kojee-mcp 0.5.11 → 0.5.13

package/dist/{chunk-DS26OORG.js → chunk-CO73VGWM.js}

@@ -5,7 +5,7 @@ import {
   secureFile
 } from "./chunk-BLEGIR35.js";
 
-// src/tandem/event-log.ts
+// src/delivery/lib/event-log.ts
 import fs from "fs";
 import os from "os";
 import path from "path";
@@ -21,13 +21,24 @@ function statusLogPath(eventLogPath) {
   const m = base.match(/^kojee-events-(.+)\.log$/);
   return path.join(dir, m ? `kojee-status-${m[1]}.log` : `${base}.status`);
 }
+function livePathOwnedBySibling(candidatePath) {
+  try {
+    const { livePaths } = listActiveSessionIds();
+    return livePaths.has(path.resolve(candidatePath));
+  } catch {
+    return false;
+  }
+}
 function startEventLog(opts) {
   const dir = opts.dir ?? DEFAULT_DIR;
   const maxBytes = opts.maxBytes ?? DEFAULT_MAX_BYTES;
   const statusMaxBytes = opts.statusMaxBytes ?? DEFAULT_STATUS_MAX_BYTES;
-  const filePath = path.join(dir, `kojee-events-${opts.key}.log`);
-  const statusPath = statusLogPath(filePath);
   fs.mkdirSync(dir, { recursive: true });
+  let filePath = path.join(dir, `kojee-events-${opts.key}.log`);
+  if (opts.key.startsWith("wd-") && livePathOwnedBySibling(filePath)) {
+    filePath = path.join(dir, `kojee-events-${opts.key}-${process.pid}.log`);
+  }
+  const statusPath = statusLogPath(filePath);
   fs.writeFileSync(filePath, "", { mode: 384 });
   secureFile(filePath);
   fs.writeFileSync(statusPath, "", { mode: 384 });
@@ -146,6 +157,19 @@ function nudgeSentinelPath(eventLogPath) {
   const m = base.match(/^kojee-events-(.+)\.log$/);
   return path.join(dir, m ? `kojee-nudge-${m[1]}.touch` : `${base}.nudge`);
 }
+function reapEventLogSiblings(messagesLogPath) {
+  for (const p of [
+    messagesLogPath,
+    statusLogPath(messagesLogPath),
+    monitorHeartbeatPath(messagesLogPath),
+    nudgeSentinelPath(messagesLogPath)
+  ]) {
+    try {
+      fs.unlinkSync(p);
+    } catch {
+    }
+  }
+}
 function isProcessAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -165,6 +189,7 @@ function listActiveSessionIds() {
   } catch {
     return { active, livePaths };
   }
+  const dead = [];
   for (const name of entries) {
     if (!name.endsWith(".json")) continue;
     const rawId = name.slice(0, -".json".length);
@@ -172,28 +197,25 @@ function listActiveSessionIds() {
     const filePath = path.join(dir, name);
     try {
       const data = JSON.parse(fs.readFileSync(filePath, "utf8"));
-      if (typeof data.pid === "number" && isProcessAlive(data.pid)) {
+      const livenessPid = data.proxyPid ?? data.pid;
+      if (typeof livenessPid === "number" && isProcessAlive(livenessPid)) {
         active.add(sessionId);
         if (data.eventLogPath) livePaths.add(path.resolve(data.eventLogPath));
       } else {
-        try {
-          fs.unlinkSync(filePath);
-        } catch {
-        }
-        if (data.eventLogPath) {
-          try {
-            fs.unlinkSync(data.eventLogPath);
-          } catch {
-          }
-          try {
-            fs.unlinkSync(statusLogPath(data.eventLogPath));
-          } catch {
-          }
-        }
+        dead.push({ filePath, eventLogPath: data.eventLogPath });
       }
     } catch {
     }
   }
+  for (const { filePath, eventLogPath } of dead) {
+    try {
+      fs.unlinkSync(filePath);
+    } catch {
+    }
+    if (eventLogPath && !livePaths.has(path.resolve(eventLogPath))) {
+      reapEventLogSiblings(eventLogPath);
+    }
+  }
   return { active, livePaths };
 }
 function sweepStaleEventLogs(dir = DEFAULT_DIR, minAgeMs = DEFAULT_MIN_AGE_MS) {
@@ -219,11 +241,7 @@ function sweepStaleEventLogs(dir = DEFAULT_DIR, minAgeMs = DEFAULT_MIN_AGE_MS) {
       const stat = fs.statSync(filePath);
       const ageMs = Math.max(0, now - stat.mtimeMs);
       if (ageMs < minAgeMs) continue;
-      fs.unlinkSync(filePath);
-      try {
-        fs.unlinkSync(statusLogPath(filePath));
-      } catch {
-      }
+      reapEventLogSiblings(filePath);
     } catch {
     }
   }

package/dist/{chunk-HIZ4NDWN.js → chunk-DXJ6QLSJ.js}

@@ -1,6 +1,6 @@
 import {
   translateToolCallResult
-} from "./chunk-LDZXU3DW.js";
+} from "./chunk-2OLXXOT3.js";
 
 // src/tandem/send.ts
 var SEND_KINDS = ["message", "status"];
@@ -52,7 +52,7 @@ function classifySendFailure(text) {
   if (/token is invalid or expired/i.test(text) || /authentication failed/i.test(text) || /re-?authoriz/i.test(text)) {
     return sendFailure("gateway_auth", text);
   }
-  if (/aren'?t a member|not a member/i.test(text)) {
+  if (/aren'?t a member|not[ _]a[ _]member|aren'?t an active member/i.test(text)) {
     return sendFailure("not_member", text);
   }
   if (/rate limit/i.test(text)) {
@@ -110,6 +110,25 @@ async function executeSend(gateway, request) {
     text
   };
 }
+async function executeJoin(gateway, tandemId) {
+  let result;
+  try {
+    result = await gateway.sendRpc("tools/call", {
+      name: "tandem_join",
+      arguments: { tandem_id: tandemId }
+    });
+  } catch (err) {
+    return classifySendFailure(
+      `tandem_join failed: ${err?.message ?? String(err)}`
+    );
+  }
+  const translated = translateToolCallResult(result);
+  const text = (translated.content ?? []).map((c) => typeof c?.text === "string" ? c.text : "").filter(Boolean).join("\n");
+  if (translated.isError) {
+    return classifySendFailure(text || "tandem_join returned an error with no text");
+  }
+  return { ok: true, tandem_id: tandemId, message_id: null, cursor: null, text };
+}
 var HTTP_STATUS_BY_CODE = {
   bad_request: 400,
   unauthorized: 401,
@@ -137,5 +156,6 @@ export {
   sendFailure,
   parseSendRequest,
   executeSend,
+  executeJoin,
   httpStatusForEnvelope
 };

package/dist/{chunk-HSR3GXCL.js → chunk-IMOEZ4NJ.js}

@@ -1,12 +1,17 @@
 import {
-  MCP_SESSION_ID,
-  createDPoPProof
-} from "./chunk-2MIISF2W.js";
+  createDPoPProof,
+  deriveStableSessionId,
+  getSessionId,
+  setStableSessionId
+} from "./chunk-NR4Y54OL.js";
 import {
   translateHttpError,
   translateJsonRpcError,
   translateNetworkError
-} from "./chunk-LDZXU3DW.js";
+} from "./chunk-2OLXXOT3.js";
+import {
+  findClaudeAncestorPid
+} from "./chunk-VHKPWUX7.js";
 
 // src/gateway-client.ts
 import crypto from "crypto";
@@ -129,7 +134,7 @@ var GatewayClient = class {
         "Content-Type": "application/json",
         Authorization: `DPoP ${this.token}`,
         DPoP: proof,
-        "Mcp-Session-Id": MCP_SESSION_ID
+        "Mcp-Session-Id": getSessionId()
       },
       body: JSON.stringify(rpcRequest),
       // ROUND-3 MAJOR A: the caller's AbortSignal rides HERE (a real fetch
@@ -153,6 +158,78 @@ var GatewayClient = class {
   }
 };
 
+// src/runtime/cc-session-id.ts
+import fs from "fs";
+import { execFileSync } from "child_process";
+import { createHash } from "crypto";
+var CC_SESSION_ENV = "CLAUDE_CODE_SESSION_ID";
+function extractCcSessionId(raw) {
+  if (raw.includes("\0")) {
+    for (const entry of raw.split("\0")) {
+      if (entry.startsWith(`${CC_SESSION_ENV}=`)) {
+        const v = entry.slice(CC_SESSION_ENV.length + 1);
+        return v.length > 0 ? v : null;
+      }
+    }
+    return null;
+  }
+  const re = new RegExp(`(?:^|\\s)${CC_SESSION_ENV}=([^\\s]+)`, "g");
+  let last = null;
+  let m;
+  while ((m = re.exec(raw)) !== null) last = m[1];
+  return last;
+}
+function defaultReadProcessEnvRaw(pid, platform) {
+  try {
+    if (platform === "linux") {
+      return fs.readFileSync(`/proc/${pid}/environ`, "utf8");
+    }
+    if (platform === "darwin") {
+      return execFileSync("ps", ["eww", "-p", String(pid), "-o", "command="], {
+        encoding: "utf8",
+        timeout: 2e3
+      });
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function sanitizeKey(value) {
+  return value.replace(/[^A-Za-z0-9_-]/g, "");
+}
+function resolveInstanceKey(deps = {}) {
+  const env = deps.env ?? process.env;
+  const platform = deps.platform ?? process.platform;
+  const ccPid = deps.ccPid ?? null;
+  if (ccPid !== null) {
+    const reader = deps.readProcessEnvRaw ?? defaultReadProcessEnvRaw;
+    const raw = reader(ccPid, platform);
+    if (raw) {
+      const sid = sanitizeKey(extractCcSessionId(raw) ?? "");
+      if (sid) return sid;
+    }
+  }
+  const explicit = sanitizeKey((env.KOJEE_INSTANCE ?? "").trim());
+  if (explicit) return `inst-${explicit}`;
+  const base = deps.projectDir ?? env.CLAUDE_PROJECT_DIR ?? deps.cwd ?? process.cwd() ?? "";
+  const hash = createHash("sha256").update(base).digest("hex").slice(0, 12);
+  return `wd-${hash}`;
+}
+
+// src/runtime/stable-session.ts
+async function applyStableSessionId(token, deps = {}) {
+  let instanceKey = deps.instanceKey;
+  if (instanceKey === void 0) {
+    const ccPid = deps.ccPid !== void 0 ? deps.ccPid : await findClaudeAncestorPid();
+    instanceKey = resolveInstanceKey({ ccPid });
+  }
+  const sessionId = deriveStableSessionId(token, instanceKey);
+  setStableSessionId(sessionId);
+  return { instanceKey, sessionId };
+}
+
 export {
-  GatewayClient
+  GatewayClient,
+  applyStableSessionId
 };

package/dist/{chunk-2MIISF2W.js → chunk-NR4Y54OL.js}

@@ -26,10 +26,23 @@ function computeAth(accessToken) {
 }
 
 // src/tandem/session-id.ts
+import crypto2 from "crypto";
 import { ulid } from "ulidx";
 var MCP_SESSION_ID = ulid();
+function deriveStableSessionId(token, instanceKey) {
+  return crypto2.createHash("sha256").update(`${token}:${instanceKey}`).digest("hex").slice(0, 32);
+}
+var _stableSessionId = null;
+function setStableSessionId(id) {
+  _stableSessionId = id;
+}
+function getSessionId() {
+  return _stableSessionId ?? MCP_SESSION_ID;
+}
 
 export {
   createDPoPProof,
-  MCP_SESSION_ID
+  deriveStableSessionId,
+  setStableSessionId,
+  getSessionId
 };

package/dist/chunk-XXFVWP6H.js

@@ -0,0 +1,44 @@
+import {
+  buildReplyRecipe
+} from "./chunk-X672ZN7V.js";
+
+// src/adapters/claude-code.ts
+function computeSeverity(event) {
+  if (event.type === "state_change") return "high";
+  if (event.mentions && event.mentions.length > 0) {
+    return "high";
+  }
+  return "normal";
+}
+function formatBody(event) {
+  if (event.type === "state_change") {
+    return `[Tandem: ${event.tandem_id}] ${event.from.displayname}: ${event.content.body}`;
+  }
+  return [
+    `[Tandem: ${event.tandem_id}] ${event.from.displayname} (${event.from.principal}) \u2014 ${event.kind}:`,
+    event.content.body,
+    "",
+    `> ${buildReplyRecipe({ tandem_id: event.tandem_id, message_id: event.id })}`
+  ].join("\n");
+}
+var claudeCodeAdapter = {
+  runtime: "claude-code",
+  supportsChannels: true,
+  formatTandemEvent(event) {
+    const meta = {
+      tandem_id: event.tandem_id,
+      message_id: event.id,
+      cursor: String(event.cursor),
+      kind: event.kind,
+      from_principal: event.from.principal,
+      from_display: event.from.displayname,
+      severity: computeSeverity(event)
+    };
+    if (event.wake_reason) meta.wake_reason = event.wake_reason;
+    return { content: formatBody(event), meta };
+  }
+};
+
+export {
+  claudeCodeAdapter
+};

package/dist/cli.js

@@ -3,25 +3,27 @@ import {
   runPair
 } from "./chunk-OGHDTFAX.js";
 import {
-  VERSION,
   startProxy
-} from "./chunk-D42PZX2I.js";
-import "./chunk-X672ZN7V.js";
-import "./chunk-BJMASMKX.js";
+} from "./chunk-3H3TL34J.js";
+import "./chunk-XXFVWP6H.js";
 import {
   pairedConfigPath
 } from "./chunk-YH27B6SW.js";
+import "./chunk-IMOEZ4NJ.js";
 import "./chunk-JXMVZEQ7.js";
-import "./chunk-HSR3GXCL.js";
-import "./chunk-MKDMAAMN.js";
-import "./chunk-2MIISF2W.js";
+import "./chunk-NR4Y54OL.js";
 import {
   defaultPairedKeystorePath,
   deriveKeystorePath
 } from "./chunk-CH32ELFX.js";
 import "./chunk-BLEGIR35.js";
+import {
+  VERSION
+} from "./chunk-CM3EKMDD.js";
+import "./chunk-X672ZN7V.js";
+import "./chunk-2OLXXOT3.js";
+import "./chunk-VHKPWUX7.js";
 import "./chunk-YKW54DKF.js";
-import "./chunk-LDZXU3DW.js";
 
 // src/cli.ts
 import { Command } from "commander";
@@ -43,15 +45,15 @@ program.command("pair <code>").description("Pair this machine against Kojee usin
 });
 program.command("hook").description("Run a kojee MCP hook script (called by Claude Code via ~/.claude/settings.json)").requiredOption("--type <type>", "Hook type: stop, user-prompt-submit, or codex-stop").action(async (opts) => {
   if (opts.type === "stop") {
-    const { runStopHook } = await import("./stop-hook-GEJF47SN.js");
+    const { runStopHook } = await import("./stop-hook-CUVDKXP7.js");
     await runStopHook();
     process.exit(0);
   } else if (opts.type === "user-prompt-submit") {
-    const { runUserPromptSubmitHook } = await import("./user-prompt-submit-hook-DGRRFHOB.js");
+    const { runUserPromptSubmitHook } = await import("./user-prompt-submit-hook-PMBUPKUV.js");
     await runUserPromptSubmitHook();
     process.exit(0);
   } else if (opts.type === "codex-stop") {
-    const { runCodexStopHook } = await import("./codex-stop-hook-SWA53ECG.js");
+    const { runCodexStopHook } = await import("./codex-stop-hook-VY7DOMAG.js");
     await runCodexStopHook();
     process.exit(0);
   } else {
@@ -77,7 +79,7 @@ Restart Claude Code for hooks to take effect.`
 program.command("send <tandem_id>").description(
   "Send a Tandem message using this machine's paired credentials (~/.kojee). Prints one JSON envelope to stdout: {ok, message_id, cursor, text} on success, {ok:false, error:<typed code>, message} on failure (exit 1)."
 ).requiredOption("--body <text>", "Message body (required)").option("--reply-to <message_id>", "Message id this send replies to").option("--kind <kind>", "Message kind: message | status (default: backend default)").action(async (tandemId, opts) => {
-  const { runSendCli } = await import("./send-cli-CN5EX7PO.js");
+  const { runSendCli } = await import("./send-cli-RH7D4JDP.js");
   const { exitCode, envelope } = await runSendCli({
     tandemId,
     body: opts.body,
@@ -88,7 +90,7 @@ program.command("send <tandem_id>").description(
   process.exit(exitCode);
 });
 program.command("tail <path>").description("Stream a file's contents and follow appends (portable replacement for `tail -F`)").action(async (filePath) => {
-  const { runTail } = await import("./tail-stream-JNR4WFW3.js");
+  const { runTail } = await import("./tail-stream-5DAVRQYK.js");
   try {
     await runTail(filePath);
   } catch (err) {
@@ -97,7 +99,7 @@ program.command("tail <path>").description("Stream a file's contents and follow
   }
 });
 program.command("doctor").description("Diagnose the kojee wake path (proxy, hook-server, SSE stream, event log, Monitor) and print the exact wake recipe").action(async () => {
-  const { runDoctor } = await import("./doctor-XK335W7B.js");
+  const { runDoctor } = await import("./doctor-FVTALRQD.js");
   const code = await runDoctor();
   process.exit(code);
 });
@@ -138,7 +140,7 @@ program.command("init").description(
     console.error("Not paired. Run `kojee-mcp pair <code> --url <broker>` first, then re-run `init` \u2014 or pass --token/--pair-code, or run `init` in a terminal for the guided wizard.");
     process.exit(1);
   }
-  const { runWizard } = await import("./wizard-PLGHYCT3.js");
+  const { runWizard } = await import("./wizard-L4MYRLJI.js");
   const result = await runWizard({
     ...opts.runtime !== void 0 ? { runtime: opts.runtime } : {},
     ...opts.uninstall ? { uninstall: true } : {},

package/dist/codex-stop-hook-VY7DOMAG.js

@@ -0,0 +1,16 @@
+import {
+  CODEX_PEEK_BUDGET_MS,
+  codexPendingMarkerPath,
+  decideCodexStopHook,
+  defaultPeekPending,
+  runCodexStopHook
+} from "./chunk-35XBRG3V.js";
+import "./chunk-LSUB6QMP.js";
+import "./chunk-X672ZN7V.js";
+export {
+  CODEX_PEEK_BUDGET_MS,
+  codexPendingMarkerPath,
+  decideCodexStopHook,
+  defaultPeekPending,
+  runCodexStopHook
+};

package/dist/{doctor-XK335W7B.js → doctor-FVTALRQD.js}

@@ -1,14 +1,20 @@
+import "./chunk-XLKGPGZT.js";
+import {
+  loadControlToken
+} from "./chunk-GI2CKKBL.js";
 import {
   monitorHeartbeatPath,
   statusLogPath
-} from "./chunk-DS26OORG.js";
+} from "./chunk-CO73VGWM.js";
 import {
   discoveryPathForKey,
-  readSessionDiscoveryByKey
+  readSessionDiscoveryByKey,
+  sessionDiscoveryDir
 } from "./chunk-DO42NPNR.js";
 import {
-  loadControlToken
-} from "./chunk-GI2CKKBL.js";
+  loadPairedConfig
+} from "./chunk-YH27B6SW.js";
+import "./chunk-BLEGIR35.js";
 import {
   buildMonitorSpawn,
   buildReplyRecipe
@@ -16,14 +22,74 @@ import {
 import {
   deriveDiscoveryKey,
   findClaudeAncestorPid
-} from "./chunk-BJMASMKX.js";
-import {
-  loadPairedConfig
-} from "./chunk-YH27B6SW.js";
-import "./chunk-BLEGIR35.js";
+} from "./chunk-VHKPWUX7.js";
 
 // src/doctor.ts
 import fs from "fs";
+import os from "os";
+import path from "path";
+var SENTINEL_FRESH_MS = 5e3;
+function eventLogKey(logPath) {
+  const m = logPath.replace(/^.*[/\\]/, "").match(/^kojee-events-(.+)\.log$/);
+  return m ? m[1] : null;
+}
+function defaultListSiblingProxies(selfKey) {
+  const dir = sessionDiscoveryDir();
+  let names;
+  try {
+    names = fs.readdirSync(dir);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const name of names) {
+    if (!name.startsWith("cc-") || !name.endsWith(".json")) continue;
+    const key = name.slice("cc-".length, -".json".length);
+    if (key === selfKey) continue;
+    try {
+      const entry = JSON.parse(fs.readFileSync(path.join(dir, name), "utf8"));
+      const proxyPid = entry.proxyPid ?? entry.pid;
+      const proxyPidAlive = typeof proxyPid === "number" && defaultIsPidAlive(proxyPid);
+      let webhookStatusLine = null;
+      if (entry.eventLogPath) {
+        const last = defaultReadLastStatusLine(statusLogPath(entry.eventLogPath));
+        if (last && last.includes("status=webhook enabled")) webhookStatusLine = last;
+      }
+      out.push({ key, proxyPidAlive, webhookStatusLine });
+    } catch {
+    }
+  }
+  return out;
+}
+async function resolveThisWebhookEnabled() {
+  try {
+    const { resolveWebhookConfig } = await import("./webhook-config-O4WMQ532.js");
+    return resolveWebhookConfig().enabled === true;
+  } catch {
+    return false;
+  }
+}
+function defaultListMonitorSentinels() {
+  const dir = os.tmpdir();
+  let names;
+  try {
+    names = fs.readdirSync(dir);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const name of names) {
+    const m = name.match(/^kojee-monitor-(.+)\.alive$/);
+    if (!m) continue;
+    const p = path.join(dir, name);
+    try {
+      const s = fs.statSync(p);
+      out.push({ path: p, key: m[1], mtimeMs: s.mtimeMs });
+    } catch {
+    }
+  }
+  return out;
+}
 function defaultIsPidAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -33,23 +99,23 @@ function defaultIsPidAlive(pid) {
     return false;
   }
 }
-function defaultStat(path) {
+function defaultStat(path2) {
   try {
-    const s = fs.statSync(path);
+    const s = fs.statSync(path2);
     return { mtimeMs: s.mtimeMs, size: s.size };
   } catch {
     return null;
   }
 }
 var STATUS_TAIL_BYTES = 64 * 1024;
-function defaultReadLastStatusLine(path) {
+function defaultReadLastStatusLine(path2) {
   let fd = null;
   try {
-    const { size } = fs.statSync(path);
+    const { size } = fs.statSync(path2);
     const start = Math.max(0, size - STATUS_TAIL_BYTES);
     const len = size - start;
     if (len === 0) return null;
-    fd = fs.openSync(path, "r");
+    fd = fs.openSync(path2, "r");
     const buf = Buffer.alloc(len);
     fs.readSync(fd, buf, 0, len, start);
     const text = buf.toString("utf8");
@@ -181,6 +247,35 @@ async function collectDoctorReport(deps = {}) {
       detail: sentinelFresh ? "live (a Monitor is reading the log)" : "no fresh sentinel \u2014 spawn the Monitor (recipe below)"
     });
   }
+  const webhookSinkEnabled = deps.webhookSinkEnabled !== void 0 ? deps.webhookSinkEnabled : await resolveThisWebhookEnabled();
+  if (!webhookSinkEnabled) {
+    const listSiblings = deps.listSiblingProxies ?? defaultListSiblingProxies;
+    const siblingsWithWebhook = listSiblings(discoveryKey).filter(
+      (s) => s.proxyPidAlive && s.webhookStatusLine
+    );
+    if (siblingsWithWebhook.length > 0) {
+      checks.push({
+        name: "sibling webhook sink",
+        ok: "warn",
+        detail: `another live proxy has a webhook sink enabled while this session's is OFF \u2014 Tandem events may be delivered via that sibling's webhook, not your Monitor. Sibling key(s): ${siblingsWithWebhook.map((s) => s.key).join(", ")}.`
+      });
+    }
+  }
+  if (logPath) {
+    const currentKey = eventLogKey(logPath);
+    const listSentinels = deps.listMonitorSentinels ?? defaultListMonitorSentinels;
+    const now = Date.now();
+    const staleLiveMonitors = listSentinels().filter(
+      (s) => now - s.mtimeMs < SENTINEL_FRESH_MS && s.key !== currentKey
+    );
+    if (staleLiveMonitors.length > 0) {
+      checks.push({
+        name: "stale Monitor",
+        ok: "warn",
+        detail: `a live Monitor is tailing ${staleLiveMonitors.map((s) => s.path).join(", ")}, but current events go to ${logPath} \u2014 re-spawn the Monitor with the recipe below.`
+      });
+    }
+  }
   checks.push({
     name: "wire contract",
     ok: "unknown",
@@ -233,7 +328,7 @@ function formatDoctorReport(report) {
 async function runDoctor() {
   const { readRecordedRuntime } = await import("./runtime-record-WO4IECM6.js");
   if (readRecordedRuntime() === "codex") {
-    const { collectCodexDoctorReport, formatCodexDoctorReport } = await import("./doctor-codex-SMROUYGV.js");
+    const { collectCodexDoctorReport, formatCodexDoctorReport } = await import("./doctor-codex-PA3WO6LR.js");
     const report2 = collectCodexDoctorReport();
     console.error(formatCodexDoctorReport(report2));
     return report2.verdict === "broken" ? 1 : 0;

package/dist/{event-log-B27VVEMK.js → event-log-VZD7NKYX.js}

@@ -5,7 +5,7 @@ import {
   startEventLog,
   statusLogPath,
   sweepStaleEventLogs
-} from "./chunk-DS26OORG.js";
+} from "./chunk-CO73VGWM.js";
 import "./chunk-DO42NPNR.js";
 import "./chunk-BLEGIR35.js";
 export {

package/dist/event-stream-XX5EZ6HN.js

@@ -0,0 +1,19 @@
+import {
+  UNDICI_DEFAULT_BODY_TIMEOUT_MS,
+  createAdaptiveWatchdog,
+  createBackoffController,
+  normalizeBackendEvent,
+  sanitizeDisplayname,
+  serializeCursorMap,
+  startEventStream
+} from "./chunk-74XFVX6Z.js";
+import "./chunk-NR4Y54OL.js";
+export {
+  UNDICI_DEFAULT_BODY_TIMEOUT_MS,
+  createAdaptiveWatchdog,
+  createBackoffController,
+  normalizeBackendEvent,
+  sanitizeDisplayname,
+  serializeCursorMap,
+  startEventStream
+};

package/dist/{gateway-client-93P1E0CZ.d.ts → gateway-client-C6yx1mfM.d.ts}

@@ -26,6 +26,11 @@ interface LoadedKeyPair {
     publicJwk: JWK;
     kid: string;
 }
+interface McpToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
 interface GovernanceMeta {
     decision: "require_approval" | "deny" | "allow";
     approval_id?: string;
@@ -89,4 +94,4 @@ declare class GatewayClient {
     private tryParseErrorBody;
 }
 
-export { GatewayClient as G, type KeystoreData as K, type LoadedKeyPair as L, type ProxyConfig as P, type ToolCallResult as T };
+export { GatewayClient as G, type KeystoreData as K, type LoadedKeyPair as L, type McpToolDefinition as M, type ProxyConfig as P, type ToolCallResult as T };