@interactive-inc/claude-funnel 0.36.0 → 0.38.0

package/dist/index.js

@@ -4,6 +4,7 @@ import { a as FunnelProcessRunner, i as NodeFunnelProcessRunner, n as FunnelGhLi
 import { a as ScheduleStateStore, i as FunnelScheduleListener, n as scheduleConnectorSchema, o as NodeFunnelFileSystem, r as scheduleEntrySchema, s as FunnelFileSystem, t as scheduleCatchupPolicySchema } from "./schedule-connector-schema-CM-sRkac.js";
 import { i as FunnelSlackAdapter, n as FunnelSlackListener, r as FunnelSlackEventProcessor, t as slackConnectorSchema } from "./slack-connector-schema-DDbSGPZn.js";
 import { dirname, join, resolve } from "node:path";
+import { hc } from "hono/client";
 import { appendFileSync, chmodSync, existsSync, mkdirSync, readFileSync } from "node:fs";
 import { z } from "zod";
 import { homedir, tmpdir } from "node:os";
@@ -17,7 +18,6 @@ import { zValidator } from "@hono/zod-validator";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
-import { stringify } from "yaml";
 //#region lib/engine/id/id-generator.ts
 /**
 * ID generator boundary. Default NodeFunnelIdGenerator wraps `crypto.randomUUID()`;
@@ -2582,7 +2582,7 @@ var SqliteFunnelEventLog = class extends FunnelEventLog {
 	record(record) {
 		const event = {
 			type: record.meta?.event_type ?? "unknown",
-			content: truncate(record.content),
+			content: truncate$1(record.content),
 			channel_id: record.channelId,
 			connector_id: record.connectorId,
 			meta: record.meta
@@ -2639,7 +2639,7 @@ var SqliteFunnelEventLog = class extends FunnelEventLog {
 		this.sink.close();
 	}
 };
-function truncate(content) {
+function truncate$1(content) {
 	if (content.length <= MAX_CONTENT_CHARS) return content;
 	return `${content.slice(0, MAX_CONTENT_CHARS)}...`;
 }
@@ -2995,6 +2995,240 @@ const channelsPublishHandler$1 = factory$1.createHandlers(zParam(z.object({ chan
 	return c.json(response);
 });
 //#endregion
+//#region lib/gateway/connector-diagnostic-sql-reader.ts
+/**
+* Read-only SQL surface over the three diagnostic tables, for Claude to query
+* the log with arbitrary `SELECT`s. It opens all files read-only and exposes
+* three views — `raw`, `processed`, `connection` — that hide the storage
+* details (the physical table is `leuco_log` and each row's columns live
+* inside a JSON `event` blob): the views surface the columns as plain fields,
+* with `payload` already pulled out of the nested JSON.
+*
+* The tables are separate files. `raw` and `processed` share an `event_id`,
+* so a `JOIN` answers "the event arrived, but what verdict did it get?";
+* `connection` answers the other half — "did the listener ever connect at
+* all?". Writes are impossible: the connection is read-only and `query`
+* rejects anything but a single `SELECT`.
+*/
+var ConnectorDiagnosticSqlReader = class {
+	db;
+	constructor(props) {
+		const db = new Database(props.rawPath, { readonly: true });
+		try {
+			db.run("PRAGMA busy_timeout = 500");
+			db.prepare("ATTACH DATABASE ? AS processeddb").run(props.processedPath);
+			db.prepare("ATTACH DATABASE ? AS connectiondb").run(props.connectionPath);
+			db.run(rawViewSql);
+			db.run(processedViewSql);
+			db.run(connectionViewSql);
+		} catch (error) {
+			db.close();
+			throw error;
+		}
+		this.db = db;
+		Object.freeze(this);
+	}
+	/**
+	* Run one read-only `SELECT` and return the rows. Returns an `Error` (rather
+	* than throwing) for a non-SELECT statement or a SQL error, so the caller
+	* can surface the message without a stack trace.
+	*/
+	query(sql, params = []) {
+		const trimmed = sql.trim().replace(/;$/, "").trim();
+		if (!/^select\b/i.test(trimmed)) return /* @__PURE__ */ new Error("only a single SELECT statement is allowed");
+		if (trimmed.includes(";")) return /* @__PURE__ */ new Error("only a single statement is allowed (remove the ';')");
+		try {
+			return this.db.prepare(trimmed).all(...params);
+		} catch (error) {
+			return error instanceof Error ? error : new Error(String(error));
+		}
+	}
+	close() {
+		this.db.close();
+	}
+};
+const rawViewSql = `CREATE TEMP VIEW raw AS SELECT
+  seq,
+  ts,
+  json_extract(event, '$.event_id')     AS event_id,
+  json_extract(event, '$.type')         AS type,
+  json_extract(event, '$.connector_id') AS connector_id,
+  json_extract(event, '$.channel_id')   AS channel_id,
+  json_extract(event, '$.payload')      AS payload
+FROM main.leuco_log`;
+const processedViewSql = `CREATE TEMP VIEW processed AS SELECT
+  seq,
+  ts,
+  json_extract(event, '$.event_id')     AS event_id,
+  json_extract(event, '$.type')         AS type,
+  json_extract(event, '$.connector_id') AS connector_id,
+  json_extract(event, '$.channel_id')   AS channel_id,
+  json_extract(event, '$.outcome')      AS outcome,
+  json_extract(event, '$.payload')      AS payload
+FROM processeddb.leuco_log`;
+const connectionViewSql = `CREATE TEMP VIEW connection AS SELECT
+  seq,
+  ts,
+  json_extract(event, '$.type')         AS type,
+  json_extract(event, '$.connector_id') AS connector_id,
+  json_extract(event, '$.channel_id')   AS channel_id,
+  json_extract(event, '$.status')       AS status,
+  json_extract(event, '$.detail')       AS detail
+FROM connectiondb.leuco_log`;
+//#endregion
+//#region lib/gateway/routes/debug.ts
+const extractPreview = (payload) => {
+	if (typeof payload !== "string" || payload.length === 0) return null;
+	try {
+		const parsed = JSON.parse(payload);
+		if (parsed !== null && typeof parsed === "object" && "text" in parsed) {
+			const text = String(parsed.text);
+			return text.length > 80 ? `${text.slice(0, 80)}…` : text;
+		}
+	} catch {
+		return payload.length > 80 ? `${payload.slice(0, 80)}…` : payload;
+	}
+	return payload.length > 80 ? `${payload.slice(0, 80)}…` : payload;
+};
+const buildChannelDiagnosis = (channel) => {
+	const rootCause = (channel.connectionErrors[channel.connectionErrors.length - 1] ?? null)?.detail ?? null;
+	if (channel.connectors.length === 0) return {
+		status: "warn",
+		message: "no connectors configured on this channel",
+		nextActions: [`fnl channels ${channel.name} connectors add <name> --type=slack ...`],
+		rootCause: null
+	};
+	if (!channel.listener) return {
+		status: "error",
+		message: "no listener running for this channel",
+		nextActions: ["fnl gateway restart"],
+		rootCause
+	};
+	if (!channel.listener.alive) return {
+		status: "error",
+		message: "listener is dead",
+		nextActions: ["fnl gateway logs", "fnl gateway restart"],
+		rootCause
+	};
+	if (channel.claudeClients === 0) return {
+		status: "warn",
+		message: "no Claude connected to this channel",
+		nextActions: [`fnl claude --channel ${channel.name}`],
+		rootCause: null
+	};
+	if (channel.listener.errors > 0) return {
+		status: "warn",
+		message: "listener has errors",
+		nextActions: ["fnl gateway logs"],
+		rootCause
+	};
+	return {
+		status: "ok",
+		message: "healthy",
+		nextActions: [],
+		rootCause: null
+	};
+};
+/** GET /debug[?channel=<name>] — per-channel diagnosis with recent events. Used by MCP fnl_debug tool. */
+const debugHandler$1 = factory$1.createHandlers(async (c) => {
+	const deps = c.var.deps;
+	const channelFilter = c.req.query("channel") ?? null;
+	const allChannels = deps.channels.list();
+	const targetChannels = channelFilter ? allChannels.filter((ch) => ch.name === channelFilter || ch.id === channelFilter) : allChannels;
+	const gatewayListeners = deps.supervisor.list();
+	const gatewayClients = deps.broadcaster.listChannels();
+	const metrics = deps.broadcaster.getMetrics();
+	const tmpDir = funnelTmpDir();
+	const rawPath = join(tmpDir, "connector-raw.db");
+	const processedPath = join(tmpDir, "connector-processed.db");
+	const connectionPath = join(tmpDir, "connector-connection.db");
+	const hasStore = existsSync(rawPath) && existsSync(processedPath) && existsSync(connectionPath);
+	const channels = targetChannels.map((ch) => {
+		const listenerEntry = gatewayListeners.find((l) => l.channelName === ch.name) ?? null;
+		const listener = listenerEntry ? {
+			alive: listenerEntry.alive,
+			events: listenerEntry.events,
+			errors: listenerEntry.errors,
+			lastEventAt: listenerEntry.lastEventAt
+		} : null;
+		const claudeClients = gatewayClients.filter((cl) => cl.channel === ch.id || cl.channel === ch.name).length;
+		const recentEvents = [];
+		const connectionErrors = [];
+		if (hasStore) {
+			const reader = new ConnectorDiagnosticSqlReader({
+				rawPath,
+				processedPath,
+				connectionPath
+			});
+			const rows = (() => {
+				try {
+					return reader.query("SELECT seq, ts, type, outcome, payload FROM processed WHERE channel_id = ? ORDER BY seq DESC LIMIT 10", [ch.id]);
+				} finally {
+					reader.close();
+				}
+			})();
+			if (!(rows instanceof Error)) for (const row of [...rows].reverse()) {
+				const rawPayload = typeof row.payload === "string" ? row.payload : null;
+				let payloadParsed = null;
+				if (rawPayload) try {
+					const parsed = JSON.parse(rawPayload);
+					if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) payloadParsed = parsed;
+				} catch {
+					payloadParsed = null;
+				}
+				recentEvents.push({
+					seq: typeof row.seq === "number" ? row.seq : null,
+					ts: typeof row.ts === "number" ? row.ts : null,
+					type: typeof row.type === "string" ? row.type : "?",
+					outcome: typeof row.outcome === "string" ? row.outcome : "?",
+					payload: rawPayload,
+					payloadParsed,
+					preview: extractPreview(row.payload)
+				});
+			}
+			if (listener && (!listener.alive || listener.errors > 0) || !listener) {
+				const errReader = new ConnectorDiagnosticSqlReader({
+					rawPath,
+					processedPath,
+					connectionPath
+				});
+				const errRows = (() => {
+					try {
+						return errReader.query("SELECT ts, type, status, detail FROM connection WHERE channel_id = ? AND status IN ('auth-failed','error') ORDER BY seq DESC LIMIT 3", [ch.id]);
+					} finally {
+						errReader.close();
+					}
+				})();
+				if (!(errRows instanceof Error)) for (const row of [...errRows].reverse()) connectionErrors.push({
+					ts: typeof row.ts === "number" ? row.ts : null,
+					type: typeof row.type === "string" ? row.type : "?",
+					status: typeof row.status === "string" ? row.status : "?",
+					detail: typeof row.detail === "string" && row.detail.length > 0 ? row.detail : null
+				});
+			}
+		}
+		const base = {
+			id: ch.id,
+			name: ch.name,
+			connectors: ch.connectors.map((conn) => conn.name),
+			listener,
+			claudeClients,
+			recentEvents,
+			connectionErrors
+		};
+		return {
+			...base,
+			diagnosis: buildChannelDiagnosis(base)
+		};
+	});
+	return c.json({
+		pid: deps.selfPid,
+		uptimeMs: deps.uptimeMs(),
+		eventsBroadcast: metrics.eventsBroadcast,
+		channels
+	});
+});
+//#endregion
 //#region lib/gateway/routes/health.ts
 /** GET /health — liveness + listener registry snapshot. */
 const healthHandler = factory$1.createHandlers((c) => {
@@ -3061,13 +3295,10 @@ const statusHandler$1 = factory$1.createHandlers((c) => {
 });
 //#endregion
 //#region lib/gateway/routes/index.ts
-/**
-* Top-level Hono app for the gateway daemon. Mounts every HTTP endpoint flat
-* (the WebSocket /ws upgrade is handled directly by `Bun.serve`). Deps come
-* from the `deps` variable set by `FunnelGatewayServer`'s middleware — same
-* shape as CLI's `c.var.funnel`.
-*/
-const gatewayRoutes = factory$1.createApp().get("/health", ...healthHandler).get("/status", ...statusHandler$1).get("/listeners", ...listenersListHandler).post("/listeners/:channel/:connector/start", ...listenersStartHandler).delete("/listeners/:channel/:connector", ...listenersStopHandler).post("/listeners/:channel/:connector/restart", ...listenersRestartHandler).post("/channels/:channel/connectors/:connector/call", ...channelsConnectorsCallHandler).post("/channels/:channel/publish", ...channelsPublishHandler$1);
+function buildGatewayRoutes() {
+	return factory$1.createApp().get("/health", ...healthHandler).get("/status", ...statusHandler$1).get("/debug", ...debugHandler$1).get("/listeners", ...listenersListHandler).post("/listeners/:channel/:connector/start", ...listenersStartHandler).delete("/listeners/:channel/:connector", ...listenersStopHandler).post("/listeners/:channel/:connector/restart", ...listenersRestartHandler).post("/channels/:channel/connectors/:connector/call", ...channelsConnectorsCallHandler).post("/channels/:channel/publish", ...channelsPublishHandler$1);
+}
+const gatewayRoutes = buildGatewayRoutes();
 //#endregion
 //#region lib/gateway/gateway-server.ts
 const DEFAULT_HOST = "127.0.0.1";
@@ -3300,6 +3531,7 @@ var FunnelGatewayServer = class {
 		if (this.token) {
 			base.use("/listeners/*", requireBearerToken({ expected: this.token }));
 			base.use("/status", requireBearerToken({ expected: this.token }));
+			base.use("/debug", requireBearerToken({ expected: this.token }));
 			base.use("/channels/*", requireBearerToken({ expected: this.token }));
 		}
 		return (this.extraRoutes ? base.route("/", this.extraRoutes) : base).route("/", gatewayRoutes);
@@ -3535,6 +3767,84 @@ var FunnelListenersClient = class {
 	}
 };
 //#endregion
+//#region lib/gateway/funnel-debug.ts
+const isGatewayStatusResponse$1 = (value) => {
+	if (value === null || typeof value !== "object") return false;
+	if (!("clients" in value) || !Array.isArray(value.clients)) return false;
+	if (!("listeners" in value) || !Array.isArray(value.listeners)) return false;
+	return true;
+};
+const buildFunnelDebugReport = async (deps, channelFilter) => {
+	const gatewayStatus = deps.gateway.getStatus();
+	const report = {
+		gateway: {
+			running: gatewayStatus.running,
+			pid: gatewayStatus.pid,
+			port: gatewayStatus.running ? gatewayStatus.port : null,
+			uptimeMs: null
+		},
+		channels: [],
+		recentEvents: null
+	};
+	const allChannels = deps.channels.list();
+	const filteredChannels = channelFilter ? allChannels.filter((ch) => ch.name === channelFilter) : allChannels;
+	let gatewayData = null;
+	if (gatewayStatus.running) {
+		const res = await fetch(`http://127.0.0.1:${gatewayStatus.port}/status`).catch(() => null);
+		if (res && res.ok) {
+			const body = await res.json();
+			if (isGatewayStatusResponse$1(body)) {
+				gatewayData = body;
+				report.gateway.uptimeMs = body.uptimeMs;
+			}
+		}
+	}
+	for (const ch of filteredChannels) {
+		const listenerEntry = gatewayData?.listeners.find((l) => l.channelName === ch.name) ?? null;
+		const listener = listenerEntry ? {
+			alive: listenerEntry.alive,
+			events: listenerEntry.events,
+			errors: listenerEntry.errors,
+			lastEventAt: listenerEntry.lastEventAt
+		} : null;
+		const claudeClients = (gatewayData?.clients ?? []).filter((cl) => !cl.tapAll && (cl.channelName === ch.name || cl.channel === ch.name));
+		report.channels.push({
+			name: ch.name,
+			connectors: ch.connectors.map((conn) => conn.name),
+			listener,
+			claudeConnected: claudeClients.length > 0,
+			claudeClientCount: claudeClients.length
+		});
+	}
+	const rawPath = join(deps.tmpDir, "connector-raw.db");
+	const processedPath = join(deps.tmpDir, "connector-processed.db");
+	const connectionPath = join(deps.tmpDir, "connector-connection.db");
+	if (existsSync(rawPath) && existsSync(processedPath) && existsSync(connectionPath)) {
+		const reader = new ConnectorDiagnosticSqlReader({
+			rawPath,
+			processedPath,
+			connectionPath
+		});
+		const filteredChannelId = channelFilter ? allChannels.find((ch) => ch.name === channelFilter)?.id ?? null : null;
+		const sql = filteredChannelId ? "SELECT ts, outcome, payload FROM processed WHERE channel_id = ? ORDER BY seq DESC LIMIT 20" : "SELECT ts, outcome, payload FROM processed ORDER BY seq DESC LIMIT 20";
+		const params = filteredChannelId ? [filteredChannelId] : [];
+		const rows = reader.query(sql, params);
+		reader.close();
+		if (!(rows instanceof Error)) report.recentEvents = rows.map((row) => {
+			const ts = typeof row.ts === "number" ? row.ts : 0;
+			const outcome = typeof row.outcome === "string" ? row.outcome : "";
+			const payload = typeof row.payload === "string" ? row.payload : null;
+			return {
+				ts,
+				outcome,
+				payload,
+				preview: payload ? payload.slice(0, 120) : null
+			};
+		});
+	}
+	return report;
+};
+//#endregion
 //#region lib/funnel.ts
 const SANDBOX_DIR = "/sandbox/.funnel";
 const SANDBOX_TMP_DIR = "/sandbox/tmp";
@@ -3781,6 +4091,17 @@ var Funnel = class Funnel {
 			extraRoutes: options.extraRoutes
 		});
 	}
