@interactive-inc/claude-funnel 0.10.0 → 0.15.1

package/dist/index.d.ts

@@ -2,11 +2,12 @@ import { n as FunnelConnectorAdapter, t as CallInput } from "./connector-adapter
 import { n as discordConnectorSchema, t as DiscordConnectorConfig } from "./discord-connector-schema-Dww2I4zH.js";
 import { n as FunnelConnectorListener, r as NotifyFn, t as FunnelLogger } from "./logger-CTlXs7z4.js";
 import { a as FunnelProcessRunner, i as DetachOptions, n as ghConnectorSchema, o as RunOptions, r as AttachOptions, s as RunResult, t as GhConnectorConfig } from "./gh-connector-schema-BZFAS-p-.js";
-import { a as ScheduleEntry, c as scheduleEntrySchema, i as ScheduleConnectorConfig, n as FunnelFileSystem, o as scheduleCatchupPolicySchema, r as ScheduleCatchupPolicy, s as scheduleConnectorSchema, t as FileStat } from "./file-system-Co60LrmR.js";
-import { n as slackConnectorSchema, t as SlackConnectorConfig } from "./slack-connector-schema-D7zAHN8k.js";
+import { a as FunnelFileSystem, c as ScheduleEntry, d as scheduleEntrySchema, i as FileStat, l as scheduleCatchupPolicySchema, n as ScheduleOnFired, o as ScheduleCatchupPolicy, s as ScheduleConnectorConfig, u as scheduleConnectorSchema } from "./schedule-listener-BPodvbld.js";
+import { a as SlackProcessed, c as SlackRawEvent, i as FunnelSlackEventProcessor, l as SlackConnectorConfig, n as SlackOnAppCreated, o as SlackProcessedEmit, r as SlackPreprocessEvent, s as SlackProcessedSkip, u as slackConnectorSchema } from "./slack-listener-CHj6uMY-.js";
 import { z } from "zod";
-import { Server, ServerWebSocket } from "bun";
 import * as _$hono_factory0 from "hono/factory";
+import { Hono } from "hono";
+import { Server, ServerWebSocket } from "bun";
 import * as _$hono_utils_http_status0 from "hono/utils/http-status";
 import * as _$hono_hono_base0 from "hono/hono-base";
 
@@ -55,11 +56,20 @@ type ConnectorConfig = z.infer<typeof connectorConfigSchema>;
 type ConnectorType = ConnectorConfig["type"];
 //#endregion
 //#region lib/connectors/connector-factory.d.ts
