@interactive-inc/claude-funnel 0.60.1 → 0.64.0

package/dist/{funnel-diagnostics-CSiJmPlZ.js → funnel-diagnostics-Cvk6Sk4x.js}

@@ -1,7 +1,8 @@
-import { t as gatewayLoopbackUrl } from "./gateway-base-url-Dy4Ykuoh.js";
-import { t as ConnectorDiagnosticSqlReader } from "./diagnostic-sql-reader-C9zR-Csp.js";
+import { n as gatewayLoopbackUrl, t as loopbackFetch } from "./loopback-fetch-CVNuN3YZ.js";
+import { t as errorMessageOf } from "./error-message-of-ColuYmAk.js";
+import { t as ConnectorDiagnosticSqlReader } from "./diagnostic-sql-reader-oXZnWFf_.js";
 import { join } from "node:path";
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync } 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;
@@ -63,21 +64,44 @@ const connectorOf = (channel, connectorId) => {
 	if (connectorId === null) return void 0;
 	return channel.connectors?.find((connector) => connector.id === connectorId)?.name;
 };
+const FLAPPING_ERROR_THRESHOLD = 3;
 const buildDiagnosis = (report) => {
 	const rootCause = (report.connectionErrors[report.connectionErrors.length - 1] ?? null)?.detail ?? null;
+	const channel = report.channel;
 	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 {
+	if (report.gateway.statusError !== null) return {
+		status: "error",
+		message: `gateway running but status probe failed: ${report.gateway.statusError}`,
+		nextActions: ["fnl gateway restart"],
+		rootCause: report.gateway.statusError
+	};
+	if (report.configuredConnectors > report.listeners.length) return {
+		status: "error",
+		message: `${report.configuredConnectors} connector(s) configured but ${report.listeners.length} registered with supervisor`,
+		nextActions: ["fnl gateway restart"],
+		rootCause: "supervisor missing listeners declared in settings.json"
+	};
+	if (report.configuredConnectors === 0) return {
 		status: "warn",
 		message: "no connectors configured on this channel",
 		nextActions: [`fnl channels ${channel} connectors add <name> --type=slack ...`],
 		rootCause: null
 	};
+	const authFailed = report.connectionErrors.filter((e) => e.status === "auth-failed");
+	if (authFailed.length > 0) {
+		const detail = authFailed[authFailed.length - 1]?.detail ?? null;
+		return {
+			status: "error",
+			message: "connector credentials rejected (auth-failed)",
+			nextActions: [`fnl channels ${channel} connectors set <connector> --bot-token=<new>`, "fnl gateway restart"],
+			rootCause: detail ?? "token rejected by upstream auth.test"
+		};
+	}
 	const allDead = report.listeners.every((l) => !l.alive);
 	const someDead = report.listeners.some((l) => !l.alive);
 	if (allDead) return {
@@ -92,6 +116,13 @@ const buildDiagnosis = (report) => {
 		nextActions: ["fnl doctor --fix"],
 		rootCause
 	};
+	const flapping = report.listeners.filter((l) => l.errors >= FLAPPING_ERROR_THRESHOLD);
+	if (flapping.length > 0) return {
+		status: "warn",
+		message: `listener(s) flapping (≥${FLAPPING_ERROR_THRESHOLD} errors): ${flapping.map((l) => l.name).join(", ")}`,
+		nextActions: ["fnl gateway logs"],
+		rootCause
+	};
 	if (report.claudeClients === 0) return {
 		status: "warn",
 		message: "no Claude connected to this channel",
@@ -141,15 +172,15 @@ var FunnelDiagnostics = class {
 		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 gatewayProbe = await this.fetchGatewayStatus();
 		const store = this.resolveStore();
-		return this.buildChannelDiagnosis(target, gatewayBody, store, 5);
+		return this.buildChannelDiagnosis(target, gatewayProbe, store, 5);
 	}
 	async diagnoseAll() {
 		const channels = this.props.channels.list();
-		const gatewayBody = await this.fetchGatewayStatus();
+		const gatewayProbe = await this.fetchGatewayStatus();
 		const store = this.resolveStore();
-		const reports = await Promise.all(channels.map((ch) => this.buildChannelDiagnosis(ch, gatewayBody, store, 5)));
+		const reports = await Promise.all(channels.map((ch) => this.buildChannelDiagnosis(ch, gatewayProbe, 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);
@@ -167,36 +198,97 @@ var FunnelDiagnostics = class {
 			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]);
+	async recentEvents(channelName, options = {}) {
+		const limit = options.limit ?? 20;
+		const ids = this.resolveScope(channelName, options.connector);
+		if (ids === null) return [];
+		const rows = queryRows(new ConnectorDiagnosticSqlReader(ids.store), `SELECT seq, ts, type, outcome, payload, event_id FROM processed ${ids.whereClause} ORDER BY seq DESC LIMIT ?`, [...ids.params, 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]);
+	async droppedEvents(channelName, options = {}) {
+		const limit = options.limit ?? 20;
+		const ids = this.resolveScope(channelName, options.connector);
+		if (ids === null) return [];
+		const where = ids.whereClause ? `${ids.whereClause} AND outcome LIKE 'skip:%'` : "WHERE outcome LIKE 'skip:%'";
+		const rows = queryRows(new ConnectorDiagnosticSqlReader(ids.store), `SELECT seq, ts, type, outcome, payload, event_id FROM processed ${where} ORDER BY seq DESC LIMIT ?`, [...ids.params, 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]);
+	/**
+	* Raw inbound rows the connector recorded before any processing. The most
+	* useful read when "did the event even reach us?" is the question, since
+	* the processed table never gets a row for an event the listener dropped
+	* pre-processor.
+	*/
+	async rawEvents(channelName, options = {}) {
+		const limit = options.limit ?? 20;
+		const ids = this.resolveScope(channelName, options.connector);
+		if (ids === null) return [];
+		const rows = queryRows(new ConnectorDiagnosticSqlReader(ids.store), `SELECT seq, ts, type, '' AS outcome, payload, event_id FROM raw ${ids.whereClause} ORDER BY seq DESC LIMIT ?`, [...ids.params, limit]);
+		if (rows instanceof Error) return [];
+		return rows.reverse().map(toDiagnosticEvent);
+	}
+	async connectionErrors(channelName, options = {}) {
+		const limit = options.limit ?? 20;
+		const ids = this.resolveScope(channelName, options.connector);
+		if (ids === null) return [];
+		const where = ids.whereClause ? `${ids.whereClause} AND status IN ('auth-failed','error')` : "WHERE status IN ('auth-failed','error')";
+		const rows = queryRows(new ConnectorDiagnosticSqlReader(ids.store), `SELECT seq, ts, type, status, detail FROM connection ${where} ORDER BY seq DESC LIMIT ?`, [...ids.params, limit]);
 		if (rows instanceof Error) return [];
 		return rows.reverse().map(toDiagnosticConnectionError);
 	}
+	/**
+	* Full connection lifecycle for one channel/connector — started, connected,
+	* disconnected, stopped, plus the auth-failed / error rows that
+	* `connectionErrors()` already surfaces. Use when you need to see the shape
+	* of a flap (connected → reconnecting → connected → disconnected) instead
+	* of just the failures.
+	*/
+	async connectionTimeline(channelName, options = {}) {
+		const limit = options.limit ?? 20;
+		const ids = this.resolveScope(channelName, options.connector);
+		if (ids === null) return [];
+		const rows = queryRows(new ConnectorDiagnosticSqlReader(ids.store), `SELECT seq, ts, type, status, detail FROM connection ${ids.whereClause} ORDER BY seq DESC LIMIT ?`, [...ids.params, limit]);
+		if (rows instanceof Error) return [];
+		return rows.reverse().map(toDiagnosticConnectionError);
+	}
+	/**
+	* Tail of `~/.funnel/.../funnel.log`. Use when a flume internal log (e.g.
+	* `slack/auth.test failed`) needs to be read from MCP — the gateway file
+	* sink is the only place that captures structured FunnelLogger output.
+	*
+	* `grep` is a case-insensitive substring filter applied after read so all
+	* matching levels and sources are scanned.
+	*/
+	async recentLogs(options = {}) {
+		const limit = options.limit ?? 200;
+		const path = join(this.props.tmpDir, "funnel.log");
+		if (!existsSync(path)) return {
+			lines: [],
+			path: null,
+			truncated: false
+		};
+		let content;
+		try {
+			content = readFileSync(path, "utf-8");
+		} catch (error) {
+			return {
+				lines: [`(read failed: ${errorMessageOf(error)})`],
+				path,
+				truncated: false
+			};
+		}
+		const all = content.split("\n").filter((line) => line.length > 0);
+		const needle = options.grep?.toLowerCase();
+		const filtered = needle ? all.filter((line) => line.toLowerCase().includes(needle)) : all;
+		const truncated = filtered.length > limit;
+		return {
+			lines: truncated ? filtered.slice(filtered.length - limit) : filtered,
+			path,
+			truncated
+		};
+	}
 	async replay(channelName, seq) {
 		const channel = this.props.channels.list().find((ch) => ch.name === channelName);
 		if (!channel) return { state: "not-found" };
@@ -259,19 +351,79 @@ var FunnelDiagnostics = class {
 		if (!channelName) return null;
 		return this.props.channels.list().find((ch) => ch.name === channelName)?.id ?? null;
 	}
+	/**
+	* Resolves a (channel, connector) filter into the SQL where-clause + the
+	* positional params, or returns `null` when the requested scope cannot be
+	* resolved (channel not found, connector not found in that channel, no
+	* store on disk yet). Centralises the channel/connector → id mapping so
+	* each read method does not redo the lookup.
+	*/
+	resolveScope(channelName, connectorName) {
+		const store = this.resolveStore();
+		if (!store) return null;
+		if (!channelName) return {
+			store,
+			whereClause: "",
+			params: []
+		};
+		const channel = this.props.channels.list().find((ch) => ch.name === channelName) ?? null;
+		if (!channel) return null;
+		if (!connectorName) return {
+			store,
+			whereClause: "WHERE channel_id = ?",
+			params: [channel.id]
+		};
+		const connectorId = channel.connectors?.find((c) => c.name === connectorName)?.id ?? null;
+		if (!connectorId) return null;
+		return {
+			store,
+			whereClause: "WHERE channel_id = ? AND connector_id = ?",
+			params: [channel.id, connectorId]
+		};
+	}
 	async fetchGatewayStatus() {
 		const gatewayStatus = this.props.gateway.getStatus();
-		if (!gatewayStatus.running) return null;
+		if (!gatewayStatus.running) return {
+			body: null,
+			error: null
+		};
 		const token = this.props.gatewayToken.read();
 		const headers = token ? { Authorization: `Bearer ${token}` } : {};
-		const res = await fetch(`${gatewayLoopbackUrl(gatewayStatus.port)}/status`, { headers }).catch(() => null);
-		if (!res || !res.ok) return null;
-		const body = await res.json();
-		return isGatewayStatusResponse(body) ? body : null;
+		let res = null;
+		try {
+			res = await loopbackFetch(`${gatewayLoopbackUrl(gatewayStatus.port)}/status`, { headers });
+		} catch (error) {
+			return {
+				body: null,
+				error: `fetch failed: ${errorMessageOf(error)}`
+			};
+		}
+		if (!res.ok) return {
+			body: null,
+			error: `gateway /status returned ${res.status}`
+		};
+		let body;
+		try {
+			body = await res.json();
+		} catch (error) {
+			return {
+				body: null,
+				error: `gateway /status body parse failed: ${errorMessageOf(error)}`
+			};
+		}
+		if (!isGatewayStatusResponse(body)) return {
+			body: null,
+			error: "gateway /status returned an unrecognized shape"
+		};
+		return {
+			body,
+			error: null
+		};
 	}
-	async buildChannelDiagnosis(target, gatewayBody, store, eventLimit) {
+	async buildChannelDiagnosis(target, gatewayProbe, store, eventLimit) {
 		const gatewayStatus = this.props.gateway.getStatus();
 		const targetName = target.name;
+		const gatewayBody = gatewayProbe.body;
 		const baseReport = {
 			channel: targetName,
 			channelId: target.id,
@@ -279,8 +431,10 @@ var FunnelDiagnostics = class {
 				running: gatewayStatus.running,
 				pid: gatewayStatus.pid,
 				port: gatewayStatus.running ? gatewayStatus.port : null,
-				uptimeMs: gatewayBody?.uptimeMs ?? null
+				uptimeMs: gatewayBody?.uptimeMs ?? null,
+				statusError: gatewayProbe.error
 			},
+			configuredConnectors: target.connectors?.length ?? 0,
 			listeners: [],
 			claudeClients: 0,
 			recentEvents: [],
@@ -300,12 +454,8 @@ var FunnelDiagnostics = class {
 		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);
-			}
+			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,

package/dist/{funnel-diagnostics-DpXOsCty.d.ts → funnel-diagnostics-b9ar0Ing.d.ts}

@@ -1,4 +1,4 @@
-import { t as ChannelConfig } from "./settings-schema-D1xcOqRu.js";
+import { t as ChannelConfig } from "./settings-schema-BL_c2Udm.js";
 
 //#region lib/engine/diagnostic-log/diagnostic-sql-reader.d.ts
 type Props$1 = {
@@ -104,7 +104,15 @@ type ChannelDiagnosis = {
     pid: number | null;
     port: number | null;
     uptimeMs: number | null;
-  };
+    /**
+     * Why the gateway /status probe failed to return a body. `null` when the
+     * gateway is not running (running=false makes the absence self-explanatory)
+     * or when the probe succeeded. A non-null value signals the daemon is up
+     * but the probe failed (auth refused, fetch error, non-OK response).
+     */
+    statusError: string | null;
+  }; /** Connectors declared in settings for this channel. */
+  configuredConnectors: number;
   listeners: Array<{
     name: string;
     type: string;
@@ -163,12 +171,66 @@ declare class FunnelDiagnostics {
   constructor(props: Props);
   diagnose(channelName?: string): Promise<ChannelDiagnosis | null>;
   diagnoseAll(): Promise<DiagnoseAllReport>;
-  recentEvents(channelName: string | null, limit?: number): Promise<DiagnosticEvent[]>;
-  droppedEvents(channelName: string | null, limit?: number): Promise<DiagnosticEvent[]>;
-  connectionErrors(channelName: string | null, limit?: number): Promise<DiagnosticConnectionError[]>;
+  recentEvents(channelName: string | null, options?: {
+    connector?: string;
+    limit?: number;
+  }): Promise<DiagnosticEvent[]>;
+  droppedEvents(channelName: string | null, options?: {
+    connector?: string;
+    limit?: number;
+  }): Promise<DiagnosticEvent[]>;
+  /**
+   * Raw inbound rows the connector recorded before any processing. The most
+   * useful read when "did the event even reach us?" is the question, since
+   * the processed table never gets a row for an event the listener dropped
+   * pre-processor.
+   */
+  rawEvents(channelName: string | null, options?: {
+    connector?: string;
+    limit?: number;
+  }): Promise<DiagnosticEvent[]>;
+  connectionErrors(channelName: string | null, options?: {
+    connector?: string;
+    limit?: number;
+  }): Promise<DiagnosticConnectionError[]>;
+  /**
+   * Full connection lifecycle for one channel/connector — started, connected,
+   * disconnected, stopped, plus the auth-failed / error rows that
+   * `connectionErrors()` already surfaces. Use when you need to see the shape
+   * of a flap (connected → reconnecting → connected → disconnected) instead
+   * of just the failures.
+   */
+  connectionTimeline(channelName: string | null, options?: {
+    connector?: string;
+    limit?: number;
+  }): Promise<DiagnosticConnectionError[]>;
+  /**
+   * Tail of `~/.funnel/.../funnel.log`. Use when a flume internal log (e.g.
+   * `slack/auth.test failed`) needs to be read from MCP — the gateway file
+   * sink is the only place that captures structured FunnelLogger output.
+   *
+   * `grep` is a case-insensitive substring filter applied after read so all
+   * matching levels and sources are scanned.
+   */
+  recentLogs(options?: {
+    grep?: string;
+    limit?: number;
+  }): Promise<{
+    lines: string[];
+    path: string | null;
+    truncated: boolean;
+  }>;
   replay(channelName: string, seq?: number): Promise<ReplayResult>;
   resolveStore(): StorePaths | null;
   private resolveChannelId;
+  /**
+   * Resolves a (channel, connector) filter into the SQL where-clause + the
+   * positional params, or returns `null` when the requested scope cannot be
+   * resolved (channel not found, connector not found in that channel, no
+   * store on disk yet). Centralises the channel/connector → id mapping so
+   * each read method does not redo the lookup.
+   */
+  private resolveScope;
   private fetchGatewayStatus;
   private buildChannelDiagnosis;
 }

package/dist/{funnel-docs-BxXZ9Ksx.js → funnel-docs-C-ge0MuB.js}

@@ -494,9 +494,10 @@ Hono app over these services.
   import { Funnel } from "@interactive-inc/claude-funnel"
   import { slackConnector } from "@interactive-inc/claude-funnel/connectors/slack"
 
-  // Connectors are fully DI: pass only the types you use. The core import never
-  // bundles a connector SDK (@slack/bolt, discord.js) — importing the sub-entry
-  // does. With no connectors, the funnel handles zero connector types.
+  // Connectors are fully DI: pass only the types you use. The core import
+  // never bundles a connector's protocol code (Socket Mode / Gateway / poller)
+  // — importing the sub-entry does. With no connectors, the funnel handles
+  // zero connector types.
   const funnel = new Funnel({ connectors: [slackConnector()] })  // uses ~/.funnel
   const sandbox = Funnel.inMemory()        // touches no disk / process / clock
 
@@ -543,9 +544,44 @@ For targeted imports (smaller bundle / clearer dependency footprint):
   import { discordConnector }    from "@interactive-inc/claude-funnel/connectors/discord"
   import { scheduleConnector }   from "@interactive-inc/claude-funnel/connectors/schedule"
 
-  // Connector launch hooks are closed over by the descriptor factory:
-  //   slackConnector({ onAppCreated, preprocessEvent })
-  //   scheduleConnector({ onFired })
+  // Schedule fires can be observed by passing onFired to the descriptor:
+  //   scheduleConnector({ onFired: (entry, firedAt) => { ... } })
+
+── flume 0.9 transport notes ───────────────────────────────────────────────
+
+Slack / Discord / GitHub connectors wrap @interactive-inc/flume 0.9. Each
+listener owns a single-source Flume FSM and reconnect is enabled by
+default (infinite attempts, 1s base / 30s max exponential backoff +
+jitter), so a wifi drop or upstream socket close auto-recovers without
+the supervisor intervening.
+
+   Source ctor                      Flume options (cross-cutting)
+   -----------                      -----------------------------
+   FlumeSlackSource({appToken,      sources / onEvent (firehose) /
+       botToken})                   onError / signal / deps / reconnect
+   FlumeDiscordSource({token,
+       intents})                    Flume 0.9 collapsed every
+   FlumeGitHubSource({token,        observation into one firehose: the
+       pollInterval})               onEvent callback receives a union of
+                                    { kind: "event" } | { kind: "log" }.
+                                    Funnel's base listener splits this
+                                    back into typed events, log forward,
+                                    and status mapping for subclasses.
+
+new Funnel({ signal: controller.signal }) plumbs the AbortSignal down to
+every Flume so a host SIGTERM handler can stop every listener cleanly:
+
+   const controller = new AbortController()
+   process.on("SIGTERM", () => controller.abort())
+   const funnel = new Funnel({
+     connectors: [slackConnector(), ghConnector()],
+     signal: controller.signal,
+   })
+
+Custom connector types: extend FlumeSource from the flume package and
+write your own ConnectorDescriptor — that's the only escape hatch for
+host-specific protocol logic, since the bundled descriptors don't take
+extension hooks.
 
 ── in-process gateway: receive events in your own process ──────────────────
 

package/dist/{funnel-doctor-CZf_0Luq.d.ts → funnel-doctor-CnRQi4kM.d.ts}

@@ -1,5 +1,5 @@
-import { c as FunnelDiagnostics, n as DiagnoseAllReport, t as ChannelDiagnosis } from "./funnel-diagnostics-DpXOsCty.js";
-import { n as RecoveryAction, t as FunnelRecovery } from "./funnel-recovery-DnLrdWO9.js";
+import { c as FunnelDiagnostics, n as DiagnoseAllReport, t as ChannelDiagnosis } from "./funnel-diagnostics-b9ar0Ing.js";
+import { n as RecoveryAction, t as FunnelRecovery } from "./funnel-recovery-CMhY8Jfk.js";
 
 //#region lib/services/doctor/funnel-doctor.d.ts
 type Props = {

package/dist/{funnel-doctor-DiJCjHsg.js → funnel-doctor-XrI2GBH8.js}

@@ -34,7 +34,7 @@ var FunnelDoctor = class {
 			if (!result.ok && result.actions.length === 0) fixFailed = true;
 		}
 		if (mode === "aggressive") {
-			if (applied.length === 0 || before.channels.some((ch) => ch.diagnosis.status === "error")) {
+			if ((await this.props.diagnostics.diagnoseAll()).channels.some((ch) => ch.diagnosis.status === "error")) {
 				const result = await this.props.recovery.restartGateway();
 				applied.push(...result.actions);
 				if (!result.ok) fixFailed = true;

package/dist/funnel-error-0t1MK1R6.js

@@ -0,0 +1,75 @@
+//#region lib/engine/error/funnel-error.ts
+/**
+* Base class every typed funnel error extends. Hosts can branch with
+* `instanceof FunnelError` to distinguish library failures from arbitrary
+* thrown values, then narrow to a specific subclass for action-grade
+* matching. The `code` field is the discriminant for serialisation /
+* cross-process boundaries where prototypes do not survive.
+*/
+var FunnelError = class extends Error {
+	constructor(message, options) {
+		super(message);
+		this.name = new.target.name;
+		if (options?.cause !== void 0) Object.defineProperty(this, "cause", {
+			value: options.cause,
+			enumerable: false
+		});
+	}
+};
+var FunnelChannelNotFoundError = class extends FunnelError {
+	code = "channel-not-found";
+	constructor(channel, options) {
+		super(`channel not found: ${channel}`, options);
+		this.channel = channel;
+	}
+};
+var FunnelChannelAlreadyExistsError = class extends FunnelError {
+	code = "channel-already-exists";
+	constructor(channel, options) {
+		super(`channel already exists: ${channel}`, options);
+		this.channel = channel;
+	}
+};
+var FunnelConnectorNotFoundError = class extends FunnelError {
+	code = "connector-not-found";
+	constructor(channel, connector, options) {
+		super(`connector not found in ${channel}: ${connector}`, options);
+		this.channel = channel;
+		this.connector = connector;
+	}
+};
+var FunnelConnectorTypeMismatchError = class extends FunnelError {
+	code = "connector-type-mismatch";
+	constructor(connector, expected, actual, options) {
+		super(`connector ${connector} type mismatch: expected ${expected}, got ${actual}`, options);
+		this.connector = connector;
+		this.expected = expected;
+		this.actual = actual;
+	}
+};
+var FunnelAuthFailedError = class extends FunnelError {
+	code = "auth-failed";
+	constructor(connector, detail, options) {
+		super(`${connector}: auth failed — ${detail}`, options);
+		this.connector = connector;
+		this.detail = detail;
+	}
+};
+var FunnelGatewayBindError = class extends FunnelError {
+	code = "gateway-bind";
+	constructor(host, port, detail, options) {
+		super(`gateway failed to bind ${host}:${port} — ${detail}`, options);
+		this.host = host;
+		this.port = port;
+		this.detail = detail;
+	}
+};
+var FunnelTokenCollisionError = class extends FunnelError {
+	code = "token-collision";
+	constructor(connector, options) {
+		super(`${connector}: both literal token and tokenEnv reference are set — pick one`, options);
+		this.connector = connector;
+	}
+};
+//#endregion
+export { FunnelConnectorTypeMismatchError as a, FunnelTokenCollisionError as c, FunnelConnectorNotFoundError as i, FunnelChannelAlreadyExistsError as n, FunnelError as o, FunnelChannelNotFoundError as r, FunnelGatewayBindError as s, FunnelAuthFailedError as t };

package/dist/{funnel-recovery-DnLrdWO9.d.ts → funnel-recovery-CMhY8Jfk.d.ts}

@@ -1,4 +1,4 @@
-import { t as ChannelConfig } from "./settings-schema-D1xcOqRu.js";
+import { t as ChannelConfig } from "./settings-schema-BL_c2Udm.js";
 
 //#region lib/services/recovery/funnel-recovery.d.ts
 /** Narrow gateway control — start / stop / restart and a probe. */