kojee-mcp 0.7.1 → 0.7.3

package/dist/{chunk-KPMD72FY.js → chunk-6XWTUDWW.js}

@@ -2,7 +2,7 @@ import {
   buildHookCommand,
   isKojeeHookCommand,
   npxHookCommand
-} from "./chunk-QJFMU4QC.js";
+} from "./chunk-TMCNB4JH.js";
 import {
   wrapNpxLauncher
 } from "./chunk-D6JKFJ6A.js";
@@ -12,6 +12,9 @@ import {
 import {
   secureFile
 } from "./chunk-U5HHHRXA.js";
+import {
+  VERSION
+} from "./chunk-5DHIUN73.js";
 
 // src/wizard/codex-config.ts
 import fs from "fs";
@@ -33,14 +36,22 @@ var CODEX_STOP_HOOK_COMMAND = npxHookCommand("codex-stop");
 function codexStopHookCommand() {
   return buildHookCommand("codex-stop");
 }
+function codexPromptSubmitHookCommand() {
+  return buildHookCommand("codex-prompt-submit");
+}
+var CODEX_HOOK_TIMEOUT_SEC = 10;
+function codexNpxPackageSpec() {
+  return /^\d/.test(VERSION) ? `kojee-mcp@${VERSION}` : "kojee-mcp";
+}
 function codexRestArgs(token, url, pairedConfigPath) {
+  const spec = codexNpxPackageSpec();
   if (token && url) {
-    return ["-y", "kojee-mcp", "--token", token, "--url", url];
+    return ["-y", spec, "--token", token, "--url", url];
   }
   if (pairedConfigPath) {
-    return ["-y", "kojee-mcp", "--paired-config", pairedConfigPath];
+    return ["-y", spec, "--paired-config", pairedConfigPath];
   }
-  return ["-y", "kojee-mcp"];
+  return ["-y", spec];
 }
 function codexLauncherLiterals(token, url, pairedConfigPath) {
   const rest = codexRestArgs(token, url, pairedConfigPath);
@@ -76,7 +87,17 @@ function buildCodexStopHookBlock() {
     "[[hooks.Stop]]",
     "[[hooks.Stop.hooks]]",
     'type = "command"',
-    `command = "${escapeTomlString(codexStopHookCommand())}"`
+    `command = "${escapeTomlString(codexStopHookCommand())}"`,
+    `timeout = ${CODEX_HOOK_TIMEOUT_SEC}`
+  ].join("\n");
+}
+function buildCodexPromptSubmitHookBlock() {
+  return [
+    "[[hooks.UserPromptSubmit]]",
+    "[[hooks.UserPromptSubmit.hooks]]",
+    'type = "command"',
+    `command = "${escapeTomlString(codexPromptSubmitHookCommand())}"`,
+    `timeout = ${CODEX_HOOK_TIMEOUT_SEC}`
   ].join("\n");
 }
 function escapeTomlString(s) {
@@ -97,13 +118,13 @@ function scrubPlaceholderWebhookEnv(envKeys) {
 function writeCodexConfig(inputs) {
   const configPath = inputs.configPath ?? defaultCodexConfigPath();
   const hooksPath = inputs.hooksPath ?? defaultCodexHooksPath();
-  let toml = "";
+  let existingToml = "";
   try {
-    toml = fs.readFileSync(configPath, "utf8");
+    existingToml = fs.readFileSync(configPath, "utf8");
   } catch {
   }
-  toml = upsertKojeeTomlTables(
-    toml,
+  const newToml = upsertKojeeTomlTables(
+    existingToml,
     inputs.webhookUrl,
     inputs.webhookSecret,
     inputs.signatureEnv ?? [],
@@ -111,18 +132,31 @@ function writeCodexConfig(inputs) {
     inputs.url,
     inputs.pairedConfigPath
   );
-  writeFile600(configPath, toml);
-  const command = codexStopHookCommand();
+  const tomlChanged = newToml !== existingToml;
+  if (tomlChanged) writeFile600(configPath, newToml);
   const hooks = readJson(hooksPath);
   hooks.hooks ??= {};
-  hooks.hooks.Stop ??= [];
+  upsertKojeeHookEntry(hooks, "Stop", codexStopHookCommand());
+  upsertKojeeHookEntry(hooks, "UserPromptSubmit", codexPromptSubmitHookCommand());
+  const newHooks = JSON.stringify(hooks, null, 2);
+  let existingHooksRaw = "";
+  try {
+    existingHooksRaw = fs.readFileSync(hooksPath, "utf8");
+  } catch {
+  }
+  const hooksChanged = newHooks !== existingHooksRaw;
+  if (hooksChanged) writeFile600(hooksPath, newHooks);
+  return { tomlChanged, hooksChanged };
+}
+function upsertKojeeHookEntry(hooks, event, command) {
+  hooks.hooks ??= {};
+  hooks.hooks[event] ??= [];
   let present = false;
-  for (const e of hooks.hooks.Stop) {
+  for (const e of hooks.hooks[event]) {
     for (const h of e.hooks ?? []) {
-      if (h.command === command) {
-        present = true;
-      } else if (isKojeeHookCommand(h.command)) {
+      if (h.command === command || isKojeeHookCommand(h.command)) {
         h.command = command;
+        h.timeout = CODEX_HOOK_TIMEOUT_SEC;
         present = true;
       }
       if (present) break;
@@ -130,11 +164,10 @@ function writeCodexConfig(inputs) {
     if (present) break;
   }
   if (!present) {
-    hooks.hooks.Stop.push({
-      hooks: [{ type: "command", command }]
+    hooks.hooks[event].push({
+      hooks: [{ type: "command", command, timeout: CODEX_HOOK_TIMEOUT_SEC }]
     });
   }
-  writeFile600(hooksPath, JSON.stringify(hooks, null, 2));
 }
 function removeCodexConfig(opts = {}) {
   const configPath = opts.configPath ?? defaultCodexConfigPath();
@@ -151,18 +184,23 @@ function removeCodexConfig(opts = {}) {
   }
   try {
     const hooks = readJson(hooksPath);
-    const stop = hooks.hooks?.Stop;
-    if (stop && stop.length > 0) {
-      const before = stop.length;
-      hooks.hooks.Stop = stop.filter(
+    let changed = false;
+    for (const event of ["Stop", "UserPromptSubmit"]) {
+      const entries = hooks.hooks?.[event];
+      if (!entries || entries.length === 0) continue;
+      const kept = entries.filter(
         // F10: strip kojee entries in EITHER persisted form (npx or pinned).
         (e) => !e.hooks?.some((h) => isKojeeHookCommand(h.command))
       );
-      if (hooks.hooks.Stop.length !== before) {
-        result.stopHook = true;
-        writeFile600(hooksPath, JSON.stringify(hooks, null, 2));
+      if (kept.length !== entries.length) {
+        hooks.hooks[event] = kept;
+        changed = true;
       }
     }
+    if (changed) {
+      result.stopHook = true;
+      writeFile600(hooksPath, JSON.stringify(hooks, null, 2));
+    }
   } catch {
   }
   return result;
@@ -309,6 +347,7 @@ export {
   defaultCodexHooksPath,
   buildCodexMcpServerTable,
   buildCodexStopHookBlock,
+  buildCodexPromptSubmitHookBlock,
   isPlaceholderWebhookUrl,
   writeCodexConfig,
   removeCodexConfig

package/dist/{chunk-GNLCUJBK.js → chunk-A4IOKD4Z.js}

@@ -6,7 +6,7 @@ import {
   buildCondensedTandemRules,
   buildMonitorSpawn,
   buildReplyRecipe
-} from "./chunk-SSW5AQSR.js";
+} from "./chunk-FJUAMJHU.js";
 import {
   translateToolCallResult
 } from "./chunk-PPTKGWFF.js";
@@ -40,15 +40,112 @@ function buildChannelInstructions(_tandemMembershipCount, eventLogPath) {
 function tandemIdArg(args) {
   return typeof args["tandem_id"] === "string" ? args["tandem_id"] : null;
 }
+function parseJoinDisplayName(content) {
+  for (const item of content) {
+    if (item.type !== "text" || typeof item.text !== "string") continue;
+    try {
+      const parsed = JSON.parse(item.text);
+      if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+        const name = parsed["display_name"];
+        if (typeof name === "string" && name.length > 0) return name;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function parseJoinStatus(content) {
+  for (const item of content) {
+    if (item.type !== "text" || typeof item.text !== "string") continue;
+    try {
+      const parsed = JSON.parse(item.text);
+      if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+        const status = parsed["status"];
+        if (typeof status === "string") return status;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+var SKIP_ADVISORY_STATUSES = /* @__PURE__ */ new Set(["pending_approval", "needs_invite"]);
+function buildUnnamedJoinAdvisory(args, content) {
+  const seatName = args["seat_name"];
+  if (typeof seatName === "string" && seatName.trim().length > 0) return null;
+  const status = parseJoinStatus(content);
+  if (status !== null && SKIP_ADVISORY_STATUSES.has(status)) return null;
+  const displayName = parseJoinDisplayName(content);
+  const handleClause = displayName !== null ? `the room minted a generated handle ('${displayName}')` : "the room minted a generated handle";
+  const text = `[kojee] You joined WITHOUT seat_name \u2014 ${handleClause}. If you previously held a name in this room, re-join now with tandem_join(tandem_id, seat_name=<your name>) to rebind your seat; mentions to your old name will NOT reach this seat until you do.`;
+  return { type: "text", text };
+}
+var DRAIN_TOOLS = /* @__PURE__ */ new Set(["tandem_messages", "tandem_ack"]);
+function extractDrainCursor(name, args, content) {
+  const candidates = [];
+  const push = (v) => {
+    if (typeof v === "number" && Number.isFinite(v) && v >= 0) candidates.push(Math.floor(v));
+  };
+  if (name === "tandem_ack") push(args["cursor"]);
+  for (const item of content) {
+    if (item.type !== "text" || typeof item.text !== "string") continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(item.text);
+    } catch {
+      continue;
+    }
+    const rows = Array.isArray(parsed) ? parsed : [];
+    if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+      const obj = parsed;
+      push(obj["cursor"]);
+      push(obj["latest_cursor"]);
+      push(obj["next_cursor"]);
+      for (const key of ["messages", "events"]) {
+        const arr = obj[key];
+        if (Array.isArray(arr)) rows.push(...arr);
+      }
+    }
+    for (const row of rows) {
+      if (row !== null && typeof row === "object") push(row["cursor"]);
+    }
+  }
+  return candidates.length > 0 ? Math.max(...candidates) : null;
+}
 async function executeToolCall(registry, name, args, hooks) {
   const rawResult = await registry.callTool(name, args);
-  const result = translateToolCallResult(rawResult);
+  let result = translateToolCallResult(rawResult);
   if (!result.isError && name === "tandem_join") {
     try {
       hooks?.onTandemJoin?.(tandemIdArg(args));
     } catch (err) {
       console.error("[mcp] onTandemJoin hook failed:", err?.message ?? String(err));
     }
+    try {
+      const advisory = buildUnnamedJoinAdvisory(args, result.content);
+      if (advisory !== null) {
+        result = { ...result, content: [...result.content, advisory] };
+      }
+    } catch (err) {
+      console.error("[mcp] unnamed-join advisory decoration failed:", err?.message ?? String(err));
+    }
+  }
+  if (!result.isError && name === "tandem_leave") {
+    try {
+      hooks?.onTandemLeave?.(tandemIdArg(args));
+    } catch (err) {
+      console.error("[mcp] onTandemLeave hook failed:", err?.message ?? String(err));
+    }
+  }
+  if (!result.isError && DRAIN_TOOLS.has(name)) {
+    const tandemId = tandemIdArg(args);
+    const cursor = tandemId !== null ? extractDrainCursor(name, args, result.content) : null;
+    if (tandemId !== null && cursor !== null) {
+      try {
+        hooks?.onTandemDrain?.(tandemId, cursor);
+      } catch (err) {
+        console.error("[mcp] onTandemDrain hook failed:", err?.message ?? String(err));
+      }
+    }
   }
   return result;
 }
@@ -88,6 +185,7 @@ async function startMcpServer(server) {
 export {
   buildNonChannelInstructions,
   buildChannelInstructions,
+  extractDrainCursor,
   executeToolCall,
   createMcpServer,
   startMcpServer

package/dist/{chunk-FBJCPRVH.js → chunk-ABECLEYE.js}

@@ -1,6 +1,6 @@
 import {
   claudeCodeAdapter
-} from "./chunk-UPJV7GBE.js";
+} from "./chunk-TCWIXG5C.js";
 import {
   GatewayClient,
   applyStableSessionId
@@ -11,7 +11,7 @@ import {
 import {
   createMcpServer,
   startMcpServer
-} from "./chunk-GNLCUJBK.js";
+} from "./chunk-A4IOKD4Z.js";
 import {
   findClaudeAncestorPid
 } from "./chunk-XJEBJIQE.js";
@@ -29,6 +29,21 @@ var ToolRegistry = class {
   gateway;
   /** Flat map: tool name → full tool definition */
   tools = /* @__PURE__ */ new Map();
+  /**
+   * LOCAL tools answered in-process by this proxy (e.g. codex's
+   * `tandem_pending` — per-window state the gateway cannot know). Local wins
+   * over a same-named gateway tool in both list and dispatch, so a future
+   * backend tool can never silently shadow a proxy-local answer.
+   */
+  localTools = /* @__PURE__ */ new Map();
+  /**
+   * Register a proxy-local tool. Callers gate registration per-runtime (see
+   * tandem/pending-state.ts installPendingTool) — an un-opted runtime's tool
+   * list must stay byte-identical to the gateway's.
+   */
+  registerLocalTool(definition, handler) {
+    this.localTools.set(definition.name, { definition, handler });
+  }
   /**
    * Fetch all tools with full schemas from the gateway in a single RPC call.
    */
@@ -56,15 +71,37 @@ var ToolRegistry = class {
     console.error(`[tools] Registered ${this.tools.size} tools from gateway`);
   }
   /**
-   * Return all registered tools for the MCP ListTools response.
+   * Return all registered tools for the MCP ListTools response — gateway tools
+   * first (minus any a local tool shadows), then local tools.
    */
   getAllTools() {
-    return Array.from(this.tools.values());
+    const gatewayTools = Array.from(this.tools.values()).filter(
+      (t) => !this.localTools.has(t.name)
+    );
+    const localDefs = Array.from(this.localTools.values()).map((t) => t.definition);
+    return [...gatewayTools, ...localDefs];
   }
   /**
-   * Call a tool through the gateway.
+   * Call a tool — local tools are answered in-process; everything else goes
+   * through the gateway.
    */
   async callTool(name, args) {
+    const local = this.localTools.get(name);
+    if (local) {
+      try {
+        return await local.handler(args);
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Local tool '${name}' failed: ${err?.message ?? String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
     if (!this.tools.has(name)) {
       const available = Array.from(this.tools.keys()).slice(0, 10).join(", ");
       return {
@@ -82,9 +119,9 @@ var ToolRegistry = class {
       arguments: args
     });
   }
-  /** Total number of registered tools. */
+  /** Total number of registered tools (gateway + local, shadowed names once). */
   get toolCount() {
-    return this.tools.size;
+    return this.getAllTools().length;
   }
 };
 
@@ -218,9 +255,16 @@ async function startProxy(config) {
       return true;
     }
   });
-  const onTandemJoin = (_tandemId) => {
+  const { installPendingTool, createRuntimeDrainHook } = await import("./pending-state-6TVRR63P.js");
+  const pendingState = installPendingTool(adapter.runtime, registry);
+  const onTandemJoin = (tandemId) => {
     joinReconnect.requestReconnect();
+    if (tandemId !== null) pendingState?.noteSeat(tandemId);
   };
+  const onTandemLeave = pendingState ? (tandemId) => {
+    if (tandemId !== null) pendingState.dropSeat(tandemId);
+  } : void 0;
+  const onTandemDrain = createRuntimeDrainHook(adapter.runtime, pendingState);
   const teardownSteps = [];
   let shuttingDown = false;
   function shutdown(reason) {
@@ -251,9 +295,12 @@ async function startProxy(config) {
   }
   console.error(`[kojee-mcp] Tandem memberships: ${tandemMembershipCount === -1 ? "unknown" : tandemMembershipCount}`);
   let server;
-  const { selectDelivery } = await import("./registry-ZZZ26WGA.js");
+  const { selectDelivery } = await import("./registry-2QS42EQF.js");
   const delivery = selectDelivery(adapter.runtime, {
-    supportsChannels: adapter.supportsChannels
+    supportsChannels: adapter.supportsChannels,
+    // Per-window delivered mirror for the tandem_pending tool (codex only —
+    // other runtimes' deliveries ignore this even when passed).
+    ...pendingState ? { onDelivered: (e) => pendingState.noteDelivered(e.tandem_id, e.cursor) } : {}
   });
   if (delivery) {
     const started = await delivery.start({
@@ -266,7 +313,11 @@ async function startProxy(config) {
       ccPid,
       tandemMembershipCount,
       listTandemIds: () => listTandemIds(gateway),
-      toolCallHooks: { onTandemJoin },
+      toolCallHooks: {
+        onTandemJoin,
+        ...onTandemLeave ? { onTandemLeave } : {},
+        ...onTandemDrain ? { onTandemDrain } : {}
+      },
       onStreamReady: (handle) => {
         activeStreamHandle = handle;
         joinReconnect.notifyReady();

package/dist/{chunk-SSW5AQSR.js → chunk-FJUAMJHU.js}

@@ -16,7 +16,7 @@ function buildCatchUpNote() {
   return "Cursors are allocated per-Tandem, and the event-log interleaves every subscribed room into one stream \u2014 so track the last `cursor=<n>` you saw keyed by the line's `tandem=<id>` field, and only treat a jump WITHIN the same tandem_id as a gap (a jump between lines from different rooms is normal interleaving, not a missed message). If the cursor jumps within one tandem, or the log resets (the proxy caps and truncates the messages log in place on overflow \u2014 a `status=rotated` line is recorded in the status sibling), you may have missed messages: catch up with tandem_messages(tandem_id, since=<last cursor you saw for THAT tandem>).";
 }
 function buildCondensedTandemRules() {
-  return "Tandem ground rules: (1) catch up before you speak \u2014 fetch messages since your last cursor (cursors are per-Tandem); never answer from a stale view. (2) close every loop \u2014 taking / done (with evidence) / blocked, said out loud; silence is a bug on a team. (3) your seat_name IS your room identity \u2014 keep it stable across sessions and reconnects. (4) plan your wake path per task and set your wake filter deliberately (heads-down \u2192 mentions; waiting on one reply \u2192 listen; co-working \u2192 all), and tell the room your posture.";
+  return "Tandem ground rules: (1) catch up before you speak \u2014 fetch messages since your last cursor (cursors are per-Tandem); never answer from a stale view. (2) close every loop \u2014 taking / done (with evidence) / blocked, said out loud; silence is a bug on a team. (3) your seat_name IS your room identity \u2014 keep it stable across sessions and reconnects. (4) plan your wake path per task and set your wake filter deliberately (heads-down \u2192 mentions; waiting on one reply \u2192 listen; co-working \u2192 all), and tell the room your posture WHEN IT CHANGES \u2014 skip the check-in ceremony when you are merely re-joining/reconnecting with the same posture. (5) send all replies and check-ins as kind=message \u2014 never kind=status; status is lifecycle-only (joined/left, system-generated).";
 }
 function buildMonitorNudge(logPath) {
   return `[kojee] Tandem events are being logged but no Monitor is reading them \u2014 you may be missing wake notifications. Spawn the watcher once: ${buildMonitorSpawn(logPath)}. Then ${buildReplyRecipe()}.`;
@@ -29,10 +29,7 @@ function buildWebhookReceiverNote(sig) {
   return "Webhook sink (optional, OFF unless KOJEE_WEBHOOK_URL + KOJEE_WEBHOOK_SECRET are set): the proxy POSTs every Tandem event as JSON to your endpoint. The body is the canonical normalized TandemEvent \u2014 " + WEBHOOK_BODY_SHAPE + ` \u2014 where from.session_id and severity are present only when the wire carried them (the body is fully normalized: it carries from.principal, never the raw backend sender envelope). To build a receiver: (1) verify the ${header} header \u2014 it is ${digestDesc} of the RAW request body bytes keyed by your KOJEE_WEBHOOK_SECRET; recompute over the received bytes and timing-safe compare, reject mismatches. (2) Dedupe by message_id \u2014 the body's \`id\`, also in the X-Kojee-Delivery header: delivery is AT-LEAST-ONCE (the proxy replays backlog from the cursor on restart), so the same event may arrive more than once \u2014 there is no exactly-once promise.`;
 }
 var CODEX_LISTEN_CAP_MS = 8e3;
-function buildCodexWakeReason(cursor) {
-  const drainSince = Math.max(0, cursor - 1);
-  return `[kojee] new Tandem event(s) pending (cursor=${cursor}). If relevant to your task, drain them now: call tandem_messages(tandem_id, since=${drainSince}) to read, then ` + buildReplyRecipe() + `. If you expect an imminent reply and want to wait for exactly one, call tandem_listen(tandem_id, since=${cursor}, timeout_ms<=${CODEX_LISTEN_CAP_MS}) \u2014 a BOUNDED wait, cap 8s, NEVER an unconditional long-poll. If not relevant, ignore.`;
-}
+var CODEX_WAKE_BELL = "[kojee] Tandem events may be pending. Call tandem_pending now and drain each room it lists (tandem_messages(id, since=cursor)), then reply in the room with a normal message (kind=message \u2014 never status). If it returns none for you, ignore this.";
 
 export {
   buildMonitorSpawn,
@@ -42,5 +39,5 @@ export {
   buildMonitorNudge,
   buildWebhookReceiverNote,
   CODEX_LISTEN_CAP_MS,
-  buildCodexWakeReason
+  CODEX_WAKE_BELL
 };

package/dist/{chunk-FSKGQ6GT.js → chunk-HI42GBQ3.js}

@@ -41,6 +41,9 @@ function createAdaptiveWatchdog(options = {}) {
     },
     armedThresholdMs() {
       return thresholdMs();
+    },
+    resetCadenceAnchor() {
+      prevHeartbeatAt = null;
     }
   };
 }
@@ -443,9 +446,11 @@ function normalizeBackendEvent(raw, sseEventType) {
 }
 
 export {
+  UNARMED_FALLBACK_MS,
   UNDICI_DEFAULT_BODY_TIMEOUT_MS,
   createAdaptiveWatchdog,
   createBackoffController,
+  LOG_HEARTBEAT_INTERVAL_MS,
   startEventStream,
   statusReason,
   serializeCursorMap,

package/dist/chunk-IZN7IZPW.js

@@ -0,0 +1,132 @@
+// src/delivery/pending-ledger.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+var LEDGER_MAX_ROOMS = 16;
+function pendingRoomsPath() {
+  return path.join(os.homedir(), ".kojee", "pending-rooms");
+}
+function drainedRoomsPath() {
+  return pendingRoomsPath() + ".drained";
+}
+function legacyMarkerPath() {
+  return path.join(os.homedir(), ".kojee", "codex-pending");
+}
+function legacyAckPath() {
+  return legacyMarkerPath() + ".ack";
+}
+function readEntries(filePath) {
+  let raw;
+  try {
+    raw = fs.readFileSync(filePath, "utf8");
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed === "") continue;
+    const parts = trimmed.split(/\s+/);
+    if (parts.length !== 2) continue;
+    const id = parts[0];
+    const cursor = Number.parseInt(parts[1], 10);
+    if (!Number.isFinite(cursor) || cursor < 0) continue;
+    const existing = out.findIndex((e) => e.id === id);
+    if (existing !== -1) {
+      const prev = out[existing];
+      out.splice(existing, 1);
+      out.push({ id, cursor: Math.max(prev.cursor, cursor) });
+    } else {
+      out.push({ id, cursor });
+    }
+  }
+  return out;
+}
+function writeEntries(filePath, entries) {
+  const tmp = `${filePath}.tmp-${process.pid}`;
+  try {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const body = entries.map((e) => `${e.id} ${e.cursor}`).join("\n") + (entries.length ? "\n" : "");
+    fs.writeFileSync(tmp, body, { mode: 384 });
+    fs.renameSync(tmp, filePath);
+  } catch {
+    try {
+      fs.unlinkSync(tmp);
+    } catch {
+    }
+  }
+}
+function upsert(filePath, tandemId, cursor, minCursor) {
+  const id = String(tandemId ?? "").replace(/\s+/g, "");
+  if (id === "") return;
+  if (!Number.isFinite(cursor) || cursor < minCursor) return;
+  const next = Math.floor(cursor);
+  const entries = readEntries(filePath);
+  const existing = entries.findIndex((e) => e.id === id);
+  let value = next;
+  if (existing !== -1) {
+    value = Math.max(entries[existing].cursor, next);
+    entries.splice(existing, 1);
+  }
+  entries.push({ id, cursor: value });
+  while (entries.length > LEDGER_MAX_ROOMS) entries.shift();
+  writeEntries(filePath, entries);
+}
+function recordDelivered(tandemId, cursor) {
+  try {
+    upsert(pendingRoomsPath(), tandemId, cursor, 1);
+  } catch {
+  }
+}
+function recordDrained(tandemId, cursor) {
+  try {
+    upsert(drainedRoomsPath(), tandemId, cursor, 0);
+  } catch {
+  }
+}
+function listPending() {
+  const delivered = readEntries(pendingRoomsPath());
+  const drained = new Map(readEntries(drainedRoomsPath()).map((e) => [e.id, e.cursor]));
+  const out = [];
+  try {
+    const body = fs.readFileSync(legacyMarkerPath(), "utf8").trim();
+    if (body !== "") {
+      let acked = null;
+      try {
+        acked = fs.readFileSync(legacyAckPath(), "utf8").trim();
+      } catch {
+        acked = null;
+      }
+      if (acked === null || acked !== body) {
+        const toks = body.split(/\s+/);
+        const parsedCursor = Number.parseInt(toks[0] ?? "", 10);
+        const cursor = Number.isFinite(parsedCursor) && parsedCursor >= 0 ? parsedCursor : 0;
+        const room = toks[1] ?? null;
+        if (room !== null) {
+          const drainedCursor = drained.get(room);
+          const inLedger = delivered.some((e) => e.id === room);
+          if (!inLedger && (drainedCursor === void 0 || drainedCursor < cursor)) {
+            out.push({ tandemId: room, cursor });
+          }
+        } else if (drained.size === 0) {
+          out.push({ tandemId: null, cursor });
+        }
+      }
+    }
+  } catch {
+  }
+  for (const entry of delivered) {
+    if (entry.cursor > (drained.get(entry.id) ?? 0)) {
+      out.push({ tandemId: entry.id, cursor: entry.cursor });
+    }
+  }
+  return out;
+}
+
+export {
+  pendingRoomsPath,
+  drainedRoomsPath,
+  recordDelivered,
+  recordDrained,
+  listPending
+};

package/dist/{chunk-UPJV7GBE.js → chunk-TCWIXG5C.js}

@@ -1,6 +1,6 @@
 import {
   buildReplyRecipe
-} from "./chunk-SSW5AQSR.js";
+} from "./chunk-FJUAMJHU.js";
 
 // src/adapters/claude-code.ts
 function computeSeverity(event) {

package/dist/{chunk-QJFMU4QC.js → chunk-TMCNB4JH.js}

@@ -20,7 +20,7 @@ function buildHookCommand(type, opts = {}) {
   const execPath = opts.execPath ?? process.execPath;
   return `"${execPath}" "${cliEntry}" hook --type=${type}`;
 }
-var PINNED_HOOK_RE = /^"[^"]+" "[^"]+" hook --type=(stop|user-prompt-submit|codex-stop)$/;
+var PINNED_HOOK_RE = /^"[^"]+" "[^"]+" hook --type=(stop|user-prompt-submit|codex-stop|codex-prompt-submit)$/;
 function isKojeeHookCommand(command) {
   if (command.startsWith("npx -y kojee-mcp hook --type=")) return true;
   return PINNED_HOOK_RE.test(command);