@raysonmeng/agentbridge 0.1.11 → 0.1.13

package/dist/cli.js

@@ -17,10 +17,67 @@ var __export = (target, all) => {
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
+// src/cli-invocation.ts
+import { basename } from "path";
+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);
+}
+var CLI_NAMES, DEFAULT_CLI_NAME = "abg";
+var init_cli_invocation = __esm(() => {
+  CLI_NAMES = ["abg", "agentbridge"];
+});
+
+// src/atomic-json.ts
+import * as fs from "fs";
+import { randomUUID } from "crypto";
+import { dirname } from "path";
+function tmpPathFor(targetPath) {
+  return `${targetPath}.tmp.${process.pid}.${randomUUID()}`;
+}
+function atomicWriteText(path, content, options = {}) {
+  fs.mkdirSync(dirname(path), { recursive: true });
+  const tmp = tmpPathFor(path);
+  let renamed = false;
+  const fd = fs.openSync(tmp, "w", options.mode ?? 438);
+  try {
+    try {
+      fs.writeFileSync(fd, content, "utf-8");
+      if (options.fsync)
+        fs.fsyncSync(fd);
+    } finally {
+      fs.closeSync(fd);
+    }
+    fs.renameSync(tmp, path);
+    renamed = true;
+  } finally {
+    if (!renamed) {
+      try {
+        fs.unlinkSync(tmp);
+      } catch {}
+    }
+  }
+}
+function atomicWriteJson(path, value, options = {}) {
+  atomicWriteText(path, JSON.stringify(value, null, 2) + `
+`, options);
+}
+var init_atomic_json = () => {};
+
 // src/state-dir.ts
-import { mkdirSync, existsSync } from "fs";
+import { mkdirSync as mkdirSync2, existsSync } from "fs";
 import { join } from "path";
 import { homedir, platform } from "os";
