kojee-mcp 0.5.4 → 0.5.7

package/README.md

@@ -218,8 +218,8 @@ in it is Hermes-specific — and it is **OFF by default**.
 |---|---|
 | `KOJEE_WEBHOOK_URL` | Receiver endpoint (http/https). **Unset ⇒ sink OFF** (zero behavior change). |
 | `KOJEE_WEBHOOK_SECRET` | HMAC-SHA256 key for the signature header. URL set but secret unset ⇒ sink **DISABLED with an error** (the proxy NEVER sends unsigned webhooks). |
-| `KOJEE_WEBHOOK_TIMEOUT_MS` | Per-attempt request timeout (default `5000`). |
-| `KOJEE_WEBHOOK_MAX_RETRIES` | Retries on a retryable failure — network / 5xx / 408 / 429 (default `4`). |
+| `KOJEE_WEBHOOK_TIMEOUT_MS` | Per-attempt request timeout (default `30000`). A timed-out attempt is **never retried** — see the retry policy below. |
+| `KOJEE_WEBHOOK_MAX_RETRIES` | Retries on a **retryable** failure — connection errors (refused / reset / DNS) / 5xx / 408 / 429 (default `2`). Timeouts are **not** in this class. |
 | `KOJEE_WEBHOOK_SIGNATURE_HEADER` | Header name carrying the signature (default `X-Kojee-Signature`). |
 | `KOJEE_WEBHOOK_SIGNATURE_PREFIX` | Literal string prepended to the hex digest (default empty — bare hex). |
 | `KOJEE_WEBHOOK_SIGNATURE_FORMAT` | Optional preset. `github` ⇒ header `X-Hub-Signature-256`, prefix `sha256=` (the GitHub-webhook convention). Explicit `_HEADER`/`_PREFIX` vars override the preset's corresponding value. Unknown values are **warned about once and ignored** — never fatal. |
@@ -275,10 +275,29 @@ constant beside it):
   cursor on restart, so the same event may arrive more than once. There is **no
   exactly-once** promise; the receiver's dedupe is what makes redelivery safe.
 
+**Retry policy (0.5.6 — anti-storm).** A delivery attempt that **times out is
+never retried**: the receiver may well have processed the event and just
+answered slowly (the canonical receiver spawns an agent session *before*
+responding), so a re-POST risks duplicate side effects by design. The sink logs
+it as `delivered-unconfirmed (receiver slow)` and moves on. Retries happen
+**only on genuine non-delivery**: connection errors (refused / reset / DNS —
+the request never reached a receiver) and 5xx / 408 / 429 responses (the
+receiver answered that it did *not* process the event), up to
+`KOJEE_WEBHOOK_MAX_RETRIES` (default `2`). For those retried cases delivery is
+still **at-least-once** and every redelivery carries the same
+`X-Kojee-Delivery` id and identical body bytes — **dedupe by event id remains
+the receiver's responsibility** (the `recipe.ts` contract). This fix removes
+the timeout-driven storm, not the at-least-once semantics. If your receiver
+does slow work, the robust pattern is still: verify the signature, dedupe,
+**respond `202` immediately**, then process.
+
 The sink is isolated and fire-and-forget: a slow, hanging, or failing webhook can
-never delay or break the Monitor (event-log) or Channel wake paths. The status
-log redacts the secret and strips any basic-auth credentials embedded in
-`KOJEE_WEBHOOK_URL`.
+never delay or break the Monitor (event-log) or Channel wake paths (those run
+before the webhook push). A slow delivery only delays *later webhook events*
+behind it in the sink's own FIFO, and that backlog is bounded: the queue caps at
+1000 (overflow logs + drops the newest; the resubscribe-replay redelivers after
+a restart). The status log redacts the secret and strips any basic-auth
+credentials embedded in `KOJEE_WEBHOOK_URL`.
 
 ## Wake Continuity (0.5.4)
 

