@interactive-inc/claude-funnel 0.53.0 → 0.56.0

package/dist/{connector-adapter-CePYBTgW.d.ts → connector-adapter-1PxjN-Uk.d.ts}

@@ -1,4 +1,4 @@
-//#region lib/connectors/connector-adapter.d.ts
+//#region lib/engine/connectors/connector-adapter.d.ts
 /**
  * A JSON-serializable value. Connector call bodies are sent to external APIs as
  * JSON, so the body must be representable as JSON — `JsonValue` says exactly

package/dist/{connector-adapter-D5Utumgz.js → connector-adapter-qwXLjQId.js}

@@ -1,4 +1,4 @@
-//#region lib/connectors/connector-adapter.ts
+//#region lib/engine/connectors/connector-adapter.ts
 var FunnelConnectorAdapter = class {};
 //#endregion
 export { FunnelConnectorAdapter as t };

package/dist/{connector-listener-DU54DN-f.js → connector-listener-CpHBecCj.js}

@@ -1,4 +1,4 @@
-//#region lib/connectors/connector-listener.ts
+//#region lib/engine/connectors/connector-listener.ts
 /**
 * Long-lived event source for one connector.
 *

package/dist/connectors/discord.d.ts

@@ -1,6 +1,6 @@
-import { S as FunnelLogger, b as FunnelConnectorListener, o as ConnectorDiagnosticLog, x as NotifyFn } from "../connector-diagnostic-log-yTOojKUR.js";
-import { n as FunnelConnectorAdapter, t as CallInput } from "../connector-adapter-CePYBTgW.js";
-import { n as discordConnectorSchema, t as DiscordConnectorConfig } from "../discord-connector-schema-R0Uu-3ns.js";
+import { S as FunnelLogger, b as FunnelConnectorListener, o as ConnectorDiagnosticLog, x as NotifyFn } from "../diagnostic-log-Bxe7Bbvw.js";
+import { n as FunnelConnectorAdapter, t as CallInput } from "../connector-adapter-1PxjN-Uk.js";
+import { n as discordConnectorSchema, t as DiscordConnectorConfig } from "../discord-connector-schema-CPgcZkXh.js";
 
 //#region lib/engine/http/http-client.d.ts
 type HttpRequest = {
@@ -19,7 +19,7 @@ declare abstract class FunnelHttpClient {
   abstract fetch(request: HttpRequest): Promise<HttpResponse>;
 }
 //#endregion
-//#region lib/connectors/discord-adapter.d.ts
+//#region lib/engine/connectors/discord-adapter.d.ts
 type Deps$1 = {
   config: DiscordConnectorConfig; /** Environment used to resolve a `botTokenEnv` reference. Defaults to process.env. */
   env?: NodeJS.ProcessEnv;
@@ -32,7 +32,7 @@ declare class FunnelDiscordAdapter extends FunnelConnectorAdapter {
   call(input: CallInput): Promise<unknown>;
 }
 //#endregion
