kojee-mcp 0.7.0 → 0.7.2

package/dist/doctor-codex-ZSALZPH3.js

@@ -0,0 +1,370 @@
+import {
+  defaultCodexConfigPath,
+  defaultCodexHooksPath,
+  isPlaceholderWebhookUrl
+} from "./chunk-RVLUZLXD.js";
+import "./chunk-TMCNB4JH.js";
+import "./chunk-D6JKFJ6A.js";
+import {
+  CODEX_STATUS_STALE_MS,
+  readAllCodexStatusRaw,
+  readCodexStatus
+} from "./chunk-XLRF5ATG.js";
+import "./chunk-SQL56SEB.js";
+import {
+  resolveWebhookConfig
+} from "./chunk-V5VZPYMZ.js";
+import "./chunk-U5HHHRXA.js";
+import {
+  VERSION
+} from "./chunk-5DHIUN73.js";
+import {
+  CODEX_LISTEN_CAP_MS
+} from "./chunk-XFGGMDZ4.js";
+
+// src/doctor-codex.ts
+import fs from "fs";
+
+// src/hooks/codex-trust-hash.ts
+import crypto from "crypto";
+var EVENT_LABELS = {
+  Stop: "stop",
+  UserPromptSubmit: "user_prompt_submit"
+};
+function canonicalize(value) {
+  if (Array.isArray(value)) return value.map(canonicalize);
+  if (value !== null && typeof value === "object") {
+    const src = value;
+    const out = {};
+    for (const key of Object.keys(src).sort()) out[key] = canonicalize(src[key]);
+    return out;
+  }
+  return value;
+}
+function codexHookTrustHash(identity) {
+  const timeout = Math.max(1, identity.timeout ?? 600);
+  const handler = {
+    type: "command",
+    command: identity.command,
+    timeout,
+    async: false,
+    ...identity.statusMessage !== void 0 ? { statusMessage: identity.statusMessage } : {}
+  };
+  const id = {
+    event_name: EVENT_LABELS[identity.event],
+    ...identity.matcher !== void 0 ? { matcher: identity.matcher } : {},
+    hooks: [handler]
+  };
+  const serialized = JSON.stringify(canonicalize(id));
+  return "sha256:" + crypto.createHash("sha256").update(serialized, "utf8").digest("hex");
+}
+function codexHookStateKey(hooksJsonPath, event, groupIndex, handlerIndex) {
+  return `${hooksJsonPath}:${EVENT_LABELS[event]}:${groupIndex}:${handlerIndex}`;
+}
+function parseCodexHooksState(toml) {
+  const state = {};
+  let currentKey = null;
+  for (const line of toml.split("\n")) {
+    const header = line.trim();
+    if (/^\[\[?[^\]]*\]\]?$/.test(header) || /^\[hooks\.state\."/.test(header)) {
+      const m = header.match(/^\[hooks\.state\."(.+)"\]$/);
+      currentKey = m ? m[1] : null;
+      if (currentKey !== null) state[currentKey] ??= {};
+      continue;
+    }
+    if (currentKey === null) continue;
+    const hash = line.match(/^\s*trusted_hash\s*=\s*"([^"]*)"\s*$/);
+    if (hash) {
+      state[currentKey].trustedHash = hash[1];
+      continue;
+    }
+    const enabled = line.match(/^\s*enabled\s*=\s*(true|false)\s*$/);
+    if (enabled) state[currentKey].enabled = enabled[1] === "true";
+  }
+  return state;
+}
+function parseCodexFeatureHooks(toml) {
+  let inFeatures = false;
+  for (const line of toml.split("\n")) {
+    const header = line.trim();
+    if (/^\[\[?[^\]]+\]\]?$/.test(header)) {
+      inFeatures = header === "[features]";
+      continue;
+    }
+    if (!inFeatures) continue;
+    const m = line.match(/^\s*hooks\s*=\s*(true|false)\s*$/);
+    if (m) return m[1] === "true";
+  }
+  return null;
+}
+
+// src/doctor-codex.ts
+function parseCodexEnvFromToml(toml) {
+  const env = {};
+  let inEnv = false;
+  for (const line of toml.split("\n")) {
+    const header = line.trim();
+    const isTableHeader = /^\[\[?[^\]]+\]\]?$/.test(header);
+    if (isTableHeader) {
+      inEnv = header === "[mcp_servers.kojee.env]";
+      continue;
+    }
+    if (!inEnv) continue;
+    const eq = line.indexOf("=");
+    if (eq <= 0) continue;
+    const key = line.slice(0, eq).trim();
+    if (!/^[A-Za-z0-9_.-]+$/.test(key)) continue;
+    let value = line.slice(eq + 1).trim();
+    const quote = value[0];
+    if ((quote === '"' || quote === "'") && value.endsWith(quote)) {
+      value = value.slice(1, -1);
+      if (quote === '"') value = value.replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+    }
+    env[key] = value;
+  }
+  return env;
+}
+var WIZARD_RERUN = "re-run `kojee-mcp init --runtime codex`";
+function extractPairedConfigPath(toml) {
+  const m = toml.match(/args\s*=\s*\[[^\]]*"--paired-config"\s*,\s*"([^"]+)"/);
+  return m ? m[1].replace(/\\\\/g, "\\") : null;
+}
+function defaultReadFile(path) {
+  return () => {
+    try {
+      return fs.readFileSync(path, "utf8");
+    } catch {
+      return null;
+    }
+  };
+}
+function collectCodexDoctorReport(deps = {}) {
+  const readConfigToml = deps.readConfigToml ?? defaultReadFile(defaultCodexConfigPath());
+  const readHooksJson = deps.readHooksJson ?? defaultReadFile(defaultCodexHooksPath());
+  const checks = [];
+  const toml = readConfigToml() ?? "";
+  const env = deps.env ?? parseCodexEnvFromToml(toml);
+  const hasKojeeTable = toml.includes("[mcp_servers.kojee]");
+  const hasRuntimeEnv = /KOJEE_RUNTIME\s*=\s*"codex"/.test(toml);
+  const configOk = hasKojeeTable && hasRuntimeEnv;
+  checks.push({
+    name: "~/.codex/config.toml [mcp_servers.kojee]",
+    ok: configOk,
+    detail: configOk ? 'present with env.KOJEE_RUNTIME="codex" (Tier-1 contract)' : `MISSING [mcp_servers.kojee] or env.KOJEE_RUNTIME="codex" \u2014 ${WIZARD_RERUN}`
+  });
+  const hooksRaw = readHooksJson() ?? "{}";
+  let hooksJson = {};
+  try {
+    hooksJson = JSON.parse(hooksRaw);
+  } catch {
+  }
+  let hookPresent = !!hooksJson.hooks?.["Stop"]?.some(
+    (e) => e.hooks?.some((h) => (h.command ?? "").includes("hook --type=codex-stop"))
+  );
+  if (!hookPresent && /hook --type=codex-stop/.test(toml)) hookPresent = true;
+  checks.push({
+    name: "Codex Stop hook (codex-stop)",
+    ok: hookPresent,
+    detail: hookPresent ? "present (fast PEEK + model-chosen bounded listen)" : `MISSING in ~/.codex/hooks.json / [[hooks.Stop]] \u2014 ${WIZARD_RERUN}`
+  });
+  const upsPresent = !!hooksJson.hooks?.["UserPromptSubmit"]?.some(
+    (e) => e.hooks?.some((h) => (h.command ?? "").includes("hook --type=codex-prompt-submit"))
+  );
+  checks.push({
+    name: "Codex UserPromptSubmit hook (codex-prompt-submit)",
+    ok: upsPresent ? true : "warn",
+    detail: upsPresent ? "present (pending-wake catch-up at the next prompt)" : `MISSING \u2014 a silently-dropped Stop block is never re-surfaced. ${WIZARD_RERUN}`
+  });
+  const featureHooks = parseCodexFeatureHooks(toml);
+  if (featureHooks !== true) {
+    checks.push({
+      name: "[features] hooks",
+      ok: "warn",
+      detail: (featureHooks === false ? "hooks = false in ~/.codex/config.toml [features]" : "no `hooks = true` under [features] in ~/.codex/config.toml") + " \u2014 Codex ignores hooks.json entirely; wakes silently stop. Enable the hooks feature."
+    });
+  } else {
+    checks.push({ name: "[features] hooks", ok: true, detail: "enabled" });
+  }
+  const hooksPath = deps.hooksPath ?? defaultCodexHooksPath();
+  const hooksState = parseCodexHooksState(toml);
+  for (const event of ["Stop", "UserPromptSubmit"]) {
+    const groups = hooksJson.hooks?.[event] ?? [];
+    for (let g = 0; g < groups.length; g++) {
+      const handlers = groups[g].hooks ?? [];
+      for (let h = 0; h < handlers.length; h++) {
+        const command = handlers[h].command ?? "";
+        if (!/hook --type=codex-(stop|prompt-submit)/.test(command)) continue;
+        const expected = codexHookTrustHash({
+          event,
+          command,
+          ...handlers[h].timeout !== void 0 ? { timeout: handlers[h].timeout } : {}
+        });
+        const key = codexHookStateKey(hooksPath, event, g, h);
+        const recorded = hooksState[key]?.trustedHash;
+        const label = command.includes("codex-stop") ? "codex-stop" : "codex-prompt-submit";
+        if (recorded === expected) {
+          checks.push({
+            name: `hook trust (${event})`,
+            ok: true,
+            detail: `${label} trusted (trusted_hash matches the current hooks.json entry)`
+          });
+        } else if (recorded === void 0) {
+          checks.push({
+            name: `hook trust (${event})`,
+            ok: "warn",
+            detail: `${label} is UNTRUSTED \u2014 no [hooks.state]."${key}" trusted_hash. Codex will NOT run it (wakes silently stop) until you launch Codex and APPROVE its trust prompt.`
+          });
+        } else {
+          checks.push({
+            name: `hook trust (${event})`,
+            ok: "warn",
+            detail: `${label} trust is STALE \u2014 trusted_hash no longer matches the current hooks.json entry (a rewrite invalidated it). Codex will NOT run it until you re-approve the trust prompt.`
+          });
+        }
+      }
+    }
+  }
+  const resolution = resolveWebhookConfig(env);
+  if (resolution.enabled && resolution.config) {
+    checks.push({
+      name: "webhook sink",
+      ok: true,
+      detail: `enabled \u2014 ${resolution.config.redactedSummary}`
+    });
+    if (resolution.warning) {
+      checks.push({
+        name: "webhook signature config",
+        ok: "warn",
+        detail: `${resolution.warning} \u2014 ${WIZARD_RERUN} with valid signature flags`
+      });
+    }
+  } else if (resolution.error) {
+    checks.push({
+      name: "webhook sink",
+      ok: false,
+      detail: `${resolution.error} \u2014 ${WIZARD_RERUN} (it generates a secret)`
+    });
+  } else {
+    checks.push({
+      name: "webhook sink",
+      ok: true,
+      detail: "optional \u2014 OFF (no KOJEE_WEBHOOK_URL). Codex wake is self-contained: the proxy records every event into the per-room pending ledger. Configure a receiver only for an extra low-latency push path."
+    });
+  }
+  const configuredUrl = (env["KOJEE_WEBHOOK_URL"] ?? "").trim();
+  if (configuredUrl && isPlaceholderWebhookUrl(configuredUrl)) {
+    checks.push({
+      name: "webhook url placeholder",
+      ok: "warn",
+      detail: `KOJEE_WEBHOOK_URL is the legacy placeholder (${configuredUrl}) \u2014 the sink POSTs every event at a non-resolving host. Re-run \`kojee-mcp connect <code> --runtime codex\` (it scrubs the placeholder), or delete KOJEE_WEBHOOK_URL + KOJEE_WEBHOOK_SECRET from [mcp_servers.kojee.env]. Codex wake is self-contained and unaffected.`
+    });
+  }
+  const pairedPath = extractPairedConfigPath(toml);
+  if (pairedPath) {
+    const present = fs.existsSync(pairedPath);
+    checks.push({
+      name: "paired-config slot",
+      ok: present,
+      detail: present ? `present \u2014 proxy launches with --paired-config ${pairedPath}` : `MISSING referenced config ${pairedPath} \u2014 re-run \`kojee-mcp connect <code> --runtime codex\``
+    });
+  }
+  if (deps.pingReceiver) {
+    const reachable = deps.pingReceiver();
+    checks.push({
+      name: "webhook receiver (optional ping)",
+      ok: reachable ? true : "warn",
+      detail: reachable ? "reachable" : "unreachable \u2014 stand up your receiver at KOJEE_WEBHOOK_URL (owner-built; see doctor note)"
+    });
+  }
+  const readStatusJsons = deps.readStatusJsons ?? readAllCodexStatusRaw;
+  const isPidAlive = deps.isPidAlive ?? ((pid) => {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch (err) {
+      return err?.code === "EPERM";
+    }
+  });
+  const now = deps.now ?? Date.now;
+  const statuses = readStatusJsons().map((raw) => readCodexStatus(raw)).filter((s) => s !== null);
+  const liveStatuses = statuses.filter((s) => isPidAlive(s.pid));
+  if (statuses.length === 0) {
+    checks.push({
+      name: "live proxy telemetry (~/.kojee/codex-status-<pid>.json)",
+      ok: "warn",
+      detail: `no live codex proxy status found \u2014 the proxy is not running (no codex window hosts the kojee MCP server), or it runs a pre-${VERSION} build that writes no telemetry (the stale-global npx trap: \`npm i -g kojee-mcp@latest\`, re-run \`kojee-mcp connect <code> --runtime codex\` \u2014 it pins the launcher version \u2014 then restart the Codex windows).`
+    });
+  } else if (liveStatuses.length === 0) {
+    const last = statuses.slice().sort((a, b) => Date.parse(a.updated_at) - Date.parse(b.updated_at)).pop();
+    checks.push({
+      name: "live proxy telemetry (~/.kojee/codex-status-<pid>.json)",
+      ok: "warn",
+      detail: `stale \u2014 written by pid ${last.pid} which is no longer running (last updated ${last.updated_at}). Restart the Codex window to relaunch the proxy.`
+    });
+  } else {
+    const multi = liveStatuses.length > 1;
+    for (const status of liveStatuses.slice().sort((a, b) => a.pid - b.pid)) {
+      const tag = multi ? ` [pid ${status.pid}]` : "";
+      const updatedAtMs = Date.parse(status.updated_at);
+      const ageMs = Number.isFinite(updatedAtMs) ? now() - updatedAtMs : Number.POSITIVE_INFINITY;
+      const fresh = ageMs <= CODEX_STATUS_STALE_MS;
+      if (!fresh) {
+        checks.push({
+          name: `live proxy telemetry (~/.kojee/codex-status-<pid>.json)${tag}`,
+          ok: "warn",
+          detail: `stale \u2014 pid ${status.pid} is alive but the status heartbeat stopped ${Math.round(ageMs / 1e3)}s ago (last updated ${status.updated_at}) \u2014 hung proxy?`
+        });
+        continue;
+      }
+      checks.push({
+        name: `live proxy telemetry (~/.kojee/codex-status-<pid>.json)${tag}`,
+        ok: true,
+        detail: `pid ${status.pid} alive, heartbeat fresh (updated ${status.updated_at})`
+      });
+      const streamOk = status.stream.connected === true;
+      checks.push({
+        name: `event stream (live)${tag}`,
+        ok: streamOk,
+        detail: streamOk ? `pid ${status.pid} connected \u2014 last event ${status.stream.last_event_at ?? "never"}, reconnects ${status.stream.reconnects ?? "?"}, ${status.delivered_events} events delivered this run` : `pid ${status.pid} NOT CONNECTED (reconnects ${status.stream.reconnects ?? "?"}) \u2014 the proxy is up but hears no Tandem events: no wake marker will be written. Check broker reachability / credentials, then restart the Codex window.`
+      });
+      if (status.proxy_version !== VERSION) {
+        checks.push({
+          name: `running proxy version${tag}`,
+          ok: "warn",
+          detail: `the live proxy runs ${status.proxy_version} but this doctor is ${VERSION} \u2014 restart the Codex windows (and re-run connect to re-pin the launcher) so the running build matches the installed one.`
+        });
+      }
+      if (status.subscribed_tandem_count === 0) {
+        checks.push({
+          name: `stream subscriptions${tag}`,
+          ok: "warn",
+          detail: "stream up but subscribed to 0 tandems \u2014 join a Tandem (or check the resubscribe-on-connect belt) before expecting wakes."
+        });
+      }
+    }
+  }
+  const verdict = checks.some((c) => c.ok === false) ? "broken" : checks.some((c) => c.ok === "warn") ? "degraded" : "healthy";
+  return { checks, verdict };
+}
+function formatCodexDoctorReport(report) {
+  const mark = (ok) => ok === true ? "\u2713" : ok === "warn" ? "\u26A0" : ok === "unknown" ? "?" : "\u2717";
+  const lines = [];
+  lines.push(`kojee-mcp doctor (codex) \u2014 verdict: ${report.verdict.toUpperCase()}`);
+  lines.push("");
+  lines.push(
+    "  Wake mode: self-contained (proxy-written per-room pending ledger) + stop-hook peek (Codex has no channel injection). Webhook OPTIONAL, never required."
+  );
+  lines.push(`  Bounded-listen cap: ${CODEX_LISTEN_CAP_MS}ms (model picks listen vs drain vs ignore).`);
+  lines.push("");
+  for (const c of report.checks) {
+    lines.push(`  ${mark(c.ok)} ${c.name}: ${c.detail}`);
+  }
+  lines.push("");
+  lines.push("NOTE: live Codex verification (hook fires, MCP connects, bounded listen) is an owner step.");
+  return lines.join("\n");
+}
+export {
+  collectCodexDoctorReport,
+  formatCodexDoctorReport,
+  parseCodexEnvFromToml
+};

