kojee-mcp 0.5.10 → 0.5.12

package/dist/lib.d.ts

@@ -1,6 +1,5 @@
 import { KeyLike, JWK } from 'jose';
-import { L as LoadedKeyPair, K as KeystoreData, G as GatewayClient } from './gateway-client-93P1E0CZ.js';
-export { P as ProxyConfig, T as ToolCallResult } from './gateway-client-93P1E0CZ.js';
+import { L as LoadedKeyPair, K as KeystoreData, G as GatewayClient, M as McpToolDefinition, T as ToolCallResult, P as ProxyConfig } from './gateway-client-C6yx1mfM.js';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 
 /**
@@ -271,6 +270,19 @@ interface EventStreamOptions {
      * webhook delivery, zero behavior change.
      */
     webhookSink?: WebhookSink;
+    /**
+     * Pluggable per-runtime WAKE DELIVERY (#32 Phase 1). When wired, consumeSse
+     * routes each normalized, wake-filtered TandemEvent through `delivery.deliver`
+     * INSTEAD OF the inline queue→event-log→channel→webhook fan-out below. The
+     * delivery owns the exact same per-sink isolation + ordering; this is purely
+     * WHERE the fan-out lives, not WHAT it does. When UNSET (the kojee-mcp/lib
+     * consumers — the OpenClaw plugin — and the event-stream unit/integration
+     * tests that pass `queue`/`eventLog`/`webhookSink` directly), the historical
+     * inline fan-out runs unchanged. The two paths are behaviorally identical.
+     */
+    delivery?: {
+        deliver(event: TandemEvent): Promise<void>;
+    };
     /**
      * Resubscribe-on-start hook (P0 audit item #2). Called once after each
      * successful (re)connect with the live `Response`. Implementations touch
@@ -426,4 +438,170 @@ interface ResubscribeOptions {
  */
 declare function resubscribeMemberships(opts: ResubscribeOptions): Promise<number>;
 