+function resolveXdgStateBase(rawXdg = process.env.XDG_STATE_HOME) {
+  const xdgState = rawXdg && rawXdg.length > 0 ? rawXdg : join(homedir(), ".local", "state");
+  return join(xdgState, "agentbridge");
+}
 
 class StateDirResolver {
   stateDir;
@@ -28,8 +85,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;
@@ -37,7 +93,7 @@ class StateDirResolver {
   }
   ensure() {
     if (!existsSync(this.stateDir)) {
-      mkdirSync(this.stateDir, { recursive: true });
+      mkdirSync2(this.stateDir, { recursive: true });
     }
   }
   get dir() {
@@ -55,8 +111,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");
@@ -120,7 +176,7 @@ function parsePositiveIntEnv(name, fallback, log = () => {}, env = process.env)
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "@raysonmeng/agentbridge",
-    version: "0.1.11",
+    version: "0.1.13",
     description: "Bridge between Claude Code and Codex \u2014 bidirectional agent communication via MCP Channel + JSON-RPC",
     type: "module",
     packageManager: "bun@1.3.11",
@@ -151,6 +207,8 @@ var require_package = __commonJS((exports, module) => {
       prepublishOnly: "bun run build:cli && bun run build:plugin && bun run verify:plugin-sync && bun scripts/check-plugin-versions.js",
       "validate:plugin": "claude plugin validate plugins/agentbridge && claude plugin validate .claude-plugin/marketplace.json",
       test: "bun test src",
+      "test:unit": "bun test src/unit-test",
+      "test:integration": "bun test src/integration-test",
       "e2e:transport": "bun scripts/e2e-codex-transport.mjs",
       "install:global": "node scripts/install-global.mjs local",
       "install:global:local": "node scripts/install-global.mjs local",
@@ -199,7 +257,7 @@ __export(exports_update_notifier, {
   buildUpdateNotice: () => buildUpdateNotice,
   PACKAGE_NAME: () => PACKAGE_NAME
 });
-import { readFileSync, writeFileSync } from "fs";
+import { readFileSync } from "fs";
 function getCurrentVersion() {
   try {
     return require_package().version;
@@ -235,9 +293,7 @@ function readCache(stateDir) {
 }
 function writeCache(stateDir, cache) {
   try {
-    stateDir.ensure();
-    writeFileSync(stateDir.updateCheckFile, JSON.stringify(cache, null, 2) + `
-`, "utf-8");
+    atomicWriteJson(stateDir.updateCheckFile, cache);
   } catch {}
 }
 function parseLatestFromRegistry(body) {
@@ -311,6 +367,7 @@ function maybeNotifyUpdate(deps = {}) {
 }
 var PACKAGE_NAME = "@raysonmeng/agentbridge", REGISTRY_URL, ABBREVIATED_ACCEPT = "application/vnd.npm.install-v1+json", DEFAULT_CHECK_INTERVAL_MS, FETCH_TIMEOUT_MS = 2500, CHECK_INTERVAL_ENV = "AGENTBRIDGE_UPDATE_CHECK_INTERVAL_MS";
 var init_update_notifier = __esm(() => {
+  init_atomic_json();
   init_state_dir();
   init_version_utils();
   REGISTRY_URL = `https://registry.npmjs.org/${encodeURIComponent(PACKAGE_NAME)}`;
@@ -318,11 +375,53 @@ var init_update_notifier = __esm(() => {
 });
 
 // src/config-service.ts
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync2 } from "fs";
+import { readFileSync as readFileSync2, mkdirSync as mkdirSync3, existsSync as existsSync2 } from "fs";
 import { join as join2 } from "path";
 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(config) {
+  const d = DEFAULT_CONFIG;
+  const b = config.budget;
+  const db = d.budget;
+  return config.idleShutdownSeconds !== d.idleShutdownSeconds || config.turnCoordination.attentionWindowSeconds !== d.turnCoordination.attentionWindowSeconds || config.codex.appPort !== d.codex.appPort || config.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;
@@ -358,35 +457,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
   };
 }
@@ -400,13 +499,13 @@ function normalizeConfig(raw) {
   return {
     version: typeof config.version === "string" ? config.version : DEFAULT_CONFIG.version,
     codex: {
-      appPort: normalizeInteger(codex.appPort ?? daemon.port, DEFAULT_CONFIG.codex.appPort),
-      proxyPort: normalizeInteger(codex.proxyPort ?? daemon.proxyPort, DEFAULT_CONFIG.codex.proxyPort)
+      appPort: normalizeBoundedInteger(codex.appPort ?? daemon.port, DEFAULT_CONFIG.codex.appPort, 1, 65535),
+      proxyPort: normalizeBoundedInteger(codex.proxyPort ?? daemon.proxyPort, DEFAULT_CONFIG.codex.proxyPort, 1, 65535)
     },
     turnCoordination: {
-      attentionWindowSeconds: normalizeInteger(turnCoordination.attentionWindowSeconds, DEFAULT_CONFIG.turnCoordination.attentionWindowSeconds)
+      attentionWindowSeconds: normalizeBoundedInteger(turnCoordination.attentionWindowSeconds, DEFAULT_CONFIG.turnCoordination.attentionWindowSeconds, 0, Number.MAX_SAFE_INTEGER)
     },
-    idleShutdownSeconds: normalizeInteger(config.idleShutdownSeconds, DEFAULT_CONFIG.idleShutdownSeconds),
+    idleShutdownSeconds: normalizeBoundedInteger(config.idleShutdownSeconds, DEFAULT_CONFIG.idleShutdownSeconds, 1, Number.MAX_SAFE_INTEGER),
     budget: normalizeBudgetConfig(config.budget)
   };
 }
@@ -423,20 +522,62 @@ class ConfigService {
     return existsSync2(this.configPath);
   }
   load() {
+    let raw;
     try {
-      const raw = readFileSync2(this.configPath, "utf-8");
-      return normalizeConfig(JSON.parse(raw));
-    } catch {
-      return null;
+      raw = readFileSync2(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 config = normalizeConfig(parsed);
+    if (!config) {
+      return { state: "corrupt", reason: "config.json could not be normalized" };
     }
+    return { state: "parsed", config };
   }
-  loadOrDefault() {
-    return this.load() ?? structuredClone(DEFAULT_CONFIG);
+  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);
+  }
+  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(config) {
-    this.ensureConfigDir();
-    writeFileSync2(this.configPath, JSON.stringify(config, null, 2) + `
-`, "utf-8");
+    atomicWriteJson(this.configPath, config);
   }
   initDefaults() {
     this.ensureConfigDir();
@@ -452,15 +593,16 @@ class ConfigService {
   }
   ensureConfigDir() {
     if (!existsSync2(this.configDir)) {
-      mkdirSync2(this.configDir, { recursive: true });
+      mkdirSync3(this.configDir, { recursive: true });
     }
   }
 }
-var DEFAULT_BUDGET_CONFIG, DEFAULT_CONFIG, CONFIG_DIR = ".agentbridge", CONFIG_FILE = "config.json";
+var DEFAULT_BUDGET_CONFIG, DEFAULT_CONFIG, CONFIG_DIR = ".agentbridge", CONFIG_FILE = "config.json", NOOP_LOGGER = () => {};
 var init_config_service = __esm(() => {
+  init_atomic_json();
   DEFAULT_BUDGET_CONFIG = {
     enabled: true,
-    pollSeconds: 60,
+    pollSeconds: 300,
     pauseAt: 90,
     resumeBelow: 30,
     syncDriftPct: 10,
@@ -490,7 +632,7 @@ var init_config_service = __esm(() => {
 });
 
 // src/cli/pkg-root.ts
-import { dirname, join as join3 } from "path";
+import { dirname as dirname2, join as join3 } from "path";
 import { existsSync as existsSync3 } from "fs";
 import { execFileSync } from "child_process";
 function findPackageRoot() {
@@ -499,7 +641,7 @@ function findPackageRoot() {
     if (existsSync3(join3(dir, "package.json"))) {
       return dir;
     }
-    const parent = dirname(dir);
+    const parent = dirname2(dir);
     if (parent === dir) {
       throw new Error("Could not find package.json in any parent directory");
     }
@@ -513,6 +655,30 @@ function registerMarketplace(marketplaceRoot) {
 }
 var init_pkg_root = () => {};
 
+// src/cli/plugin-cache.ts
+import { existsSync as existsSync4 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join4, resolve } from "path";
+function pluginCacheRoot(home = homedir2()) {
+  return join4(home, ".claude", "plugins", "cache", MARKETPLACE_NAME, PLUGIN_NAME);
+}
+function isInsideRepoCheckout(projectRoot) {
+  const buildScript = resolve(projectRoot, "scripts", "build-bundles.mjs");
+  return existsSync4(buildScript);
+}
+function shouldWarnMissingPluginCache(cacheExists) {
+  return !cacheExists;
+}
+var MARKETPLACE_STEPS;
+var init_plugin_cache = __esm(() => {
+  init_cli();
+  MARKETPLACE_STEPS = [
+    `/plugin marketplace add raysonmeng/agent-bridge`,
+    `/plugin install ${PLUGIN_NAME}@${MARKETPLACE_NAME}`,
+    `/reload-plugins`
+  ];
+});
+
 // src/marker-section.ts
 function upsertMarkedSection(content, sectionId, section) {
   const startMarker = MARKER_START(sectionId);
@@ -649,18 +815,25 @@ var exports_init = {};
 __export(exports_init, {
   writeCollaborationSections: () => writeCollaborationSections,
   runInit: () => runInit,
+  pluginInstallFallbackGuidance: () => pluginInstallFallbackGuidance,
+  formatDepChecks: () => formatDepChecks,
   compareVersions: () => compareVersions
 });
 import { execSync, execFileSync as execFileSync2 } from "child_process";
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
-import { join as join4 } from "path";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { join as join5 } from "path";
 async function runInit() {
   console.log(`AgentBridge Init
 `);
+  const cli = cliInvocationName();
   console.log("Checking dependencies...");
-  checkBun();
-  checkClaude();
-  checkCodex();
+  const depChecks = [checkBun(), checkClaude(), checkCodex()];
+  for (const line of formatDepChecks(depChecks, cli)) {
+    console.log(line);
+  }
+  if (depChecks.some((check) => check.status === "fail")) {
+    process.exit(1);
+  }
   console.log("");
   console.log("Generating project config...");
   const configService = new ConfigService;
@@ -681,72 +854,123 @@ async function runInit() {
   }
   console.log("");
   console.log("Installing AgentBridge plugin...");
+  let pluginInstalled = false;
   try {
-    registerMarketplace(findPackageRoot());
+    const packageRoot = findPackageRoot();
+    registerMarketplace(packageRoot);
     execFileSync2("claude", ["plugin", "install", `${PLUGIN_NAME}@${MARKETPLACE_NAME}`], {
       stdio: "inherit"
     });
     console.log("  Plugin installed successfully.");
+    pluginInstalled = true;
   } catch {
     console.log("  Plugin install skipped (marketplace registration or install failed).");
-    console.log("  You can install it later with:");
-    console.log(`    abg dev   # registers marketplace and installs plugin`);
+    for (const line of pluginInstallFallbackGuidance(detectRepoCheckout(), cli)) {
+      console.log(line);
+    }
   }
   console.log("");
-  console.log(`Setup complete!
+  if (pluginInstalled) {
+    console.log(`Setup complete!
+`);
+  } else {
+    console.log(`Setup incomplete \u2014 plugin not installed.
 `);
+    process.exitCode = 1;
+  }
   console.log("Next steps:");
   console.log("  1. If Claude Code is already running, execute /reload-plugins in your session");
-  console.log("  2. Start Claude Code:  agentbridge claude");
-  console.log("  3. Start Codex TUI:    agentbridge codex");
+  console.log(`  2. Start Claude Code:  ${cli} claude`);
+  console.log(`  3. Start Codex TUI:    ${cli} codex`);
+}
+function detectRepoCheckout() {
+  try {
+    return isInsideRepoCheckout(findPackageRoot());
+  } catch {
+    return false;
+  }
+}
+function pluginInstallFallbackGuidance(insideRepo, cli = cliInvocationName()) {
+  if (insideRepo) {
+    return [
+      "  You can install it later with:",
+      `    ${cli} dev   # registers marketplace and installs plugin`
+    ];
+  }
+  return [
+    "  Install the plugin from Claude Code with these steps:",
+    ...MARKETPLACE_STEPS.map((step) => `    ${step}`)
+  ];
+}
+function formatDepChecks(checks, cli) {
+  const lines = [];
+  for (const check of checks) {
+    lines.push(`  ${check.status.toUpperCase().padEnd(4)} ${check.name}: ${check.detail}`);
+    if ((check.status === "warn" || check.status === "fail") && check.hint) {
+      lines.push(`       \u21B3 ${check.hint}`);
+    }
+  }
+  lines.push(`  \u9A8C\u8BC1\u5B89\u88C5: ${cli} doctor`);
+  return lines;
 }
 function checkBun() {
   try {
     const version = execSync("bun --version", { encoding: "utf-8" }).trim();
-    console.log(`  bun: ${version}`);
+    return { name: "bun", status: "ok", detail: version };
   } catch {
-    console.error("  ERROR: bun not found in PATH.");
-    console.error("  Install Bun: https://bun.sh");
-    process.exit(1);
+    return {
+      name: "bun",
+      status: "fail",
+      detail: "not found in PATH",
+      hint: "Install Bun: https://bun.sh"
+    };
   }
 }
 function checkClaude() {
+  let versionOutput;
   try {
-    const versionOutput = execSync("claude --version", { encoding: "utf-8" }).trim();
-    const match = versionOutput.match(/(\d+\.\d+\.\d+)/);
-    if (match) {
-      const version = match[1];
-      console.log(`  claude: ${version}`);
-      if (compareVersions(version, MIN_CLAUDE_VERSION) < 0) {
-        console.error(`  ERROR: Claude Code version ${version} is too old.`);
-        console.error(`  Channels require >= ${MIN_CLAUDE_VERSION}.`);
-        console.error("  Update: npm update -g @anthropic-ai/claude-code");
-        process.exit(1);
-      }
-    } else {
-      console.log(`  claude: ${versionOutput} (version check skipped)`);
-    }
+    versionOutput = execSync("claude --version", { encoding: "utf-8" }).trim();
   } catch {
-    console.error("  ERROR: claude not found in PATH.");
-    console.error("  Install Claude Code: npm install -g @anthropic-ai/claude-code");
-    process.exit(1);
+    return {
+      name: "claude",
+      status: "fail",
+      detail: "not found in PATH",
+      hint: "Install Claude Code: npm install -g @anthropic-ai/claude-code"
+    };
+  }
+  const match = versionOutput.match(/(\d+\.\d+\.\d+)/);
+  if (!match) {
+    return { name: "claude", status: "ok", detail: `${versionOutput} (version check skipped)` };
+  }
+  const version = match[1];
+  if (compareVersions(version, MIN_CLAUDE_VERSION) < 0) {
+    return {
+      name: "claude",
+      status: "fail",
+      detail: `${version} is too old (channels require >= ${MIN_CLAUDE_VERSION})`,
+      hint: "Update: npm update -g @anthropic-ai/claude-code"
+    };
   }
+  return { name: "claude", status: "ok", detail: version };
 }
 function checkCodex() {
   try {
     const version = execSync("codex --version", { encoding: "utf-8" }).trim();
-    console.log(`  codex: ${version}`);
+    return { name: "codex", status: "ok", detail: version };
   } catch {
-    console.error("  ERROR: codex not found in PATH.");
-    console.error("  Install Codex: https://github.com/openai/codex");
-    process.exit(1);
+    return {
+      name: "codex",
+      status: "warn",
+      detail: "not found in PATH (the Codex side will be unavailable until installed)",
+      hint: "Install Codex when you want to pair: https://github.com/openai/codex"
+    };
   }
 }
 function writeCollaborationSections(projectRoot) {
   const results = [];
   const files = [
-    { name: "CLAUDE.md", path: join4(projectRoot, "CLAUDE.md"), section: CLAUDE_MD_SECTION },
-    { name: "AGENTS.md", path: join4(projectRoot, "AGENTS.md"), section: AGENTS_MD_SECTION }
+    { name: "CLAUDE.md", path: join5(projectRoot, "CLAUDE.md"), section: CLAUDE_MD_SECTION },
+    { name: "AGENTS.md", path: join5(projectRoot, "AGENTS.md"), section: AGENTS_MD_SECTION }
   ];
   for (const { name, path, section } of files) {
     let existing = "";
@@ -765,7 +989,7 @@ function writeCollaborationSections(projectRoot) {
       results.push(`${name}: unchanged (section already up to date)`);
       continue;
     }
-    writeFileSync3(path, updated, "utf-8");
+    writeFileSync2(path, updated, "utf-8");
     if (existing === "") {
       results.push(`${name}: created with collaboration section`);
     } else if (existing.includes(`<!-- ${MARKER_ID}:start -->`)) {
@@ -778,9 +1002,11 @@ function writeCollaborationSections(projectRoot) {
 }
 var MIN_CLAUDE_VERSION = "2.1.80";
 var init_init = __esm(() => {
+  init_cli_invocation();
   init_config_service();
   init_cli();
   init_pkg_root();
+  init_plugin_cache();
   init_version_utils();
 });
 
@@ -790,19 +1016,17 @@ __export(exports_dev, {
   runDev: () => runDev
 });
 import { execFileSync as execFileSync3, spawnSync } from "child_process";
-import { resolve } from "path";
-import { existsSync as existsSync4, cpSync, rmSync } from "fs";
-import { homedir as homedir2 } from "os";
+import { resolve as resolve2 } from "path";
+import { existsSync as existsSync5, cpSync, rmSync } from "fs";
 async function runDev(args = []) {
   console.log(`AgentBridge Dev Setup
 `);
   const skipBuild = args.includes("--skip-build");
   const projectRoot = findPackageRoot();
-  const marketplacePath = resolve(projectRoot, ".claude-plugin", "marketplace.json");
-  const pluginDir = resolve(projectRoot, "plugins", "agentbridge");
-  const pluginManifest = resolve(pluginDir, ".claude-plugin", "plugin.json");
-  const buildScript = resolve(projectRoot, "scripts", "build-bundles.mjs");
-  if (!existsSync4(buildScript)) {
+  const marketplacePath = resolve2(projectRoot, ".claude-plugin", "marketplace.json");
+  const pluginDir = resolve2(projectRoot, "plugins", "agentbridge");
+  const pluginManifest = resolve2(pluginDir, ".claude-plugin", "plugin.json");
+  if (!isInsideRepoCheckout(projectRoot)) {
     console.error("  ERROR: 'agentbridge dev' must run inside an AgentBridge repository checkout \u2014");
     console.error("  the published package does not ship the build scripts.");
     console.error("");
@@ -839,12 +1063,12 @@ async function runDev(args = []) {
     console.log(`  \u2713 Plugin built successfully
 `);
   }
-  if (!existsSync4(pluginManifest)) {
+  if (!existsSync5(pluginManifest)) {
     console.error(`  ERROR: Plugin manifest not found at ${pluginManifest}`);
     console.error("  Run 'bun run build:plugin' first, or check your working tree.");
     process.exit(1);
   }
-  if (!existsSync4(marketplacePath)) {
+  if (!existsSync5(marketplacePath)) {
     console.error(`  ERROR: Marketplace manifest not found at ${marketplacePath}`);
     process.exit(1);
   }
@@ -873,12 +1097,12 @@ Installing plugin...`);
   }
   console.log(`
 Syncing local plugin to cache...`);
-  const cacheDir = resolve(homedir2(), ".claude", "plugins", "cache", MARKETPLACE_NAME, PLUGIN_NAME);
-  if (existsSync4(cacheDir)) {
+  const cacheDir = pluginCacheRoot();
+  if (existsSync5(cacheDir)) {
     const versionDirs = Bun.spawnSync(["ls", cacheDir]).stdout.toString().trim().split(`
 `).filter(Boolean);
     for (const ver of versionDirs) {
-      const targetDir = resolve(cacheDir, ver);
+      const targetDir = resolve2(cacheDir, ver);
       rmSync(targetDir, { recursive: true, force: true });
       cpSync(pluginDir, targetDir, { recursive: true });
       console.log(`  Synced to ${targetDir}`);
@@ -898,22 +1122,101 @@ Syncing local plugin to cache...`);
 var init_dev = __esm(() => {
   init_cli();
   init_pkg_root();
+  init_plugin_cache();
 });
 
 // src/control-protocol.ts
-var CLOSE_CODE_REPLACED = 4001, CLOSE_CODE_EVICTED_STALE = 4002, CLOSE_CODE_PROBE_IN_PROGRESS = 4003, CLOSE_CODE_PAIR_MISMATCH = 4004;
+var CLOSE_CODE_REPLACED = 4001, CLOSE_CODE_EVICTED_STALE = 4002, CLOSE_CODE_PROBE_IN_PROGRESS = 4003, CLOSE_CODE_PAIR_MISMATCH = 4004, CLOSE_CODE_TOKEN_MISMATCH = 4005, CLOSE_CODE_CONTRACT_MISMATCH = 4006;
+
+// src/interrupt-timing.ts
+var CLIENT_REPLY_TIMEOUT_MS = 15000, INTERRUPT_CLIENT_MARGIN_MS = 2000, MAX_INTERRUPT_TIMEOUT_MS;
+var init_interrupt_timing = __esm(() => {
+  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((resolve3, reject) => {
+      const timer = this.setTimer(() => {
+        if (!this.entries.has(id))
+          return;
+        this.entries.delete(id);
+        options.onTimeout({ resolve: resolve3, reject });
+      }, options.timeoutMs);
+      if (options.unref) {
+        timer.unref?.();
+      }
+      this.entries.set(id, { resolve: resolve3, reject, timer });
+    });
+  }
+  settle(id, value) {
+    const entry = this.entries.get(id);
+    if (!entry)
+      return false;
+    this.clearTimer(entry.timer);
+    this.entries.delete(id);
+    entry.resolve(value);
+    return true;
+  }
+  reject(id, error) {
+    const entry = this.entries.get(id);
+    if (!entry)
+      return false;
+    this.clearTimer(entry.timer);
+    this.entries.delete(id);
+    entry.reject(error);
+    return true;
+  }
+  settleAll(value) {
+    const make = typeof value === "function" ? value : () => value;
+    for (const [id, entry] of this.entries) {
+      this.clearTimer(entry.timer);
+      this.entries.delete(id);
+      entry.resolve(make(id));
+    }
+  }
+  rejectAll(error) {
+    const make = typeof error === "function" ? error : () => error;
+    for (const [id, entry] of this.entries) {
+      this.clearTimer(entry.timer);
+      this.entries.delete(id);
+      entry.reject(make(id));
+    }
+  }
+}
 
 // src/daemon-client.ts
 import { EventEmitter } from "events";
 var nextSocketId = 0, DaemonClient;
 var init_daemon_client = __esm(() => {
+  init_interrupt_timing();
   DaemonClient = class DaemonClient extends EventEmitter {
     url;
     options;
     ws = null;
     wsId = 0;
     nextRequestId = 1;
-    pendingReplies = new Map;
+    pendingReplies = new PendingRequestRegistry;
+    pendingEventWaiters = new PendingRequestRegistry;
     constructor(url, options = {}) {
       super();
       this.url = url;
@@ -933,7 +1236,7 @@ var init_daemon_client = __esm(() => {
         this.ws = null;
       }
       const socketId = ++nextSocketId;
-      await new Promise((resolve2, reject) => {
+      await new Promise((resolve3, reject) => {
         const ws = new WebSocket(this.url);
         let settled = false;
         ws.onopen = () => {
@@ -942,7 +1245,7 @@ var init_daemon_client = __esm(() => {
           this.wsId = socketId;
           this.attachSocketHandlers(ws, socketId);
           this.log(`ws#${socketId} opened and attached`);
-          resolve2();
+          resolve3();
         };
         ws.onerror = () => {
           if (settled)
@@ -959,82 +1262,73 @@ var init_daemon_client = __esm(() => {
       });
     }
     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((resolve2) => {
-        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();
-          resolve2(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((resolve2) => {
-        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);
-          resolve2(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: resolve3 }) => resolve3(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;
@@ -1047,25 +1341,24 @@ var init_daemon_client = __esm(() => {
       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((resolve2) => {
-        const timer = setTimeout(() => {
-          this.pendingReplies.delete(requestId);
-          resolve2({ success: false, error: "Timed out waiting for AgentBridge daemon reply." });
-        }, 15000);
-        this.pendingReplies.set(requestId, { resolve: resolve2, 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: resolve3 }) => resolve3({ 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) => {
@@ -1081,14 +1374,23 @@ var init_daemon_client = __esm(() => {
             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;
@@ -1103,7 +1405,7 @@ var init_daemon_client = __esm(() => {
         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");
@@ -1113,11 +1415,7 @@ var init_daemon_client = __esm(() => {
       ws.onerror = () => {};
     }
     rejectPendingReplies(error) {
-      for (const [requestId, pending] of this.pendingReplies.entries()) {
-        clearTimeout(pending.timer);
-        pending.resolve({ success: false, error });
-        this.pendingReplies.delete(requestId);
-      }
+      this.pendingReplies.settleAll(() => ({ success: false, error }));
     }
     send(message) {
       if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
@@ -1136,6 +1434,10 @@ var init_daemon_client = __esm(() => {
 var CONTRACT_VERSION = 1;
 
 // src/build-info.ts
+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;
 }
@@ -1150,7 +1452,14 @@ function defineNumber(value, fallback) {
 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)
@@ -1160,21 +1469,23 @@ 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}`;
 }
-var BUILD_INFO;
+var CODE_HASH_SENTINEL = "source", BUILD_INFO;
 var init_build_info = __esm(() => {
   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("dist"),
-    contractVersion: defineNumber(1, CONTRACT_VERSION)
+    contractVersion: defineNumber(1, CONTRACT_VERSION),
+    codeHash: defineString("e1fd67d07c62", "source")
   });
 });
 
 // src/process-lifecycle.ts
 import { execFileSync as execFileSync4 } from "child_process";
-import { basename } from "path";
+import { basename as basename2 } from "path";
 function parsePsProcessList(output) {
   const entries = [];
   for (const line of output.split(/\r?\n/)) {
@@ -1190,11 +1501,11 @@ function parsePsProcessList(output) {
 }
 function invokesCodexBinary(command) {
   const tokens = command.trim().split(/\s+/);
-  const exe = tokens[0] ? basename(tokens[0]) : "";
+  const exe = tokens[0] ? basename2(tokens[0]) : "";
   if (exe === "codex")
     return true;
   if ((exe === "node" || exe === "bun") && tokens[1]) {
-    return basename(tokens[1]) === "codex";
+    return basename2(tokens[1]) === "codex";
   }
   return false;
 }
@@ -1330,19 +1641,205 @@ var init_process_lifecycle = __esm(() => {
   isProcessAlive = pidLooksAlive;
 });
 
+// src/daemon-record.ts
+import { readFileSync as readFileSync4 } from "fs";
+function writeDaemonRecord(path, record) {
+  atomicWriteJson(path, record);
+}
+function sanitizePorts(value) {
+  if (typeof value !== "object" || value === null)
+    return;
+  const raw = value;
+  const ports = {};
+  if (typeof raw.appPort === "number")
+    ports.appPort = raw.appPort;
+  if (typeof raw.proxyPort === "number")
+    ports.proxyPort = raw.proxyPort;
+  if (typeof raw.controlPort === "number")
+    ports.controlPort = raw.controlPort;
+  return Object.keys(ports).length > 0 ? ports : undefined;
+}
+function readDaemonRecord(path, read = defaultRead) {
+  let parsed;
+  try {
+    parsed = JSON.parse(read(path));
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null)
+    return null;
+  const obj = parsed;
+  if (typeof obj.pid !== "number" || !Number.isFinite(obj.pid))
+    return null;
+  const phase = obj.phase === "ready" ? "ready" : "booting";
+  const record = { pid: obj.pid, phase };
+  if (typeof obj.startedAt === "number")
+    record.startedAt = obj.startedAt;
+  if (typeof obj.nonce === "string")
+    record.nonce = obj.nonce;
+  if (obj.pairId === null || typeof obj.pairId === "string")
+    record.pairId = obj.pairId;
+  if (obj.cwd === null || typeof obj.cwd === "string")
+    record.cwd = obj.cwd;
+  if (obj.stateDir === null || typeof obj.stateDir === "string")
+    record.stateDir = obj.stateDir;
+  if (typeof obj.proxyUrl === "string")
+    record.proxyUrl = obj.proxyUrl;
+  if (typeof obj.appServerUrl === "string")
+    record.appServerUrl = obj.appServerUrl;
+  const ports = sanitizePorts(obj.ports);
+  if (ports !== undefined)
+    record.ports = ports;
+  if (typeof obj.build === "object" && obj.build !== null) {
+    record.build = obj.build;
+  }
+  if (typeof obj.turnPhase === "string")
+    record.turnPhase = obj.turnPhase;
+  if (typeof obj.turnInProgress === "boolean")
+    record.turnInProgress = obj.turnInProgress;
+  if (typeof obj.attentionWindowActive === "boolean") {
+    record.attentionWindowActive = obj.attentionWindowActive;
+  }
+  return record;
+}
+function synthesizeLegacyRecord(pidFilePath, statusFilePath, read = defaultRead) {
+  let pidFromPidFile = null;
+  try {
+    const raw = read(pidFilePath).trim();
+    const n = Number.parseInt(raw, 10);
+    if (Number.isFinite(n))
+      pidFromPidFile = n;
+  } catch {}
+  let status = null;
+  try {
+    const parsed = JSON.parse(read(statusFilePath));
+    if (typeof parsed === "object" && parsed !== null)
+      status = parsed;
+  } catch {}
+  const pidFromStatus = status && typeof status.pid === "number" && Number.isFinite(status.pid) ? status.pid : null;
+  const pid = pidFromPidFile ?? pidFromStatus;
+  if (pid === null)
+    return null;
+  const record = {
+    pid,
+    phase: status ? "ready" : "booting"
+  };
+  if (status) {
+    if (typeof status.proxyUrl === "string")
+      record.proxyUrl = status.proxyUrl;
+    if (typeof status.appServerUrl === "string")
+      record.appServerUrl = status.appServerUrl;
+    const controlPort = typeof status.controlPort === "number" ? status.controlPort : undefined;
+    const proxyPort = portFromUrl(status.proxyUrl);
+    const appPort = portFromUrl(status.appServerUrl);
+    if (controlPort !== undefined || proxyPort !== undefined || appPort !== undefined) {
+      record.ports = {};
+      if (appPort !== undefined)
+        record.ports.appPort = appPort;
+      if (proxyPort !== undefined)
+        record.ports.proxyPort = proxyPort;
+      if (controlPort !== undefined)
+        record.ports.controlPort = controlPort;
+    }
+    if (status.pairId === null || typeof status.pairId === "string")
+      record.pairId = status.pairId;
+    if (status.cwd === null || typeof status.cwd === "string")
+      record.cwd = status.cwd;
+    if (status.stateDir === null || typeof status.stateDir === "string")
+      record.stateDir = status.stateDir;
+    if (typeof status.build === "object" && status.build !== null) {
+      record.build = status.build;
+    }
+    if (typeof status.turnPhase === "string")
+      record.turnPhase = status.turnPhase;
+    if (typeof status.turnInProgress === "boolean")
+      record.turnInProgress = status.turnInProgress;
+    if (typeof status.attentionWindowActive === "boolean") {
+      record.attentionWindowActive = status.attentionWindowActive;
+    }
+  }
+  return record;
+}
+function readUnifiedDaemonRecord(paths, read = defaultRead) {
+  return readDaemonRecord(paths.daemonRecordFile, read) ?? synthesizeLegacyRecord(paths.pidFile, paths.statusFile, read);
+}
+function portFromUrl(url) {
+  if (typeof url !== "string")
+    return;
+  const match = url.match(/:(\d+)(?:[/?]|$)/);
+  return match ? Number.parseInt(match[1], 10) : undefined;
+}
+var defaultRead = (path) => readFileSync4(path, "utf-8");
+var init_daemon_record = __esm(() => {
+  init_atomic_json();
+});
+
 // src/daemon-lifecycle.ts
 import { spawn } from "child_process";
-import { existsSync as existsSync5, readFileSync as readFileSync4, statSync, unlinkSync, writeFileSync as writeFileSync4, openSync, closeSync, constants } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync5, statSync, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3, openSync as openSync2, closeSync as closeSync2, constants } from "fs";
 import { fileURLToPath } from "url";
+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`;
@@ -1366,55 +1863,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`);
@@ -1427,7 +1909,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`);
@@ -1441,18 +1923,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`);
@@ -1461,7 +1946,7 @@ class DaemonLifecycle {
         }
       }
       this.launch();
-      await this.waitForReady();
+      await this.waitForReady(this.timing.waitReadyRetries, this.timing.waitReadyDelayMs);
     });
   }
   async isHealthy() {
@@ -1476,7 +1961,7 @@ class DaemonLifecycle {
     for (let attempt = 0;attempt < maxRetries; attempt++) {
       if (await this.isHealthy())
         return;
-      await new Promise((resolve2) => setTimeout(resolve2, delayMs));
+      await new Promise((resolve3) => setTimeout(resolve3, delayMs));
     }
     throw new Error(`Timed out waiting for AgentBridge daemon health on ${this.healthUrl}`);
   }
@@ -1488,42 +1973,59 @@ 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;
-      await new Promise((resolve2) => setTimeout(resolve2, delayMs));
+      await new Promise((resolve3) => setTimeout(resolve3, delayMs));
     }
     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;
         }
       }
-      await new Promise((resolve2) => setTimeout(resolve2, delayMs));
+      await new Promise((resolve3) => setTimeout(resolve3, delayMs));
     }
     throw new Error(`Timed out waiting for AgentBridge daemon readiness+identity on ${this.readyUrl} (control port ${this.controlPort})`);
   }
+  readDaemonRecord() {
+    return readUnifiedDaemonRecord({
+      daemonRecordFile: this.stateDir.daemonRecordFile,
+      pidFile: this.stateDir.pidFile,
+      statusFile: this.stateDir.statusFile
+    });
+  }
+  writeDaemonRecord(record) {
+    writeDaemonRecord(this.stateDir.daemonRecordFile, record);
+  }
+  removeDaemonRecord() {
+    try {
+      unlinkSync2(this.stateDir.daemonRecordFile);
+    } catch {}
+  }
   readStatus() {
     try {
-      const raw = readFileSync4(this.stateDir.statusFile, "utf-8");
+      const raw = readFileSync5(this.stateDir.statusFile, "utf-8");
       return JSON.parse(raw);
     } catch {
       return null;
     }
   }
   writeStatus(status) {
-    this.stateDir.ensure();
-    writeFileSync4(this.stateDir.statusFile, JSON.stringify(status, null, 2) + `
-`, "utf-8");
+    atomicWriteJson(this.stateDir.statusFile, status);
   }
   readPid() {
     try {
-      const raw = readFileSync4(this.stateDir.pidFile, "utf-8").trim();
+      const raw = readFileSync5(this.stateDir.pidFile, "utf-8").trim();
       if (!raw)
         return null;
       const pid = Number.parseInt(raw, 10);
@@ -1533,32 +2035,31 @@ class DaemonLifecycle {
     }
   }
   writePid(pid) {
-    this.stateDir.ensure();
-    writeFileSync4(this.stateDir.pidFile, `${pid ?? process.pid}
-`, "utf-8");
+    atomicWriteText(this.stateDir.pidFile, `${pid ?? process.pid}
+`);
   }
   removePidFile() {
     try {
-      unlinkSync(this.stateDir.pidFile);
+      unlinkSync2(this.stateDir.pidFile);
     } catch {}
   }
   removeStatusFile() {
     try {
-      unlinkSync(this.stateDir.statusFile);
+      unlinkSync2(this.stateDir.statusFile);
     } catch {}
   }
   markKilled() {
     this.stateDir.ensure();
-    writeFileSync4(this.stateDir.killedFile, `${Date.now()}
+    writeFileSync3(this.stateDir.killedFile, `${Date.now()}
 `, "utf-8");
   }
   clearKilled() {
     try {
-      unlinkSync(this.stateDir.killedFile);
+      unlinkSync2(this.stateDir.killedFile);
     } catch {}
   }
   wasKilled() {
-    return existsSync5(this.stateDir.killedFile);
+    return existsSync6(this.stateDir.killedFile);
   }
   launch() {
     this.stateDir.ensure();
@@ -1576,21 +2077,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 {}
         }
@@ -1598,9 +2104,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 {
@@ -1614,15 +2124,15 @@ class DaemonLifecycle {
     this.stateDir.ensure();
     let fd = null;
     try {
-      fd = openSync(this.stateDir.lockFile, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY);
-      writeFileSync4(fd, `${process.pid}
+      fd = openSync2(this.stateDir.lockFile, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY);
+      writeFileSync3(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();
       }
@@ -1630,7 +2140,7 @@ class DaemonLifecycle {
         if (reclaimed)
           return false;
         try {
-          const holderPid = Number.parseInt(readFileSync4(this.stateDir.lockFile, "utf-8").trim(), 10);
+          const holderPid = Number.parseInt(readFileSync5(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();
@@ -1659,7 +2169,7 @@ class DaemonLifecycle {
   }
   releaseLock() {
     try {
-      unlinkSync(this.stateDir.lockFile);
+      unlinkSync2(this.stateDir.lockFile);
     } catch {}
   }
   async kill(gracefulTimeoutMs = 3000, pidOverride) {
@@ -1693,7 +2203,7 @@ class DaemonLifecycle {
         this.cleanup();
         return true;
       }
-      await new Promise((resolve2) => setTimeout(resolve2, 200));
+      await new Promise((resolve3) => setTimeout(resolve3, 200));
     }
     this.log(`Daemon pid ${pid} did not stop gracefully, sending SIGKILL`);
     try {
@@ -1705,6 +2215,7 @@ class DaemonLifecycle {
   cleanup() {
     this.removePidFile();
     this.removeStatusFile();
+    this.removeDaemonRecord();
   }
 }
 async function fetchWithTimeout(url, timeoutMs = HEALTH_FETCH_TIMEOUT_MS) {
@@ -1716,10 +2227,12 @@ async function fetchWithTimeout(url, timeoutMs = HEALTH_FETCH_TIMEOUT_MS) {
     clearTimeout(timer);
   }
 }
-var DEFAULT_DAEMON_ENTRY, DAEMON_ENTRY, DAEMON_PATH, REUSE_READY_RETRIES, REUSE_READY_DELAY_MS = 250, HEALTH_FETCH_TIMEOUT_MS = 500, LOCK_IDENTITY_GRACE_MS;
+var DEFAULT_DAEMON_ENTRY, DAEMON_ENTRY, DAEMON_PATH, REUSE_READY_RETRIES, REUSE_READY_DELAY_MS = 250, WAIT_READY_RETRIES = 40, WAIT_READY_DELAY_MS = 250, HEALTH_FETCH_TIMEOUT_MS = 500, LOCK_IDENTITY_GRACE_MS;
 var init_daemon_lifecycle = __esm(() => {
+  init_atomic_json();
   init_build_info();
   init_process_lifecycle();
+  init_daemon_record();
   DEFAULT_DAEMON_ENTRY = import.meta.url.endsWith(".ts") ? "./daemon.ts" : "./daemon.js";
   DAEMON_ENTRY = process.env.AGENTBRIDGE_DAEMON_ENTRY || DEFAULT_DAEMON_ENTRY;
   DAEMON_PATH = fileURLToPath(new URL(DAEMON_ENTRY, import.meta.url));
@@ -1730,26 +2243,22 @@ var init_daemon_lifecycle = __esm(() => {
 // src/pair-registry.ts
 import { execFileSync as execFileSync5 } from "child_process";
 import {
-  closeSync as closeSync2,
-  existsSync as existsSync6,
-  fsyncSync,
+  existsSync as existsSync7,
   linkSync,
   lstatSync,
-  mkdirSync as mkdirSync3,
-  openSync as openSync2,
+  mkdirSync as mkdirSync4,
   readdirSync,
-  readFileSync as readFileSync5,
+  readFileSync as readFileSync6,
   realpathSync,
-  renameSync,
   rmSync as rmSync2,
   statSync as statSync2,
-  unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync5
+  unlinkSync as unlinkSync3,
+  writeFileSync as writeFileSync4
 } from "fs";
 import { createServer } from "net";
-import { createHash, randomUUID } from "crypto";
+import { createHash, randomUUID as randomUUID2 } from "crypto";
 import { hostname, userInfo } from "os";
-import { basename as basename2, join as join5, resolve as resolve2, sep } from "path";
+import { basename as basename3, join as join6, resolve as resolve3, sep } from "path";
 function portsForSlot(slot) {
   if (!Number.isInteger(slot) || slot < 0) {
     throw new PairError("PAIR_ID_INVALID", `Invalid slot: ${slot}`);
@@ -1787,18 +2296,18 @@ function pickLowestFreeSlot(entries) {
   return slot;
 }
 function pairsDir(base) {
-  return join5(base, "pairs");
+  return join6(base, "pairs");
 }
 function registryPath(base) {
-  return join5(pairsDir(base), REGISTRY_FILE_NAME);
+  return join6(pairsDir(base), REGISTRY_FILE_NAME);
 }
 function readRegistry(base) {
   const path = registryPath(base);
-  if (!existsSync6(path))
+  if (!existsSync7(path))
     return { version: 1, pairs: [] };
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync5(path, "utf-8"));
+    parsed = JSON.parse(readFileSync6(path, "utf-8"));
   } catch (err) {
     throw new PairError("PAIR_REGISTRY_CORRUPT", `Registry JSON is not parseable at ${path}: ${err.message}`, {
       path
@@ -1829,26 +2338,14 @@ function readRegistry(base) {
   return parsed;
 }
 function writeRegistry(base, reg) {
-  mkdirSync3(pairsDir(base), { recursive: true });
-  const target = registryPath(base);
-  const tmp = `${target}.tmp.${process.pid}`;
-  const data = JSON.stringify(reg, null, 2) + `
-`;
-  const fd = openSync2(tmp, "w");
-  try {
-    writeFileSync5(fd, data);
-    fsyncSync(fd);
-  } finally {
-    closeSync2(fd);
-  }
-  renameSync(tmp, target);
+  atomicWriteJson(registryPath(base), reg, { fsync: true });
 }
 function lockFilePath(base) {
-  return join5(pairsDir(base), LOCK_FILE_NAME);
+  return join6(pairsDir(base), LOCK_FILE_NAME);
 }
 function readLockOwner(lockFile) {
   try {
-    const parsed = JSON.parse(readFileSync5(lockFile, "utf-8"));
+    const parsed = JSON.parse(readFileSync6(lockFile, "utf-8"));
     if (typeof parsed.pid === "number" && typeof parsed.nonce === "string")
       return parsed;
     return null;
@@ -1878,7 +2375,7 @@ function safeUid() {
   }
 }
 function sleep(ms) {
-  return new Promise((resolve3) => setTimeout(resolve3, ms));
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 function lockIsStale(lockFile) {
   const owner = readLockOwner(lockFile);
@@ -1888,7 +2385,7 @@ function lockIsStale(lockFile) {
 }
 function attemptReclaim(lockFile) {
   const reclaimLock = `${lockFile}.reclaim`;
-  const myNonce = randomUUID();
+  const myNonce = randomUUID2();
   const ownerJson = JSON.stringify({
     pid: process.pid,
     createdAt: Date.now(),
@@ -1896,10 +2393,10 @@ function attemptReclaim(lockFile) {
     hostname: safeHostname(),
     uid: safeUid()
   });
-  const tmp = `${reclaimLock}.acq.${process.pid}.${randomUUID()}`;
+  const tmp = `${reclaimLock}.acq.${process.pid}.${randomUUID2()}`;
   let held = false;
   try {
-    writeFileSync5(tmp, ownerJson);
+    writeFileSync4(tmp, ownerJson);
     try {
       linkSync(tmp, reclaimLock);
       held = true;
@@ -1907,7 +2404,7 @@ function attemptReclaim(lockFile) {
       if (err?.code === "EEXIST") {
         if (lockIsStale(reclaimLock)) {
           try {
-            unlinkSync2(reclaimLock);
+            unlinkSync3(reclaimLock);
           } catch {}
         }
         return;
@@ -1916,7 +2413,7 @@ function attemptReclaim(lockFile) {
     }
   } finally {
     try {
-      unlinkSync2(tmp);
+      unlinkSync3(tmp);
     } catch {}
   }
   if (!held)
@@ -1926,22 +2423,22 @@ function attemptReclaim(lockFile) {
       return;
     if (lockIsStale(lockFile)) {
       try {
-        unlinkSync2(lockFile);
+        unlinkSync3(lockFile);
       } catch {}
     }
   } finally {
     if (readLockOwner(reclaimLock)?.nonce === myNonce) {
       try {
-        unlinkSync2(reclaimLock);
+        unlinkSync3(reclaimLock);
       } catch {}
     }
   }
 }
 async function withRegistryLock(base, fn) {
-  mkdirSync3(pairsDir(base), { recursive: true });
+  mkdirSync4(pairsDir(base), { recursive: true });
   const lockFile = lockFilePath(base);
   const deadline = Date.now() + LOCK_DEADLINE_MS;
-  const myNonce = randomUUID();
+  const myNonce = randomUUID2();
   const ownerJson = JSON.stringify({
     pid: process.pid,
     createdAt: Date.now(),
@@ -1950,10 +2447,10 @@ async function withRegistryLock(base, fn) {
     uid: safeUid()
   });
   for (;; ) {
-    const tmp = `${lockFile}.acq.${process.pid}.${randomUUID()}`;
+    const tmp = `${lockFile}.acq.${process.pid}.${randomUUID2()}`;
     let acquired = false;
     try {
-      writeFileSync5(tmp, ownerJson);
+      writeFileSync4(tmp, ownerJson);
       try {
         linkSync(tmp, lockFile);
         acquired = true;
@@ -1963,7 +2460,7 @@ async function withRegistryLock(base, fn) {
       }
     } finally {
       try {
-        unlinkSync2(tmp);
+        unlinkSync3(tmp);
       } catch {}
     }
     if (acquired) {
@@ -1973,7 +2470,7 @@ async function withRegistryLock(base, fn) {
         const current = readLockOwner(lockFile);
         if (!current || current.nonce === myNonce) {
           try {
-            unlinkSync2(lockFile);
+            unlinkSync3(lockFile);
           } catch {}
         }
       }
@@ -1990,12 +2487,12 @@ async function withRegistryLock(base, fn) {
   }
 }
 function detectLegacyRootDaemon(base) {
-  const rootPidFile = join5(base, "daemon.pid");
-  if (!existsSync6(rootPidFile))
+  const rootPidFile = join6(base, "daemon.pid");
+  if (!existsSync7(rootPidFile))
     return null;
   let pid;
   try {
-    const raw = readFileSync5(rootPidFile, "utf-8").trim();
+    const raw = readFileSync6(rootPidFile, "utf-8").trim();
     pid = Number.parseInt(raw, 10);
   } catch {
     return null;
@@ -2005,11 +2502,11 @@ function detectLegacyRootDaemon(base) {
   return { pid, controlPort: LEGACY_ROOT_CONTROL_PORT };
 }
 function probePortFree(port) {
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     const server = createServer();
-    server.once("error", () => resolve3(false));
+    server.once("error", () => resolve4(false));
     server.once("listening", () => {
-      server.close(() => resolve3(true));
+      server.close(() => resolve4(true));
     });
     server.listen(port, "127.0.0.1");
   });
@@ -2086,7 +2583,7 @@ async function resolvePair(base, opts) {
     pairId: entry.pairId,
     slot,
     ports,
-    stateDir: join5(pairsDir(base), entry.pairId),
+    stateDir: join6(pairsDir(base), entry.pairId),
     name: entry.name ?? name,
     entry,
     warning
@@ -2094,7 +2591,7 @@ async function resolvePair(base, opts) {
 }
 async function removeAllocatedPairIfUnchanged(base, pairId, slot) {
   await withRegistryLock(base, () => {
-    if (existsSync6(pairDirPath(base, pairId)) || pairDirDaemonAlive(base, pairId))
+    if (existsSync7(pairDirPath(base, pairId)) || pairDirDaemonAlive(base, pairId))
       return;
     const reg = readRegistry(base);
     const nextPairs = reg.pairs.filter((pair) => !(pair.pairId === pairId && pair.slot === slot));
@@ -2103,21 +2600,24 @@ async function removeAllocatedPairIfUnchanged(base, pairId, slot) {
     writeRegistry(base, { version: 1, pairs: nextPairs });
   });
 }
+function pairsRootDir(base) {
+  return pairsDir(base);
+}
 function pairDirPath(base, pairId) {
   const id = validatePairId(pairId);
-  return join5(pairsDir(base), id);
+  return join6(pairsDir(base), id);
 }
 function removePairDir(base, pairId) {
   const id = validatePairId(pairId);
   const root = pairsDir(base);
-  const dir = join5(root, id);
-  const canonicalRoot = resolve2(root);
-  const canonicalDir = resolve2(dir);
+  const dir = join6(root, id);
+  const canonicalRoot = resolve3(root);
+  const canonicalDir = resolve3(dir);
   if (canonicalDir === canonicalRoot || !canonicalDir.startsWith(canonicalRoot + sep)) {
     throw new PairError("PAIR_ID_INVALID", `Refusing to remove a pair dir outside ${canonicalRoot}: ${canonicalDir}`, { pairId });
   }
   assertPairsRootNotSymlinked(root);
-  if (!existsSync6(canonicalDir))
+  if (!existsSync7(canonicalDir))
     return false;
   rmSync2(canonicalDir, { recursive: true, force: true });
   return true;
@@ -2135,22 +2635,27 @@ function assertPairsRootNotSymlinked(root) {
 }
 function listPairDirs(base) {
   const root = pairsDir(base);
-  if (!existsSync6(root))
+  if (!existsSync7(root))
     return [];
   if (lstatSync(root).isSymbolicLink())
     return [];
   return readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
 }
 function pairDirDaemonAlive(base, pairId) {
-  const dir = join5(pairsDir(base), pairId);
+  const dir = join6(pairsDir(base), pairId);
   const pids = [];
   try {
-    const pid = Number.parseInt(readFileSync5(join5(dir, "daemon.pid"), "utf-8").trim(), 10);
+    const record = JSON.parse(readFileSync6(join6(dir, "daemon.json"), "utf-8"));
+    if (typeof record?.pid === "number" && Number.isFinite(record.pid))
+      pids.push(record.pid);
+  } catch {}
+  try {
+    const pid = Number.parseInt(readFileSync6(join6(dir, "daemon.pid"), "utf-8").trim(), 10);
     if (Number.isFinite(pid))
       pids.push(pid);
   } catch {}
   try {
-    const status = JSON.parse(readFileSync5(join5(dir, "status.json"), "utf-8"));
+    const status = JSON.parse(readFileSync6(join6(dir, "status.json"), "utf-8"));
     if (typeof status?.pid === "number")
       pids.push(status.pid);
   } catch {}
@@ -2184,10 +2689,54 @@ async function removeUnregisteredPairDir(base, pairId) {
     return { removed: removePairDir(base, pairId) };
   });
 }
-var PAIR_BASE_PORT = 4500, PAIR_SLOT_STRIDE = 10, PAIR_ID_REGEX, DEFAULT_PAIR_NAME = "main", LOCK_FILE_NAME = ".registry.lock", REGISTRY_FILE_NAME = "registry.json", LOCK_DEADLINE_MS = 1e4, ORPHAN_GRACE_MS = 3000, LEGACY_ROOT_CONTROL_PORT = 4502, WINDOWS_RESERVED_RE, PairError, MAX_PAIR_SLOT;
+async function removeOrphanPairDirIgnoringRegistry(base, pairId) {
+  return withRegistryLock(base, () => {
+    if (pairDirDaemonAlive(base, pairId)) {
+      return { removed: false, reason: "live" };
+    }
+    return { removed: removePairDir(base, pairId) };
+  });
+}
+function isEntryReclaimable(signals) {
+  return signals.cwdGone && signals.dead && signals.old;
+}
+function cwdMissing(cwd) {
+  try {
+    statSync2(cwd);
+    return false;
+  } catch (err) {
+    return err?.code === "ENOENT";
+  }
+}
+function parseCreatedAtMs(createdAt) {
+  if (typeof createdAt !== "string")
+    return null;
+  const ms = Date.parse(createdAt);
+  return Number.isFinite(ms) ? ms : null;
+}
+function classifyReclaimableEntries(base, now = Date.now()) {
+  const reg = readRegistry(base);
+  const out = [];
+  for (const entry of reg.pairs) {
+    const createdMs = parseCreatedAtMs(entry.createdAt);
+    const ageMs = createdMs === null ? null : Math.max(0, now - createdMs);
+    const signals = {
+      cwdGone: cwdMissing(entry.cwd),
+      dead: !pairDirDaemonAlive(base, entry.pairId),
+      old: ageMs !== null && ageMs >= RECLAIMABLE_MIN_AGE_MS,
+      ageMs
+    };
+    if (isEntryReclaimable(signals))
+      out.push({ entry, signals });
+  }
+  return out;
+}
+var PAIR_BASE_PORT = 4500, PAIR_SLOT_STRIDE = 10, PAIR_ID_REGEX, DEFAULT_PAIR_NAME = "main", RECLAIMABLE_MIN_AGE_MS, LOCK_FILE_NAME = ".registry.lock", REGISTRY_FILE_NAME = "registry.json", LOCK_DEADLINE_MS = 1e4, ORPHAN_GRACE_MS = 3000, LEGACY_ROOT_CONTROL_PORT = 4502, WINDOWS_RESERVED_RE, PairError, MAX_PAIR_SLOT;
 var init_pair_registry = __esm(() => {
+  init_atomic_json();
   init_process_lifecycle();
   PAIR_ID_REGEX = /^[A-Za-z0-9._-]{1,64}$/;
+  RECLAIMABLE_MIN_AGE_MS = 24 * 60 * 60 * 1000;
   WINDOWS_RESERVED_RE = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])$/i;
   PairError = class PairError extends Error {
     code;
@@ -2283,7 +2832,7 @@ var init_env_guard = __esm(() => {
 
 // src/pair-resolver.ts
 import { realpathSync as realpathSync2 } from "fs";
-import { join as join6, resolve as resolve3 } from "path";
+import { join as join7, resolve as resolve4 } from "path";
 function computeBaseDir() {
   return process.env.AGENTBRIDGE_BASE_DIR || process.env.AGENTBRIDGE_STATE_DIR || StateDirResolver.platformBaseDir();
 }
@@ -2410,7 +2959,7 @@ function resolvePairReadOnly(pairFlag) {
         pairId: entry.pairId,
         slot: entry.slot,
         ports: portsForEntry(entry),
-        stateDir: new StateDirResolver(join6(base, "pairs", entry.pairId)),
+        stateDir: new StateDirResolver(join7(base, "pairs", entry.pairId)),
         name: entry.name ?? name,
         manual: false
       }
@@ -2423,7 +2972,7 @@ function resolvePairReadOnly(pairFlag) {
       pairId,
       slot: null,
       ports: { appPort: 0, proxyPort: 0, controlPort: 0 },
-      stateDir: new StateDirResolver(join6(base, "pairs", pairId)),
+      stateDir: new StateDirResolver(join7(base, "pairs", pairId)),
       name,
       manual: false
     }
@@ -2453,7 +3002,7 @@ function portsForEntry(entry) {
   return portsForSlot(entry.slot);
 }
 function canonicalizeCwd(cwd) {
-  const absolute = resolve3(cwd);
+  const absolute = resolve4(cwd);
   try {
     return realpathSync2.native(absolute);
   } catch {
@@ -2470,8 +3019,8 @@ var init_pair_resolver = __esm(() => {
 });
 
 // src/trace-log.ts
-import { appendFileSync, mkdirSync as mkdirSync4 } from "fs";
-import { join as join7 } from "path";
+import { appendFileSync, existsSync as existsSync8, mkdirSync as mkdirSync5, readdirSync as readdirSync2, statSync as statSync3, unlinkSync as unlinkSync4 } from "fs";
+import { join as join8 } from "path";
 function pickRelevantEnv(env) {
   const picked = {};
   for (const [key, value] of Object.entries(env)) {
@@ -2506,7 +3055,7 @@ function redactArgv(argv) {
 }
 function traceLogPath(cwd, timestamp) {
   const day = timestamp.slice(0, 10);
-  return join7(cwd, ".agentbridge", "logs", `trace-${day}.jsonl`);
+  return join8(cwd, ".agentbridge", "logs", `trace-${day}.jsonl`);
 }
 function appendTraceEvent(input) {
   const timestamp = input.timestamp ?? new Date().toISOString();
@@ -2520,11 +3069,39 @@ function appendTraceEvent(input) {
     ...input.env ? { env: pickRelevantEnv(input.env) } : {},
     ...input.data ? { data: redactData(input.data) } : {}
   };
-  mkdirSync4(join7(input.cwd, ".agentbridge", "logs"), { recursive: true });
+  const logsDir = join8(input.cwd, ".agentbridge", "logs");
+  const isNewDayFile = !existsSync8(path);
+  mkdirSync5(logsDir, { recursive: true });
+  if (isNewDayFile) {
+    pruneOldTraceLogs(logsDir, path, Date.parse(timestamp));
+  }
   appendFileSync(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 = join8(logsDir, name);
+    if (filePath === keepPath)
+      continue;
+    try {
+      if (statSync3(filePath).mtimeMs < cutoff) {
+        unlinkSync4(filePath);
+      }
+    } catch {}
+  }
+}
 function isEnvSnapshot(key, value) {
   return /env$/i.test(key) && !!value && typeof value === "object" && !Array.isArray(value);
 }
@@ -2550,8 +3127,9 @@ function redactData(value, key = "") {
   }
   return value;
 }
-var SECRET_KEY_RE, SECRET_ARG_RE, RELEVANT_ENV_RE;
+var TRACE_RETENTION_DAYS = 7, TRACE_FILE_RE, SECRET_KEY_RE, SECRET_ARG_RE, RELEVANT_ENV_RE;
 var init_trace_log = __esm(() => {
+  TRACE_FILE_RE = /^trace-\d{4}-\d{2}-\d{2}\.jsonl$/;
   SECRET_KEY_RE = /(token|secret|password|passwd|api[_-]?key|auth|cookie|session)/i;
   SECRET_ARG_RE = /^--?(?:token|secret|password|passwd|apikey|api-key|api_key|auth|cookie|session)(?:=.*)?$/i;
   RELEVANT_ENV_RE = /^(AGENTBRIDGE_|CODEX_)/;
@@ -2600,10 +3178,14 @@ var init_max_permissions = __esm(() => {
 // src/cli/claude.ts
 var exports_claude = {};
 __export(exports_claude, {
+  warnIfPluginCacheMissing: () => warnIfPluginCacheMissing,
   runClaude: () => runClaude,
+  mapChildExitCode: () => mapChildExitCode,
   checkOwnedFlagConflicts: () => checkOwnedFlagConflicts
 });
 import { spawn as spawn2 } from "child_process";
+import { existsSync as existsSync9 } from "fs";
+import { constants as osConstants } from "os";
 async function runClaude(args) {
   const originalEnv = { ...process.env };
   const envGuardResult = guardAgentBridgeEnv({
@@ -2641,6 +3223,7 @@ async function runClaude(args) {
   }
   await assertPairNotLive(lifecycle, pair);
   lifecycle.clearKilled();
+  warnIfPluginCacheMissing();
   const channelEntry = `plugin:${PLUGIN_NAME}@${MARKETPLACE_NAME}`;
   if (permissionPlan.inject) {
     console.error(`[agentbridge] running with ${CLAUDE_MAX_PERMISSION_FLAG} (default; opt out with --safe or AGENTBRIDGE_SAFE=1)`);
@@ -2655,8 +3238,8 @@ async function runClaude(args) {
     stdio: "inherit",
     env: process.env
   });
-  child.on("exit", (code) => {
-    process.exit(code ?? 0);
+  child.on("exit", (code, signal) => {
+    process.exit(mapChildExitCode(code, signal));
   });
   child.on("error", (err) => {
     if (err.code === "ENOENT") {
@@ -2668,6 +3251,24 @@ async function runClaude(args) {
     process.exit(1);
   });
 }
+function mapChildExitCode(code, signal) {
+  if (signal) {
+    return 128 + (osConstants.signals[signal] ?? 0);
+  }
+  return code ?? 0;
+}
+function warnIfPluginCacheMissing(cacheRoot = pluginCacheRoot(), log = (msg) => console.error(msg)) {
+  let cacheExists;
+  try {
+    cacheExists = existsSync9(cacheRoot);
+  } catch {
+    return false;
+  }
+  if (!shouldWarnMissingPluginCache(cacheExists))
+    return false;
+  log("[agentbridge] \u26A0\uFE0F  Plugin not installed (no plugin cache found). Run `abg init`, " + `or in Claude Code: ${MARKETPLACE_STEPS.join(" \u2192 ")}. Launching anyway\u2026`);
+  return true;
+}
 function traceCliStart(event, args, originalEnv, envGuardAction, pair) {
   try {
     appendTraceEvent({
@@ -2744,6 +3345,7 @@ function checkOwnedFlagConflicts(args, commandName, ownedFlags) {
 var OWNED_FLAGS;
 var init_claude = __esm(() => {
   init_cli();
+  init_plugin_cache();
   init_daemon_client();
   init_daemon_lifecycle();
   init_build_info();
@@ -2755,15 +3357,15 @@ var init_claude = __esm(() => {
 });
 
 // src/agents-contract.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync7 } from "fs";
+import { join as join9 } from "path";
 function checkAgentsMdContract(cwd) {
-  const path = join8(cwd, "AGENTS.md");
-  const exists = existsSync7(path);
+  const path = join9(cwd, "AGENTS.md");
+  const exists = existsSync10(path);
   let content = "";
   if (exists) {
     try {
-      content = readFileSync6(path, "utf-8");
+      content = readFileSync7(path, "utf-8");
     } catch {
       return {
         fresh: false,
@@ -2790,8 +3392,8 @@ function isFreshAgentsMdContract(content) {
 var init_agents_contract = () => {};
 
 // src/wrapper-exit-observability.ts
-import { readFileSync as readFileSync7, readdirSync as readdirSync2, statSync as statSync3 } from "fs";
-import { join as join9 } from "path";
+import { readFileSync as readFileSync8, readdirSync as readdirSync3, statSync as statSync4 } from "fs";
+import { join as join10 } from "path";
 function discoverNativeChildPid(launcherPid, run) {
   try {
     const out = run("pgrep", ["-P", String(launcherPid)]);
@@ -2801,17 +3403,15 @@ function discoverNativeChildPid(launcherPid, run) {
     return null;
   }
 }
-function readTurnInProgress(statusFilePath, read = (p) => readFileSync7(p, "utf-8"), isPidAlive = defaultIsPidAlive) {
-  try {
-    const status = JSON.parse(read(statusFilePath));
-    if (typeof status.turnInProgress !== "boolean")
-      return null;
-    if (typeof status.pid === "number" && !isPidAlive(status.pid))
-      return null;
-    return status.turnInProgress;
-  } catch {
+function readUnifiedTurnInProgress(paths, read = (p) => readFileSync8(p, "utf-8"), isPidAlive = defaultIsPidAlive) {
+  const record = readUnifiedDaemonRecord(paths, read);
+  if (!record)
     return null;
-  }
+  if (typeof record.turnInProgress !== "boolean")
+    return null;
+  if (typeof record.pid === "number" && !isPidAlive(record.pid))
+    return null;
+  return record.turnInProgress;
 }
 function refineCleanExitClassification(turnInProgress) {
   if (turnInProgress === true)
@@ -2820,14 +3420,14 @@ function refineCleanExitClassification(turnInProgress) {
     return "exit_0_idle";
   return "exit_0_turn_unknown";
 }
-function findCodexSqliteLog(codexHome, fs = { readdir: readdirSync2, stat: statSync3 }) {
+function findCodexSqliteLog(codexHome, fs2 = { readdir: readdirSync3, stat: statSync4 }) {
   try {
-    const entries = fs.readdir(codexHome).filter((name) => /^logs.*\.sqlite$/.test(String(name)));
+    const entries = fs2.readdir(codexHome).filter((name) => /^logs.*\.sqlite$/.test(String(name)));
     let best = null;
     for (const name of entries) {
-      const path = join9(codexHome, String(name));
+      const path = join10(codexHome, String(name));
       try {
-        const mtime = fs.stat(path).mtimeMs;
+        const mtime = fs2.stat(path).mtimeMs;
         if (!best || mtime > best.mtime)
           best = { path, mtime };
       } catch {}
@@ -2862,14 +3462,15 @@ function captureTuiLogTail(options) {
 var defaultIsPidAlive;
 var init_wrapper_exit_observability = __esm(() => {
   init_process_lifecycle();
+  init_daemon_record();
   defaultIsPidAlive = pidLooksAlive;
 });
 
 // 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 {
@@ -2878,22 +3479,23 @@ function pairScopedCommand(cmd) {
       selector = pairId;
     }
   }
-  return `agentbridge --pair ${selector} ${cmd}`;
+  return `${name} --pair ${selector} ${cmd}`;
 }
 var init_pair_command = __esm(() => {
+  init_cli_invocation();
   init_pair_resolver();
 });
 
 // src/rotating-log.ts
-import { appendFileSync as appendFileSync2, existsSync as existsSync8, renameSync as renameSync2, statSync as statSync4, unlinkSync as unlinkSync3 } from "fs";
-import { dirname as dirname2 } from "path";
-function appendRotatingLog(path, content, options = {}) {
+import { appendFileSync as appendFileSync2, existsSync as existsSync11, renameSync as renameSync2, statSync as statSync5, unlinkSync as unlinkSync5 } from "fs";
+import { dirname as dirname3 } from "path";
+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 (!existsSync8(dirname2(path)))
+  if (!fsOps.existsSync(dirname3(path)))
     return;
-  rotateIfNeeded(path, Buffer.byteLength(content), maxBytes, keep);
-  appendFileSync2(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];
@@ -2902,30 +3504,53 @@ 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(error) {
+  return !!error && error.code === "ENOENT";
+}
+function renameIfPresent(from, to, fsOps) {
+  try {
+    fsOps.renameSync(from, to);
+  } catch (error) {
+    if (!isEnoent(error))
+      throw error;
+  }
+}
+function unlinkIfPresent(path, fsOps) {
+  try {
+    fsOps.unlinkSync(path);
+  } catch (error) {
+    if (!isEnoent(error))
+      throw error;
+  }
+}
+function rotateIfNeeded(path, incomingBytes, maxBytes, keep, fsOps) {
   if (!Number.isFinite(maxBytes) || maxBytes <= 0 || keep <= 0)
     return;
-  if (!existsSync8(path))
-    return;
-  const size = statSync4(path).size;
+  let size;
+  try {
+    size = fsOps.statSync(path).size;
+  } catch (error) {
+    if (isEnoent(error))
+      return;
+    throw error;
+  }
   if (size + incomingBytes <= maxBytes)
     return;
   for (let index = keep;index >= 1; index--) {
     const current = `${path}.${index}`;
     const next = `${path}.${index + 1}`;
-    if (!existsSync8(current))
-      continue;
     if (index === keep) {
-      unlinkSync3(current);
+      unlinkIfPresent(current, fsOps);
     } else {
-      renameSync2(current, next);
+      renameIfPresent(current, next, fsOps);
     }
   }
-  renameSync2(path, `${path}.1`);
+  renameIfPresent(path, `${path}.1`, fsOps);
 }
-var DEFAULT_MAX_BYTES, DEFAULT_KEEP = 3;
+var DEFAULT_MAX_BYTES, DEFAULT_KEEP = 3, REAL_FS_OPS;
 var init_rotating_log = __esm(() => {
   DEFAULT_MAX_BYTES = 5 * 1024 * 1024;
+  REAL_FS_OPS = { statSync: statSync5, renameSync: renameSync2, unlinkSync: unlinkSync5, appendFileSync: appendFileSync2, existsSync: existsSync11 };
 });
 
 // src/stderr-ring-buffer.ts
@@ -2978,31 +3603,21 @@ var init_stderr_ring_buffer = __esm(() => {
 
 // src/thread-state.ts
 import {
-  existsSync as existsSync9,
-  mkdirSync as mkdirSync5,
-  readdirSync as readdirSync3,
-  readFileSync as readFileSync8,
-  renameSync as renameSync3,
-  writeFileSync as writeFileSync6
+  existsSync as existsSync12,
+  readdirSync as readdirSync4,
+  readFileSync as readFileSync9
 } from "fs";
 import { homedir as homedir3 } from "os";
-import { basename as basename3, dirname as dirname3, join as join10 } from "path";
+import { basename as basename4, join as join11 } from "path";
 function nowIso() {
   return new Date().toISOString();
 }
 function codexHome(env = process.env) {
-  return env.CODEX_HOME && env.CODEX_HOME.length > 0 ? env.CODEX_HOME : join10(homedir3(), ".codex");
-}
-function atomicWriteJson(path, value) {
-  mkdirSync5(dirname3(path), { recursive: true });
-  const tmp = `${path}.tmp.${process.pid}.${Date.now()}`;
-  writeFileSync6(tmp, JSON.stringify(value, null, 2) + `
-`, "utf-8");
-  renameSync3(tmp, path);
+  return env.CODEX_HOME && env.CODEX_HOME.length > 0 ? env.CODEX_HOME : join11(homedir3(), ".codex");
 }
 function readRawCurrentThread(stateDir) {
   try {
-    const parsed = JSON.parse(readFileSync8(stateDir.currentThreadFile, "utf-8"));
+    const parsed = JSON.parse(readFileSync9(stateDir.currentThreadFile, "utf-8"));
     if (parsed?.version === 1 && typeof parsed.threadId === "string" && parsed.threadId.length > 0 && (parsed.status === "pending" || parsed.status === "current") && typeof parsed.cwd === "string") {
       return parsed;
     }
@@ -3010,8 +3625,8 @@ function readRawCurrentThread(stateDir) {
   return null;
 }
 function findCodexRolloutFile(threadId, env = process.env, maxEntries = 20000) {
-  const sessionsDir = join10(codexHome(env), "sessions");
-  if (!threadId || !existsSync9(sessionsDir))
+  const sessionsDir = join11(codexHome(env), "sessions");
+  if (!threadId || !existsSync12(sessionsDir))
     return null;
   const exactName = `rollout-${threadId}.jsonl`;
   const stack = [sessionsDir];
@@ -3020,20 +3635,20 @@ function findCodexRolloutFile(threadId, env = process.env, maxEntries = 20000) {
     const dir = stack.pop();
     let entries;
     try {
-      entries = readdirSync3(dir, { withFileTypes: true });
+      entries = readdirSync4(dir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
       visited++;
-      const path = join10(dir, entry.name);
+      const path = join11(dir, entry.name);
       if (entry.isDirectory()) {
         stack.push(path);
         continue;
       }
       if (!entry.isFile())
         continue;
-      const name = basename3(entry.name);
+      const name = basename4(entry.name);
       if (name === exactName || name.startsWith("rollout-") && name.endsWith(".jsonl") && name.includes(threadId)) {
         return path;
       }
@@ -3051,7 +3666,7 @@ function readUsableCurrentThread(identity, env = process.env) {
     return null;
   if (state.cwd !== identity.cwd)
     return null;
-  if (state.rolloutPath && existsSync9(state.rolloutPath))
+  if (state.rolloutPath && existsSync12(state.rolloutPath))
     return state;
   const rolloutPath = findCodexRolloutFile(state.threadId, env);
   if (!rolloutPath)
@@ -3065,7 +3680,9 @@ function readUsableCurrentThread(identity, env = process.env) {
   atomicWriteJson(identity.stateDir.currentThreadFile, repaired);
   return repaired;
 }
-var init_thread_state = () => {};
+var init_thread_state = __esm(() => {
+  init_atomic_json();
+});
 
 // src/cli/codex.ts
 var exports_codex = {};
@@ -3080,18 +3697,18 @@ import {
   openSync as openSync3,
   writeSync,
   closeSync as closeSync3,
-  writeFileSync as writeFileSync7,
-  readFileSync as readFileSync9,
-  unlinkSync as unlinkSync4,
-  existsSync as existsSync10,
+  writeFileSync as writeFileSync5,
+  readFileSync as readFileSync10,
+  unlinkSync as unlinkSync6,
+  existsSync as existsSync13,
   mkdirSync as mkdirSync6
 } from "fs";
 import { homedir as homedir4 } from "os";
-import { dirname as dirname4, join as join11 } from "path";
+import { dirname as dirname4, join as join12 } from "path";
 function appendWrapperLog(path, entry) {
   try {
     const dir = dirname4(path);
-    if (!existsSync10(dir)) {
+    if (!existsSync13(dir)) {
       mkdirSync6(dir, { recursive: true });
     }
     appendRotatingLog(path, `[${new Date().toISOString()}] ${entry}
@@ -3254,11 +3871,11 @@ async function runCodex(args) {
     process.exit(1);
   }
   let proxyUrl;
-  const status = lifecycle.readStatus();
-  if (status?.proxyUrl) {
-    proxyUrl = status.proxyUrl;
+  const record = lifecycle.readDaemonRecord();
+  if (typeof record?.proxyUrl === "string" && record.proxyUrl.length > 0) {
+    proxyUrl = record.proxyUrl;
   } else {
-    const fallbackProxyPort = process.env.CODEX_PROXY_PORT ?? String(new ConfigService().loadOrDefault().codex.proxyPort);
+    const fallbackProxyPort = process.env.CODEX_PROXY_PORT ?? String(new ConfigService().loadOrDefault((msg) => console.error(`[agentbridge] ${msg}`)).codex.proxyPort);
     proxyUrl = `ws://127.0.0.1:${fallbackProxyPort}`;
     console.error(`[agentbridge] No daemon status found, using fallback proxy port: ${proxyUrl}`);
   }
@@ -3338,7 +3955,7 @@ async function runCodex(args) {
     env: buildChildEnv()
   });
   if (typeof child.pid === "number") {
-    writeFileSync7(stateDir.tuiPidFile, `${child.pid}
+    writeFileSync5(stateDir.tuiPidFile, `${child.pid}
 `, "utf-8");
     appendWrapperLog(wrapperLogPath, `child pid=${child.pid}`);
   }
@@ -3378,7 +3995,7 @@ async function runCodex(args) {
       return;
     cleanedTuiPid = true;
     try {
-      unlinkSync4(stateDir.tuiPidFile);
+      unlinkSync6(stateDir.tuiPidFile);
     } catch {}
   }
   function requestChildTermination(reason) {
@@ -3449,10 +4066,14 @@ async function runCodex(args) {
     else if (typeof code === "number" && code !== 0)
       classification = `nonzero_exit:${code}`;
     else if (code === 0 && tail.trim().length === 0) {
-      classification = refineCleanExitClassification(readTurnInProgress(stateDir.statusFile));
+      classification = refineCleanExitClassification(readUnifiedTurnInProgress({
+        daemonRecordFile: stateDir.daemonRecordFile,
+        pidFile: stateDir.pidFile,
+        statusFile: stateDir.statusFile
+      }));
     }
     const tuiLogTail = captureTuiLogTail({
-      codexHome: join11(homedir4(), ".codex"),
+      codexHome: join12(homedir4(), ".codex"),
       nativePid: nativeChildPid,
       run: (cmd, args2) => execFileSync6(cmd, args2, { encoding: "utf-8", timeout: 2000 })
     });
@@ -3508,12 +4129,12 @@ function guardNoLiveManagedTui(stateDir, proxyUrl) {
   if (pid) {
     if (!isProcessAlive(pid)) {
       try {
-        unlinkSync4(stateDir.tuiPidFile);
+        unlinkSync6(stateDir.tuiPidFile);
       } catch {}
     } else if (!isManagedCodexTuiProcess(pid, proxyUrl)) {
       appendWrapperLog(stateDir.codexWrapperLogFile, `stale tui pid file pointed at unmanaged live pid=${pid}; removing`);
       try {
-        unlinkSync4(stateDir.tuiPidFile);
+        unlinkSync6(stateDir.tuiPidFile);
       } catch {}
     } else {
       console.error(`[agentbridge] This pair already has a managed Codex TUI running (pid ${pid}).`);
@@ -3530,7 +4151,7 @@ function guardNoLiveManagedTui(stateDir, proxyUrl) {
 }
 function readTuiPid(stateDir) {
   try {
-    const raw = readFileSync9(stateDir.tuiPidFile, "utf-8").trim();
+    const raw = readFileSync10(stateDir.tuiPidFile, "utf-8").trim();
     if (!raw)
       return null;
     const pid = Number.parseInt(raw, 10);
@@ -3544,7 +4165,12 @@ function isManagedCodexTuiProcess(pid, proxyUrl) {
   return cmd !== null && commandMatchesManagedCodexTui(cmd, proxyUrl);
 }
 function proxyHealthUrl(proxyUrl) {
-  const url = new URL(proxyUrl);
+  let url;
+  try {
+    url = new URL(proxyUrl);
+  } catch {
+    throw new Error(`Malformed Codex proxy URL: ${JSON.stringify(proxyUrl)}`);
+  }
   url.protocol = url.protocol === "wss:" ? "https:" : "http:";
   url.pathname = "/healthz";
   url.search = "";
@@ -3560,7 +4186,7 @@ async function waitForProxyReady(proxyUrl, maxRetries = 20, delayMs = 100) {
         return;
       }
     } catch {}
-    await new Promise((resolve4) => setTimeout(resolve4, delayMs));
+    await new Promise((resolve5) => setTimeout(resolve5, delayMs));
   }
   throw new Error(`Timed out waiting for Codex proxy readiness on ${healthUrl}`);
 }
@@ -3609,17 +4235,17 @@ var init_codex = __esm(() => {
 });
 
 // src/claude-session.ts
-import { readdirSync as readdirSync4, statSync as statSync5 } from "fs";
+import { readdirSync as readdirSync5, statSync as statSync6 } from "fs";
 import { homedir as homedir5 } from "os";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 function encodeClaudeProjectDir(cwd) {
   return cwd.replace(/[^a-zA-Z0-9]/g, "-");
 }
-function findLatestClaudeSession(cwd, claudeHome = process.env.CLAUDE_CONFIG_DIR || join12(homedir5(), ".claude")) {
-  const dir = join12(claudeHome, "projects", encodeClaudeProjectDir(cwd));
+function findLatestClaudeSession(cwd, claudeHome = process.env.CLAUDE_CONFIG_DIR || join13(homedir5(), ".claude")) {
+  const dir = join13(claudeHome, "projects", encodeClaudeProjectDir(cwd));
   let entries;
   try {
-    entries = readdirSync4(dir);
+    entries = readdirSync5(dir);
   } catch {
     return null;
   }
@@ -3630,10 +4256,10 @@ function findLatestClaudeSession(cwd, claudeHome = process.env.CLAUDE_CONFIG_DIR
     const sessionId = name.slice(0, -".jsonl".length);
     if (!SESSION_ID_PATTERN.test(sessionId))
       continue;
-    const file = join12(dir, name);
+    const file = join13(dir, name);
     let mtimeMs;
     try {
-      const st = statSync5(file);
+      const st = statSync6(file);
       if (!st.isFile())
         continue;
       mtimeMs = st.mtimeMs;
@@ -3739,8 +4365,8 @@ __export(exports_kill, {
   runKill: () => runKill,
   formatKillReport: () => formatKillReport
 });
-import { readFileSync as readFileSync10, unlinkSync as unlinkSync5 } from "fs";
-import { join as join13 } from "path";
+import { readFileSync as readFileSync11, unlinkSync as unlinkSync7 } from "fs";
+import { join as join14 } from "path";
 async function runKill(args = []) {
   const argError = validateKillArgs(args);
   if (argError === "help") {
@@ -3760,8 +4386,9 @@ async function runKill(args = []) {
   const base = computeBaseDir();
   console.log(`AgentBridge Kill \u2014 stopping AgentBridge pair processes
 `);
+  const cli = cliInvocationName();
   const results = [];
-  let restartCommand = "agentbridge claude";
+  let restartCommand = `${cli} claude`;
   if (parsed.pairFlag !== undefined) {
     let pair;
     try {
@@ -3775,7 +4402,7 @@ async function runKill(args = []) {
       printKnownPairs(base);
       return;
     }
-    restartCommand = `agentbridge --pair ${pair.name ?? parsed.pairFlag} claude`;
+    restartCommand = `${cli} --pair ${pair.name ?? parsed.pairFlag} claude`;
     results.push(await stopPairEntry(base, pair));
   } else if (parsed.all) {
     let registered = [];
@@ -3792,7 +4419,7 @@ async function runKill(args = []) {
     for (const dirName of listPairDirsSafe(base)) {
       if (registeredIds.has(dirName))
         continue;
-      const stateDir = new StateDirResolver(join13(base, "pairs", dirName));
+      const stateDir = new StateDirResolver(join14(base, "pairs", dirName));
       results.push(await stopStateDir(`${dirName} (unregistered)`, stateDir, portsFromStateDir(stateDir)));
     }
     const legacy = detectLegacyRootDaemon(base);
@@ -3809,7 +4436,7 @@ async function runKill(args = []) {
       cwdPairs = listPairsForCwd(base, process.cwd());
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      console.log(`\u26A0\uFE0F  pair registry \u4E0D\u53EF\u8BFB\uFF08${message}\uFF09\u2014\u2014\u65E0\u6CD5\u6309\u76EE\u5F55\u5B9A\u4F4D pair\u3002` + "\u8FD0\u884C `abg kill --all` \u53EF\u964D\u7EA7\u4E3A\u5168\u76D8\u72B6\u6001\u76EE\u5F55\u626B\u63CF\uFF0C\u505C\u6B62\u6240\u6709\u80FD\u627E\u5230\u7684 pair\u3002");
+      console.log(`\u26A0\uFE0F  pair registry \u4E0D\u53EF\u8BFB\uFF08${message}\uFF09\u2014\u2014\u65E0\u6CD5\u6309\u76EE\u5F55\u5B9A\u4F4D pair\u3002` + `\u8FD0\u884C \`${cli} kill --all\` \u53EF\u964D\u7EA7\u4E3A\u5168\u76D8\u72B6\u6001\u76EE\u5F55\u626B\u63CF\uFF0C\u505C\u6B62\u6240\u6709\u80FD\u627E\u5230\u7684 pair\u3002`);
       process.exitCode = 2;
     }
     for (const pair of cwdPairs) {
@@ -3825,7 +4452,7 @@ async function runKill(args = []) {
     }
     if (results.length === 0) {
       console.log(`No AgentBridge pairs registered for current directory: ${process.cwd()}`);
-      console.log("Use `abg kill all` or `abg kill --all` to stop pairs from every directory.");
+      console.log(`Use \`${cli} kill all\` or \`${cli} kill --all\` to stop pairs from every directory.`);
       return;
     }
   }
@@ -3877,7 +4504,7 @@ No arguments stop this directory's registered pairs and any legacy-root daemon.
 }
 async function stopPairEntry(base, pair) {
   const ports = portsForEntry(pair);
-  const stateDir = new StateDirResolver(join13(base, "pairs", pair.pairId));
+  const stateDir = new StateDirResolver(join14(base, "pairs", pair.pairId));
   return stopStateDir(pair.pairId, stateDir, ports);
 }
 function listPairDirsSafe(base) {
@@ -3888,22 +4515,18 @@ function listPairDirsSafe(base) {
   }
 }
 function portsFromStateDir(stateDir) {
-  try {
-    const raw = JSON.parse(readFileSync10(stateDir.statusFile, "utf-8"));
-    return {
-      appPort: portFromUrl(raw?.appServerUrl) ?? 0,
-      proxyPort: portFromUrl(raw?.proxyUrl) ?? 0,
-      controlPort: typeof raw?.controlPort === "number" ? raw.controlPort : 0
-    };
-  } catch {
+  const record = readUnifiedDaemonRecord({
+    daemonRecordFile: stateDir.daemonRecordFile,
+    pidFile: stateDir.pidFile,
+    statusFile: stateDir.statusFile
+  });
+  if (!record)
     return { appPort: 0, proxyPort: 0, controlPort: 0 };
-  }
-}
-function portFromUrl(url) {
-  if (typeof url !== "string")
-    return null;
-  const match = url.match(/:(\d+)(?:[/?]|$)/);
-  return match ? Number.parseInt(match[1], 10) : null;
+  return {
+    appPort: record.ports?.appPort ?? portFromUrl(record.appServerUrl) ?? 0,
+    proxyPort: record.ports?.proxyPort ?? portFromUrl(record.proxyUrl) ?? 0,
+    controlPort: record.ports?.controlPort ?? 0
+  };
 }
 async function stopStateDir(label, stateDir, ports) {
   const portsLabel = `${ports.appPort}/${ports.proxyPort}/${ports.controlPort}`;
@@ -3916,8 +4539,8 @@ async function stopStateDir(label, stateDir, ports) {
       log
     });
     lifecycle.markKilled();
-    const status = lifecycle.readStatus();
-    const proxyUrl = typeof status?.proxyUrl === "string" && status.proxyUrl.length > 0 ? status.proxyUrl : `ws://127.0.0.1:${ports.proxyPort}`;
+    const record = lifecycle.readDaemonRecord();
+    const proxyUrl = typeof record?.proxyUrl === "string" && record.proxyUrl.length > 0 ? record.proxyUrl : `ws://127.0.0.1:${ports.proxyPort}`;
     const tuiKilled = await killManagedCodexTui(stateDir, proxyUrl, log);
     const daemonKilled = await lifecycle.kill();
     return { label, portsLabel, daemonKilled, tuiKilled, details };
@@ -3982,9 +4605,10 @@ function formatKillReport(results, frontends, restartCommand) {
   }
   lines.push("");
   if (stopped.length > 0) {
+    const cliName = restartCommand.split(" ")[0] ?? "abg";
     lines.push("AgentBridge stopped.");
     lines.push(`Please restart Claude Code (\`${restartCommand}\`), switch to a new conversation, or run \`/resume\` to fully disconnect.`);
-    lines.push("\u2139\uFE0F  \u5DF2\u5199\u5165 killed \u54E8\u5175\uFF1A\u88AB\u505C\u6B62\u7684 pair \u4E0D\u4F1A\u88AB\u81EA\u52A8\u590D\u6D3B\uFF1B" + `\u4E0B\u6B21 \`${restartCommand}\` / \`agentbridge codex\` \u4F1A\u6E05\u9664\u54E8\u5175\u5E76\u7528\u5F53\u524D\u5B89\u88C5\u7248\u672C\u542F\u52A8\u5168\u65B0 daemon\u3002`);
+    lines.push("\u2139\uFE0F  \u5DF2\u5199\u5165 killed \u54E8\u5175\uFF1A\u88AB\u505C\u6B62\u7684 pair \u4E0D\u4F1A\u88AB\u81EA\u52A8\u590D\u6D3B\uFF1B" + `\u4E0B\u6B21 \`${restartCommand}\` / \`${cliName} codex\` \u4F1A\u6E05\u9664\u54E8\u5175\u5E76\u7528\u5F53\u524D\u5B89\u88C5\u7248\u672C\u542F\u52A8\u5168\u65B0 daemon\u3002`);
   } else {
     lines.push("No running AgentBridge daemon or managed Codex TUI found.");
     lines.push("\u2139\uFE0F  \u76EE\u6807 pair \u90FD\u6CA1\u6709\u5728\u8FD0\u884C\u7684\u8FDB\u7A0B\u2014\u2014\u5982\u679C\u4F60\u4ECD\u770B\u5230 AgentBridge \u6D3B\u52A8\uFF0C\u89C1\u4E0B\u65B9\u524D\u7AEF\u63D0\u793A\u3002");
@@ -4035,7 +4659,7 @@ async function killManagedCodexTui(stateDir, proxyUrl, log, gracefulTimeoutMs =
 }
 function readTuiPid2(stateDir) {
   try {
-    const raw = readFileSync10(stateDir.tuiPidFile, "utf-8").trim();
+    const raw = readFileSync11(stateDir.tuiPidFile, "utf-8").trim();
     if (!raw)
       return null;
     const pid = Number.parseInt(raw, 10);
@@ -4046,7 +4670,7 @@ function readTuiPid2(stateDir) {
 }
 function removeTuiPidFile(stateDir) {
   try {
-    unlinkSync5(stateDir.tuiPidFile);
+    unlinkSync7(stateDir.tuiPidFile);
   } catch {}
 }
 function isManagedCodexTuiProcess2(pid, proxyUrl) {
@@ -4054,7 +4678,9 @@ function isManagedCodexTuiProcess2(pid, proxyUrl) {
   return cmd !== null && commandMatchesManagedCodexTui(cmd, proxyUrl);
 }
 var init_kill = __esm(() => {
+  init_cli_invocation();
   init_daemon_lifecycle();
+  init_daemon_record();
   init_pair_registry();
   init_pair_resolver();
   init_process_lifecycle();
@@ -4066,7 +4692,14 @@ var exports_pairs = {};
 __export(exports_pairs, {
   runPairs: () => runPairs
 });
-import { join as join14 } from "path";
+import { join as join15 } from "path";
+function isRegistryCorruptError(error) {
+  return error instanceof PairError && error.code === "PAIR_REGISTRY_CORRUPT";
+}
+function registryPathForNotice(base, error) {
+  const fromDetails = error.details?.path;
+  return typeof fromDetails === "string" && fromDetails.length > 0 ? fromDetails : join15(pairsRootDir(base), "registry.json");
+}
 async function runPairs(args = []) {
   const [command, ...rest] = args;
   if (command === "rm") {
@@ -4079,7 +4712,7 @@ async function runPairs(args = []) {
   }
   if (command && command !== "list" && command !== "--json" && command !== "--threads") {
     console.error(`Unknown pairs command: ${command}`);
-    console.error("Usage: abg pairs [--json] [--threads] | abg pairs rm <name|id> | abg pairs prune [--dry-run]");
+    console.error("Usage: abg pairs [--json] [--threads] | abg pairs rm <name|id> | abg pairs prune [--apply]");
     process.exit(1);
   }
   const json = command === "--json" || rest.includes("--json");
@@ -4134,16 +4767,40 @@ async function runRemove(args) {
   }
 }
 async function runPrune(args) {
-  const dryRun = args.includes("--dry-run");
+  const apply = args.includes("--apply");
   for (const arg of args) {
-    if (arg !== "--dry-run") {
+    if (arg !== "--apply" && arg !== "--dry-run") {
       console.error(`Unknown prune argument: ${arg}`);
-      console.error("Usage: abg pairs prune [--dry-run]");
+      console.error("Usage: abg pairs prune [--apply]");
       process.exit(1);
     }
   }
+  if (apply && args.includes("--dry-run")) {
+    console.error("Error: --apply and --dry-run are mutually exclusive.");
+    console.error("Usage: abg pairs prune [--apply]");
+    process.exit(1);
+  }
   const base = computeBaseDir();
-  const registered = new Set(listPairs(base).map((pair) => pair.pairId.toLowerCase()));
+  let reclaimable;
+  let registryReadable = true;
+  try {
+    reclaimable = classifyReclaimableEntries(base);
+  } catch (error) {
+    if (!isRegistryCorruptError(error))
+      throw error;
+    registryReadable = false;
+    reclaimable = [];
+    console.error(`\u26A0\uFE0F  pair registry \u4E0D\u53EF\u8BFB\uFF08${error.message}\uFF09\u2014\u2014` + `\u4F4D\u4E8E ${registryPathForNotice(base, error)}\u3002` + `\u8DF3\u8FC7 registry \u6761\u76EE\u56DE\u6536\uFF0C\u964D\u7EA7\u4E3A\u78C1\u76D8\u626B\u63CF\u6E05\u7406\u5B64\u513F\u76EE\u5F55\uFF08\u65E0\u9700\u53EF\u89E3\u6790\u7684 registry\uFF09\u3002` + `\u4FEE\u590D\u6216\u5220\u9664\u8BE5\u6587\u4EF6\u540E\u53EF\u6062\u590D\u5B8C\u6574 prune\u3002`);
+    process.exitCode = 2;
+  }
+  const reclaimableIds = new Set(reclaimable.map((c) => c.entry.pairId.toLowerCase()));
+  const dirResult = pruneOrphanDirs(base, apply, reclaimableIds, registryReadable);
+  const entryResult = await pruneReclaimableEntries(reclaimable, base, apply);
+  const resolvedDirResult = await dirResult;
+  printPruneSummary(resolvedDirResult, entryResult, apply);
+}
+async function pruneOrphanDirs(base, apply, reclaimableIds, registryReadable) {
+  const registered = registryReadable ? new Set(listPairs(base).map((pair) => pair.pairId.toLowerCase())) : new Set;
   const removed = [];
   const kept = [];
   for (const name of listPairDirs(base)) {
@@ -4158,6 +4815,9 @@ async function runPrune(args) {
       kept.push({ name, reason: "directory name is not a canonical pair id" });
       continue;
     }
+    if (reclaimableIds.has(id.toLowerCase())) {
+      continue;
+    }
     if (registered.has(id.toLowerCase())) {
       kept.push({ name, reason: "registered \u2014 use `abg pairs rm`" });
       continue;
@@ -4166,12 +4826,12 @@ async function runPrune(args) {
       kept.push({ name, reason: "daemon still alive" });
       continue;
     }
-    if (dryRun) {
+    if (!apply) {
       removed.push(name);
       continue;
     }
     try {
-      const outcome = await removeUnregisteredPairDir(base, id);
+      const outcome = registryReadable ? await removeUnregisteredPairDir(base, id) : await removeOrphanPairDirIgnoringRegistry(base, id);
       if (outcome.removed) {
         removed.push(name);
       } else if (outcome.reason === "registered") {
@@ -4185,33 +4845,90 @@ async function runPrune(args) {
       kept.push({ name, reason: `error: ${err instanceof Error ? err.message : String(err)}` });
     }
   }
-  printPruneSummary(removed, kept, dryRun);
+  return { removed, kept };
+}
+async function pruneReclaimableEntries(candidates, base, apply) {
+  const reclaimed = [];
+  const kept = [];
+  for (const candidate of candidates) {
+    const reason = describeReclaimReason(candidate);
+    if (!apply) {
+      reclaimed.push({ pairId: candidate.entry.pairId, slot: candidate.entry.slot, reason });
+      continue;
+    }
+    try {
+      const res = await removePairEntryAndDir(base, candidate.entry.pairId);
+      if (res.keptLive) {
+        kept.push({ pairId: candidate.entry.pairId, reason: "became live during prune" });
+      } else {
+        reclaimed.push({ pairId: candidate.entry.pairId, slot: candidate.entry.slot, reason });
+      }
+    } catch (err) {
+      kept.push({
+        pairId: candidate.entry.pairId,
+        reason: `error: ${err instanceof Error ? err.message : String(err)}`
+      });
+    }
+  }
+  return { reclaimed, kept };
 }
-function printPruneSummary(removed, kept, dryRun) {
-  if (removed.length === 0 && kept.length === 0) {
-    console.log("No pair directories found.");
+function describeReclaimReason(candidate) {
+  const { signals } = candidate;
+  const age = signals.ageMs === null ? "age?" : `age ${formatAgeDays(signals.ageMs)}`;
+  return `cwd-gone, dead, ${age}`;
+}
+function formatAgeDays(ageMs) {
+  const days = ageMs / (24 * 60 * 60 * 1000);
+  return days >= 10 ? `${Math.round(days)}d` : `${days.toFixed(1)}d`;
+}
+function printPruneSummary(dirResult, entryResult, apply) {
+  const { removed: dirsRemoved, kept: dirsKept } = dirResult;
+  const { reclaimed: entriesReclaimed, kept: entriesKept } = entryResult;
+  const nothingFound = dirsRemoved.length === 0 && dirsKept.length === 0 && entriesReclaimed.length === 0 && entriesKept.length === 0;
+  if (nothingFound) {
+    console.log("Nothing to prune: no orphan pair directories or reclaimable entries found.");
     return;
   }
-  if (removed.length > 0) {
-    console.log(dryRun ? "Would remove orphan pair directories:" : "Removed orphan pair directories:");
-    for (const name of removed)
+  if (dirsRemoved.length > 0) {
+    console.log(apply ? "Removed orphan pair directories:" : "Would remove orphan pair directories:");
+    for (const name of dirsRemoved)
       console.log(`  ${name}`);
-  } else {
-    console.log(dryRun ? "No orphan pair directories to remove." : "No orphan pair directories removed.");
   }
-  if (kept.length > 0) {
+  if (entriesReclaimed.length > 0) {
+    console.log(apply ? "Reclaimed registry entries:" : "Would reclaim registry entries:");
+    for (const { pairId, slot, reason } of entriesReclaimed) {
+      console.log(`  ${pairId} (slot ${slot}) \u2014 ${reason}`);
+    }
+  }
+  if (dirsRemoved.length === 0 && entriesReclaimed.length === 0) {
+    console.log(apply ? "Nothing was reclaimed." : "Nothing to reclaim.");
+  }
+  const keptLines = [
+    ...dirsKept.map(({ name, reason }) => `  ${name} (${reason})`),
+    ...entriesKept.map(({ pairId, reason }) => `  ${pairId} (${reason})`)
+  ];
+  if (keptLines.length > 0) {
     console.log("Kept:");
-    for (const { name, reason } of kept)
-      console.log(`  ${name} (${reason})`);
+    for (const line of keptLines)
+      console.log(line);
   }
-  if (dryRun) {
+  if (!apply) {
     console.log(`
-(dry run \u2014 nothing was deleted. Re-run without --dry-run to apply.)`);
+(dry run \u2014 nothing was deleted. Re-run with --apply to reclaim.)`);
   }
 }
 async function collectRows() {
   const base = computeBaseDir();
-  const rows = await Promise.all(listPairs(base).map((pair) => rowForPair(base, pair)));
+  let rows;
+  try {
+    rows = await Promise.all(listPairs(base).map((pair) => rowForPair(base, pair)));
+  } catch (error) {
+    if (!isRegistryCorruptError(error))
+      throw error;
+    console.error(`\u26A0\uFE0F  pair registry \u4E0D\u53EF\u8BFB\uFF08${error.message}\uFF09\u2014\u2014` + `\u4F4D\u4E8E ${registryPathForNotice(base, error)}\u3002` + `\u964D\u7EA7\u4E3A\u78C1\u76D8\u626B\u63CF\u5217\u51FA ${pairsRootDir(base)} \u4E0B\u7684 pair \u76EE\u5F55\uFF08slot/name/cwd \u7B49\u9700 registry \u7684\u5B57\u6BB5\u663E\u793A\u4E3A -\uFF09\u3002` + `\u4FEE\u590D\u6216\u5220\u9664\u8BE5\u6587\u4EF6\u540E\u53EF\u6062\u590D\u5B8C\u6574\u5217\u8868\uFF1B\u7528 \`abg pairs prune\` \u6E05\u7406\u5B64\u513F\u76EE\u5F55\u3002`);
+    process.exitCode = 2;
+    rows = await collectDiskScanRows(base);
+  }
   const legacy = detectLegacyRootDaemon(base);
   if (legacy) {
     rows.push({
@@ -4232,15 +4949,15 @@ async function collectRows() {
 }
 async function rowForPair(base, pair) {
   const ports = portsForEntry(pair);
-  const stateDir = new StateDirResolver(join14(base, "pairs", pair.pairId));
+  const stateDir = new StateDirResolver(join15(base, "pairs", pair.pairId));
   const lifecycle = new DaemonLifecycle({
     stateDir,
     controlPort: ports.controlPort,
     log: () => {}
   });
-  const [running, status] = await Promise.all([
+  const [running, record] = await Promise.all([
     lifecycle.isHealthy(),
-    Promise.resolve(lifecycle.readStatus())
+    Promise.resolve(lifecycle.readDaemonRecord())
   ]);
   const thread = readRawCurrentThread(stateDir);
   return {
@@ -4251,7 +4968,42 @@ async function rowForPair(base, pair) {
     source: pair.source,
     cwd: pair.cwd,
     running,
-    pid: typeof status?.pid === "number" ? status.pid : null,
+    pid: typeof record?.pid === "number" ? record.pid : null,
+    threadId: thread?.threadId ?? null,
+    threadStatus: thread?.status ?? null,
+    threadUpdatedAt: thread?.updatedAt ?? null
+  };
+}
+async function collectDiskScanRows(base) {
+  const names = listPairDirsSafe2(base);
+  return Promise.all(names.map((name) => rowForDiskScanDir(base, name)));
+}
+function listPairDirsSafe2(base) {
+  try {
+    return listPairDirs(base);
+  } catch {
+    return [];
+  }
+}
+async function rowForDiskScanDir(base, dirName) {
+  const stateDir = new StateDirResolver(join15(base, "pairs", dirName));
+  const record = new DaemonLifecycle({ stateDir, controlPort: 0, log: () => {} }).readDaemonRecord();
+  const ports = {
+    appPort: record?.ports?.appPort ?? 0,
+    proxyPort: record?.ports?.proxyPort ?? 0,
+    controlPort: record?.ports?.controlPort ?? 0
+  };
+  const running = ports.controlPort > 0 ? await new DaemonLifecycle({ stateDir, controlPort: ports.controlPort, log: () => {} }).isHealthy() : false;
+  const thread = readRawCurrentThread(stateDir);
+  return {
+    pairId: dirName,
+    name: "-",
+    slot: null,
+    ports,
+    source: "cwd",
+    cwd: "-",
+    running,
+    pid: typeof record?.pid === "number" ? record.pid : null,
     threadId: thread?.threadId ?? null,
     threadStatus: thread?.status ?? null,
     threadUpdatedAt: thread?.updatedAt ?? null
@@ -4339,20 +5091,20 @@ var DAEMON_STATUS_FETCH_TIMEOUT_MS = 1000;
 import { Database } from "bun:sqlite";
 import {
   copyFileSync,
-  existsSync as existsSync11,
+  existsSync as existsSync14,
   mkdirSync as mkdirSync7,
-  readFileSync as readFileSync11
+  readFileSync as readFileSync12
 } from "fs";
-import { dirname as dirname5, join as join15 } from "path";
+import { dirname as dirname5, join as join16 } from "path";
 function isKickoffText(text) {
   if (!text)
     return false;
   return KICKOFF_FINGERPRINTS.some((fingerprint) => text.includes(fingerprint));
 }
 function extractFirstRealUserMessage(rolloutPath) {
-  if (!existsSync11(rolloutPath))
+  if (!existsSync14(rolloutPath))
     return null;
-  const raw = readFileSync11(rolloutPath, "utf-8");
+  const raw = readFileSync12(rolloutPath, "utf-8");
   for (const line of raw.split(`
 `)) {
     if (!line.trim())
@@ -4374,8 +5126,8 @@ function extractFirstRealUserMessage(rolloutPath) {
 }
 function scanResumePollution(options = {}) {
   const codexHome2 = options.codexHome ?? codexHome();
-  const dbPath = options.dbPath ?? join15(codexHome2, "state_5.sqlite");
-  if (!existsSync11(dbPath)) {
+  const dbPath = options.dbPath ?? join16(codexHome2, "state_5.sqlite");
+  if (!existsSync14(dbPath)) {
     return { codexHome: codexHome2, dbPath, scanned: 0, candidates: [], applied: 0, renamed: 0, deleted: 0 };
   }
   const db = options.apply ? new Database(dbPath) : new Database(dbPath, { readonly: true });
@@ -4468,12 +5220,12 @@ function scanResumePollution(options = {}) {
 }
 function backupCodexStateFiles(dbPath, now = new Date().toISOString()) {
   const safeStamp = now.replace(/[:.]/g, "-");
-  const base = join15(dirname5(dbPath), "agentbridge-backups", `resume-pollution-${safeStamp}`);
+  const base = join16(dirname5(dbPath), "agentbridge-backups", `resume-pollution-${safeStamp}`);
   mkdirSync7(base, { recursive: true });
   for (const path of [dbPath, `${dbPath}-wal`, `${dbPath}-shm`]) {
-    if (!existsSync11(path))
+    if (!existsSync14(path))
       continue;
-    const target = join15(base, path.split("/").pop());
+    const target = join16(base, path.split("/").pop());
     mkdirSync7(dirname5(target), { recursive: true });
     copyFileSync(path, target);
   }
@@ -4519,11 +5271,12 @@ var init_resume_pollution = __esm(() => {
 var exports_doctor = {};
 __export(exports_doctor, {
   runDoctor: () => runDoctor,
-  formatDoctorReport: () => formatDoctorReport
+  formatDoctorReport: () => formatDoctorReport,
+  evaluateArtifactAlignment: () => evaluateArtifactAlignment,
+  describeBuildDrift: () => describeBuildDrift
 });
-import { existsSync as existsSync12, readFileSync as readFileSync12, readdirSync as readdirSync5, realpathSync as realpathSync3, statSync as statSync6 } from "fs";
-import { homedir as homedir6 } from "os";
-import { join as join16 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync13, readdirSync as readdirSync6, realpathSync as realpathSync3, statSync as statSync7 } from "fs";
+import { join as join17 } from "path";
 async function runDoctor(args = []) {
   if (args[0] === "resume-pollution") {
     runResumePollution(args.slice(1));
@@ -4599,6 +5352,7 @@ function runResumePollution(args) {
 }
 async function buildDoctorReport(pair, registered) {
   const cwd = process.cwd();
+  const cli = cliInvocationName();
   const env = inspectAgentBridgeEnv({ cwd, env: process.env });
   const [health, ready] = registered ? await Promise.all([
     fetchDaemonStatus(pair.ports.controlPort, "/healthz"),
@@ -4618,19 +5372,20 @@ async function buildDoctorReport(pair, registered) {
     name: "pair registration",
     status: registered ? "ok" : "warn",
     detail: registered ? pair.manual ? "manual mode (explicit env)" : `registered as ${pair.pairId}` : `not registered yet \u2014 would be ${pair.pairId} (created on first launch)`,
-    hint: registered ? undefined : "\u8BE5\u76EE\u5F55\u8FD8\u6CA1\u6709\u6CE8\u518C\u8FC7 pair\uFF1A\u8FD0\u884C `agentbridge claude` \u5373\u4F1A\u521B\u5EFA\u3002\u4EE5\u4E0B\u68C0\u67E5\u6309\u672A\u542F\u52A8\u72B6\u6001\u89E3\u8BFB\u3002"
+    hint: registered ? undefined : `\u8BE5\u76EE\u5F55\u8FD8\u6CA1\u6709\u6CE8\u518C\u8FC7 pair\uFF1A\u8FD0\u884C \`${cli} claude\` \u5373\u4F1A\u521B\u5EFA\u3002\u4EE5\u4E0B\u68C0\u67E5\u6309\u672A\u542F\u52A8\u72B6\u6001\u89E3\u8BFB\u3002`
   });
   checks.push({
     name: "env",
     status: env.ok ? "ok" : "fail",
     detail: env.ok ? "AgentBridge env matches cwd" : env.reasons.join("; "),
-    hint: env.ok ? undefined : "\u73AF\u5883\u53D8\u91CF\u4E0E\u5F53\u524D\u76EE\u5F55\u4E0D\u5339\u914D\uFF1A\u8BF7\u5728\u6B63\u786E\u7684\u9879\u76EE\u76EE\u5F55\u91CC\u91CD\u65B0\u8FD0\u884C `agentbridge claude`\uFF0C\u4E0D\u8981\u590D\u7528\u5176\u4ED6\u76EE\u5F55\u7684\u4F1A\u8BDD\u73AF\u5883\u3002"
+    hint: env.ok ? undefined : `\u73AF\u5883\u53D8\u91CF\u4E0E\u5F53\u524D\u76EE\u5F55\u4E0D\u5339\u914D\uFF1A\u8BF7\u5728\u6B63\u786E\u7684\u9879\u76EE\u76EE\u5F55\u91CC\u91CD\u65B0\u8FD0\u884C \`${cli} claude\`\uFF0C\u4E0D\u8981\u590D\u7528\u5176\u4ED6\u76EE\u5F55\u7684\u4F1A\u8BDD\u73AF\u5883\u3002`
   });
+  checks.push(configParseabilityCheck(cwd, cli));
   checks.push({
     name: "daemon health",
     status: health ? "ok" : "warn",
     detail: health ? `healthz reachable pid=${health.pid}` : registered ? `no daemon reachable on :${pair.ports.controlPort}` : "n/a \u2014 pair not registered",
-    hint: health ? undefined : "daemon \u672A\u8FD0\u884C\u3002\u8FD0\u884C `agentbridge claude`\uFF08\u6216 `agentbridge codex`\uFF09\u4F1A\u81EA\u52A8\u542F\u52A8\u5B83\u3002"
+    hint: health ? undefined : `daemon \u672A\u8FD0\u884C\u3002\u8FD0\u884C \`${cli} claude\`\uFF08\u6216 \`${cli} codex\`\uFF09\u4F1A\u81EA\u52A8\u542F\u52A8\u5B83\u3002`
   });
   checks.push({
     name: "daemon readiness",
@@ -4638,18 +5393,26 @@ async function buildDoctorReport(pair, registered) {
     detail: ready ? `ready thread=${ready.threadId ?? "none"}` : health ? "readyz is not OK" : "n/a \u2014 daemon not running",
     hint: !ready && health ? "daemon \u5728\u8FD0\u884C\u4F46 codex app-server \u5C1A\u672A\u5C31\u7EEA\uFF1B\u7A0D\u5019\u7247\u523B\u91CD\u8BD5\uFF0C\u6301\u7EED\u4E0D\u5C31\u7EEA\u8BF7\u67E5\u770B\u4E0B\u65B9 daemon log\u3002" : undefined
   });
+  const appServerInfo = health?.appServerInfo ?? null;
+  checks.push({
+    name: "codex app-server",
+    status: health ? "ok" : "skip",
+    detail: !health ? "n/a \u2014 daemon not running" : appServerInfo ? `version=${appServerInfo.version ?? "unknown"}` + (appServerInfo.platformOs ? ` platform=${appServerInfo.platformOs}` : "") : "not captured yet \u2014 connect Codex (initialize handshake) to populate",
+    hint: health && appServerInfo && appServerInfo.version === null ? "app-server \u672A\u8FD4\u56DE\u53EF\u89E3\u6790\u7684\u7248\u672C\u53F7\uFF08userAgent \u5F02\u5E38\uFF09\u3002\u82E5\u521A\u5347\u7EA7\u8FC7 Codex\uFF0C\u8BF7\u6838\u5BF9 codex-adapter \u7684 version-coupling checklist\u3002" : undefined
+  });
+  const drift = buildDrift === true ? describeBuildDrift(health?.build, BUILD_INFO, cli) : null;
   checks.push({
     name: "build drift",
     status: buildDrift === false ? "ok" : buildDrift === true ? "fail" : "skip",
-    detail: buildDrift === false ? `runtime matches launcher ${formatBuildInfo(BUILD_INFO)}` : buildDrift === true ? `runtime ${formatBuildInfo(health?.build)} differs from launcher ${formatBuildInfo(BUILD_INFO)}` : launcherStamped ? "n/a \u2014 daemon not running" : "n/a \u2014 launcher running from source (unstamped)",
-    hint: buildDrift === true ? "daemon \u8FD0\u884C\u7684\u662F\u65E7\u6784\u5EFA\uFF08\u901A\u5E38\u7531\u65E7\u7248 CLI \u6216\u672A\u91CD\u5F00\u7684 Claude Code \u7A97\u53E3\u542F\u52A8\uFF09\u3002" + "\u6CA1\u6709\u8FDB\u884C\u4E2D\u7684 Codex \u4F1A\u8BDD\u65F6\uFF0C\u8FD0\u884C `abg kill` \u540E\u91CD\u65B0 `agentbridge claude` \u5373\u53EF\u5BF9\u9F50\uFF1B" + "\u6709\u6D3B\u8DC3\u4F1A\u8BDD\u5219\u7B49\u6536\u5C3E\u540E\u518D\u91CD\u542F\u2014\u2014\u7248\u672C\u5DEE\u5F02\u4E0D\u4F1A\u5F3A\u6740\u6D3B\u8DC3\u4F1A\u8BDD\uFF0C\u53EF\u4EE5\u7EE7\u7EED\u7528\u3002" : undefined
+    detail: buildDrift === false ? `runtime matches launcher ${formatBuildInfo(BUILD_INFO)}` : drift ? drift.detail : launcherStamped ? "n/a \u2014 daemon not running" : "n/a \u2014 launcher running from source (unstamped)",
+    hint: drift?.hint
   });
   checks.push(artifactAlignmentCheck());
   checks.push({
     name: "current thread",
     status: usableThread ? "ok" : rawThread ? "warn" : registered ? "warn" : "skip",
     detail: usableThread ? `current=${usableThread.threadId}` : rawThread ? rawThread.status === "current" ? `stored ${rawThread.threadId} has no rollout file yet` : `stored ${rawThread.threadId} is still ${rawThread.status} (no first response yet)` : registered ? "no current-thread.json for this pair" : "n/a \u2014 pair not registered",
-    hint: usableThread ? undefined : rawThread ? "\u901A\u5E38\u65E0\u5BB3\uFF1A\u7EBF\u7A0B\u8FD8\u6CA1\u6709\u4EA7\u751F\u9996\u6761\u56DE\u5E94\u3001\u6216 rollout \u6587\u4EF6\u5C1A\u672A\u843D\u76D8\u3002" + "\u4EC5\u5F53 `abg codex`\uFF08resume\uFF09\u5931\u8D25\u65F6\u624D\u9700\u8981\u5904\u7406\uFF1A\u7528 `abg codex --new` \u5F00\u65B0\u7EBF\u7A0B\u3002" : registered ? "\u5C1A\u65E0\u7EBF\u7A0B\u8BB0\u5F55\uFF1A\u8FDE\u63A5 Codex \u540E\u5EFA\u7ACB\u9996\u4E2A\u7EBF\u7A0B\u65F6\u4F1A\u81EA\u52A8\u5199\u5165\uFF0C\u65E0\u9700\u5904\u7406\u3002" : undefined
+    hint: usableThread ? undefined : rawThread ? "\u901A\u5E38\u65E0\u5BB3\uFF1A\u7EBF\u7A0B\u8FD8\u6CA1\u6709\u4EA7\u751F\u9996\u6761\u56DE\u5E94\u3001\u6216 rollout \u6587\u4EF6\u5C1A\u672A\u843D\u76D8\u3002" + `\u4EC5\u5F53 \`${cli} codex\`\uFF08resume\uFF09\u5931\u8D25\u65F6\u624D\u9700\u8981\u5904\u7406\uFF1A\u7528 \`${cli} codex --new\` \u5F00\u65B0\u7EBF\u7A0B\u3002` : registered ? "\u5C1A\u65E0\u7EBF\u7A0B\u8BB0\u5F55\uFF1A\u8FDE\u63A5 Codex \u540E\u5EFA\u7ACB\u9996\u4E2A\u7EBF\u7A0B\u65F6\u4F1A\u81EA\u52A8\u5199\u5165\uFF0C\u65E0\u9700\u5904\u7406\u3002" : undefined
   });
   const pairProxyUrl = `ws://127.0.0.1:${pair.ports.proxyPort}`;
   const managedTuis = listManagedCodexTuiProcesses();
@@ -4666,19 +5429,19 @@ async function buildDoctorReport(pair, registered) {
     name: "codex tui (this pair)",
     status: attachedHere.length > 0 ? "ok" : "warn",
     detail: attachedHere.length > 0 ? `${attachedHere.length} attached to ${pairProxyUrl} (pid ${attachedHere.map((t) => t.pid).join(", ")})` : `no managed Codex TUI attached to this pair's proxy ${pairProxyUrl}`,
-    hint: attachedHere.length > 0 ? undefined : "\u53E6\u5F00\u4E00\u4E2A\u7EC8\u7AEF\u3001\u5728\u540C\u4E00\u76EE\u5F55\u8FD0\u884C `agentbridge codex` \u8FDE\u63A5\u672C pair\u3002"
+    hint: attachedHere.length > 0 ? undefined : `\u53E6\u5F00\u4E00\u4E2A\u7EC8\u7AEF\u3001\u5728\u540C\u4E00\u76EE\u5F55\u8FD0\u884C \`${cli} codex\` \u8FDE\u63A5\u672C pair\u3002`
   });
   checks.push({
     name: "codex tui (other pairs)",
     status: attachedElsewhere.length > 0 ? "warn" : "ok",
     detail: attachedElsewhere.length > 0 ? `${attachedElsewhere.length} managed Codex TUI(s) attached to a DIFFERENT pair/proxy \u2014 likely started from another cwd, will not bridge here: ` + attachedElsewhere.map((t) => `pid ${t.pid}\u2192${t.remoteUrl ?? "?"}`).join(", ") : "no managed Codex TUI attached to another pair",
-    hint: attachedElsewhere.length > 0 ? "\u8FD9\u4E9B TUI \u5C5E\u4E8E\u5176\u4ED6\u76EE\u5F55\u7684 pair\uFF0C\u4E0D\u5F71\u54CD\u672C pair\uFF1B\u5B83\u4EEC\u4E0D\u4F1A\u6865\u63A5\u5230\u8FD9\u91CC\u3002\u5982\u4E0D\u518D\u9700\u8981\uFF0C\u53BB\u5BF9\u5E94\u76EE\u5F55\u8FD0\u884C `abg kill`\u3002" : undefined
+    hint: attachedElsewhere.length > 0 ? `\u8FD9\u4E9B TUI \u5C5E\u4E8E\u5176\u4ED6\u76EE\u5F55\u7684 pair\uFF0C\u4E0D\u5F71\u54CD\u672C pair\uFF1B\u5B83\u4EEC\u4E0D\u4F1A\u6865\u63A5\u5230\u8FD9\u91CC\u3002\u5982\u4E0D\u518D\u9700\u8981\uFF0C\u53BB\u5BF9\u5E94\u76EE\u5F55\u8FD0\u884C \`${cli} kill\`\u3002` : undefined
   });
   for (const [name, path] of [
     ["daemon log", pair.stateDir.logFile],
     ["codex wrapper log", pair.stateDir.codexWrapperLogFile]
   ]) {
-    checks.push(logCheck(name, path));
+    checks.push(logCheck(name, path, cli));
   }
   return {
     cwd,
@@ -4699,62 +5462,126 @@ async function buildDoctorReport(pair, registered) {
     checks
   };
 }
+function describeBuildDrift(runtime, launcher, cli = "abg") {
+  const basis = runtimeContractComparisonBasis(runtime, launcher);
+  const baseDetail = `runtime ${formatBuildInfo(runtime)} differs from launcher ${formatBuildInfo(launcher)}`;
+  const baseHint = "daemon \u8FD0\u884C\u7684\u662F\u65E7\u6784\u5EFA\uFF08\u901A\u5E38\u7531\u65E7\u7248 CLI \u6216\u672A\u91CD\u5F00\u7684 Claude Code \u7A97\u53E3\u542F\u52A8\uFF09\u3002" + `\u6CA1\u6709\u8FDB\u884C\u4E2D\u7684 Codex \u4F1A\u8BDD\u65F6\uFF0C\u8FD0\u884C \`${cli} kill\` \u540E\u91CD\u65B0 \`${cli} claude\` \u5373\u53EF\u5BF9\u9F50\uFF1B` + "\u6709\u6D3B\u8DC3\u4F1A\u8BDD\u5219\u7B49\u6536\u5C3E\u540E\u518D\u91CD\u542F\u2014\u2014\u7248\u672C\u5DEE\u5F02\u4E0D\u4F1A\u5F3A\u6740\u6D3B\u8DC3\u4F1A\u8BDD\uFF0C\u53EF\u4EE5\u7EE7\u7EED\u7528\u3002";
+  if (basis === "codeHash") {
+    return { detail: `${baseDetail} [compared by codeHash \u2014 real code difference]`, hint: baseHint };
+  }
+  return {
+    detail: `${baseDetail} [compared by commit stamp \u2014 legacy build without codeHash]`,
+    hint: baseHint + "\uFF08\u6CE8\u610F\uFF1A\u672C\u5224\u5B9A\u57FA\u4E8E commit stamp \u53E3\u5F84\u2014\u2014\u6709\u4E00\u4FA7\u662F\u7F3A codeHash \u7684\u65E7\u6784\u5EFA\uFF1Bsquash \u5408\u5E76\u4F1A\u8BA9 stamp \u6EDE\u540E\u4E00\u683C\uFF0C" + "\u6E90\u7801\u4E00\u81F4\u65F6\u4E5F\u53EF\u80FD\u8BEF\u62A5\u3002\u5347\u7EA7\u4E24\u7AEF\u5230\u5E26 codeHash \u7684\u6784\u5EFA\u540E\u5C06\u6309\u4EE3\u7801\u5185\u5BB9\u5224\u5B9A\u3002\uFF09"
+  };
+}
+function isUsableCodeHash(hash) {
+  return typeof hash === "string" && hash.length > 0 && hash !== "source";
+}
+function evaluateArtifactAlignment(stamps) {
+  if (stamps.length < 2) {
+    return {
+      name: "artifact alignment",
+      status: "skip",
+      detail: "n/a \u2014 fewer than two stamped artifacts found"
+    };
+  }
+  if (stamps.every((stamp) => isUsableCodeHash(stamp.codeHash))) {
+    const rendered2 = stamps.map((stamp) => `${stamp.label}=${stamp.codeHash}`).join(", ");
+    if (new Set(stamps.map((stamp) => stamp.codeHash)).size === 1) {
+      return { name: "artifact alignment", status: "ok", detail: `codeHash basis: ${rendered2}` };
+    }
+    return {
+      name: "artifact alignment",
+      status: "fail",
+      detail: `deployed artifacts contain DIFFERENT code (codeHash basis): ${rendered2}`,
+      hint: "\u90E8\u7F72\u7269\u4EE3\u7801\u5206\u88C2\u4F1A\u5BFC\u81F4\u4E92\u76F8\u66FF\u6362 daemon\uFF08\u6740\u6389\u6D3B\u4F1A\u8BDD\uFF09\u3002\u5728\u4ED3\u5E93\u76EE\u5F55\u8FD0\u884C `bun run install:global` " + "\u4E00\u6B21\u6027\u5BF9\u9F50\u5168\u5C40 CLI \u4E0E\u63D2\u4EF6\u7F13\u5B58\uFF0C\u7136\u540E\u5173\u95ED\u5E76\u91CD\u5F00\u4ECD\u5728\u4F7F\u7528\u65E7\u63D2\u4EF6\u7684 Claude Code \u7A97\u53E3\u3002"
+    };
+  }
+  const rendered = stamps.map((stamp) => `${stamp.label}=${stamp.commit}`).join(", ");
+  if (new Set(stamps.map((stamp) => stamp.commit)).size === 1) {
+    return {
+      name: "artifact alignment",
+      status: "ok",
+      detail: `legacy commit-stamp basis: ${rendered}`
+    };
+  }
+  return {
+    name: "artifact alignment",
+    status: "fail",
+    detail: `deployed artifacts are at DIFFERENT builds (legacy commit-stamp basis): ${rendered}`,
+    hint: "\uFF08stamp \u53E3\u5F84\uFF1A\u5B58\u5728\u7F3A codeHash \u7684\u65E7\u90E8\u7F72\u7269\uFF0C\u4E14 squash \u5408\u5E76\u4F1A\u8BA9 stamp \u6EDE\u540E\u4E00\u683C\uFF0C\u6E90\u7801\u4E00\u81F4\u65F6\u4E5F\u53EF\u80FD\u8BEF\u62A5\u3002\uFF09" + "\u90E8\u7F72\u7269\u7248\u672C\u5206\u88C2\u4F1A\u5BFC\u81F4\u4E92\u76F8\u66FF\u6362 daemon\uFF08\u6740\u6389\u6D3B\u4F1A\u8BDD\uFF09\u3002\u5728\u4ED3\u5E93\u76EE\u5F55\u8FD0\u884C `bun run install:global` " + "\u4E00\u6B21\u6027\u5BF9\u9F50\u5168\u5C40 CLI \u4E0E\u63D2\u4EF6\u7F13\u5B58\u5E76\u5347\u7EA7\u5230\u5E26 codeHash \u7684\u6784\u5EFA\uFF0C\u7136\u540E\u5173\u95ED\u5E76\u91CD\u5F00\u4ECD\u5728\u4F7F\u7528\u65E7\u63D2\u4EF6\u7684 Claude Code \u7A97\u53E3\uFF1B" + "\u5BF9\u9F50\u540E\u6B64\u68C0\u67E5\u5C06\u6309\u4EE3\u7801\u5185\u5BB9\uFF08codeHash\uFF09\u5224\u5B9A\uFF0Cstamp \u6EDE\u540E\u4E0D\u518D\u8BEF\u62A5\u3002"
+  };
+}
 function artifactAlignmentCheck() {
   const stamps = [];
   if (BUILD_INFO.commit !== "source") {
-    stamps.push({ label: `launcher(${BUILD_INFO.bundle})`, commit: BUILD_INFO.commit });
+    stamps.push({
+      label: `launcher(${BUILD_INFO.bundle})`,
+      commit: BUILD_INFO.commit,
+      codeHash: hasValidCodeHash(BUILD_INFO) ? BUILD_INFO.codeHash ?? null : null
+    });
   }
   const bin = Bun.which("agentbridge") ?? Bun.which("abg");
   if (bin) {
     try {
-      const commit = extractBundleCommit(realpathSync3(bin));
-      if (commit)
-        stamps.push({ label: "global-cli", commit });
+      const stamp = extractBundleStamp(realpathSync3(bin));
+      if (stamp)
+        stamps.push({ label: "global-cli", ...stamp });
     } catch {}
   }
-  const cacheRoot = join16(homedir6(), ".claude", "plugins", "cache", "agentbridge", "agentbridge");
+  const cacheRoot = pluginCacheRoot();
   try {
-    for (const version of readdirSync5(cacheRoot)) {
-      const commit = extractBundleCommit(join16(cacheRoot, version, "server", "daemon.js"));
-      if (commit)
-        stamps.push({ label: `plugin-cache@${version}`, commit });
+    for (const version of readdirSync6(cacheRoot)) {
+      const stamp = extractBundleStamp(join17(cacheRoot, version, "server", "daemon.js"));
+      if (stamp)
+        stamps.push({ label: `plugin-cache@${version}`, ...stamp });
     }
   } catch {}
-  const repoBundle = join16(process.cwd(), "plugins", "agentbridge", "server", "daemon.js");
-  if (existsSync12(repoBundle)) {
-    const commit = extractBundleCommit(repoBundle);
-    if (commit)
-      stamps.push({ label: "repo-bundle", commit });
+  const repoBundle = join17(process.cwd(), "plugins", "agentbridge", "server", "daemon.js");
+  if (existsSync15(repoBundle)) {
+    const stamp = extractBundleStamp(repoBundle);
+    if (stamp)
+      stamps.push({ label: "repo-bundle", ...stamp });
   }
-  if (stamps.length < 2) {
+  return evaluateArtifactAlignment(stamps);
+}
+function extractBundleStamp(path) {
+  try {
+    const text = readFileSync13(path, "utf-8");
+    const commit = text.match(/commit:\s*defineString\("([^"]+)",\s*"source"\)/)?.[1] ?? null;
+    if (!commit)
+      return null;
+    const codeHash = text.match(/codeHash:\s*defineString\("([^"]+)",\s*"source"\)/)?.[1] ?? null;
+    return { commit, codeHash };
+  } catch {
+    return null;
+  }
+}
+function configParseabilityCheck(cwd, cli) {
+  const desc = new ConfigService(cwd).describeConfig();
+  if (desc.state === "absent") {
     return {
-      name: "artifact alignment",
-      status: "skip",
-      detail: "n/a \u2014 fewer than two stamped artifacts found"
+      name: "config.json",
+      status: "ok",
+      detail: `no project config at ${desc.path} \u2014 built-in defaults in effect`
     };
   }
-  const commits = new Set(stamps.map((s) => s.commit));
-  const rendered = stamps.map((s) => `${s.label}=${s.commit}`).join(", ");
-  if (commits.size === 1) {
-    return { name: "artifact alignment", status: "ok", detail: rendered };
+  if (desc.state === "corrupt") {
+    return {
+      name: "config.json",
+      status: "warn",
+      detail: `unparseable at ${desc.path} (${desc.reason}) \u2014 custom thresholds NOT in effect, using defaults`,
+      hint: "config.json \u635F\u574F\u6216\u5B57\u6BB5\u7C7B\u578B\u9519\u8BEF\uFF1Abridge \u5DF2\u56DE\u9000\u5230\u9ED8\u8BA4\u9608\u503C\uFF0C\u4F60\u7684\u81EA\u5B9A\u4E49 budget/idle \u8BBE\u7F6E\u672A\u751F\u6548\u3002" + `\u4FEE\u6B63\u8BE5\u6587\u4EF6\u7684 JSON \u8BED\u6CD5/\u5B57\u6BB5\u7C7B\u578B\u540E\u91CD\u542F \`${cli} claude\` \u5373\u53EF\u91CD\u65B0\u751F\u6548\u3002`
+    };
   }
   return {
-    name: "artifact alignment",
-    status: "fail",
-    detail: `deployed artifacts are at DIFFERENT builds: ${rendered}`,
-    hint: "\u90E8\u7F72\u7269\u7248\u672C\u5206\u88C2\u4F1A\u5BFC\u81F4\u4E92\u76F8\u66FF\u6362 daemon\uFF08\u6740\u6389\u6D3B\u4F1A\u8BDD\uFF09\u3002\u5728\u4ED3\u5E93\u76EE\u5F55\u8FD0\u884C `bun run install:global` " + "\u4E00\u6B21\u6027\u5BF9\u9F50\u5168\u5C40 CLI \u4E0E\u63D2\u4EF6\u7F13\u5B58\uFF0C\u7136\u540E\u5173\u95ED\u5E76\u91CD\u5F00\u4ECD\u5728\u4F7F\u7528\u65E7\u63D2\u4EF6\u7684 Claude Code \u7A97\u53E3\u3002"
+    name: "config.json",
+    status: "ok",
+    detail: desc.customValues ? `parsed at ${desc.path} \u2014 custom values in effect` : `parsed at ${desc.path} \u2014 all values match defaults`
   };
 }
-function extractBundleCommit(path) {
-  try {
-    const match = readFileSync12(path, "utf-8").match(/commit:\s*defineString\("([^"]+)",\s*"source"\)/);
-    return match ? match[1] : null;
-  } catch {
-    return null;
-  }
-}
-function logCheck(name, path) {
-  if (!existsSync12(path)) {
+function logCheck(name, path, cli) {
+  if (!existsSync15(path)) {
     return {
       name,
       status: "warn",
@@ -4762,13 +5589,13 @@ function logCheck(name, path) {
       hint: "\u65E5\u5FD7\u4F1A\u5728\u76F8\u5E94\u8FDB\u7A0B\u9996\u6B21\u542F\u52A8\u65F6\u521B\u5EFA\uFF1B\u8FDB\u7A0B\u4ECE\u672A\u542F\u52A8\u8FC7\u65F6\u8FD9\u662F\u6B63\u5E38\u7684\u3002"
     };
   }
-  const stat = statSync6(path);
+  const stat = statSync7(path);
   if (stat.size > LARGE_LOG_WARN_BYTES) {
     return {
       name,
       status: "warn",
       detail: `${path} (${stat.size} bytes, oversized; stop the pair, rebuild/reinstall, then rotate or remove this log)`,
-      hint: "\u65E5\u5FD7\u8FC7\u5927\uFF1A`abg kill` \u505C\u6B62 pair \u540E\u5220\u9664\u8BE5\u6587\u4EF6\u518D\u91CD\u542F\u5373\u53EF\u3002"
+      hint: `\u65E5\u5FD7\u8FC7\u5927\uFF1A\`${cli} kill\` \u505C\u6B62 pair \u540E\u5220\u9664\u8BE5\u6587\u4EF6\u518D\u91CD\u542F\u5373\u53EF\u3002`
     };
   }
   return { name, status: "ok", detail: `${path} (${stat.size} bytes)` };
@@ -4804,7 +5631,10 @@ function printDoctorReport(report) {
 }
 var LARGE_LOG_WARN_BYTES;
 var init_doctor = __esm(() => {
+  init_plugin_cache();
   init_build_info();
+  init_cli_invocation();
+  init_config_service();
   init_env_guard();
   init_pair_resolver();
   init_thread_state();
@@ -4836,6 +5666,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`);
@@ -4902,6 +5735,7 @@ __export(exports_budget, {
 });
 async function runBudget(args) {
   const json = args.includes("--json");
+  const cli = cliInvocationName();
   const { pairFlag } = parsePairFlag(args.filter((arg) => arg !== "--json"));
   let resolution;
   try {
@@ -4921,7 +5755,7 @@ async function runBudget(args) {
     if (json) {
       console.log(JSON.stringify({ ok: false, error: "pair_not_registered" }));
     } else {
-      console.error("\u8BE5\u76EE\u5F55\u5C1A\u65E0 pair\uFF0C\u5148\u8FD0\u884C abg claude");
+      console.error(`\u8BE5\u76EE\u5F55\u5C1A\u65E0 pair\uFF0C\u5148\u8FD0\u884C ${cli} claude`);
     }
     process.exit(1);
     return;
@@ -4931,7 +5765,7 @@ async function runBudget(args) {
     if (json) {
       console.log(JSON.stringify({ ok: false, pairId: pair.pairId, error: "daemon_unreachable" }));
     } else {
-      console.error(`AgentBridge daemon \u672A\u8FD0\u884C\uFF08pair ${pair.pairId}\uFF0C\u63A7\u5236\u7AEF\u53E3 ${pair.ports.controlPort}\uFF09\u3002` + "\u5148\u8FD0\u884C `abg claude` \u542F\u52A8\u4F1A\u8BDD\u3002");
+      console.error(`AgentBridge daemon \u672A\u8FD0\u884C\uFF08pair ${pair.pairId}\uFF0C\u63A7\u5236\u7AEF\u53E3 ${pair.ports.controlPort}\uFF09\u3002` + `\u5148\u8FD0\u884C \`${cli} claude\` \u542F\u52A8\u4F1A\u8BDD\u3002`);
     }
     process.exit(1);
   }
@@ -4943,10 +5777,165 @@ async function runBudget(args) {
   console.log(status.budget ? renderBudgetSnapshot(status.budget) : BUDGET_UNAVAILABLE_TEXT);
 }
 var init_budget = __esm(() => {
+  init_cli_invocation();
   init_pair_resolver();
   init_render();
 });
 
+// src/cli/logs.ts
+var exports_logs = {};
+__export(exports_logs, {
+  tailLines: () => tailLines,
+  runLogs: () => runLogs,
+  parseLogsArgs: () => parseLogsArgs,
+  followLog: () => followLog
+});
+import { existsSync as existsSync16, readFileSync as readFileSync14 } from "fs";
+import { spawn as spawn4 } from "child_process";
+function parseLogsArgs(args) {
+  let codex = false;
+  let follow = false;
+  let lines = DEFAULT_LINES;
+  for (let i = 0;i < args.length; i++) {
+    const a = args[i];
+    if (a === "--codex") {
+      codex = true;
+      continue;
+    }
+    if (a === "-f" || a === "--follow") {
+      follow = true;
+      continue;
+    }
+    if (a === "-n" || a === "--lines") {
+      const next = args[i + 1];
+      if (next === undefined) {
+        throw new Error(`${a} requires a positive integer (e.g. ${a} 200)`);
+      }
+      lines = parsePositiveInt(next, a);
+      i++;
+      continue;
+    }
+    if (a.startsWith("-n")) {
+      lines = parsePositiveInt(a.slice(2), "-n");
+      continue;
+    }
+    if (a.startsWith("--lines=")) {
+      lines = parsePositiveInt(a.slice("--lines=".length), "--lines");
+      continue;
+    }
+    throw new Error(`Unknown logs flag: ${a}`);
+  }
+  return { codex, follow, lines };
+}
+function parsePositiveInt(raw, flag) {
+  if (!/^\d+$/.test(raw)) {
+    throw new Error(`${flag} must be a positive integer, got "${raw}"`);
+  }
+  const n = Number.parseInt(raw, 10);
+  if (!Number.isInteger(n) || n <= 0) {
+    throw new Error(`${flag} must be a positive integer, got "${raw}"`);
+  }
+  return n;
+}
+function tailLines(text, count) {
+  const body = text.endsWith(`
+`) ? text.slice(0, -1) : text;
+  if (body.length === 0)
+    return [];
+  const all = body.split(`
+`);
+  return all.length <= count ? all : all.slice(all.length - count);
+}
+async function runLogs(args) {
+  const { pairFlag } = parsePairFlag(args);
+  const rest = stripPairTokens(args);
+  let options;
+  try {
+    options = parseLogsArgs(rest);
+  } catch (err) {
+    console.error(`[agentbridge] ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+    return;
+  }
+  let resolution;
+  try {
+    resolution = resolvePairReadOnly(pairFlag);
+  } catch (err) {
+    console.error(`[agentbridge] ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+    return;
+  }
+  const { pair } = resolution;
+  const logPath = options.codex ? pair.stateDir.codexWrapperLogFile : pair.stateDir.logFile;
+  const logLabel = options.codex ? "codex wrapper log" : "daemon log";
+  if (!existsSync16(logPath)) {
+    const which = options.codex ? "codex wrapper log" : "daemon log";
+    console.error(`no ${which} for pair ${pair.name} yet \u2014 start it with \`abg claude\` (${logPath})`);
+    process.exit(1);
+    return;
+  }
+  if (options.follow) {
+    await followLog(logPath, options.lines);
+    return;
+  }
+  printTail(logPath, options.lines, logLabel, pair.name);
+}
+function printTail(logPath, count, label, pairName) {
+  let text;
+  try {
+    text = readFileSync14(logPath, "utf8");
+  } catch (err) {
+    console.error(`[agentbridge] failed to read ${label} for pair ${pairName}: ` + `${err instanceof Error ? err.message : String(err)} (${logPath})`);
+    process.exit(1);
+    return;
+  }
+  const lines = tailLines(text, count);
+  for (const line of lines)
+    console.log(line);
+}
+function followLog(logPath, count) {
+  return new Promise((resolvePromise) => {
+    const child = spawn4("tail", ["-f", "-n", String(count), logPath], {
+      stdio: "inherit"
+    });
+    child.on("error", (err) => {
+      console.error(`[agentbridge] failed to follow log: ${err.message}`);
+      process.exit(1);
+    });
+    child.on("exit", (code, signal) => {
+      if (signal === "SIGINT" || signal === "SIGTERM") {
+        resolvePromise();
+        return;
+      }
+      if (code != null && code !== 0) {
+        process.exit(code);
+        return;
+      }
+      resolvePromise();
+    });
+  });
+}
+function stripPairTokens(args) {
+  const out = [];
+  for (let i = 0;i < args.length; i++) {
+    const a = args[i];
+    if (a === "--pair") {
+      const next = args[i + 1];
+      if (next !== undefined && !next.startsWith("-"))
+        i++;
+      continue;
+    }
+    if (a.startsWith("--pair="))
+      continue;
+    out.push(a);
+  }
+  return out;
+}
+var DEFAULT_LINES = 100;
+var init_logs = __esm(() => {
+  init_pair_resolver();
+});
+
 // src/cli.ts
 function parseTopLevel(args) {
   const pairTokens = [];
@@ -5019,6 +6008,10 @@ async function main(command, restArgs) {
       const { runBudget: runBudget2 } = await Promise.resolve().then(() => (init_budget(), exports_budget));
       await runBudget2(restArgs);
       break;
+    case "logs":
+      const { runLogs: runLogs2 } = await Promise.resolve().then(() => (init_logs(), exports_logs));
+      await runLogs2(restArgs);
+      break;
     case "--help":
     case "-h":
     case undefined:
@@ -5035,6 +6028,7 @@ async function main(command, restArgs) {
   }
 }
 function printHelp() {
+  const cli = cliInvocationName();
   console.log(`
 AgentBridge \u2014 Multi-agent collaboration bridge
 
@@ -5052,11 +6046,15 @@ Commands:
                      No target: print resume commands for this directory's last
                      Claude session + this pair's current Codex thread.
                      With target: resume that side directly.
-  pairs [rm <name|id> | prune [--dry-run]]
-                     List pairs; remove one (rm), or delete orphan state dirs (prune)
+  pairs [rm <name|id> | prune [--apply]]
+                     List pairs; remove one (rm), or reclaim orphan dirs + stranded
+                     entries (prune previews by default; --apply to delete)
   doctor [--json]    Diagnose env, daemon, build drift, logs, and current thread
   doctor resume-pollution [--apply]  Find/fix old AgentBridge kickoff metadata
   budget [--json]    Show both agents' subscription quota snapshot (5h/weekly, drift, pause state)
+  logs [--codex] [-f] [-n N]
+                     Tail this pair's daemon log (or the codex wrapper log with
+                     --codex). -n N: last N lines (default 100). -f: follow/stream.
   kill [all | --all | --pair <name|id>]
                      Stop this directory's pairs (default), every pair (all/--all), or one (--pair)
 
@@ -5082,26 +6080,30 @@ Multi-pair:
   contesting it \u2014 pick another --pair name (or kill the live one first).
 
 Examples:
-  abg init                     # First-time setup
-  abg claude                   # Start the "main" pair for this directory
-  abg codex                    # Connect Codex to this directory's "main" pair
-  abg resume                   # Print resume commands for both sides
-  abg resume claude            # Resume the last Claude Code session here
-  abg resume codex             # Resume this pair's current Codex thread
-  abg claude --safe            # One launch without the max-permission default
-  abg --pair work claude       # Start a named pair "work" (this directory)
-  abg --pair work codex        # Connect Codex to the "work" pair
-  abg --pair review claude     # A second, parallel pair
-  abg pairs                    # List all pairs and their ports/status
-  abg pairs --threads          # Include current thread mapping
-  abg doctor --json            # Emit a structured diagnostics report
-  abg pairs rm work            # Stop this directory's "work" pair and free its slot
-  abg pairs rm work-1a2b3c4d   # ...or by its full id (from that pair's directory)
-  abg pairs prune --dry-run    # Preview orphan pair dirs (no registry entry, not live)
-  abg pairs prune              # ...delete those orphan state directories
-  abg --pair work kill         # Stop only this directory's "work" pair
-  abg kill                     # Stop this directory's pairs (+ any legacy-root daemon)
-  abg kill all                 # Stop every pair in every directory (+ legacy-root)
+  ${cli} init                     # First-time setup
+  ${cli} claude                   # Start the "main" pair for this directory
+  ${cli} codex                    # Connect Codex to this directory's "main" pair
+  ${cli} resume                   # Print resume commands for both sides
+  ${cli} resume claude            # Resume the last Claude Code session here
+  ${cli} resume codex             # Resume this pair's current Codex thread
+  ${cli} claude --safe            # One launch without the max-permission default
+  ${cli} --pair work claude       # Start a named pair "work" (this directory)
+  ${cli} --pair work codex        # Connect Codex to the "work" pair
+  ${cli} --pair review claude     # A second, parallel pair
+  ${cli} pairs                    # List all pairs and their ports/status
+  ${cli} pairs --threads          # Include current thread mapping
+  ${cli} doctor --json            # Emit a structured diagnostics report
+  ${cli} logs                     # Tail the last 100 lines of this pair's daemon log
+  ${cli} logs -f -n 200           # Follow the log, starting from the last 200 lines
+  ${cli} logs --codex             # Tail the codex wrapper log instead
+  ${cli} --pair work logs         # Tail the "work" pair's daemon log
+  ${cli} pairs rm work            # Stop this directory's "work" pair and free its slot
+  ${cli} pairs rm work-1a2b3c4d   # ...or by its full id (from that pair's directory)
+  ${cli} pairs prune              # Preview reclaimable: orphan dirs + stranded entries (cwd-gone, dead, >1d)
+  ${cli} pairs prune --apply      # ...actually delete the previewed dirs + entries
+  ${cli} --pair work kill         # Stop only this directory's "work" pair
+  ${cli} kill                     # Stop this directory's pairs (+ any legacy-root daemon)
+  ${cli} kill all                 # Stop every pair in every directory (+ legacy-root)
 `.trim());
 }
 function printVersion() {
@@ -5114,9 +6116,10 @@ function printVersion() {
 }
 var MARKETPLACE_NAME = "agentbridge", PLUGIN_NAME = "agentbridge", REFRESH_COMMANDS, NOTIFY_COMMANDS, PAIR_AWARE_COMMANDS;
 var init_cli = __esm(() => {
+  init_cli_invocation();
   REFRESH_COMMANDS = new Set(["claude", "codex", "resume"]);
   NOTIFY_COMMANDS = new Set(["claude", "codex", "init", "dev", "resume"]);
-  PAIR_AWARE_COMMANDS = new Set(["claude", "codex", "kill", "doctor", "budget", "resume"]);
+  PAIR_AWARE_COMMANDS = new Set(["claude", "codex", "kill", "doctor", "budget", "resume", "logs"]);
   if (import.meta.main) {
     const { command, restArgs } = parseTopLevel(process.argv.slice(2));
     main(command, restArgs).catch((err) => {
@@ -5129,6 +6132,9 @@ init_cli();
 
 export {
   parseTopLevel,
+  REFRESH_COMMANDS,
   PLUGIN_NAME,
+  PAIR_AWARE_COMMANDS,
+  NOTIFY_COMMANDS,
   MARKETPLACE_NAME
 };