@mclawnet/agent 0.6.34 → 0.6.36

package/dist/{chunk-M2CDVPQF.js → chunk-JH6RGJBQ.js}

@@ -1,7 +1,7 @@
 import {
   loadConfig,
   saveConfig
-} from "./chunk-PJ5M6Q36.js";
+} from "./chunk-376QZ7JB.js";
 
 // src/service/config.ts
 import { existsSync, readFileSync } from "fs";
@@ -85,4 +85,4 @@ export {
   validateServiceConfig,
   mergeServiceConfig
 };
-//# sourceMappingURL=chunk-M2CDVPQF.js.map
+//# sourceMappingURL=chunk-JH6RGJBQ.js.map

package/dist/{chunk-MFXF77LG.js → chunk-VAEFJLPL.js}

@@ -21,7 +21,7 @@ async function createBackendAdapter(kind, ctx = {}) {
     }
   } else if (resolved === "codex") {
     try {
-      const mod = await import("./dist-VLBO5CT3.js");
+      const mod = await import("./dist-NWVHAP5R.js");
       adapter = new mod.CodexAdapter();
     } catch (err) {
       throw rethrowWithRole(
@@ -41,9 +41,31 @@ function rethrowWithRole(err, roleName, prefix) {
   const tag = roleName ? ` [role=${roleName}]` : "";
   return new Error(`${prefix}${tag}: ${base}`);
 }
+var ALL_KINDS_MAP = { claude: true, codex: true };
+var ALL_KINDS = Object.keys(ALL_KINDS_MAP);
+async function collectAgentManifest() {
+  const entries = await Promise.all(
+    ALL_KINDS.map(async (kind) => {
+      try {
+        const adapter = await createBackendAdapter(kind);
+        return await adapter.getManifest();
+      } catch (err) {
+        return {
+          kind,
+          installed: false,
+          unavailableReason: err instanceof Error ? err.message : String(err),
+          models: [],
+          modes: []
+        };
+      }
+    })
+  );
+  return { manifestVersion: 1, backends: entries };
+}
 
 export {
   __resetBackendFactoryCache,
-  createBackendAdapter
+  createBackendAdapter,
+  collectAgentManifest
 };
-//# sourceMappingURL=chunk-MFXF77LG.js.map
+//# sourceMappingURL=chunk-VAEFJLPL.js.map

package/dist/chunk-VAEFJLPL.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/backend-factory.ts"],"sourcesContent":["import type { BackendAdapter } from \"./backend-adapter.js\";\nimport type { AgentManifestPayload, BackendKind } from \"@mclawnet/shared\";\n\n// Re-export for back-compat with existing callers that import BackendKind from\n// this module rather than @mclawnet/shared.\nexport type { BackendKind };\n\nconst cache = new Map<BackendKind, BackendAdapter>();\n\nexport function __resetBackendFactoryCache(): void {\n  cache.clear();\n}\n\nexport interface BackendFactoryContext {\n  /** Role instance / template name — surfaces in error messages so users know\n   *  which role is misconfigured when its backend package fails to load. */\n  roleName?: string;\n}\n\n/**\n * Resolve a BackendAdapter for the given backend kind.\n *\n * - \"claude\" / undefined → @mclawnet/claude-adapter (back-compat default).\n * - \"codex\" → @mclawnet/codex-adapter via dynamic import so the codex bundle\n *   isn't pulled into claude-only deployments.\n *\n * Why dynamic import (and why codex-adapter is `optionalDependencies` in\n * agent's package.json, not `dependencies`):\n *   - agent owns the runtime relationship \"I load adapters on demand\".\n *   - Adapters only depend on @mclawnet/backend-types (the interface package),\n *     so there is no build-time cycle.\n *   - `optionalDependencies` keeps the \"user installs just @mclawnet/agent\n *     and codex backend works out of the box\" UX: npm/pnpm will try to\n *     install codex-adapter; if that fails (network, platform issue, user\n *     opted out via --no-optional), the dynamic import below throws and\n *     the agent surfaces a clear error instead of crashing at startup.\n *   - Promoting codex-adapter to `dependencies` would force install, which\n *     is fine for monorepo but unfriendly to claude-only deployments.\n *\n * Results are cached per kind; subsequent calls return the same instance.\n */\nexport async function createBackendAdapter(\n  kind: BackendKind | undefined,\n  ctx: BackendFactoryContext = {},\n): Promise<BackendAdapter> {\n  const resolved: BackendKind = kind ?? \"claude\";\n  const cached = cache.get(resolved);\n  if (cached) return cached;\n\n  let adapter: BackendAdapter;\n  if (resolved === \"claude\") {\n    try {\n      const mod = (await import(\"@mclawnet/claude-adapter\" as string)) as {\n        ClaudeCodeAdapter: new () => BackendAdapter;\n      };\n      adapter = new mod.ClaudeCodeAdapter();\n    } catch (err) {\n      throw rethrowWithRole(\n        err,\n        ctx.roleName,\n        \"failed to load @mclawnet/claude-adapter\",\n      );\n    }\n  } else if (resolved === \"codex\") {\n    try {\n      const mod = (await import(\"@mclawnet/codex-adapter\" as string)) as {\n        CodexAdapter: new () => BackendAdapter;\n      };\n      adapter = new mod.CodexAdapter();\n    } catch (err) {\n      throw rethrowWithRole(\n        err,\n        ctx.roleName,\n        \"failed to load @mclawnet/codex-adapter (is codex CLI installed?)\",\n      );\n    }\n  } else {\n    throw new Error(`unknown backend kind: ${resolved}`);\n  }\n\n  cache.set(resolved, adapter);\n  return adapter;\n}\n\nfunction rethrowWithRole(err: unknown, roleName: string | undefined, prefix: string): Error {\n  const base = err instanceof Error ? err.message : String(err);\n  const tag = roleName ? ` [role=${roleName}]` : \"\";\n  return new Error(`${prefix}${tag}: ${base}`);\n}\n\n/**\n * All backend kinds the agent should advertise in its manifest. Mirrors the\n * `BackendKind` union exposed by @mclawnet/shared. The `satisfies` clause\n * forces a tsc error if `BackendKind` grows without a matching map entry.\n */\nconst ALL_KINDS_MAP = { claude: true, codex: true } as const satisfies Record<BackendKind, true>;\nconst ALL_KINDS = Object.keys(ALL_KINDS_MAP) as BackendKind[];\n\n/**\n * Probe every known backend adapter and aggregate their `getManifest()` output\n * into a single payload the agent can ship to the hub. Failures (binary not on\n * PATH, adapter package broken, etc.) become `installed: false` entries rather\n * than rejecting the whole collection — the hub still wants to know \"we tried\n * but it isn't available\" for each kind.\n */\nexport async function collectAgentManifest(): Promise<AgentManifestPayload> {\n  const entries = await Promise.all(\n    ALL_KINDS.map(async (kind) => {\n      try {\n        const adapter = await createBackendAdapter(kind);\n        return await adapter.getManifest();\n      } catch (err) {\n        return {\n          kind,\n          installed: false,\n          unavailableReason: err instanceof Error ? err.message : String(err),\n          models: [],\n          modes: [],\n        };\n      }\n    }),\n  );\n  return { manifestVersion: 1, backends: entries };\n}\n"],"mappings":";AAOA,IAAM,QAAQ,oBAAI,IAAiC;AAE5C,SAAS,6BAAmC;AACjD,QAAM,MAAM;AACd;AA8BA,eAAsB,qBACpB,MACA,MAA6B,CAAC,GACL;AACzB,QAAM,WAAwB,QAAQ;AACtC,QAAM,SAAS,MAAM,IAAI,QAAQ;AACjC,MAAI,OAAQ,QAAO;AAEnB,MAAI;AACJ,MAAI,aAAa,UAAU;AACzB,QAAI;AACF,YAAM,MAAO,MAAM,OAAO,0BAAoC;AAG9D,gBAAU,IAAI,IAAI,kBAAkB;AAAA,IACtC,SAAS,KAAK;AACZ,YAAM;AAAA,QACJ;AAAA,QACA,IAAI;AAAA,QACJ;AAAA,MACF;AAAA,IACF;AAAA,EACF,WAAW,aAAa,SAAS;AAC/B,QAAI;AACF,YAAM,MAAO,MAAM,OAAO,oBAAmC;AAG7D,gBAAU,IAAI,IAAI,aAAa;AAAA,IACjC,SAAS,KAAK;AACZ,YAAM;AAAA,QACJ;AAAA,QACA,IAAI;AAAA,QACJ;AAAA,MACF;AAAA,IACF;AAAA,EACF,OAAO;AACL,UAAM,IAAI,MAAM,yBAAyB,QAAQ,EAAE;AAAA,EACrD;AAEA,QAAM,IAAI,UAAU,OAAO;AAC3B,SAAO;AACT;AAEA,SAAS,gBAAgB,KAAc,UAA8B,QAAuB;AAC1F,QAAM,OAAO,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG;AAC5D,QAAM,MAAM,WAAW,UAAU,QAAQ,MAAM;AAC/C,SAAO,IAAI,MAAM,GAAG,MAAM,GAAG,GAAG,KAAK,IAAI,EAAE;AAC7C;AAOA,IAAM,gBAAgB,EAAE,QAAQ,MAAM,OAAO,KAAK;AAClD,IAAM,YAAY,OAAO,KAAK,aAAa;AAS3C,eAAsB,uBAAsD;AAC1E,QAAM,UAAU,MAAM,QAAQ;AAAA,IAC5B,UAAU,IAAI,OAAO,SAAS;AAC5B,UAAI;AACF,cAAM,UAAU,MAAM,qBAAqB,IAAI;AAC/C,eAAO,MAAM,QAAQ,YAAY;AAAA,MACnC,SAAS,KAAK;AACZ,eAAO;AAAA,UACL;AAAA,UACA,WAAW;AAAA,UACX,mBAAmB,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG;AAAA,UAClE,QAAQ,CAAC;AAAA,UACT,OAAO,CAAC;AAAA,QACV;AAAA,MACF;AAAA,IACF,CAAC;AAAA,EACH;AACA,SAAO,EAAE,iBAAiB,GAAG,UAAU,QAAQ;AACjD;","names":[]}

package/dist/{dist-VLBO5CT3.js → dist-NWVHAP5R.js}

@@ -1,28 +1,43 @@
 // ../codex-adapter/dist/codex-adapter.js
-import { spawn } from "child_process";
+import { execSync, spawn } from "child_process";
 import { EventEmitter } from "events";
-import { existsSync } from "fs";
+import { existsSync, readFileSync } from "fs";
 import { createRequire } from "module";
-import { homedir } from "os";
-import { join as join2 } from "path";
+import { homedir, platform as platform2 } from "os";
+import { dirname, join as join2 } from "path";
 
 // ../codex-adapter/dist/codex-spawn-args.js
 import { writeFileSync, unlinkSync } from "fs";
 import { join } from "path";
 import { tmpdir } from "os";
 import { randomUUID } from "crypto";
-import { DEFAULT_SANDBOX } from "@mclawnet/shared";
+import { DEFAULT_SANDBOX, SANDBOX_LEVELS } from "@mclawnet/shared";
 function escapeToml(value) {
   return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
 }
+var VALID_CODEX_SANDBOX = new Set(SANDBOX_LEVELS);
 function buildCodexSpawnArgs(options) {
   const args = ["app-server"];
   let briefingFile;
   void options.resumeId;
   args.push("-c", 'approval_policy="never"');
-  const sandboxLevel = options.sandbox ?? DEFAULT_SANDBOX;
+  let sandboxLevel;
+  let modeSource;
+  if (options.mode && VALID_CODEX_SANDBOX.has(options.mode)) {
+    sandboxLevel = options.mode;
+    modeSource = "options.mode";
+  } else if (options.sandbox) {
+    sandboxLevel = options.sandbox;
+    modeSource = "options.sandbox";
+  } else {
+    sandboxLevel = DEFAULT_SANDBOX;
+    modeSource = "default";
+  }
   const codexSandboxMode = sandboxLevel === "read-only" ? "read-only" : sandboxLevel === "full-access" ? "danger-full-access" : "workspace-write";
   args.push("-c", `sandbox_mode="${codexSandboxMode}"`);
+  if (options.model) {
+    args.push("-c", `model="${escapeToml(options.model)}"`);
+  }
   if (options.mcpServer) {
     const { command, args: serverArgs, env } = options.mcpServer;
     args.push("-c", `mcp_servers.clawnet-mcp.command="${escapeToml(command)}"`);
@@ -38,11 +53,12 @@ function buildCodexSpawnArgs(options) {
     args.push("-c", 'mcp_servers.clawnet-mcp.default_tools_approval_mode="approve"');
   }
   if (options.systemPrompt) {
-    briefingFile = join(tmpdir(), `clawnet-briefing-${options.sessionId}-${randomUUID().slice(0, 8)}.md`);
+    const safeId = options.sessionId.replace(/[\\/:*?"<>|\x00-\x1F]/g, "_").replace(/[. ]+$/g, "_");
+    briefingFile = join(tmpdir(), `clawnet-briefing-${safeId}-${randomUUID().slice(0, 8)}.md`);
     writeFileSync(briefingFile, options.systemPrompt, { encoding: "utf-8", mode: 384 });
     args.push("-c", `model_instructions_file="${escapeToml(briefingFile)}"`);
   }
-  return { args, briefingFile };
+  return { args, briefingFile, modeSource };
 }
 function cleanupBriefingFile(filePath) {
   try {
@@ -69,17 +85,38 @@ var JsonRpcClient = class {
     this.onNotification = opts.onNotification;
     this.onMalformedLine = opts.onMalformedLine;
     opts.stdout.on("data", (chunk) => this.feed(chunk.toString("utf-8")));
+    this.stdin.on("error", (err) => this.failAllPending(err));
+  }
+  /**
+   * Reject every in-flight request with the given error. Called when stdin
+   * dies so callers get a clean rejection instead of hanging until the
+   * handshake death-poll catches up.
+   */
+  failAllPending(err) {
+    for (const [, p] of this.pending) {
+      try {
+        p.reject(err);
+      } catch {
+      }
+    }
+    this.pending.clear();
   }
   request(method, params) {
     const id = this.nextId++;
     const frame = { jsonrpc: "2.0", id, method, params };
     return new Promise((resolve, reject) => {
       this.pending.set(id, { resolve, reject });
-      this.stdin.write(JSON.stringify(frame) + "\n");
+      this.stdin.write(JSON.stringify(frame) + "\n", (err) => {
+        if (err) {
+          this.pending.delete(id);
+          reject(err);
+        }
+      });
     });
   }
   notify(method, params) {
-    this.stdin.write(JSON.stringify({ jsonrpc: "2.0", method, params }) + "\n");
+    this.stdin.write(JSON.stringify({ jsonrpc: "2.0", method, params }) + "\n", () => {
+    });
   }
   feed(s) {
     this.buffer += s;
@@ -273,9 +310,6 @@ function mapCodexFrame(frame) {
     }
     case "item/completed": {
       const item = params.item;
-      if (item?.type === "agentMessage" && typeof item.text === "string") {
-        return { kind: "assistant_text", text: item.text };
-      }
       if (item?.type === "commandExecution") {
         const failed = item.status === "failed" || item.status === "declined";
         const badExit = typeof item.exitCode === "number" && item.exitCode !== 0;
@@ -354,13 +388,139 @@ function mapCodexFrame(frame) {
   return { kind: "raw", backend: "codex", payload: frame };
 }
 
+// ../codex-adapter/dist/catalog.js
+var CODEX_MODELS = [
+  {
+    code: "gpt-4o",
+    label: "GPT-4o",
+    tier: "premium",
+    contextWindow: 128e3,
+    supportsVision: true,
+    supportsToolUse: true,
+    default: true
+  },
+  {
+    code: "gpt-4o-mini",
+    label: "GPT-4o mini",
+    tier: "standard",
+    contextWindow: 128e3,
+    supportsVision: true,
+    supportsToolUse: true
+  }
+];
+var CODEX_MODES = [
+  { code: "read-only", label: "Read Only", description: "No FS writes" },
+  { code: "workspace-write", label: "Workspace Write", description: "Write inside cwd only", default: true },
+  { code: "full-access", label: "Full Access", description: "No sandbox" }
+];
+
+// ../codex-adapter/dist/detect.js
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { platform } from "os";
+var exec = promisify(execFile);
+async function detectCodexInstall() {
+  try {
+    const isWin2 = platform() === "win32";
+    const lookup = isWin2 ? "where" : "which";
+    const { stdout: lookupOut } = await exec(lookup, ["codex"], { timeout: 5e3 });
+    const binaryPath = lookupOut.trim().split(/\r?\n/)[0]?.trim();
+    if (!binaryPath) {
+      return { installed: false, reason: `codex CLI not detected: empty ${lookup} output` };
+    }
+    const { stdout: verOut } = await exec(binaryPath, ["--version"], { timeout: 5e3 });
+    return { installed: true, binaryPath, version: verOut.trim() };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { installed: false, reason: `codex CLI not detected: ${message}` };
+  }
+}
+
 // ../codex-adapter/dist/codex-adapter.js
 var log = createLogger({ module: "codex-adapter" });
+var isWin = platform2() === "win32";
+function resolveCodexBin(explicit) {
+  if (explicit && explicit !== "codex")
+    return explicit;
+  const names = isWin ? ["codex.exe", "codex.cmd", "codex.bat"] : ["codex"];
+  const whichCmd = isWin ? "where" : "which";
+  for (const name of names) {
+    try {
+      const found = execSync(`${whichCmd} ${name}`, {
+        encoding: "utf-8",
+        // 1.5s is plenty for `where`/`which` on a healthy machine; the old
+        // 5s × 3 worst-case (15s blocking event loop) showed up on slow
+        // domain-joined Windows hosts / network-PATH setups.
+        timeout: 1500,
+        stdio: ["ignore", "pipe", "ignore"]
+      }).trim().split(/\r?\n/)[0];
+      if (found && existsSync(found))
+        return found;
+    } catch {
+    }
+  }
+  const home = homedir();
+  const fallbacks = isWin ? [
+    join2(home, "AppData", "Roaming", "npm", "codex.cmd"),
+    join2(home, "AppData", "Roaming", "npm", "codex.exe"),
+    join2(home, ".cargo", "bin", "codex.exe"),
+    join2(home, ".local", "bin", "codex.exe")
+  ] : [
+    join2(home, ".cargo", "bin", "codex"),
+    join2(home, ".local", "bin", "codex"),
+    "/opt/homebrew/bin/codex",
+    "/usr/local/bin/codex"
+  ];
+  for (const p of fallbacks) {
+    if (existsSync(p))
+      return p;
+  }
+  return isWin ? "codex.cmd" : "codex";
+}
+var resolvedCodexBinCache = /* @__PURE__ */ new Map();
+var resolveCodexBinCallCount = 0;
+function getResolvedCodexBin(explicit) {
+  const key = explicit ?? "";
+  const hit = resolvedCodexBinCache.get(key);
+  if (hit)
+    return hit;
+  resolveCodexBinCallCount++;
+  const resolved = resolveCodexBin(explicit);
+  resolvedCodexBinCache.set(key, resolved);
+  return resolved;
+}
+function resolveSpawnTarget(codexBin) {
+  const isWindows = platform2() === "win32";
+  if (!isWindows || !codexBin.toLowerCase().endsWith(".cmd")) {
+    return { command: codexBin, prefixArgs: [] };
+  }
+  try {
+    const cmdContent = readFileSync(codexBin, "utf-8");
+    const exeMatch = cmdContent.match(/(?:%~?dp0%?)[\\/](.+?\.exe)/i);
+    if (exeMatch) {
+      const relParts = exeMatch[1].split(/[\\/]/);
+      const exePath = join2(dirname(codexBin), ...relParts);
+      if (existsSync(exePath))
+        return { command: exePath, prefixArgs: [] };
+    }
+    const jsMatch = cmdContent.match(/(?:%~?dp0%?)[\\/](.+?\.js)/i);
+    if (jsMatch) {
+      const relParts = jsMatch[1].split(/[\\/]/);
+      const cliJsPath = join2(dirname(codexBin), ...relParts);
+      if (existsSync(cliJsPath)) {
+        return { command: process.execPath, prefixArgs: [cliJsPath] };
+      }
+    }
+  } catch {
+  }
+  return { command: codexBin, prefixArgs: [] };
+}
 var CLAWNET_CLIENT_INFO = {
   name: "clawnet",
   version: "0.1.0",
   title: "ClawNet Agent"
 };
+var ASSISTANT_TEXT_SEEN_MAX = 64;
 var CodexProcess = class extends EventEmitter {
   id;
   workDir;
@@ -388,6 +548,24 @@ var CodexProcess = class extends EventEmitter {
   handshakeComplete = false;
   /** Inputs queued by send() while the handshake is still in flight. */
   pendingInputs = [];
+  /**
+   * Per-itemId accumulator of assistant text already emitted via
+   * `item/agentMessage/delta` chunks. Consulted on `item/completed` with
+   * `item.type === "agentMessage"` to decide what (if anything) of the
+   * completed payload still needs to be emitted. Without this, codex
+   * delivers the same assistant text twice (deltas + final) and the UI
+   * renders "Hello worldHello world".
+   *
+   * Entries are cleared per item when the matching `item/completed` fires.
+   * We do NOT clear the whole map on `turn/completed`: codex's wire
+   * doesn't strictly guarantee that every item/completed precedes its
+   * parent turn/completed, and a trailing item/completed against an empty
+   * accumulator would re-emit the full text (reactivating the bug). To
+   * cap unbounded growth from interrupted turns that never fire
+   * completed, the map is size-bounded with FIFO eviction; in practice a
+   * single turn produces 1-2 agentMessage items so the cap is generous.
+   */
+  assistantTextSeen = /* @__PURE__ */ new Map();
   /** Temp file for briefing injection; cleaned up on kill(). */
   briefingFile;
   /**
@@ -425,6 +603,7 @@ var CodexProcess = class extends EventEmitter {
     this.approvalMethods.clear();
     this.approvalResolvers.clear();
     this.pendingInputs.length = 0;
+    this.assistantTextSeen.clear();
     if (this.briefingFile) {
       cleanupBriefingFile(this.briefingFile);
       this.briefingFile = void 0;
@@ -448,28 +627,39 @@ var CodexAdapter = class {
   type = "codex";
   codexBin;
   handshakeTimeoutMs;
+  detect;
   constructor(options) {
-    this.codexBin = options?.codexBin ?? "codex";
+    this.codexBin = getResolvedCodexBin(options?.codexBin);
     const envTimeout = Number(process.env.CLAWNET_CODEX_HANDSHAKE_TIMEOUT_MS);
     this.handshakeTimeoutMs = options?.handshakeTimeoutMs ?? (Number.isFinite(envTimeout) && envTimeout > 0 ? envTimeout : 15e3);
+    this.detect = options?.detect ?? detectCodexInstall;
   }
   async spawn(options) {
     let cwd = options.workDir || process.cwd();
     if (!existsSync(cwd))
       cwd = homedir();
     const mcpServer = this.buildMcpServerConfig(options);
-    const { args, briefingFile } = buildCodexSpawnArgs({
+    const { args, briefingFile, modeSource } = buildCodexSpawnArgs({
       sessionId: options.sessionId,
       resumeId: options.resumeId,
       systemPrompt: options.systemPrompt,
       mcpServer,
-      sandbox: options.sandbox
+      sandbox: options.sandbox,
+      model: options.model,
+      mode: options.mode
     });
+    if (options.mode && modeSource !== "options.mode") {
+      log.warn({ sessionId: options.sessionId, requestedMode: options.mode, modeSource }, "codex: invalid options.mode ignored, falling back");
+    }
     log.info({ sessionId: options.sessionId, bin: this.codexBin, args, cwd, resumeId: options.resumeId }, "codex spawn: forking app-server");
-    const proc = spawn(this.codexBin, args, {
+    const { command, prefixArgs } = resolveSpawnTarget(this.codexBin);
+    if (command !== this.codexBin) {
+      log.info({ sessionId: options.sessionId, bin: this.codexBin, spawnCmd: command, prefixArgs }, "codex spawn: using resolved shim target (windows .cmd bypass)");
+    }
+    const proc = spawn(command, [...prefixArgs, ...args], {
       cwd,
       stdio: ["pipe", "pipe", "pipe"],
-      env: process.env,
+      env: { ...process.env, ...options.env ?? {} },
       windowsHide: true
     });
     const stderrChunks = [];
@@ -481,12 +671,32 @@ var CodexAdapter = class {
       }
     });
     let exitInfo = null;
+    let createdCp;
+    const emitProcessExit = (cp2, code, signal) => {
+      try {
+        cp2.emit("exit", code);
+      } catch {
+      }
+      const isClean = code === 0 || signal === "SIGTERM";
+      if (isClean)
+        return;
+      const stderr = stderrChunks.join("\n").trim().slice(0, 800);
+      const detail = stderr ? ` \u2014 stderr: ${stderr}` : "";
+      try {
+        cp2.emit("error", new Error(`codex process exited (code=${code ?? "null"}, signal=${signal ?? "null"})${detail}`));
+      } catch {
+      }
+    };
     proc.on("exit", (code, signal) => {
       const isClean = code === 0 || signal === "SIGTERM";
       const level = isClean ? "debug" : "warn";
       log[level]({ sessionId: options.sessionId, code, signal }, "codex process exited");
       if (!exitInfo)
         exitInfo = { code, signal };
+      const cpRef = createdCp;
+      if (!cpRef)
+        return;
+      emitProcessExit(cpRef, code, signal);
     });
     await new Promise((resolve, reject) => {
       const t = setTimeout(() => resolve(), 2e3);
@@ -505,15 +715,39 @@ var CodexAdapter = class {
     cp.resumeId = options.resumeId;
     cp.getExitInfo = () => exitInfo;
     cp.getStderr = () => stderrChunks.join("\n").slice(0, 800);
+    createdCp = cp;
+    if (exitInfo) {
+      const { code, signal } = exitInfo;
+      setImmediate(() => emitProcessExit(cp, code, signal));
+    }
     this.wireRpc(cp);
     return cp;
   }
   buildMcpServerConfig(options) {
     let serverPath;
-    try {
-      const require2 = createRequire(import.meta.url);
-      serverPath = require2.resolve("@mclawnet/mcp-server/dist/server.js");
-    } catch {
+    const require2 = createRequire(import.meta.url);
+    const tryResolve = (specifier) => {
+      try {
+        const p = require2.resolve(specifier);
+        return p && existsSync(p) ? p : void 0;
+      } catch {
+        return void 0;
+      }
+    };
+    serverPath = tryResolve("@mclawnet/mcp-server/server");
+    if (!serverPath) {
+      try {
+        const pkgPath = require2.resolve("@mclawnet/mcp-server/package.json");
+        const candidate = join2(dirname(pkgPath), "dist", "server.js");
+        if (existsSync(candidate))
+          serverPath = candidate;
+      } catch {
+      }
+    }
+    if (!serverPath) {
+      serverPath = tryResolve("@mclawnet/mcp-server/dist/server.js");
+    }
+    if (!serverPath) {
       const devPath = join2(import.meta.dirname ?? __dirname, "../../mcp-server/dist/server.js");
       if (existsSync(devPath))
         serverPath = devPath;
@@ -522,6 +756,7 @@ var CodexAdapter = class {
       log.warn({ pkg: "@mclawnet/mcp-server" }, "codex: clawnet-mcp-server not resolvable, codex role will lack MCP tools");
       return void 0;
     }
+    log.debug({ serverPath }, "codex: resolved clawnet-mcp-server path");
     const env = {};
     if (options.workDir)
       env.CLAWNET_WORK_DIR = options.workDir;
@@ -646,7 +881,24 @@ var CodexAdapter = class {
       return;
     }
     if (method === "error") {
+      const p = params ?? {};
+      const message = p.error?.message ?? "codex emitted unspecified error";
       log.warn({ sessionId: cp.id, params }, "codex error notification");
+      cp.emit("error", new Error(`codex: ${message}`));
+      if (p.willRetry === false) {
+        void cp.kill().catch((err) => {
+          log.warn({ err, sessionId: cp.id }, "kill after fatal codex error failed");
+        });
+      }
+      return;
+    }
+    if (method === "thread/status/changed") {
+      const p = params ?? {};
+      if (p.status?.type === "systemError") {
+        log.warn({ sessionId: cp.id, params }, "codex thread systemError");
+        cp.emit("error", new Error("codex: thread entered systemError"));
+      }
+      return;
     }
     if (method === "turn/completed" || method === "thread/turnComplete" || method === "turn/complete") {
       log.info({ sessionId: cp.id, method }, "codex turn complete");
@@ -659,6 +911,49 @@ var CodexAdapter = class {
       log.info({ sessionId: cp.id }, "codex turn started");
       return;
     }
+    if (method === "item/agentMessage/delta") {
+      const p = params ?? {};
+      if (typeof p.itemId === "string" && typeof p.delta === "string") {
+        const prev = cp.assistantTextSeen.get(p.itemId) ?? "";
+        if (!cp.assistantTextSeen.has(p.itemId) && cp.assistantTextSeen.size >= ASSISTANT_TEXT_SEEN_MAX) {
+          const oldest = cp.assistantTextSeen.keys().next().value;
+          if (oldest !== void 0)
+            cp.assistantTextSeen.delete(oldest);
+        }
+        cp.assistantTextSeen.set(p.itemId, prev + p.delta);
+      } else {
+        log.warn({ sessionId: cp.id, params: p }, "codex agentMessage delta: missing itemId/delta \u2014 dedupe will not apply to this item");
+      }
+    } else if (method === "item/completed") {
+      const p = params ?? {};
+      const item = p.item;
+      if (item?.type === "agentMessage") {
+        if (typeof item.id !== "string" || typeof item.text !== "string") {
+          log.warn({ sessionId: cp.id, item }, "codex agentMessage completed: malformed item.id/text \u2014 dropping to avoid duplicate emission");
+          return;
+        }
+        const seen = cp.assistantTextSeen.get(item.id) ?? "";
+        cp.assistantTextSeen.delete(item.id);
+        const full = item.text;
+        let suffix;
+        if (full === seen) {
+          return;
+        } else if (seen.length > 0 && full.startsWith(seen)) {
+          suffix = full.slice(seen.length);
+        } else {
+          suffix = full;
+          if (seen.length > 0) {
+            log.warn({ sessionId: cp.id, itemId: item.id, seenLen: seen.length, fullLen: full.length }, "codex agentMessage: completed text diverges from accumulated deltas \u2014 emitting full");
+          }
+        }
+        if (suffix.length === 0)
+          return;
+        const out2 = { kind: "assistant_text", text: suffix };
+        this.logBackendOutput(cp.id, method, out2);
+        cp.emit("output", out2);
+        return;
+      }
+    }
     const out = mapCodexFrame({ method, params });
     this.logBackendOutput(cp.id, method, out);
     cp.emit("output", out);
@@ -763,6 +1058,18 @@ var CodexAdapter = class {
     if (process2 instanceof CodexProcess)
       process2.on("exit", handler);
   }
+  async getManifest() {
+    const det = await this.detect();
+    return {
+      kind: "codex",
+      installed: det.installed,
+      binaryPath: det.binaryPath,
+      version: det.version,
+      unavailableReason: det.reason,
+      models: det.installed ? CODEX_MODELS : [],
+      modes: det.installed ? CODEX_MODES : []
+    };
+  }
 };
 export {
   CodexAdapter,
@@ -772,4 +1079,4 @@ export {
   mapCodexFrame,
   parseApprovalRequest
 };
-//# sourceMappingURL=dist-VLBO5CT3.js.map
+//# sourceMappingURL=dist-NWVHAP5R.js.map