-export { AuthModule, type EventLog, type EventStreamOptions, GatewayClient, type HarnessAdapter, type PairedConfig, type Runtime, type StreamHandle, type StreamState, type TandemEvent, type WebhookSink, createDPoPProof, defaultPairedKeystorePath, deriveKeystorePath, generateES256KeyPair, loadKeystore, loadPairedConfig, normalizeBackendEvent, pairedConfigPath, resubscribeMemberships, sanitizeDisplayname, saveKeystore, startEventStream };
+/**
+ * Flat tool registry — fetches all Kojee tools with full schemas on startup
+ * and registers them directly with the MCP server. No discovery indirection,
+ * no meta-tools, no call_tool wrapper.
+ *
+ * The agent sees each Kojee tool directly (e.g. gmail_send_email, github_list_repos)
+ * and calls it like any native MCP tool. Prompt caching handles the token cost
+ * of ~15K tokens after the first turn.
+ */
+declare class ToolRegistry {
+    private readonly gateway;
+    /** Flat map: tool name → full tool definition */
+    private tools;
+    constructor(gateway: GatewayClient);
+    /**
+     * Fetch all tools with full schemas from the gateway in a single RPC call.
+     */
+    discoverTools(): Promise<void>;
+    /**
+     * Return all registered tools for the MCP ListTools response.
+     */
+    getAllTools(): McpToolDefinition[];
+    /**
+     * Call a tool through the gateway.
+     */
+    callTool(name: string, args: Record<string, unknown>): Promise<ToolCallResult>;
+    /** Total number of registered tools. */
+    get toolCount(): number;
+}
+
+/**
+ * Side-channel hooks observed by the tool-call path (0.5.4 wake continuity).
+ */
+interface ToolCallHooks {
+    /**
+     * Fired after a SUCCESSFUL tandem_join performed through this proxy by its
+     * agent, with the joined tandem id (null if it couldn't be read from args).
+     * The proxy wires this to the debounced stream-reconnect scheduler so the
+     * event-stream's membership snapshot picks up the just-acquired seat without
+     * a daemon restart, AND (#28) records the room in this instance's local
+     * room-memory for session-faithful re-seat. A throwing hook never breaks the
+     * tool reply.
+     */
+    onTandemJoin?: (tandemId: string | null) => void;
+    /**
+     * Fired after a SUCCESSFUL tandem_leave through this proxy, with the left
+     * tandem id (#28). The proxy drops the room from this instance's local
+     * room-memory so a restart doesn't rejoin a room the agent deliberately
+     * left. A throwing hook never breaks the tool reply.
+     */
+    onTandemLeave?: (tandemId: string | null) => void;
+}
+
+/**
+ * The pluggable per-runtime WAKE-DELIVERY interface (#32 Phase 1).
+ *
+ * Historically the dispatch of a normalized TandemEvent to its wake sinks lived
+ * in two places: the THREE-WAY branch in `startProxy` (src/index.ts) that wired
+ * the event-log / webhook / hook-server / discovery surfaces per runtime, and
+ * the inline fan-out in `consumeSse` (src/tandem/event-stream.ts) that, per
+ * event, appended to the event log (Monitor wake), emitted a channel
+ * notification (claude-code only), and enqueued the webhook POST.
+ *
+ * Phase 1 extracts that into one interface so each runtime owns its own wake
+ * delivery as a composable unit, selected from a registry instead of an
+ * if/else-if/else ladder. The extraction is BEHAVIOR-PRESERVING: each runtime's
+ * `start`/`deliver`/`stop` replicate exactly what its branch did before.
+ *
+ *   - start(ctx)     — build + start this runtime's sinks/surfaces and the SSE
+ *                      stream. Returns the wired MCP `server` (so the proxy can
+ *                      drive the stdio transport) plus a stop handle.
+ *   - deliver(event) — the per-event fan-out, formerly inlined in consumeSse
+ *                      (event-stream.ts:594-642). MUST preserve per-sink
+ *                      isolation + ordering: event-log append (primary Monitor
+ *                      wake) FIRST, channel notification SECOND (claude-code
+ *                      only), webhook enqueue LAST + fire-and-forget. Each sink
+ *                      is wrapped in its own try/catch so one failing sink can
+ *                      never starve another.
+ *   - stop()         — idempotent teardown (webhook sink stop, discovery
+ *                      cleanup, event-log cleanup, hook-server stop).
+ *   - health()       — optional liveness snapshot for GET /status + doctor.
+ */
+
+/**
+ * Everything a {@link WakeDelivery.start} needs from the proxy to build its
+ * sinks/surfaces and wire the SSE stream. Assembled once in `startProxy` after
+ * auth + ensure-join, before the stream connects.
+ */
+interface WakeDeliveryContext {
+    /**
+     * This instance's stable key (#28): the CC session_id when readable, else
+     * KOJEE_INSTANCE / a working-dir hash. Used to derive the per-runtime
+     * event-log filename and other per-session artifacts.
+     */
+    instanceKey: string;
+    /** The detected runtime label (drives capability + which delivery is built). */
+    runtime: Runtime;
+    /** The selected harness adapter (channel capability + formatTandemEvent). */
+    adapter: HarnessAdapter;
+    /** Directory the event log lives in (defaults to os.tmpdir()). */
+    eventLogDir?: string;
+    /** Resolved proxy config (broker url + token + auth mode). */
+    config: ProxyConfig;
+    /** The discovered tool registry (used to build the MCP server). */
+    registry: ToolRegistry;
+    /** The authenticated gateway JSON-RPC client. */
+    gateway: GatewayClient;
+    /** The Claude Code ancestor pid, or null if none was found. */
+    ccPid: number | null;
+    /** Boot-probed membership count for the handshake instructions (-1 = unknown). */
+    tandemMembershipCount: number;
+    /** tandem_id lister for the resubscribe-on-connect touch. */
+    listTandemIds: () => Promise<string[] | null>;
+    /** join/leave side-channel hooks (stream reconnect + room-memory record). */
+    toolCallHooks: ToolCallHooks;
+    /** Called once the stream handle is armed, to flush a boot-race reconnect. */
+    onStreamReady?: (handle: StreamLike) => void;
+    /** Best-effort line sink for boot/observability logs (status sibling backed). */
+    log: (line: string) => void;
+}
+/** The subset of the SSE stream handle the proxy + scheduler depend on. */
+interface StreamLike {
+    (): void;
+    reconnect: () => void;
+    getState: () => unknown;
+}
+/** Optional liveness snapshot surfaced via GET /status + doctor. */
+interface DeliveryHealth {
+    /** Whether the SSE stream is currently connected (null = no stream). */
+    connected: boolean | null;
+    /** Implementation-specific extra state (stream state, hook-server, etc.). */
+    detail?: Record<string, unknown>;
+}
+/** The result of {@link WakeDelivery.start}: the wired server + teardown. */
+interface StartedDelivery {
+    /** The MCP server to drive over stdio. */
+    server: Server;
+    /** Synchronous teardown steps to register with the shutdown coordinator. */
+    teardown: Array<() => void | Promise<void>>;
+    /** Last-ditch synchronous cleanup for process 'exit' (cannot await). */
+    exitCleanup?: () => void;
+}
+/**
+ * A per-runtime wake-delivery unit. Built from the registry, started once, and
+ * driven per-event by consumeSse via {@link WakeDelivery.deliver}.
+ */
+interface WakeDelivery {
+    /** Stable identifier (the runtime label + variant, e.g. "claude-code"). */
+    readonly name: string;
+    /**
+     * Build + start this delivery's sinks/surfaces and the SSE stream. The stream
+     * is wired so consumeSse calls back into {@link WakeDelivery.deliver}.
+     */
+    start(ctx: WakeDeliveryContext): Promise<StartedDelivery>;
+    /**
+     * Per-event fan-out (the seam formerly inlined in consumeSse). Called for
+     * every normalized, wake-filtered TandemEvent. MUST preserve per-sink
+     * isolation + ordering and never throw.
+     */
+    deliver(event: TandemEvent): Promise<void>;
+    /** Idempotent teardown. */
+    stop(): Promise<void>;
+    /** Optional liveness snapshot. */
+    health?(): DeliveryHealth;
+}
+
+export { AuthModule, type DeliveryHealth, type EventLog, type EventStreamOptions, GatewayClient, type HarnessAdapter, type PairedConfig, ProxyConfig, type Runtime, type StartedDelivery, type StreamHandle, type StreamLike, type StreamState, type TandemEvent, ToolCallResult, type WakeDelivery, type WakeDeliveryContext, type WebhookSink, createDPoPProof, defaultPairedKeystorePath, deriveKeystorePath, generateES256KeyPair, loadKeystore, loadPairedConfig, normalizeBackendEvent, pairedConfigPath, resubscribeMemberships, sanitizeDisplayname, saveKeystore, startEventStream };

