@interactive-inc/claude-funnel 0.60.0 → 0.63.0

package/dist/{channels-2g_BU1N0.d.ts → channels-B8RQPrVq.d.ts}

@@ -1,7 +1,7 @@
-import { n as ChannelDeliveryMode, t as ChannelConfig } from "./settings-schema-D1xcOqRu.js";
-import { n as FunnelIdGenerator, t as FunnelSettingsReader } from "./settings-reader-BIFB_j2f.js";
-import { A as FunnelConnectorAdapter, B as FunnelLogger, D as FunnelConnectorListener, I as FunnelProcessRunner, M as BaseConnectorConfig, k as CallInput, n as ConnectorBuildContext, o as ConnectorOperationContext, p as ConnectorDiagnosticLog, r as ConnectorDescriptor, s as ConnectorUpdateContext } from "./connector-descriptor-6SXJoszo.js";
-import { n as FunnelFileSystem } from "./file-system-o51IsM0W.js";
+import { n as ChannelDeliveryMode, t as ChannelConfig } from "./settings-schema-BL_c2Udm.js";
+import { n as FunnelIdGenerator, t as FunnelSettingsReader } from "./settings-reader-BNxjsxCB.js";
+import { B as FunnelProcessRunner, I as BaseConnectorConfig, N as CallInput, P as FunnelConnectorAdapter, W as FunnelLogger, _ as ConnectorDiagnosticLog, c as FunnelClock, j as FunnelConnectorListener, l as FunnelHttpClient, n as ConnectorBuildContext, o as ConnectorOperationContext, r as ConnectorDescriptor, s as ConnectorUpdateContext } from "./connector-descriptor-ClEEbuW3.js";
+import { n as FunnelFileSystem } from "./file-system-VhwwXZbm.js";
 
 //#region lib/engine/connectors/connector-registry.d.ts
 type Deps$1 = {
@@ -11,9 +11,18 @@ type Deps$1 = {
   descriptors: ConnectorDescriptor[];
   fs?: FunnelFileSystem;
   process?: FunnelProcessRunner;
+  http?: FunnelHttpClient;
+  clock?: FunnelClock;
   logger?: FunnelLogger;
   diagnosticLog?: ConnectorDiagnosticLog;
   dir?: string;
+  /**
+   * Shared shutdown signal forwarded to every listener built by this
+   * registry. Hosts wire one signal here (e.g. from a per-Funnel
+   * AbortController in a SIGTERM handler) and every listener tears down
+   * together when it aborts.
+   */
+  signal?: AbortSignal;
 };
 /**
  * Dispatches connector work to injected descriptors by `type`. Replaces the old
@@ -28,8 +37,11 @@ declare class FunnelConnectorRegistry {
   private readonly descriptors;
   private readonly fs;
   private readonly process;
+  private readonly http;
+  private readonly clock;
   private readonly logger;
   private readonly diagnosticLog;
+  private readonly signal;
   private readonly dir;
   constructor(deps: Deps$1);
   has(type: string): boolean;
@@ -59,17 +71,6 @@ type ProfileChannelChecker = {
   hasChannelRef(channelId: string): boolean;
 };
 //#endregion
-//#region lib/engine/time/clock.d.ts
-/**
- * Time boundary. Default NodeFunnelClock returns `new Date()`; MemoryFunnelClock
- * is settable and `advance(ms)`-able for deterministic schedule / timeout tests.
- */
-declare abstract class FunnelClock {
-  abstract now(): Date;
-  millis(): number;
-  iso(): string;
-}
-//#endregion
 //#region lib/engine/channels/channels.d.ts
 type Deps = {
   store: FunnelSettingsReader;
@@ -171,4 +172,4 @@ declare class FunnelChannels {
   private assertNoTokenCollision;
 }
 //#endregion
-export { FunnelConnectorRegistry as a, FunnelClock as i, ChannelConnectorView as n, FunnelChannels as r, AddConnectorInput as t };
+export { FunnelConnectorRegistry as i, ChannelConnectorView as n, FunnelChannels as r, AddConnectorInput as t };

package/dist/claude.d.ts

@@ -1,9 +1,7 @@
-import { a as ProcessGuard, c as ChannelResolver, i as SessionStore, n as FunnelClaude, o as McpInstaller, r as LaunchOptions, s as GatewayController, t as FileProcessGuard } from "./file-process-guard-DOlCr4GF.js";
-import { r as ConnectorDescriptor } from "./connector-descriptor-6SXJoszo.js";
-import { n as FunnelFileSystem } from "./file-system-o51IsM0W.js";
-import { t as FunnelProfiles } from "./profiles-Cy5wXQ0L.js";
-import { a as FunnelLocalConfig, c as LOCAL_CONFIG_FILENAME, d as channelSpecSchema, f as connectorSpecSchema, i as FunnelTokenPrompter, l as LocalConfig, m as profileSpecSchema, n as FunnelLocalConfigSync, o as ChannelSpec, p as localConfigSchema, r as LocalConfigSyncResult, s as ConnectorSpec, t as ConnectorSyncOutcome, u as ProfileSpec } from "./local-config-sync-Dh1Croqe.js";
-import { i as funnelJsonSchema, n as NodeFunnelTokenPrompter, r as FunnelLocalConfigWriter, t as MemoryFunnelTokenPrompter } from "./memory-token-prompter-B4sjyaAq.js";
+import { a as ProcessGuard, c as ChannelResolver, i as SessionStore, n as FunnelClaude, o as McpInstaller, r as LaunchOptions, s as GatewayController, t as FunnelFileProcessGuard } from "./file-process-guard-DGHxALfI.js";
+import { r as ConnectorDescriptor } from "./connector-descriptor-ClEEbuW3.js";
+import { n as FunnelFileSystem } from "./file-system-VhwwXZbm.js";
+import { t as FunnelProfiles } from "./profiles-cVZQkM69.js";
 
 //#region lib/engine/mcp/mcp.d.ts
 declare const FUNNEL_MCP_COMMAND = "bun";
@@ -58,4 +56,4 @@ type ChannelServerOptions = {
  */
 declare const startChannelServer: (options?: ChannelServerOptions) => Promise<void>;
 //#endregion
-export { ChannelResolver, ChannelServerOptions, ChannelSpec, ConnectorSpec, ConnectorSyncOutcome, FUNNEL_MCP_ARGS, FUNNEL_MCP_COMMAND, FUNNEL_MCP_NAME, FileProcessGuard, FunnelClaude, FunnelLocalConfig, FunnelLocalConfigSync, FunnelLocalConfigWriter, FunnelMcp, FunnelProfiles, FunnelTokenPrompter, GatewayController, LOCAL_CONFIG_FILENAME, LaunchOptions, LocalConfig, LocalConfigSyncResult, McpInstaller, MemoryFunnelTokenPrompter, NodeFunnelTokenPrompter, ProcessGuard, ProfileSpec, SessionStore, channelSpecSchema, connectorSpecSchema, funnelJsonSchema, localConfigSchema, profileSpecSchema, startChannelServer };
+export { ChannelResolver, ChannelServerOptions, FUNNEL_MCP_ARGS, FUNNEL_MCP_COMMAND, FUNNEL_MCP_NAME, FunnelClaude, FunnelFileProcessGuard, FunnelMcp, FunnelProfiles, GatewayController, LaunchOptions, McpInstaller, ProcessGuard, SessionStore, startChannelServer };

package/dist/claude.js

@@ -1,15 +1,13 @@
-import { t as gatewayLoopbackUrl } from "./gateway-base-url-Dy4Ykuoh.js";
-import { d as settingsSchema, o as resolveFunnelPort } from "./settings-store-CUKSeTXC.js";
-import { a as FunnelMcp, i as FUNNEL_MCP_NAME, n as FUNNEL_MCP_ARGS, o as FileProcessGuard, r as FUNNEL_MCP_COMMAND, s as FunnelClaude, t as renderYaml } from "./yaml-render-qW34NlYz.js";
-import { t as FunnelDocs } from "./funnel-docs-BxXZ9Ksx.js";
-import { a as FunnelLocalConfig, c as connectorSpecSchema, i as FunnelTokenPrompter, l as localConfigSchema, n as NodeFunnelTokenPrompter, o as LOCAL_CONFIG_FILENAME, r as FunnelLocalConfigSync, s as channelSpecSchema, t as funnelJsonSchema, u as profileSpecSchema } from "./local-config-json-schema-JyLqOQNX.js";
-import { t as FunnelProfiles } from "./profiles-DSzTeKQw.js";
-import { t as errorMessageOf } from "./error-message-of-Byi4y0Uf.js";
-import { t as discordConnector } from "./discord-connector-BL36yvbL.js";
-import { t as ghConnector } from "./gh-connector-DpiixfQZ.js";
-import { t as scheduleConnector } from "./schedule-connector-L4uzg5M8.js";
-import { t as slackConnector } from "./slack-connector-DQIFPdBF.js";
-import { n as FunnelLocalConfigWriter, t as MemoryFunnelTokenPrompter } from "./memory-token-prompter-CZde7e6y.js";
+import { n as gatewayLoopbackUrl, t as loopbackFetch } from "./loopback-fetch-CVNuN3YZ.js";
+import { d as settingsSchema, o as resolveFunnelPort } from "./settings-store-C2QdOH-t.js";
+import { a as FunnelMcp, i as FUNNEL_MCP_NAME, n as FUNNEL_MCP_ARGS, o as FunnelFileProcessGuard, r as FUNNEL_MCP_COMMAND, s as FunnelClaude, t as renderYaml } from "./yaml-render--J1_3BSA.js";
+import { t as errorMessageOf } from "./error-message-of-ColuYmAk.js";
+import { t as FunnelDocs } from "./funnel-docs-C-ge0MuB.js";
+import { t as FunnelProfiles } from "./profiles-ZHLONml4.js";
+import { t as discordConnector } from "./discord-connector-DIFkYBbi.js";
+import { t as ghConnector } from "./gh-connector-BUGCOEWS.js";
+import { t as scheduleConnector } from "./schedule-connector-9k3gOIgl.js";
+import { t as slackConnector } from "./slack-connector-BU86fIge.js";
 import { join } from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
@@ -63,7 +61,12 @@ const toYamlResult = async (res) => {
 	}
 };
 const getJson = async (url, headers, options = {}) => {
-	const res = await fetch(url, { headers }).catch(() => null);
+	let res = null;
+	try {
+		res = await loopbackFetch(url, { headers });
+	} catch {
+		res = null;
+	}
 	if (!res) {
 		if (options.offlineFallback !== void 0) return yamlResult(options.offlineFallback);
 		return errorResult("gateway unreachable", GATEWAY_OFFLINE_HINT);
@@ -71,14 +74,19 @@ const getJson = async (url, headers, options = {}) => {
 	return toYamlResult(res);
 };
 const postJson = async (url, headers, body, options = {}) => {
-	const res = await fetch(url, {
-		method: "POST",
-		headers: {
-			...headers,
-			"content-type": "application/json"
-		},
-		body: JSON.stringify(body)
-	}).catch(() => null);
+	let res = null;
+	try {
+		res = await loopbackFetch(url, {
+			method: "POST",
+			headers: {
+				...headers,
+				"content-type": "application/json"
+			},
+			body: JSON.stringify(body)
+		}, 3e4);
+	} catch {
+		res = null;
+	}
 	if (!res) {
 		if (options.offlineFallback !== void 0) return yamlResult(options.offlineFallback);
 		return errorResult("gateway unreachable", GATEWAY_OFFLINE_HINT);
@@ -99,7 +107,9 @@ const handleBuiltinTool = async (deps) => {
 	if (deps.token) headers.authorization = `Bearer ${deps.token}`;
 	const args = deps.args;
 	const channelArg = typeof args?.channel === "string" ? args.channel : null;
+	const connectorArg = typeof args?.connector === "string" ? args.connector : null;
 	const limitArg = typeof args?.limit === "number" ? args.limit : void 0;
+	const grepArg = typeof args?.grep === "string" ? args.grep : null;
 	const seqArg = typeof args?.seq === "number" ? args.seq : void 0;
 	const modeArg = args?.mode === "safe" || args?.mode === "aggressive" || args?.mode === "off" ? args.mode : "off";
 	const topicArg = typeof args?.topic === "string" ? args.topic : null;
@@ -121,9 +131,12 @@ const handleBuiltinTool = async (deps) => {
 		},
 		knownChannels: deps.allChannels.map((ch) => ch.name)
 	} });
-	if (deps.name === "fnl_recent_events") return getJson(`${base}/diagnostics/events?${eventListQuery(channelArg, limitArg)}`, headers);
-	if (deps.name === "fnl_dropped_events") return getJson(`${base}/diagnostics/dropped?${eventListQuery(channelArg, limitArg)}`, headers);
-	if (deps.name === "fnl_connection_errors") return getJson(`${base}/diagnostics/errors?${eventListQuery(channelArg, limitArg)}`, headers);
+	if (deps.name === "fnl_recent_events") return getJson(`${base}/diagnostics/events?${eventListQuery(channelArg, connectorArg, limitArg)}`, headers);
+	if (deps.name === "fnl_dropped_events") return getJson(`${base}/diagnostics/dropped?${eventListQuery(channelArg, connectorArg, limitArg)}`, headers);
+	if (deps.name === "fnl_raw_events") return getJson(`${base}/diagnostics/raw?${eventListQuery(channelArg, connectorArg, limitArg)}`, headers);
+	if (deps.name === "fnl_connection_errors") return getJson(`${base}/diagnostics/errors?${eventListQuery(channelArg, connectorArg, limitArg)}`, headers);
+	if (deps.name === "fnl_connection_timeline") return getJson(`${base}/diagnostics/connection?${eventListQuery(channelArg, connectorArg, limitArg)}`, headers);
+	if (deps.name === "fnl_logs") return getJson(`${base}/diagnostics/logs?${logsQuery(grepArg, limitArg)}`, headers);
 	if (deps.name === "fnl_replay_event") {
 		if (!channelArg) return errorResult("channel is required", "Provide the channel name (see fnl_status)");
 		return postJson(`${base}/diagnostics/replay`, headers, {
@@ -145,9 +158,16 @@ const handleBuiltinTool = async (deps) => {
 	}
 	return errorResult(`unknown built-in tool: ${deps.name}`, null);
 };
-const eventListQuery = (channel, limit) => {
+const eventListQuery = (channel, connector, limit) => {
 	const params = new URLSearchParams();
 	if (channel) params.set("channel", channel);
+	if (connector) params.set("connector", connector);
+	if (limit !== void 0) params.set("limit", String(limit));
+	return params.toString();
+};
+const logsQuery = (grep, limit) => {
+	const params = new URLSearchParams();
+	if (grep) params.set("grep", grep);
 	if (limit !== void 0) params.set("limit", String(limit));
 	return params.toString();
 };
@@ -210,7 +230,10 @@ const buildChannelServerInstructions = (allChannels, currentChannelName) => {
 		"  fnl_debug                           per-channel diagnosis (subset of fnl_doctor)",
 		"  fnl_recent_events                   last N processed events with outcome",
 		"  fnl_dropped_events                  events filtered out (skip:*) with reason",
+		"  fnl_raw_events                      raw inbound rows before any processing",
 		"  fnl_connection_errors               listener auth-failed / error events",
+		"  fnl_connection_timeline             full lifecycle (started/connected/disconnected/stopped)",
+		"  fnl_logs                            tail of funnel.log (flume internal + structured app logs)",
 		"  fnl_replay_event                    replay a past event to test a fix",
 		"  fnl_docs                            embedded docs (architecture / debugging / recipes / …)",
 		"",
@@ -252,7 +275,10 @@ const BUILTIN_TOOL_NAMES = [
 	"fnl_debug",
 	"fnl_recent_events",
 	"fnl_dropped_events",
+	"fnl_raw_events",
 	"fnl_connection_errors",
+	"fnl_connection_timeline",
+	"fnl_logs",
 	"fnl_replay_event",
 	"fnl_docs"
 ];
@@ -342,6 +368,10 @@ const buildBuiltinTools = (allChannels) => {
 				type: "object",
 				properties: {
 					channel: channelArgSchema,
+					connector: {
+						type: "string",
+						description: "Connector name to filter (optional)"
+					},
 					limit: {
 						type: "number",
 						description: "Max rows (default 20)"
@@ -356,6 +386,10 @@ const buildBuiltinTools = (allChannels) => {
 				type: "object",
 				properties: {
 					channel: channelArgSchema,
+					connector: {
+						type: "string",
+						description: "Connector name to filter (optional)"
+					},
 					limit: {
 						type: "number",
 						description: "Max rows (default 20)"
@@ -370,6 +404,28 @@ const buildBuiltinTools = (allChannels) => {
 				type: "object",
 				properties: {
 					channel: channelArgSchema,
+					connector: {
+						type: "string",
+						description: "Connector name to filter (optional)"
+					},
+					limit: {
+						type: "number",
+						description: "Max rows (default 20)"
+					}
+				}
+			}
+		},
+		{
+			name: "fnl_connection_timeline",
+			description: "Full connection lifecycle (started / connected / disconnected / stopped + auth-failed / error). Use when fnl_connection_errors only shows the failure but you need to see how the listener got there — was it ever connected, is it flapping, how many reconnects.",
+			inputSchema: {
+				type: "object",
+				properties: {
+					channel: channelArgSchema,
+					connector: {
+						type: "string",
+						description: "Connector name to filter (optional)"
+					},
 					limit: {
 						type: "number",
 						description: "Max rows (default 20)"
@@ -377,6 +433,41 @@ const buildBuiltinTools = (allChannels) => {
 				}
 			}
 		},
+		{
+			name: "fnl_raw_events",
+			description: "Return raw inbound rows the connector recorded BEFORE any processing. Use when fnl_dropped_events and fnl_recent_events both come up empty — this is the table that captures every event the listener ever saw, including ones it dropped pre-processor (envelope shape change, pre-READY, malformed).",
+			inputSchema: {
+				type: "object",
+				properties: {
+					channel: channelArgSchema,
+					connector: {
+						type: "string",
+						description: "Connector name to filter (optional)"
+					},
+					limit: {
+						type: "number",
+						description: "Max rows (default 20)"
+					}
+				}
+			}
+		},
+		{
+			name: "fnl_logs",
+			description: "Return the tail of the gateway daemon log file (funnel.log) where structured FunnelLogger output and forwarded flume logs land. Use when fnl_connection_timeline shows a status change but you need the upstream reason (slack/auth.test failed, github http 401, discord gateway close 4014) — those messages only appear in the log file.",
+			inputSchema: {
+				type: "object",
+				properties: {
+					grep: {
+						type: "string",
+						description: "Case-insensitive substring filter (e.g. 'slack', 'auth')"
+					},
+					limit: {
+						type: "number",
+						description: "Max lines to return (default 200)"
+					}
+				}
+			}
+		},
 		{
 			name: "fnl_replay_event",
 			description: "Re-publish a past event back into a channel so subscribers receive it again. Call after applying a fix to verify Claude handles the previously-failed event correctly. Without `seq`, replays the most recent emitted event for that channel.",
@@ -449,13 +540,17 @@ var FunnelChannelSubscriber = class {
 			}, this.state.reconnectDelay);
 			this.state.reconnectDelay = Math.min(this.state.reconnectDelay * 2, MAX_RECONNECT_DELAY);
 		});
-		ws.addEventListener("error", () => {});
+		ws.addEventListener("error", (event) => {
+			const reason = readErrorEventMessage(event);
+			process.stderr.write(`funnel: ws error: ${reason}\n`);
+		});
 	}
 	async handleMessage(event) {
 		try {
 			const payload = JSON.parse(String(event.data));
 			const eventType = payload.meta?.event_type ?? "unknown";
-			if (typeof payload.offset === "number" && payload.offset > this.state.lastOffset) this.state.lastOffset = payload.offset;
+			const offset = typeof payload.offset === "number" ? payload.offset : null;
+			if (offset !== null && offset > this.state.lastOffset) this.state.lastOffset = offset;
 			process.stderr.write(`funnel: received event (${eventType})\n`);
 			await this.props.server.notification({
 				method: "notifications/claude/channel",
@@ -465,18 +560,25 @@ var FunnelChannelSubscriber = class {
 				}
 			});
 		} catch (error) {
-			process.stderr.write(`funnel: error: ${errorMessageOf(error)}\n`);
+			process.stderr.write(`funnel: error handling ws message (offset=${this.state.lastOffset}): ${errorMessageOf(error)}\n`);
 		}
 	}
 };
+const readErrorEventMessage = (event) => {
+	if (event instanceof Error) return event.message;
+	if ("message" in event && typeof event.message === "string") return event.message;
+	if ("error" in event && event.error instanceof Error) return event.error.message;
+	return "unknown";
+};
 //#endregion
 //#region lib/engine/connectors/builtin-connectors.ts
 /**
-* The four built-in connector descriptors. Importing this pulls every connector
-* SDK (@slack/bolt, discord.js, …) into the bundle, so it is used ONLY by
-* full-bundle entry points (the `fnl` CLI, the gateway daemon, the MCP server) —
-* never by the library's public barrel. Programmatic hosts pass the descriptors
-* they actually need to `new Funnel({ connectors: [...] })` instead.
+* The four built-in connector descriptors. Importing this pulls every
+* connector's protocol code (Slack Socket Mode, Discord Gateway, GitHub
+* polling) into the bundle, so it is used ONLY by full-bundle entry points
+* (the `fnl` CLI, the gateway daemon, the MCP server) — never by the
+* library's public barrel. Programmatic hosts pass the descriptors they
+* actually need to `new Funnel({ connectors: [...] })` instead.
 */
 const builtinConnectors = () => [
 	slackConnector(),
@@ -533,12 +635,17 @@ const readAllChannels = (dir) => {
 	try {
 		const raw = JSON.parse(readFileSync(settingsPath, "utf-8"));
 		const parsed = settingsSchema.safeParse(raw);
-		if (!parsed.success) return [];
+		if (!parsed.success) {
+			process.stderr.write(`funnel: ${settingsPath} failed schema validation: ${parsed.error.message}\n`);
+			return [];
+		}
 		return parsed.data.channels.map((c) => ({
 			id: c.id,
 			name: c.name
 		}));
-	} catch {
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		process.stderr.write(`funnel: failed to read ${settingsPath}: ${message}\n`);
 		return [];
 	}
 };
@@ -643,4 +750,4 @@ const dispatchConnectorTool = async (input) => {
 	}
 };
 //#endregion
-export { FUNNEL_MCP_ARGS, FUNNEL_MCP_COMMAND, FUNNEL_MCP_NAME, FileProcessGuard, FunnelClaude, FunnelLocalConfig, FunnelLocalConfigSync, FunnelLocalConfigWriter, FunnelMcp, FunnelProfiles, FunnelTokenPrompter, LOCAL_CONFIG_FILENAME, MemoryFunnelTokenPrompter, NodeFunnelTokenPrompter, channelSpecSchema, connectorSpecSchema, funnelJsonSchema, localConfigSchema, profileSpecSchema, startChannelServer };
+export { FUNNEL_MCP_ARGS, FUNNEL_MCP_COMMAND, FUNNEL_MCP_NAME, FunnelClaude, FunnelFileProcessGuard, FunnelMcp, FunnelProfiles, startChannelServer };

package/dist/{connector-descriptor-6SXJoszo.d.ts → connector-descriptor-ClEEbuW3.d.ts}

@@ -1,4 +1,4 @@
-import { n as FunnelFileSystem } from "./file-system-o51IsM0W.js";
+import { n as FunnelFileSystem } from "./file-system-VhwwXZbm.js";
 import { z } from "zod";
 
 //#region lib/engine/logger/logger.d.ts
@@ -185,10 +185,10 @@ declare const connectorConnectionEventSchema: z.ZodObject<{
   channel_id: z.ZodNullable<z.ZodString>;
   status: z.ZodEnum<{
     error: "error";
+    "auth-failed": "auth-failed";
     started: "started";
     connected: "connected";
     disconnected: "disconnected";
-    "auth-failed": "auth-failed";
     stopped: "stopped";
   }>;
   detail: z.ZodString;
@@ -298,20 +298,59 @@ declare abstract class ConnectorDiagnosticLog {
   abstract close(): void;
 }
 //#endregion
+//#region lib/engine/http/http-client.d.ts
+type HttpRequest = {
+  method: string;
+  url: string;
+  headers?: Record<string, string>;
+  body?: string;
+};
+type HttpResponse = {
+  status: number;
+  ok: boolean;
+  text(): Promise<string>;
+  json(): Promise<unknown>;
+};
+declare abstract class FunnelHttpClient {
+  abstract fetch(request: HttpRequest): Promise<HttpResponse>;
+}
+//#endregion
+//#region lib/engine/time/clock.d.ts
+/**
+ * Time boundary. Default NodeFunnelClock returns `new Date()`; MemoryFunnelClock
+ * is settable and `advance(ms)`-able for deterministic schedule / timeout tests.
+ */
+declare abstract class FunnelClock {
+  abstract now(): Date;
+  millis(): number;
+  iso(): string;
+}
+//#endregion
 //#region lib/engine/connectors/connector-descriptor.d.ts
 /** Boundaries a listener needs, supplied by the registry at build time. */
 type ConnectorListenerDeps = {
   channelId: string;
   fs: FunnelFileSystem;
-  process: FunnelProcessRunner;
+  process: FunnelProcessRunner; /** HTTP client for self-detection (Slack auth.test), reactions, and other listener-side REST calls. */
+  http: FunnelHttpClient; /** Wall clock — listeners that own a timer (schedule) read it from here so tests can inject a fake. */
+  clock: FunnelClock;
   logger?: FunnelLogger;
-  diagnosticLog?: ConnectorDiagnosticLog; /** Resolves the per-connector state directory (`<dir>/channels/<id>/connectors/<id>`). */
+  diagnosticLog?: ConnectorDiagnosticLog;
+  /**
+   * Optional shutdown signal forwarded to flume-backed listeners. When the
+   * host aborts the signal, the listener's Flume tears down its WebSocket /
+   * fetch loop without waiting for the supervisor's `stop()`. Hosts that want
+   * a clean SIGTERM story wire `controller.signal` here and call
+   * `controller.abort()` in their shutdown handler.
+   */
+  signal?: AbortSignal; /** Resolves the per-connector state directory (`<dir>/channels/<id>/connectors/<id>`). */
   connectorDir: (channelId: string, connectorId: string) => string;
 };
 /** Boundaries an adapter needs. Adapters are channel-agnostic. */
 type ConnectorAdapterDeps = {
   fs: FunnelFileSystem;
-  process: FunnelProcessRunner;
+  process: FunnelProcessRunner; /** HTTP client for outbound calls. Used by the Slack adapter, future REST adapters. */
+  http: FunnelHttpClient;
   logger?: FunnelLogger;
 };
 type ConnectorBuildContext = {
@@ -344,11 +383,11 @@ type ConnectorOperation = (props: {
  * descriptor accepts/returns `BaseConnectorConfig` at every boundary and parses
  * to its concrete config internally (via `schema`), so the registry can hold a
  * homogeneous `ConnectorDescriptor[]` with no variance gymnastics. Type-specific
- * launch hooks (Slack `onAppCreated`, Schedule `onFired`) are closed over by the
- * descriptor factory, not threaded through here. Each descriptor parses configs
- * to its concrete shape internally (it owns its zod schema), so no schema is
- * exposed here — that also sidesteps the variance trap of a `ZodType<Slack>`
- * field declared as `ZodType<BaseConnectorConfig>`.
+ * launch hooks (e.g. Schedule `onFired`) are closed over by the descriptor
+ * factory, not threaded through here. Each descriptor parses configs to its
+ * concrete shape internally (it owns its zod schema), so no schema is exposed
+ * here — that also sidesteps the variance trap of a `ZodType<Slack>` field
+ * declared as `ZodType<BaseConnectorConfig>`.
  */
 type ConnectorDescriptor = {
   type: string;
@@ -361,4 +400,4 @@ type ConnectorDescriptor = {
   operations: Record<string, ConnectorOperation>;
 };
 //#endregion
-export { FunnelConnectorAdapter as A, FunnelLogger as B, StoredRawEvent as C, FunnelConnectorListener as D, connectorRawEventSchema as E, DetachOptions as F, FunnelProcessRunner as I, ProcessSnapshot as L, BaseConnectorConfig as M, baseConnectorConfigSchema as N, NotifyFn as O, AttachOptions as P, RunOptions as R, StoredProcessedEvent as S, connectorProcessedEventSchema as T, ConnectorQuery as _, ConnectorOperation as a, ConnectorRawRecord as b, CONNECTOR_CONNECTION_STATUSES as c, ConnectorConnectionRecord as d, ConnectorConnectionStatus as f, ConnectorProcessedRecord as g, ConnectorProcessedQuery as h, ConnectorListenerDeps as i, JsonValue as j, CallInput as k, ConnectorConnectionEvent as l, ConnectorProcessedEvent as m, ConnectorBuildContext as n, ConnectorOperationContext as o, ConnectorDiagnosticLog as p, ConnectorDescriptor as r, ConnectorUpdateContext as s, ConnectorAdapterDeps as t, ConnectorConnectionQuery as u, ConnectorRawEvent as v, connectorConnectionEventSchema as w, StoredConnectionEvent as x, ConnectorRawQuery as y, RunResult as z };
+export { connectorRawEventSchema as A, FunnelProcessRunner as B, ConnectorRawQuery as C, StoredRawEvent as D, StoredProcessedEvent as E, JsonValue as F, RunOptions as H, BaseConnectorConfig as I, baseConnectorConfigSchema as L, NotifyFn as M, CallInput as N, connectorConnectionEventSchema as O, FunnelConnectorAdapter as P, AttachOptions as R, ConnectorRawEvent as S, StoredConnectionEvent as T, RunResult as U, ProcessSnapshot as V, FunnelLogger as W, ConnectorDiagnosticLog as _, ConnectorOperation as a, ConnectorProcessedRecord as b, FunnelClock as c, HttpResponse as d, CONNECTOR_CONNECTION_STATUSES as f, ConnectorConnectionStatus as g, ConnectorConnectionRecord as h, ConnectorListenerDeps as i, FunnelConnectorListener as j, connectorProcessedEventSchema as k, FunnelHttpClient as l, ConnectorConnectionQuery as m, ConnectorBuildContext as n, ConnectorOperationContext as o, ConnectorConnectionEvent as p, ConnectorDescriptor as r, ConnectorUpdateContext as s, ConnectorAdapterDeps as t, HttpRequest as u, ConnectorProcessedEvent as v, ConnectorRawRecord as w, ConnectorQuery as x, ConnectorProcessedQuery as y, DetachOptions as z };

package/dist/connector-diagnostics-recorder-COtNEmUp.js

@@ -0,0 +1,42 @@
+//#region lib/engine/connectors/connector-diagnostics-recorder.ts
+/**
+* Wraps a `ConnectorDiagnosticLog` with the per-listener axes (`type` /
+* `connectorId` / `channelId`) so call sites only pass the row-specific
+* fields. When no log is wired every call is a silent no-op.
+*/
+var FunnelConnectorDiagnosticsRecorder = class {
+	constructor(props) {
+		this.props = props;
+		Object.freeze(this);
+	}
+	recordRaw(eventId, payload) {
+		this.props.log?.recordRaw({
+			eventId,
+			type: this.props.type,
+			connectorId: this.props.connectorId,
+			channelId: this.props.channelId,
+			payload
+		});
+	}
+	recordProcessed(eventId, outcome, payload) {
+		this.props.log?.recordProcessed({
+			eventId,
+			type: this.props.type,
+			connectorId: this.props.connectorId,
+			channelId: this.props.channelId,
+			outcome,
+			payload
+		});
+	}
+	recordConnection(status, detail) {
+		this.props.log?.recordConnection({
+			type: this.props.type,
+			connectorId: this.props.connectorId,
+			channelId: this.props.channelId,
+			status,
+			detail
+		});
+	}
+};
+//#endregion
+export { FunnelConnectorDiagnosticsRecorder as t };

package/dist/connectors/discord.d.ts

@@ -1,26 +1,8 @@
-import { A as FunnelConnectorAdapter, B as FunnelLogger, D as FunnelConnectorListener, O as NotifyFn, k as CallInput, p as ConnectorDiagnosticLog, r as ConnectorDescriptor } from "../connector-descriptor-6SXJoszo.js";
-import { t as FunnelHttpClient } from "../http-client-oICicjuO.js";
-import { z } from "zod";
+import { M as NotifyFn, N as CallInput, P as FunnelConnectorAdapter, W as FunnelLogger, _ as ConnectorDiagnosticLog, l as FunnelHttpClient, r as ConnectorDescriptor } from "../connector-descriptor-ClEEbuW3.js";
+import { n as discordConnectorSchema, t as DiscordConnectorConfig } from "../discord-connector-schema-D-bOVAKt.js";
+import { t as FunnelFlumeSourceListener } from "../flume-source-listener-Dim5szHG.js";
+import { FlumeRuntimeDeps } from "@interactive-inc/flume";
 
-//#region lib/engine/connectors/discord-connector-schema.d.ts
-/**
- * Like slack, a discord connector holds either a literal `botToken` or a
- * `botTokenEnv` reference resolved from `process.env` at listener start. The
- * reference form keeps the secret out of settings.json, but is only set through
- * the engine API (`new Funnel(...)`); funnel.json and the `fnl` CLI produce
- * literals.
- */
-declare const discordConnectorSchema: z.ZodObject<{
-  id: z.ZodString;
-  name: z.ZodString;
-  type: z.ZodLiteral<"discord">;
-  botToken: z.ZodOptional<z.ZodString>;
-  botTokenEnv: z.ZodOptional<z.ZodString>;
-  createdAt: z.ZodOptional<z.ZodString>;
-  updatedAt: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-type DiscordConnectorConfig = z.infer<typeof discordConnectorSchema>;
-//#endregion
 //#region lib/engine/connectors/discord-adapter.d.ts
 type Deps$1 = {
   config: DiscordConnectorConfig; /** Environment used to resolve a `botTokenEnv` reference. Defaults to process.env. */
@@ -38,6 +20,9 @@ declare class FunnelDiscordAdapter extends FunnelConnectorAdapter {
 /**
  * Discord connector descriptor. Pass `discordConnector()` to
  * `new Funnel({ connectors: [...] })` to enable the type.
+ *
+ * The listener is backed by `@interactive-inc/flume`'s `FlumeDiscordSource`
+ * (raw Gateway WebSocket).
  */
 declare const discordConnector: () => ConnectorDescriptor;
 //#endregion
@@ -68,28 +53,37 @@ declare class FunnelDiscordEventProcessor {
   process(message: DiscordInboundMessage): DiscordProcessed;
 }
 //#endregion
-//#region lib/engine/connectors/discord-listener.d.ts
+//#region lib/engine/connectors/discord-flume-listener.d.ts
 type Deps = {
-  config: DiscordConnectorConfig; /** Funnel channel uuid this connector lives under; stamped onto diagnostic-log rows. */
-  channelId?: string; /** Environment used to resolve a `botTokenEnv` reference. Defaults to process.env. */
+  config: DiscordConnectorConfig;
+  channelId?: string;
   env?: NodeJS.ProcessEnv;
-  logger?: FunnelLogger; /** Diagnostic log of inbound events, before and after processing. No-op when absent. */
+  logger?: FunnelLogger;
   diagnosticLog?: ConnectorDiagnosticLog;
+  flumeDeps?: Partial<FlumeRuntimeDeps>; /** Shutdown signal forwarded to the underlying Flume. */
+  signal?: AbortSignal;
 };
-declare class FunnelDiscordListener extends FunnelConnectorListener {
+/**
+ * Discord listener backed by `@interactive-inc/flume`'s `FlumeDiscordSource`
+ * (raw Gateway WebSocket + Zod). The processor layer
+ * (`FunnelDiscordEventProcessor`) is the application layer — self-skip,
+ * mention detection, meta shaping. Self-detection requires the bot's own
+ * user id, which Discord does not surface until READY; we read it from the
+ * READY payload on the first dispatch and build the processor then. Events
+ * seen before READY are impossible by protocol, so no event is lost.
+ */
+declare class FunnelFlumeDiscordListener extends FunnelFlumeSourceListener {
   private readonly config;
-  private readonly channelId;
   private readonly env;
-  private readonly logger;
-  private readonly diagnosticLog;
-  private client;
+  private readonly flumeDeps;
+  private readonly signal;
+  private processor;
   constructor(deps: Deps);
   start(notify: NotifyFn): Promise<void>;
-  stop(): Promise<void>;
-  isAlive(): boolean;
-  private recordRaw;
-  private recordProcessed;
-  private recordConnection;
+  protected onStop(): void;
+  private handleEvent;
+  private adoptReady;
+  private deliver;
 }
 //#endregion
-export { DiscordConnectorConfig, DiscordInboundMessage, DiscordProcessed, DiscordProcessedEmit, DiscordProcessedSkip, FunnelDiscordAdapter, FunnelDiscordEventProcessor, FunnelDiscordListener, discordConnector, discordConnectorSchema };
+export { DiscordConnectorConfig, DiscordInboundMessage, DiscordProcessed, DiscordProcessedEmit, DiscordProcessedSkip, FunnelDiscordAdapter, FunnelDiscordEventProcessor, FunnelFlumeDiscordListener, discordConnector, discordConnectorSchema };

package/dist/connectors/discord.js

@@ -1,3 +1,3 @@
-import { t as discordConnectorSchema } from "../discord-connector-schema-B_N6IXLz.js";
-import { i as FunnelDiscordAdapter, n as FunnelDiscordListener, r as FunnelDiscordEventProcessor, t as discordConnector } from "../discord-connector-BL36yvbL.js";
-export { FunnelDiscordAdapter, FunnelDiscordEventProcessor, FunnelDiscordListener, discordConnector, discordConnectorSchema };
+import { t as discordConnectorSchema } from "../discord-connector-schema-B4YpWpR3.js";
+import { i as FunnelDiscordAdapter, n as FunnelFlumeDiscordListener, r as FunnelDiscordEventProcessor, t as discordConnector } from "../discord-connector-DIFkYBbi.js";
+export { FunnelDiscordAdapter, FunnelDiscordEventProcessor, FunnelFlumeDiscordListener, discordConnector, discordConnectorSchema };