kojee-mcp 0.7.0 → 0.7.2

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-5H75AEZ2.js → chunk-R5GC2GRD.js}

@@ -1,6 +1,6 @@
 import {
   claudeCodeAdapter
-} from "./chunk-OB5T6P24.js";
+} from "./chunk-E35VWFZV.js";
 import {
   GatewayClient,
   applyStableSessionId
@@ -11,7 +11,7 @@ import {
 import {
   createMcpServer,
   startMcpServer
-} from "./chunk-SGRVG4HW.js";
+} from "./chunk-ZUIYFRO5.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-VRFHKOPP.js");
+  const { selectDelivery } = await import("./registry-42Y45L6I.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-OBIJ6WQP.js → chunk-RVLUZLXD.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) {
@@ -84,6 +105,16 @@ function escapeTomlString(s) {
 }
 var KOJEE_TABLE_HEADER = "[mcp_servers.kojee]";
 var KOJEE_ENV_TABLE_HEADER = "[mcp_servers.kojee.env]";
+function isPlaceholderWebhookUrl(url) {
+  return /^https?:\/\/YOUR-[A-Z0-9-]*\.local(?=[/:?#]|$)/i.test(url.trim());
+}
+function scrubPlaceholderWebhookEnv(envKeys) {
+  const urlEntry = envKeys.find(([k]) => k === "KOJEE_WEBHOOK_URL");
+  if (!urlEntry) return envKeys;
+  const raw = urlEntry[1].trim().replace(/^"(.*)"$/s, "$1").replace(/^'(.*)'$/s, "$1");
+  if (!isPlaceholderWebhookUrl(raw)) return envKeys;
+  return envKeys.filter(([k]) => k !== "KOJEE_WEBHOOK_URL" && k !== "KOJEE_WEBHOOK_SECRET");
+}
 function writeCodexConfig(inputs) {
   const configPath = inputs.configPath ?? defaultCodexConfigPath();
   const hooksPath = inputs.hooksPath ?? defaultCodexHooksPath();
@@ -102,17 +133,21 @@ function writeCodexConfig(inputs) {
     inputs.pairedConfigPath
   );
   writeFile600(configPath, toml);
-  const command = codexStopHookCommand();
   const hooks = readJson(hooksPath);
   hooks.hooks ??= {};
-  hooks.hooks.Stop ??= [];
+  upsertKojeeHookEntry(hooks, "Stop", codexStopHookCommand());
+  upsertKojeeHookEntry(hooks, "UserPromptSubmit", codexPromptSubmitHookCommand());
+  writeFile600(hooksPath, JSON.stringify(hooks, null, 2));
+}
+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;
@@ -120,11 +155,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();
@@ -141,18 +175,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;
@@ -176,7 +215,7 @@ function upsertKojeeTomlTables(existing, webhookUrl, webhookSecret, signatureEnv
     ["command", commandLiteral],
     ["args", argsLiteral]
   ]);
-  const envKeys = upsertKeyLines(parsed.envKeys, [
+  const envKeys = upsertKeyLines(scrubPlaceholderWebhookEnv(parsed.envKeys), [
     ["KOJEE_RUNTIME", '"codex"'],
     // Own KOJEE_WEBHOOK_URL/SECRET ONLY when supplied this run. The credential-
     // only `connect` path passes neither → they drop out of the owned set and
@@ -299,6 +338,8 @@ export {
   defaultCodexHooksPath,
   buildCodexMcpServerTable,
   buildCodexStopHookBlock,
+  buildCodexPromptSubmitHookBlock,
+  isPlaceholderWebhookUrl,
   writeCodexConfig,
   removeCodexConfig
 };

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);

package/dist/{chunk-QEJUNP3X.js → chunk-XFGGMDZ4.js}

@@ -15,6 +15,9 @@ function buildReplyRecipe(event) {
 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 WHEN IT CHANGES \u2014 skip the check-in ceremony when you are merely re-joining/reconnecting with the same posture.";
+}
 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()}.`;
 }
@@ -26,17 +29,15 @@ 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. If it returns none for you, ignore this.";
 
 export {
   buildMonitorSpawn,
   buildReplyRecipe,
   buildCatchUpNote,
+  buildCondensedTandemRules,
   buildMonitorNudge,
   buildWebhookReceiverNote,
   CODEX_LISTEN_CAP_MS,
-  buildCodexWakeReason
+  CODEX_WAKE_BELL
 };

package/dist/chunk-XLRF5ATG.js

@@ -0,0 +1,103 @@
+// src/delivery/codex-status.ts
+import fs from "fs";
+import fsp from "fs/promises";
+import os from "os";
+import path from "path";
+import crypto from "crypto";
+var CODEX_STATUS_HEARTBEAT_MS = 6e4;
+var CODEX_STATUS_STALE_MS = 5 * 6e4;
+function codexStatusDir() {
+  return path.join(os.homedir(), ".kojee");
+}
+function codexStatusPath(pid = process.pid) {
+  return path.join(codexStatusDir(), `codex-status-${pid}.json`);
+}
+var STATUS_FILE_RE = /^codex-status(?:-(\d+))?\.json$/;
+function readAllCodexStatusRaw() {
+  const dir = codexStatusDir();
+  let names;
+  try {
+    names = fs.readdirSync(dir);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const name of names.filter((n) => STATUS_FILE_RE.test(n)).sort()) {
+    try {
+      out.push(fs.readFileSync(path.join(dir, name), "utf8"));
+    } catch {
+    }
+  }
+  return out;
+}
+async function sweepDeadCodexStatusFiles(isPidAlive = defaultIsPidAlive) {
+  const dir = codexStatusDir();
+  let names;
+  try {
+    names = await fsp.readdir(dir);
+  } catch {
+    return;
+  }
+  for (const name of names) {
+    const m = STATUS_FILE_RE.exec(name);
+    if (!m) continue;
+    const full = path.join(dir, name);
+    let pid = m[1] ? Number(m[1]) : null;
+    if (pid === null) {
+      try {
+        pid = readCodexStatus(await fsp.readFile(full, "utf8"))?.pid ?? null;
+      } catch {
+        pid = null;
+      }
+    }
+    if (pid === process.pid) continue;
+    if (pid !== null && isPidAlive(pid)) continue;
+    try {
+      await fsp.unlink(full);
+    } catch {
+    }
+  }
+}
+function defaultIsPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err?.code === "EPERM";
+  }
+}
+function readCodexStatus(raw) {
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || typeof parsed.pid !== "number" || typeof parsed.updated_at !== "string" || typeof parsed.stream !== "object" || parsed.stream === null) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function writeCodexStatus(status) {
+  const statusPath = codexStatusPath(status.pid);
+  const tmp = `${statusPath}.tmp-${process.pid}-${crypto.randomUUID()}`;
+  try {
+    await fsp.mkdir(path.dirname(statusPath), { recursive: true });
+    await fsp.writeFile(tmp, JSON.stringify(status, null, 2), { mode: 384 });
+    await fsp.rename(tmp, statusPath);
+  } catch {
+    try {
+      await fsp.unlink(tmp);
+    } catch {
+    }
+  }
+}
+
+export {
+  CODEX_STATUS_HEARTBEAT_MS,
+  CODEX_STATUS_STALE_MS,
+  readAllCodexStatusRaw,
+  sweepDeadCodexStatusFiles,
+  readCodexStatus,
+  writeCodexStatus
+};