@interactive-inc/claude-funnel 0.59.1 → 0.60.0

package/dist/connectors/schedule.d.ts

@@ -1,4 +1,6 @@
-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-DoMPjHZj.js";
+import { B as FunnelLogger, D as FunnelConnectorListener, O as NotifyFn, p as ConnectorDiagnosticLog, r as ConnectorDescriptor } from "../connector-descriptor-6SXJoszo.js";
+import { n as FunnelFileSystem } from "../file-system-o51IsM0W.js";
+import { z } from "zod";
 
 //#region lib/engine/connectors/match-cron.d.ts
 /**
@@ -13,4 +15,124 @@ import { a as ScheduleEntry, c as scheduleEntrySchema, i as ScheduleConnectorCon
  */
 declare const matchCron: (expr: string, date: Date) => boolean;
 //#endregion
-export { FunnelScheduleListener, ScheduleCatchupPolicy, ScheduleConnectorConfig, ScheduleEntry, ScheduleOnFired, ScheduleStateStore, matchCron, scheduleCatchupPolicySchema, scheduleConnectorSchema, scheduleEntrySchema };
+//#region lib/engine/connectors/schedule-state-store.d.ts
+type Deps$1 = {
+  path: string;
+  fs?: FunnelFileSystem;
+};
+/**
+ * Per-connector lastFiredAt persistence for the schedule listener. The path is
+ * passed in by the schedule connector descriptor (via the registry's
+ * connectorDir) so this store does not know about the funnel directory layout
+ * (`channels/<id>/connectors/<id>/state.json` lives outside this class).
+ */
+declare class ScheduleStateStore {
+  private readonly path;
+  private readonly fs;
+  constructor(deps: Deps$1);
+  load(): Map<string, Date>;
+  save(state: Map<string, Date>): void;
+}
+//#endregion
+//#region lib/engine/connectors/schedule-connector-schema.d.ts
+/**
+ * Catch-up behavior when the daemon was down past one or more matching minutes.
+ *
+ * - `latest`: fire once with the most recent missed match (default; preserves prior behavior).
+ * - `all`: fire once per missed minute, oldest first (capped at 24 h).
+ * - `skip`: never fire missed matches; only fire when the current minute matches.
+ */
+declare const scheduleCatchupPolicySchema: z.ZodEnum<{
+  latest: "latest";
+  all: "all";
+  skip: "skip";
+}>;
+type ScheduleCatchupPolicy = z.infer<typeof scheduleCatchupPolicySchema>;
+declare const scheduleEntrySchema: z.ZodObject<{
+  id: z.ZodString;
+  cron: z.ZodString;
+  prompt: z.ZodString;
+  enabled: z.ZodDefault<z.ZodBoolean>;
+  catchupPolicy: z.ZodDefault<z.ZodEnum<{
+    latest: "latest";
+    all: "all";
+    skip: "skip";
+  }>>;
+}, z.core.$strip>;
+type ScheduleEntry = z.infer<typeof scheduleEntrySchema>;
+declare const scheduleConnectorSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  type: z.ZodLiteral<"schedule">;
+  entries: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    cron: z.ZodString;
+    prompt: z.ZodString;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    catchupPolicy: z.ZodDefault<z.ZodEnum<{
+      latest: "latest";
+      all: "all";
+      skip: "skip";
+    }>>;
+  }, z.core.$strip>>>;
+  createdAt: z.ZodOptional<z.ZodString>;
+  updatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ScheduleConnectorConfig = z.infer<typeof scheduleConnectorSchema>;
+//#endregion
+//#region lib/engine/connectors/schedule-listener.d.ts
+type ScheduleOnFired = (entry: ScheduleEntry, firedAt: Date) => void | Promise<void>;
+type Deps = {
+  config: ScheduleConnectorConfig;
+  lastFiredStore: ScheduleStateStore; /** Funnel channel uuid this connector lives under; stamped onto diagnostic-log rows. */
+  channelId?: string;
+  logger?: FunnelLogger; /** Diagnostic log of fired entries and lifecycle. No-op when absent. */
+  diagnosticLog?: ConnectorDiagnosticLog;
+  now?: () => Date;
+  /**
+   * Invoked after a schedule entry fires successfully. Use to remove one-shot
+   * entries from the connector config, or to log per-fire side effects.
+   * Errors from this callback are caught and logged; they do not abort the tick.
+   */
+  onFired?: ScheduleOnFired;
+};
+declare class FunnelScheduleListener extends FunnelConnectorListener {
+  private readonly config;
+  private readonly lastFiredStore;
+  private readonly channelId;
+  private readonly logger;
+  private readonly diagnosticLog;
+  private readonly now;
+  private readonly onFired;
+  private timer;
+  private stopped;
+  constructor(deps: Deps);
+  start(notify: NotifyFn): Promise<void>;
+  stop(): Promise<void>;
+  isAlive(): boolean;
+  tick(notify: NotifyFn): Promise<void>;
+  private fireEntry;
+  private notifyOne;
+  private findMostRecentMatch;
+  private findAllMatches;
+  private logInvalidCron;
+  private truncateToMinute;
+  private recordRaw;
+  private recordProcessed;
+  private recordConnection;
+}
+//#endregion
+//#region lib/engine/connectors/schedule-connector.d.ts
+type ScheduleConnectorOptions = {
+  /** Invoked after a schedule entry fires successfully — e.g. to drop one-shot entries. */onFired?: ScheduleOnFired;
+};
+/**
+ * Schedule connector descriptor. Pass `scheduleConnector()` to
+ * `new Funnel({ connectors: [...] })` to enable the type. Schedule has no
+ * outbound adapter; its per-entry CRUD is exposed via `operations`
+ * (listEntries / addEntry / removeEntry) and reached through
+ * `funnel.channels.connectorOp(...)`.
+ */
+declare const scheduleConnector: (options?: ScheduleConnectorOptions) => ConnectorDescriptor;
+//#endregion
+export { FunnelScheduleListener, ScheduleCatchupPolicy, ScheduleConnectorConfig, ScheduleConnectorOptions, ScheduleEntry, ScheduleOnFired, ScheduleStateStore, matchCron, scheduleCatchupPolicySchema, scheduleConnector, scheduleConnectorSchema, scheduleEntrySchema };