package/dist/{event-stream-KRYWEYWO.js → event-stream-WPN3EN7C.js}

@@ -1,4 +1,6 @@
 import {
+  LOG_HEARTBEAT_INTERVAL_MS,
+  UNARMED_FALLBACK_MS,
   UNDICI_DEFAULT_BODY_TIMEOUT_MS,
   createAdaptiveWatchdog,
   createBackoffController,
@@ -7,10 +9,12 @@ import {
   serializeCursorMap,
   startEventStream,
   statusReason
-} from "./chunk-FSKGQ6GT.js";
+} from "./chunk-HI42GBQ3.js";
 import "./chunk-Z5LPNJQ6.js";
 import "./chunk-MIEI4PLB.js";
 export {
+  LOG_HEARTBEAT_INTERVAL_MS,
+  UNARMED_FALLBACK_MS,
   UNDICI_DEFAULT_BODY_TIMEOUT_MS,
   createAdaptiveWatchdog,
   createBackoffController,

package/dist/index.js

@@ -1,16 +1,17 @@
 import {
   listTandemIds,
   startProxy
-} from "./chunk-5H75AEZ2.js";
-import "./chunk-OB5T6P24.js";
+} from "./chunk-R5GC2GRD.js";
+import "./chunk-E35VWFZV.js";
 import "./chunk-247WFMCJ.js";