-//#region lib/connectors/discord-event-processor.d.ts
+//#region lib/engine/connectors/discord-event-processor.d.ts
 type DiscordInboundMessage = {
   authorId: string;
   authorIsBot: boolean;
@@ -59,7 +59,7 @@ declare class FunnelDiscordEventProcessor {
   process(message: DiscordInboundMessage): DiscordProcessed;
 }
 //#endregion
-//#region lib/connectors/discord-listener.d.ts
+//#region lib/engine/connectors/discord-listener.d.ts
 type Deps = {
   config: DiscordConnectorConfig; /** Funnel channel uuid this connector lives under; stamped onto diagnostic-log rows. */
   channelId?: string; /** Environment used to resolve a `botTokenEnv` reference. Defaults to process.env. */

package/dist/connectors/discord.js

@@ -1,3 +1,3 @@
-import { n as FunnelDiscordEventProcessor, r as FunnelDiscordAdapter, t as FunnelDiscordListener } from "../discord-listener-_jSE3HsQ.js";
-import { t as discordConnectorSchema } from "../discord-connector-schema-CBDyGdOI.js";
+import { n as FunnelDiscordEventProcessor, r as FunnelDiscordAdapter, t as FunnelDiscordListener } from "../discord-listener-C0MoKdQO.js";
+import { t as discordConnectorSchema } from "../discord-connector-schema-B_N6IXLz.js";
 export { FunnelDiscordAdapter, FunnelDiscordEventProcessor, FunnelDiscordListener, discordConnectorSchema };

package/dist/connectors/gh.d.ts

@@ -1,9 +1,9 @@
-import { S as FunnelLogger, b as FunnelConnectorListener, o as ConnectorDiagnosticLog, x as NotifyFn } from "../connector-diagnostic-log-yTOojKUR.js";
-import { r as FunnelProcessRunner } from "../process-runner-DfniuWVU.js";
-import { n as FunnelConnectorAdapter, t as CallInput } from "../connector-adapter-CePYBTgW.js";
-import { n as ghConnectorSchema, t as GhConnectorConfig } from "../gh-connector-schema-eoTtHbY6.js";
+import { S as FunnelLogger, b as FunnelConnectorListener, o as ConnectorDiagnosticLog, x as NotifyFn } from "../diagnostic-log-Bxe7Bbvw.js";
+import { r as FunnelProcessRunner } from "../process-runner-D5I_jhYQ.js";
+import { n as FunnelConnectorAdapter, t as CallInput } from "../connector-adapter-1PxjN-Uk.js";
+import { n as ghConnectorSchema, t as GhConnectorConfig } from "../gh-connector-schema-CU1ojfIF.js";
 
-//#region lib/connectors/gh-adapter.d.ts
+//#region lib/engine/connectors/gh-adapter.d.ts
 type Deps$1 = {
   process?: FunnelProcessRunner;
 };
@@ -13,7 +13,7 @@ declare class FunnelGhAdapter extends FunnelConnectorAdapter {
   call(input: CallInput): Promise<unknown>;
 }
 //#endregion
-//#region lib/connectors/gh-listener.d.ts
+//#region lib/engine/connectors/gh-listener.d.ts
 type Deps = {
   config: GhConnectorConfig; /** Funnel channel uuid this connector lives under; stamped onto diagnostic-log rows. */
   channelId?: string;

package/dist/connectors/gh.js

@@ -1,3 +1,3 @@
-import { t as ghConnectorSchema } from "../gh-connector-schema-o3Q1-ojL.js";
-import { n as FunnelGhAdapter, t as FunnelGhListener } from "../gh-listener-DH-fClQm.js";
+import { t as ghConnectorSchema } from "../gh-connector-schema-DUcZgN2Q.js";
+import { n as FunnelGhAdapter, t as FunnelGhListener } from "../gh-listener-Dsx6AmhH.js";
 export { FunnelGhAdapter, FunnelGhListener, ghConnectorSchema };

package/dist/connectors/schedule.d.ts

@@ -1,6 +1,16 @@
-import { a as ScheduleEntry, c as scheduleEntrySchema, i as ScheduleConnectorConfig, l as ScheduleStateStore, n as ScheduleOnFired, o as scheduleCatchupPolicySchema, r as ScheduleCatchupPolicy, s as scheduleConnectorSchema, t as FunnelScheduleListener } from "../schedule-listener-CUyUFFR1.js";
+import { a as ScheduleEntry, c as scheduleEntrySchema, i as ScheduleConnectorConfig, l as ScheduleStateStore, n as ScheduleOnFired, o as scheduleCatchupPolicySchema, r as ScheduleCatchupPolicy, s as scheduleConnectorSchema, t as FunnelScheduleListener } from "../schedule-listener-DKh0hnkK.js";
 
-//#region lib/connectors/match-cron.d.ts
+//#region lib/engine/connectors/match-cron.d.ts
+/**
+ * Returns true when `date` (local time) satisfies a 5-field cron expression.
+ *
+ * Two deliberate deviations from Vixie cron, called out so schedules are not
+ * written expecting the other behavior:
+ *   - Day-of-month and day-of-week are ANDed, not ORed. Vixie cron fires when
+ *     EITHER matches once both are restricted; here every field must match.
+ *   - Day-of-week is 0-6 (Sunday=0). `7` for Sunday is NOT accepted (it throws
+ *     as out-of-range); use `0`.
+ */
 declare const matchCron: (expr: string, date: Date) => boolean;
 //#endregion
 export { FunnelScheduleListener, ScheduleCatchupPolicy, ScheduleConnectorConfig, ScheduleEntry, ScheduleOnFired, ScheduleStateStore, matchCron, scheduleCatchupPolicySchema, scheduleConnectorSchema, scheduleEntrySchema };

package/dist/connectors/schedule.js

@@ -1,3 +1,3 @@
-import { n as ScheduleStateStore, r as matchCron, t as FunnelScheduleListener } from "../schedule-listener-ePAjians.js";
-import { n as scheduleConnectorSchema, r as scheduleEntrySchema, t as scheduleCatchupPolicySchema } from "../schedule-connector-schema-iCI61gzU.js";
+import { n as ScheduleStateStore, r as matchCron, t as FunnelScheduleListener } from "../schedule-listener-DP9Jhc6U.js";
+import { n as scheduleConnectorSchema, r as scheduleEntrySchema, t as scheduleCatchupPolicySchema } from "../schedule-connector-schema-B_xO5z5B.js";
 export { FunnelScheduleListener, ScheduleStateStore, matchCron, scheduleCatchupPolicySchema, scheduleConnectorSchema, scheduleEntrySchema };

package/dist/connectors/slack.d.ts

@@ -1,7 +1,7 @@
-import { n as FunnelConnectorAdapter, t as CallInput } from "../connector-adapter-CePYBTgW.js";
-import { a as slackConnectorSchema, c as SlackProcessedEmit, d as SlackSkipReason, i as SlackConnectorConfig, l as SlackProcessedSkip, n as SlackOnAppCreated, o as FunnelSlackEventProcessor, r as SlackPreprocessEvent, s as SlackProcessed, t as FunnelSlackListener, u as SlackRawEvent } from "../slack-listener-Bv5xI9gC.js";
+import { n as FunnelConnectorAdapter, t as CallInput } from "../connector-adapter-1PxjN-Uk.js";
+import { a as slackConnectorSchema, c as SlackProcessedEmit, d as SlackSkipReason, i as SlackConnectorConfig, l as SlackProcessedSkip, n as SlackOnAppCreated, o as FunnelSlackEventProcessor, r as SlackPreprocessEvent, s as SlackProcessed, t as FunnelSlackListener, u as SlackRawEvent } from "../slack-listener-COQA8wAZ.js";
 
-//#region lib/connectors/slack-adapter.d.ts
+//#region lib/engine/connectors/slack-adapter.d.ts
 type SlackWebClientLike = {
   apiCall: (method: string, options?: Record<string, unknown>) => Promise<unknown>;
 };

package/dist/connectors/slack.js

@@ -1,3 +1,3 @@
-import { n as FunnelSlackEventProcessor, r as FunnelSlackAdapter, t as FunnelSlackListener } from "../slack-listener-ClQuHhEF.js";
-import { t as slackConnectorSchema } from "../slack-connector-schema-BCNWluHM.js";
+import { n as FunnelSlackEventProcessor, r as FunnelSlackAdapter, t as FunnelSlackListener } from "../slack-listener-DUKPcpJH.js";
+import { t as slackConnectorSchema } from "../slack-connector-schema-C1zEf4TG.js";
 export { FunnelSlackAdapter, FunnelSlackEventProcessor, FunnelSlackListener, slackConnectorSchema };

package/dist/{connector-diagnostic-log-yTOojKUR.d.ts → diagnostic-log-Bxe7Bbvw.d.ts}

@@ -13,7 +13,7 @@ declare abstract class FunnelLogger {
   abstract readonly file: string | null;
 }
 //#endregion
-//#region lib/connectors/connector-listener.d.ts
+//#region lib/engine/connectors/connector-listener.d.ts
 type NotifyFn = (content: string, meta?: Record<string, string>) => Promise<void>;
 /**
  * Long-lived event source for one connector.
@@ -32,7 +32,7 @@ declare abstract class FunnelConnectorListener {
   isAlive(): boolean;
 }
 //#endregion
-//#region lib/gateway/connector-diagnostic-log.d.ts
+//#region lib/gateway/diagnostic-log/diagnostic-log.d.ts
 /**
  * Points in the listener's connection lifecycle. The single source of truth
  * for the value set: the `status` column schema, the `ConnectorConnectionStatus`

package/dist/diagnostic-sql-reader-CzYgZpq2.js

@@ -0,0 +1,83 @@
+import { Database } from "bun:sqlite";
+//#region lib/gateway/diagnostic-log/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
+export { ConnectorDiagnosticSqlReader as t };

package/dist/diagnostics.d.ts

@@ -0,0 +1,2 @@
+import { a as DiagnosticsGatewayProbe, c as FunnelDiagnostics, d as DiagnosticEvent, f as previewOf, h as toDiagnosticEvent, i as DiagnosticsChannelSource, l as ReplayResult, m as toDiagnosticConnectionError, n as DiagnoseAllReport, o as DiagnosticsPublisher, p as queryRows, r as DiagnosisStatus, s as DiagnosticsTokenReader, t as ChannelDiagnosis, u as DiagnosticConnectionError } from "./funnel-diagnostics-qWy5tPSq.js";
+export { ChannelDiagnosis, DiagnoseAllReport, DiagnosisStatus, DiagnosticConnectionError, DiagnosticEvent, DiagnosticsChannelSource, DiagnosticsGatewayProbe, DiagnosticsPublisher, DiagnosticsTokenReader, FunnelDiagnostics, ReplayResult, previewOf, queryRows, toDiagnosticConnectionError, toDiagnosticEvent };

package/dist/diagnostics.js

@@ -0,0 +1,2 @@
+import { a as toDiagnosticEvent, i as toDiagnosticConnectionError, n as previewOf, r as queryRows, t as FunnelDiagnostics } from "./funnel-diagnostics-BpKYrMSu.js";
+export { FunnelDiagnostics, previewOf, queryRows, toDiagnosticConnectionError, toDiagnosticEvent };

package/dist/{discord-connector-schema-CBDyGdOI.js → discord-connector-schema-B_N6IXLz.js}

@@ -1,5 +1,5 @@
 import { z } from "zod";
-//#region lib/connectors/discord-connector-schema.ts
+//#region lib/engine/connectors/discord-connector-schema.ts
 /**
 * Like slack, a discord connector holds either a literal `botToken` or a
 * `botTokenEnv` reference resolved from `process.env` at listener start. The

package/dist/{discord-connector-schema-R0Uu-3ns.d.ts → discord-connector-schema-CPgcZkXh.d.ts}

@@ -1,6 +1,6 @@
 import { z } from "zod";
 
-//#region lib/connectors/discord-connector-schema.d.ts
+//#region lib/engine/connectors/discord-connector-schema.d.ts
 /**
  * Like slack, a discord connector holds either a literal `botToken` or a
  * `botTokenEnv` reference resolved from `process.env` at listener start. The

package/dist/{discord-listener-_jSE3HsQ.js → discord-listener-C0MoKdQO.js}

@@ -1,6 +1,6 @@
-import { t as FunnelConnectorAdapter } from "./connector-adapter-D5Utumgz.js";
-import { t as resolveConnectorToken } from "./resolve-connector-token-BHmZLRrV.js";
-import { t as FunnelConnectorListener } from "./connector-listener-DU54DN-f.js";
+import { t as FunnelConnectorAdapter } from "./connector-adapter-qwXLjQId.js";
+import { t as resolveConnectorToken } from "./resolve-connector-token-CczqG_Ig.js";
+import { t as FunnelConnectorListener } from "./connector-listener-CpHBecCj.js";
 import { Client, GatewayIntentBits, Partials } from "discord.js";
 //#region lib/engine/http/http-client.ts
 var FunnelHttpClient = class {};
@@ -26,7 +26,7 @@ var NodeFunnelHttpClient = class extends FunnelHttpClient {
 	}
 };
 //#endregion
-//#region lib/connectors/discord-adapter.ts
+//#region lib/engine/connectors/discord-adapter.ts
 const DISCORD_API_BASE = "https://discord.com/api/v10";
 const defaultHttp = new NodeFunnelHttpClient();
 var FunnelDiscordAdapter = class extends FunnelConnectorAdapter {
@@ -63,7 +63,7 @@ var FunnelDiscordAdapter = class extends FunnelConnectorAdapter {
 	}
 };
 //#endregion
-//#region lib/connectors/discord-event-processor.ts
+//#region lib/engine/connectors/discord-event-processor.ts
 var FunnelDiscordEventProcessor = class {
 	ownUserId;
 	constructor(props) {
@@ -86,7 +86,7 @@ var FunnelDiscordEventProcessor = class {
 	}
 };
 //#endregion
-//#region lib/connectors/discord-listener.ts
+//#region lib/engine/connectors/discord-listener.ts
 var FunnelDiscordListener = class extends FunnelConnectorListener {
 	config;
 	channelId;

package/dist/docs.d.ts

@@ -0,0 +1,2 @@
+import { n as FunnelDocs, t as DocsTopicListing } from "./funnel-docs-dXPokzr5.js";
+export { DocsTopicListing, FunnelDocs };

package/dist/docs.js

@@ -0,0 +1,2 @@
+import { t as FunnelDocs } from "./funnel-docs-ng5K8w4j.js";
+export { FunnelDocs };

package/dist/doctor.d.ts

@@ -0,0 +1,2 @@
+import { n as DoctorReport, r as FunnelDoctor, t as DoctorFixMode } from "./funnel-doctor-BF3Rdgk0.js";
+export { DoctorFixMode, DoctorReport, FunnelDoctor };

package/dist/doctor.js

@@ -0,0 +1,2 @@
+import { t as FunnelDoctor } from "./funnel-doctor-CApCezTq.js";
+export { FunnelDoctor };

package/dist/{file-process-guard-DMeLB6Zd.d.ts → file-process-guard-DI1742H5.d.ts}

@@ -1,7 +1,8 @@
-import { n as FunnelIdGenerator, r as ChannelConfig } from "./settings-reader-BSU6JyvM.js";
-import { S as FunnelLogger } from "./connector-diagnostic-log-yTOojKUR.js";
-import { r as FunnelProcessRunner } from "./process-runner-DfniuWVU.js";
-import { n as FunnelFileSystem } from "./file-system-BeOKXjlV.js";
+import { t as ChannelConfig } from "./settings-schema-zhnMIa8I.js";
+import { n as FunnelIdGenerator } from "./settings-reader-CBrgz01o.js";
+import { S as FunnelLogger } from "./diagnostic-log-Bxe7Bbvw.js";
+import { r as FunnelProcessRunner } from "./process-runner-D5I_jhYQ.js";
+import { n as FunnelFileSystem } from "./file-system-Wub9Nto4.js";
 
 //#region lib/engine/claude/channel-resolver.d.ts
 type ChannelResolver = {

package/dist/funnel-diagnostics-BpKYrMSu.js

@@ -0,0 +1,300 @@
+import { t as ConnectorDiagnosticSqlReader } from "./diagnostic-sql-reader-CzYgZpq2.js";
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+//#region lib/services/diagnostics/diagnostic-event.ts
+const stringOrNull = (value) => typeof value === "string" && value.length > 0 ? value : null;
+const numberOrNull = (value) => typeof value === "number" ? value : null;
+const stringOr = (value, fallback) => typeof value === "string" ? value : fallback;
+const isStringKeyedObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const parsePayloadObject = (payload) => {
+	if (payload === null) return null;
+	try {
+		const parsed = JSON.parse(payload);
+		if (isStringKeyedObject(parsed)) return parsed;
+	} catch {
+		return null;
+	}
+	return null;
+};
+const truncate = (text, max) => text.length <= max ? text : `${text.slice(0, max)}…`;
+const previewOf = (payload) => {
+	if (typeof payload !== "string" || payload.length === 0) return null;
+	const parsed = parsePayloadObject(payload);
+	if (parsed !== null && "text" in parsed) return truncate(String(parsed.text), 60);
+	return truncate(payload, 60);
+};
+const toDiagnosticEvent = (row) => {
+	const payload = stringOrNull(row.payload);
+	return {
+		seq: numberOrNull(row.seq),
+		ts: numberOrNull(row.ts),
+		type: stringOr(row.type, "?"),
+		outcome: stringOr(row.outcome, "?"),
+		eventId: stringOrNull(row.event_id),
+		payload,
+		payloadParsed: parsePayloadObject(payload),
+		preview: previewOf(row.payload)
+	};
+};
+const toDiagnosticConnectionError = (row) => ({
+	seq: numberOrNull(row.seq),
+	ts: numberOrNull(row.ts),
+	type: stringOr(row.type, "?"),
+	status: stringOr(row.status, "?"),
+	detail: stringOrNull(row.detail)
+});
+const queryRows = (reader, sql, params) => {
+	try {
+		return reader.query(sql, params);
+	} finally {
+		reader.close();
+	}
+};
+//#endregion
+//#region lib/services/diagnostics/funnel-diagnostics.ts
+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 connectorOf = (channel, connectorId) => {
+	if (connectorId === null) return void 0;
+	return channel.connectors?.find((connector) => connector.id === connectorId)?.name;
+};
+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 doctor --fix", "fnl doctor --fix --aggressive"],
+		rootCause
+	};
+	if (someDead) return {
+		status: "warn",
+		message: "some listeners are dead",
+		nextActions: ["fnl doctor --fix"],
+		rootCause
+	};
+	if (report.claudeClients === 0) return {
+		status: "warn",
+		message: "no Claude connected to this channel",
+		nextActions: [`fnl claude --channel ${channel}`],
+		rootCause: null
+	};
+	if (report.listeners.some((l) => l.errors > 0)) return {
+		status: "warn",
+		message: "listeners have errors",
+		nextActions: ["fnl gateway logs"],
+		rootCause
+	};
+	return {
+		status: "ok",
+		message: "everything looks healthy",
+		nextActions: [],
+		rootCause: null
+	};
+};
+/**
+* Programmable diagnostics surface — used by both the CLI (fnl debug …) and
+* the MCP tools (fnl_debug, fnl_recent_events, …). Pure read-side, no
+* mutation; pair with FunnelRecovery for self-healing actions.
+*/
+var FunnelDiagnostics = class {
+	constructor(props) {
+		this.props = props;
+		Object.freeze(this);
+	}
+	async diagnose(channelName) {
+		const channels = this.props.channels.list();
+		const target = channelName ? channels.find((ch) => ch.name === channelName) ?? null : channels[0] ?? null;
+		if (!target) return null;
+		const gatewayBody = await this.fetchGatewayStatus();
+		const store = this.resolveStore();
+		return this.buildChannelDiagnosis(target, gatewayBody, store, 5);
+	}
+	async diagnoseAll() {
+		const channels = this.props.channels.list();
+		const gatewayBody = await this.fetchGatewayStatus();
+		const store = this.resolveStore();
+		const reports = await Promise.all(channels.map((ch) => this.buildChannelDiagnosis(ch, gatewayBody, store, 5)));
+		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 {
+			summary: {
+				total: reports.length,
+				ok: okChannels.length,
+				warn: warnChannels.length,
+				error: errorChannels.length,
+				criticalChannels: errorChannels,
+				warnChannels,
+				suggestedActions: uniqueActions
+			},
+			channels: reports
+		};
+	}
+	async recentEvents(channelName, limit = 20) {
+		const store = this.resolveStore();
+		if (!store) return [];
+		const channelId = this.resolveChannelId(channelName);
+		if (channelName && !channelId) return [];
+		const reader = new ConnectorDiagnosticSqlReader(store);
+		const rows = channelId ? queryRows(reader, "SELECT seq, ts, type, outcome, payload FROM processed WHERE channel_id = ? ORDER BY seq DESC LIMIT ?", [channelId, limit]) : queryRows(reader, "SELECT seq, ts, type, outcome, payload FROM processed ORDER BY seq DESC LIMIT ?", [limit]);
+		if (rows instanceof Error) return [];
+		return rows.reverse().map(toDiagnosticEvent);
+	}
+	async droppedEvents(channelName, limit = 20) {
+		const store = this.resolveStore();
+		if (!store) return [];
+		const channelId = this.resolveChannelId(channelName);
+		if (channelName && !channelId) return [];
+		const reader = new ConnectorDiagnosticSqlReader(store);
+		const rows = channelId ? queryRows(reader, "SELECT seq, ts, type, outcome, payload, event_id FROM processed WHERE channel_id = ? AND outcome LIKE 'skip:%' ORDER BY seq DESC LIMIT ?", [channelId, limit]) : queryRows(reader, "SELECT seq, ts, type, outcome, payload, event_id FROM processed WHERE outcome LIKE 'skip:%' ORDER BY seq DESC LIMIT ?", [limit]);
+		if (rows instanceof Error) return [];
+		return rows.reverse().map(toDiagnosticEvent);
+	}
+	async connectionErrors(channelName, limit = 20) {
+		const store = this.resolveStore();
+		if (!store) return [];
+		const channelId = this.resolveChannelId(channelName);
+		if (channelName && !channelId) return [];
+		const reader = new ConnectorDiagnosticSqlReader(store);
+		const rows = channelId ? queryRows(reader, "SELECT seq, ts, type, status, detail FROM connection WHERE channel_id = ? AND status IN ('auth-failed','error') ORDER BY seq DESC LIMIT ?", [channelId, limit]) : queryRows(reader, "SELECT seq, ts, type, status, detail FROM connection WHERE status IN ('auth-failed','error') ORDER BY seq DESC LIMIT ?", [limit]);
+		if (rows instanceof Error) return [];
+		return rows.reverse().map(toDiagnosticConnectionError);
+	}
+	async replay(channelName, seq) {
+		const channel = this.props.channels.list().find((ch) => ch.name === channelName);
+		if (!channel) return { state: "not-found" };
+		const store = this.resolveStore();
+		if (!store) return {
+			state: "error",
+			reason: "no diagnostic store yet"
+		};
+		const reader = new ConnectorDiagnosticSqlReader(store);
+		const rows = seq !== void 0 ? queryRows(reader, "SELECT seq, event_id, type, payload, connector_id, channel_id FROM processed WHERE channel_id = ? AND seq = ? LIMIT 1", [channel.id, seq]) : queryRows(reader, "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", [channel.id]);
+		if (rows instanceof Error) return {
+			state: "error",
+			reason: rows.message
+		};
+		const firstRow = rows[0];
+		if (!firstRow) return { state: "not-found" };
+		const replaySeq = typeof firstRow.seq === "number" ? firstRow.seq : null;
+		const eventId = typeof firstRow.event_id === "string" ? firstRow.event_id : null;
+		const connectorId = typeof firstRow.connector_id === "string" ? firstRow.connector_id : null;
+		let content = typeof firstRow.payload === "string" ? firstRow.payload : null;
+		if ((!content || content.length === 0) && eventId) {
+			const rawRows = queryRows(new ConnectorDiagnosticSqlReader(store), "SELECT payload FROM raw WHERE event_id = ? LIMIT 1", [eventId]);
+			const rawRow = rawRows instanceof Error ? null : rawRows[0];
+			if (rawRow) content = typeof rawRow.payload === "string" ? rawRow.payload : null;
+		}
+		if (!content) return {
+			state: "error",
+			reason: "event has no payload to replay"
+		};
+		const connectorName = connectorOf(channel, connectorId);
+		const result = await this.props.publisher.publish(channel.name, {
+			content,
+			connector: connectorName
+		});
+		if (result.state === "offline") return { state: "offline" };
+		if (result.state === "error") return {
+			state: "error",
+			reason: result.reason
+		};
+		return {
+			state: "ok",
+			seq: replaySeq,
+			offset: result.offset,
+			preview: content.slice(0, 60)
+		};
+	}
+	resolveStore() {
+		const tmpDir = this.props.tmpDir;
+		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
+		};
+	}
+	resolveChannelId(channelName) {
+		if (!channelName) return null;
+		return this.props.channels.list().find((ch) => ch.name === channelName)?.id ?? null;
+	}
+	async fetchGatewayStatus() {
+		const gatewayStatus = this.props.gateway.getStatus();
+		if (!gatewayStatus.running) return null;
+		const token = this.props.gatewayToken.read();
+		const headers = token ? { Authorization: `Bearer ${token}` } : {};
+		const res = await fetch(`http://127.0.0.1:${gatewayStatus.port}/status`, { headers }).catch(() => null);
+		if (!res || !res.ok) return null;
+		const body = await res.json();
+		return isGatewayStatusResponse(body) ? body : null;
+	}
+	async buildChannelDiagnosis(target, gatewayBody, store, eventLimit) {
+		const gatewayStatus = this.props.gateway.getStatus();
+		const targetName = target.name;
+		const baseReport = {
+			channel: targetName,
+			channelId: target.id,
+			gateway: {
+				running: gatewayStatus.running,
+				pid: gatewayStatus.pid,
+				port: gatewayStatus.running ? gatewayStatus.port : null,
+				uptimeMs: gatewayBody?.uptimeMs ?? null
+			},
+			listeners: [],
+			claudeClients: 0,
+			recentEvents: [],
+			connectionErrors: []
+		};
+		if (gatewayBody) {
+			baseReport.listeners = gatewayBody.listeners.filter((l) => l.channelName === targetName).map((l) => ({
+				name: l.name,
+				type: l.type,
+				alive: l.alive,
+				events: l.events,
+				errors: l.errors,
+				lastEventAt: l.lastEventAt
+			}));
+			baseReport.claudeClients = gatewayBody.clients.filter((cl) => cl.channelName === targetName).length;
+		}
+		if (store) {
+			const evRows = queryRows(new ConnectorDiagnosticSqlReader(store), "SELECT seq, ts, type, outcome, payload FROM processed WHERE channel_id = ? ORDER BY seq DESC LIMIT ?", [target.id, eventLimit]);
+			if (!(evRows instanceof Error)) baseReport.recentEvents = evRows.reverse().map(toDiagnosticEvent);
+			const hasDeadListeners = baseReport.listeners.some((l) => !l.alive);
+			const hasListenerErrors = baseReport.listeners.some((l) => l.errors > 0);
+			if (hasDeadListeners || hasListenerErrors) {
+				const errRows = queryRows(new ConnectorDiagnosticSqlReader(store), "SELECT ts, type, status, detail FROM connection WHERE channel_id = ? AND status IN ('auth-failed','error') ORDER BY seq DESC LIMIT 3", [target.id]);
+				if (!(errRows instanceof Error)) baseReport.connectionErrors = errRows.reverse().map(toDiagnosticConnectionError);
+			}
+		}
+		return {
+			...baseReport,
+			diagnosis: buildDiagnosis(baseReport)
+		};
+	}
+};
+//#endregion
+export { toDiagnosticEvent as a, toDiagnosticConnectionError as i, previewOf as n, queryRows as r, FunnelDiagnostics as t };