package/dist/lib.js

@@ -1,21 +1,21 @@
 import {
   resubscribeMemberships
 } from "./chunk-OT2GILXC.js";
+import {
+  normalizeBackendEvent,
+  sanitizeDisplayname,
+  startEventStream
+} from "./chunk-5XP2UOFK.js";
 import {
   loadPairedConfig,
   pairedConfigPath
 } from "./chunk-YH27B6SW.js";
-import {
-  AuthModule
-} from "./chunk-JXMVZEQ7.js";
 import {
   GatewayClient
 } from "./chunk-HSR3GXCL.js";
 import {
-  normalizeBackendEvent,
-  sanitizeDisplayname,
-  startEventStream
-} from "./chunk-MKDMAAMN.js";
+  AuthModule
+} from "./chunk-JXMVZEQ7.js";
 import {
   createDPoPProof
 } from "./chunk-2MIISF2W.js";

package/dist/{parent-watchdog-RZLHYP7T.js → parent-watchdog-TLU355FB.js}

@@ -1,6 +1,6 @@
 import {
   findClaudeAncestorPid
-} from "./chunk-BJMASMKX.js";
+} from "./chunk-VHKPWUX7.js";
 
 // src/runtime/parent-watchdog.ts
 function defaultIsPidAlive(pid) {

package/dist/registry-A3VT6VJD.js

@@ -0,0 +1,348 @@
+import "./chunk-35XBRG3V.js";
+import "./chunk-PHXO5P25.js";
+import "./chunk-LSUB6QMP.js";
+import {
+  claudeCodeAdapter
+} from "./chunk-XXFVWP6H.js";
+import "./chunk-WLMPCX7T.js";
+import "./chunk-X672ZN7V.js";
+import "./chunk-LDZXU3DW.js";
+
+// src/delivery/lib/fanout.ts
+async function deliverEvent(event, sinks) {
+  sinks.queue?.push(event);
+  if (sinks.eventLog) {
+    try {
+      await sinks.eventLog.append(event);
+      sinks.queue?.markMonitorDelivered(event.id);
+    } catch (err) {
+      console.error("[event-stream] event-log append failed:", err);
+    }
+  }
+  if (sinks.formatChannelNotification && sinks.server) {
+    try {
+      const channel = sinks.formatChannelNotification(event);
+      await sinks.server.notification({
+        method: "notifications/claude/channel",
+        params: channel
+      });
+      sinks.queue?.markChannelDelivered(event.id);
+    } catch (err) {
+      console.error("[event-stream] channel notification failed:", err);
+    }
+  }
+  try {
+    sinks.webhookSink?.enqueue(event);
+  } catch (err) {
+    console.error("[event-stream] webhook enqueue failed:", err);
+  }
+}
+
+// src/delivery/lib/channel.ts
+function formatChannelNotification(event) {
+  return claudeCodeAdapter.formatTandemEvent(event);
+}
+
+// src/delivery/claude-code.ts
+function createClaudeCodeDelivery() {
+  let eventLog = null;
+  let webhookSink = null;
+  let queue = null;
+  let server = null;
+  let hookServer = null;
+  let cleanupDiscoveryFile = null;
+  let streamHandle = null;
+  return {
+    name: "claude-code",
+    async start(ctx) {
+      const { EventQueue } = await import("./event-queue-5YVJFR3E.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-VZD7NKYX.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-FOT7MJZH.js");
+      const { createMcpServer } = await import("./server-77QRWKJM.js");
+      const { deriveDiscoveryKey } = await import("./ancestry-ONFBQEP5.js");
+      sweepStaleDiscovery();
+      sweepStaleEventLogs();
+      const projectDir = process.env["CLAUDE_PROJECT_DIR"];
+      const discoveryKey = deriveDiscoveryKey(projectDir, ctx.ccPid);
+      eventLog = startEventLog({
+        key: ctx.instanceKey,
+        ...ctx.eventLogDir ? { dir: ctx.eventLogDir } : {}
+      });
+      const log = eventLog;
+      const webhookResolution = resolveWebhookConfig();
+      if (webhookResolution.error) {
+        console.error(`[kojee-mcp] webhook sink ERROR: ${webhookResolution.error}`);
+        void log.appendStatus(`status=webhook error="${webhookResolution.error}"`).catch(() => {
+        });
+      }
+      if (webhookResolution.warning) {
+        console.error(`[kojee-mcp] webhook sink WARNING: ${webhookResolution.warning}`);
+        void log.appendStatus(`status=webhook warning="${webhookResolution.warning}"`).catch(() => {
+        });
+      }
+      webhookSink = webhookResolution.enabled && webhookResolution.config ? createWebhookSink(webhookResolution.config, {
+        log: (line) => {
+          void log.appendStatus(`status=webhook ${line}`).catch(() => {
+          });
+        }
+      }) : null;
+      if (webhookSink) {
+        console.error(`[kojee-mcp] webhook sink ENABLED (${webhookSink.configSummary()})`);
+        void log.appendStatus(`status=webhook enabled ${webhookSink.configSummary()}`).catch(() => {
+        });
+      }
+      server = createMcpServer(
+        ctx.registry,
+        ctx.adapter,
+        ctx.tandemMembershipCount,
+        eventLog.path,
+        ctx.toolCallHooks
+      );
+      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; GET /poll and /status left UNGATED (degrade open):",
+          err.message
+        );
+      }
+      queue = new EventQueue();
+      const localQueue = queue;
+      let liveStream = null;
+      hookServer = await startHookServer({
+        port: 0,
+        queue: localQueue,
+        adapter: ctx.adapter,
+        ...controlToken !== null ? { controlToken, send: { gateway: ctx.gateway, authToken: controlToken } } : {},
+        getStreamState: () => liveStream ? liveStream.getState() : {
+          connected: false,
+          connectedSince: null,
+          lastEventAt: null,
+          lastHeartbeatAt: null,
+          cursors: {},
+          reconnectCount: 0,
+          staleAfterMs: null
+        }
+      });
+      writeDiscoveryByKey(discoveryKey, {
+        schema: 2,
+        discoveryKey,
+        ccPid: ctx.ccPid,
+        projectDir: projectDir ?? null,
+        proxyPid: process.pid,
+        pid: process.pid,
+        port: hookServer.port,
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        brokerUrl: ctx.config.url,
+        eventLogPath: eventLog.path,
+        ...controlToken !== null ? { controlTokenPath: controlTokenPath() } : {},
+        authMode: ctx.config.authMode ?? "paired"
+      });
+      cleanupDiscoveryFile = () => cleanupDiscoveryByKey(discoveryKey);
+      const localCleanupDiscovery = cleanupDiscoveryFile;
+      const localHookServer = hookServer;
+      const exitCleanup = () => {
+        localCleanupDiscovery();
+        eventLog?.cleanup();
+      };
+      const teardown = [
+        () => {
+          void webhookSink?.stop();
+        },
+        () => localCleanupDiscovery(),
+        () => eventLog?.cleanup(),
+        () => localHookServer.stop()
+      ];
+      streamHandle = await startEventStream({
+        brokerUrl: ctx.config.url,
+        token: ctx.config.token,
+        gateway: ctx.gateway,
+        adapter: ctx.adapter,
+        server,
+        // eventLog is passed so the stream's status/heartbeat lines land in the
+        // status sibling (emitStatus / heartbeat use opts.eventLog.appendStatus).
+        // The PER-EVENT fan-out (queue/eventLog/channel/webhook) is owned by
+        // `delivery.deliver` below, so queue/webhookSink are NOT re-wired here —
+        // the queue still feeds the hook-server /poll directly (startHookServer).
+        eventLog,
+        delivery: this,
+        onConnected: /* @__PURE__ */ (() => {
+          const debounceState = { lastRunAt: 0 };
+          return async () => {
+            await resubscribeMemberships({
+              gateway: ctx.gateway,
+              eventLog,
+              listTandems: async () => await ctx.listTandemIds() ?? [],
+              debounceState
+            });
+          };
+        })()
+      });
+      liveStream = streamHandle;
+      ctx.onStreamReady?.(streamHandle);
+      return { server, teardown, exitCleanup };
+    },
+    async deliver(event) {
+      await deliverEvent(event, {
+        ...queue ? { queue } : {},
+        ...eventLog ? { eventLog } : {},
+        ...server ? { server } : {},
+        // Channel notification is gated by providing the formatter (claude-code
+        // supportsChannels=true). formatChannelNotification throws by contract
+        // for other runtimes, but this delivery is only ever built for
+        // claude-code, so it is always the channel-capable path.
+        formatChannelNotification,
+        ...webhookSink ? { webhookSink } : {}
+      });
+    },
+    async stop() {
+      await webhookSink?.stop();
+      cleanupDiscoveryFile?.();
+      eventLog?.cleanup();
+      await hookServer?.stop();
+    },
+    health() {
+      const state = streamHandle?.getState();
+      return {
+        connected: state ? state.connected ?? null : null,
+        ...state ? { detail: { stream: state } } : {}
+      };
+    }
+  };
+}
+
+// src/delivery/hermes.ts
+function createWebhookDelivery(name) {
+  let eventLog = null;
+  let webhookSink = null;
+  let streamHandle = null;
+  return {
+    name,
+    async start(ctx) {
+      const { startEventLog, sweepStaleEventLogs } = await import("./event-log-VZD7NKYX.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-FOT7MJZH.js");
+      const { createMcpServer } = await import("./server-77QRWKJM.js");
+      sweepStaleEventLogs();
+      eventLog = startEventLog({
+        key: ctx.instanceKey,
+        ...ctx.eventLogDir ? { dir: ctx.eventLogDir } : {}
+      });
+      const log = eventLog;
+      const webhookResolution = resolveWebhookConfig();
+      if (webhookResolution.error) {
+        console.error(`[kojee-mcp] webhook sink ERROR: ${webhookResolution.error}`);
+        void log.appendStatus(`status=webhook error="${webhookResolution.error}"`).catch(() => {
+        });
+      }
+      if (webhookResolution.warning) {
+        console.error(`[kojee-mcp] webhook sink WARNING: ${webhookResolution.warning}`);
+        void log.appendStatus(`status=webhook warning="${webhookResolution.warning}"`).catch(() => {
+        });
+      }
+      webhookSink = webhookResolution.enabled && webhookResolution.config ? createWebhookSink(webhookResolution.config, {
+        log: (line) => {
+          void log.appendStatus(`status=webhook ${line}`).catch(() => {
+          });
+        }
+      }) : null;
+      if (webhookSink) {
+        console.error(`[kojee-mcp] webhook sink ENABLED (${webhookSink.configSummary()})`);
+        void log.appendStatus(`status=webhook enabled ${webhookSink.configSummary()}`).catch(() => {
+        });
+      }
+      const server = createMcpServer(
+        ctx.registry,
+        ctx.adapter,
+        ctx.tandemMembershipCount,
+        void 0,
+        ctx.toolCallHooks
+      );
+      const exitCleanup = () => eventLog?.cleanup();
+      const teardown = [
+        () => {
+          void webhookSink?.stop();
+        },
+        () => 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 };
+    },
+    async deliver(event) {
+      await deliverEvent(event, {
+        ...eventLog ? { eventLog } : {},
+        ...webhookSink ? { webhookSink } : {}
+      });
+    },
+    async stop() {
+      await webhookSink?.stop();
+      eventLog?.cleanup();
+    },
+    health() {
+      const state = streamHandle?.getState();
+      return {
+        connected: state ? state.connected ?? null : null,
+        ...state ? { detail: { stream: state } } : {}
+      };
+    }
+  };
+}
+
+// src/delivery/codex.ts
+function createCodexDelivery() {
+  return createWebhookDelivery("codex");
+}
+
+// src/delivery/registry.ts
+function needsWebhookEventStream(env = process.env) {
+  return (env["KOJEE_WEBHOOK_URL"] ?? "").trim().length > 0;
+}
+function selectDelivery(runtime, opts) {
+  if (opts.supportsChannels) {
+    return createClaudeCodeDelivery();
+  }
+  if (!needsWebhookEventStream(opts.env)) {
+    return null;
+  }
+  if (runtime === "codex") {
+    return createCodexDelivery();
+  }
+  return createWebhookDelivery(runtime);
+}
+export {
+  needsWebhookEventStream,
+  selectDelivery
+};

