@interactive-inc/claude-funnel 0.36.0 → 0.37.0

package/dist/index.js

@@ -17,7 +17,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 +2581,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 +2638,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 +2994,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$1 = (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$1(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) => {
@@ -3067,7 +3300,7 @@ const statusHandler$1 = factory$1.createHandlers((c) => {
 * 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);
+const gatewayRoutes = 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);
 //#endregion
 //#region lib/gateway/gateway-server.ts
 const DEFAULT_HOST = "127.0.0.1";
@@ -3300,6 +3533,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 +3769,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 +4093,13 @@ var Funnel = class Funnel {
 			extraRoutes: options.extraRoutes
 		});
 	}
+	async debug(channelName) {
+		return buildFunnelDebugReport({
+			gateway: this.gateway,
+			channels: this.channels,
+			tmpDir: this.paths.tmpDir
+		}, channelName ?? null);
+	}
 };
 //#endregion
 //#region lib/engine/mcp/channel-subscriber.ts
@@ -3874,14 +4193,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 +4238,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 +4254,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 +4303,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 +4366,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 +4954,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
@@ -5051,9 +5418,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,13 +5438,26 @@ 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 query = c.req.valid("query");
 	const channels = c.var.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}]`;
 	});
@@ -5161,12 +5548,848 @@ const claudeHandler = factory.createHandlers(zValidator$1("query", z.object({
 	process.exit(exitCode);
 });
 //#endregion
-//#region lib/cli/routes/gateway.ts
-const groupHelp$1 = `funnel gateway — manage the funnel daemon
+//#region lib/cli/routes/debug.ts
+const debugHelp = `funnel debug — diagnose why Claude is not receiving events
 
-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.
+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 truncate = (text, max) => text.length <= max ? text : `${text.slice(0, max)}…`;
+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) return truncate(String(parsed.text), 60);
+	} catch {
+		return truncate(payload, 60);
+	}
+	return truncate(payload, 60);
+};
+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
+	};
+};
+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.var.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 = (() => {
+		try {
+			if (channel) return reader.query("SELECT seq, ts, type, outcome, payload FROM processed WHERE channel_id = ? ORDER BY seq DESC LIMIT ?", [channel.id, limit]);
+			return reader.query("SELECT seq, ts, type, outcome, payload FROM processed ORDER BY seq DESC LIMIT ?", [limit]);
+		} finally {
+			reader.close();
+		}
+	})();
+	if (rows instanceof Error) return c.text(`error: ${rows.message}`);
+	const events = [...rows].reverse().map((row) => {
+		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;
+		}
+		return {
+			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 (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.var.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 = (() => {
+		try {
+			if (channel) return reader.query("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]);
+			return reader.query("SELECT seq, ts, type, outcome, payload, event_id FROM processed WHERE outcome LIKE 'skip:%' ORDER BY seq DESC LIMIT ?", [limit]);
+		} finally {
+			reader.close();
+		}
+	})();
+	if (rows instanceof Error) return c.text(`error: ${rows.message}`);
+	const events = [...rows].reverse().map((row) => {
+		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;
+		}
+		return {
+			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 : "?",
+			event_id: typeof row.event_id === "string" ? row.event_id : null,
+			payload: rawPayload,
+			payloadParsed,
+			preview: extractPreview(row.payload)
+		};
+	});
+	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.event_id ? `  event_id=${ev.event_id.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.var.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 = (() => {
+		try {
+			if (channel) return reader.query("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]);
+			return reader.query("SELECT seq, ts, type, status, detail FROM connection WHERE status IN ('auth-failed','error') ORDER BY seq DESC LIMIT ?", [limit]);
+		} finally {
+			reader.close();
+		}
+	})();
+	if (rows instanceof Error) return c.text(`error: ${rows.message}`);
+	const errors = [...rows].reverse().map((row) => ({
+		seq: typeof row.seq === "number" ? row.seq : null,
+		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
+	}));
+	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 reader = new ConnectorDiagnosticSqlReader(store);
+		const evRows = (() => {
+			try {
+				return reader.query("SELECT seq, ts, type, outcome, payload FROM processed WHERE channel_id = ? ORDER BY seq DESC LIMIT ?", [targetChannel.id, limit]);
+			} finally {
+				reader.close();
+			}
+		})();
+		if (!(evRows instanceof Error)) baseReport.recentEvents = evRows.reverse().map((row) => {
+			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;
+			}
+			return {
+				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)
+			};
+		});
+		const hasDeadListeners = baseReport.listeners.some((l) => !l.alive);
+		const hasListenerErrors = baseReport.listeners.some((l) => l.errors > 0);
+		if (hasDeadListeners || hasListenerErrors) {
+			const errReader = new ConnectorDiagnosticSqlReader(store);
+			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", [targetChannel.id]);
+				} finally {
+					errReader.close();
+				}
+			})();
+			if (!(errRows instanceof Error)) baseReport.connectionErrors = errRows.reverse().map((row) => ({
+				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
+			}));
+		}
+	}
+	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.var.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.var.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 reader = new ConnectorDiagnosticSqlReader(store);
+	const rows = (() => {
+		try {
+			if (query.seq) return reader.query("SELECT seq, event_id, type, payload, connector_id, channel_id FROM processed WHERE channel_id = ? AND seq = ? LIMIT 1", [targetChannel.id, Number(query.seq)]);
+			return reader.query("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]);
+		} finally {
+			reader.close();
+		}
+	})();
+	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 rawReader = new ConnectorDiagnosticSqlReader(store);
+		const rawRows = (() => {
+			try {
+				return rawReader.query("SELECT payload FROM raw WHERE event_id = ? LIMIT 1", [eventId]);
+			} finally {
+				rawReader.close();
+			}
+		})();
+		if (!(rawRows instanceof Error) && rawRows[0]) {
+			const rawRow = rawRows[0];
+			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 = connectorId ? targetChannel.connectors?.find((c) => c.id === connectorId)?.name : void 0;
+	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 = extractPreview(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/channels.$channel.validate.ts
+const validateHelp = `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 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() }), validateHelp), (c) => {
+	const param = c.req.valid("param");
+	const query = c.req.valid("query");
+	const funnel = c.var.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/gateway.ts
+const groupHelp$1 = `funnel gateway — manage the funnel daemon
+
+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 +6400,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();
 	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
@@ -5212,24 +6464,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 +6504,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 +6543,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 +6556,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 +6565,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
+
+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
 
-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?".
+Output is always JSON — pipe to jq or pass directly to Claude.
 
-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)
+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 | ...)
 
-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
+common join: SELECT r.payload FROM raw r JOIN processed p USING(event_id) WHERE p.outcome = 'skip:dedup'
 
-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.
+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.var.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 +6650,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();
 		}
@@ -5428,15 +6728,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.var.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
@@ -5675,29 +7001,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 +7081,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.var.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
@@ -5766,7 +7158,7 @@ const createCliApp = (funnel) => {
 		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);
+	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/validate", ...channelsValidateHandler).get("/channels/validate", ...helpRoute(validateHelp)).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("/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);
 };
 /** CLI Hono app wired to a default `new Funnel()`. For embedding with a custom Funnel use `createCliApp`. */
 const app = createCliApp(new Funnel());