-import "./chunk-I67C2HYA.js";
 import "./chunk-Z5LPNJQ6.js";
+import "./chunk-I67C2HYA.js";
 import "./chunk-MIEI4PLB.js";
 import "./chunk-6G6YYST6.js";
 import "./chunk-U5HHHRXA.js";
-import "./chunk-SGRVG4HW.js";
-import "./chunk-QEJUNP3X.js";
+import "./chunk-ZUIYFRO5.js";
+import "./chunk-5DHIUN73.js";
+import "./chunk-XFGGMDZ4.js";
 import "./chunk-PPTKGWFF.js";
 import "./chunk-XJEBJIQE.js";
 import "./chunk-KNEJTD6G.js";

package/dist/{install-V7LSQCYZ.js → install-GGI6GU6C.js}

@@ -1,7 +1,7 @@
 import {
   buildHookCommand,
   isKojeeHookCommand
-} from "./chunk-QJFMU4QC.js";
+} from "./chunk-TMCNB4JH.js";
 import {
   wrapNpxLauncher
 } from "./chunk-D6JKFJ6A.js";

package/dist/lib.d.ts

@@ -487,33 +487,39 @@ declare function applyStableSessionId(token: string, deps?: StableSessionDeps):
  */
 declare function deriveStableSessionId(token: string, instanceKey: string): string;
 