-type Deps$12 = {
+type SlackListenerOptions = {
+  onAppCreated?: SlackOnAppCreated;
+  preprocessEvent?: SlackPreprocessEvent;
+};
+type ScheduleListenerOptions = {
+  onFired?: ScheduleOnFired;
+};
+type Deps$15 = {
   fs?: FunnelFileSystem;
   process?: FunnelProcessRunner;
   logger?: FunnelLogger;
-  dir?: string;
+  dir?: string; /** Per-listener hooks for the slack connector type. Threaded into every Slack listener built by this factory. */
+  slackListenerOptions?: SlackListenerOptions; /** Per-listener hooks for the schedule connector type. Threaded into every Schedule listener built by this factory. */
+  scheduleListenerOptions?: ScheduleListenerOptions;
 };
 /**
  * Pure factory for per-type listeners and adapters. The factory has no CRUD
@@ -68,13 +78,19 @@ type Deps$12 = {
  *
  * `dir` is the funnel home (defaults to ~/.funnel); per-connector state files
  * land at `<dir>/channels/<channel-id>/connectors/<connector-id>/state.json`.
+ *
+ * Host integrations can supply per-type listener hooks via
+ * `slackListenerOptions` / `scheduleListenerOptions` — e.g. to attach a
+ * Bolt `app.action` handler or to drop one-shot schedule entries on fire.
  */
 declare class FunnelConnectorFactory {
   private readonly fs;
   private readonly process;
   private readonly logger;
   private readonly dir;
-  constructor(deps?: Deps$12);
+  private readonly slackListenerOptions;
+  private readonly scheduleListenerOptions;
+  constructor(deps?: Deps$15);
   createListener(channelId: string, config: ConnectorConfig): FunnelConnectorListener;
   createAdapter(config: ConnectorConfig): FunnelConnectorAdapter | null;
   connectorDir(channelId: string, connectorId: string): string;
@@ -252,7 +268,7 @@ declare abstract class FunnelSettingsReader {
 }
 //#endregion
 //#region lib/engine/channels/channels.d.ts
-type Deps$11 = {
+type Deps$14 = {
   store: FunnelSettingsReader;
   factory: FunnelConnectorFactory;
   profileChecker: ProfileChannelChecker;
@@ -295,7 +311,7 @@ declare class FunnelChannels {
   private readonly profileChecker;
   private readonly clock;
   private readonly idGenerator;
-  constructor(deps: Deps$11);
+  constructor(deps: Deps$14);
   list(): ChannelConfig[];
   get(name: string): ChannelConfig | null;
   getById(id: string): ChannelConfig | null;
@@ -339,13 +355,7 @@ declare class FunnelChannels {
     listener: FunnelConnectorListener;
   }[];
   private requireChannel;
-  private requireConnector;
-  private requireSlackConnector;
-  private requireGhConnector;
-  private requireDiscordConnector;
-  private requireScheduleConnector;
   private assertNoTokenCollision;
-  private tokensOf;
 }
 //#endregion
 //#region lib/engine/claude/gateway-controller.d.ts
@@ -359,7 +369,7 @@ type GatewayController = {
 //#region lib/engine/mcp/mcp.d.ts
 declare const FUNNEL_MCP_COMMAND = "funnel";
 declare const FUNNEL_MCP_NAME = "funnel";
-type Deps$10 = {
+type Deps$13 = {
   fs?: FunnelFileSystem;
 };
 /**
@@ -369,7 +379,7 @@ type Deps$10 = {
  */
 declare class FunnelMcp {
   private readonly fs;
-  constructor(deps?: Deps$10);
+  constructor(deps?: Deps$13);
   install(repoPath: string): void;
   uninstall(repoPath: string): void;
   findInstalledName(cwd: string): string | null;
@@ -385,9 +395,10 @@ type LaunchOptions = {
   subAgent?: string;
   userArgs?: string[];
   profileName?: string; /** Forward `--brief` to claude on launch (enables the SendUserMessage tool). */
-  brief?: boolean;
+  brief?: boolean; /** Extra env vars merged under process.env (process.env wins on collision). */
+  extraEnv?: Record<string, string>;
 };
-type Deps$9 = {
+type Deps$12 = {
   channels: FunnelChannels;
   mcp: FunnelMcp;
   gateway: GatewayController;
@@ -410,7 +421,7 @@ declare class FunnelClaude {
   private readonly fs;
   private readonly logger;
   private readonly pidDir;
-  constructor(deps: Deps$9);
+  constructor(deps: Deps$12);
   launch(options: LaunchOptions): Promise<number>;
   isRunning(profileName: string): boolean;
   private pidPath;
@@ -423,6 +434,151 @@ declare class FunnelClaude {
   private buildEnv;
 }
 //#endregion
+//#region lib/engine/local-config/dotenv-reader.d.ts
+type Deps$11 = {
+  fs: FunnelFileSystem;
+};
+/**
+ * Minimal `.env.local` parser. Supports `KEY=value` lines, blank lines, and
+ * `#` comments. Strips matching surrounding single or double quotes. No
+ * interpolation, no `export` prefix — anything fancier should live in a real
+ * env file loaded by the shell.
+ */
+declare class FunnelDotenvReader {
+  private readonly fs;
+  constructor(deps: Deps$11);
+  read(cwd: string): Record<string, string>;
+}
+//#endregion
+//#region lib/engine/local-config/local-config-schema.d.ts
+declare const connectorSpecSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  type: z.ZodLiteral<"slack">;
+  name: z.ZodString;
+  botToken: z.ZodOptional<z.ZodString>;
+  appToken: z.ZodOptional<z.ZodString>;
+  env: z.ZodOptional<z.ZodObject<{
+    botToken: z.ZodOptional<z.ZodString>;
+    appToken: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"discord">;
+  name: z.ZodString;
+  botToken: z.ZodOptional<z.ZodString>;
+  env: z.ZodOptional<z.ZodObject<{
+    botToken: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"gh">;
+  name: z.ZodString;
+  pollInterval: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"schedule">;
+  name: z.ZodString;
+}, z.core.$strip>], "type">;
+type ConnectorSpec = z.infer<typeof connectorSpecSchema>;
+declare const localConfigSchema: z.ZodObject<{
+  $schema: z.ZodOptional<z.ZodString>;
+  channel: z.ZodString;
+  options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  connectors: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"slack">;
+    name: z.ZodString;
+    botToken: z.ZodOptional<z.ZodString>;
+    appToken: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodObject<{
+      botToken: z.ZodOptional<z.ZodString>;
+      appToken: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"discord">;
+    name: z.ZodString;
+    botToken: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodObject<{
+      botToken: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"gh">;
+    name: z.ZodString;
+    pollInterval: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"schedule">;
+    name: z.ZodString;
+  }, z.core.$strip>], "type">>>;
+}, z.core.$strip>;
+type LocalConfig = z.infer<typeof localConfigSchema>;
+declare const LOCAL_CONFIG_FILENAME = "funnel.json";
+declare const LOCAL_ENV_FILENAME = ".env.local";
+//#endregion
+//#region lib/engine/local-config/local-config.d.ts
+type Deps$10 = {
+  fs: FunnelFileSystem;
+};
+/**
+ * Reads `funnel.json` from a directory. Returns `null` when the file is
+ * absent so callers can fall through to other resolution paths (default
+ * profile, help). Throws on present-but-invalid files so misconfiguration
+ * surfaces loudly instead of silently launching the wrong channel.
+ */
+declare class FunnelLocalConfig {
+  private readonly fs;
+  constructor(deps: Deps$10);
+  read(cwd: string): LocalConfig | null;
+}
+//#endregion
+//#region lib/engine/token-prompter/token-prompter.d.ts
+/**
+ * Asks the user for a secret value on stdin. Used as a last resort when a
+ * funnel.json token field is absent and not present in `~/.funnel`. The Node
+ * implementation refuses to prompt when stdin is not a TTY so non-interactive
+ * launches (CI, agent spawning agent, daemons) fail fast instead of hanging.
+ */
+declare abstract class FunnelTokenPrompter {
+  abstract promptSecret(label: string): Promise<string>;
+}
+//#endregion
+//#region lib/engine/local-config/local-config-sync.d.ts
+type Deps$9 = {
+  channels: FunnelChannels;
+  dotenv: FunnelDotenvReader;
+  prompter: FunnelTokenPrompter;
+  env?: NodeJS.ProcessEnv;
+};
+/**
+ * Reconciles a `funnel.json` spec with `~/.funnel/settings.json`. The spec
+ * is the source of truth for the channel it declares:
+ *
+ *   - missing channel → created
+ *   - declared connector matched by name → tokens reconciled
+ *   - declared connector matched by token in the same channel under a
+ *     different name → renamed in place (then tokens reconciled)
+ *   - declared connector with no match → added
+ *   - any connector left in the channel that the spec did not touch → removed
+ *
+ * Removal only fires when funnel.json has a `connectors` field. An absent
+ * field means "do not manage connectors from here" and leaves everything in
+ * `~/.funnel` alone.
+ */
+declare class FunnelLocalConfigSync {
+  private readonly channels;
+  private readonly dotenv;
+  private readonly prompter;
+  private readonly env;
+  constructor(deps: Deps$9);
+  ensure(local: LocalConfig, cwd: string): Promise<void>;
+  private ensureConnector;
+  private ensureSlack;
+  private ensureDiscord;
+  private ensureGh;
+  private ensureSchedule;
+  private findExistingSlack;
+  private findExistingDiscord;
+  private findSlackByToken;
+  private findDiscordByToken;
+  private removeExtras;
+  private resolveField;
+}
+//#endregion
 //#region lib/engine/profiles/profiles.d.ts
 type Deps$8 = {
   store: FunnelSettingsReader;
@@ -501,62 +657,6 @@ declare class FunnelChannelPublisher {
   private authHeaders;
 }
 //#endregion
-//#region lib/gateway/gateway.d.ts
-type Deps$6 = {
-  process?: FunnelProcessRunner;
-  fs?: FunnelFileSystem;
-  clock?: FunnelClock;
-  dir?: string;
-  tmpDir?: string;
-  port?: number;
-  sleep?: (ms: number) => Promise<void>;
-};
-/**
- * Manages the gateway daemon as a separate process via PID file.
- * Use `start()` to spawn `bun daemon.ts` in the background and `stop()` to
- * terminate it. For an in-process gateway, use `Funnel.gatewayServer` instead.
- */
-declare class FunnelGateway {
-  private readonly process;
-  private readonly fs;
-  private readonly clock;
-  private readonly pidFile;
-  private readonly logDir;
-  private readonly gatewayLog;
-  private readonly tmpDir;
-  private readonly port;
-  private readonly sleep;
-  constructor(deps?: Deps$6);
-  isRunning(): boolean;
-  getStatus(): {
-    running: boolean;
-    pid: number | null;
-    port: number;
-  };
-  start(options?: {
-    caffeinate?: boolean;
-  }): Promise<boolean>;
-  buildStartCommand(gatewayScript: string, options?: {
-    caffeinate?: boolean;
-  }): string;
-  stop(): Promise<boolean>;
-  restart(options?: {
-    onlyIfRunning?: boolean;
-    caffeinate?: boolean;
-  }): Promise<{
-    ok: boolean;
-    wasRunning: boolean;
-    stopped: boolean;
-    started: boolean;
-  }>;
-  getLogDir(): string;
-  getGatewayLog(): string;
-  getPort(): number;
-  private readPid;
-  private removePid;
-  private isProcessAlive;
-}
-//#endregion
 //#region lib/gateway/broadcaster.d.ts
 type ClientData = {
   /** Stable channel id (uuid) that the WS client subscribed to. */channel: string; /** Human-facing channel name resolved at upgrade time, kept for log readability. */
@@ -582,7 +682,7 @@ type BroadcastSubscriber = (event: ReplayableEvent) => void;
 type ReplaySource = {
   loadSince(since: number): ReplayableEvent[];
 };
-type Deps$5 = {
+type Deps$6 = {
   logger?: FunnelLogger;
   maxBufferedBytes?: number;
   now?: () => number; /** Number of recent events kept in the in-memory replay buffer. */
@@ -633,7 +733,7 @@ declare class FunnelBroadcaster {
   private droppedSlowClients;
   private lastBroadcastAt;
   private latestOffset;
-  constructor(deps?: Deps$5);
+  constructor(deps?: Deps$6);
   getMetrics(): BroadcasterMetrics;
   /**
    * Returns events with offset > since, filtered by the connector subscription
@@ -669,82 +769,6 @@ declare class FunnelBroadcaster {
   seedLatestOffset(offset: number): void;
 }
 //#endregion
-//#region lib/gateway/funnel-event-store.d.ts
-/**
- * Replayable event payload persisted by the gateway. Domain events the
- * broadcaster emits to WS clients land here so reconnects across daemon
- * restarts can be served from disk. System events (gateway start, channel
- * connected, etc.) are routed to `FunnelLogger` instead — they never go
- * through this store, which keeps the seq space clean for replay.
- */
-declare const funnelEventSchema: z.ZodObject<{
-  type: z.ZodString;
-  content: z.ZodString;
-  channel_id: z.ZodNullable<z.ZodString>;
-  connector_id: z.ZodNullable<z.ZodString>;
-  meta: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>;
-}, z.core.$strip>;
-type FunnelEvent = z.infer<typeof funnelEventSchema>;
-type Props$5 = {
-  /** SQLite database file path. Created on first write. ":memory:" for tests. */path: string; /** Override for tests. Defaults to `Date.now`. */
-  now?: () => number; /** Optional row cap. Pruned on every insert. */
-  maxRows?: number; /** Optional age cap in ms. Pruned on every insert. */
-  maxAgeMs?: number;
-};
-/**
- * SQLite-backed event store. One indexed table holds every broadcaster
- * event with `channel_id` and `connector_id` as dedicated columns, so
- * per-channel and per-connector replay is an indexed range scan.
- *
- * Concurrency: `seq` is `INTEGER PRIMARY KEY`, so SQLite assigns it
- * atomically. The broadcaster owns its own offset counter at runtime
- * (seeded from `findMaxOffset()` at startup); each broadcaster event
- * flows in here via `record()` with that pre-assigned offset, which the
- * sink stores via `write()` — PK uniqueness catches double-emit bugs.
- *
- * System events (gateway lifecycle, channel connect/disconnect, etc.) do
- * NOT go through this store. They are diagnostic only and live in
- * `FunnelLogger`'s file so the seq space here stays exclusive to
- * broadcaster traffic. This is what makes the broadcaster's seq seeding
- * (`getMaxSeq()` at startup) correct without per-event coordination.
- */
-declare class FunnelEventStore {
-  private readonly sink;
-  private readonly now;
-  constructor(props: Props$5);
-  /**
-   * Persist a broadcaster-driven event with its assigned offset. Caller
-   * (the gateway-server) supplies the offset from `broadcaster.broadcast()`
-   * so this store and the broadcaster's in-memory ring stay aligned.
-   */
-  record(props: {
-    content: string;
-    channelId: string | null;
-    connectorId: string | null;
-    meta: Record<string, string> | null;
-    offset: number;
-  }): void;
-  /**
-   * Returns events with offset > since. Filtering by channel/connector is
-   * the broadcaster's responsibility (it knows the client's subscription),
-   * so this returns the full slice and lets the caller filter.
-   */
-  loadSince(since: number): ReplayableEvent[];
-  /**
-   * Returns events for one channel (and optionally one connector). Used
-   * by the gateway logs CLI for scoped queries. Channel/connector filters
-   * are indexed columns, so this is an indexed range scan.
-   */
-  loadForChannel(props: {
-    channelId: string;
-    connectorId?: string;
-    sinceSeq?: number;
-    limit?: number;
-  }): ReplayableEvent[];
-  findMaxOffset(): number;
-  close(): void;
-}
-//#endregion
 //#region lib/gateway/listener-supervisor.d.ts
 type ConnectorRegistry = {
   listAllConnectors(): ChannelConnectorView[];
@@ -755,7 +779,7 @@ type ConnectorRegistry = {
   } | null;
 };
 type SupervisorNotify = (channelName: string, connectorName: string, content: string, meta?: Record<string, string>) => Promise<void>;
-type Deps$4 = {
+type Deps$5 = {
   channels: ConnectorRegistry;
   notify: SupervisorNotify;
   logger?: FunnelLogger;
@@ -800,7 +824,7 @@ declare class FunnelListenerSupervisor {
   private readonly now;
   private healthCheckTimer;
   private healthCheckInFlight;
-  constructor(deps: Deps$4);
+  constructor(deps: Deps$5);
   static keyOf(channelName: string, connectorName: string): string;
   isRunning(channelName: string, connectorName: string): boolean;
   list(): ListenerEntryStatus[];
@@ -827,6 +851,164 @@ declare class FunnelListenerSupervisor {
   private recoverDead;
 }
 //#endregion
+//#region lib/gateway/routes/route-deps.d.ts
+type GatewayEmitInput = {
+  channel: string;
+  connector?: string;
+  content: string;
+  meta?: Record<string, string>;
+};
+type GatewayRouteDeps = {
+  selfPid: number;
+  broadcaster: FunnelBroadcaster;
+  supervisor: FunnelListenerSupervisor;
+  channels: FunnelChannels;
+  uptimeMs: () => number;
+  emit: (input: GatewayEmitInput) => {
+    offset: number;
+  };
+};
+//#endregion
+//#region lib/gateway/factory.d.ts
+type Env$1 = {
+  Variables: {
+    deps: GatewayRouteDeps;
+  };
+};
+//#endregion
+//#region lib/gateway/gateway.d.ts
+type Deps$4 = {
+  process?: FunnelProcessRunner;
+  fs?: FunnelFileSystem;
+  clock?: FunnelClock;
+  dir?: string;
+  tmpDir?: string;
+  port?: number;
+  sleep?: (ms: number) => Promise<void>;
+};
+/**
+ * Manages the gateway daemon as a separate process via PID file.
+ * Use `start()` to spawn `bun daemon.ts` in the background and `stop()` to
+ * terminate it. For an in-process gateway, use `Funnel.gatewayServer` instead.
+ */
+declare class FunnelGateway {
+  private readonly process;
+  private readonly fs;
+  private readonly clock;
+  private readonly dir;
+  private readonly pidFile;
+  private readonly logDir;
+  private readonly gatewayLog;
+  private readonly tmpDir;
+  private readonly port;
+  private readonly sleep;
+  constructor(deps?: Deps$4);
+  isRunning(): boolean;
+  getStatus(): {
+    running: boolean;
+    pid: number | null;
+    port: number;
+  };
+  start(options?: {
+    caffeinate?: boolean;
+  }): Promise<boolean>;
+  buildStartCommand(gatewayScript: string, options?: {
+    caffeinate?: boolean;
+  }): string;
+  stop(): Promise<boolean>;
+  restart(options?: {
+    onlyIfRunning?: boolean;
+    caffeinate?: boolean;
+  }): Promise<{
+    ok: boolean;
+    wasRunning: boolean;
+    stopped: boolean;
+    started: boolean;
+  }>;
+  getLogDir(): string;
+  getGatewayLog(): string;
+  getPort(): number;
+  private readPid;
+  private removePid;
+  private isProcessAlive;
+}
+//#endregion
+//#region lib/gateway/funnel-event-store.d.ts
+/**
+ * Replayable event payload persisted by the gateway. Domain events the
+ * broadcaster emits to WS clients land here so reconnects across daemon
+ * restarts can be served from disk. System events (gateway start, channel
+ * connected, etc.) are routed to `FunnelLogger` instead — they never go
+ * through this store, which keeps the seq space clean for replay.
+ */
+declare const funnelEventSchema: z.ZodObject<{
+  type: z.ZodString;
+  content: z.ZodString;
+  channel_id: z.ZodNullable<z.ZodString>;
+  connector_id: z.ZodNullable<z.ZodString>;
+  meta: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+type FunnelEvent = z.infer<typeof funnelEventSchema>;
+type Props$6 = {
+  /** SQLite database file path. Created on first write. ":memory:" for tests. */path: string; /** Override for tests. Defaults to `Date.now`. */
+  now?: () => number; /** Optional row cap. Pruned on every insert. */
+  maxRows?: number; /** Optional age cap in ms. Pruned on every insert. */
+  maxAgeMs?: number;
+};
+/**
+ * SQLite-backed event store. One indexed table holds every broadcaster
+ * event with `channel_id` and `connector_id` as dedicated columns, so
+ * per-channel and per-connector replay is an indexed range scan.
+ *
+ * Concurrency: `seq` is `INTEGER PRIMARY KEY`, so SQLite assigns it
+ * atomically. The broadcaster owns its own offset counter at runtime
+ * (seeded from `findMaxOffset()` at startup); each broadcaster event
+ * flows in here via `record()` with that pre-assigned offset, which the
+ * sink stores via `write()` — PK uniqueness catches double-emit bugs.
+ *
+ * System events (gateway lifecycle, channel connect/disconnect, etc.) do
+ * NOT go through this store. They are diagnostic only and live in
+ * `FunnelLogger`'s file so the seq space here stays exclusive to
+ * broadcaster traffic. This is what makes the broadcaster's seq seeding
+ * (`getMaxSeq()` at startup) correct without per-event coordination.
+ */
+declare class FunnelEventStore {
+  private readonly sink;
+  private readonly now;
+  constructor(props: Props$6);
+  /**
+   * Persist a broadcaster-driven event with its assigned offset. Caller
+   * (the gateway-server) supplies the offset from `broadcaster.broadcast()`
+   * so this store and the broadcaster's in-memory ring stay aligned.
+   */
+  record(props: {
+    content: string;
+    channelId: string | null;
+    connectorId: string | null;
+    meta: Record<string, string> | null;
+    offset: number;
+  }): void;
+  /**
+   * Returns events with offset > since. Filtering by channel/connector is
+   * the broadcaster's responsibility (it knows the client's subscription),
+   * so this returns the full slice and lets the caller filter.
+   */
+  loadSince(since: number): ReplayableEvent[];
+  /**
+   * Returns events for one channel (and optionally one connector). Used
+   * by the gateway logs CLI for scoped queries. Channel/connector filters
+   * are indexed columns, so this is an indexed range scan.
+   */
+  loadForChannel(props: {
+    channelId: string;
+    connectorId?: string;
+    sinceSeq?: number;
+    limit?: number;
+  }): ReplayableEvent[];
+  findMaxOffset(): number;
+  close(): void;
+}
+//#endregion
 //#region lib/gateway/gateway-server.d.ts
 type Deps$3 = {
   channels: FunnelChannels;
@@ -836,9 +1018,17 @@ type Deps$3 = {
   process?: FunnelProcessRunner;
   clock?: FunnelClock;
   logger?: FunnelLogger;
-  selfPid?: number;
+  selfPid?: number; /** Funnel home dir, used to scope kill-competing to daemons rooted at the same dir. Defaults to FUNNEL_DIR. */
+  dir?: string;
   killCompetingSlack?: boolean; /** Bearer token required for `/listeners*`, `/status`, and `/ws`. Empty string disables auth (tests only). */
   token?: string;
+  /**
+   * Additional hono app mounted before the built-in gateway routes.
+   * Use to embed host-specific endpoints (e.g. an MCP route, custom `/api/*`).
+   * Host routes are mounted first; built-in `/listeners`, `/status`,
+   * `/channels`, `/health` are mounted after and take precedence on conflict.
+   */
+  extraRoutes?: Hono<Env$1>;
 };
 type WsData = {
   /** Stable channel id (uuid) the client subscribed to. "" for tap-all clients. */channel: string; /** Resolved channel name (for log readability). null for tap-all or unknown. */
@@ -866,12 +1056,14 @@ declare class FunnelGatewayServer {
   private readonly process?;
   private readonly logger;
   private readonly selfPid;
+  private readonly dir;
   private readonly killCompetingSlack;
   private readonly token;
   private readonly broadcaster;
   private readonly eventStore;
   private readonly supervisor;
   private readonly nowMs;
+  private readonly extraRoutes;
   private startedAt;
   private server;
   constructor(deps: Deps$3);
@@ -1006,15 +1198,27 @@ declare class FunnelListenersClient {
 }
 //#endregion
 //#region lib/funnel.d.ts
-type Props$4 = {
+type Props$5 = {
   /** Settings persistence (channels with nested connectors / profiles). Defaults to a FunnelSettingsStore rooted at `dir`. */store?: FunnelSettingsReader; /** Filesystem boundary. Replace with MemoryFunnelFileSystem to sandbox all disk I/O. */
   fs?: FunnelFileSystem; /** Process runner used by gateway / claude / gh listener. Replace with MemoryFunnelProcessRunner for tests. */
   process?: FunnelProcessRunner; /** Logger flowed into every facet. Replace with MemoryFunnelLogger or NoopFunnelLogger to silence/inspect. */
   logger?: FunnelLogger; /** Clock used by schedule listener, gh poll watermarks, and gateway timeouts. */
   clock?: FunnelClock; /** ID generator for channel and connector ids. Use MemoryFunnelIdGenerator for deterministic tests. */
-  idGenerator?: FunnelIdGenerator; /** Funnel home directory (settings.json + per-channel/per-connector dirs). Defaults to ~/.funnel. */
+  idGenerator?: FunnelIdGenerator; /** Prompter used by FunnelLocalConfigSync when funnel.json omits a token. Defaults to a TTY-only stdin prompter. */
+  tokenPrompter?: FunnelTokenPrompter; /** Funnel home directory (settings.json + per-channel/per-connector dirs). Defaults to ~/.funnel. */
   dir?: string; /** Temp / runtime directory (gateway logs and PID adjacent files). Defaults to /tmp/funnel. */
   tmpDir?: string;
+  /**
+   * Host integration hooks for Slack listeners — `onAppCreated` for attaching
+   * Bolt `app.action` handlers, `preprocessEvent` for transforming/dropping
+   * raw Slack events before the built-in processor sees them.
+   */
+  slackListenerOptions?: SlackListenerOptions;
+  /**
+   * Host integration hooks for Schedule listeners — `onFired` is invoked after
+   * each successful fire, useful for dropping one-shot entries.
+   */
+  scheduleListenerOptions?: ScheduleListenerOptions;
 };
 /**
  * Facade exposing every funnel facet as a getter.
@@ -1037,15 +1241,14 @@ type Props$4 = {
  */
 declare class Funnel {
   private readonly props;
-  private readonly cache;
-  constructor(props?: Props$4);
+  private readonly memos;
+  constructor(props?: Props$5);
   /**
    * Sandboxed Funnel wired with in-memory implementations for every IO boundary.
    * Touches no real disk, processes, wall-clock time, or UUIDs — safe for tests
    * and ad-hoc experiments. Override individual fields by passing them in `props`.
    */
-  static inMemory(props?: Props$4): Funnel;
-  private memo;
+  static inMemory(props?: Props$5): Funnel;
   /** Resolved on-disk paths the facade will read/write when methods are called. Pure compute, not memoized. */
   get paths(): {
     dir: string;
@@ -1070,6 +1273,14 @@ declare class Funnel {
   get channels(): FunnelChannels;
   /** Launch profiles (named presets for `fnl claude`: path + sub-agent + channel id). */
   get profiles(): FunnelProfiles;
+  /** Reads `funnel.json` from a cwd. `fnl claude` consults it before falling back to the default profile. */
+  get localConfig(): FunnelLocalConfig;
+  /** Parses `.env.local` from a cwd (used by sync to back $VAR references). */
+  get dotenv(): FunnelDotenvReader;
+  /** Secret prompter. Defaults to a TTY-only stdin reader; tests inject MemoryFunnelTokenPrompter. */
+  get tokenPrompter(): FunnelTokenPrompter;
+  /** Reconciles funnel.json's channel + connectors with `~/.funnel/settings.json` on launch. */
+  get localConfigSync(): FunnelLocalConfigSync;
   /** funnel MCP installer (writes/removes `.mcp.json` entries in target repos). */
   get mcp(): FunnelMcp;
   /** Launch Claude Code with a channel injected via env, MCP installed, gateway ensured. */
@@ -1100,6 +1311,13 @@ declare class Funnel {
     logDir?: string;
     killCompetingSlack?: boolean; /** Override the auth token. Defaults to the persisted gateway.token. Pass "" to disable auth (tests). */
     token?: string;
+    /**
+     * Additional hono app mounted before the built-in gateway routes.
+     * Use to embed host-specific endpoints (e.g. an MCP route, custom `/api/*`).
+     * Host routes are mounted first; built-in `/listeners`, `/status`,
+     * `/channels`, `/health` are mounted after and take precedence on conflict.
+     */
+    extraRoutes?: Hono<Env$1>;
   }): FunnelGatewayServer;
 }
 //#endregion
@@ -1112,6 +1330,15 @@ type ChannelServerOptions = {
 };
 declare const startChannelServer: (options?: ChannelServerOptions) => Promise<void>;
 //#endregion
+//#region lib/engine/local-config/local-config-json-schema.d.ts
+/**
+ * Generates the JSON Schema (draft 2020-12) for `funnel.json`. Useful for
+ * `$schema` references in committed `funnel.json` files so editors can give
+ * autocomplete and validation for channel / subAgent / env / connectors[]
+ * without anyone hand-maintaining a separate schema.
+ */
+declare const funnelJsonSchema: () => Record<string, unknown>;
+//#endregion
 //#region lib/engine/settings/settings-store.d.ts
 declare const FUNNEL_DIR: string;
 declare const SETTINGS_PATH: string;
@@ -1154,7 +1381,7 @@ declare class NodeFunnelFileSystem extends FunnelFileSystem {
 }
 //#endregion
 //#region lib/engine/fs/memory-file-system.d.ts
-type Props$3 = {
+type Props$4 = {
   dirs?: string[];
   files?: Record<string, string>;
   mtimes?: Record<string, number>;
@@ -1167,7 +1394,7 @@ declare class MemoryFunnelFileSystem extends FunnelFileSystem {
   private readonly mtimes;
   private readonly modes;
   private readonly now;
-  constructor(props?: Props$3);
+  constructor(props?: Props$4);
   existsSync(path: string): boolean;
   readFileSync(path: string): string;
   writeFileSync(path: string, data: string): void;
@@ -1239,14 +1466,14 @@ declare class MemoryFunnelProcessRunner extends FunnelProcessRunner {
 }
 //#endregion
 //#region lib/engine/logger/node-logger.d.ts
-type Props$2 = {
+type Props$3 = {
   file?: string;
   now?: () => Date;
 };
 declare class NodeFunnelLogger extends FunnelLogger {
   readonly file: string;
   private readonly now;
-  constructor(props?: Props$2);
+  constructor(props?: Props$3);
   info(message: string, meta?: Record<string, unknown>): void;
   warn(message: string, meta?: Record<string, unknown>): void;
   error(message: string, meta?: Record<string, unknown>): void;
@@ -1282,12 +1509,12 @@ declare class NodeFunnelClock extends FunnelClock {
 }
 //#endregion
 //#region lib/engine/time/memory-clock.d.ts
-type Props$1 = {
+type Props$2 = {
   start?: Date;
 };
 declare class MemoryFunnelClock extends FunnelClock {
   private current;
-  constructor(props?: Props$1);
+  constructor(props?: Props$2);
   now(): Date;
   set(date: Date): void;
   advance(ms: number): void;
@@ -1299,16 +1526,43 @@ declare class NodeFunnelIdGenerator extends FunnelIdGenerator {
 }
 //#endregion
 //#region lib/engine/id/memory-id-generator.d.ts
-type Props = {
+type Props$1 = {
   prefix?: string;
 };
 declare class MemoryFunnelIdGenerator extends FunnelIdGenerator {
   private counter;
   private readonly prefix;
-  constructor(props?: Props);
+  constructor(props?: Props$1);
   generate(): string;
 }
 //#endregion
+//#region lib/engine/token-prompter/node-token-prompter.d.ts
+/**
+ * Reads a secret from stdin in raw mode. Echoes a `*` per byte so the user
+ * can see progress without exposing the token. Refuses to prompt when stdin
+ * is not a TTY — callers should surface the resulting error with a hint
+ * pointing at the corresponding env var or CLI command.
+ */
+declare class NodeFunnelTokenPrompter extends FunnelTokenPrompter {
+  promptSecret(label: string): Promise<string>;
+  private readSecret;
+}
+//#endregion
+//#region lib/engine/token-prompter/memory-token-prompter.d.ts
+type Props = {
+  answers?: Record<string, string>;
+};
+/**
+ * Pre-seeded answers keyed by prompt label. Tests configure the map up front;
+ * unmapped labels throw so the test surfaces unexpected prompts loudly.
+ */
+declare class MemoryFunnelTokenPrompter extends FunnelTokenPrompter {
+  private readonly answers;
+  readonly asked: string[];
+  constructor(props?: Props);
+  promptSecret(label: string): Promise<string>;
+}
+//#endregion
 //#region lib/cli/factory.d.ts
 type Env = {
   Variables: {
@@ -1359,7 +1613,7 @@ declare const createCliApp: (funnel: Funnel) => _$hono_hono_base0.HonoBase<Env,
           channel?: string | undefined;
         };
       };
-      output: "funnel claude — launch Claude Code\n\nusage:\n  funnel claude                          launch the default profile (first in the list)\n  funnel claude -p <name>                launch a named profile\n  funnel claude --profile <name>         (long form)\n  funnel claude --channel <name>         raw launch (no profile, cwd = current dir)\n\noptions:\n  -p, --profile      profile name to launch\n  --channel          channel name (raw launch, ignored when --profile is given)\n\nAny other arguments are forwarded to the claude CLI.\nOn launch the FUNNEL_CHANNEL_ID env var is set and MCP connects to the gateway.";
+      output: "funnel claude — launch Claude Code\n\nusage:\n  funnel claude                          launch using funnel.json in cwd, or the default profile\n  funnel claude -p <name>                launch a named profile\n  funnel claude --profile <name>         (long form)\n  funnel claude --channel <name>         raw launch (no profile, cwd = current dir)\n  funnel claude [...]                    any other argument is forwarded to the claude CLI\n\nresolution order when no --profile / --channel is given:\n  1. ./funnel.json in the current directory\n  2. the default profile (first entry in fnl profiles)\n\nfunnel-specific options (everything else passes through to claude verbatim):\n  -p, --profile      profile name to launch\n  --channel          channel name (raw launch, ignored when --profile is given)\n  -h, --help         show this help\n\nPositional args, unknown short flags (e.g. -c, -r), and claude's own flags\n(--agent, --resume, --model, --print, --output-format ...) are all forwarded.\nOn launch the FUNNEL_CHANNEL_ID env var is set and MCP connects to the gateway.";
       outputFormat: "text";
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     };
@@ -2579,6 +2833,25 @@ ${string}`;
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     };
   };
+} & {
+  "/schema": {
+    $get: {
+      input: {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: Record<string, never>;
+      };
+      output: `${string}
+`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
 } & {
   "/status": {
     $get: {
@@ -2631,7 +2904,7 @@ declare const app: _$hono_hono_base0.HonoBase<Env, {
           channel?: string | undefined;
         };
       };
-      output: "funnel claude — launch Claude Code\n\nusage:\n  funnel claude                          launch the default profile (first in the list)\n  funnel claude -p <name>                launch a named profile\n  funnel claude --profile <name>         (long form)\n  funnel claude --channel <name>         raw launch (no profile, cwd = current dir)\n\noptions:\n  -p, --profile      profile name to launch\n  --channel          channel name (raw launch, ignored when --profile is given)\n\nAny other arguments are forwarded to the claude CLI.\nOn launch the FUNNEL_CHANNEL_ID env var is set and MCP connects to the gateway.";
+      output: "funnel claude — launch Claude Code\n\nusage:\n  funnel claude                          launch using funnel.json in cwd, or the default profile\n  funnel claude -p <name>                launch a named profile\n  funnel claude --profile <name>         (long form)\n  funnel claude --channel <name>         raw launch (no profile, cwd = current dir)\n  funnel claude [...]                    any other argument is forwarded to the claude CLI\n\nresolution order when no --profile / --channel is given:\n  1. ./funnel.json in the current directory\n  2. the default profile (first entry in fnl profiles)\n\nfunnel-specific options (everything else passes through to claude verbatim):\n  -p, --profile      profile name to launch\n  --channel          channel name (raw launch, ignored when --profile is given)\n  -h, --help         show this help\n\nPositional args, unknown short flags (e.g. -c, -r), and claude's own flags\n(--agent, --resume, --model, --print, --output-format ...) are all forwarded.\nOn launch the FUNNEL_CHANNEL_ID env var is set and MCP connects to the gateway.";
       outputFormat: "text";
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     };
@@ -3851,6 +4124,25 @@ ${string}`;
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     };
   };
+} & {
+  "/schema": {
+    $get: {
+      input: {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: Record<string, never>;
+      };
+      output: `${string}
+`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
 } & {
   "/status": {
     $get: {
@@ -3885,4 +4177,4 @@ ${string}`;
 //#region lib/tui/tui.d.ts
 declare function launchTui(funnel: Funnel): Promise<void>;
 //#endregion
-export { AttachOptions, BroadcastEvent, BroadcastSubscriber, ChannelConfig, ChannelConnectorView, ChannelDeliveryMode, ChannelServerOptions, ConnectorConfig, ConnectorType, DEFAULT_GATEWAY_TOKEN_PATH, DetachOptions, DiscordConnectorConfig, Env, FUNNEL_DIR, FUNNEL_MCP_COMMAND, FUNNEL_MCP_NAME, FileStat, Funnel, FunnelBroadcaster, FunnelChannelPublisher, FunnelChannels, FunnelClaude, FunnelClock, FunnelConnectorFactory, FunnelConnectorListener, FunnelEvent, FunnelEventStore, FunnelFileSystem, FunnelGateway, FunnelGatewayServer, FunnelGatewayToken, FunnelIdGenerator, FunnelListenerSupervisor, FunnelListenersClient, FunnelLogger, FunnelMcp, FunnelProcessRunner, FunnelProfiles, FunnelSettingsReader, FunnelSettingsStore, GhConnectorConfig, LaunchOptions, ListListenersResult, ListenerEntry, ListenerOpResult, LogEntry, MemoryFunnelClock, MemoryFunnelFileSystem, MemoryFunnelIdGenerator, MemoryFunnelLogger, MemoryFunnelProcessRunner, MemoryProcessCall, MemoryProcessHandler, MemoryProcessResponse, MemoryProcessSyncHandler, MockFunnelSettingsReader, NodeFunnelClock, NodeFunnelFileSystem, NodeFunnelIdGenerator, NodeFunnelLogger, NodeFunnelProcessRunner, NoopFunnelLogger, NotifyFn, ProfileConfig, PublishRequest, PublishResponse, PublishResult, ReplayableEvent, RunOptions, RunResult, SETTINGS_PATH, SETTINGS_VERSION, ScheduleCatchupPolicy, type ScheduleConnectorConfig, ScheduleEntry, Settings, SlackConnectorConfig, channelConfigSchema, channelDeliveryModeSchema, app as cliApp, connectorConfigSchema, createCliApp, createSettings, discordConnectorSchema, factory, funnelEventSchema, ghConnectorSchema, launchTui, profileConfigSchema, publishRequestSchema, publishResponseSchema, queryToCliArgs, scheduleCatchupPolicySchema, scheduleConnectorSchema, scheduleEntrySchema, settingsSchema, slackConnectorSchema, startChannelServer, toRequest };
+export { AttachOptions, BroadcastEvent, BroadcastSubscriber, ChannelConfig, ChannelConnectorView, ChannelDeliveryMode, ChannelServerOptions, ConnectorConfig, ConnectorSpec, ConnectorType, DEFAULT_GATEWAY_TOKEN_PATH, DetachOptions, DiscordConnectorConfig, Env, FUNNEL_DIR, FUNNEL_MCP_COMMAND, FUNNEL_MCP_NAME, FileStat, Funnel, FunnelBroadcaster, FunnelChannelPublisher, FunnelChannels, FunnelClaude, FunnelClock, FunnelConnectorFactory, FunnelConnectorListener, FunnelDotenvReader, FunnelEvent, FunnelEventStore, FunnelFileSystem, FunnelGateway, FunnelGatewayServer, FunnelGatewayToken, FunnelIdGenerator, FunnelListenerSupervisor, FunnelListenersClient, FunnelLocalConfig, FunnelLocalConfigSync, FunnelLogger, FunnelMcp, FunnelProcessRunner, FunnelProfiles, FunnelSettingsReader, FunnelSettingsStore, FunnelSlackEventProcessor, FunnelTokenPrompter, GhConnectorConfig, LOCAL_CONFIG_FILENAME, LOCAL_ENV_FILENAME, LaunchOptions, ListListenersResult, ListenerEntry, ListenerOpResult, LocalConfig, LogEntry, MemoryFunnelClock, MemoryFunnelFileSystem, MemoryFunnelIdGenerator, MemoryFunnelLogger, MemoryFunnelProcessRunner, MemoryFunnelTokenPrompter, MemoryProcessCall, MemoryProcessHandler, MemoryProcessResponse, MemoryProcessSyncHandler, MockFunnelSettingsReader, NodeFunnelClock, NodeFunnelFileSystem, NodeFunnelIdGenerator, NodeFunnelLogger, NodeFunnelProcessRunner, NodeFunnelTokenPrompter, NoopFunnelLogger, NotifyFn, ProfileConfig, PublishRequest, PublishResponse, PublishResult, ReplayableEvent, RunOptions, RunResult, SETTINGS_PATH, SETTINGS_VERSION, ScheduleCatchupPolicy, ScheduleConnectorConfig, ScheduleEntry, ScheduleListenerOptions, Settings, SlackConnectorConfig, SlackListenerOptions, SlackProcessed, SlackProcessedEmit, SlackProcessedSkip, SlackRawEvent, channelConfigSchema, channelDeliveryModeSchema, app as cliApp, connectorConfigSchema, connectorSpecSchema, createCliApp, createSettings, discordConnectorSchema, factory, funnelEventSchema, funnelJsonSchema, ghConnectorSchema, launchTui, localConfigSchema, profileConfigSchema, publishRequestSchema, publishResponseSchema, queryToCliArgs, scheduleCatchupPolicySchema, scheduleConnectorSchema, scheduleEntrySchema, settingsSchema, slackConnectorSchema, startChannelServer, toRequest };