package/dist/server-77QRWKJM.js

@@ -0,0 +1,14 @@
+import {
+  buildChannelInstructions,
+  createMcpServer,
+  executeToolCall,
+  startMcpServer
+} from "./chunk-WLMPCX7T.js";
+import "./chunk-X672ZN7V.js";
+import "./chunk-LDZXU3DW.js";
+export {
+  buildChannelInstructions,
+  createMcpServer,
+  executeToolCall,
+  startMcpServer
+};

package/dist/{stop-hook-OTCJGL6V.js → stop-hook-CUVDKXP7.js}

@@ -1,27 +1,28 @@
+import "./chunk-XLKGPGZT.js";
+import {
+  controlTokenAuthHeaders
+} from "./chunk-GI2CKKBL.js";
 import {
   formatChannelEvents
-} from "./chunk-YKS6YZKM.js";
+} from "./chunk-PHXO5P25.js";
 import {
   readHookStdin
 } from "./chunk-LSUB6QMP.js";
 import {
   monitorHeartbeatPath,
   nudgeSentinelPath
-} from "./chunk-DS26OORG.js";
+} from "./chunk-CO73VGWM.js";
 import {
   readSessionDiscoveryByKey
 } from "./chunk-DO42NPNR.js";
-import {
-  controlTokenAuthHeaders
-} from "./chunk-GI2CKKBL.js";
+import "./chunk-BLEGIR35.js";
 import {
   buildMonitorNudge
 } from "./chunk-X672ZN7V.js";
 import {
   deriveDiscoveryKey,
   findClaudeAncestorPid
-} from "./chunk-BJMASMKX.js";
-import "./chunk-BLEGIR35.js";
+} from "./chunk-VHKPWUX7.js";
 
 // src/hooks/stop-hook.ts
 import fs from "fs";