package/dist/{chunk-36L3GCU3.js → chunk-3XDJOHMZ.js}

@@ -14,10 +14,18 @@ import {
 
 // src/auth/keystore.ts
 import { importJWK, exportJWK, generateKeyPair } from "jose";
+import crypto from "crypto";
 import fs from "fs";
 import os from "os";
 import path from "path";
 var DEFAULT_PATH = path.join(os.homedir(), ".kojee", "keypair.json");
+function defaultPairedKeystorePath() {
+  return path.join(os.homedir(), ".kojee", "keypair.json");
+}
+function deriveKeystorePath(token) {
+  const hash = crypto.createHash("sha256").update(token).digest("hex").slice(0, 12);
+  return path.join(os.homedir(), ".kojee", `keypair-${hash}.json`);
+}
 async function loadKeystore(keystorePath = DEFAULT_PATH, expectedBrokerUrl) {
   if (!fs.existsSync(keystorePath)) {
     return null;
@@ -61,7 +69,7 @@ async function generateES256KeyPair() {
 }
 
 // src/gateway-client.ts
-import crypto from "crypto";
+import crypto2 from "crypto";
 var GatewayClient = class {
   constructor(brokerUrl, token, privateKey, kid, sessionId) {
     this.brokerUrl = brokerUrl;
@@ -97,7 +105,7 @@ var GatewayClient = class {
    * session_id = sha256(token + "proxy").slice(0, 16)
    */
   static deriveSessionId(token) {
-    const hash = crypto.createHash("sha256").update(token + "proxy").digest("hex");
+    const hash = crypto2.createHash("sha256").update(token + "proxy").digest("hex");
     return hash.slice(0, 16);
   }
   /**
@@ -206,6 +214,8 @@ var GatewayClient = class {
 };
 
 export {
+  defaultPairedKeystorePath,
+  deriveKeystorePath,
   loadKeystore,
   saveKeystore,
   generateES256KeyPair,

package/dist/chunk-6SK6ITFE.js

@@ -0,0 +1,142 @@
+import {
+  generateES256KeyPair,
+  loadKeystore,
+  saveKeystore
+} from "./chunk-3XDJOHMZ.js";
+
+// src/auth/auth-module.ts
+import { calculateJwkThumbprint } from "jose";
+import crypto from "crypto";
+
+// src/auth/registration.ts
+async function registerKey(brokerUrl, token, publicJwk) {
+  const url = `${brokerUrl}/api/v1/bots/keys/register/`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify({ public_jwk: publicJwk })
+  });
+  if (!response.ok) {
+    const body = await response.text();
+    throw new Error(
+      `Key registration failed (${response.status}): ${body}`
+    );
+  }
+  return await response.json();
+}
+async function confirmKey(brokerUrl, token, botKeyId, challenge, signature) {
+  const url = `${brokerUrl}/api/v1/bots/keys/confirm/`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify({
+      bot_key_id: botKeyId,
+      challenge,
+      signature
+    })
+  });
+  if (!response.ok) {
+    const body = await response.text();
+    throw new Error(
+      `Key confirmation failed (${response.status}): ${body}`
+    );
+  }
+  return await response.json();
+}
+
+// src/auth/auth-module.ts
+async function signChallengeRaw(privateKey, data) {
+  const signer = crypto.createSign("SHA256");
+  signer.update(data);
+  signer.end();
+  const derSignature = signer.sign(
+    privateKey
+  );
+  return derSignature.toString("base64url");
+}
+var AuthModule = class {
+  constructor(token, brokerUrl, keystorePath) {
+    this.token = token;
+    this.brokerUrl = brokerUrl;
+    this.keystorePath = keystorePath;
+  }
+  token;
+  brokerUrl;
+  keystorePath;
+  privateKey = null;
+  publicJwk = null;
+  kid = null;
+  /**
+   * Ensure we have an enrolled keypair. Either loads from disk or
+   * performs the full enrollment flow.
+   */
+  async ensureEnrolled() {
+    const existing = await loadKeystore(this.keystorePath, this.brokerUrl);
+    if (existing) {
+      this.privateKey = existing.privateKey;
+      this.publicJwk = existing.publicJwk;
+      this.kid = existing.kid;
+      console.error("[auth] Loaded existing keypair from keystore");
+      return {
+        privateKey: existing.privateKey,
+        publicJwk: existing.publicJwk,
+        kid: existing.kid
+      };
+    }
+    console.error("[auth] No valid keystore found, enrolling new keypair...");
+    const { privateKey, publicJwk } = await generateES256KeyPair();
+    const regResult = await registerKey(this.brokerUrl, this.token, publicJwk);
+    console.error(`[auth] Key registered: ${regResult.bot_key_id}`);
+    const thumbprint = await calculateJwkThumbprint(publicJwk, "sha256");
+    const challengeData = `${regResult.challenge}.${thumbprint}`;
+    const signature = await signChallengeRaw(privateKey, challengeData);
+    const confirmResult = await confirmKey(
+      this.brokerUrl,
+      this.token,
+      regResult.bot_key_id,
+      regResult.challenge,
+      signature
+    );
+    if (!confirmResult.key_confirmed) {
+      throw new Error("Key enrollment failed: confirmation was rejected");
+    }
+    console.error("[auth] Key enrollment confirmed");
+    await saveKeystore(
+      privateKey,
+      publicJwk,
+      regResult.bot_key_id,
+      this.brokerUrl,
+      this.keystorePath
+    );
+    this.privateKey = privateKey;
+    this.publicJwk = publicJwk;
+    this.kid = regResult.bot_key_id;
+    return {
+      privateKey,
+      publicJwk,
+      kid: regResult.bot_key_id
+    };
+  }
+  getPrivateKey() {
+    if (!this.privateKey) throw new Error("Not enrolled yet");
+    return this.privateKey;
+  }
+  getPublicJwk() {
+    if (!this.publicJwk) throw new Error("Not enrolled yet");
+    return this.publicJwk;
+  }
+  getKid() {
+    if (!this.kid) throw new Error("Not enrolled yet");
+    return this.kid;
+  }
+};
+
+export {
+  AuthModule
+};

package/dist/{chunk-62KH6VNQ.js → chunk-GATXJ6UT.js}

@@ -1,21 +1,21 @@
 import {
-  startEventStream
-} from "./chunk-YVUXQ4Z2.js";
+  buildCatchUpNote,
+  buildMonitorSpawn,
+  buildReplyRecipe
+} from "./chunk-X672ZN7V.js";
 import {
   deriveDiscoveryKey,
   findClaudeAncestorPid
 } from "./chunk-BJMASMKX.js";
 import {
-  buildCatchUpNote,
-  buildMonitorSpawn,
-  buildReplyRecipe
-} from "./chunk-X672ZN7V.js";
+  AuthModule
+} from "./chunk-6SK6ITFE.js";
 import {
-  GatewayClient,
-  generateES256KeyPair,
-  loadKeystore,
-  saveKeystore
-} from "./chunk-36L3GCU3.js";
+  GatewayClient
+} from "./chunk-3XDJOHMZ.js";
+import {
+  startEventStream
+} from "./chunk-UEGQGXPY.js";
 import {
   translateToolCallResult
 } from "./chunk-LDZXU3DW.js";
@@ -25,139 +25,6 @@ import fs2 from "fs";
 import os from "os";
 import path2 from "path";
 
-// src/auth/auth-module.ts
-import { calculateJwkThumbprint } from "jose";
-import crypto from "crypto";
-
-// src/auth/registration.ts
-async function registerKey(brokerUrl, token, publicJwk) {
-  const url = `${brokerUrl}/api/v1/bots/keys/register/`;
-  const response = await fetch(url, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${token}`
-    },
-    body: JSON.stringify({ public_jwk: publicJwk })
-  });
-  if (!response.ok) {
-    const body = await response.text();
-    throw new Error(
-      `Key registration failed (${response.status}): ${body}`
-    );
-  }
-  return await response.json();
-}
-async function confirmKey(brokerUrl, token, botKeyId, challenge, signature) {
-  const url = `${brokerUrl}/api/v1/bots/keys/confirm/`;
-  const response = await fetch(url, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${token}`
-    },
-    body: JSON.stringify({
-      bot_key_id: botKeyId,
-      challenge,
-      signature
-    })
-  });
-  if (!response.ok) {
-    const body = await response.text();
-    throw new Error(
-      `Key confirmation failed (${response.status}): ${body}`
-    );
-  }
-  return await response.json();
-}
-
-// src/auth/auth-module.ts
-async function signChallengeRaw(privateKey, data) {
-  const signer = crypto.createSign("SHA256");
-  signer.update(data);
-  signer.end();
-  const derSignature = signer.sign(
-    privateKey
-  );
-  return derSignature.toString("base64url");
-}
-var AuthModule = class {
-  constructor(token, brokerUrl, keystorePath) {
-    this.token = token;
-    this.brokerUrl = brokerUrl;
-    this.keystorePath = keystorePath;
-  }
-  token;
-  brokerUrl;
-  keystorePath;
-  privateKey = null;
-  publicJwk = null;
-  kid = null;
-  /**
-   * Ensure we have an enrolled keypair. Either loads from disk or
-   * performs the full enrollment flow.
-   */
-  async ensureEnrolled() {
-    const existing = await loadKeystore(this.keystorePath, this.brokerUrl);
-    if (existing) {
-      this.privateKey = existing.privateKey;
-      this.publicJwk = existing.publicJwk;
-      this.kid = existing.kid;
-      console.error("[auth] Loaded existing keypair from keystore");
-      return {
-        privateKey: existing.privateKey,
-        publicJwk: existing.publicJwk,
-        kid: existing.kid
-      };
-    }
-    console.error("[auth] No valid keystore found, enrolling new keypair...");
-    const { privateKey, publicJwk } = await generateES256KeyPair();
-    const regResult = await registerKey(this.brokerUrl, this.token, publicJwk);
-    console.error(`[auth] Key registered: ${regResult.bot_key_id}`);
-    const thumbprint = await calculateJwkThumbprint(publicJwk, "sha256");
-    const challengeData = `${regResult.challenge}.${thumbprint}`;
-    const signature = await signChallengeRaw(privateKey, challengeData);
-    const confirmResult = await confirmKey(
-      this.brokerUrl,
-      this.token,
-      regResult.bot_key_id,
-      regResult.challenge,
-      signature
-    );
-    if (!confirmResult.key_confirmed) {
-      throw new Error("Key enrollment failed: confirmation was rejected");
-    }
-    console.error("[auth] Key enrollment confirmed");
-    await saveKeystore(
-      privateKey,
-      publicJwk,
-      regResult.bot_key_id,
-      this.brokerUrl,
-      this.keystorePath
-    );
-    this.privateKey = privateKey;
-    this.publicJwk = publicJwk;
-    this.kid = regResult.bot_key_id;
-    return {
-      privateKey,
-      publicJwk,
-      kid: regResult.bot_key_id
-    };
-  }
-  getPrivateKey() {
-    if (!this.privateKey) throw new Error("Not enrolled yet");
-    return this.privateKey;
-  }
-  getPublicJwk() {
-    if (!this.publicJwk) throw new Error("Not enrolled yet");
-    return this.publicJwk;
-  }
-  getKid() {
-    if (!this.kid) throw new Error("Not enrolled yet");
-    return this.kid;
-  }
-};
-
 // src/tool-registry.ts
 var ToolRegistry = class {
   constructor(gateway) {
@@ -269,7 +136,19 @@ function buildChannelInstructions(_tandemMembershipCount, eventLogPath) {
   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.";
   return intro + monitorSection + listenSection + advice;
 }
-function createMcpServer(registry, adapter, tandemMembershipCount = -1, eventLogPath) {
+async function executeToolCall(registry, name, args, hooks) {
+  const rawResult = await registry.callTool(name, args);
+  const result = translateToolCallResult(rawResult);
+  if (name === "tandem_join" && !result.isError) {
+    try {
+      hooks?.onTandemJoin?.();
+    } catch (err) {
+      console.error("[mcp] onTandemJoin hook failed:", err?.message ?? String(err));
+    }
+  }
+  return result;
+}
+function createMcpServer(registry, adapter, tandemMembershipCount = -1, eventLogPath, hooks) {
   const capabilities = { tools: {} };
   if (adapter.supportsChannels) {
     capabilities.experimental = { "claude/channel": {} };
@@ -291,8 +170,7 @@ function createMcpServer(registry, adapter, tandemMembershipCount = -1, eventLog
   });
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
-    const rawResult = await registry.callTool(name, args ?? {});
-    const result = translateToolCallResult(rawResult);
+    const result = await executeToolCall(registry, name, args ?? {}, hooks);
     return { content: result.content, isError: result.isError };
   });
   return server;
@@ -420,6 +298,7 @@ async function listTandemIds(gateway) {
     return list.map((t) => {
       if (typeof t === "string") return t;
       const obj = t;
+      if (obj?.my_membership?.is_member !== true) return void 0;
       return obj?.tandem_id ?? obj?.id;
     }).filter((id) => typeof id === "string" && id.length > 0);
   } catch {
@@ -437,6 +316,50 @@ async function startProxy(config) {
   console.error(
     `[kojee-mcp] Ready \u2014 ${registry.toolCount} tools available from ${config.url}`
   );
+  let activeStreamHandle = null;
+  const { createJoinReconnectScheduler } = await import("./reconnect-scheduler-ARV6JIWK.js");
+  const joinReconnect = createJoinReconnectScheduler({
+    // BOOT-RACE (Bug B): report whether the stream handle was actually ready.
+    // `false` ⇒ activeStreamHandle is still null (tandem_join fired before the
+    // stream was set up) → the scheduler queues the reconnect and flushes it on
+    // notifyReady() once the handle is assigned (see below), instead of silently
+    // dropping it as the old `activeStreamHandle?.reconnect()` no-op did.
+    reconnect: () => {
+      if (!activeStreamHandle) return false;
+      activeStreamHandle.reconnect();
+      return true;
+    }
+  });
+  const onTandemJoin = () => joinReconnect.requestReconnect();
+  const teardownSteps = [];
+  let shuttingDown = false;
+  function shutdown(reason) {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    activeStreamHandle?.();
+    for (const step of teardownSteps) {
+      try {
+        const maybe = step();
+        if (maybe && typeof maybe.catch === "function") {
+          maybe.catch((err) => {
+            console.error("[kojee-mcp] async shutdown step failed:", err?.message ?? err);
+          });
+        }
+      } catch (err) {
+        console.error("[kojee-mcp] shutdown step failed:", err?.message ?? err);
+      }
+    }
+    console.error(`[kojee-mcp] shutting down (${reason}), exiting`);
+    process.exit(0);
+  }
+  const ccPid = await findClaudeAncestorPid();
+  const { ensureJoinTandems } = await import("./ensure-join-7AEDJMPE.js");
+  await ensureJoinTandems({
+    gateway,
+    env: process.env["KOJEE_TANDEMS"],
+    listTandems: () => listTandemIds(gateway),
+    onJoined: () => joinReconnect.requestReconnect()
+  });
   let tandemMembershipCount = -1;
   try {
     const bootIds = await listTandemIds(gateway);
@@ -448,19 +371,18 @@ async function startProxy(config) {
   let server;
   if (adapter.supportsChannels) {
     const { EventQueue } = await import("./event-queue-5YVJFR3E.js");
-    const { startHookServer } = await import("./hook-server-NDJSV22J.js");
+    const { startHookServer } = await import("./hook-server-37E2LUKJ.js");
     const {
       writeDiscoveryByKey,
       cleanupDiscoveryByKey,
       sweepStaleDiscovery
     } = 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-UKUSI2FE.js");
-    const { createWebhookSink } = await import("./webhook-sink-GCLL2S6S.js");
+    const { resubscribeMemberships } = await import("./resubscribe-G5OGDZJD.js");
+    const { resolveWebhookConfig } = await import("./webhook-config-O4WMQ532.js");
+    const { createWebhookSink } = await import("./webhook-sink-NWGCUDGY.js");
     sweepStaleDiscovery();
     sweepStaleEventLogs();
-    const ccPid = await findClaudeAncestorPid();
     const projectDir = process.env["CLAUDE_PROJECT_DIR"];
     const discoveryKey = deriveDiscoveryKey(projectDir, ccPid);
     const eventLog = startEventLog({ key: discoveryKey });
@@ -487,14 +409,16 @@ async function startProxy(config) {
       void eventLog.appendStatus(`status=webhook enabled ${webhookSink.configSummary()}`).catch(() => {
       });
     }
-    server = createMcpServer(registry, adapter, tandemMembershipCount, eventLog.path);
-    const { issueControlToken, controlTokenPath } = await import("./control-token-TYDAL477.js");
+    server = createMcpServer(registry, adapter, tandemMembershipCount, eventLog.path, {
+      onTandemJoin
+    });
+    const { issueControlToken, controlTokenPath } = await import("./control-token-4BUCTYQB.js");
     let controlToken = null;
     try {
       controlToken = issueControlToken();
     } catch (err) {
       console.error(
-        "[kojee-mcp] control token write failed \u2014 POST /send disabled:",
+        "[kojee-mcp] control token write failed \u2014 POST /send disabled; GET /poll and /status left UNGATED (degrade open):",
         err.message
       );
     }
@@ -504,7 +428,10 @@ async function startProxy(config) {
       port: 0,
       queue,
       adapter,
-      ...controlToken !== null ? { send: { gateway, authToken: controlToken } } : {},
+      // 0.5.4 hardening: the same bearer gates POST /send AND the data-bearing
+      // reads (GET /poll, GET /status). When token issuance failed both stay
+      // available-but-degraded: /send answers 503, the reads stay open.
+      ...controlToken !== null ? { controlToken, send: { gateway, authToken: controlToken } } : {},
       getStreamState: () => streamHandle ? streamHandle.getState() : {
         connected: false,
         connectedSince: null,
@@ -539,16 +466,16 @@ async function startProxy(config) {
       authMode: config.authMode ?? "paired"
     });
     const cleanupDiscoveryFile = () => cleanupDiscoveryByKey(discoveryKey);
-    process.on("exit", () => cleanupDiscoveryFile());
-    process.on("SIGINT", () => {
+    process.on("exit", () => {
       cleanupDiscoveryFile();
-      process.exit(0);
+      eventLog.cleanup();
     });
-    process.on("SIGTERM", () => {
-      cleanupDiscoveryFile();
-      process.exit(0);
+    teardownSteps.push(() => {
+      void webhookSink?.stop();
     });
-    process.on("exit", () => eventLog.cleanup());
+    teardownSteps.push(() => cleanupDiscoveryFile());
+    teardownSteps.push(() => eventLog.cleanup());
+    teardownSteps.push(() => hookServer.stop());
     streamHandle = await startEventStream({
       brokerUrl: config.url,
       token: config.token,
@@ -584,24 +511,14 @@ async function startProxy(config) {
         };
       })()
     });
-    const cancelStream = streamHandle;
-    process.stdin.on("end", () => {
-      cancelStream();
-      void webhookSink?.stop();
-      cleanupDiscoveryFile();
-      eventLog.cleanup();
-      hookServer.stop().finally(() => {
-        console.error("[kojee-mcp] stdin closed, exiting");
-        process.exit(0);
-      });
-    });
+    activeStreamHandle = streamHandle;
+    joinReconnect.notifyReady();
   } else if (needsWebhookEventStream()) {
     const { startEventLog, sweepStaleEventLogs } = await import("./event-log-RSTM4PLL.js");
-    const { resolveWebhookConfig } = await import("./webhook-config-UKUSI2FE.js");
-    const { createWebhookSink } = await import("./webhook-sink-GCLL2S6S.js");
-    const { resubscribeMemberships } = await import("./resubscribe-SLZNA76S.js");
+    const { resolveWebhookConfig } = await import("./webhook-config-O4WMQ532.js");
+    const { createWebhookSink } = await import("./webhook-sink-NWGCUDGY.js");
+    const { resubscribeMemberships } = await import("./resubscribe-G5OGDZJD.js");
     sweepStaleEventLogs();
-    const ccPid = await findClaudeAncestorPid();
     const projectDir = process.env["CLAUDE_PROJECT_DIR"];
     const discoveryKey = deriveDiscoveryKey(projectDir, ccPid);
     const eventLog = startEventLog({ key: discoveryKey });
@@ -627,8 +544,14 @@ async function startProxy(config) {
       void eventLog.appendStatus(`status=webhook enabled ${webhookSink.configSummary()}`).catch(() => {
       });
     }
-    server = createMcpServer(registry, adapter, tandemMembershipCount);
+    server = createMcpServer(registry, adapter, tandemMembershipCount, void 0, {
+      onTandemJoin
+    });
     process.on("exit", () => eventLog.cleanup());
+    teardownSteps.push(() => {
+      void webhookSink?.stop();
+    });
+    teardownSteps.push(() => eventLog.cleanup());
     const streamHandle = await startEventStream({
       brokerUrl: config.url,
       token: config.token,
@@ -649,19 +572,28 @@ async function startProxy(config) {
         };
       })()
     });
-    process.stdin.on("end", () => {
-      streamHandle();
-      void webhookSink?.stop();
-      eventLog.cleanup();
-      console.error("[kojee-mcp] stdin closed, exiting");
-      process.exit(0);
-    });
+    activeStreamHandle = streamHandle;
+    joinReconnect.notifyReady();
   } else {
     server = createMcpServer(registry, adapter, tandemMembershipCount);
-    process.stdin.on("end", () => {
-      console.error("[kojee-mcp] stdin closed, exiting");
-      process.exit(0);
+  }
+  process.stdin.on("end", () => shutdown("stdin end"));
+  process.stdin.on("close", () => shutdown("stdin close"));
+  process.on("SIGHUP", () => shutdown("SIGHUP"));
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  if (ccPid !== null) {
+    const { createParentWatchdog } = await import("./parent-watchdog-RZLHYP7T.js");
+    const watchdog = createParentWatchdog({
+      ccPid,
+      onParentGone: () => shutdown("parent (Claude Code) gone")
     });
+    watchdog.start();
+    teardownSteps.push(() => watchdog.stop());
+  } else {
+    console.error(
+      "[kojee-mcp] no Claude Code ancestor found \u2014 parent-liveness watchdog NOT armed (stdin/signal handlers still cover clean exits)"
+    );
   }
   await startMcpServer(server);
 }
@@ -698,7 +630,7 @@ async function enrollAndDiscover(config, keystorePath, isRetry = false) {
 }
 
 export {
-  AuthModule,
   VERSION,
+  listTandemIds,
   startProxy
 };