-/**
- * Flat tool registry — fetches all Kojee tools with full schemas on startup
- * and registers them directly with the MCP server. No discovery indirection,
- * no meta-tools, no call_tool wrapper.
- *
- * The agent sees each Kojee tool directly (e.g. gmail_send_email, github_list_repos)
- * and calls it like any native MCP tool. Prompt caching handles the token cost
- * of ~15K tokens after the first turn.
- */
 declare class ToolRegistry {
     private readonly gateway;
     /** Flat map: tool name → full tool definition */
     private tools;
+    /**
+     * 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.
+     */
+    private localTools;
     constructor(gateway: GatewayClient);
+    /**
+     * 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: McpToolDefinition, handler: (args: Record<string, unknown>) => ToolCallResult | Promise<ToolCallResult>): void;
     /**
      * Fetch all tools with full schemas from the gateway in a single RPC call.
      */
     discoverTools(): Promise<void>;
     /**
-     * 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(): McpToolDefinition[];
     /**
-     * Call a tool through the gateway.
+     * Call a tool — local tools are answered in-process; everything else goes
+     * through the gateway.
      */
     callTool(name: string, args: Record<string, unknown>): Promise<ToolCallResult>;
-    /** Total number of registered tools. */
+    /** Total number of registered tools (gateway + local, shadowed names once). */
     get toolCount(): number;
 }
 