package/dist/{tail-stream-JNR4WFW3.js → tail-stream-VZ462ZON.js}

@@ -1,12 +1,13 @@
+import "./chunk-XLKGPGZT.js";
 import {
   STATUS_LINE_PREFIX,
   monitorHeartbeatPath,
   statusLogPath
-} from "./chunk-DS26OORG.js";
+} from "./chunk-CO73VGWM.js";
 import "./chunk-DO42NPNR.js";
 import {
   createAdaptiveWatchdog
-} from "./chunk-MKDMAAMN.js";
+} from "./chunk-5XP2UOFK.js";
 import "./chunk-2MIISF2W.js";
 import "./chunk-BLEGIR35.js";
 

package/dist/{user-prompt-submit-hook-QXMC7EZU.js → user-prompt-submit-hook-PMBUPKUV.js}

@@ -1,20 +1,20 @@
+import {
+  controlTokenAuthHeaders
+} from "./chunk-GI2CKKBL.js";
 import {
   formatChannelEvents
-} from "./chunk-YKS6YZKM.js";
+} from "./chunk-PHXO5P25.js";
 import {
   readHookStdin
 } from "./chunk-LSUB6QMP.js";
 import {
   readSessionDiscoveryByKey
 } from "./chunk-DO42NPNR.js";
-import {
-  controlTokenAuthHeaders
-} from "./chunk-GI2CKKBL.js";
+import "./chunk-BLEGIR35.js";
 import {
   deriveDiscoveryKey,
   findClaudeAncestorPid
-} from "./chunk-BJMASMKX.js";
-import "./chunk-BLEGIR35.js";
+} from "./chunk-VHKPWUX7.js";
 
 // src/hooks/user-prompt-submit-hook.ts
 async function runUserPromptSubmitHook() {

package/dist/{webhook-sink-NWGCUDGY.js → webhook-sink-N6AUTFL3.js}

@@ -3,7 +3,7 @@ import {
   WEBHOOK_DEFAULT_SIGNATURE_PREFIX
 } from "./chunk-V5VZPYMZ.js";
 
-// src/tandem/webhook-sink.ts
+// src/delivery/lib/webhook-sink.ts
 import crypto from "crypto";
 import { ulid } from "ulidx";
 var DEFAULT_MAX_QUEUE = 1e3;