kojee-mcp 0.6.0 → 0.7.0

package/dist/{registry-YLOFZDI2.js → registry-VRFHKOPP.js}

@@ -1,11 +1,16 @@
-import "./chunk-KFDZWNQO.js";
+import {
+  createCachedOpenclawWakeResolver,
+  postOpenclawWake
+} from "./chunk-NE2F5CKS.js";
 import "./chunk-PHXO5P25.js";
-import "./chunk-LSUB6QMP.js";
+import {
+  codexPendingMarkerPath
+} from "./chunk-WIU5WGDF.js";
 import {
   claudeCodeAdapter
-} from "./chunk-N35X22G7.js";
-import "./chunk-ALZX3SGI.js";
-import "./chunk-Q7T3WAST.js";
+} from "./chunk-OB5T6P24.js";
+import "./chunk-SGRVG4HW.js";
+import "./chunk-QEJUNP3X.js";
 import "./chunk-PPTKGWFF.js";
 
 // src/delivery/lib/fanout.ts
@@ -36,6 +41,18 @@ async function deliverEvent(event, sinks) {
   } catch (err) {
     console.error("[event-stream] webhook enqueue failed:", err);
   }
+  if (sinks.codexPendingMarker) {
+    try {
+      const pending = sinks.codexPendingMarker(event);
+      if (pending && typeof pending.then === "function") {
+        pending.catch((err) => {
+          console.error("[event-stream] codex pending-marker write failed:", err);
+        });
+      }
+    } catch (err) {
+      console.error("[event-stream] codex pending-marker write failed:", err);
+    }
+  }
 }
 
 // src/delivery/lib/channel.ts
@@ -96,20 +113,27 @@ function createClaudeCodeDelivery() {
         writeDiscoveryByKey,
         cleanupDiscoveryByKey,
         sweepStaleDiscovery
-      } = await import("./session-discovery-FNMJGFPM.js");
-      const { startEventLog, sweepStaleEventLogs } = await import("./event-log-HOBO3ECB.js");
+      } = await import("./session-discovery-NHCZ2XWA.js");
+      const { startEventLog, sweepStaleEventLogs } = await import("./event-log-2NBJEIEP.js");
       const { resubscribeMemberships } = await import("./resubscribe-G5OGDZJD.js");
       const { resolveWebhookConfig } = await import("./webhook-config-O4WMQ532.js");
       const { createWebhookSink } = await import("./webhook-sink-N6AUTFL3.js");
-      const { startEventStream } = await import("./event-stream-SYBUJ5EH.js");
-      const { createMcpServer } = await import("./server-R24AVNTI.js");
-      const { deriveDiscoveryKey } = await import("./ancestry-ONFBQEP5.js");
+      const { startEventStream } = await import("./event-stream-KRYWEYWO.js");
+      const { createMcpServer } = await import("./server-YTHOMA4H.js");
+      const { deriveDiscoveryKey } = await import("./ancestry-A2F5KQ6A.js");
+      const { resolveSharedSessionId } = await import("./cc-session-id-RURNIHHC.js");
       sweepStaleDiscovery();
       sweepStaleEventLogs();
       const projectDir = process.env["CLAUDE_PROJECT_DIR"];
-      const discoveryKey = deriveDiscoveryKey(projectDir, ctx.ccPid);
+      const sessionId = resolveSharedSessionId();
+      const discoveryKey = deriveDiscoveryKey(projectDir, ctx.ccPid, sessionId);
       eventLog = startEventLog({
         key: ctx.instanceKey,
+        // The proxy's OWN discovery key: lets startEventLog reclaim the STABLE
+        // base log path on an in-session reconnect (env-switch / /mcp reconnect;
+        // unchanged ccPid → unchanged discovery key) instead of salting and
+        // stranding the agent's already-running Monitor on the dead base log.
+        selfKey: discoveryKey,
         ...ctx.eventLogDir ? { dir: ctx.eventLogDir } : {}
       });
       const log = eventLog;
@@ -142,7 +166,7 @@ function createClaudeCodeDelivery() {
         eventLog.path,
         ctx.toolCallHooks
       );
-      const { issueControlToken, controlTokenPath } = await import("./control-token-4BUCTYQB.js");
+      const { issueControlToken, controlTokenPath } = await import("./control-token-KXSZ3GBY.js");
       let controlToken = null;
       try {
         controlToken = issueControlToken();
@@ -174,7 +198,7 @@ function createClaudeCodeDelivery() {
           staleAfterMs: null
         }
       });
