@raysonmeng/agentbridge 0.1.5 → 0.1.6

package/dist/cli.js

@@ -20,16 +20,46 @@ var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 // src/config-service.ts
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
 import { join } from "path";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeInteger(value, fallback) {
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (typeof value === "string") {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed))
+      return parsed;
+  }
+  return fallback;
+}
+function normalizeConfig(raw) {
+  if (!isRecord(raw))
+    return null;
+  const config = raw;
+  const codex = isRecord(config.codex) ? config.codex : {};
+  const daemon = isRecord(config.daemon) ? config.daemon : {};
+  const turnCoordination = isRecord(config.turnCoordination) ? config.turnCoordination : {};
+  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)
+    },
+    turnCoordination: {
+      attentionWindowSeconds: normalizeInteger(turnCoordination.attentionWindowSeconds, DEFAULT_CONFIG.turnCoordination.attentionWindowSeconds)
+    },
+    idleShutdownSeconds: normalizeInteger(config.idleShutdownSeconds, DEFAULT_CONFIG.idleShutdownSeconds)
+  };
+}
 
 class ConfigService {
   configDir;
   configPath;
-  collaborationPath;
   constructor(projectRoot) {
     const root = projectRoot ?? process.cwd();
     this.configDir = join(root, CONFIG_DIR);
     this.configPath = join(this.configDir, CONFIG_FILE);
-    this.collaborationPath = join(this.configDir, COLLABORATION_FILE);
   }
   hasConfig() {
     return existsSync(this.configPath);
@@ -37,7 +67,7 @@ class ConfigService {
   load() {
     try {
       const raw = readFileSync(this.configPath, "utf-8");
-      return JSON.parse(raw);
+      return normalizeConfig(JSON.parse(raw));
     } catch {
       return null;
     }
@@ -50,17 +80,6 @@ class ConfigService {
     writeFileSync(this.configPath, JSON.stringify(config, null, 2) + `
 `, "utf-8");
   }
-  loadCollaboration() {
-    try {
-      return readFileSync(this.collaborationPath, "utf-8");
-    } catch {
-      return null;
-    }
-  }
-  saveCollaboration(content) {
-    this.ensureConfigDir();
-    writeFileSync(this.collaborationPath, content, "utf-8");
-  }
   initDefaults() {
     this.ensureConfigDir();
     const created = [];
@@ -68,74 +87,34 @@ class ConfigService {
       this.save(DEFAULT_CONFIG);
       created.push(this.configPath);
     }
-    if (!existsSync(this.collaborationPath)) {
-      this.saveCollaboration(DEFAULT_COLLABORATION_MD);
-      created.push(this.collaborationPath);
-    }
     return created;
   }
   get configFilePath() {
     return this.configPath;
   }
-  get collaborationFilePath() {
-    return this.collaborationPath;
-  }
   ensureConfigDir() {
     if (!existsSync(this.configDir)) {
       mkdirSync(this.configDir, { recursive: true });
     }
   }
 }
-var DEFAULT_CONFIG, DEFAULT_COLLABORATION_MD = `# Collaboration Rules
-
-## Roles
-- Claude: Reviewer, Planner, Hypothesis Challenger
-- Codex: Implementer, Executor, Reproducer/Verifier
-
-## Thinking Patterns
-- Analytical/review tasks: Independent Analysis & Convergence
-- Implementation tasks: Architect -> Builder -> Critic
-- Debugging tasks: Hypothesis -> Experiment -> Interpretation
-
-## Communication
-- Use explicit phrases: "My independent view is:", "I agree on:", "I disagree on:", "Current consensus:"
-- Tag messages with [IMPORTANT], [STATUS], or [FYI]
-
-## Review Process
-- Cross-review: author never reviews their own code
-- All changes go through feature/fix branches + PR
-- Merge via squash merge
-
-## Custom Rules
-<!-- Add your project-specific collaboration rules here -->
-`, CONFIG_DIR = ".agentbridge", CONFIG_FILE = "config.json", COLLABORATION_FILE = "collaboration.md";
+var DEFAULT_CONFIG, CONFIG_DIR = ".agentbridge", CONFIG_FILE = "config.json";
 var init_config_service = __esm(() => {
   DEFAULT_CONFIG = {
     version: "1.0",
-    daemon: {
-      port: 4500,
+    codex: {
+      appPort: 4500,
       proxyPort: 4501
     },
-    agents: {
-      claude: {
-        role: "Reviewer, Planner",
-        mode: "push"
-      },
-      codex: {
-        role: "Implementer, Executor"
-      }
-    },
-    markers: ["IMPORTANT", "STATUS", "FYI"],
     turnCoordination: {
-      attentionWindowSeconds: 15,
-      busyGuard: true
+      attentionWindowSeconds: 15
     },
     idleShutdownSeconds: 30
   };
 });
 
 // src/cli/pkg-root.ts
-import { dirname as dirname2, join as join2 } from "path";
+import { dirname, join as join2 } from "path";
 import { existsSync as existsSync2 } from "fs";
 import { execFileSync } from "child_process";
 function findPackageRoot() {
@@ -144,7 +123,7 @@ function findPackageRoot() {
     if (existsSync2(join2(dir, "package.json"))) {
       return dir;
     }
-    const parent = dirname2(dir);
+    const parent = dirname(dir);
     if (parent === dir) {
       throw new Error("Could not find package.json in any parent directory");
     }
@@ -158,13 +137,112 @@ function registerMarketplace(marketplaceRoot) {
 }
 var init_pkg_root = () => {};
 
+// src/marker-section.ts
+function upsertMarkedSection(content, sectionId, section) {
+  const startMarker = MARKER_START(sectionId);
+  const endMarker = MARKER_END(sectionId);
+  const block = `${startMarker}
+${section}
+${endMarker}`;
+  const startIdx = content.indexOf(startMarker);
+  const endIdx = content.indexOf(endMarker);
+  const hasStart = startIdx !== -1;
+  const hasEnd = endIdx !== -1;
+  if (hasStart && hasEnd && startIdx < endIdx) {
+    const before = content.slice(0, startIdx);
+    const after = content.slice(endIdx + endMarker.length);
+    return before + block + after;
+  }
+  if (hasStart || hasEnd) {
+    throw new Error(`Malformed ${sectionId} markers in file (start=${startIdx}, end=${endIdx}). ` + `Please repair the file manually \u2014 remove the stray marker(s) or restore the pair.`);
+  }
+  if (content.trim() === "") {
+    return block + `
+`;
+  }
+  const trimmed = content.endsWith(`
+`) ? content : content + `
+`;
+  return trimmed + `
+` + block + `
+`;
+}
+var MARKER_START = (id) => `<!-- ${id}:start -->`, MARKER_END = (id) => `<!-- ${id}:end -->`;
+
+// src/collaboration-content.ts
+var MARKER_ID = "AgentBridge", CLAUDE_MD_SECTION = `## AgentBridge \u2014 Multi-Agent Collaboration
+
+You are working in a **multi-agent environment** powered by AgentBridge.
+Another AI agent (Codex, by OpenAI) is available in a parallel session on this machine.
+
+### Communication mechanism
+- **Claude \u2192 Codex**: Use the AgentBridge MCP tools (\`reply\` / \`get_messages\`) \u2014 these are yours only.
+- **Codex \u2192 Claude**: Codex has no symmetric tool. The bridge transparently intercepts Codex's normal output and forwards it to you. Messages arrive as push notifications (or via \`get_messages\` in pull mode).
+- If Codex ever complains it can't find a "send-to-Claude" API, remind it that its side is transparent \u2014 it just writes a reply and you'll see it.
+
+### When to collaborate vs. work solo
+- **Collaborate** when the task benefits from a second perspective, parallel execution, or capabilities you lack (e.g., sandboxed code execution, independent verification).
+- **Work solo** for simple, self-contained tasks where the coordination overhead isn't worth it.
+- When in doubt, **propose a task split** to Codex rather than doing everything yourself.
+
+### Capability comparison
+| Capability | Claude (you) | Codex |
+|---|---|---|
+| Architecture & planning | Strong | Moderate |
+| Code review & analysis | Strong | Strong |
+| Sandboxed code execution | No | Yes |
+| File editing & refactoring | Yes (via tools) | Yes (via sandbox) |
+| Web search & docs | Yes | Limited |
+| Independent verification | Cross-review | Reproduce & test |
+
+### How to start collaborating
+1. When you receive a complex task, **proactively propose a division of labor** to Codex via the reply tool.
+2. State what you'll handle and what you'd like Codex to take on.
+3. Ask for Codex's agreement or counter-proposal before proceeding.
+4. After task completion, **cross-review** each other's work.`, AGENTS_MD_SECTION = `## AgentBridge \u2014 Multi-Agent Collaboration
+
+You are working in a **multi-agent environment** powered by AgentBridge.
+Another AI agent (Claude, by Anthropic) is available in a parallel session on this machine.
+
+### Communication mechanism (read this first)
+AgentBridge is a **transparent proxy** on your side. You do **not** have a tool to "send a message to Claude".
+
+- **Codex \u2192 Claude**: Just write your normal response. The bridge intercepts your \`agentMessage\` output and forwards it to Claude automatically. No tool call needed.
+- **Claude \u2192 Codex**: Claude uses its own MCP tools (\`reply\` / \`get_messages\`). Those messages arrive in your session as new user turns \u2014 you'll see them like any other user input.
+
+**Do not** search the AgentBridge source for a Codex-side "send" / "reply" / "sendToClaude" API \u2014 it does not exist, and looking for it wastes turns. If you catch yourself thinking "I need to find how to message Claude", stop and just write your reply as normal text.
+
+### When to collaborate vs. work solo
+- **Collaborate** when the task benefits from a second perspective, parallel execution, or capabilities the other agent has.
+- **Work solo** for simple, self-contained tasks where the coordination overhead isn't worth it.
+- When in doubt, **propose a task split** to Claude rather than doing everything yourself.
+
+### Capability comparison
+| Capability | Codex (you) | Claude |
+|---|---|---|
+| Sandboxed code execution | Yes | No |
+| Reproduce & verify bugs | Strong | Limited |
+| Architecture & planning | Moderate | Strong |
+| Code review & analysis | Strong | Strong |
+| Web search & docs | Limited | Yes |
+| File editing & refactoring | Yes (via sandbox) | Yes (via tools) |
+
+### How to start collaborating
+1. When you receive a complex task, **proactively propose a division of labor** in your response (Claude will receive it).
+2. State what you'll handle and what you'd like Claude to take on.
+3. Ask for Claude's agreement or counter-proposal before proceeding.
+4. After task completion, **cross-review** each other's work.`;
+
 // src/cli/init.ts
 var exports_init = {};
 __export(exports_init, {
+  writeCollaborationSections: () => writeCollaborationSections,
   runInit: () => runInit,
   compareVersions: () => compareVersions
 });
 import { execSync, execFileSync as execFileSync2 } from "child_process";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join3 } from "path";
 async function runInit() {
   console.log(`AgentBridge Init
 `);
@@ -184,6 +262,13 @@ async function runInit() {
     console.log("  Project config already exists, skipping.");
   }
   console.log("");
+  console.log("Writing collaboration sections...");
+  const projectRoot = process.cwd();
+  const collabResults = writeCollaborationSections(projectRoot);
+  for (const result of collabResults) {
+    console.log(`  ${result}`);
+  }
+  console.log("");
   console.log("Installing AgentBridge plugin...");
   try {
     registerMarketplace(findPackageRoot());
@@ -259,6 +344,40 @@ function compareVersions(a, b) {
   }
   return 0;
 }
+function writeCollaborationSections(projectRoot) {
+  const results = [];
+  const files = [
+    { name: "CLAUDE.md", path: join3(projectRoot, "CLAUDE.md"), section: CLAUDE_MD_SECTION },
+    { name: "AGENTS.md", path: join3(projectRoot, "AGENTS.md"), section: AGENTS_MD_SECTION }
+  ];
+  for (const { name, path, section } of files) {
+    let existing = "";
+    try {
+      existing = readFileSync2(path, "utf-8");
+    } catch {}
+    let updated;
+    try {
+      updated = upsertMarkedSection(existing, MARKER_ID, section);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      results.push(`${name}: skipped \u2014 ${msg}`);
+      continue;
+    }
+    if (updated === existing) {
+      results.push(`${name}: unchanged (section already up to date)`);
+      continue;
+    }
+    writeFileSync2(path, updated, "utf-8");
+    if (existing === "") {
+      results.push(`${name}: created with collaboration section`);
+    } else if (existing.includes(`<!-- ${MARKER_ID}:start -->`)) {
+      results.push(`${name}: updated collaboration section`);
+    } else {
+      results.push(`${name}: appended collaboration section`);
+    }
+  }
+  return results;
+}
 var MIN_CLAUDE_VERSION = "2.1.80";
 var init_init = __esm(() => {
   init_config_service();
@@ -367,7 +486,7 @@ var init_dev = __esm(() => {
 
 // src/daemon-lifecycle.ts
 import { spawn, execFileSync as execFileSync4 } from "child_process";
-import { existsSync as existsSync4, readFileSync as readFileSync2, unlinkSync, writeFileSync as writeFileSync2, openSync, closeSync, constants } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync3, unlinkSync, writeFileSync as writeFileSync3, openSync, closeSync, constants } from "fs";
 import { fileURLToPath } from "url";
 
 class DaemonLifecycle {
@@ -455,7 +574,7 @@ class DaemonLifecycle {
   }
   readStatus() {
     try {
-      const raw = readFileSync2(this.stateDir.statusFile, "utf-8");
+      const raw = readFileSync3(this.stateDir.statusFile, "utf-8");
       return JSON.parse(raw);
     } catch {
       return null;
@@ -463,12 +582,12 @@ class DaemonLifecycle {
   }
   writeStatus(status) {
     this.stateDir.ensure();
-    writeFileSync2(this.stateDir.statusFile, JSON.stringify(status, null, 2) + `
+    writeFileSync3(this.stateDir.statusFile, JSON.stringify(status, null, 2) + `
 `, "utf-8");
   }
   readPid() {
     try {
-      const raw = readFileSync2(this.stateDir.pidFile, "utf-8").trim();
+      const raw = readFileSync3(this.stateDir.pidFile, "utf-8").trim();
       if (!raw)
         return null;
       const pid = Number.parseInt(raw, 10);
@@ -479,7 +598,7 @@ class DaemonLifecycle {
   }
   writePid(pid) {
     this.stateDir.ensure();
-    writeFileSync2(this.stateDir.pidFile, `${pid ?? process.pid}
+    writeFileSync3(this.stateDir.pidFile, `${pid ?? process.pid}
 `, "utf-8");
   }
   removePidFile() {
@@ -494,7 +613,7 @@ class DaemonLifecycle {
   }
   markKilled() {
     this.stateDir.ensure();
-    writeFileSync2(this.stateDir.killedFile, `${Date.now()}
+    writeFileSync3(this.stateDir.killedFile, `${Date.now()}
 `, "utf-8");
   }
   clearKilled() {
@@ -532,14 +651,14 @@ class DaemonLifecycle {
     this.stateDir.ensure();
     try {
       const fd = openSync(this.stateDir.lockFile, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY);
-      writeFileSync2(fd, `${process.pid}
+      writeFileSync3(fd, `${process.pid}
 `);
       closeSync(fd);
       return true;
     } catch (err) {
       if (err.code === "EEXIST") {
         try {
-          const holderPid = Number.parseInt(readFileSync2(this.stateDir.lockFile, "utf-8").trim(), 10);
+          const holderPid = Number.parseInt(readFileSync3(this.stateDir.lockFile, "utf-8").trim(), 10);
           if (Number.isFinite(holderPid) && !isProcessAlive(holderPid)) {
             this.log(`Stale lock file from dead process ${holderPid}, removing`);
             this.releaseLock();
@@ -631,7 +750,7 @@ var init_daemon_lifecycle = __esm(() => {
 
 // src/state-dir.ts
 import { mkdirSync as mkdirSync2, existsSync as existsSync5 } from "fs";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 import { homedir as homedir2, platform } from "os";
 
 class StateDirResolver {
@@ -641,10 +760,10 @@ class StateDirResolver {
     if (override) {
       this.stateDir = override;
     } else if (platform() === "darwin") {
-      this.stateDir = join3(homedir2(), "Library", "Application Support", "AgentBridge");
+      this.stateDir = join4(homedir2(), "Library", "Application Support", "AgentBridge");
     } else {
-      const xdgState = process.env.XDG_STATE_HOME ?? join3(homedir2(), ".local", "state");
-      this.stateDir = join3(xdgState, "agentbridge");
+      const xdgState = process.env.XDG_STATE_HOME ?? join4(homedir2(), ".local", "state");
+      this.stateDir = join4(xdgState, "agentbridge");
     }
   }
   ensure() {
@@ -656,25 +775,28 @@ class StateDirResolver {
     return this.stateDir;
   }
   get pidFile() {
-    return join3(this.stateDir, "daemon.pid");
+    return join4(this.stateDir, "daemon.pid");
   }
   get tuiPidFile() {
-    return join3(this.stateDir, "codex-tui.pid");
+    return join4(this.stateDir, "codex-tui.pid");
   }
   get lockFile() {
-    return join3(this.stateDir, "daemon.lock");
+    return join4(this.stateDir, "daemon.lock");
   }
   get statusFile() {
-    return join3(this.stateDir, "status.json");
+    return join4(this.stateDir, "status.json");
   }
   get portsFile() {
-    return join3(this.stateDir, "ports.json");
+    return join4(this.stateDir, "ports.json");
   }
   get logFile() {
-    return join3(this.stateDir, "agentbridge.log");
+    return join4(this.stateDir, "agentbridge.log");
+  }
+  get codexWrapperLogFile() {
+    return join4(this.stateDir, "codex-wrapper.log");
   }
   get killedFile() {
-    return join3(this.stateDir, "killed");
+    return join4(this.stateDir, "killed");
   }
 }
 var init_state_dir = () => {};
@@ -744,13 +866,88 @@ var init_claude = __esm(() => {
   OWNED_FLAGS = ["--channels", "--dangerously-load-development-channels"];
 });
 
+// src/stderr-ring-buffer.ts
+class StderrRingBuffer {
+  maxBytes;
+  chunks = [];
+  bytes = 0;
+  constructor(maxBytes = DEFAULT_MAX_BYTES) {
+    this.maxBytes = maxBytes;
+    if (maxBytes <= 0) {
+      throw new Error("StderrRingBuffer maxBytes must be positive");
+    }
+  }
+  append(chunk) {
+    if (chunk.length === 0)
+      return;
+    if (chunk.length >= this.maxBytes) {
+      this.chunks = [chunk.subarray(chunk.length - this.maxBytes)];
+      this.bytes = this.maxBytes;
+      return;
+    }
+    this.chunks.push(chunk);
+    this.bytes += chunk.length;
+    while (this.bytes > this.maxBytes && this.chunks.length > 0) {
+      const head = this.chunks[0];
+      const overflow = this.bytes - this.maxBytes;
+      if (head.length <= overflow) {
+        this.chunks.shift();
+        this.bytes -= head.length;
+      } else {
+        this.chunks[0] = head.subarray(overflow);
+        this.bytes -= overflow;
+      }
+    }
+  }
+  snapshot() {
+    return Buffer.concat(this.chunks, this.bytes);
+  }
+  toString(encoding = "utf-8") {
+    return this.snapshot().toString(encoding);
+  }
+  get byteLength() {
+    return this.bytes;
+  }
+}
+var DEFAULT_MAX_BYTES;
+var init_stderr_ring_buffer = __esm(() => {
+  DEFAULT_MAX_BYTES = 64 * 1024;
+});
+
 // src/cli/codex.ts
 var exports_codex = {};
 __export(exports_codex, {
   runCodex: () => runCodex
 });
 import { spawn as spawn3, execSync as execSync2 } from "child_process";
-import { openSync as openSync2, writeSync, closeSync as closeSync2, writeFileSync as writeFileSync3, unlinkSync as unlinkSync2 } from "fs";
+import {
+  openSync as openSync2,
+  writeSync,
+  closeSync as closeSync2,
+  writeFileSync as writeFileSync4,
+  unlinkSync as unlinkSync2,
+  appendFileSync,
+  existsSync as existsSync6,
+  mkdirSync as mkdirSync3
+} from "fs";
+import { dirname as dirname2 } from "path";
+function appendWrapperLog(path, entry) {
+  try {
+    const dir = dirname2(path);
+    if (!existsSync6(dir)) {
+      mkdirSync3(dir, { recursive: true });
+    }
+    appendFileSync(path, `[${new Date().toISOString()}] ${entry}
+`, "utf-8");
+  } catch {}
+}
+function buildChildEnv() {
+  return {
+    ...process.env,
+    RUST_BACKTRACE: process.env.RUST_BACKTRACE ?? "full",
+    RUST_LOG: process.env.RUST_LOG ?? "info,codex_core=debug,codex_tui=debug,codex_app_server=debug"
+  };
+}
 async function runCodex(args) {
   checkOwnedFlagConflicts(args, "agentbridge codex", OWNED_FLAGS2);
   for (let i = 0;i < args.length; i++) {
@@ -793,7 +990,7 @@ async function runCodex(args) {
   if (status?.proxyUrl) {
     proxyUrl = status.proxyUrl;
   } else {
-    proxyUrl = `ws://127.0.0.1:${config.daemon.proxyPort}`;
+    proxyUrl = `ws://127.0.0.1:${config.codex.proxyPort}`;
     console.error(`[agentbridge] No daemon status found, using config default: ${proxyUrl}`);
   }
   try {
@@ -855,13 +1052,27 @@ async function runCodex(args) {
     proxyUrl,
     ...args
   ];
+  const stderrTail = new StderrRingBuffer;
+  const wrapperLogPath = stateDir.codexWrapperLogFile;
+  const startedAt = Date.now();
+  stateDir.ensure();
+  appendWrapperLog(wrapperLogPath, `spawn: codex ${fullArgs.map((a) => a.includes(" ") ? JSON.stringify(a) : a).join(" ")}`);
   const child = spawn3("codex", fullArgs, {
-    stdio: "inherit",
-    env: process.env
+    stdio: ["inherit", "inherit", "pipe"],
+    env: buildChildEnv()
   });
   if (typeof child.pid === "number") {
-    writeFileSync3(stateDir.tuiPidFile, `${child.pid}
+    writeFileSync4(stateDir.tuiPidFile, `${child.pid}
 `, "utf-8");
+    appendWrapperLog(wrapperLogPath, `child pid=${child.pid}`);
+  }
+  if (child.stderr) {
+    child.stderr.on("data", (chunk) => {
+      try {
+        process.stderr.write(chunk);
+      } catch {}
+      stderrTail.append(chunk);
+    });
   }
   let cleanedTuiPid = false;
   function cleanupTuiPidFile() {
@@ -886,12 +1097,36 @@ async function runCodex(args) {
     cleanupTuiPidFile();
     process.exit(143);
   });
-  child.on("exit", (code) => {
+  child.on("exit", (code, signal) => {
     cleanupTuiPidFile();
+    const runtimeMs = Date.now() - startedAt;
+    const tail = stderrTail.toString();
+    const tailLines = tail.length === 0 ? "(no stderr captured)" : tail;
+    let classification = "normal";
+    if (/ERROR: remote app server/.test(tail))
+      classification = "fatal_exit";
+    else if (/Error: .* failed: Not initialized/.test(tail))
+      classification = "not_initialized_after_reconnect";
+    else if (/Error: .* failed:/.test(tail))
+      classification = "rpc_error_exit";
+    else if (signal)
+      classification = `signal:${signal}`;
+    else if (typeof code === "number" && code !== 0)
+      classification = `nonzero_exit:${code}`;
+    else if (code === 0 && tail.trim().length === 0)
+      classification = "exit_0_empty_stderr";
+    appendWrapperLog(wrapperLogPath, [
+      `exit: code=${code ?? "null"} signal=${signal ?? "null"} runtime_ms=${runtimeMs} pid=${child.pid ?? "unknown"} classification=${classification}`,
+      `--- last stderr (${stderrTail.byteLength} bytes) ---`,
+      tailLines,
+      `--- end stderr ---`
+    ].join(`
+`));
     process.exit(code ?? 0);
   });
   child.on("error", (err) => {
     cleanupTuiPidFile();
+    appendWrapperLog(wrapperLogPath, `spawn error: ${err.message}`);
     if (err.code === "ENOENT") {
       console.error("Error: codex not found in PATH.");
       console.error("Install Codex: https://github.com/openai/codex");
@@ -927,6 +1162,7 @@ var init_codex = __esm(() => {
   init_state_dir();
   init_config_service();
   init_daemon_lifecycle();
+  init_stderr_ring_buffer();
   init_claude();
   OWNED_FLAGS2 = ["--remote"];
 });
@@ -937,7 +1173,7 @@ __export(exports_kill, {
   runKill: () => runKill
 });
 import { execFileSync as execFileSync5 } from "child_process";
-import { readFileSync as readFileSync3, unlinkSync as unlinkSync3 } from "fs";
+import { readFileSync as readFileSync4, unlinkSync as unlinkSync3 } from "fs";
 async function runKill() {
   console.log(`AgentBridge Kill \u2014 stopping daemon and managed Codex TUI
 `);
@@ -1003,7 +1239,7 @@ async function killManagedCodexTui(stateDir, log, gracefulTimeoutMs = 3000) {
 }
 function readTuiPid(stateDir) {
   try {
-    const raw = readFileSync3(stateDir.tuiPidFile, "utf-8").trim();
+    const raw = readFileSync4(stateDir.tuiPidFile, "utf-8").trim();
     if (!raw)
       return null;
     const pid = Number.parseInt(raw, 10);
@@ -1034,7 +1270,7 @@ var init_kill = __esm(() => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "@raysonmeng/agentbridge",
-    version: "0.1.5",
+    version: "0.1.6",
     description: "Bridge between Claude Code and Codex \u2014 bidirectional agent communication via MCP Channel + JSON-RPC",
     type: "module",
     bin: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raysonmeng/agentbridge",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Bridge between Claude Code and Codex — bidirectional agent communication via MCP Channel + JSON-RPC",
   "type": "module",
   "bin": {

package/plugins/agentbridge/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "agentbridge",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Bridge Claude Code and Codex with a shared daemon, push channel delivery, and bidirectional reply tooling.",
   "author": {
     "name": "AgentBridge Contributors",