+	async debug(channelName) {
+		return buildFunnelDebugReport({
+			gateway: this.gateway,
+			channels: this.channels,
+			tmpDir: this.paths.tmpDir
+		}, channelName ?? null);
+	}
+	gatewayClient() {
+		const { port } = this.gateway.getStatus();
+		return hc(`http://127.0.0.1:${port}`);
+	}
 };
 //#endregion
 //#region lib/engine/mcp/channel-subscriber.ts
@@ -3874,14 +4195,44 @@ const readGatewayToken = (dir) => {
 //#endregion
 //#region lib/engine/mcp/usage-hint-for-type.ts
 const usageHintForType = (type) => {
-	if (type === "slack") return "Slack Web API. method=POST path=chat.postMessage body={channel,text,thread_ts?}";
-	if (type === "discord") return "Discord REST API. method=POST path=/channels/<id>/messages body={content,...}";
-	if (type === "gh") return "GitHub REST via gh CLI. method=POST path=repos/owner/repo/issues/N/comments body={body}";
+	if (type === "slack") return [
+		"Slack Web API.",
+		"To reply in the same thread: method=POST path=chat.postMessage body={ channel: meta.channel_id, text: \"...\", thread_ts: meta.thread_ts }",
+		"To react: method=POST path=reactions.add body={ channel: meta.channel_id, timestamp: meta.thread_ts, name: \"thumbsup\" }",
+		"Use meta fields from the incoming event: channel_id (Slack channel), thread_ts (thread anchor), user_id (sender)."
+	].join(" ");
+	if (type === "discord") return [
+		"Discord REST API.",
+		"To reply: method=POST path=/channels/<meta.channel_id>/messages body={ content: \"...\" }",
+		"Use meta fields: channel_id (Discord channel), user_id (sender), guild_id."
+	].join(" ");
+	if (type === "gh") return [
+		"GitHub REST via gh CLI.",
+		"To comment: method=POST path=repos/<meta.repository>/issues/<number>/comments body={ body: \"...\" }",
+		"Parse <number> from meta.subject_url. meta fields: repository (owner/repo), subject_type, subject_url, reason."
+	].join(" ");
 	return "Generic adapter call.";
 };
 //#endregion
 //#region lib/engine/mcp/channel-server.ts
 const DEFAULT_FUNNEL_DIR = join(homedir(), ".funnel");
+const BUILTIN_TOOL_NAMES = ["fnl_status", "fnl_debug"];
+const isBuiltinTool = (name) => BUILTIN_TOOL_NAMES.includes(name);
+const readAllChannels = (dir) => {
+	const settingsPath = join(dir, "settings.json");
+	if (!existsSync(settingsPath)) return [];
+	try {
+		const raw = JSON.parse(readFileSync(settingsPath, "utf-8"));
+		const parsed = settingsSchema.safeParse(raw);
+		if (!parsed.success) return [];
+		return parsed.data.channels.map((c) => ({
+			id: c.id,
+			name: c.name
+		}));
+	} catch {
+		return [];
+	}
+};
 const startChannelServer = async (options = {}) => {
 	const dir = options.dir ?? DEFAULT_FUNNEL_DIR;
 	const gatewayBaseUrl = options.gatewayUrl ?? process.env.FUNNEL_GATEWAY_URL ?? `http://127.0.0.1:${resolveFunnelPort()}`;
@@ -3889,6 +4240,13 @@ const startChannelServer = async (options = {}) => {
 	const channelId = options.channelId ?? process.env.FUNNEL_CHANNEL_ID;
 	const channel = channelId ? readChannelConnectors(dir, channelId) : null;
 	const token = options.token ?? readGatewayToken(dir);
+	const allChannels = readAllChannels(dir);
+	const currentChannelName = channel?.channelName ?? null;
+	const channelContext = allChannels.length > 0 ? [
+		"",
+		"Configured channels (use as the `channel` argument to fnl_debug):",
+		...allChannels.map((ch) => `  ${ch.name}${ch.name === currentChannelName ? " ← this session" : ""}`)
+	].join("\n") : "";
 	const server = new Server({
 		name: FUNNEL_MCP_NAME,
 		version: "1.0.0"
@@ -3898,13 +4256,35 @@ const startChannelServer = async (options = {}) => {
 			tools: {}
 		},
 		instructions: [
-			`Events arrive inside <channel source="${FUNNEL_MCP_NAME}"> tags. Use meta.event_type to discriminate.`,
+			`Events arrive as notifications (method: notifications/claude/channel) with two fields:`,
+			`  content — the event payload as a JSON string (parse it to read the message)`,
+			`  meta    — key/value strings describing the event`,
+			"",
+			"meta fields by event_type:",
+			"  slack:    event_type=slack  channel_id=C…  thread_ts=1234.5678  user_id=U…  mentioned=true|false",
+			"  gh:       event_type=gh     repository=owner/repo  subject_type=Issue|PullRequest  subject_url=…  reason=…",
+			"  discord:  event_type=discord  channel_id=…  user_id=…  guild_id=…  mentioned=true|false",
+			"  schedule: event_type=schedule  entry_id=…",
+			"",
+			"To reply to a Slack message in the same thread, call the connector tool with:",
+			`  method: POST`,
+			`  path:   chat.postMessage`,
+			`  body:   { channel: meta.channel_id, text: "your reply", thread_ts: meta.thread_ts }`,
+			"",
+			"To comment on a GitHub issue/PR (extract from subject_url in meta):",
+			`  method: POST`,
+			`  path:   repos/<meta.repository>/issues/<number>/comments   (parse number from meta.subject_url)`,
+			`  body:   { body: "your reply" }`,
 			"",
-			"To reply or act, call the connector tool exposed by this MCP (one tool per connector configured on this channel). Each tool takes { method, path, body } matching the underlying adapter's CallInput."
+			"Built-in diagnostic tools — call proactively when events seem missing or delayed:",
+			"  fnl_status — gateway running state, all listeners alive/dead, Claude WS clients",
+			"  fnl_debug  — per-channel diagnosis with last 10 events, rootCause, suggestedActions",
+			"               omit channel arg to diagnose all channels; check summary.suggestedActions first",
+			channelContext
 		].join("\n")
 	});
 	server.setRequestHandler(ListToolsRequestSchema, async () => {
-		return { tools: (channel?.connectors ?? []).map((c) => ({
+		const connectorTools = (channel?.connectors ?? []).map((c) => ({
 			name: c.name,
 			description: `Call the "${c.name}" (${c.type}) connector. ${usageHintForType(c.type)}`,
 			inputSchema: {
@@ -3925,17 +4305,42 @@ const startChannelServer = async (options = {}) => {
 				},
 				required: ["method", "path"]
 			}
-		})) };
+		}));
+		const channelEnum = allChannels.length > 0 ? allChannels.map((ch) => ch.name) : void 0;
+		const builtinTools = [{
+			name: "fnl_status",
+			description: "Return the current funnel gateway status as JSON — gateway running state, listener alive/dead per channel, and connected Claude WS clients. Call this when you need to check whether the gateway is up or why events stopped arriving.",
+			inputSchema: {
+				type: "object",
+				properties: {}
+			}
+		}, {
+			name: "fnl_debug",
+			description: "Return a full channel diagnosis as JSON — gateway health, listener state, Claude WS connection, last 10 inbound events with outcome, connectionErrors (when listener is dead), and diagnosis.rootCause. Call this first when debugging missing events. Omit `channel` to diagnose all channels at once.",
+			inputSchema: {
+				type: "object",
+				properties: { channel: channelEnum ? {
+					type: "string",
+					description: `Channel name to inspect. One of: ${channelEnum.join(", ")}. Omit to get all channels.`,
+					enum: channelEnum
+				} : {
+					type: "string",
+					description: "Channel name to inspect. Omit to get all channels."
+				} }
+			}
+		}];
+		return { tools: [...connectorTools, ...builtinTools] };
 	});
 	server.setRequestHandler(CallToolRequestSchema, async (request) => {
+		const toolName = request.params.name;
+		if (isBuiltinTool(toolName)) return handleBuiltinTool(toolName, request.params.arguments, gatewayBaseUrl, token, allChannels);
 		if (!channel) throw new Error("FUNNEL_CHANNEL_ID is not set or channel not found in settings.json");
-		const connectorName = request.params.name;
 		const args = request.params.arguments ?? {};
 		const method = typeof args.method === "string" ? args.method : "";
 		const path = typeof args.path === "string" ? args.path : "";
 		const body = args.body ?? {};
 		if (!method || !path) throw new Error("`method` and `path` are required");
-		const url = `${gatewayBaseUrl}/channels/${encodeURIComponent(channel.channelName)}/connectors/${encodeURIComponent(connectorName)}/call`;
+		const url = `${gatewayBaseUrl}/channels/${encodeURIComponent(channel.channelName)}/connectors/${encodeURIComponent(toolName)}/call`;
 		const headers = { "content-type": "application/json" };
 		if (token) headers.authorization = `Bearer ${token}`;
 		const res = await fetch(url, {
@@ -3963,6 +4368,51 @@ const startChannelServer = async (options = {}) => {
 		protocols: token ? [`funnel.token.${token}`] : void 0
 	}).start();
 };
+const handleBuiltinTool = async (name, args, gatewayBaseUrl, token, allChannels) => {
+	const headers = {};
+	if (token) headers.authorization = `Bearer ${token}`;
+	if (name === "fnl_status") {
+		const res = await fetch(`${gatewayBaseUrl}/status`, { headers }).catch(() => null);
+		if (!res) return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				running: false,
+				error: "gateway unreachable",
+				hint: "run: fnl gateway start",
+				knownChannels: allChannels.map((ch) => ch.name)
+			})
+		}] };
+		const body = await res.json();
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(body)
+		}] };
+	}
+	const channelArg = typeof args?.channel === "string" ? args.channel : null;
+	const url = channelArg ? `${gatewayBaseUrl}/debug?channel=${encodeURIComponent(channelArg)}` : `${gatewayBaseUrl}/debug`;
+	const res = await fetch(url, { headers }).catch(() => null);
+	if (!res) return { content: [{
+		type: "text",
+		text: JSON.stringify({
+			gateway: { running: false },
+			channels: allChannels.map((ch) => ({
+				id: ch.id,
+				name: ch.name,
+				diagnosis: {
+					status: "error",
+					message: "gateway is not running",
+					nextAction: "fnl gateway start",
+					rootCause: null
+				}
+			}))
+		})
+	}] };
+	const body = await res.json();
+	return { content: [{
+		type: "text",
+		text: JSON.stringify(body)
+	}] };
+};
 //#endregion
 //#region lib/engine/local-config/local-config-json-schema.ts
 /**
@@ -4506,87 +4956,6 @@ const takeRecent = (events, limit) => {
 	return events.slice(-limit);
 };
 //#endregion
-//#region lib/gateway/connector-diagnostic-sql-reader.ts
-/**
-* Read-only SQL surface over the three diagnostic tables, for Claude to query
-* the log with arbitrary `SELECT`s. It opens all files read-only and exposes
-* three views — `raw`, `processed`, `connection` — that hide the storage
-* details (the physical table is `leuco_log` and each row's columns live
-* inside a JSON `event` blob): the views surface the columns as plain fields,
-* with `payload` already pulled out of the nested JSON.
-*
-* The tables are separate files. `raw` and `processed` share an `event_id`,
-* so a `JOIN` answers "the event arrived, but what verdict did it get?";
-* `connection` answers the other half — "did the listener ever connect at
-* all?". Writes are impossible: the connection is read-only and `query`
-* rejects anything but a single `SELECT`.
-*/
-var ConnectorDiagnosticSqlReader = class {
-	db;
-	constructor(props) {
-		const db = new Database(props.rawPath, { readonly: true });
-		try {
-			db.run("PRAGMA busy_timeout = 500");
-			db.prepare("ATTACH DATABASE ? AS processeddb").run(props.processedPath);
-			db.prepare("ATTACH DATABASE ? AS connectiondb").run(props.connectionPath);
-			db.run(rawViewSql);
-			db.run(processedViewSql);
-			db.run(connectionViewSql);
-		} catch (error) {
-			db.close();
-			throw error;
-		}
-		this.db = db;
-		Object.freeze(this);
-	}
-	/**
-	* Run one read-only `SELECT` and return the rows. Returns an `Error` (rather
-	* than throwing) for a non-SELECT statement or a SQL error, so the caller
-	* can surface the message without a stack trace.
-	*/
-	query(sql) {
-		const trimmed = sql.trim().replace(/;$/, "").trim();
-		if (!/^select\b/i.test(trimmed)) return /* @__PURE__ */ new Error("only a single SELECT statement is allowed");
-		if (trimmed.includes(";")) return /* @__PURE__ */ new Error("only a single statement is allowed (remove the ';')");
-		try {
-			return this.db.prepare(trimmed).all();
-		} catch (error) {
-			return error instanceof Error ? error : new Error(String(error));
-		}
-	}
-	close() {
-		this.db.close();
-	}
-};
-const rawViewSql = `CREATE TEMP VIEW raw AS SELECT
-  seq,
-  ts,
-  json_extract(event, '$.event_id')     AS event_id,
-  json_extract(event, '$.type')         AS type,
-  json_extract(event, '$.connector_id') AS connector_id,
-  json_extract(event, '$.channel_id')   AS channel_id,
-  json_extract(event, '$.payload')      AS payload
-FROM main.leuco_log`;
-const processedViewSql = `CREATE TEMP VIEW processed AS SELECT
-  seq,
-  ts,
-  json_extract(event, '$.event_id')     AS event_id,
-  json_extract(event, '$.type')         AS type,
-  json_extract(event, '$.connector_id') AS connector_id,
-  json_extract(event, '$.channel_id')   AS channel_id,
-  json_extract(event, '$.outcome')      AS outcome,
-  json_extract(event, '$.payload')      AS payload
-FROM processeddb.leuco_log`;
-const connectionViewSql = `CREATE TEMP VIEW connection AS SELECT
-  seq,
-  ts,
-  json_extract(event, '$.type')         AS type,
-  json_extract(event, '$.connector_id') AS connector_id,
-  json_extract(event, '$.channel_id')   AS channel_id,
-  json_extract(event, '$.status')       AS status,
-  json_extract(event, '$.detail')       AS detail
-FROM connectiondb.leuco_log`;
-//#endregion
 //#region lib/cli/factory.ts
 const factory = createFactory();
 //#endregion
@@ -4705,7 +5074,18 @@ const queryToCliArgs = (url, reservedKeys = []) => {
 	return args;
 };
 //#endregion