package/dist/connectors/schedule.js

@@ -1,3 +1,3 @@
-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 };
+import { n as scheduleConnectorSchema, r as scheduleEntrySchema, t as scheduleCatchupPolicySchema } from "../schedule-connector-schema-CfyuMCMh.js";
+import { i as matchCron, n as FunnelScheduleListener, r as ScheduleStateStore, t as scheduleConnector } from "../schedule-connector-L4uzg5M8.js";
+export { FunnelScheduleListener, ScheduleStateStore, matchCron, scheduleCatchupPolicySchema, scheduleConnector, scheduleConnectorSchema, scheduleEntrySchema };

package/dist/connectors/slack.d.ts

@@ -1,18 +1,48 @@
-import { n as FunnelConnectorAdapter, t as CallInput } from "../connector-adapter-DGacCppE.js";
-import { a as slackConnectorSchema, c as SlackProcessedEmit, d as SlackSkipReason, f as SlackEvent, i as SlackConnectorConfig, l as SlackProcessedSkip, m as SlackReactionEvent, n as SlackOnAppCreated, o as FunnelSlackEventProcessor, p as SlackMessageEvent, r as SlackPreprocessEvent, s as SlackProcessed, t as FunnelSlackListener, u as SlackRawEvent } from "../slack-listener-Dj9NFbAJ.js";
+import { A as FunnelConnectorAdapter, B as FunnelLogger, D as FunnelConnectorListener, O as NotifyFn, k as CallInput, p as ConnectorDiagnosticLog, r as ConnectorDescriptor } from "../connector-descriptor-6SXJoszo.js";
+import { z } from "zod";
+import { App } from "@slack/bolt";
 