@@ -527,11 +533,30 @@ interface ToolCallHooks {
      * The proxy wires this to the debounced stream-reconnect scheduler so the
      * event-stream's membership snapshot picks up the just-acquired EXPLICIT seat
      * without a daemon restart. A throwing hook never breaks the tool reply.
-     * (There is no leave hook: auto-join removal deleted the room-memory it fed,
-     * and a leave needs no proxy action — the stream stops hearing the room on the
-     * next reconnect.)
+     * (A leave needs no STREAM action — the stream stops hearing the room on the
+     * next reconnect; onTandemLeave below exists only for per-window pending
+     * state.)
      */
     onTandemJoin?: (tandemId: string | null) => void;
+    /**
+     * Fired after a SUCCESSFUL tandem_leave performed through this proxy, with
+     * the left tandem id (null if unreadable). Wired today only for runtimes
+     * carrying a per-window SessionPendingState (codex — tandem/pending-state.ts)
+     * so the `tandem_pending` tool stops reporting a room the agent explicitly
+     * left. A throwing hook never breaks the tool reply.
+     */
+    onTandemLeave?: (tandemId: string | null) => void;
+    /**
+     * Fired after a SUCCESSFUL tandem_messages/tandem_ack performed through this
+     * proxy, with the room and the highest cursor the reply/args carried. The
+     * proxy wires this to the general pending ledger's recordDrained
+     * (delivery/pending-ledger.ts): CONSUMPTION of a pending wake is PROXY-SIDE
+     * ONLY — a runtime hook surface (e.g. the codex stop-hook) merely peeks and
+     * never consumes, so a session blocking on another session's room can never
+     * eat that room's wake (Guy's live defect D2). A throwing hook never breaks
+     * the tool reply.
+     */
+    onTandemDrain?: (tandemId: string, cursor: number) => void;
 }
 
 /**

package/dist/lib.js

@@ -1,11 +1,11 @@
-import {
-  resubscribeMemberships
-} from "./chunk-OT2GILXC.js";
 import {
   normalizeBackendEvent,
   sanitizeDisplayname,
   startEventStream
-} from "./chunk-FSKGQ6GT.js";
+} from "./chunk-HI42GBQ3.js";
+import {
+  resubscribeMemberships
+} from "./chunk-OT2GILXC.js";
 import {
   loadPairedConfig,
   pairedConfigPath
@@ -14,12 +14,12 @@ import {
   GatewayClient,
   applyStableSessionId
 } from "./chunk-247WFMCJ.js";
-import {
-  AuthModule
-} from "./chunk-I67C2HYA.js";
 import {
   deriveStableSessionId
 } from "./chunk-Z5LPNJQ6.js";
+import {
+  AuthModule
+} from "./chunk-I67C2HYA.js";
 import {
   createDPoPProof
 } from "./chunk-MIEI4PLB.js";

package/dist/pending-state-6TVRR63P.js

@@ -0,0 +1,134 @@
+import {
+  recordDrained
+} from "./chunk-IZN7IZPW.js";
+
+// src/tandem/pending-state.ts
+var PENDING_TOOL_RUNTIMES = /* @__PURE__ */ new Set(["codex"]);
+var LEDGER_DRAIN_RUNTIMES = /* @__PURE__ */ new Set(["codex"]);
+var TANDEM_PENDING_TOOL_NAME = "tandem_pending";
+var REJOIN_ADVICE = "if you were in rooms before a restart, rejoin with your previous seat_name \u2014 the room rebinds your seat";
+var MAX_TRACKED_ROOMS = 256;
+function usableCursor(cursor) {
+  if (!Number.isFinite(cursor) || cursor < 0) return null;
+  return Math.floor(cursor);
+}
+function createSessionPendingState() {
+  const rooms = /* @__PURE__ */ new Map();
+  let clock = 0;
+  const touch = (tandemId) => {
+    let rec = rooms.get(tandemId);
+    if (rec === void 0) {
+      rec = { seat: false, delivered: 0, drained: 0, touched: 0 };
+      rooms.set(tandemId, rec);
+      evictIfOverCap(tandemId);
+    }
+    rec.touched = ++clock;
+    return rec;
+  };
+  const evictIfOverCap = (justInserted) => {
+    while (rooms.size > MAX_TRACKED_ROOMS) {
+      let victim = null;
+      let victimTouched = Number.POSITIVE_INFINITY;
+      let victimPending = true;
+      for (const [id, rec] of rooms) {
+        if (id === justInserted) continue;
+        const isPending = rec.delivered > rec.drained;
+        const better = victimPending && !isPending || victimPending === isPending && rec.touched < victimTouched;
+        if (better) {
+          victim = id;
+          victimTouched = rec.touched;
+          victimPending = isPending;
+        }
+      }
+      if (victim === null) return;
+      rooms.delete(victim);
+    }
+  };
+  return {
+    noteSeat(tandemId) {
+      if (tandemId) touch(tandemId).seat = true;
+    },
+    dropSeat(tandemId) {
+      rooms.delete(tandemId);
+    },
+    noteDelivered(tandemId, cursor) {
+      const next = usableCursor(cursor);
+      if (tandemId === "" || next === null) return;
+      const rec = touch(tandemId);
+      rec.delivered = Math.max(rec.delivered, next);
+    },
+    noteDrained(tandemId, cursor) {
+      const next = usableCursor(cursor);
+      if (tandemId === "" || next === null) return;
+      const rec = touch(tandemId);
+      rec.drained = Math.max(rec.drained, next);
+    },
+    snapshot(filterTandemId) {
+      const pending = [];
+      let sessionHasSeats = false;
+      for (const [tandemId, rec] of rooms) {
+        if (!rec.seat && rec.delivered === 0) continue;
+        sessionHasSeats = true;
+        if (filterTandemId !== void 0 && tandemId !== filterTandemId) continue;
+        if (rec.delivered > rec.drained) {
+          pending.push({
+            tandem_id: tandemId,
+            since_cursor: rec.drained,
+            delivered_cursor: rec.delivered
+          });
+        }
+      }
+      const advice = !sessionHasSeats ? REJOIN_ADVICE : pending.length > 0 ? "drain each pending room with tandem_messages(tandem_id, since=since_cursor), then reply in the room" : "no pending Tandem events for this window";
+      return { pending, session_has_seats: sessionHasSeats, advice };
+    },
+    trackedRoomCount() {
+      return rooms.size;
+    }
+  };
+}
+function tandemPendingToolDefinition() {
+  return {
+    name: TANDEM_PENDING_TOOL_NAME,
+    description: "Report THIS window's pending Tandem events \u2014 answered entirely from this proxy's in-process state (rooms this session holds seats in, cursors delivered on this proxy's stream, cursors drained through this proxy's tool calls). Precise per-window: it never reads shared machine-wide files. Call it when the turn-end bell says events may be pending, then drain each listed room with tandem_messages(tandem_id, since=since_cursor) and reply in the room. If it lists nothing, the bell was for another window \u2014 ignore it. After a proxy restart it correctly reports nothing until you rejoin (use your previous seat_name \u2014 the room rebinds your seat).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        tandem_id: {
+          type: "string",
+          description: "Optional: report only this room."
+        }
+      }
+    }
+  };
+}
+function installPendingTool(runtime, registry) {
+  if (!PENDING_TOOL_RUNTIMES.has(runtime)) return null;
+  const state = createSessionPendingState();
+  registry.registerLocalTool(tandemPendingToolDefinition(), (args) => {
+    const filter = typeof args["tandem_id"] === "string" && args["tandem_id"] !== "" ? args["tandem_id"] : void 0;
+    return {
+      content: [{ type: "text", text: JSON.stringify(state.snapshot(filter)) }],
+      isError: false
+    };
+  });
+  return state;
+}
+function createRuntimeDrainHook(runtime, state) {
+  const writesLedger = LEDGER_DRAIN_RUNTIMES.has(runtime);
+  if (!writesLedger && state === null) return void 0;
+  return (tandemId, cursor) => {
+    if (writesLedger) recordDrained(tandemId, cursor);
+    state?.noteDrained(tandemId, cursor);
+  };
+}
+export {
+  LEDGER_DRAIN_RUNTIMES,
+  MAX_TRACKED_ROOMS,
+  PENDING_TOOL_RUNTIMES,
+  REJOIN_ADVICE,
+  TANDEM_PENDING_TOOL_NAME,
+  createRuntimeDrainHook,
+  createSessionPendingState,
+  installPendingTool,
+  tandemPendingToolDefinition
+};