-//#region lib/cli/router/validator.ts
+//#region lib/cli/routes/channels.add.ts
+const help$17 = `funnel channels add — add a channel
+
+usage: funnel channels add <name> [--delivery fanout|exclusive]
+
+options:
+  --delivery    routing mode (default fanout):
+                  fanout      every connected client receives every event
+                  exclusive   each event delivered to exactly one client (round-robin)`;
+const channelsAddHelpHandler = factory.createHandlers((c) => c.text(help$17));
+//#endregion
+//#region lib/cli/router/validator.ts
 const zValidator$1 = (target, schema, helpText) => zValidator(target, schema, (result, c) => {
 	if (helpText && c.req.query("help")) return c.text(helpText);
 	if (result.success) return;
@@ -4716,18 +5096,10 @@ const zValidator$1 = (target, schema, helpText) => zValidator(target, schema, (r
 });
 //#endregion
 //#region lib/cli/routes/channels.add.$channel.ts
-const addHelp$3 = `funnel channels add — add a channel
-
-usage: funnel channels add <name> [--delivery fanout|exclusive]
-
-options:
-  --delivery    routing mode (default fanout):
-                  fanout      every connected client receives every event
-                  exclusive   each event delivered to exactly one client (round-robin)`;
-const channelsAddHandler = factory.createHandlers(zValidator$1("param", z.object({ channel: z.string() })), zValidator$1("query", z.object({ delivery: channelDeliveryModeSchema.optional() }), addHelp$3), (c) => {
+const channelsAddHandler = factory.createHandlers(zValidator$1("param", z.object({ channel: z.string() })), zValidator$1("query", z.object({ delivery: channelDeliveryModeSchema.optional() })), (c) => {
 	const param = c.req.valid("param");
 	const query = c.req.valid("query");
-	const created = c.var.funnel.channels.add({
+	const created = c.env.funnel.channels.add({
 		name: param.channel,
 		delivery: query.delivery
 	});
@@ -4737,14 +5109,14 @@ const channelsConnectorsGroupHandler = factory.createHandlers(zValidator$1("para
 
 usage: funnel channels <channel> connectors`), (c) => {
 	const param = c.req.valid("param");
-	const channel = c.var.funnel.channels.get(param.channel);
+	const channel = c.env.funnel.channels.get(param.channel);
 	if (!channel) throw new HTTPException(404, { message: `channel "${param.channel}" not found` });
 	if (channel.connectors.length === 0) return c.text(`no connectors in channel "${channel.name}"`);
 	return c.text(channel.connectors.map((c) => `${c.name} (${c.type}, id: ${c.id})`).join("\n"));
 });
 //#endregion
-//#region lib/cli/routes/channels.$channel.connectors.add.$connector.ts
-const addHelp$2 = `funnel channels <channel> connectors add <connector> — add a connector to a channel
+//#region lib/cli/routes/channels.$channel.connectors.add.ts
+const help$16 = `funnel channels <channel> connectors add <connector> — add a connector to a channel
 
 usage:
   funnel channels <channel> connectors add <connector> --type=slack --bot-token=xoxb-... --app-token=xapp-...
@@ -4753,6 +5125,9 @@ usage:
   funnel channels <channel> connectors add <connector> --type=schedule
 
 Token uniqueness is enforced across all channels.`;
+const channelsConnectorsAddHelpHandler = factory.createHandlers((c) => c.text(help$16));
+//#endregion
+//#region lib/cli/routes/channels.$channel.connectors.add.$connector.ts
 const slackBody = z.object({
 	type: z.literal("slack"),
 	"bot-token": z.string().startsWith("xoxb-"),
@@ -4776,10 +5151,10 @@ const addBody = z.discriminatedUnion("type", [
 const channelsConnectorsAddHandler = factory.createHandlers(zValidator$1("param", z.object({
 	channel: z.string(),
 	connector: z.string()
-})), zValidator$1("query", addBody, addHelp$2), async (c) => {
+})), zValidator$1("query", addBody), async (c) => {
 	const param = c.req.valid("param");
 	const query = c.req.valid("query");
-	const funnel = c.var.funnel;
+	const funnel = c.env.funnel;
 	if (query.type === "slack") {
 		const created = funnel.channels.addConnector(param.channel, {
 			type: "slack",
@@ -4817,28 +5192,34 @@ const channelsConnectorsAddHandler = factory.createHandlers(zValidator$1("param"
 	return c.text(`added schedule connector "${created.name}" to channel "${param.channel}"`);
 });
 //#endregion
-//#region lib/cli/routes/channels.$channel.connectors.remove.$connector.ts
-const removeHelp$3 = `funnel channels <channel> connectors remove <connector> — remove a connector
+//#region lib/cli/routes/channels.$channel.connectors.remove.ts
+const help$15 = `funnel channels <channel> connectors remove <connector> — remove a connector
 
 usage: funnel channels <channel> connectors remove <connector>`;
+const channelsConnectorsRemoveHelpHandler = factory.createHandlers((c) => c.text(help$15));
+//#endregion
+//#region lib/cli/routes/channels.$channel.connectors.remove.$connector.ts
 const channelsConnectorsRemoveHandler = factory.createHandlers(zValidator$1("param", z.object({
 	channel: z.string(),
 	connector: z.string()
-})), zValidator$1("query", z.object({}), removeHelp$3), async (c) => {
+})), zValidator$1("query", z.object({})), async (c) => {
 	const param = c.req.valid("param");
-	const funnel = c.var.funnel;
+	const funnel = c.env.funnel;
 	await funnel.listeners.stop(param.channel, param.connector);
 	funnel.channels.removeConnector(param.channel, param.connector);
 	return c.text(`removed connector "${param.connector}" from channel "${param.channel}"`);
 });
 //#endregion
-//#region lib/cli/routes/channels.$channel.connectors.set.$connector.ts
-const setHelp$1 = `funnel channels <channel> connectors set <connector> — update connector fields
+//#region lib/cli/routes/channels.$channel.connectors.set.ts
+const help$14 = `funnel channels <channel> connectors set <connector> — update connector fields
 
 usage:
   funnel channels <ch> connectors set <conn> [--bot-token=...] [--app-token=...]   # slack
   funnel channels <ch> connectors set <conn> [--bot-token=...]                    # discord
   funnel channels <ch> connectors set <conn> [--poll-interval=N]                  # gh`;
+const channelsConnectorsSetHelpHandler = factory.createHandlers((c) => c.text(help$14));
+//#endregion
+//#region lib/cli/routes/channels.$channel.connectors.set.$connector.ts
 const channelsConnectorsSetHandler = factory.createHandlers(zValidator$1("param", z.object({
 	channel: z.string(),
 	connector: z.string()
@@ -4846,10 +5227,10 @@ const channelsConnectorsSetHandler = factory.createHandlers(zValidator$1("param"
 	"bot-token": z.string().optional(),
 	"app-token": z.string().optional(),
 	"poll-interval": z.coerce.number().int().positive().optional()
-}).passthrough(), setHelp$1), async (c) => {
+}).passthrough()), async (c) => {
 	const param = c.req.valid("param");
 	const query = c.req.valid("query");
-	const funnel = c.var.funnel;
+	const funnel = c.env.funnel;
 	const existing = funnel.channels.getConnector(param.channel, param.connector);
 	if (!existing) throw new HTTPException(404, { message: `connector "${param.connector}" not found in channel "${param.channel}"` });
 	if (existing.type === "slack") funnel.channels.updateSlackConnector(param.channel, param.connector, {
@@ -4869,27 +5250,36 @@ const channelsConnectorsShowHandler = factory.createHandlers(zValidator$1("param
 
 usage: funnel channels <channel> connectors show <connector>`), (c) => {
 	const param = c.req.valid("param");
-	const connector = c.var.funnel.channels.getConnector(param.channel, param.connector);
+	const connector = c.env.funnel.channels.getConnector(param.channel, param.connector);
 	if (!connector) throw new HTTPException(404, { message: `connector "${param.connector}" not found in channel "${param.channel}"` });
 	return c.text(JSON.stringify(connector, null, 2));
 });
 //#endregion
-//#region lib/cli/routes/channels.$channel.connectors.$connector.rename.$newName.ts
-const renameHelp$2 = `funnel channels <channel> connectors rename <connector> <new-name>
+//#region lib/cli/routes/channels.$channel.connectors.rename.ts
+const help$13 = `funnel channels <channel> connectors rename <connector> <new-name>
 
 usage: funnel channels <channel> connectors rename <connector> <new-name>`;
+const channelsConnectorsRenameHelpHandler = factory.createHandlers((c) => c.text(help$13));
+//#endregion
+//#region lib/cli/routes/channels.$channel.connectors.$connector.rename.$newName.ts
 const channelsConnectorsRenameHandler = factory.createHandlers(zValidator$1("param", z.object({
 	channel: z.string(),
 	connector: z.string(),
 	newName: z.string()
-})), zValidator$1("query", z.object({}), renameHelp$2), async (c) => {
+})), zValidator$1("query", z.object({})), async (c) => {
 	const param = c.req.valid("param");
-	const funnel = c.var.funnel;
+	const funnel = c.env.funnel;
 	await funnel.listeners.stop(param.channel, param.connector);
 	funnel.channels.renameConnector(param.channel, param.connector, param.newName);
 	await funnel.listeners.start(param.channel, param.newName);
 	return c.text(`renamed connector "${param.connector}" to "${param.newName}"`);
 });
+//#endregion
+//#region lib/cli/routes/channels.$channel.connectors.$connector.rename.ts
+const help$12 = `funnel channels <channel> connectors rename <connector> <new-name>
+
+usage: funnel channels <channel> connectors rename <connector> <new-name>`;
+const channelsConnectorRenameHelpHandler = factory.createHandlers((c) => c.text(help$12));
 const channelsConnectorsRequestHandler = factory.createHandlers(zValidator$1("param", z.object({
 	channel: z.string(),
 	connector: z.string()
@@ -4898,7 +5288,7 @@ const channelsConnectorsRequestHandler = factory.createHandlers(zValidator$1("pa
 usage: funnel channels <channel> connectors <connector> request --method=<api.method> [--key=value ...]`), async (c) => {
 	const param = c.req.valid("param");
 	const query = c.req.valid("query");
-	const funnel = c.var.funnel;
+	const funnel = c.env.funnel;
 	const passthrough = {};
 	for (const [k, v] of new URL(c.req.url).searchParams) {
 		if (k === "method") continue;
@@ -4918,15 +5308,18 @@ const channelsConnectorsSchedulesGroupHandler = factory.createHandlers(zValidato
 
 usage: funnel channels <ch> connectors <conn> schedules`), (c) => {
 	const param = c.req.valid("param");
-	const entries = c.var.funnel.channels.listScheduleEntries(param.channel, param.connector);
+	const entries = c.env.funnel.channels.listScheduleEntries(param.channel, param.connector);
 	if (entries.length === 0) return c.text("no schedule entries");
 	return c.text(entries.map((e) => `${e.id}\t${e.cron}\t${e.enabled ? "on" : "off"}\t${e.prompt}`).join("\n"));
 });
 //#endregion
-//#region lib/cli/routes/channels.$channel.connectors.$connector.schedules.add.$id.ts
-const addHelp$1 = `funnel channels <ch> connectors <conn> schedules add <id> — add a schedule entry
+//#region lib/cli/routes/channels.$channel.connectors.$connector.schedules.add.ts
+const help$11 = `funnel channels <ch> connectors <conn> schedules add <id> — add a schedule entry
 
 usage: funnel channels <ch> connectors <conn> schedules add <id> --cron="*/5 * * * *" --prompt="..." [--enabled=true] [--catchup-policy=latest|all|skip]`;
+const channelsConnectorSchedulesAddHelpHandler = factory.createHandlers((c) => c.text(help$11));
+//#endregion
+//#region lib/cli/routes/channels.$channel.connectors.$connector.schedules.add.$id.ts
 const channelsConnectorsSchedulesAddHandler = factory.createHandlers(zValidator$1("param", z.object({
 	channel: z.string(),
 	connector: z.string(),
@@ -4936,10 +5329,10 @@ const channelsConnectorsSchedulesAddHandler = factory.createHandlers(zValidator$
 	prompt: z.string(),
 	enabled: z.coerce.boolean().optional(),
 	"catchup-policy": scheduleCatchupPolicySchema.optional()
-}), addHelp$1), async (c) => {
+})), async (c) => {
 	const param = c.req.valid("param");
 	const query = c.req.valid("query");
-	const funnel = c.var.funnel;
+	const funnel = c.env.funnel;
 	const entry = funnel.channels.addScheduleEntry(param.channel, param.connector, {
 		id: param.id,
 		cron: query.cron,
@@ -4951,24 +5344,27 @@ const channelsConnectorsSchedulesAddHandler = factory.createHandlers(zValidator$
 	return c.text(`added schedule entry "${entry.id}"`);
 });
 //#endregion
-//#region lib/cli/routes/channels.$channel.connectors.$connector.schedules.remove.$id.ts
-const removeHelp$2 = `funnel channels <ch> connectors <conn> schedules remove <id>
+//#region lib/cli/routes/channels.$channel.connectors.$connector.schedules.remove.ts
+const help$10 = `funnel channels <ch> connectors <conn> schedules remove <id>
 
 usage: funnel channels <ch> connectors <conn> schedules remove <id>`;
+const channelsConnectorSchedulesRemoveHelpHandler = factory.createHandlers((c) => c.text(help$10));
+//#endregion
+//#region lib/cli/routes/channels.$channel.connectors.$connector.schedules.remove.$id.ts
 const channelsConnectorsSchedulesRemoveHandler = factory.createHandlers(zValidator$1("param", z.object({
 	channel: z.string(),
 	connector: z.string(),
 	id: z.string()
-})), zValidator$1("query", z.object({}), removeHelp$2), async (c) => {
+})), zValidator$1("query", z.object({})), async (c) => {
 	const param = c.req.valid("param");
-	const funnel = c.var.funnel;
+	const funnel = c.env.funnel;
 	funnel.channels.removeScheduleEntry(param.channel, param.connector, param.id);
 	await funnel.listeners.restart(param.channel, param.connector);
 	return c.text(`removed schedule entry "${param.id}"`);
 });
 //#endregion
-//#region lib/cli/routes/channels.$channel.publish.ts
-const publishHelp = `funnel channels <channel> publish — push arbitrary content into a channel
+//#region lib/cli/routes/channels.publish.ts
+const help$9 = `funnel channels <channel> publish — push arbitrary content into a channel
 
 usage: funnel channels <channel> publish --content="<text>" [--connector=<name>] [--meta-<key>=<value> ...]
 
@@ -4976,14 +5372,17 @@ options:
   --content       Required. The event body delivered to subscribers.
   --connector     Optional. Stamp the event with a connector name (resolved to id when found).
   --meta-<key>    Optional. Repeatable. Added to meta. Example: --meta-source=cron`;
+const channelsPublishHelpHandler = factory.createHandlers((c) => c.text(help$9));
+//#endregion
+//#region lib/cli/routes/channels.$channel.publish.ts
 const querySchema = z.object({
 	content: z.string().min(1, { message: "--content is required" }),
 	connector: z.string().min(1).optional()
 }).passthrough();
-const channelsPublishHandler = factory.createHandlers(zValidator$1("param", z.object({ channel: z.string() })), zValidator$1("query", querySchema, publishHelp), async (c) => {
+const channelsPublishHandler = factory.createHandlers(zValidator$1("param", z.object({ channel: z.string() })), zValidator$1("query", querySchema), async (c) => {
 	const param = c.req.valid("param");
 	const query = c.req.valid("query");
-	const funnel = c.var.funnel;
+	const funnel = c.env.funnel;
 	const meta = {};
 	for (const [k, v] of new URL(c.req.url).searchParams) if (k.startsWith("meta-")) meta[k.slice(5)] = v;
 	const result = await funnel.publisher.publish(param.channel, {
@@ -4996,28 +5395,42 @@ const channelsPublishHandler = factory.createHandlers(zValidator$1("param", z.ob
 	return c.text(`published (offset=${result.offset})`);
 });
 //#endregion
-//#region lib/cli/routes/channels.remove.$channel.ts
-const removeHelp$1 = `funnel channels remove — remove a channel
+//#region lib/cli/routes/channels.remove.ts
+const help$8 = `funnel channels remove — remove a channel
 
 usage: funnel channels remove <name>`;
-const channelsRemoveHandler = factory.createHandlers(zValidator$1("param", z.object({ channel: z.string() })), zValidator$1("query", z.object({}), removeHelp$1), (c) => {
+const channelsRemoveHelpHandler = factory.createHandlers((c) => c.text(help$8));
+//#endregion
+//#region lib/cli/routes/channels.remove.$channel.ts
+const channelsRemoveHandler = factory.createHandlers(zValidator$1("param", z.object({ channel: z.string() })), zValidator$1("query", z.object({})), (c) => {
 	const param = c.req.valid("param");
-	c.var.funnel.channels.remove(param.channel);
+	c.env.funnel.channels.remove(param.channel);
 	return c.text(`removed channel "${param.channel}"`);
 });
 //#endregion
-//#region lib/cli/routes/channels.$channel.rename.$newName.ts
-const renameHelp$1 = `funnel channels rename — rename a channel
+//#region lib/cli/routes/channels.rename.ts
+const help$7 = `funnel channels rename — rename a channel
 
 usage:
   funnel channels rename <old> <new>
   funnel channels <old> rename <new>`;
+const channelsRenameHelpHandler = factory.createHandlers((c) => c.text(help$7));
+//#endregion
+//#region lib/cli/routes/channels.$channel.rename.ts
+const help$6 = `funnel channels rename — rename a channel
+
+usage:
+  funnel channels rename <old> <new>
+  funnel channels <old> rename <new>`;
+const channelsChannelRenameHelpHandler = factory.createHandlers((c) => c.text(help$6));
+//#endregion
+//#region lib/cli/routes/channels.$channel.rename.$newName.ts
 const channelsRenameHandler = factory.createHandlers(zValidator$1("param", z.object({
 	channel: z.string(),
 	newName: z.string()
-})), zValidator$1("query", z.object({}), renameHelp$1), (c) => {
+})), zValidator$1("query", z.object({})), (c) => {
 	const param = c.req.valid("param");
-	c.var.funnel.channels.rename(param.channel, param.newName);
+	c.env.funnel.channels.rename(param.channel, param.newName);
 	return c.text(`renamed channel "${param.channel}" to "${param.newName}"`);
 });
 const channelsSetDeliveryHandler = factory.createHandlers(zValidator$1("param", z.object({
@@ -5034,12 +5447,12 @@ modes:
 tap=all clients (TUI dashboard, debugging) always receive regardless of mode.
 `), (c) => {
 	const param = c.req.valid("param");
-	c.var.funnel.channels.setDelivery(param.channel, param.mode);
+	c.env.funnel.channels.setDelivery(param.channel, param.mode);
 	return c.text(`channel "${param.channel}" delivery set to ${param.mode}`);
 });
 const channelsShowHandler = factory.createHandlers(zValidator$1("param", z.object({ channel: z.string() })), zValidator$1("query", z.object({}), `funnel channels <name> — show channel details`), (c) => {
 	const param = c.req.valid("param");
-	const channel = c.var.funnel.channels.get(param.channel);
+	const channel = c.env.funnel.channels.get(param.channel);
 	if (!channel) throw new HTTPException(404, { message: `channel "${param.channel}" not found` });
 	const connectorLines = channel.connectors.length ? channel.connectors.map((c) => `  - ${c.name} (${c.type}, id: ${c.id})`) : ["  (none)"];
 	const lines = [
@@ -5051,9 +5464,16 @@ const channelsShowHandler = factory.createHandlers(zValidator$1("param", z.objec
 	];
 	return c.text(lines.join("\n"));
 });
-const channelsGroupHandler = factory.createHandlers(zValidator$1("query", z.object({}), `funnel channels — manage subscription boxes
+const channelsGroupHandler = factory.createHandlers(zValidator$1("query", z.object({ json: z.enum([
+	"true",
+	"false",
+	""
+]).optional() }), `funnel channels — manage subscription boxes
+
+usage: funnel channels [--json]
 
-usage: funnel channels [subcommand]
+options:
+  --json                output as JSON array (machine-readable, useful for Claude)
 
 subcommands:
   (none)                          list
@@ -5064,19 +5484,132 @@ subcommands:
   <name> connectors add <c> --type=...    add a connector
 
 examples:
+  funnel channels
+  funnel channels --json
   funnel channels add prod-inbox
   funnel channels prod-inbox connectors add prod-slack --type=slack --bot-token=xoxb-... --app-token=xapp-...
   funnel channels prod-inbox`), (c) => {
-	const channels = c.var.funnel.channels.list();
+	const query = c.req.valid("query");
+	const channels = c.env.funnel.channels.list();
+	if (query.json === "true" || query.json === "") return c.json(channels.map((ch) => ({
+		id: ch.id,
+		name: ch.name,
+		delivery: ch.delivery,
+		connectors: ch.connectors.map((conn) => ({
+			id: conn.id,
+			name: conn.name,
+			type: conn.type
+		}))
+	})));
 	if (channels.length === 0) return c.text("no channels");
 	const lines = channels.map((ch) => {
-		const names = ch.connectors.map((c) => c.name);
+		const names = ch.connectors.map((conn) => conn.name);
 		const connectors = names.length > 0 ? names.join(", ") : "(none)";
 		return `${ch.name} [${connectors}]`;
 	});
 	return c.text(lines.join("\n"));
 });
 //#endregion
+//#region lib/cli/routes/channels.validate.ts
+const help$5 = `funnel channels <channel> validate — check connector configuration
+
+usage: funnel channels <channel> validate [--json]
+
+options:
+  --json   output as JSON
+
+Checks that each connector has the required tokens and fields set.
+Does not make any network calls — static config check only.
+
+examples:
+  funnel channels open-karte validate
+  funnel channels open-karte validate --json`;
+const channelsValidateHelpHandler = factory.createHandlers((c) => c.text(help$5));
+//#endregion
+//#region lib/cli/routes/channels.$channel.validate.ts
+const validateConnector = (connector) => {
+	const issues = [];
+	if (connector.type === "slack") {
+		if (!(connector.botToken || connector.botTokenEnv)) issues.push({
+			connector: connector.name,
+			field: "botToken",
+			message: "missing botToken (xoxb-...) or botTokenEnv"
+		});
+		if (!(connector.appToken || connector.appTokenEnv)) issues.push({
+			connector: connector.name,
+			field: "appToken",
+			message: "missing appToken (xapp-...) or appTokenEnv"
+		});
+		if (connector.botToken && typeof connector.botToken === "string" && !connector.botToken.startsWith("xoxb-")) issues.push({
+			connector: connector.name,
+			field: "botToken",
+			message: `botToken must start with xoxb- (got: ${connector.botToken.slice(0, 8)}...)`
+		});
+		if (connector.appToken && typeof connector.appToken === "string" && !connector.appToken.startsWith("xapp-")) issues.push({
+			connector: connector.name,
+			field: "appToken",
+			message: `appToken must start with xapp- (got: ${connector.appToken.slice(0, 8)}...)`
+		});
+	}
+	if (connector.type === "gh") {
+		if (!(connector.token || connector.tokenEnv)) issues.push({
+			connector: connector.name,
+			field: "token",
+			message: "missing token or tokenEnv for GitHub connector"
+		});
+		if (!connector.repo) issues.push({
+			connector: connector.name,
+			field: "repo",
+			message: "missing repo (expected owner/repo format)"
+		});
+	}
+	if (connector.type === "discord") {
+		if (!(connector.botToken || connector.botTokenEnv)) issues.push({
+			connector: connector.name,
+			field: "botToken",
+			message: "missing botToken or botTokenEnv for Discord connector"
+		});
+	}
+	return issues;
+};
+const channelsValidateHandler = factory.createHandlers(zValidator$1("param", z.object({ channel: z.string() })), zValidator$1("query", z.object({ json: z.enum([
+	"true",
+	"false",
+	""
+]).optional() })), (c) => {
+	const param = c.req.valid("param");
+	const query = c.req.valid("query");
+	const funnel = c.env.funnel;
+	const isJson = query.json === "true" || query.json === "";
+	const channel = funnel.channels.get(param.channel);
+	if (!channel) throw new HTTPException(404, { message: `channel "${param.channel}" not found` });
+	if (channel.connectors.length === 0) {
+		if (isJson) return c.json({
+			channel: channel.name,
+			valid: false,
+			issues: [{
+				connector: "(none)",
+				field: "connectors",
+				message: "no connectors configured"
+			}]
+		});
+		return c.text(`⚠ ${channel.name}: no connectors configured`);
+	}
+	const allIssues = [];
+	for (const connector of channel.connectors) {
+		const issues = validateConnector(connector);
+		allIssues.push(...issues);
+	}
+	if (isJson) return c.json({
+		channel: channel.name,
+		valid: allIssues.length === 0,
+		issues: allIssues
+	});
+	if (allIssues.length === 0) return c.text(`✓ ${channel.name}: all connectors valid`);
+	const lines = allIssues.map((issue) => `✗ ${channel.name}/${issue.connector}: ${issue.message}`);
+	return c.text(lines.join("\n"));
+});
+//#endregion
 //#region lib/cli/routes/claude.ts
 const claudeHelp = `funnel claude — launch Claude Code
 
@@ -5108,7 +5641,7 @@ const claudeHandler = factory.createHandlers(zValidator$1("query", z.object({
 	channel: z.string().optional()
 }).passthrough(), claudeHelp), async (c) => {
 	const query = c.req.valid("query");
-	const funnel = c.var.funnel;
+	const funnel = c.env.funnel;
 	const userArgs = queryToCliArgs(c.req.url, RESERVED_KEYS$1);
 	if (query.channel && !query.profile) {
 		const exitCode = await funnel.claude.launch({
@@ -5161,12 +5694,697 @@ const claudeHandler = factory.createHandlers(zValidator$1("query", z.object({
 	process.exit(exitCode);
 });
 //#endregion
+//#region lib/cli/routes/debug-row.ts
+const stringOrNull = (value) => typeof value === "string" && value.length > 0 ? value : null;
+const numberOrNull = (value) => typeof value === "number" ? value : null;
+const stringOr = (value, fallback) => typeof value === "string" ? value : fallback;
+/**
+* Parse a payload string as a JSON object. Returns null for non-strings,
+* malformed JSON, or any non-object JSON (arrays, primitives) — the callers
+* only ever want the object form.
+*/
+const parsePayloadObject = (payload) => {
+	if (payload === null) return null;
+	try {
+		const parsed = JSON.parse(payload);
+		if (isStringKeyedObject(parsed)) return parsed;
+	} catch {
+		return null;
+	}
+	return null;
+};
+const isStringKeyedObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const truncate = (text, max) => text.length <= max ? text : `${text.slice(0, max)}…`;
+/**
+* A short human preview of a payload: the `text` field when the payload is a
+* JSON object that has one, otherwise the raw payload, both truncated.
+*/
+const previewOf = (payload) => {
+	if (typeof payload !== "string" || payload.length === 0) return null;
+	const parsed = parsePayloadObject(payload);
+	if (parsed !== null && "text" in parsed) return truncate(String(parsed.text), 60);
+	return truncate(payload, 60);
+};
+/** Narrow one processed-table row into a `DebugEvent`. */
+const toDebugEvent = (row) => {
+	const payload = stringOrNull(row.payload);
+	return {
+		seq: numberOrNull(row.seq),
+		ts: numberOrNull(row.ts),
+		type: stringOr(row.type, "?"),
+		outcome: stringOr(row.outcome, "?"),
+		eventId: stringOrNull(row.event_id),
+		payload,
+		payloadParsed: parsePayloadObject(payload),
+		preview: previewOf(row.payload)
+	};
+};
+/** Narrow one connection-table row into a `DebugConnectionError`. */
+const toDebugConnectionError = (row) => ({
+	seq: numberOrNull(row.seq),
+	ts: numberOrNull(row.ts),
+	type: stringOr(row.type, "?"),
+	status: stringOr(row.status, "?"),
+	detail: stringOrNull(row.detail)
+});
+/**
+* Open a reader, run one query, and always close — the shared shape behind
+* every diagnostic lookup. Returns the rows or the reader's `Error`.
+*/
+const queryRows = (reader, sql, params) => {
+	try {
+		return reader.query(sql, params);
+	} finally {
+		reader.close();
+	}
+};
+//#endregion
+//#region lib/cli/routes/debug.ts
+const debugHelp = `funnel debug — diagnose why Claude is not receiving events
+
+usage: funnel debug [subcommand] [--channel <name>] [--all] [--json]
+
+subcommands:
+  (none)                full diagnosis (gateway + listener + Claude + last 5 events)
+  events                last N processed events with outcome and preview
+  dropped               events filtered out (skip:*) with payload detail
+  errors                listener connection errors (auth-failed, error)
+
+options:
+  --channel <name>      channel to inspect (auto-selected when only one exists)
+  --all                 diagnose all channels at once (JSON output)
+  --limit <N>           number of recent events to include (default: 5; events/dropped/errors default: 20)
+  --json                output as JSON (machine-readable, useful for Claude)
+
+when a listener is dead the diagnosis includes rootCause — the most recent
+connection error detail pulled from the connection log automatically.
+
+use --json when asking Claude to analyse the output — it returns structured
+data that Claude can parse without guessing at text formatting.
+
+examples:
+  funnel debug
+  funnel debug --all --json
+  funnel debug --channel open-karte
+  funnel debug --channel open-karte --json
+  funnel debug events --channel open-karte --limit 50
+  funnel debug dropped --channel open-karte --json
+  funnel debug errors`;
+const debugEventsHelp = `funnel debug events — last N processed events with outcome and preview
+
+usage: funnel debug events [--channel <name>] [--limit <N>] [--json]
+
+options:
+  --channel <name>      channel to inspect (auto-selected when only one exists)
+  --limit <N>           number of rows (default: 20)
+  --json                output as JSON
+
+examples:
+  funnel debug events
+  funnel debug events --channel open-karte --limit 50
+  funnel debug events --json`;
+const debugDroppedHelp = `funnel debug dropped — events filtered out (skip:*)
+
+usage: funnel debug dropped [--channel <name>] [--limit <N>] [--json]
+
+options:
+  --channel <name>      channel to inspect (auto-selected when only one exists)
+  --limit <N>           number of rows (default: 20)
+  --json                output as JSON
+
+shows why events were skipped: skip:type, skip:subtype, skip:dedup,
+skip:self-user, skip:self-bot, skip:preprocess
+
+examples:
+  funnel debug dropped
+  funnel debug dropped --channel open-karte --json`;
+const debugErrorsHelp = `funnel debug errors — listener connection errors
+
+usage: funnel debug errors [--channel <name>] [--limit <N>] [--json]
+
+options:
+  --channel <name>      channel to inspect (auto-selected when only one exists)
+  --limit <N>           number of rows (default: 20)
+  --json                output as JSON
+
+shows auth-failed and error events from the connection lifecycle log.
+use this when a listener never connects or keeps disconnecting.
+
+examples:
+  funnel debug errors
+  funnel debug errors --channel open-karte`;
+const isGatewayStatusResponse = (value) => {
+	if (value === null || typeof value !== "object") return false;
+	if (!("clients" in value) || !Array.isArray(value.clients)) return false;
+	if (!("listeners" in value) || !Array.isArray(value.listeners)) return false;
+	return true;
+};
+const formatUptime = (ms) => {
+	const sec = Math.floor(ms / 1e3);
+	const min = Math.floor(sec / 60);
+	if (min >= 60) return `${Math.floor(min / 60)}h ${min % 60}m`;
+	if (sec >= 60) return `${min}m ${sec % 60}s`;
+	return `${sec}s`;
+};
+const formatTs = (epochMs) => {
+	if (typeof epochMs !== "number") return "?";
+	return new Date(epochMs).toISOString().slice(11, 19);
+};
+const buildDiagnosis = (report) => {
+	const rootCause = (report.connectionErrors[report.connectionErrors.length - 1] ?? null)?.detail ?? null;
+	if (!report.gateway.running) return {
+		status: "error",
+		message: "gateway is not running",
+		nextActions: ["fnl gateway start"],
+		rootCause: null
+	};
+	const channel = report.channel;
+	if (!(report.listeners.length > 0)) return {
+		status: "warn",
+		message: "no connectors configured on this channel",
+		nextActions: [`fnl channels ${channel} connectors add <name> --type=slack ...`],
+		rootCause: null
+	};
+	const allDead = report.listeners.every((l) => !l.alive);
+	const someDead = report.listeners.some((l) => !l.alive);
+	if (allDead) return {
+		status: "error",
+		message: "all listeners are dead",
+		nextActions: ["fnl gateway logs", "fnl gateway restart"],
+		rootCause
+	};
+	if (someDead) return {
+		status: "warn",
+		message: "some listeners are dead",
+		nextActions: ["fnl gateway logs"],
+		rootCause
+	};
+	const hasErrors = report.listeners.some((l) => l.errors > 0);
+	if (report.claudeClients === 0) return {
+		status: "warn",
+		message: "no Claude connected to this channel",
+		nextActions: [`fnl claude --channel ${channel}`],
+		rootCause: null
+	};
+	if (hasErrors) return {
+		status: "warn",
+		message: "listeners have errors",
+		nextActions: ["fnl gateway logs"],
+		rootCause
+	};
+	return {
+		status: "ok",
+		message: "everything looks healthy",
+		nextActions: [],
+		rootCause: null
+	};
+};
+const renderText = (report) => {
+	const lines = [];
+	lines.push(`= funnel debug: ${report.channel} =`);
+	lines.push("");
+	const gw = report.gateway;
+	if (!gw.running) lines.push("[gateway]    ○ not running");
+	else {
+		const uptime = gw.uptimeMs !== null ? ` · up ${formatUptime(gw.uptimeMs)}` : "";
+		lines.push(`[gateway]    ● running  pid ${gw.pid} · port ${gw.port}${uptime}`);
+	}
+	if (report.listeners.length === 0) lines.push("[listener]   - no listener");
+	else for (const listener of report.listeners) {
+		const indicator = listener.alive ? "●" : "○";
+		const state = listener.alive ? "alive " : "dead  ";
+		const eventsStr = `${listener.events} events`;
+		const lastStr = listener.lastEventAt ? ` · last ${listener.lastEventAt.slice(11, 19)}` : "";
+		const errStr = listener.errors > 0 ? ` · ⚠ ${listener.errors} errors` : "";
+		lines.push(`[listener]   ${indicator} ${state} ${eventsStr}${lastStr}${errStr}`);
+	}
+	const claudeCount = report.claudeClients;
+	if (claudeCount === 0) lines.push("[claude]     ○ not connected");
+	else lines.push(`[claude]     ● connected (${claudeCount} WS client${claudeCount > 1 ? "s" : ""})`);
+	if (report.recentEvents.length === 0) lines.push("[events]     no events recorded");
+	else {
+		lines.push(`[events]     last ${report.recentEvents.length} event${report.recentEvents.length > 1 ? "s" : ""}:`);
+		for (const event of report.recentEvents) {
+			const time = formatTs(event.ts);
+			const type = event.type.padEnd(8);
+			const outcome = event.outcome.padEnd(20);
+			const preview = event.preview ? ` "${event.preview}"` : "";
+			const seq = event.seq !== null ? ` (seq=${event.seq})` : "";
+			lines.push(`               ${time}  ${type} ${outcome}${preview}${seq}`);
+		}
+	}
+	if (report.connectionErrors.length > 0) {
+		lines.push("[conn errs]  recent connection errors:");
+		for (const err of report.connectionErrors) {
+			const time = formatTs(err.ts);
+			const status = err.status.padEnd(14);
+			const detail = err.detail ? ` "${err.detail}"` : "";
+			lines.push(`               ${time}  ${err.type.padEnd(8)}  ${status}${detail}`);
+		}
+	}
+	lines.push("");
+	const diag = report.diagnosis;
+	const icon = diag.status === "ok" ? "✓" : diag.status === "warn" ? "⚠" : "✗";
+	lines.push(`diagnosis: ${icon} ${diag.message}`);
+	if (diag.rootCause) lines.push(`  root cause: ${diag.rootCause}`);
+	for (const action of diag.nextActions) lines.push(`  → ${action}`);
+	return lines.join("\n");
+};
+const resolveStoreOrNull = () => {
+	const tmpDir = funnelTmpDir();
+	const rawPath = join(tmpDir, "connector-raw.db");
+	const processedPath = join(tmpDir, "connector-processed.db");
+	const connectionPath = join(tmpDir, "connector-connection.db");
+	if (!existsSync(rawPath) || !existsSync(processedPath) || !existsSync(connectionPath)) return null;
+	return {
+		rawPath,
+		processedPath,
+		connectionPath
+	};
+};
+/**
+* Resolve the connector name for a connector id on a channel, used to attribute
+* a replayed event back to its source connector. Returns undefined when the id
+* is null or no longer present (connectors can be removed after an event was
+* logged).
+*/
+const connectorOf = (channel, connectorId) => {
+	if (connectorId === null) return void 0;
+	return channel.connectors?.find((connector) => connector.id === connectorId)?.name;
+};
+const resolveChannelId = (channels, channelName) => {
+	if (channelName) {
+		const match = channels.find((ch) => ch.name === channelName);
+		if (match) return {
+			found: true,
+			channel: match
+		};
+		return {
+			found: false,
+			reason: "not-found",
+			name: channelName
+		};
+	}
+	if (channels.length === 1 && channels[0]) return {
+		found: true,
+		channel: channels[0]
+	};
+	if (channels.length === 0) return {
+		found: false,
+		reason: "none"
+	};
+	return {
+		found: false,
+		reason: "ambiguous",
+		names: channels.map((ch) => ch.name)
+	};
+};
+const debugEventsHandler = factory.createHandlers(zValidator$1("query", z.object({
+	channel: z.string().optional(),
+	limit: z.string().optional(),
+	json: z.enum([
+		"true",
+		"false",
+		""
+	]).optional()
+}), debugEventsHelp), async (c) => {
+	const query = c.req.valid("query");
+	const channels = c.env.funnel.channels.list();
+	const isJson = query.json === "true" || query.json === "";
+	const limit = query.limit ? Math.max(1, Number(query.limit)) : 20;
+	const store = resolveStoreOrNull();
+	if (!store) {
+		if (isJson) return c.json([]);
+		return c.text("no diagnostic store yet (start the gateway first)");
+	}
+	const resolved = resolveChannelId(channels, query.channel);
+	if (!resolved.found) {
+		if (resolved.reason === "not-found") {
+			if (isJson) return c.json({
+				error: `channel not found: ${resolved.name}`,
+				availableChannels: channels.map((ch) => ch.name)
+			});
+			return c.text(`channel not found: ${resolved.name}`);
+		}
+		if (resolved.reason === "ambiguous") {
+			if (isJson) return c.json({
+				error: "multiple channels — specify one with --channel",
+				channels: resolved.names
+			});
+			return c.text(`multiple channels — specify one with --channel:\n${resolved.names.map((n) => `  - ${n}`).join("\n")}`);
+		}
+		if (isJson) return c.json([]);
+		return c.text("no channels configured");
+	}
+	const channel = resolved.channel;
+	const reader = new ConnectorDiagnosticSqlReader(store);
+	const rows = channel ? queryRows(reader, "SELECT seq, ts, type, outcome, payload FROM processed WHERE channel_id = ? ORDER BY seq DESC LIMIT ?", [channel.id, limit]) : queryRows(reader, "SELECT seq, ts, type, outcome, payload FROM processed ORDER BY seq DESC LIMIT ?", [limit]);
+	if (rows instanceof Error) return c.text(`error: ${rows.message}`);
+	const events = rows.reverse().map(toDebugEvent);
+	if (isJson) return c.json(events);
+	if (events.length === 0) return c.text("no events recorded");
+	const lines = events.map((ev) => {
+		const time = formatTs(ev.ts);
+		const type = ev.type.padEnd(8);
+		const outcome = ev.outcome.padEnd(20);
+		const preview = ev.preview ? `  "${ev.preview}"` : "";
+		return `${time}  ${type}  ${outcome}${ev.seq !== null ? `  seq=${ev.seq}` : ""}${preview}`;
+	});
+	return c.text(lines.join("\n"));
+});
+const debugDroppedHandler = factory.createHandlers(zValidator$1("query", z.object({
+	channel: z.string().optional(),
+	limit: z.string().optional(),
+	json: z.enum([
+		"true",
+		"false",
+		""
+	]).optional()
+}), debugDroppedHelp), async (c) => {
+	const query = c.req.valid("query");
+	const channels = c.env.funnel.channels.list();
+	const isJson = query.json === "true" || query.json === "";
+	const limit = query.limit ? Math.max(1, Number(query.limit)) : 20;
+	const store = resolveStoreOrNull();
+	if (!store) {
+		if (isJson) return c.json([]);
+		return c.text("no diagnostic store yet (start the gateway first)");
+	}
+	const resolvedDropped = resolveChannelId(channels, query.channel);
+	if (!resolvedDropped.found) {
+		if (resolvedDropped.reason === "not-found") {
+			if (isJson) return c.json({
+				error: `channel not found: ${resolvedDropped.name}`,
+				availableChannels: channels.map((ch) => ch.name)
+			});
+			return c.text(`channel not found: ${resolvedDropped.name}`);
+		}
+		if (resolvedDropped.reason === "ambiguous") {
+			if (isJson) return c.json({
+				error: "multiple channels — specify one with --channel",
+				channels: resolvedDropped.names
+			});
+			return c.text(`multiple channels — specify one with --channel:\n${resolvedDropped.names.map((n) => `  - ${n}`).join("\n")}`);
+		}
+		if (isJson) return c.json([]);
+		return c.text("no channels configured");
+	}
+	const channel = resolvedDropped.channel;
+	const reader = new ConnectorDiagnosticSqlReader(store);
+	const rows = channel ? queryRows(reader, "SELECT p.seq, p.ts, p.type, p.outcome, p.payload, p.event_id FROM processed p WHERE p.channel_id = ? AND p.outcome LIKE 'skip:%' ORDER BY p.seq DESC LIMIT ?", [channel.id, limit]) : queryRows(reader, "SELECT seq, ts, type, outcome, payload, event_id FROM processed WHERE outcome LIKE 'skip:%' ORDER BY seq DESC LIMIT ?", [limit]);
+	if (rows instanceof Error) return c.text(`error: ${rows.message}`);
+	const events = rows.reverse().map(toDebugEvent);
+	if (isJson) return c.json(events);
+	if (events.length === 0) return c.text("no dropped events recorded");
+	const lines = events.map((ev) => {
+		return `${formatTs(ev.ts)}  ${ev.type.padEnd(8)}  ${ev.outcome.padEnd(20)}${ev.seq !== null ? `  seq=${ev.seq}` : ""}${ev.eventId ? `  event_id=${ev.eventId.slice(0, 8)}` : ""}${ev.preview ? `  "${ev.preview}"` : ""}`;
+	});
+	return c.text(lines.join("\n"));
+});
+const debugErrorsHandler = factory.createHandlers(zValidator$1("query", z.object({
+	channel: z.string().optional(),
+	limit: z.string().optional(),
+	json: z.enum([
+		"true",
+		"false",
+		""
+	]).optional()
+}), debugErrorsHelp), async (c) => {
+	const query = c.req.valid("query");
+	const channels = c.env.funnel.channels.list();
+	const isJson = query.json === "true" || query.json === "";
+	const limit = query.limit ? Math.max(1, Number(query.limit)) : 20;
+	const store = resolveStoreOrNull();
+	if (!store) {
+		if (isJson) return c.json([]);
+		return c.text("no diagnostic store yet (start the gateway first)");
+	}
+	const resolvedErrors = resolveChannelId(channels, query.channel);
+	if (!resolvedErrors.found) {
+		if (resolvedErrors.reason === "not-found") {
+			if (isJson) return c.json({
+				error: `channel not found: ${resolvedErrors.name}`,
+				availableChannels: channels.map((ch) => ch.name)
+			});
+			return c.text(`channel not found: ${resolvedErrors.name}`);
+		}
+		if (resolvedErrors.reason === "ambiguous") {
+			if (isJson) return c.json({
+				error: "multiple channels — specify one with --channel",
+				channels: resolvedErrors.names
+			});
+			return c.text(`multiple channels — specify one with --channel:\n${resolvedErrors.names.map((n) => `  - ${n}`).join("\n")}`);
+		}
+		if (isJson) return c.json([]);
+		return c.text("no channels configured");
+	}
+	const channel = resolvedErrors.channel;
+	const reader = new ConnectorDiagnosticSqlReader(store);
+	const rows = channel ? queryRows(reader, "SELECT seq, ts, type, status, detail FROM connection WHERE channel_id = ? AND status IN ('auth-failed','error') ORDER BY seq DESC LIMIT ?", [channel.id, limit]) : queryRows(reader, "SELECT seq, ts, type, status, detail FROM connection WHERE status IN ('auth-failed','error') ORDER BY seq DESC LIMIT ?", [limit]);
+	if (rows instanceof Error) return c.text(`error: ${rows.message}`);
+	const errors = rows.reverse().map(toDebugConnectionError);
+	if (isJson) return c.json(errors);
+	if (errors.length === 0) return c.text("no connection errors recorded");
+	const lines = errors.map((ev) => {
+		return `${formatTs(ev.ts)}  ${ev.type.padEnd(8)}  ${ev.status.padEnd(16)}${ev.detail ? `  "${ev.detail}"` : ""}`;
+	});
+	return c.text(lines.join("\n"));
+});
+const buildChannelReport = async (targetChannel, gatewayStatus, gatewayBodyOrNull, store, limit = 5) => {
+	const targetChannelName = targetChannel.name;
+	const baseReport = {
+		channel: targetChannelName,
+		channelId: targetChannel.id,
+		gateway: {
+			running: gatewayStatus.running,
+			pid: gatewayStatus.pid,
+			port: gatewayStatus.running ? gatewayStatus.port : null,
+			uptimeMs: gatewayBodyOrNull?.uptimeMs ?? null
+		},
+		listeners: [],
+		claudeClients: 0,
+		recentEvents: [],
+		connectionErrors: []
+	};
+	if (gatewayBodyOrNull) {
+		baseReport.listeners = gatewayBodyOrNull.listeners.filter((l) => l.channelName === targetChannelName).map((l) => ({
+			name: l.name,
+			type: l.type,
+			alive: l.alive,
+			events: l.events,
+			errors: l.errors,
+			lastEventAt: l.lastEventAt
+		}));
+		baseReport.claudeClients = gatewayBodyOrNull.clients.filter((cl) => !cl.tapAll && cl.channelName === targetChannelName).length;
+	}
+	if (store) {
+		const evRows = queryRows(new ConnectorDiagnosticSqlReader(store), "SELECT seq, ts, type, outcome, payload FROM processed WHERE channel_id = ? ORDER BY seq DESC LIMIT ?", [targetChannel.id, limit]);
+		if (!(evRows instanceof Error)) baseReport.recentEvents = evRows.reverse().map(toDebugEvent);
+		const hasDeadListeners = baseReport.listeners.some((l) => !l.alive);
+		const hasListenerErrors = baseReport.listeners.some((l) => l.errors > 0);
+		if (hasDeadListeners || hasListenerErrors) {
+			const errRows = queryRows(new ConnectorDiagnosticSqlReader(store), "SELECT ts, type, status, detail FROM connection WHERE channel_id = ? AND status IN ('auth-failed','error') ORDER BY seq DESC LIMIT 3", [targetChannel.id]);
+			if (!(errRows instanceof Error)) baseReport.connectionErrors = errRows.reverse().map(toDebugConnectionError);
+		}
+	}
+	return {
+		...baseReport,
+		diagnosis: buildDiagnosis(baseReport)
+	};
+};
+const debugHandler = factory.createHandlers(zValidator$1("query", z.object({
+	channel: z.string().optional(),
+	all: z.enum([
+		"true",
+		"false",
+		""
+	]).optional(),
+	json: z.enum([
+		"true",
+		"false",
+		""
+	]).optional(),
+	limit: z.string().optional()
+}), debugHelp), async (c) => {
+	const query = c.req.valid("query");
+	const funnel = c.env.funnel;
+	const channels = funnel.channels.list();
+	const gatewayStatus = funnel.gateway.getStatus();
+	const isJson = query.json === "true" || query.json === "";
+	const isAll = query.all === "true" || query.all === "";
+	const eventLimit = query.limit ? Math.max(1, Number(query.limit)) : 5;
+	if (channels.length === 0) {
+		if (isJson) return c.json({
+			error: "no channels configured",
+			nextAction: "fnl channels add <name>"
+		});
+		return c.text("no channels configured — run: fnl channels add <name>");
+	}
+	const token = funnel.gatewayToken.read();
+	const headers = token ? { Authorization: `Bearer ${token}` } : {};
+	let gatewayBodyOrNull = null;
+	if (gatewayStatus.running) {
+		const res = await fetch(`http://127.0.0.1:${gatewayStatus.port}/status`, { headers }).catch(() => null);
+		if (res && res.ok) {
+			const body = await res.json();
+			if (isGatewayStatusResponse(body)) gatewayBodyOrNull = body;
+		}
+	}
+	const store = resolveStoreOrNull();
+	if (isAll) {
+		const reports = await Promise.all(channels.map((ch) => buildChannelReport(ch, gatewayStatus, gatewayBodyOrNull, store, eventLimit)));
+		const errorChannels = reports.filter((r) => r.diagnosis.status === "error").map((r) => r.channel);
+		const warnChannels = reports.filter((r) => r.diagnosis.status === "warn").map((r) => r.channel);
+		const okChannels = reports.filter((r) => r.diagnosis.status === "ok").map((r) => r.channel);
+		const uniqueActions = [...new Set(reports.flatMap((r) => r.diagnosis.nextActions))];
+		return c.json({
+			summary: {
+				total: reports.length,
+				ok: okChannels.length,
+				warn: warnChannels.length,
+				error: errorChannels.length,
+				criticalChannels: errorChannels,
+				warnChannels,
+				suggestedActions: uniqueActions
+			},
+			channels: reports
+		});
+	}
+	let targetChannel = null;
+	if (query.channel) {
+		targetChannel = channels.find((ch) => ch.name === query.channel) ?? null;
+		if (!targetChannel) {
+			if (isJson) return c.json({
+				error: `channel not found: ${query.channel}`,
+				availableChannels: channels.map((ch) => ch.name)
+			});
+			return c.text(`channel not found: ${query.channel}`);
+		}
+	} else if (channels.length === 1 && channels[0]) targetChannel = channels[0];
+	else {
+		const names = channels.map((ch) => ch.name);
+		if (isJson) return c.json({
+			error: "multiple channels — specify one with --channel or use --all",
+			channels: names,
+			hint: "use --all for all channels at once"
+		});
+		return c.text(`multiple channels — specify one with --channel or use --all:\n${names.map((n) => `  - ${n}`).join("\n")}`);
+	}
+	const report = await buildChannelReport(targetChannel, gatewayStatus, gatewayBodyOrNull, store, eventLimit);
+	if (isJson) return c.json(report);
+	return c.text(renderText(report));
+});
+const debugReplayHandler = factory.createHandlers(zValidator$1("query", z.object({
+	channel: z.string().optional(),
+	seq: z.string().optional(),
+	json: z.enum([
+		"true",
+		"false",
+		""
+	]).optional()
+}), `funnel debug replay — re-publish a past event into a channel
+
+usage: funnel debug replay --channel <name> [--seq <N>] [--json]
+
+options:
+  --channel <name>   channel to replay into (required when multiple channels exist)
+  --seq <N>          replay the event at this processed-table seq (default: most recent emitted)
+  --json             output result as JSON
+
+Re-sends a past event from the diagnostic store through the publisher path,
+so subscribers receive it again. Useful to verify that Claude handles an event
+correctly without waiting for a real external trigger.
+
+Gateway must be running. The event is injected via POST /channels/<name>/publish.
+
+examples:
+  fnl debug replay --channel open-karte
+  fnl debug replay --channel open-karte --seq 412
+  fnl debug replay --channel open-karte --json`), async (c) => {
+	const query = c.req.valid("query");
+	const funnel = c.env.funnel;
+	const channels = funnel.channels.list();
+	const isJson = query.json === "true" || query.json === "";
+	const resolved = resolveChannelId(channels, query.channel);
+	if (!resolved.found) {
+		if (resolved.reason === "not-found") {
+			if (isJson) return c.json({
+				error: `channel not found: ${resolved.name}`,
+				availableChannels: channels.map((ch) => ch.name)
+			});
+			return c.text(`channel not found: ${resolved.name}`);
+		}
+		if (resolved.reason === "ambiguous") {
+			if (isJson) return c.json({
+				error: "multiple channels — specify one with --channel",
+				channels: resolved.names
+			});
+			return c.text(`multiple channels — specify one with --channel:\n${resolved.names.map((n) => `  - ${n}`).join("\n")}`);
+		}
+		if (isJson) return c.json({ error: "no channels configured" });
+		return c.text("no channels configured");
+	}
+	const targetChannel = resolved.channel;
+	const store = resolveStoreOrNull();
+	if (!store) {
+		if (isJson) return c.json({ error: "no diagnostic store yet (start the gateway first)" });
+		return c.text("no diagnostic store yet (start the gateway first)");
+	}
+	const rows = query.seq ? queryRows(new ConnectorDiagnosticSqlReader(store), "SELECT seq, event_id, type, payload, connector_id, channel_id FROM processed WHERE channel_id = ? AND seq = ? LIMIT 1", [targetChannel.id, Number(query.seq)]) : queryRows(new ConnectorDiagnosticSqlReader(store), "SELECT seq, event_id, type, payload, connector_id, channel_id FROM processed WHERE channel_id = ? AND outcome LIKE 'emitted%' ORDER BY seq DESC LIMIT 1", [targetChannel.id]);
+	if (rows instanceof Error) {
+		if (isJson) return c.json({ error: rows.message });
+		return c.text(`error: ${rows.message}`);
+	}
+	const firstRow = rows[0];
+	if (!firstRow) {
+		if (isJson) return c.json({ error: "no matching event found" });
+		return c.text("no matching event found");
+	}
+	const seq = typeof firstRow.seq === "number" ? firstRow.seq : null;
+	const eventId = typeof firstRow.event_id === "string" ? firstRow.event_id : null;
+	const connectorId = typeof firstRow.connector_id === "string" ? firstRow.connector_id : null;
+	let content = typeof firstRow.payload === "string" ? firstRow.payload : null;
+	if ((!content || content.length === 0) && eventId) {
+		const rawRows = queryRows(new ConnectorDiagnosticSqlReader(store), "SELECT payload FROM raw WHERE event_id = ? LIMIT 1", [eventId]);
+		const rawRow = rawRows instanceof Error ? null : rawRows[0];
+		if (rawRow) content = typeof rawRow.payload === "string" ? rawRow.payload : null;
+	}
+	if (!content) {
+		if (isJson) return c.json({ error: "event has no payload to replay" });
+		return c.text("event has no payload to replay");
+	}
+	const connectorName = connectorOf(targetChannel, connectorId);
+	const result = await funnel.publisher.publish(targetChannel.name, {
+		content,
+		connector: connectorName
+	});
+	if (result.state === "offline") {
+		if (isJson) return c.json({
+			error: "gateway daemon is not running",
+			nextAction: "fnl gateway start"
+		});
+		return c.text("error: gateway daemon is not running — run: fnl gateway start");
+	}
+	if (result.state === "error") {
+		if (isJson) return c.json({ error: result.reason });
+		return c.text(`error: ${result.reason}`);
+	}
+	const preview = previewOf(content);
+	if (isJson) return c.json({
+		replayed: true,
+		seq,
+		offset: result.offset,
+		preview
+	});
+	return c.text(`replayed seq=${seq ?? "?"} → offset=${result.offset}${preview ? `  "${preview}"` : ""}`);
+});
+//#endregion
 //#region lib/cli/routes/gateway.ts
 const groupHelp$1 = `funnel gateway — manage the funnel daemon
 
-The gateway daemon hosts the WebSocket /ws (used by Claude MCP), the
-local web UI at /, and the listener supervisor that runs every
-connector. One daemon, one port (9742), one PID file.
+The gateway daemon hosts the WebSocket /ws (used by Claude MCP) and the
+listener supervisor that runs every connector. One daemon, one port (9743
+for the CLI, 9742 for programmatic use), one PID file.
 
 usage: funnel gateway [subcommand]
 
@@ -5177,20 +6395,49 @@ subcommands:
   restart             stop then start
   run                 start in foreground (for developers)
   logs [-n <N>]       tail the daemon diagnostic log (lifecycle, listener boot)
-  sql --query "<SQL>" query inbound connector traffic (raw + processed verdict)
+  sql                 query inbound connector traffic (raw + processed verdict)
   listeners           list running connector listeners (alive / dead)
 
 examples:
-  funnel gateway                check status
-  funnel gateway restart        restart`;
+  funnel gateway                    check status
+  funnel gateway restart            restart after config changes
+  funnel gateway logs               stream the daemon log
+  funnel gateway sql --preset recent  inspect last 20 inbound events
+
+see also: fnl debug --channel <name>  (higher-level diagnosis with next-action hints)`;
 const renderGatewayStatus = async (c) => {
-	const status = c.var.funnel.gateway.getStatus();
+	const status = c.env.funnel.gateway.getStatus();
 	if (!status.running) throw new HTTPException(503, { message: "funnel gateway: not running" });
-	const res = await fetch(`http://127.0.0.1:${status.port}/health`).catch(() => null);
+	const res = await fetch(`http://127.0.0.1:${status.port}/status`).catch(() => null);
 	if (!res) return c.text(`funnel gateway: running (pid ${status.pid}) — health check failed`);
-	const health = await res.json();
-	const clients = health !== null && typeof health === "object" && "clients" in health ? health.clients : 0;
-	return c.text(`funnel gateway: running (pid ${status.pid})\n  port: ${status.port}\n  clients: ${clients ?? 0}`);
+	const data = await res.json();
+	const lines = [];
+	lines.push(`funnel gateway: running (pid ${data.pid})`);
+	lines.push(`  port:   ${status.port}`);
+	const uptimeSec = Math.floor(data.uptimeMs / 1e3);
+	const uptimeMin = Math.floor(uptimeSec / 60);
+	const uptimeStr = uptimeMin >= 60 ? `${Math.floor(uptimeMin / 60)}h ${uptimeMin % 60}m` : uptimeSec >= 60 ? `${uptimeMin}m ${uptimeSec % 60}s` : `${uptimeSec}s`;
+	lines.push(`  uptime: ${uptimeStr}`);
+	lines.push(`  events: ${data.broadcaster.eventsBroadcast} broadcast`);
+	if (data.listeners.length === 0) lines.push(`  listeners: none`);
+	else {
+		lines.push(`  listeners:`);
+		for (const l of data.listeners) {
+			const indicator = l.alive ? "●" : "○";
+			const eventsStr = l.events > 0 ? ` (${l.events} events)` : "";
+			const errStr = l.errors > 0 ? ` ⚠ ${l.errors} errors` : "";
+			lines.push(`    ${indicator} ${l.channelName}/${l.name} [${l.type}]${eventsStr}${errStr}`);
+		}
+	}
+	if (data.clients.length === 0) lines.push(`  clients: none`);
+	else {
+		lines.push(`  clients: ${data.clients.length}`);
+		for (const cl of data.clients) {
+			const connectors = cl.connectors.length > 0 ? ` → ${cl.connectors.join(", ")}` : "";
+			lines.push(`    · ${cl.channel}${connectors}`);
+		}
+	}
+	return c.text(lines.join("\n"));
 };
 const gatewayGroupHandler = factory.createHandlers(zValidator$1("query", z.object({}), groupHelp$1), renderGatewayStatus);
 const gatewayListenersHandler = factory.createHandlers(zValidator$1("query", z.object({}), `funnel gateway listeners — show running connector listeners
@@ -5201,7 +6448,7 @@ Reads /listeners from the running gateway daemon and prints the live registry.
 
 examples:
   funnel gateway listeners`), async (c) => {
-	const result = await c.var.funnel.listeners.list();
+	const result = await c.env.funnel.listeners.list();
 	if (result.state === "offline") throw new HTTPException(503, { message: "funnel gateway: not running" });
 	if (result.state === "error") throw new HTTPException(503, { message: `funnel gateway: ${result.reason}` });
 	if (result.listeners.length === 0) return c.text("funnel gateway: no running listeners");
@@ -5212,24 +6459,31 @@ examples:
 });
 //#endregion
 //#region lib/cli/routes/gateway.logs.ts
-const logsHelp = `funnel gateway logs — tail diagnostic logs
+const logsHelp = `funnel gateway logs — tail the daemon diagnostic log
 
-usage: funnel gateway logs [-n <N>]
+usage: funnel gateway logs [-n <N>] [--format <plain|json>]
 
 options:
   -n <N>                number of trailing lines to show (default: 20)
+  --format <plain|json> output format (default: plain)
 
-Tails ${join(funnelTmpDir(), "funnel.log")} (the daemon's diagnostic stream — gateway
-lifecycle, channel connect/disconnect, listener boot). Exit with SIGINT.
-Output is formatted as YAML.
+Streams ${join(funnelTmpDir(), "funnel.log")} — the daemon's diagnostic stream covering
+gateway lifecycle, listener start/stop/error, and WebSocket connect/disconnect.
+Exit with Ctrl-C.
 
-Domain events fanned out to WebSocket clients live in the SQLite event
-store (${join(funnelTmpDir(), "events.db")}); they are not shown here. Subscribe via
-the WS endpoint or query the store directly.
+plain format:  HH:MM:SS LEVEL  message               key=value ...
+json format:   raw JSON lines (pipe to jq for filtering)
+
+This log does NOT contain inbound Slack/connector events. For those, use:
+  fnl gateway sql --preset recent      last 20 processed events
+  fnl debug --channel <name>           per-channel diagnosis with outcome summary
 
 examples:
   funnel gateway logs
-  funnel gateway logs -n 100`;
+  funnel gateway logs -n 100
+  funnel gateway logs --format json | jq 'select(.level == "error")'
+
+see also: fnl debug, fnl gateway sql`;
 const logger = new NodeFunnelLogger();
 const tryParseJson = (line) => {
 	try {
@@ -5245,11 +6499,27 @@ const isLogEntry = (value) => {
 	if (!("message" in value) || typeof value.message !== "string") return false;
 	return true;
 };
-const gatewayLogsHandler = factory.createHandlers(zValidator$1("query", z.object({ n: z.string().optional() }), logsHelp), async (c) => {
+const formatMetaValue = (value) => {
+	const str = typeof value === "string" ? value : JSON.stringify(value);
+	return str.includes(" ") ? `"${str}"` : str;
+};
+const formatMeta = (meta) => {
+	if (meta === null || typeof meta !== "object") return "";
+	const pairs = Object.entries(meta).map(([k, v]) => `${k}=${formatMetaValue(v)}`).join(" ");
+	return pairs ? ` ${pairs}` : "";
+};
+const formatPlain = (entry) => {
+	return `${entry.time.slice(11, 19)} ${entry.level.toUpperCase().padEnd(5)} ${entry.message.padEnd(30)}${formatMeta(entry.meta)}\n`;
+};
+const gatewayLogsHandler = factory.createHandlers(zValidator$1("query", z.object({
+	n: z.string().optional(),
+	format: z.enum(["plain", "json"]).optional()
+}), logsHelp), async (c) => {
 	const query = c.req.valid("query");
 	const path = logger.file;
 	if (!path || !existsSync(path)) return c.text("no logs");
 	const lineCount = query.n ? Number(query.n) : 20;
+	const format = query.format ?? "plain";
 	const tail = Bun.spawn([
 		"tail",
 		"-f",
@@ -5268,7 +6538,6 @@ const gatewayLogsHandler = factory.createHandlers(zValidator$1("query", z.object
 	const reader = tail.stdout.getReader();
 	const decoder = new TextDecoder();
 	let buffer = "";
-	logger.info("gateway.logs tail start", { file: path });
 	while (true) {
 		const result = await reader.read();
 		if (result.done) break;
@@ -5282,13 +6551,8 @@ const gatewayLogsHandler = factory.createHandlers(zValidator$1("query", z.object
 				process.stdout.write(`${line}\n`);
 				continue;
 			}
-			const output = {
-				time: parsed.time,
-				level: parsed.level,
-				message: parsed.message,
-				...parsed.meta ? { meta: parsed.meta } : {}
-			};
-			process.stdout.write(`---\n${stringify(output)}`);
+			if (format === "json") process.stdout.write(`${JSON.stringify(parsed)}\n`);
+			else process.stdout.write(formatPlain(parsed));
 		}
 	}
 	await tail.exited;
@@ -5296,47 +6560,78 @@ const gatewayLogsHandler = factory.createHandlers(zValidator$1("query", z.object
 });
 //#endregion
 //#region lib/cli/routes/gateway.sql.ts
+const PRESETS = {
+	recent: "SELECT seq, ts, type, outcome FROM processed ORDER BY seq DESC LIMIT 20",
+	skipped: "SELECT seq, ts, type, outcome, payload FROM processed WHERE outcome LIKE 'skip:%' ORDER BY seq DESC LIMIT 20",
+	errors: "SELECT ts, status, detail FROM connection WHERE status IN ('auth-failed','error') ORDER BY seq DESC LIMIT 20",
+	summary: "SELECT outcome, COUNT(*) AS count FROM processed GROUP BY outcome ORDER BY count DESC",
+	"trace-dedup": "SELECT r.seq, r.ts, r.event_id, r.payload FROM raw r JOIN processed p USING(event_id) WHERE p.outcome='skip:dedup' ORDER BY r.seq DESC LIMIT 20"
+};
 const sqlHelp = `funnel gateway sql — query inbound connector traffic with SQL
 
-usage: funnel gateway sql --query "<SELECT ...>"
+usage: funnel gateway sql --preset <name> [--channel <name|id>] [--limit <N>]
+       funnel gateway sql --query "<SELECT ...>"
+
+options:
+  --preset <name>       run a named preset (quickest starting point)
+  --channel <name|id>   filter preset results by channel name or id
+  --limit <N>           override the row limit for presets (default: 20)
+  --query "<SQL>"       run a custom SELECT; output is JSON
 
-Runs one read-only SELECT against the daemon's diagnostic store of inbound
-connector events and prints the rows as JSON. Use it to answer "Slack
-delivered an event, so why was there no notification?".
+quick-start presets (--preset <name>):
+  recent        last N processed events — type, outcome, preview
+  skipped       last N events filtered out (skip:*) — see why events were dropped
+  errors        listener auth-failed or error events — start here for connection failures
+  summary       outcome counts grouped by type — high-level health snapshot (no limit)
+  trace-dedup   raw payload of events dropped as duplicates
 
-Three views:
-  raw         every inbound event, untouched, before any filtering
-  processed   the verdict for that event after the per-type processor ran
-  connection  the listener lifecycle (so you can tell events never arrived)
+Output is always JSON — pipe to jq or pass directly to Claude.
 
-Shared columns (all three views):
-  seq           row id within the view (not comparable across views)
-  ts            epoch milliseconds
-  type          connector kind: slack | discord | gh | schedule
-  connector_id  funnel connector id
-  channel_id    funnel channel id
-raw and processed also have:
-  event_id      correlation id shared by an event's raw and processed rows
-  payload       raw: the original event JSON (text); processed: the delivered body, or "" when skipped
-processed also has:
-  outcome       'emitted' | 'emitted:delivery-failed' | 'skip:<reason>'
-                (skip reasons: skip:type, skip:subtype, skip:dedup,
-                 skip:self-user, skip:self-bot, skip:preprocess)
-connection also has:
-  status        'started' | 'connected' | 'disconnected' | 'auth-failed' | 'stopped' | 'error'
-  detail        an error message or reason, or "" when none
+three SQL views (for --query):
+  raw         every inbound event before filtering (payload = original JSON)
+  processed   filter verdict per event (outcome: emitted | skip:<reason>)
+  connection  listener lifecycle (status: connected | auth-failed | error | ...)
 
-To trace one event end to end, join raw and processed on event_id. When the
-event tables are empty, query connection — a listener that never connected, or
-failed auth, explains why nothing arrived.
+common join: SELECT r.payload FROM raw r JOIN processed p USING(event_id) WHERE p.outcome = 'skip:dedup'
+
+skip reasons: skip:type  skip:subtype  skip:dedup  skip:self-user  skip:self-bot  skip:preprocess
 
 examples:
-  funnel gateway sql --query "SELECT event_id, ts, type FROM raw ORDER BY seq DESC LIMIT 20"
+  funnel gateway sql --preset recent
+  funnel gateway sql --preset recent --limit 100
+  funnel gateway sql --preset skipped --channel open-karte
+  funnel gateway sql --preset errors
+  funnel gateway sql --preset summary
   funnel gateway sql --query "SELECT outcome, COUNT(*) n FROM processed GROUP BY outcome"
-  funnel gateway sql --query "SELECT r.payload FROM raw r JOIN processed p USING(event_id) WHERE p.outcome='skip:dedup'"
-  funnel gateway sql --query "SELECT ts, status, detail FROM connection WHERE status IN ('auth-failed','error') ORDER BY seq DESC"`;
-const gatewaySqlHandler = factory.createHandlers(zValidator$1("query", z.object({ query: z.string().optional() }), sqlHelp), async (c) => {
-	const sql = c.req.valid("query").query;
+
+tip: for a higher-level view without writing SQL, use: fnl debug --channel <name> --json
+
+see also: fnl debug, fnl gateway logs`;
+const gatewaySqlHandler = factory.createHandlers(zValidator$1("query", z.object({
+	query: z.string().optional(),
+	preset: z.enum(Object.keys(PRESETS)).optional(),
+	channel: z.string().optional(),
+	limit: z.string().optional()
+}), sqlHelp), async (c) => {
+	const query = c.req.valid("query");
+	const funnel = c.env.funnel;
+	let sql = null;
+	let params = [];
+	let resolvedChannelId = null;
+	if (query.channel) resolvedChannelId = funnel.channels.list().find((ch) => ch.id === query.channel || ch.name === query.channel)?.id ?? query.channel;
+	if (query.preset) {
+		const base = PRESETS[query.preset] ?? null;
+		if (!base) return c.text(sqlHelp);
+		let applied = base;
+		if (query.limit) {
+			const n = Math.max(1, Number(query.limit));
+			applied = applied.replace(/LIMIT \d+/, `LIMIT ${n}`);
+		}
+		if (resolvedChannelId) {
+			sql = applied.replace(/FROM (raw|processed|connection)\b/, "FROM $1 WHERE channel_id = ?");
+			params = [resolvedChannelId];
+		} else sql = applied;
+	} else if (query.query) sql = query.query;
 	if (!sql) return c.text(sqlHelp);
 	const tmpDir = funnelTmpDir();
 	const rawPath = join(tmpDir, "connector-raw.db");
@@ -5350,7 +6645,7 @@ const gatewaySqlHandler = factory.createHandlers(zValidator$1("query", z.object(
 	});
 	const rows = (() => {
 		try {
-			return reader.query(sql);
+			return reader.query(sql, params);
 		} finally {
 			reader.close();
 		}
@@ -5369,7 +6664,7 @@ examples:
   funnel gateway restart
   funnel gateway restart --no-caffeine`), async (c) => {
 	const query = c.req.valid("query");
-	const result = await c.var.funnel.gateway.restart({ caffeinate: query["no-caffeine"] !== "true" });
+	const result = await c.env.funnel.gateway.restart({ caffeinate: query["no-caffeine"] !== "true" });
 	const lines = [];
 	if (result.wasRunning) lines.push(result.stopped ? "funnel gateway: stopped" : "funnel gateway: failed to stop");
 	if (result.stopped) lines.push(result.started ? "funnel gateway: started" : "funnel gateway: failed to start");
@@ -5390,7 +6685,7 @@ examples:
   funnel gateway run
   funnel gateway run --no-caffeine`), async (c) => {
 	const query = c.req.valid("query");
-	const funnel = c.var.funnel;
+	const funnel = c.env.funnel;
 	const gatewayScript = resolveDaemonScript();
 	const command = query["no-caffeine"] !== "true" && process.platform === "darwin" ? [
 		"caffeinate",
@@ -5420,7 +6715,7 @@ examples:
   funnel gateway start --no-caffeine`;
 const gatewayStartHandler = factory.createHandlers(zValidator$1("query", z.object({ "no-caffeine": z.string().optional() }), startHelp), async (c) => {
 	const query = c.req.valid("query");
-	const funnel = c.var.funnel;
+	const funnel = c.env.funnel;
 	if (funnel.gateway.isRunning()) {
 		const status = funnel.gateway.getStatus();
 		return c.text(`funnel gateway: already running (pid ${status.pid})`);
@@ -5428,15 +6723,41 @@ const gatewayStartHandler = factory.createHandlers(zValidator$1("query", z.objec
 	if (!await funnel.gateway.start({ caffeinate: query["no-caffeine"] !== "true" })) throw new HTTPException(500, { message: "funnel gateway: failed to start" });
 	return c.text("funnel gateway: started");
 });
-const gatewayStatusHandler = factory.createHandlers(zValidator$1("query", z.object({}), `funnel gateway status — show gateway running status
+const gatewayStatusHandler = factory.createHandlers(zValidator$1("query", z.object({ json: z.enum([
+	"true",
+	"false",
+	""
+]).optional() }), `funnel gateway status — show gateway running status
+
+usage: funnel gateway status [--json]
 
-usage: funnel gateway status
+options:
+  --json   output as JSON
 
-When running, prints PID, port, and connected channel count. When not running, exits with 503.
+When running, prints PID, port, uptime, listeners (alive/dead), and WS clients.
+When not running, exits with 503.
 
 examples:
   funnel gateway status
-  funnel gateway`), renderGatewayStatus);
+  funnel gateway status --json`), async (c) => {
+	const query = c.req.valid("query");
+	if (!(query.json === "true" || query.json === "")) return renderGatewayStatus(c);
+	const status = c.env.funnel.gateway.getStatus();
+	if (!status.running) throw new HTTPException(503, { message: "funnel gateway: not running" });
+	const res = await fetch(`http://127.0.0.1:${status.port}/status`).catch(() => null);
+	if (!res) return c.json({
+		running: true,
+		pid: status.pid,
+		port: status.port,
+		error: "health check failed"
+	});
+	const data = await res.json();
+	return c.json({
+		running: true,
+		port: status.port,
+		...data
+	});
+});
 const gatewayStopHandler = factory.createHandlers(zValidator$1("query", z.object({}), `funnel gateway stop — stop the gateway
 
 usage: funnel gateway stop
@@ -5445,12 +6766,29 @@ Terminates the process whose PID is stored in ~/.funnel/gateway.pid.
 
 examples:
   funnel gateway stop`), async (c) => {
-	const funnel = c.var.funnel;
+	const funnel = c.env.funnel;
 	if (!funnel.gateway.isRunning()) return c.text("funnel gateway: no running process");
 	if (!await funnel.gateway.stop()) throw new HTTPException(500, { message: "funnel gateway: failed to stop" });
 	return c.text("funnel gateway: stopped");
 });
 //#endregion
+//#region lib/cli/routes/profiles.add.ts
+const help$4 = `funnel profiles add — add a profile
+
+usage: funnel profiles add <name> --path <path> --channel <channel-name> [recipe]
+
+options:
+  --path        working directory passed to claude as cwd
+  --channel     channel name (resolved to channel id internally)
+  --agent       sub-agent name, prepended to the launch argv as --agent <name>
+  --options     extra launch argv as one whitespace-split string (e.g. "--brief")
+  --env         env vars layered under the process, as "KEY=VAL,KEY2=VAL2"
+  --no-resume   start a fresh claude session every launch (default resumes)
+
+The launch recipe (--agent / --options / --env / --resume) lives on the
+profile; the channel only declares transport (connectors / delivery).`;
+const profilesAddHelpHandler = factory.createHandlers((c) => c.text(help$4));
+//#endregion
 //#region lib/cli/routes/parse-profile-recipe.ts
 /**
 * Turns the single-string CLI flags (`--agent`, `--options "<argv>"`,
@@ -5487,20 +6825,6 @@ const parseProfileRecipe = (query) => {
 };
 //#endregion
 //#region lib/cli/routes/profiles.add.$profile.ts
-const addHelp = `funnel profiles add — add a profile
-
-usage: funnel profiles add <name> --path <path> --channel <channel-name> [recipe]
-
-options:
-  --path        working directory passed to claude as cwd
-  --channel     channel name (resolved to channel id internally)
-  --agent       sub-agent name, prepended to the launch argv as --agent <name>
-  --options     extra launch argv as one whitespace-split string (e.g. "--brief")
-  --env         env vars layered under the process, as "KEY=VAL,KEY2=VAL2"
-  --no-resume   start a fresh claude session every launch (default resumes)
-
-The launch recipe (--agent / --options / --env / --resume) lives on the
-profile; the channel only declares transport (connectors / delivery).`;
 const profilesAddHandler = factory.createHandlers(zValidator$1("param", z.object({ profile: z.string() })), zValidator$1("query", z.object({
 	path: z.string(),
 	channel: z.string(),
@@ -5509,10 +6833,10 @@ const profilesAddHandler = factory.createHandlers(zValidator$1("param", z.object
 	env: z.string().optional(),
 	resume: z.string().optional(),
 	"no-resume": z.string().optional()
-}), addHelp), (c) => {
+})), (c) => {
 	const param = c.req.valid("param");
 	const query = c.req.valid("query");
-	const funnel = c.var.funnel;
+	const funnel = c.env.funnel;
 	const channel = funnel.channels.get(query.channel);
 	if (!channel) throw new HTTPException(400, { message: `channel "${query.channel}" not found` });
 	const recipe = parseProfileRecipe(query);
@@ -5532,22 +6856,33 @@ usage: funnel profiles <name> as-default
 
 the first profile in the list is treated as the default for fnl claude.`), (c) => {
 	const param = c.req.valid("param");
-	c.var.funnel.profiles.asDefault(param.profile);
+	c.env.funnel.profiles.asDefault(param.profile);
 	return c.text(`profile "${param.profile}" is now the default`);
 });
 //#endregion
-//#region lib/cli/routes/profiles.$profile.rename.$newName.ts
-const renameHelp = `funnel profiles rename — rename a profile
+//#region lib/cli/routes/profiles.rename.ts
+const help$3 = `funnel profiles rename — rename a profile
 
 usage:
   funnel profiles rename <old> <new>
   funnel profiles <old> rename <new>`;
+const profilesRenameHelpHandler = factory.createHandlers((c) => c.text(help$3));
+//#endregion
+//#region lib/cli/routes/profiles.$profile.rename.ts
+const help$2 = `funnel profiles rename — rename a profile
+
+usage:
+  funnel profiles rename <old> <new>
+  funnel profiles <old> rename <new>`;
+const profilesProfileRenameHelpHandler = factory.createHandlers((c) => c.text(help$2));
+//#endregion
+//#region lib/cli/routes/profiles.$profile.rename.$newName.ts
 const profilesRenameHandler = factory.createHandlers(zValidator$1("param", z.object({
 	profile: z.string(),
 	newName: z.string()
-})), zValidator$1("query", z.object({}), renameHelp), (c) => {
+})), zValidator$1("query", z.object({})), (c) => {
 	const param = c.req.valid("param");
-	c.var.funnel.profiles.rename(param.profile, param.newName);
+	c.env.funnel.profiles.rename(param.profile, param.newName);
 	return c.text(`renamed profile "${param.profile}" to "${param.newName}"`);
 });
 //#endregion
@@ -5559,7 +6894,7 @@ usage: funnel profiles <name> run [additional claude args...]
 const RESERVED_KEYS = [];
 const profilesLaunchHandler = factory.createHandlers(zValidator$1("param", z.object({ profile: z.string() })), zValidator$1("query", z.object({}).passthrough(), launchHelp), async (c) => {
 	const param = c.req.valid("param");
-	const funnel = c.var.funnel;
+	const funnel = c.env.funnel;
 	const profile = funnel.profiles.get(param.profile);
 	if (!profile) throw new HTTPException(404, { message: `profile "${param.profile}" not found` });
 	const exitCode = await funnel.claude.launch({
@@ -5574,18 +6909,21 @@ const profilesLaunchHandler = factory.createHandlers(zValidator$1("param", z.obj
 	process.exit(exitCode);
 });
 //#endregion
-//#region lib/cli/routes/profiles.remove.$profile.ts
-const removeHelp = `funnel profiles remove — remove a profile
+//#region lib/cli/routes/profiles.remove.ts
+const help$1 = `funnel profiles remove — remove a profile
 
 usage: funnel profiles remove <name>`;
-const profilesRemoveHandler = factory.createHandlers(zValidator$1("param", z.object({ profile: z.string() })), zValidator$1("query", z.object({}), removeHelp), (c) => {
+const profilesRemoveHelpHandler = factory.createHandlers((c) => c.text(help$1));
+//#endregion
+//#region lib/cli/routes/profiles.remove.$profile.ts
+const profilesRemoveHandler = factory.createHandlers(zValidator$1("param", z.object({ profile: z.string() })), zValidator$1("query", z.object({})), (c) => {
 	const param = c.req.valid("param");
-	c.var.funnel.profiles.remove(param.profile);
+	c.env.funnel.profiles.remove(param.profile);
 	return c.text(`removed profile "${param.profile}"`);
 });
 //#endregion
-//#region lib/cli/routes/profiles.set.$profile.ts
-const setHelp = `funnel profiles <name> set — update a profile
+//#region lib/cli/routes/profiles.set.ts
+const help = `funnel profiles <name> set — update a profile
 
 usage: funnel profiles <name> set [--path <path>] [--channel <channel-name>] [recipe]
 
@@ -5599,6 +6937,9 @@ options:
 
 Only the flags you pass are changed; --agent and --options together replace
 the profile's whole options list.`;
+const profilesSetHelpHandler = factory.createHandlers((c) => c.text(help));
+//#endregion
+//#region lib/cli/routes/profiles.set.$profile.ts
 const profilesSetHandler = factory.createHandlers(zValidator$1("param", z.object({ profile: z.string() })), zValidator$1("query", z.object({
 	path: z.string().optional(),
 	channel: z.string().optional(),
@@ -5607,10 +6948,10 @@ const profilesSetHandler = factory.createHandlers(zValidator$1("param", z.object
 	env: z.string().optional(),
 	resume: z.string().optional(),
 	"no-resume": z.string().optional()
-}), setHelp), (c) => {
+})), (c) => {
 	const param = c.req.valid("param");
 	const query = c.req.valid("query");
-	const funnel = c.var.funnel;
+	const funnel = c.env.funnel;
 	const channel = query.channel !== void 0 ? funnel.channels.get(query.channel) : null;
 	if (query.channel !== void 0 && !channel) throw new HTTPException(400, { message: `channel "${query.channel}" not found` });
 	const recipe = parseProfileRecipe(query);
@@ -5645,7 +6986,7 @@ examples:
   funnel profiles add cto --path /repo/myapp --channel prod-inbox --agent pm --options "--brief"
   funnel profiles cto as-default
   funnel profiles cto run`), (c) => {
-	const profiles = c.var.funnel.profiles.list();
+	const profiles = c.env.funnel.profiles.list();
 	if (profiles.length === 0) return c.text("no profiles");
 	const lines = profiles.map((profile, index) => {
 		const tag = index === 0 ? " (default)" : "";
@@ -5675,29 +7016,77 @@ can validate and autocomplete the config:
 });
 //#endregion
 //#region lib/cli/routes/status.ts
-const statusHelp = `funnel status — show overall connection status
+const statusHelp = `funnel status — overall health at a glance
+
+usage: funnel status [--watch] [--interval <N>]
+
+options:
+  --watch               continuously refresh (Ctrl+C to stop)
+  --interval <N>        polling interval in seconds (used with --watch, default: 3)
+
+Shows gateway running state (pid, port, uptime), per-channel listener health
+(● alive / ○ dead), and whether Claude is connected to each channel as a
+WebSocket client. Use this as the first step when debugging missing events.
 
-usage: funnel status
+examples:
+  funnel status
+  funnel status --watch
+  funnel status --watch --interval 5
 
-Lists configured connectors / channels / profiles, gateway running status,
-and active MCP WebSocket clients.`;
+see also: fnl debug --channel <name>  (per-channel diagnosis with next steps)`;
 const isGatewayStatus = (value) => {
 	if (value === null || typeof value !== "object") return false;
 	if (!("clients" in value) || !Array.isArray(value.clients)) return false;
-	return value.clients.every((client) => typeof client === "object" && client !== null && "channel" in client && typeof client.channel === "string" && "connectors" in client && Array.isArray(client.connectors));
+	if (!("listeners" in value) || !Array.isArray(value.listeners)) return false;
+	return true;
 };
-const statusHandler = factory.createHandlers(zValidator$1("query", z.object({}), statusHelp), async (c) => {
-	const funnel = c.var.funnel;
+const buildStatusLines = async (funnel) => {
 	const channels = funnel.channels.list();
 	const profiles = funnel.profiles.list();
 	const gatewayStatus = funnel.gateway.getStatus();
 	const lines = [];
 	lines.push("= funnel status =");
 	lines.push("");
+	let gatewayData = null;
+	if (!gatewayStatus.running) lines.push("gateway: not running");
+	else {
+		const res = await fetch(`http://127.0.0.1:${gatewayStatus.port}/status`).catch(() => null);
+		let uptimeStr = "";
+		if (res && res.ok) {
+			const body = await res.json();
+			if (isGatewayStatus(body)) {
+				gatewayData = body;
+				const uptimeSec = Math.floor(body.uptimeMs / 1e3);
+				const uptimeMin = Math.floor(uptimeSec / 60);
+				uptimeStr = uptimeMin >= 60 ? ` · ${Math.floor(uptimeMin / 60)}h ${uptimeMin % 60}m` : uptimeSec >= 60 ? ` · ${uptimeMin}m ${uptimeSec % 60}s` : ` · ${uptimeSec}s`;
+			}
+		}
+		lines.push(`gateway: running (pid ${gatewayStatus.pid}, port ${gatewayStatus.port})${uptimeStr}`);
+	}
+	lines.push("");
+	const clientsByChannel = /* @__PURE__ */ new Map();
+	const listenerAliveByChannel = /* @__PURE__ */ new Map();
+	if (gatewayData) {
+		for (const client of gatewayData.clients) {
+			if (client.tapAll) continue;
+			const key = client.channelName ?? client.channel;
+			clientsByChannel.set(key, (clientsByChannel.get(key) ?? 0) + 1);
+		}
+		for (const listener of gatewayData.listeners) {
+			const current = listenerAliveByChannel.get(listener.channelName);
+			listenerAliveByChannel.set(listener.channelName, current === void 0 ? listener.alive : current && listener.alive);
+		}
+	}
+	const maxNameLen = Math.max(...channels.map((ch) => ch.name.length), 0);
 	lines.push(`channels: ${channels.length}`);
 	for (const ch of channels) {
-		const attached = ch.connectors.length > 0 ? ch.connectors.map((c) => `${c.name}:${c.type}`).join(", ") : "(none)";
-		lines.push(`  - ${ch.name} [${attached}]`);
+		const connectorLabel = ch.connectors.length > 0 ? ch.connectors.map((conn) => conn.type).join(", ") : "no connectors";
+		const isAlive = listenerAliveByChannel.get(ch.name);
+		const indicator = gatewayData === null ? "-" : isAlive === true ? "●" : isAlive === false ? "○" : "-";
+		const claudeCount = clientsByChannel.get(ch.name) ?? 0;
+		const claudeLabel = gatewayData === null ? "" : claudeCount === 0 ? "  no Claude" : claudeCount === 1 ? "  Claude connected (1 client)" : `  Claude connected (${claudeCount} clients)`;
+		const paddedName = ch.name.padEnd(maxNameLen);
+		lines.push(`  ${indicator} ${paddedName}  [${connectorLabel}]${claudeLabel}`);
 	}
 	lines.push("");
 	lines.push(`profiles: ${profiles.length}`);
@@ -5707,23 +7096,41 @@ const statusHandler = factory.createHandlers(zValidator$1("query", z.object({}),
 		const channelLabel = channel ? channel.name : `id:${profile.channelId}`;
 		lines.push(`  - ${profile.name}${tag} [path=${profile.path}, channel=${channelLabel}]`);
 	}
-	lines.push("");
-	if (!gatewayStatus.running) lines.push("gateway: not running");
-	else {
-		lines.push(`gateway: running (pid ${gatewayStatus.pid}, port ${gatewayStatus.port})`);
-		const res = await fetch(`http://127.0.0.1:${gatewayStatus.port}/status`).catch(() => null);
-		if (res && res.ok) {
-			const body = await res.json();
-			if (isGatewayStatus(body)) {
-				lines.push(`  clients: ${body.clients.length}`);
-				for (const client of body.clients) {
-					const connectorList = client.connectors.length > 0 ? client.connectors.join(", ") : "(none)";
-					lines.push(`    - channel=${client.channel || "(unset)"} [${connectorList}]`);
-				}
-			}
-		}
-	}
-	return c.text(lines.join("\n"));
+	return lines;
+};
+const statusHandler = factory.createHandlers(zValidator$1("query", z.object({
+	watch: z.enum([
+		"true",
+		"false",
+		""
+	]).optional(),
+	interval: z.string().optional()
+}), statusHelp), async (c) => {
+	const query = c.req.valid("query");
+	const funnel = c.env.funnel;
+	const isWatch = query.watch === "true" || query.watch === "";
+	const intervalSec = Math.min(60, Math.max(1, query.interval ? Number(query.interval) : 3));
+	if (!isWatch) {
+		const lines = await buildStatusLines(funnel);
+		return c.text(lines.join("\n"));
+	}
+	const render = async () => {
+		const lines = await buildStatusLines(funnel);
+		const ts = (/* @__PURE__ */ new Date()).toISOString().slice(11, 19);
+		process.stdout.write("\x1B[2J\x1B[H");
+		process.stdout.write(lines.join("\n"));
+		process.stdout.write(`\n\n  refreshing every ${intervalSec}s · ${ts} · Ctrl+C to stop\n`);
+	};
+	process.on("SIGINT", () => {
+		process.stdout.write("\n");
+		process.exit(0);
+	});
+	await render();
+	const timer = setInterval(render, intervalSec * 1e3);
+	await new Promise(() => {
+		process.on("exit", () => clearInterval(timer));
+	});
+	return c.text("");
 });
 //#endregion
 //#region lib/cli/routes/update.ts
@@ -5745,30 +7152,9 @@ const updateHandler = factory.createHandlers(zValidator$1("query", z.object({}),
 });
 //#endregion
 //#region lib/cli/routes/index.ts
-const helpRoute = (text) => factory.createHandlers((c) => c.text(text));
-/**
-* Build the CLI Hono app wired to a specific Funnel instance.
-* Exposed so library consumers can mount the same routes their `fnl` CLI
-* uses against a custom Funnel (e.g. one with sandboxed boundaries).
-*
-* All CLI verbs (`add` / `remove` / `set` / `rename` / `as-default` / `request`) map to POST in
-* to-request.ts and stay in the URL as a literal segment. Read paths (list / show / launch) keep GET.
-* Help shortcuts at parameterless URLs return the help text directly so `funnel <verb>` (no args) is
-* informative instead of 404.
-*/
-const createCliApp = (funnel) => {
-	const base = factory.createApp();
-	base.use((c, next) => {
-		c.set("funnel", funnel);
-		return next();
-	});
-	base.onError((error, c) => {
-		if (error instanceof HTTPException) return c.text(`error: ${error.message}`, error.status);
-		return c.text(`error: ${error instanceof Error ? error.message : String(error)}`, 400);
-	});
-	return base.get("/claude", ...claudeHandler).get("/channels", ...channelsGroupHandler).post("/channels/add", ...helpRoute(addHelp$3)).post("/channels/add/:channel", ...channelsAddHandler).post("/channels/remove", ...helpRoute(removeHelp$1)).post("/channels/remove/:channel", ...channelsRemoveHandler).post("/channels/rename/:channel/:newName", ...channelsRenameHandler).post("/channels/:channel/rename/:newName", ...channelsRenameHandler).post("/channels/rename", ...helpRoute(renameHelp$1)).post("/channels/:channel/rename", ...helpRoute(renameHelp$1)).post("/channels/:channel/set/delivery/:mode", ...channelsSetDeliveryHandler).post("/channels/publish", ...helpRoute(publishHelp)).post("/channels/:channel/publish", ...channelsPublishHandler).get("/channels/:channel", ...channelsShowHandler).get("/channels/:channel/connectors", ...channelsConnectorsGroupHandler).post("/channels/:channel/connectors/add", ...helpRoute(addHelp$2)).post("/channels/:channel/connectors/add/:connector", ...channelsConnectorsAddHandler).post("/channels/:channel/connectors/remove", ...helpRoute(removeHelp$3)).post("/channels/:channel/connectors/remove/:connector", ...channelsConnectorsRemoveHandler).post("/channels/:channel/connectors/set", ...helpRoute(setHelp$1)).post("/channels/:channel/connectors/set/:connector", ...channelsConnectorsSetHandler).post("/channels/:channel/connectors/rename/:connector/:newName", ...channelsConnectorsRenameHandler).post("/channels/:channel/connectors/:connector/rename/:newName", ...channelsConnectorsRenameHandler).post("/channels/:channel/connectors/rename", ...helpRoute(renameHelp$2)).post("/channels/:channel/connectors/:connector/rename", ...helpRoute(renameHelp$2)).post("/channels/:channel/connectors/:connector/request", ...channelsConnectorsRequestHandler).get("/channels/:channel/connectors/:connector", ...channelsConnectorsShowHandler).get("/channels/:channel/connectors/:connector/schedules", ...channelsConnectorsSchedulesGroupHandler).post("/channels/:channel/connectors/:connector/schedules/add", ...helpRoute(addHelp$1)).post("/channels/:channel/connectors/:connector/schedules/add/:id", ...channelsConnectorsSchedulesAddHandler).post("/channels/:channel/connectors/:connector/schedules/remove", ...helpRoute(removeHelp$2)).post("/channels/:channel/connectors/:connector/schedules/remove/:id", ...channelsConnectorsSchedulesRemoveHandler).get("/profiles", ...profilesGroupHandler).post("/profiles/add", ...helpRoute(addHelp)).post("/profiles/add/:profile", ...profilesAddHandler).post("/profiles/set", ...helpRoute(setHelp)).post("/profiles/set/:profile", ...profilesSetHandler).post("/profiles/remove", ...helpRoute(removeHelp)).post("/profiles/remove/:profile", ...profilesRemoveHandler).post("/profiles/rename/:profile/:newName", ...profilesRenameHandler).post("/profiles/:profile/rename/:newName", ...profilesRenameHandler).post("/profiles/rename", ...helpRoute(renameHelp)).post("/profiles/:profile/rename", ...helpRoute(renameHelp)).post("/profiles/:profile/as-default", ...profilesAsDefaultHandler).get("/profiles/:profile/run", ...profilesLaunchHandler).get("/profiles/:profile", ...profilesLaunchHandler).get("/gateway", ...gatewayGroupHandler).get("/gateway/status", ...gatewayStatusHandler).get("/gateway/start", ...gatewayStartHandler).get("/gateway/stop", ...gatewayStopHandler).get("/gateway/restart", ...gatewayRestartHandler).get("/gateway/run", ...gatewayRunHandler).get("/gateway/logs", ...gatewayLogsHandler).get("/gateway/sql", ...gatewaySqlHandler).get("/gateway/listeners", ...gatewayListenersHandler).get("/schema", ...schemaHandler).get("/status", ...statusHandler).get("/update", ...updateHandler);
-};
-/** CLI Hono app wired to a default `new Funnel()`. For embedding with a custom Funnel use `createCliApp`. */
-const app = createCliApp(new Funnel());
+const routes = factory.createApp().onError((error, c) => {
+	if (error instanceof HTTPException) return c.text(`error: ${error.message}`, error.status);
+	return c.text(`error: ${error instanceof Error ? error.message : String(error)}`, 400);
+}).get("/claude", ...claudeHandler).get("/channels", ...channelsGroupHandler).post("/channels/add", ...channelsAddHelpHandler).post("/channels/add/:channel", ...channelsAddHandler).post("/channels/remove", ...channelsRemoveHelpHandler).post("/channels/remove/:channel", ...channelsRemoveHandler).post("/channels/rename/:channel/:newName", ...channelsRenameHandler).post("/channels/:channel/rename/:newName", ...channelsRenameHandler).post("/channels/rename", ...channelsRenameHelpHandler).post("/channels/:channel/rename", ...channelsChannelRenameHelpHandler).post("/channels/:channel/set/delivery/:mode", ...channelsSetDeliveryHandler).post("/channels/publish", ...channelsPublishHelpHandler).post("/channels/:channel/publish", ...channelsPublishHandler).get("/channels/:channel/validate", ...channelsValidateHandler).get("/channels/validate", ...channelsValidateHelpHandler).get("/channels/:channel", ...channelsShowHandler).get("/channels/:channel/connectors", ...channelsConnectorsGroupHandler).post("/channels/:channel/connectors/add", ...channelsConnectorsAddHelpHandler).post("/channels/:channel/connectors/add/:connector", ...channelsConnectorsAddHandler).post("/channels/:channel/connectors/remove", ...channelsConnectorsRemoveHelpHandler).post("/channels/:channel/connectors/remove/:connector", ...channelsConnectorsRemoveHandler).post("/channels/:channel/connectors/set", ...channelsConnectorsSetHelpHandler).post("/channels/:channel/connectors/set/:connector", ...channelsConnectorsSetHandler).post("/channels/:channel/connectors/rename/:connector/:newName", ...channelsConnectorsRenameHandler).post("/channels/:channel/connectors/:connector/rename/:newName", ...channelsConnectorsRenameHandler).post("/channels/:channel/connectors/rename", ...channelsConnectorsRenameHelpHandler).post("/channels/:channel/connectors/:connector/rename", ...channelsConnectorRenameHelpHandler).post("/channels/:channel/connectors/:connector/request", ...channelsConnectorsRequestHandler).get("/channels/:channel/connectors/:connector", ...channelsConnectorsShowHandler).get("/channels/:channel/connectors/:connector/schedules", ...channelsConnectorsSchedulesGroupHandler).post("/channels/:channel/connectors/:connector/schedules/add", ...channelsConnectorSchedulesAddHelpHandler).post("/channels/:channel/connectors/:connector/schedules/add/:id", ...channelsConnectorsSchedulesAddHandler).post("/channels/:channel/connectors/:connector/schedules/remove", ...channelsConnectorSchedulesRemoveHelpHandler).post("/channels/:channel/connectors/:connector/schedules/remove/:id", ...channelsConnectorsSchedulesRemoveHandler).get("/profiles", ...profilesGroupHandler).post("/profiles/add", ...profilesAddHelpHandler).post("/profiles/add/:profile", ...profilesAddHandler).post("/profiles/set", ...profilesSetHelpHandler).post("/profiles/set/:profile", ...profilesSetHandler).post("/profiles/remove", ...profilesRemoveHelpHandler).post("/profiles/remove/:profile", ...profilesRemoveHandler).post("/profiles/rename/:profile/:newName", ...profilesRenameHandler).post("/profiles/:profile/rename/:newName", ...profilesRenameHandler).post("/profiles/rename", ...profilesRenameHelpHandler).post("/profiles/:profile/rename", ...profilesProfileRenameHelpHandler).post("/profiles/:profile/as-default", ...profilesAsDefaultHandler).get("/profiles/:profile/run", ...profilesLaunchHandler).get("/profiles/:profile", ...profilesLaunchHandler).get("/gateway", ...gatewayGroupHandler).get("/gateway/status", ...gatewayStatusHandler).get("/gateway/start", ...gatewayStartHandler).get("/gateway/stop", ...gatewayStopHandler).get("/gateway/restart", ...gatewayRestartHandler).get("/gateway/run", ...gatewayRunHandler).get("/gateway/logs", ...gatewayLogsHandler).get("/gateway/sql", ...gatewaySqlHandler).get("/gateway/listeners", ...gatewayListenersHandler).get("/debug", ...debugHandler).get("/debug/events", ...debugEventsHandler).get("/debug/dropped", ...debugDroppedHandler).get("/debug/errors", ...debugErrorsHandler).get("/debug/replay", ...debugReplayHandler).get("/schema", ...schemaHandler).get("/status", ...statusHandler).get("/update", ...updateHandler);
 //#endregion
-export { CONNECTOR_CONNECTION_STATUSES, ConnectorDiagnosticLog, ConnectorDiagnosticSqlReader, DEFAULT_GATEWAY_PORT, DEFAULT_GATEWAY_TOKEN_PATH, FUNNEL_DIR, FUNNEL_MCP_ARGS, FUNNEL_MCP_COMMAND, FUNNEL_MCP_NAME, Funnel, FunnelBroadcaster, FunnelChannelPublisher, FunnelChannels, FunnelClaude, FunnelClock, FunnelConnectorFactory, FunnelConnectorListener, FunnelEventLog, FunnelFileSystem, FunnelGateway, FunnelGatewayServer, FunnelGatewayToken, FunnelIdGenerator, FunnelListenerSupervisor, FunnelListenersClient, FunnelLocalConfig, FunnelLocalConfigSync, FunnelLocalConfigWriter, FunnelLogger, FunnelMcp, FunnelProcessRunner, FunnelProfiles, FunnelSettingsReader, FunnelSettingsStore, FunnelSlackEventProcessor, FunnelTokenPrompter, LOCAL_CONFIG_FILENAME, MemoryConnectorDiagnosticLog, MemoryFunnelClock, MemoryFunnelEventLog, MemoryFunnelFileSystem, MemoryFunnelIdGenerator, MemoryFunnelLogger, MemoryFunnelProcessRunner, MemoryFunnelTokenPrompter, MockFunnelSettingsReader, NodeFunnelClock, NodeFunnelFileSystem, NodeFunnelIdGenerator, NodeFunnelLogger, NodeFunnelProcessRunner, NodeFunnelTokenPrompter, NoopFunnelLogger, SETTINGS_PATH, SETTINGS_VERSION, SqliteConnectorDiagnosticLog, SqliteFunnelEventLog, channelConfigSchema, channelDeliveryModeSchema, channelSpecSchema, app as cliApp, connectorConfigSchema, connectorConnectionEventSchema, connectorProcessedEventSchema, connectorRawEventSchema, connectorSpecSchema, createCliApp, createSettings, discordConnectorSchema, factory, funnelEventSchema, funnelJsonSchema, ghConnectorSchema, localConfigSchema, profileConfigSchema, profileSpecSchema, publishRequestSchema, publishResponseSchema, queryToCliArgs, resolveFunnelDir, resolveFunnelPort, scheduleCatchupPolicySchema, scheduleConnectorSchema, scheduleEntrySchema, settingsSchema, slackConnectorSchema, startChannelServer, toRequest };
+export { CONNECTOR_CONNECTION_STATUSES, ConnectorDiagnosticLog, ConnectorDiagnosticSqlReader, DEFAULT_GATEWAY_PORT, DEFAULT_GATEWAY_TOKEN_PATH, FUNNEL_DIR, FUNNEL_MCP_ARGS, FUNNEL_MCP_COMMAND, FUNNEL_MCP_NAME, Funnel, FunnelBroadcaster, FunnelChannelPublisher, FunnelChannels, FunnelClaude, FunnelClock, FunnelConnectorFactory, FunnelConnectorListener, FunnelEventLog, FunnelFileSystem, FunnelGateway, FunnelGatewayServer, FunnelGatewayToken, FunnelIdGenerator, FunnelListenerSupervisor, FunnelListenersClient, FunnelLocalConfig, FunnelLocalConfigSync, FunnelLocalConfigWriter, FunnelLogger, FunnelMcp, FunnelProcessRunner, FunnelProfiles, FunnelSettingsReader, FunnelSettingsStore, FunnelSlackEventProcessor, FunnelTokenPrompter, LOCAL_CONFIG_FILENAME, MemoryConnectorDiagnosticLog, MemoryFunnelClock, MemoryFunnelEventLog, MemoryFunnelFileSystem, MemoryFunnelIdGenerator, MemoryFunnelLogger, MemoryFunnelProcessRunner, MemoryFunnelTokenPrompter, MockFunnelSettingsReader, NodeFunnelClock, NodeFunnelFileSystem, NodeFunnelIdGenerator, NodeFunnelLogger, NodeFunnelProcessRunner, NodeFunnelTokenPrompter, NoopFunnelLogger, SETTINGS_PATH, SETTINGS_VERSION, SqliteConnectorDiagnosticLog, SqliteFunnelEventLog, channelConfigSchema, channelDeliveryModeSchema, channelSpecSchema, routes as cliRoutes, connectorConfigSchema, connectorConnectionEventSchema, connectorProcessedEventSchema, connectorRawEventSchema, connectorSpecSchema, createSettings, discordConnectorSchema, factory, funnelEventSchema, funnelJsonSchema, ghConnectorSchema, localConfigSchema, profileConfigSchema, profileSpecSchema, publishRequestSchema, publishResponseSchema, queryToCliArgs, resolveFunnelDir, resolveFunnelPort, scheduleCatchupPolicySchema, scheduleConnectorSchema, scheduleEntrySchema, settingsSchema, slackConnectorSchema, startChannelServer, toRequest };