kojee-mcp 0.4.0 → 0.5.2

package/dist/{chunk-ZGVUM4AG.js → chunk-YEC7IHIG.js}

@@ -1,11 +1,26 @@
 import {
   deriveDiscoveryKey,
   findClaudeAncestorPid
-} from "./chunk-36DMIXH7.js";
+} from "./chunk-BJMASMKX.js";
+import {
+  buildCatchUpNote,
+  buildMonitorSpawn,
+  buildReplyRecipe
+} from "./chunk-C6GZ2L2W.js";
+import {
+  MCP_SESSION_ID,
+  createDPoPProof,
+  startEventStream
+} from "./chunk-WBMX4CHB.js";
+import {
+  secureDir,
+  secureFile
+} from "./chunk-BLEGIR35.js";
 
 // src/index.ts
-import fs2 from "fs";
-import path2 from "path";
+import fs3 from "fs";
+import os2 from "os";
+import path3 from "path";
 
 // src/auth/auth-module.ts
 import { calculateJwkThumbprint } from "jose";
@@ -14,12 +29,9 @@ import crypto from "crypto";
 // src/auth/keystore.ts
 import { importJWK, exportJWK, generateKeyPair } from "jose";
 import fs from "fs";
+import os from "os";
 import path from "path";
-var DEFAULT_PATH = path.join(
-  process.env["HOME"] ?? "~",
-  ".kojee",
-  "keypair.json"
-);
+var DEFAULT_PATH = path.join(os.homedir(), ".kojee", "keypair.json");
 async function loadKeystore(keystorePath = DEFAULT_PATH, expectedBrokerUrl) {
   if (!fs.existsSync(keystorePath)) {
     return null;
@@ -39,9 +51,8 @@ async function loadKeystore(keystorePath = DEFAULT_PATH, expectedBrokerUrl) {
 }
 async function saveKeystore(privateKey, publicJwk, kid, brokerUrl, keystorePath = DEFAULT_PATH) {
   const dir = path.dirname(keystorePath);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true, mode: 448 });
-  }
+  fs.mkdirSync(dir, { recursive: true, mode: 448 });
+  secureDir(dir);
   const privateJwk = await exportJWK(privateKey);
   const data = {
     private_key_jwk: privateJwk,
@@ -53,6 +64,7 @@ async function saveKeystore(privateKey, publicJwk, kid, brokerUrl, keystorePath
   fs.writeFileSync(keystorePath, JSON.stringify(data, null, 2), {
     mode: 384
   });
+  secureFile(keystorePath);
 }
 async function generateES256KeyPair() {
   const { privateKey, publicKey } = await generateKeyPair("ES256");
@@ -192,34 +204,7 @@ var AuthModule = class {
 };
 
 // src/gateway-client.ts
-import crypto3 from "crypto";
-
-// src/auth/dpop.ts
-import { SignJWT, base64url } from "jose";
 import crypto2 from "crypto";
-async function createDPoPProof(privateKey, kid, method, url, nonce, accessToken) {
-  const payload = {
-    htm: method,
-    htu: url,
-    jti: crypto2.randomUUID()
-  };
-  if (nonce) {
-    payload.nonce = nonce;
-  }
-  if (accessToken) {
-    payload.ath = computeAth(accessToken);
-  }
-  const header = {
-    typ: "dpop+jwt",
-    alg: "ES256",
-    jwk: { kid }
-  };
-  return new SignJWT(payload).setProtectedHeader(header).setIssuedAt().sign(privateKey);
-}
-function computeAth(accessToken) {
-  const hash = crypto2.createHash("sha256").update(accessToken).digest();
-  return base64url.encode(hash);
-}
 
 // src/error-translator.ts
 function translateGovernanceResult(result) {
@@ -249,7 +234,7 @@ function formatDenied(governance) {
     isError: true
   };
 }
-function translateHttpError(status, errorCode, _trigger) {
+function translateHttpError(status, errorCode, trigger) {
   if (status === 401) {
     if (errorCode === "use_dpop_nonce") {
       return null;
@@ -267,8 +252,9 @@ function translateHttpError(status, errorCode, _trigger) {
     );
   }
   if (status === 403 && errorCode === "step_up_required") {
+    const reason = trigger ? ` (reason: ${trigger})` : "";
     return makeError(
-      "Device re-authorization required. The user has been notified but has not yet approved. Try again later."
+      `Device re-authorization required${reason}. This action can't proceed until the user re-authorizes this device in the Kojee dashboard.`
     );
   }
   if (status === 429) {
@@ -384,13 +370,7 @@ function makeError(text) {
   };
 }
 
-// src/tandem/session-id.ts
-import { ulid } from "ulidx";
-var MCP_SESSION_ID = ulid();
-
 // src/gateway-client.ts
-var STEP_UP_POLL_INTERVAL_MS = 5e3;
-var STEP_UP_MAX_TIMEOUT_MS = 3e5;
 var GatewayClient = class {
   constructor(brokerUrl, token, privateKey, kid, sessionId) {
     this.brokerUrl = brokerUrl;
@@ -426,26 +406,35 @@ var GatewayClient = class {
    * session_id = sha256(token + "proxy").slice(0, 16)
    */
   static deriveSessionId(token) {
-    const hash = crypto3.createHash("sha256").update(token + "proxy").digest("hex");
+    const hash = crypto2.createHash("sha256").update(token + "proxy").digest("hex");
     return hash.slice(0, 16);
   }
   /**
-   * Send a JSON-RPC 2.0 request to the gateway, handling DPoP auth,
-   * nonce retry, and step-up retry transparently.
+   * Send a JSON-RPC 2.0 request to the gateway, handling DPoP auth and
+   * nonce retry transparently. A 403 `step_up_required` (deprecated feature,
+   * owner ruling 2026-06-10) is no longer polled — it surfaces immediately as
+   * a structured tool error via translateHttpError.
+   *
+   * `signal` (ROUND-3 MAJOR A) is a REAL AbortSignal threaded into the
+   * underlying `fetch` option — NOT placed inside `params`/`arguments`. A
+   * caller with a per-call timeout budget (e.g. resubscribeMemberships) passes
+   * its controller's signal here so a hung backend aborts at the budget instead
+   * of hanging forever. Putting the signal in `arguments` (the round-2 bug) both
+   * left fetch un-aborted AND serialized a junk `{}` onto the wire body.
    */
-  async sendRpc(method, params = {}) {
+  async sendRpc(method, params = {}, signal) {
     const rpcRequest = {
       jsonrpc: "2.0",
       id: ++this.requestCounter,
       method,
       params
     };
-    return this.executeWithRetries(rpcRequest);
+    return this.executeWithRetries(rpcRequest, signal);
   }
-  async executeWithRetries(rpcRequest) {
+  async executeWithRetries(rpcRequest, signal) {
     let response;
     try {
-      response = await this.sendHttpRequest(rpcRequest);
+      response = await this.sendHttpRequest(rpcRequest, signal);
     } catch (err) {
       return translateNetworkError(err);
     }
@@ -455,7 +444,7 @@ var GatewayClient = class {
       if (body?.error === "use_dpop_nonce") {
         console.error("[gateway] Nonce expired, retrying with fresh nonce...");
         try {
-          response = await this.sendHttpRequest(rpcRequest);
+          response = await this.sendHttpRequest(rpcRequest, signal);
         } catch (err) {
           return translateNetworkError(err);
         }
@@ -467,9 +456,6 @@ var GatewayClient = class {
     }
     if (response.status === 403) {
       const body = await this.tryParseErrorBody(response);
-      if (body?.error === "step_up_required") {
-        return this.handleStepUp(rpcRequest, body.trigger);
-      }
       const translated = translateHttpError(403, body?.error, body?.trigger);
       if (translated) return translated;
     }
@@ -489,7 +475,7 @@ var GatewayClient = class {
     const result = rpcResponse.result;
     return result ?? { content: [{ type: "text", text: "No result" }] };
   }
-  async sendHttpRequest(rpcRequest) {
+  async sendHttpRequest(rpcRequest, signal) {
     const proof = await createDPoPProof(
       this.privateKey,
       this.kid,
@@ -506,56 +492,13 @@ var GatewayClient = class {
         DPoP: proof,
         "Mcp-Session-Id": MCP_SESSION_ID
       },
-      body: JSON.stringify(rpcRequest)
+      body: JSON.stringify(rpcRequest),
+      // ROUND-3 MAJOR A: the caller's AbortSignal rides HERE (a real fetch
+      // option), never inside the JSON-RPC body. `undefined` is a valid value
+      // for the fetch `signal` option (no abort wired).
+      ...signal ? { signal } : {}
     });
   }
-  /**
-   * Handle step-up retry: poll with backoff until user approves
-   * or timeout is reached.
-   */
-  async handleStepUp(rpcRequest, trigger) {
-    console.error(
-      `[gateway] Device re-authorization required (${trigger ?? "unknown"}). Waiting for user approval...`
-    );
-    const deadline = Date.now() + STEP_UP_MAX_TIMEOUT_MS;
-    while (Date.now() < deadline) {
-      await sleep(STEP_UP_POLL_INTERVAL_MS);
-      let response;
-      try {
-        response = await this.sendHttpRequest(rpcRequest);
-      } catch {
-        continue;
-      }
-      this.trackNonce(response);
-      if (response.status === 403) {
-        const body2 = await this.tryParseErrorBody(response);
-        if (body2?.error === "step_up_required") {
-          console.error("[gateway] Still waiting for step-up approval...");
-          continue;
-        }
-      }
-      if (response.ok) {
-        const rpcResponse = await response.json();
-        if (rpcResponse.error) {
-          return translateJsonRpcError(rpcResponse.error);
-        }
-        const result = rpcResponse.result;
-        return result ?? { content: [{ type: "text", text: "No result" }] };
-      }
-      const body = await this.tryParseErrorBody(response);
-      const translated = translateHttpError(response.status, body?.error);
-      if (translated) return translated;
-    }
-    return {
-      content: [
-        {
-          type: "text",
-          text: "Device re-authorization was not approved within 5 minutes. Try again later."
-        }
-      ],
-      isError: true
-    };
-  }
   trackNonce(response) {
     const nonce = response.headers.get("DPoP-Nonce");
     if (nonce) {
@@ -570,9 +513,6 @@ var GatewayClient = class {
     }
   }
 };
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
 
 // src/tool-registry.ts
 var ToolRegistry = class {
@@ -648,16 +588,41 @@ import {
   ListToolsRequestSchema,
   CallToolRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
-function buildChannelInstructions(tandemMembershipCount, eventLogPath) {
-  const intro = 'Tandem events are delivered to you in three ways depending on which is active in your Claude Code session:\n\n(1) If channel notifications are available, you\'ll see them as `<channel source="kojee-mcp" ...>` tags in your context. Each tag carries tandem_id, message_id, from_principal, kind, severity. Reply with tandem_send(tandem_id, text, reply_to=<message_id>); read more context with tandem_messages(tandem_id, since=cursor).\n\n';
-  const monitorSection = `(2) For sustained wake-from-idle WITHOUT channel notifications, the proxy writes one event line per Tandem message to ${eventLogPath}. At the start of every session, spawn ONE Monitor task: Monitor(command="tail -n +1 -F ${eventLogPath}", persistent=true, description="kojee Tandem events"). Each appended line will arrive as a separate wake notification. Use the cursor in the line to call tandem_messages(tandem_id, since=cursor-1) for the full message body.
+
+// src/version.ts
+import fs2 from "fs";
+import path2 from "path";
+import { fileURLToPath } from "url";
+var FALLBACK_VERSION = "0.0.0-unknown";
+function resolveVersion() {
+  try {
+    const here = path2.dirname(fileURLToPath(import.meta.url));
+    const parsed = JSON.parse(
+      fs2.readFileSync(path2.join(here, "..", "package.json"), "utf8")
+    );
+    return typeof parsed?.version === "string" && parsed.version ? parsed.version : FALLBACK_VERSION;
+  } catch (err) {
+    process.stderr.write(
+      `kojee-mcp: could not resolve version from package.json, falling back to ${FALLBACK_VERSION}: ${String(err)}
+`
+    );
+    return FALLBACK_VERSION;
+  }
+}
+var VERSION = resolveVersion();
+
+// src/server.ts
+function buildChannelInstructions(_tandemMembershipCount, eventLogPath) {
+  const intro = `Tandem events are delivered to you in three ways depending on which is active in your Claude Code session:
+
+(1) If channel notifications are available, you'll see them as \`<channel source="kojee-mcp" ...>\` tags in your context. Each tag carries tandem_id, message_id, from_principal, kind, severity. To respond: ${buildReplyRecipe()}.
+
+`;
+  const monitorSection = `(2) For sustained wake-from-idle WITHOUT channel notifications, the proxy writes one event line per Tandem message to ${eventLogPath}. At the start of every session, spawn ONE Monitor task: ${buildMonitorSpawn(eventLogPath)}. Each appended line will arrive as a separate wake notification, and carries msg=<id> and cursor=<n>. To respond: ${buildReplyRecipe()}. ${buildCatchUpNote()} (\`kojee-mcp tail\` is a portable line-streamer shipped with this proxy \u2014 works on macOS, Linux, and Windows. It follows BOTH the messages log above and a status sibling; status/heartbeat telemetry never wakes you \u2014 only real messages do.)
 
 `;
   const listenSection = "(3) If you want to BLOCK until any single reply lands (rather than receive a stream of events), call tandem_listen(tandem_id, since=cursor, timeout_ms=N) instead.";
   const advice = "\n\nPrefer (2) at session start \u2014 it's the default no-allowlist wake mechanism. (1) supplements it when channels are enabled; (3) is for one-shot blocking waits.";
-  if (tandemMembershipCount === 0) {
-    return intro + listenSection;
-  }
   return intro + monitorSection + listenSection + advice;
 }
 function createMcpServer(registry, adapter, tandemMembershipCount = -1, eventLogPath) {
@@ -666,7 +631,7 @@ function createMcpServer(registry, adapter, tandemMembershipCount = -1, eventLog
     capabilities.experimental = { "claude/channel": {} };
   }
   const server = new Server(
-    { name: "kojee-mcp", version: "0.3.0" },
+    { name: "kojee-mcp", version: VERSION },
     {
       capabilities,
       ...adapter.supportsChannels ? { instructions: buildChannelInstructions(tandemMembershipCount, eventLogPath ?? "") } : {}
@@ -695,35 +660,35 @@ async function startMcpServer(server) {
 }
 
 // src/runtime/detect.ts
-import childProcess from "child_process";
-function detectRuntime(env = process.env) {
+import psList from "ps-list";
+async function detectRuntime(env = process.env) {
   if (env["KOJEE_RUNTIME"] === "claude-code") return "claude-code";
+  if (env["KOJEE_RUNTIME"] === "codex") return "codex";
   if (env["CLAUDE_CODE_SESSION_ID"]) return "claude-code";
-  if (parentProcessLooksLikeClaude()) return "claude-code";
+  const ancestor = await detectRuntimeFromAncestry();
+  if (ancestor) return ancestor;
   return "unknown";
 }
-function parentProcessLooksLikeClaude() {
-  if (process.platform === "win32") return false;
+async function detectRuntimeFromAncestry() {
   try {
+    const processes = await psList();
+    const byPid = new Map(processes.map((p) => [p.pid, p]));
     let pid = process.ppid;
     for (let depth = 0; depth < 5 && pid && pid > 1; depth++) {
-      const cmd = childProcess.execFileSync("ps", ["-p", String(pid), "-o", "command="], {
-        encoding: "utf8",
-        stdio: ["ignore", "pipe", "ignore"]
-      }).trim();
-      if (/(^|\/)claude(\.app)?(\/|$|\s|\\)/i.test(cmd) || /Claude Helper/i.test(cmd)) {
-        return true;
+      const row = byPid.get(pid);
+      if (!row) return null;
+      const haystack = `${row.name} ${row.cmd ?? ""}`;
+      if (/(^|\/|\\)claude(\.app|\.exe)?(\/|$|\s|\\)/i.test(haystack) || /Claude Helper/i.test(haystack)) {
+        return "claude-code";
+      }
+      if (/(^|\/|\\)codex(\.exe)?(\/|$|\s|\\)/i.test(haystack)) {
+        return "codex";
       }
-      const ppidOut = childProcess.execFileSync("ps", ["-o", "ppid=", "-p", String(pid)], {
-        encoding: "utf8",
-        stdio: ["ignore", "pipe", "ignore"]
-      }).trim();
-      pid = Number.parseInt(ppidOut, 10);
-      if (!Number.isFinite(pid)) return false;
+      pid = row.ppid;
     }
   } catch {
   }
-  return false;
+  return null;
 }
 
 // src/adapters/claude-code.ts
@@ -742,7 +707,7 @@ function formatBody(event) {
     `[Tandem: ${event.tandem_id}] ${event.from.displayname} (${event.from.principal}) \u2014 ${event.kind}:`,
     event.content.body,
     "",
-    `> reply with tandem_send(tandem_id="${event.tandem_id}", text="...", reply_to="${event.id}")`
+    `> ${buildReplyRecipe({ tandem_id: event.tandem_id, message_id: event.id })}`
   ].join("\n");
 }
 var claudeCodeAdapter = {
@@ -762,6 +727,18 @@ var claudeCodeAdapter = {
   }
 };
 
+// src/adapters/codex.ts
+var codexAdapter = {
+  runtime: "codex",
+  supportsChannels: false,
+  // Codex has NO Claude-style channel injection
+  formatTandemEvent() {
+    throw new Error(
+      "codexAdapter.formatTandemEvent() is unreachable \u2014 Codex has no channel injection; server.ts gates this on supportsChannels. Codex receives events via the webhook sink + a model-chosen bounded tandem_listen."
+    );
+  }
+};
+
 // src/adapters/unknown.ts
 var unknownAdapter = {
   runtime: "unknown",
@@ -773,176 +750,44 @@ var unknownAdapter = {
   }
 };
 
-// src/tandem/event-stream.ts
-async function startEventStream(opts) {
-  let stopped = false;
-  let lastCursor = null;
-  const controller = new AbortController();
-  void (async function loop() {
-    let backoffMs = 1e3;
-    while (!stopped) {
-      try {
-        await connectAndConsume(opts, lastCursor, controller, (cursor) => {
-          lastCursor = cursor;
-          backoffMs = 1e3;
-        });
-      } catch (err) {
-        if (stopped) return;
-        console.error("[event-stream] disconnect:", err.message);
-      }
-      if (stopped) return;
-      const jitter = Math.random() * backoffMs;
-      await sleep2(jitter);
-      backoffMs = Math.min(backoffMs * 2, 3e4);
-    }
-  })();
-  return () => {
-    stopped = true;
-    controller.abort();
-  };
-}
-async function connectAndConsume(opts, sinceCursor, controller, onCursor) {
-  const params = new URLSearchParams();
-  if (sinceCursor !== null) params.set("since", String(sinceCursor));
-  const url = `${opts.brokerUrl}/api/v2/tandems/stream${params.toString() ? "?" + params.toString() : ""}`;
-  const proof = await createDPoPProof(
-    opts.gateway.getPrivateKey(),
-    opts.gateway.getKid(),
-    "GET",
-    url,
-    void 0,
-    opts.token
-  );
-  const res = await fetch(url, {
-    method: "GET",
-    headers: {
-      Authorization: `DPoP ${opts.token}`,
-      DPoP: proof,
-      "Mcp-Session-Id": MCP_SESSION_ID,
-      Accept: "text/event-stream"
-    },
-    signal: controller.signal
-  });
-  if (!res.ok) throw new Error(`SSE connect failed: ${res.status}`);
-  if (!res.body) throw new Error("SSE response has no body");
-  await consumeSse(res.body, opts, onCursor);
-}
-async function consumeSse(body, opts, onCursor) {
-  const reader = body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  while (true) {
-    const { value, done } = await reader.read();
-    if (done) return;
-    buffer += decoder.decode(value, { stream: true });
-    const events = drainSseEvents(buffer);
-    buffer = events.remaining;
-    for (const evt of events.events) {
-      if (evt.event === "stream_revoked") {
-        throw new Error("stream_revoked \u2014 reconnect needed");
-      }
-      if (evt.event === "heartbeat") continue;
-      if (evt.event === "message" || evt.event === "state_change") {
-        try {
-          const raw = JSON.parse(evt.data);
-          const parsed = normalizeBackendEvent(raw, evt.event);
-          onCursor(parsed.cursor);
-          opts.queue?.push(parsed);
-          const channel = opts.adapter.formatTandemEvent(parsed);
-          await opts.server.notification({
-            method: "notifications/claude/channel",
-            params: channel
-          });
-          opts.queue?.markChannelDelivered(parsed.id);
-          if (opts.eventLog) {
-            try {
-              await opts.eventLog.append(parsed);
-              opts.queue?.markMonitorDelivered(parsed.id);
-            } catch (err) {
-              console.error("[event-stream] event-log append failed:", err);
-            }
-          }
-        } catch (err) {
-          console.error("[event-stream] failed to handle event:", err);
-        }
-      }
-    }
-  }
-}
-function drainSseEvents(input) {
-  const events = [];
-  const parts = input.split("\n\n");
-  const remaining = parts.pop() ?? "";
-  for (const block of parts) {
-    let id;
-    let event = "message";
-    const dataLines = [];
-    for (const line of block.split("\n")) {
-      if (line.startsWith("id: ")) id = line.slice(4);
-      else if (line.startsWith("event: ")) event = line.slice(7);
-      else if (line.startsWith("data: ")) dataLines.push(line.slice(6));
-    }
-    if (dataLines.length > 0) events.push({ id, event, data: dataLines.join("\n") });
-  }
-  return { events, remaining };
-}
-function sleep2(ms) {
-  return new Promise((r) => setTimeout(r, ms));
-}
-function normalizeBackendEvent(raw, sseEventType) {
-  const obj = raw ?? {};
-  const maybeFrom = obj["from"];
-  if (maybeFrom && typeof maybeFrom["principal"] === "string") {
-    return raw;
-  }
-  const sender = obj["sender"] ?? {};
-  const principal = sender["principal_id"] ?? "";
-  const agentId = sender["agent_id"];
-  const displayname = principal ? `principal:${principal.slice(0, 8)}` : "unknown";
-  const type = sseEventType === "state_change" ? "state_change" : "message";
-  const kind = obj["kind"] ?? "message";
-  return {
-    type,
-    id: obj["message_id"] ?? obj["id"] ?? "",
-    tandem_id: obj["tandem_id"] ?? "",
-    cursor: obj["cursor"] ?? 0,
-    time: obj["time"] ?? (/* @__PURE__ */ new Date()).toISOString(),
-    from: {
-      member_id: "",
-      principal,
-      ...agentId ? { agent_id: agentId } : {},
-      displayname
-    },
-    kind,
-    content: {
-      body: obj["body"] ?? "",
-      ...typeof obj["format"] === "string" ? { format: obj["format"] } : {}
-    },
-    ...Array.isArray(obj["mentions"]) ? { mentions: obj["mentions"] } : {},
-    ...obj["reply_to"] !== void 0 ? { reply_to: obj["reply_to"] } : {}
-  };
-}
-
 // src/index.ts
-var DEFAULT_KEYSTORE_PATH = path2.join(
-  process.env["HOME"] ?? "~",
-  ".kojee",
-  "keypair.json"
-);
+var DEFAULT_KEYSTORE_PATH = path3.join(os2.homedir(), ".kojee", "keypair.json");
 function isDPoPEnrollmentError(err) {
   const msg = String(err?.message ?? err ?? "").toLowerCase();
   if (msg.includes("invalid or expired") && msg.includes("token")) return false;
   if (msg.includes("generate a new")) return false;
   return msg.includes("401") || msg.includes("authentication failed") || msg.includes("dpop") || msg.includes("key enrollment") || msg.includes("kid");
 }
-function selectAdapter() {
-  const runtime = detectRuntime();
+async function selectAdapter() {
+  const runtime = await detectRuntime();
   if (runtime === "claude-code") return claudeCodeAdapter;
+  if (runtime === "codex") return codexAdapter;
   return unknownAdapter;
 }
+async function listTandemIds(gateway) {
+  const result = await gateway.sendRpc("tools/call", { name: "tandem_list", arguments: {} });
+  const maybeErr = result;
+  if (maybeErr.isError) return null;
+  const text = maybeErr.content?.[0]?.text;
+  try {
+    const parsed = text ? JSON.parse(text) : {};
+    const list = Array.isArray(parsed.tandems) ? parsed.tandems : Array.isArray(parsed) ? parsed : null;
+    if (!Array.isArray(list)) return [];
+    return list.map((t) => {
+      if (typeof t === "string") return t;
+      const obj = t;
+      return obj?.tandem_id ?? obj?.id;
+    }).filter((id) => typeof id === "string" && id.length > 0);
+  } catch {
+    return null;
+  }
+}
+function needsWebhookEventStream() {
+  return (process.env["KOJEE_WEBHOOK_URL"] ?? "").trim().length > 0;
+}
 async function startProxy(config) {
   const keystorePath = config.keystorePath || DEFAULT_KEYSTORE_PATH;
-  const adapter = selectAdapter();
+  const adapter = await selectAdapter();
   console.error(`[kojee-mcp] Starting proxy for ${config.url} (runtime=${adapter.runtime})`);
   const { registry, gateway } = await enrollAndDiscover(config, keystorePath);
   console.error(
@@ -950,22 +795,8 @@ async function startProxy(config) {
   );
   let tandemMembershipCount = -1;
   try {
-    const result = await gateway.sendRpc("tools/call", { name: "tandem_list", arguments: {} });
-    const maybeErr = result;
-    if (!maybeErr.isError) {
-      const text = maybeErr.content?.[0]?.text;
-      try {
-        const parsed = text ? JSON.parse(text) : {};
-        if (Array.isArray(parsed.tandems)) {
-          tandemMembershipCount = parsed.tandems.length;
-        } else if (Array.isArray(parsed)) {
-          tandemMembershipCount = parsed.length;
-        } else {
-          tandemMembershipCount = 0;
-        }
-      } catch {
-      }
-    }
+    const bootIds = await listTandemIds(gateway);
+    tandemMembershipCount = bootIds === null ? -1 : bootIds.length;
   } catch (err) {
     console.error("[kojee-mcp] tandem_list probe failed:", err.message);
   }
@@ -973,22 +804,58 @@ async function startProxy(config) {
   let server;
   if (adapter.supportsChannels) {
     const { EventQueue } = await import("./event-queue-5YVJFR3E.js");
-    const { startHookServer } = await import("./hook-server-43QS7L7P.js");
+    const { startHookServer } = await import("./hook-server-QF5JVUHV.js");
     const {
       writeDiscoveryByKey,
       cleanupDiscoveryByKey,
       sweepStaleDiscovery
-    } = await import("./session-discovery-WSHLR4OV.js");
-    const { startEventLog, sweepStaleEventLogs } = await import("./event-log-ETWR6PPY.js");
+    } = await import("./session-discovery-FNMJGFPM.js");
+    const { startEventLog, sweepStaleEventLogs } = await import("./event-log-RSTM4PLL.js");
+    const { resubscribeMemberships } = await import("./resubscribe-SLZNA76S.js");
+    const { resolveWebhookConfig } = await import("./webhook-config-5TLLX7RA.js");
+    const { createWebhookSink } = await import("./webhook-sink-7OYZBWXA.js");
     sweepStaleDiscovery();
     sweepStaleEventLogs();
-    const ccPid = findClaudeAncestorPid();
+    const ccPid = await findClaudeAncestorPid();
     const projectDir = process.env["CLAUDE_PROJECT_DIR"];
     const discoveryKey = deriveDiscoveryKey(projectDir, ccPid);
     const eventLog = startEventLog({ key: discoveryKey });
+    const webhookResolution = resolveWebhookConfig();
+    if (webhookResolution.error) {
+      console.error(`[kojee-mcp] webhook sink ERROR: ${webhookResolution.error}`);
+      void eventLog.appendStatus(`status=webhook error="${webhookResolution.error}"`).catch(() => {
+      });
+    }
+    const webhookSink = webhookResolution.enabled && webhookResolution.config ? createWebhookSink(webhookResolution.config, {
+      // Route delivery/failure observability to the STATUS sink.
+      log: (line) => {
+        void eventLog.appendStatus(`status=webhook ${line}`).catch(() => {
+        });
+      }
+    }) : null;
+    if (webhookSink) {
+      console.error(`[kojee-mcp] webhook sink ENABLED (${webhookSink.configSummary()})`);
+      void eventLog.appendStatus(`status=webhook enabled ${webhookSink.configSummary()}`).catch(() => {
+      });
+    }
     server = createMcpServer(registry, adapter, tandemMembershipCount, eventLog.path);
     const queue = new EventQueue();
-    const hookServer = await startHookServer({ port: 0, queue, adapter });
+    let streamHandle = null;
+    const hookServer = await startHookServer({
+      port: 0,
+      queue,
+      adapter,
+      getStreamState: () => streamHandle ? streamHandle.getState() : {
+        connected: false,
+        connectedSince: null,
+        lastEventAt: null,
+        lastHeartbeatAt: null,
+        cursors: {},
+        reconnectCount: 0,
+        // Adaptive: unknown until the watchdog observes ≥2 heartbeats.
+        staleAfterMs: null
+      }
+    });
     writeDiscoveryByKey(discoveryKey, {
       schema: 2,
       discoveryKey,
@@ -1000,7 +867,13 @@ async function startProxy(config) {
       pid: process.pid,
       port: hookServer.port,
       startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      brokerUrl: config.url
+      brokerUrl: config.url,
+      eventLogPath: eventLog.path,
+      // Stamp the auth mode so `kojee-mcp doctor` renders the pairing check
+      // honestly: a token-mode box has no ~/.kojee/config.json by design and
+      // must not hard-fail on "paired config: MISSING". Defaults to "paired"
+      // for back-compat with callers that don't set it.
+      authMode: config.authMode ?? "paired"
     });
     const cleanupDiscoveryFile = () => cleanupDiscoveryByKey(discoveryKey);
     process.on("exit", () => cleanupDiscoveryFile());
@@ -1013,17 +886,45 @@ async function startProxy(config) {
       process.exit(0);
     });
     process.on("exit", () => eventLog.cleanup());
-    const cancelStream = await startEventStream({
+    streamHandle = await startEventStream({
       brokerUrl: config.url,
       token: config.token,
       gateway,
       adapter,
       server,
       queue,
-      eventLog
+      eventLog,
+      // Generic webhook sink (null unless KOJEE_WEBHOOK_URL + _SECRET are set).
+      // Wired LAST in the fan-out, fire-and-forget — can't delay a wake.
+      ...webhookSink ? { webhookSink } : {},
+      // Resubscribe-on-start (P0 #2): touch all memberships + write a
+      // `status=subscribed n=<count>` line on every (re)connect, so a backend
+      // restart / scope reset self-heals and the log is never ambiguously
+      // empty. See resubscribe.ts for the unverified-touch caveat.
+      //
+      // MINOR 6: `listTandems` re-fetches the membership list per reconnect (a
+      // mid-session join is touched next reconnect, not boot-frozen), each
+      // touch is timeout-bounded + run with bounded concurrency, and the whole
+      // routine runs concurrently with consumeSse (never blocks first-event
+      // delivery). `listTandemIds` may return null (unknown) → treat as empty.
+      // MINOR E: a shared debounce cursor damps a connect/drop flap storm — a
+      // resubscribe within 30s of the last successful one is skipped.
+      onConnected: /* @__PURE__ */ (() => {
+        const debounceState = { lastRunAt: 0 };
+        return async () => {
+          await resubscribeMemberships({
+            gateway,
+            eventLog,
+            listTandems: async () => await listTandemIds(gateway) ?? [],
+            debounceState
+          });
+        };
+      })()
     });
+    const cancelStream = streamHandle;
     process.stdin.on("end", () => {
       cancelStream();
+      void webhookSink?.stop();
       cleanupDiscoveryFile();
       eventLog.cleanup();
       hookServer.stop().finally(() => {
@@ -1031,6 +932,62 @@ async function startProxy(config) {
         process.exit(0);
       });
     });
+  } else if (needsWebhookEventStream()) {
+    const { startEventLog, sweepStaleEventLogs } = await import("./event-log-RSTM4PLL.js");
+    const { resolveWebhookConfig } = await import("./webhook-config-5TLLX7RA.js");
+    const { createWebhookSink } = await import("./webhook-sink-7OYZBWXA.js");
+    const { resubscribeMemberships } = await import("./resubscribe-SLZNA76S.js");
+    sweepStaleEventLogs();
+    const ccPid = await findClaudeAncestorPid();
+    const projectDir = process.env["CLAUDE_PROJECT_DIR"];
+    const discoveryKey = deriveDiscoveryKey(projectDir, ccPid);
+    const eventLog = startEventLog({ key: discoveryKey });
+    const webhookResolution = resolveWebhookConfig();
+    if (webhookResolution.error) {
+      console.error(`[kojee-mcp] webhook sink ERROR: ${webhookResolution.error}`);
+      void eventLog.appendStatus(`status=webhook error="${webhookResolution.error}"`).catch(() => {
+      });
+    }
+    const webhookSink = webhookResolution.enabled && webhookResolution.config ? createWebhookSink(webhookResolution.config, {
+      log: (line) => {
+        void eventLog.appendStatus(`status=webhook ${line}`).catch(() => {
+        });
+      }
+    }) : null;
+    if (webhookSink) {
+      console.error(`[kojee-mcp] webhook sink ENABLED (${webhookSink.configSummary()})`);
+      void eventLog.appendStatus(`status=webhook enabled ${webhookSink.configSummary()}`).catch(() => {
+      });
+    }
+    server = createMcpServer(registry, adapter, tandemMembershipCount);
+    process.on("exit", () => eventLog.cleanup());
+    const streamHandle = await startEventStream({
+      brokerUrl: config.url,
+      token: config.token,
+      gateway,
+      adapter,
+      server,
+      eventLog,
+      ...webhookSink ? { webhookSink } : {},
+      onConnected: /* @__PURE__ */ (() => {
+        const debounceState = { lastRunAt: 0 };
+        return async () => {
+          await resubscribeMemberships({
+            gateway,
+            eventLog,
+            listTandems: async () => await listTandemIds(gateway) ?? [],
+            debounceState
+          });
+        };
+      })()
+    });
+    process.stdin.on("end", () => {
+      streamHandle();
+      void webhookSink?.stop();
+      eventLog.cleanup();
+      console.error("[kojee-mcp] stdin closed, exiting");
+      process.exit(0);
+    });
   } else {
     server = createMcpServer(registry, adapter, tandemMembershipCount);
     process.stdin.on("end", () => {
@@ -1064,7 +1021,7 @@ async function enrollAndDiscover(config, keystorePath, isRetry = false) {
       "[kojee-mcp] Auth failed, attempting recovery with fresh enrollment..."
     );
     try {
-      if (fs2.existsSync(keystorePath)) fs2.unlinkSync(keystorePath);
+      if (fs3.existsSync(keystorePath)) fs3.unlinkSync(keystorePath);
     } catch (unlinkErr) {
       console.error("[kojee-mcp] Could not remove stale keystore:", unlinkErr);
     }
@@ -1074,5 +1031,6 @@ async function enrollAndDiscover(config, keystorePath, isRetry = false) {
 
 export {
   AuthModule,
+  VERSION,
   startProxy
 };