-      writeDiscoveryByKey(discoveryKey, {
+      const discoveryEntry = {
         schema: 2,
         discoveryKey,
         ccPid: ctx.ccPid,
@@ -187,8 +211,18 @@ function createClaudeCodeDelivery() {
         eventLogPath: eventLog.path,
         ...controlToken !== null ? { controlTokenPath: controlTokenPath() } : {},
         authMode: ctx.config.authMode ?? "paired"
-      });
-      cleanupDiscoveryFile = () => cleanupDiscoveryByKey(discoveryKey);
+      };
+      writeDiscoveryByKey(discoveryKey, discoveryEntry);
+      const aliasKey = sessionId && ctx.ccPid !== null ? deriveDiscoveryKey(projectDir, ctx.ccPid, null) : null;
+      if (aliasKey !== null && aliasKey !== discoveryKey) {
+        writeDiscoveryByKey(aliasKey, { ...discoveryEntry, discoveryKey: aliasKey });
+      }
+      cleanupDiscoveryFile = () => {
+        cleanupDiscoveryByKey(discoveryKey);
+        if (aliasKey !== null && aliasKey !== discoveryKey) {
+          cleanupDiscoveryByKey(aliasKey);
+        }
+      };
       const localCleanupDiscovery = cleanupDiscoveryFile;
       const localHookServer = hookServer;
       const localLiveliness = liveliness;
@@ -267,19 +301,19 @@ function createClaudeCodeDelivery() {
 }
 
 // src/delivery/hermes.ts
-function createWebhookDelivery(name) {
+function createWebhookDelivery(name, codexPendingMarker) {
   let eventLog = null;
   let webhookSink = null;
   let streamHandle = null;
   return {
     name,
     async start(ctx) {
-      const { startEventLog, sweepStaleEventLogs } = await import("./event-log-HOBO3ECB.js");
+      const { startEventLog, sweepStaleEventLogs } = await import("./event-log-2NBJEIEP.js");
       const { resolveWebhookConfig } = await import("./webhook-config-O4WMQ532.js");
       const { createWebhookSink } = await import("./webhook-sink-N6AUTFL3.js");
       const { resubscribeMemberships } = await import("./resubscribe-G5OGDZJD.js");
-      const { startEventStream } = await import("./event-stream-SYBUJ5EH.js");
-      const { createMcpServer } = await import("./server-R24AVNTI.js");
+      const { startEventStream } = await import("./event-stream-KRYWEYWO.js");
+      const { createMcpServer } = await import("./server-YTHOMA4H.js");
       sweepStaleEventLogs();
       eventLog = startEventLog({
         key: ctx.instanceKey,
@@ -348,7 +382,9 @@ function createWebhookDelivery(name) {
     async deliver(event) {
       await deliverEvent(event, {
         ...eventLog ? { eventLog } : {},
-        ...webhookSink ? { webhookSink } : {}
+        ...webhookSink ? { webhookSink } : {},
+        // OPTIONAL codex-only marker sink (undefined ⇒ byte-identical hermes path).
+        ...codexPendingMarker ? { codexPendingMarker } : {}
       });
     },
     async stop() {
@@ -365,9 +401,139 @@ function createWebhookDelivery(name) {
   };
 }
 
+// src/delivery/codex-pending-marker.ts
+import fsp from "fs/promises";
+import path from "path";
+import crypto from "crypto";
+var MAX_MARKER_BODY_CHARS = 32;
+var ensuredDir = null;
+async function writeCodexPendingMarker(event) {
+  const markerPath = codexPendingMarkerPath();
+  const dir = path.dirname(markerPath);
+  const tmp = `${markerPath}.tmp-${process.pid}-${crypto.randomUUID()}`;
+  try {
+    if (ensuredDir !== dir) {
+      await fsp.mkdir(dir, { recursive: true });
+      ensuredDir = dir;
+    }
+    const body = String(event.cursor ?? 0).slice(0, MAX_MARKER_BODY_CHARS);
+    await fsp.writeFile(tmp, body, { mode: 384 });
+    await fsp.rename(tmp, markerPath);
+  } catch {
+    ensuredDir = null;
+    try {
+      await fsp.unlink(tmp);
+    } catch {
+    }
+  }
+}
+
 // src/delivery/codex.ts
 function createCodexDelivery() {
-  return createWebhookDelivery("codex");
+  return createWebhookDelivery("codex", writeCodexPendingMarker);
+}
+
+// src/delivery/openclaw.ts
+function formatOpenclawNudge(event) {
+  const who = event.from?.member_id ?? "someone";
+  const body = (event.content?.body ?? "").replace(/\s+/g, " ").slice(0, 160);
+  return `New Kojee Tandem activity in ${event.tandem_id} from ${who}: "${body}". Catch up with tandem_messages / tandem_listen and reply via tandem_send.`;
+}
+function createOpenclawDelivery(deps = {}) {
+  const resolveTarget = deps.resolveTarget ?? createCachedOpenclawWakeResolver();
+  const postWake = deps.postWake ?? postOpenclawWake;
+  let eventLog = null;
+  let streamHandle = null;
+  let warnedUnconfigured = false;
+  return {
+    name: "openclaw",
+    async start(ctx) {
+      const { startEventLog, sweepStaleEventLogs } = await import("./event-log-2NBJEIEP.js");
+      const { resubscribeMemberships } = await import("./resubscribe-G5OGDZJD.js");
+      const { startEventStream } = await import("./event-stream-KRYWEYWO.js");
+      const { createMcpServer } = await import("./server-YTHOMA4H.js");
+      sweepStaleEventLogs();
+      eventLog = startEventLog({
+        key: ctx.instanceKey,
+        ...ctx.eventLogDir ? { dir: ctx.eventLogDir } : {}
+      });
+      const log = eventLog;
+      const initial = await resolveTarget();
+      void log.appendStatus(
+        `status=openclaw-wake ${initial.ok ? `target=${initial.target.url}` : `error="${initial.reason}"`}`
+      ).catch(() => {
+      });
+      const server = createMcpServer(
+        ctx.registry,
+        ctx.adapter,
+        ctx.tandemMembershipCount,
+        void 0,
+        ctx.toolCallHooks
+      );
+      const teardown = [() => eventLog?.cleanup()];
+      streamHandle = await startEventStream({
+        brokerUrl: ctx.config.url,
+        token: ctx.config.token,
+        gateway: ctx.gateway,
+        adapter: ctx.adapter,
+        server,
+        eventLog,
+        delivery: this,
+        onConnected: /* @__PURE__ */ (() => {
+          const debounceState = { lastRunAt: 0 };
+          return async () => {
+            await resubscribeMemberships({
+              gateway: ctx.gateway,
+              eventLog,
+              listTandems: async () => await ctx.listTandemIds() ?? [],
+              debounceState
+            });
+          };
+        })()
+      });
+      ctx.onStreamReady?.(streamHandle);
+      return { server, teardown, exitCleanup: () => eventLog?.cleanup() };
+    },
+    // Event-log append FIRST (survival/observability parity with hermes; the
+    // Monitor's PRIMARY wake path, so it is AWAITED like fanout's eventLog sink).
+    // The /wake POST is FIRE-AND-FORGET: it is network I/O with a 4s timeout and
+    // must NOT be awaited on the shared consumeSse loop — a gateway that accepts
+    // TCP but hangs would otherwise backpressure the single interleaved stream
+    // for every room (hermes/codex enqueue their network/disk sinks the same way,
+    // fanout.ts). Target RESOLUTION rides the same detached chain (F5): it is
+    // disk I/O (openclaw.json read — async + mtime-cached by the default
+    // resolver), and a stalled home dir (NFS, AV scan, full disk) must never
+    // block the reader loop that multiplexes tool-call proxying for every room.
+    async deliver(event) {
+      try {
+        await eventLog?.append(event);
+      } catch (err) {
+        console.error("[openclaw] event-log append failed:", err);
+      }
+      void (async () => {
+        const r = await resolveTarget();
+        if (!r.ok) {
+          if (!warnedUnconfigured) {
+            warnedUnconfigured = true;
+            console.error(`[openclaw] wake skipped: ${r.reason}`);
+          }
+          return;
+        }
+        warnedUnconfigured = false;
+        const res = await postWake(r.target, { text: formatOpenclawNudge(event), mode: "now" });
+        if (!res.ok) console.error(`[openclaw] wake POST failed: ${res.error ?? res.status}`);
+      })().catch((err) => {
+        console.error("[openclaw] wake delivery failed:", err);
+      });
+    },
+    async stop() {
+      eventLog?.cleanup();
+    },
+    health() {
+      const s = streamHandle?.getState();
+      return { connected: s ? s.connected ?? null : null, ...s ? { detail: { stream: s } } : {} };
+    }
+  };
 }
 
 // src/delivery/registry.ts
@@ -378,12 +544,15 @@ function selectDelivery(runtime, opts) {
   if (opts.supportsChannels) {
     return createClaudeCodeDelivery();
   }
-  if (!needsWebhookEventStream(opts.env)) {
-    return null;
-  }
   if (runtime === "codex") {
     return createCodexDelivery();
   }
+  if (runtime === "openclaw") {
+    return createOpenclawDelivery();
+  }
+  if (!needsWebhookEventStream(opts.env)) {
+    return null;
+  }
   return createWebhookDelivery(runtime);
 }
 export {

package/dist/resolve-slot-BFIB46Y5.js

@@ -0,0 +1,13 @@
+import {
+  CONNECT_RUNTIMES,
+  resolveLaunchCreds,
+  resolvePairedSlot
+} from "./chunk-EIH2LNF4.js";
+import "./chunk-5SZHXYPK.js";
+import "./chunk-6G6YYST6.js";
+import "./chunk-U5HHHRXA.js";
+export {
+  CONNECT_RUNTIMES,
+  resolveLaunchCreds,
+  resolvePairedSlot
+};

package/dist/{runtime-record-WO4IECM6.js → runtime-record-OXRLTOLC.js}

@@ -3,9 +3,9 @@ import {
   readRecordedRuntime,
   recordRuntime,
   runtimeRecordPath
-} from "./chunk-EW72ZNQL.js";
+} from "./chunk-RDLF4NQC.js";
 import "./chunk-SQL56SEB.js";
-import "./chunk-BLEGIR35.js";
+import "./chunk-U5HHHRXA.js";
 export {
   clearRuntimeRecord,
   readRecordedRuntime,

package/dist/{send-cli-IYJF32PE.js → send-cli-45RLGYIC.js}

@@ -1,3 +1,6 @@
+import {
+  resolvePairedSlot
+} from "./chunk-EIH2LNF4.js";
 import {
   executeJoin,
   executeSend,
@@ -6,38 +9,47 @@ import {
 } from "./chunk-PKOBR7ZN.js";
 import {
   loadPairedConfig
-} from "./chunk-YH27B6SW.js";
+} from "./chunk-5SZHXYPK.js";
 import {
   GatewayClient,
   applyStableSessionId
-} from "./chunk-KH5YEJIM.js";
-import "./chunk-NR4Y54OL.js";
+} from "./chunk-247WFMCJ.js";
+import "./chunk-Z5LPNJQ6.js";
+import "./chunk-MIEI4PLB.js";
 import {
+  deriveKeystorePath,
   loadKeystore
-} from "./chunk-CH32ELFX.js";
-import "./chunk-BLEGIR35.js";
+} from "./chunk-6G6YYST6.js";
+import "./chunk-U5HHHRXA.js";
 import "./chunk-PPTKGWFF.js";
+import "./chunk-KNEJTD6G.js";
 
 // src/tandem/send-cli.ts
 import os from "os";
 import path from "path";
-async function createPairedGateway(kojeeDir, stableDeps = {}) {
-  const configPath = path.join(kojeeDir, "config.json");
+async function createPairedGateway(kojeeDir, stableDeps = {}, slot = {}) {
+  const resolvedRuntime = slot.runtime ?? process.env["KOJEE_RUNTIME"];
+  const resolution = resolvePairedSlot({
+    ...slot.pairedConfig ? { pairedConfig: slot.pairedConfig } : {},
+    ...resolvedRuntime ? { runtime: resolvedRuntime } : {},
+    kojeeDir
+  });
+  const configPath = resolution.configPath;
   const paired = loadPairedConfig(configPath);
   if (!paired) {
     return sendFailure(
       "not_paired",
-      `no paired config at ${configPath} \u2014 run \`kojee-mcp pair <code> --url <broker>\` first`
+      `no paired config at ${configPath} \u2014 run \`kojee-mcp connect <code> --runtime <id>\` first`
     );
   }
   await applyStableSessionId(paired.token, stableDeps);
   const brokerUrl = paired.broker_url.replace(/\/+$/, "");
-  const keystorePath = path.join(kojeeDir, "keypair.json");
+  const keystorePath = resolution.scope === "paired" ? deriveKeystorePath(paired.token) : path.join(kojeeDir, "keypair.json");
   const keystore = await loadKeystore(keystorePath, brokerUrl).catch(() => null);
   if (!keystore) {
     return sendFailure(
       "not_enrolled",
-      `no DPoP keystore for ${brokerUrl} at ${keystorePath} \u2014 start the proxy once (or re-run \`kojee-mcp pair\`) to enroll a keypair`
+      `no DPoP keystore for ${brokerUrl} at ${keystorePath} \u2014 start the proxy once (or re-run \`kojee-mcp connect\`) to enroll a keypair`
     );
   }
   const sessionId = GatewayClient.deriveSessionId(paired.token);

package/dist/{server-R24AVNTI.js → server-YTHOMA4H.js}

@@ -1,13 +1,15 @@
 import {
   buildChannelInstructions,
+  buildNonChannelInstructions,
   createMcpServer,
   executeToolCall,
   startMcpServer
-} from "./chunk-ALZX3SGI.js";
-import "./chunk-Q7T3WAST.js";
+} from "./chunk-SGRVG4HW.js";
+import "./chunk-QEJUNP3X.js";
 import "./chunk-PPTKGWFF.js";
 export {
   buildChannelInstructions,
+  buildNonChannelInstructions,
   createMcpServer,
   executeToolCall,
   startMcpServer

package/dist/{session-discovery-FNMJGFPM.js → session-discovery-NHCZ2XWA.js}

@@ -10,8 +10,8 @@ import {
   sweepStaleDiscovery,
   writeDiscoveryByKey,
   writeSessionDiscovery
-} from "./chunk-DO42NPNR.js";
-import "./chunk-BLEGIR35.js";
+} from "./chunk-67F67AQ6.js";
+import "./chunk-U5HHHRXA.js";
 export {
   cleanupDiscoveryByKey,
   cleanupSessionDiscovery,

package/dist/setup-handler-UHVKSX7E.js

@@ -0,0 +1,159 @@
+import {
+  DEFAULT_BROKER_URL,
+  pairSlotFor,
+  reconcileConnectPairSlot,
+  runWizard
+} from "./chunk-GVWYW7MY.js";
+import "./chunk-E6WMFMM2.js";
+import "./chunk-OBIJ6WQP.js";
+import "./chunk-QJFMU4QC.js";
+import "./chunk-D6JKFJ6A.js";
+import "./chunk-EIH2LNF4.js";
+import "./chunk-RDLF4NQC.js";
+import "./chunk-SQL56SEB.js";
+import {
+  isWizardRuntime
+} from "./chunk-77HWBSRH.js";
+import "./chunk-V5VZPYMZ.js";
+import {
+  runPair
+} from "./chunk-EIAUW6KO.js";
+import {
+  loadPairedConfig
+} from "./chunk-5SZHXYPK.js";
+import "./chunk-I67C2HYA.js";
+import "./chunk-MIEI4PLB.js";
+import "./chunk-6G6YYST6.js";
+import "./chunk-U5HHHRXA.js";
+import "./chunk-QEJUNP3X.js";
+
+// src/wizard/setup-handler.ts
+var SETUP_SUPPORTED_RUNTIMES = ["claude-code", "codex"];
+function isSetupRuntime(value) {
+  return SETUP_SUPPORTED_RUNTIMES.includes(value);
+}
+function resolvePairCode(opts) {
+  return opts.pair ?? opts.pairCode;
+}
+async function runSetup(opts) {
+  const messages = [];
+  const requested = opts.runtime ?? "claude-code";
+  if (opts.verb === "setup" && opts.runtime !== void 0 && !isSetupRuntime(opts.runtime)) {
+    const supported = SETUP_SUPPORTED_RUNTIMES.join(", ");
+    const output = isWizardRuntime(opts.runtime) ? `\`setup\` does not support --runtime ${opts.runtime} yet (coming soon). Supported by \`setup\`: ${supported}. For ${opts.runtime}, use \`kojee-mcp init --runtime ${opts.runtime}\` for now.` : `Unknown --runtime "${opts.runtime}". \`setup\` supports: ${supported}. (For hermes/openclaw use \`kojee-mcp init\`.)`;
+    return { runtime: requested, messages, output, exitCode: 2 };
+  }
+  if (opts.token !== void 0 && (opts.url === void 0 || opts.url.trim() === "") && !opts.uninstall) {
+    return {
+      runtime: requested,
+      messages,
+      output: "--token requires --url (the broker URL the Kojee UI gave you). Re-run with --url <broker-url>. Nothing was written.",
+      exitCode: 2
+    };
+  }
+  const url = opts.url ? opts.url.replace(/\/+$/, "") : void 0;
+  if (opts.pairCode && !opts.uninstall && opts.interactive && opts.runtime === void 0) {
+    return {
+      runtime: requested,
+      messages,
+      output: "Pass --runtime (claude-code | codex) together with --pair <code> so the paired credentials are keyed to the runtime you're setting up. Re-run: kojee-mcp setup --pair <code> --runtime <id>.",
+      exitCode: 2
+    };
+  }
+  let justPaired = false;
+  let pairedConfigLauncher;
+  if (opts.pairCode && !opts.uninstall) {
+    const pair = opts.runPair ?? runPair;
+    const pairUrl = url ?? DEFAULT_BROKER_URL;
+    const reconcile = reconcileConnectPairSlot(requested, opts.pairCode);
+    if (!reconcile.ok) {
+      return { runtime: requested, messages, output: reconcile.output, exitCode: reconcile.exitCode };
+    }
+    messages.push(...reconcile.messages);
+    const slot = pairSlotFor(requested, opts.pairCode);
+    try {
+      const r = await pair({
+        code: opts.pairCode,
+        url: pairUrl,
+        keystorePath: slot.keystorePath,
+        configPath: slot.configPath,
+        ...slot.runtime ? { runtime: slot.runtime } : {},
+        ...slot.allowOverwrite ? { allowOverwrite: true } : {}
+      });
+      messages.push(r.message);
+      justPaired = true;
+      pairedConfigLauncher = slot.pairedConfigPath;
+    } catch (err) {
+      return {
+        runtime: requested,
+        messages,
+        output: `Pairing failed: ${err.message}`,
+        exitCode: 1
+      };
+    }
+  }
+  const loadCfg = opts.loadPairedConfig ?? loadPairedConfig;
+  const hasCredential = justPaired || loadCfg() !== null || opts.token !== void 0;
+  if (!hasCredential && !opts.interactive && !opts.uninstall) {
+    return {
+      runtime: requested,
+      messages,
+      output: "Not paired. Run `kojee-mcp pair <code> --url <broker>` first, then re-run \u2014 or pass --pair <code> (or --token <T> --url <U>), or run in a terminal for the guided wizard.",
+      exitCode: 1
+    };
+  }
+  const result = await runWizard({
+    ...opts.runtime !== void 0 ? { runtime: opts.runtime } : {},
+    ...opts.uninstall ? { uninstall: true } : {},
+    ...opts.configPath ? { configPath: opts.configPath } : {},
+    ...opts.hooksPath ? { hooksPath: opts.hooksPath } : {},
+    // Token mode (token + url) threads --token/--url into the written config.
+    ...opts.token ? { token: opts.token } : {},
+    ...url ? { url } : {},
+    // connect-runtime pair-mode: point the launcher at the per-runtime slot so
+    // the launched proxy reads it (its default branch reads only the global slot).
+    ...pairedConfigLauncher ? { pairedConfigPath: pairedConfigLauncher } : {},
+    ...opts.webhookUrl ? { webhookUrl: opts.webhookUrl } : {},
+    ...opts.webhookSecret ? { webhookSecret: opts.webhookSecret } : {},
+    ...opts.webhookSignatureFormat ? { webhookSignatureFormat: opts.webhookSignatureFormat } : {},
+    ...opts.webhookSignatureHeader ? { webhookSignatureHeader: opts.webhookSignatureHeader } : {},
+    ...opts.webhookSignaturePrefix !== void 0 ? { webhookSignaturePrefix: opts.webhookSignaturePrefix } : {},
+    interactive: opts.interactive,
+    ...opts.interactive && opts.prompts ? opts.prompts : {}
+  });
+  if (opts.verb === "setup" && result.exitCode === 0 && !opts.uninstall) {
+    return {
+      runtime: result.runtime,
+      messages,
+      output: crispSetupSummary(result.runtime, opts, url),
+      exitCode: 0
+    };
+  }
+  return { runtime: result.runtime, messages, output: result.output, exitCode: result.exitCode };
+}
+function crispSetupSummary(runtime, opts, url) {
+  const pairedSlotLabel = isSetupRuntime(runtime) ? `~/.kojee/agents/${runtime}/config.json` : "~/.kojee/config.json";
+  const authLine = opts.token ? `  Auth:        token mode (--token/--url${url ? `, ${url}` : ""})` : `  Auth:        paired credentials (${pairedSlotLabel})`;
+  const lines = [];
+  if (runtime === "codex") {
+    lines.push("\u2713 kojee is set up for Codex.");
+    lines.push(`  MCP config:  ${opts.configPath ?? "~/.codex/config.toml"}  ([mcp_servers.kojee])`);
+    lines.push(`  Stop hook:   ${opts.hooksPath ?? "~/.codex/hooks.json"}  (codex-stop)`);
+    lines.push(authLine);
+    lines.push("");
+    lines.push("Next: restart Codex to connect.");
+  } else {
+    lines.push("\u2713 kojee is set up for Claude Code.");
+    lines.push(`  MCP config:  ${opts.configPath ?? "~/.claude.json"}  (mcpServers.kojee)`);
+    lines.push(`  Hooks:       ${opts.hooksPath ?? "~/.claude/settings.json"}  (Stop + UserPromptSubmit)`);
+    lines.push(authLine);
+    lines.push("");
+    lines.push("Next: restart Claude Code to connect.");
+  }
+  return lines.join("\n");
+}
+export {
+  SETUP_SUPPORTED_RUNTIMES,
+  resolvePairCode,
+  runSetup
+};

package/dist/{stop-hook-TCPJFGFF.js → stop-hook-YI4KRKF2.js}

@@ -1,28 +1,27 @@
-import "./chunk-XLKGPGZT.js";
 import {
-  formatChannelEvents
-} from "./chunk-PHXO5P25.js";
+  resolveHookDiscovery
+} from "./chunk-WBXU27BF.js";
 import {
   readHookStdin
 } from "./chunk-LSUB6QMP.js";
+import "./chunk-XLKGPGZT.js";
 import {
-  monitorHeartbeatPath,
-  nudgeSentinelPath
-} from "./chunk-DURRQDYI.js";
+  controlTokenAuthHeaders
+} from "./chunk-GKXHKR3B.js";
 import {
-  readSessionDiscoveryByKey
-} from "./chunk-DO42NPNR.js";
+  formatChannelEvents
+} from "./chunk-PHXO5P25.js";
 import {
-  controlTokenAuthHeaders
-} from "./chunk-GI2CKKBL.js";
-import "./chunk-BLEGIR35.js";
+  monitorHeartbeatPath,
+  nudgeSentinelPath
+} from "./chunk-TNZITJAB.js";
+import "./chunk-67F67AQ6.js";
+import "./chunk-U5HHHRXA.js";
 import {
   buildMonitorNudge
-} from "./chunk-Q7T3WAST.js";
-import {
-  deriveDiscoveryKey,
-  findClaudeAncestorPid
-} from "./chunk-VHKPWUX7.js";
+} from "./chunk-QEJUNP3X.js";
+import "./chunk-XJEBJIQE.js";
+import "./chunk-KNEJTD6G.js";
 
 // src/hooks/stop-hook.ts
 import fs from "fs";
@@ -72,10 +71,8 @@ function defaultRecordNudge(logPath) {
   }
 }
 async function runStopHook() {
-  const { stopHookActive } = await readHookStdin();
-  const ccPid = await findClaudeAncestorPid();
-  const key = deriveDiscoveryKey(process.env["CLAUDE_PROJECT_DIR"], ccPid);
-  const discovery = readSessionDiscoveryByKey(key);
+  const { stopHookActive, sessionId: stdinSessionId } = await readHookStdin();
+  const { discovery } = await resolveHookDiscovery(stdinSessionId);
   const out = await decideStopHook({
     stopHookActive,
     discovery: discovery ? { port: discovery.port, eventLogPath: discovery.eventLogPath } : null,