kojee-mcp 0.4.0 → 0.5.0

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

@@ -1,11 +1,22 @@
+import {
+  MCP_SESSION_ID,
+  createDPoPProof,
+  startEventStream
+} from "./chunk-QB22PD6T.js";
+import {
+  buildCatchUpNote,
+  buildMonitorSpawn,
+  buildReplyRecipe
+} from "./chunk-E26AHU6J.js";
 import {
   deriveDiscoveryKey,
   findClaudeAncestorPid
-} from "./chunk-36DMIXH7.js";
+} from "./chunk-BJMASMKX.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 +25,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;
@@ -192,34 +200,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) {
@@ -384,10 +365,6 @@ 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;
@@ -426,26 +403,33 @@ 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.
+   *
+   * `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 +439,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);
         }
@@ -468,7 +452,7 @@ 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);
+        return this.handleStepUp(rpcRequest, body.trigger, signal);
       }
       const translated = translateHttpError(403, body?.error, body?.trigger);
       if (translated) return translated;
@@ -489,7 +473,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,14 +490,18 @@ 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) {
+  async handleStepUp(rpcRequest, trigger, signal) {
     console.error(
       `[gateway] Device re-authorization required (${trigger ?? "unknown"}). Waiting for user approval...`
     );
@@ -522,7 +510,7 @@ var GatewayClient = class {
       await sleep(STEP_UP_POLL_INTERVAL_MS);
       let response;
       try {
-        response = await this.sendHttpRequest(rpcRequest);
+        response = await this.sendHttpRequest(rpcRequest, signal);
       } catch {
         continue;
       }
@@ -648,16 +636,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 +679,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,31 +708,26 @@ 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["CLAUDE_CODE_SESSION_ID"]) return "claude-code";
-  if (parentProcessLooksLikeClaude()) return "claude-code";
+  if (await parentProcessLooksLikeClaude()) return "claude-code";
   return "unknown";
 }
-function parentProcessLooksLikeClaude() {
-  if (process.platform === "win32") return false;
+async function parentProcessLooksLikeClaude() {
   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)) {
+      const row = byPid.get(pid);
+      if (!row) return false;
+      const haystack = `${row.name} ${row.cmd ?? ""}`;
+      if (/(^|\/|\\)claude(\.app|\.exe)?(\/|$|\s|\\)/i.test(haystack) || /Claude Helper/i.test(haystack)) {
         return true;
       }
-      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 {
   }
@@ -742,7 +750,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 = {
@@ -773,176 +781,40 @@ 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;
   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;
+  }
+}
 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 +822,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 +831,38 @@ 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-QE5TTAPS.js");
+    const { startEventLog, sweepStaleEventLogs } = await import("./event-log-R6VW6GAF.js");
+    const { resubscribeMemberships } = await import("./resubscribe-SLZNA76S.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 });
     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 +874,8 @@ async function startProxy(config) {
       pid: process.pid,
       port: hookServer.port,
       startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      brokerUrl: config.url
+      brokerUrl: config.url,
+      eventLogPath: eventLog.path
     });
     const cleanupDiscoveryFile = () => cleanupDiscoveryByKey(discoveryKey);
     process.on("exit", () => cleanupDiscoveryFile());
@@ -1013,15 +888,39 @@ 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,
+      // 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();
       cleanupDiscoveryFile();
@@ -1064,7 +963,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 +973,6 @@ async function enrollAndDiscover(config, keystorePath, isRetry = false) {
 
 export {
   AuthModule,
+  VERSION,
   startProxy
 };

package/dist/{chunk-WHTH6WBP.js → chunk-LSUB6QMP.js}

@@ -5,6 +5,7 @@ var NULL_RESULT = {
   sessionId: null,
   transcriptPath: null,
   hookEventName: null,
+  stopHookActive: false,
   raw: ""
 };
 async function readHookStdin() {
@@ -21,6 +22,7 @@ async function readHookStdin() {
       sessionId: stringOrNull(parsed["session_id"]),
       transcriptPath: stringOrNull(parsed["transcript_path"]),
       hookEventName: stringOrNull(parsed["hook_event_name"]),
+      stopHookActive: parsed["stop_hook_active"] === true,
       raw
     };
   } catch {
@@ -28,6 +30,7 @@ async function readHookStdin() {
       sessionId: null,
       transcriptPath: null,
       hookEventName: null,
+      stopHookActive: false,
       raw
     };
   }