+//#region lib/engine/connectors/slack-connector-schema.d.ts
+/**
+ * A slack connector resolves its tokens one of two ways, set at sync time:
+ *
+ *   - literal: `botToken` / `appToken` hold the real `xoxb-`/`xapp-` secret
+ *     (set by a `fnl channels` command or a TTY prompt at launch).
+ *   - by reference: `botTokenEnv` / `appTokenEnv` hold the *name* of an env var.
+ *     The secret never lands in settings.json; the listener resolves it from
+ *     `process.env` at start. This form is only set through the engine API
+ *     (`new Funnel(...)`) — funnel.json and the `fnl` CLI produce literals.
+ *
+ * Both are optional at the schema level (a discriminated-union member can't
+ * carry a cross-field refine); the listener requires exactly one resolved
+ * token per slot and errors loudly otherwise.
+ */
+declare const slackConnectorSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  type: z.ZodLiteral<"slack">;
+  botToken: z.ZodOptional<z.ZodString>;
+  appToken: z.ZodOptional<z.ZodString>;
+  botTokenEnv: z.ZodOptional<z.ZodString>;
+  appTokenEnv: z.ZodOptional<z.ZodString>;
+  minify: z.ZodDefault<z.ZodBoolean>;
+  createdAt: z.ZodOptional<z.ZodString>;
+  updatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type SlackConnectorConfig = z.infer<typeof slackConnectorSchema>;
+//#endregion
 //#region lib/engine/connectors/slack-adapter.d.ts
 type SlackWebClientLike = {
   apiCall: (method: string, options?: Record<string, unknown>) => Promise<unknown>;
 };
-type Deps = {
+type Deps$1 = {
   config: SlackConnectorConfig; /** Environment used to resolve a `botTokenEnv` reference. Defaults to process.env. */
   env?: NodeJS.ProcessEnv;
   client?: SlackWebClientLike;
 };
 declare class FunnelSlackAdapter extends FunnelConnectorAdapter {
   private readonly client;
-  constructor(deps: Deps);
+  constructor(deps: Deps$1);
   call(input: CallInput): Promise<unknown>;
   postMessage(props: {
     channel: string;
@@ -31,4 +61,118 @@ declare class FunnelSlackAdapter extends FunnelConnectorAdapter {
   }): Promise<unknown>;
 }
 //#endregion
-export { FunnelSlackAdapter, FunnelSlackEventProcessor, FunnelSlackListener, SlackConnectorConfig, SlackEvent, SlackMessageEvent, SlackOnAppCreated, SlackPreprocessEvent, SlackProcessed, SlackProcessedEmit, SlackProcessedSkip, SlackRawEvent, SlackReactionEvent, SlackSkipReason, SlackWebClientLike, slackConnectorSchema };
+//#region lib/engine/connectors/slack-event-types.d.ts
+type SlackMessageEvent = {
+  kind: "message";
+  channel: string;
+  user: string;
+  rawText: string;
+  text: string;
+  threadTs: string;
+  ts: string;
+  isThreadRoot: boolean;
+  mentioned: boolean;
+  source: "app_mention" | "message";
+};
+type SlackReactionEvent = {
+  kind: "reaction_added" | "reaction_removed";
+  channel: string;
+  user: string;
+  emoji: string;
+  targetTs: string;
+  targetUser: string | null;
+};
+type SlackEvent = SlackMessageEvent | SlackReactionEvent;
+//#endregion
+//#region lib/engine/connectors/slack-event-processor.d.ts
+type SlackRawEvent = Record<string, unknown>;
+/**
+ * Why the processor dropped an event. Mirrored verbatim into the diagnostic
+ * log's processed `outcome` column so "Slack delivered it but no notification arrived" is
+ * traceable to the exact gate that dropped it. The listener may additionally
+ * record `skip:preprocess` for events a host preprocessor dropped before the
+ * processor ran — that gate is outside this type.
+ */
+type SlackSkipReason = "skip:type" | "skip:subtype" | "skip:dedup" | "skip:self-user" | "skip:self-bot";
+type SlackProcessedSkip = {
+  skip: true;
+  reason: SlackSkipReason;
+};
+type SlackProcessedEmit = {
+  skip: false;
+  event: SlackEvent;
+  content: string;
+  meta: Record<string, string>;
+  shouldReact: boolean;
+  channel: string;
+  timestamp: string;
+};
+type SlackProcessed = SlackProcessedSkip | SlackProcessedEmit;
+type Props = {
+  ownBotUserId: string;
+  ownBotId: string;
+  minify?: boolean;
+  now?: () => number;
+};
+declare class FunnelSlackEventProcessor {
+  private readonly ownBotUserId;
+  private readonly ownBotId;
+  private readonly minify;
+  private readonly now;
+  private readonly dedup;
+  constructor(props: Props);
+  process(event: SlackRawEvent): SlackProcessed;
+}
+//#endregion
+//#region lib/engine/connectors/slack-listener.d.ts
+type SlackOnAppCreated = (app: App) => void | Promise<void>;
+type SlackPreprocessEvent = (event: SlackRawEvent) => SlackRawEvent | null;
+type Deps = {
+  config: SlackConnectorConfig; /** Funnel channel uuid this connector lives under; stamped onto diagnostic-log rows. */
+  channelId?: string; /** Environment used to resolve `botTokenEnv`/`appTokenEnv` references. Defaults to process.env. */
+  env?: NodeJS.ProcessEnv;
+  logger?: FunnelLogger; /** Diagnostic log of inbound events, before and after processing. No-op when absent. */
+  diagnosticLog?: ConnectorDiagnosticLog;
+  /**
+   * Invoked after the Bolt App is constructed, before it starts.
+   * Use to attach app.action handlers, custom middleware, etc.
+   */
+  onAppCreated?: SlackOnAppCreated;
+  /**
+   * Transform or drop the raw Slack event before the built-in processor sees it.
+   * Return null to drop the event entirely.
+   */
+  preprocessEvent?: SlackPreprocessEvent;
+};
+declare class FunnelSlackListener extends FunnelConnectorListener {
+  private readonly config;
+  private readonly channelId;
+  private readonly env;
+  private readonly logger;
+  private readonly diagnosticLog;
+  private readonly onAppCreated;
+  private readonly preprocessEvent;
+  private app;
+  private connected;
+  constructor(deps: Deps);
+  start(notify: NotifyFn): Promise<void>;
+  stop(): Promise<void>;
+  isAlive(): boolean;
+  private recordRaw;
+  private recordProcessed;
+  private recordConnection;
+}
+//#endregion
+//#region lib/engine/connectors/slack-connector.d.ts
+type SlackConnectorOptions = {
+  /** Invoked after the Bolt App is constructed, before start — attach app.action handlers etc. */onAppCreated?: SlackOnAppCreated; /** Transform or drop a raw Slack event before the built-in processor sees it. */
+  preprocessEvent?: SlackPreprocessEvent;
+};
+/**
+ * Slack connector descriptor. Pass `slackConnector()` to
+ * `new Funnel({ connectors: [...] })` to enable the type. Host launch hooks are
+ * closed over here, so they need no Funnel-level option plumbing.
+ */
+declare const slackConnector: (options?: SlackConnectorOptions) => ConnectorDescriptor;
+//#endregion
+export { FunnelSlackAdapter, FunnelSlackEventProcessor, FunnelSlackListener, SlackConnectorConfig, SlackConnectorOptions, SlackEvent, SlackMessageEvent, SlackOnAppCreated, SlackPreprocessEvent, SlackProcessed, SlackProcessedEmit, SlackProcessedSkip, SlackRawEvent, SlackReactionEvent, SlackSkipReason, SlackWebClientLike, slackConnector, slackConnectorSchema };

package/dist/connectors/slack.js

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

package/dist/{diagnostic-sql-reader-CzYgZpq2.js → diagnostic-sql-reader-C9zR-Csp.js}

@@ -1,10 +1,10 @@
 import { Database } from "bun:sqlite";
-//#region lib/gateway/diagnostic-log/diagnostic-sql-reader.ts
+//#region lib/engine/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
+* details (the physical table is `logs` 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.
 *
@@ -59,7 +59,7 @@ const rawViewSql = `CREATE TEMP VIEW raw AS SELECT
   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`;
+FROM main.logs`;
 const processedViewSql = `CREATE TEMP VIEW processed AS SELECT
   seq,
   ts,
@@ -69,7 +69,7 @@ const processedViewSql = `CREATE TEMP VIEW processed AS SELECT
   json_extract(event, '$.channel_id')   AS channel_id,
   json_extract(event, '$.outcome')      AS outcome,
   json_extract(event, '$.payload')      AS payload
-FROM processeddb.leuco_log`;
+FROM processeddb.logs`;
 const connectionViewSql = `CREATE TEMP VIEW connection AS SELECT
   seq,
   ts,
@@ -78,6 +78,6 @@ const connectionViewSql = `CREATE TEMP VIEW connection AS SELECT
   json_extract(event, '$.channel_id')   AS channel_id,
   json_extract(event, '$.status')       AS status,
   json_extract(event, '$.detail')       AS detail
-FROM connectiondb.leuco_log`;
+FROM connectiondb.logs`;
 //#endregion
 export { ConnectorDiagnosticSqlReader as t };

package/dist/diagnostics.d.ts

@@ -1,2 +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-K-wON25Y.js";
+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-DpXOsCty.js";
 export { ChannelDiagnosis, DiagnoseAllReport, DiagnosisStatus, DiagnosticConnectionError, DiagnosticEvent, DiagnosticsChannelSource, DiagnosticsGatewayProbe, DiagnosticsPublisher, DiagnosticsTokenReader, FunnelDiagnostics, ReplayResult, previewOf, queryRows, toDiagnosticConnectionError, toDiagnosticEvent };

package/dist/diagnostics.js

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

package/dist/{discord-listener-CKsZGTnH.js → discord-connector-BL36yvbL.js}

@@ -1,31 +1,10 @@
-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 { t as discordConnectorSchema } from "./discord-connector-schema-B_N6IXLz.js";
+import { t as NodeFunnelHttpClient } from "./node-http-client-lowp60Oa.js";
+import { t as FunnelConnectorAdapter } from "./connector-adapter-DU9Rvyec.js";
+import { t as FunnelConnectorListener } from "./connector-listener-DR3aKOuK.js";
+import { t as errorMessageOf } from "./error-message-of-Byi4y0Uf.js";
+import { n as resolveConnectorToken, t as slotFields } from "./slot-fields-CMoRpwuy.js";
 import { Client, GatewayIntentBits, Partials } from "discord.js";
-//#region lib/engine/http/http-client.ts
-var FunnelHttpClient = class {};
-//#endregion
-//#region lib/engine/http/node-http-client.ts
-var NodeFunnelHttpClient = class extends FunnelHttpClient {
-	constructor() {
-		super();
-		Object.freeze(this);
-	}
-	async fetch(request) {
-		const res = await globalThis.fetch(request.url, {
-			method: request.method,
-			headers: request.headers,
-			body: request.body
-		});
-		return {
-			status: res.status,
-			ok: res.ok,
-			text: () => res.text(),
-			json: () => res.json()
-		};
-	}
-};
-//#endregion
 //#region lib/engine/connectors/discord-adapter.ts
 const DISCORD_API_BASE = "https://discord.com/api/v10";
 const defaultHttp = new NodeFunnelHttpClient();
@@ -145,7 +124,7 @@ var FunnelDiscordListener = class extends FunnelConnectorListener {
 				await notify(result.content, result.meta);
 			} catch (error) {
 				this.recordProcessed(eventId, rawEvent, "emitted:delivery-failed", result.content);
-				this.logger?.error("discord notify error", { error: messageOf(error) });
+				this.logger?.error("discord notify error", { error: errorMessageOf(error) });
 				return;
 			}
 			this.recordProcessed(eventId, rawEvent, "emitted", result.content);
@@ -158,8 +137,8 @@ var FunnelDiscordListener = class extends FunnelConnectorListener {
 			});
 		});
 		client.on("error", (error) => {
-			this.recordConnection("error", messageOf(error));
-			this.logger?.error("discord client error", { error: messageOf(error) });
+			this.recordConnection("error", errorMessageOf(error));
+			this.logger?.error("discord client error", { error: errorMessageOf(error) });
 		});
 		try {
 			await client.login(resolveConnectorToken({
@@ -169,7 +148,7 @@ var FunnelDiscordListener = class extends FunnelConnectorListener {
 				label: `${this.config.name}.botToken`
 			}));
 		} catch (error) {
-			this.recordConnection("error", messageOf(error));
+			this.recordConnection("error", errorMessageOf(error));
 			throw error;
 		}
 		this.client = client;
@@ -181,8 +160,8 @@ var FunnelDiscordListener = class extends FunnelConnectorListener {
 			await this.client.destroy();
 			this.recordConnection("disconnected", "");
 		} catch (error) {
-			this.recordConnection("error", messageOf(error));
-			this.logger?.error("discord stop error", { error: messageOf(error) });
+			this.recordConnection("error", errorMessageOf(error));
+			this.logger?.error("discord stop error", { error: errorMessageOf(error) });
 		} finally {
 			this.client = null;
 			this.recordConnection("stopped", "");
@@ -220,8 +199,52 @@ var FunnelDiscordListener = class extends FunnelConnectorListener {
 		});
 	}
 };
-const messageOf = (error) => {
-	return error instanceof Error ? error.message : String(error);
-};
 //#endregion
-export { FunnelHttpClient as a, NodeFunnelHttpClient as i, FunnelDiscordEventProcessor as n, FunnelDiscordAdapter as r, FunnelDiscordListener as t };
+//#region lib/engine/connectors/discord-connector.ts
+/**
+* Discord connector descriptor. Pass `discordConnector()` to
+* `new Funnel({ connectors: [...] })` to enable the type.
+*/
+const discordConnector = () => ({
+	type: "discord",
+	toolExposed: true,
+	createListener(config, deps) {
+		return new FunnelDiscordListener({
+			config: discordConnectorSchema.parse(config),
+			channelId: deps.channelId,
+			logger: deps.logger,
+			diagnosticLog: deps.diagnosticLog
+		});
+	},
+	createAdapter(config) {
+		return new FunnelDiscordAdapter({ config: discordConnectorSchema.parse(config) });
+	},
+	secretTokens(config) {
+		return [discordConnectorSchema.parse(config).botToken].filter((token) => token !== void 0);
+	},
+	buildConfig(input, context) {
+		return discordConnectorSchema.parse({
+			id: context.id,
+			type: "discord",
+			name: input.name,
+			...typeof input.botToken === "string" ? { botToken: input.botToken } : {},
+			...typeof input.botTokenEnv === "string" ? { botTokenEnv: input.botTokenEnv } : {},
+			createdAt: context.now,
+			updatedAt: context.now
+		});
+	},
+	applyUpdate(config, fields, context) {
+		const current = discordConnectorSchema.parse(config);
+		return discordConnectorSchema.parse({
+			id: current.id,
+			name: current.name,
+			type: "discord",
+			createdAt: current.createdAt,
+			updatedAt: context.now,
+			...slotFields("botToken", "botTokenEnv", fields, current)
+		});
+	},
+	operations: {}
+});
+//#endregion
+export { FunnelDiscordAdapter as i, FunnelDiscordListener as n, FunnelDiscordEventProcessor as r, discordConnector as t };

package/dist/docs.d.ts

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

package/dist/docs.js

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

package/dist/doctor.d.ts

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

package/dist/doctor.js

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

package/dist/error-message-of-Byi4y0Uf.js

@@ -0,0 +1,9 @@
+//#region lib/engine/error/error-message-of.ts
+/**
+* Normalize an unknown thrown value into a loggable message string.
+*/
+const errorMessageOf = (error) => {
+	return error instanceof Error ? error.message : String(error);
+};
+//#endregion
+export { errorMessageOf as t };

package/dist/{file-process-guard-JhFpmHYo.d.ts → file-process-guard-DOlCr4GF.d.ts}

@@ -1,8 +1,7 @@
-import { t as ChannelConfig } from "./settings-schema-1hh11jnN.js";
-import { n as FunnelIdGenerator } from "./settings-reader-DPwqOVUm.js";
-import { S as FunnelLogger } from "./diagnostic-log-Cb3v8P7p.js";
-import { r as FunnelProcessRunner } from "./process-runner-DIm1cy95.js";
-import { n as FunnelFileSystem } from "./file-system-DxpnnUVb.js";
+import { t as ChannelConfig } from "./settings-schema-D1xcOqRu.js";
+import { n as FunnelIdGenerator } from "./settings-reader-BIFB_j2f.js";
+import { B as FunnelLogger, I as FunnelProcessRunner } from "./connector-descriptor-6SXJoszo.js";
+import { n as FunnelFileSystem } from "./file-system-o51IsM0W.js";
 
 //#region lib/engine/claude/channel-resolver.d.ts
 type ChannelResolver = {

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

@@ -1,4 +1,5 @@
-import { t as ConnectorDiagnosticSqlReader } from "./diagnostic-sql-reader-CzYgZpq2.js";
+import { t as gatewayLoopbackUrl } from "./gateway-base-url-Dy4Ykuoh.js";
+import { t as ConnectorDiagnosticSqlReader } from "./diagnostic-sql-reader-C9zR-Csp.js";
 import { join } from "node:path";
 import { existsSync } from "node:fs";
 //#region lib/services/diagnostics/diagnostic-event.ts
@@ -103,6 +104,8 @@ const buildDiagnosis = (report) => {
 		nextActions: ["fnl gateway logs"],
 		rootCause
 	};
+	const slackEventGap = diagnoseSlackEventSubscriptionGap(report);
+	if (slackEventGap !== null) return slackEventGap;
 	return {
 		status: "ok",
 		message: "everything looks healthy",
@@ -110,6 +113,20 @@ const buildDiagnosis = (report) => {
 		rootCause: null
 	};
 };
+const diagnoseSlackEventSubscriptionGap = (report) => {
+	if (!report.listeners.some((listener) => listener.type === "slack") || report.recentEvents.length === 0) return null;
+	const slackEvents = report.recentEvents.filter((event) => event.type === "slack").map((event) => event.payloadParsed?.type);
+	if (slackEvents.length === 0) return null;
+	const sawAppMention = slackEvents.includes("app_mention");
+	const sawMessage = slackEvents.includes("message");
+	if (!sawAppMention || sawMessage) return null;
+	return {
+		status: "warn",
+		message: "Slack is only delivering app_mention events; unmentioned thread replies may not arrive",
+		nextActions: ["Add Slack bot events: message.channels, message.groups, message.im, message.mpim; reinstall the app; then restart the gateway"],
+		rootCause: "Slack Event Subscriptions likely omit message.* events"
+	};
+};
 /**
 * Programmable diagnostics surface — used by both the CLI (fnl debug …) and
 * the MCP tools (fnl_debug, fnl_recent_events, …). Pure read-side, no
@@ -247,7 +264,7 @@ var FunnelDiagnostics = class {
 		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);
+		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;

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

@@ -1,6 +1,6 @@
-import { t as ChannelConfig } from "./settings-schema-1hh11jnN.js";
+import { t as ChannelConfig } from "./settings-schema-D1xcOqRu.js";
 
-//#region lib/gateway/diagnostic-log/diagnostic-sql-reader.d.ts
+//#region lib/engine/diagnostic-log/diagnostic-sql-reader.d.ts
 type Props$1 = {
   /** SQLite file holding the raw (pre-filter) table. */rawPath: string; /** SQLite file holding the processed (verdict) table. */
   processedPath: string; /** SQLite file holding the connection (lifecycle) table. */
@@ -11,7 +11,7 @@ type Row = Record<string, unknown>;
  * 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
+ * details (the physical table is `logs` 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.
  *