@interactive-inc/claude-funnel 0.36.0 → 0.38.0

package/dist/index.d.ts

@@ -4,11 +4,13 @@ import { S as NotifyFn, _ as connectorConnectionEventSchema, a as ConnectorConne
 import { a as FunnelProcessRunner, c as RunResult, i as DetachOptions, n as ghConnectorSchema, o as ProcessSnapshot, r as AttachOptions, s as RunOptions, t as GhConnectorConfig } from "./gh-connector-schema-CQmEWzdV.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-3M6WkH1Y.js";
 import { a as SlackProcessed, c as SlackRawEvent, d as slackConnectorSchema, i as FunnelSlackEventProcessor, l as SlackSkipReason, n as SlackOnAppCreated, o as SlackProcessedEmit, r as SlackPreprocessEvent, s as SlackProcessedSkip, u as SlackConnectorConfig } from "./slack-listener-9UdAn_ui.js";
+import { hc } from "hono/client";
 import { z } from "zod";
 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_utils_types0 from "hono/utils/types";
 import * as _$hono_hono_base0 from "hono/hono-base";
 
 //#region lib/connectors/connector-config-schema.d.ts
@@ -386,696 +388,1014 @@ declare class FunnelChannels {
   private assertNoTokenCollision;
 }
 //#endregion
-//#region lib/engine/claude/gateway-controller.d.ts
-type GatewayController = {
-  isRunning(): boolean;
-  start(options?: {
-    caffeinate?: boolean;
-  }): Promise<boolean>;
-};
-//#endregion
-//#region lib/engine/mcp/mcp.d.ts
-declare const FUNNEL_MCP_COMMAND = "bun";
-declare const FUNNEL_MCP_ARGS: string[];
-declare const FUNNEL_MCP_NAME = "funnel";
-type Deps$13 = {
-  fs?: FunnelFileSystem;
-};
+//#region lib/engine/error/on-funnel-error.d.ts
 /**
- * Installs/uninstalls the funnel MCP entry into a target repository's
- * `.mcp.json`. Detects an existing entry by command match so renaming is
- * preserved across re-installs.
+ * Host integration hook called when Funnel catches an exception that would
+ * otherwise be silently swallowed (subscriber throw, listener start failure,
+ * MCP forward failure, etc.). Pass `Sentry.captureException` from the host to
+ * pipe these into your error reporter. Defaults to a no-op when omitted.
+ *
+ * `context` carries the component name and any extra metadata the caller had
+ * at the catch site (channel / connector / subscriber id when available).
  */
-declare class FunnelMcp {
-  private readonly fs;
-  constructor(deps?: Deps$13);
-  install(repoPath: string): void;
-  uninstall(repoPath: string): void;
-  findInstalledName(cwd: string): string | null;
-  private findServerName;
-  private isFunnelEntry;
-  private readConfig;
-  private writeConfig;
-}
+type OnFunnelError = (error: Error, context?: Record<string, unknown>) => void;
 //#endregion
-//#region lib/engine/profiles/profiles.d.ts
-type Deps$12 = {
-  store: FunnelSettingsReader;
-  idGenerator: FunnelIdGenerator;
+//#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. */
+  channelName?: string | null; /** Connector names belonging to that channel; used by tap-all replay filtering. */
+  connectors: string[];
+  tapAll?: boolean; /** Routing mode resolved from channel config at upgrade time. Defaults to fanout. */
+  delivery?: "fanout" | "exclusive";
+};
+type BroadcastEvent = {
+  content: string;
+  meta?: Record<string, string>;
+};
+type ReplayableEvent = BroadcastEvent & {
+  offset: number;
 };
+type BroadcastSubscriber = (event: ReplayableEvent) => void;
 /**
- * Named launch presets for `fnl claude`. Each profile bundles a working
- * directory, the channel id its Claude instance subscribes to, and the launch
- * recipe (`options` prepended to the claude argv, `env` layered under the
- * process, `resume` toggling session reuse). Implements ProfileChannelChecker
- * so FunnelChannels can refuse to remove a channel that is still referenced.
- *
- * Each profile has a stable `id` (uuid) minted at `add`. That id is the unit
- * everything internal keys on — the PID file, the resumable session id — so a
- * rename never strands either. `name` is purely the CLI/TUI handle; the CRUD
- * methods here take it because that is what the user types, but resolve to the
- * id before touching id-keyed state. The first array entry is the default
- * profile; `asDefault` reorders to put one first.
- *
- * `channelId` always stores the channel's stable id (uuid). CLI surfaces
- * resolve channel name → id before calling `add`/`update` here.
+ * Optional persistent replay source. Wired in by the gateway-server with a
+ * `FunnelEventLog` (SQLite-backed by default) so reconnects across daemon
+ * restarts can recover events older than the in-memory buffer via an indexed
+ * `seq > since` range scan.
  */
-declare class FunnelProfiles {
-  private readonly store;
-  private readonly idGenerator;
-  constructor(deps: Deps$12);
-  list(): ProfileConfig[];
-  get(name: string): ProfileConfig | null;
-  getById(id: string): ProfileConfig | null;
-  getDefault(): ProfileConfig | null;
-  add(input: {
-    name: string;
-    path: string;
-    channelId: string;
-    options?: string[];
-    env?: Record<string, string>;
-    resume?: boolean;
-  }): void;
-  remove(name: string): void;
-  rename(oldName: string, newName: string): void;
-  asDefault(name: string): void;
-  hasChannelRef(channelId: string): boolean;
-  /** Resumable claude session id last launched by this profile (by id), or null. */
-  getSessionId(id: string): string | null;
-  /** Records the claude session id this profile launched, overwriting any prior one. */
-  setSessionId(id: string, sessionId: string): void;
-  update(name: string, fields: Partial<Omit<ProfileConfig, "name">>): void;
-}
-//#endregion
-//#region lib/engine/claude/claude.d.ts
-type LaunchOptions = {
-  channel: string;
-  cwd?: string;
-  userArgs?: string[];
-  /** Stable id of the launching profile (uuid). Keys the singleton PID file and
-   *  the resumable session. Absent for a profile-less launch (raw `--channel`),
-   *  which never enforces singleton-ness and never resumes. */
-  profileId?: string; /** Args prepended to the claude argv (typically a profile's recipe). Defaults to none. */
-  options?: string[]; /** Env vars layered under the launched claude process. process.env wins on collision. */
-  env?: Record<string, string>;
-  /** Whether to inject a `--session-id`/`--resume` for this profile.
-   *  Defaults to false: resuming is opt-in and only meaningful for a profile,
-   *  since the persisted session is owned by the profile (by id). A launch
-   *  without a profile always starts a fresh session regardless of this flag. */
-  resume?: boolean;
-  /** Invoked synchronously after the child claude process has been spawned, with its PID.
-   *  Useful for hosts that need to register the spawned process before it exits
-   *  (e.g. multi-session registries that track per-claude liveness). */
-  onSpawned?: (pid: number) => void;
-  /** Whether to install the funnel MCP entry into `.mcp.json` (default: true).
-   *  Set to false when the host already provides its own MCP server entry and
-   *  does not need the funnel binary as an MCP endpoint. */
-  installMcp?: boolean;
+type ReplaySource = {
+  loadSince(since: number): ReplayableEvent[];
 };
-type Deps$11 = {
-  channels: FunnelChannels;
-  mcp: FunnelMcp;
-  gateway: GatewayController;
-  profiles: FunnelProfiles;
-  process?: FunnelProcessRunner;
-  fs?: FunnelFileSystem;
-  idGenerator?: FunnelIdGenerator;
-  logger?: FunnelLogger;
-  dir?: string;
+type Deps$13 = {
+  logger?: FunnelLogger; /** Host hook for surfacing subscriber-throw exceptions. Defaults to no-op. */
+  onError?: OnFunnelError;
+  maxBufferedBytes?: number;
+  now?: () => number; /** Number of recent events kept in the in-memory replay buffer. */
+  replayBufferSize?: number; /** Hard byte cap on replay buffer payloads. Older events are evicted FIFO until under this cap. */
+  replayBufferMaxBytes?: number; /** Persistent replay source consulted when the in-memory buffer cannot satisfy `since`. */
+  persistentReplay?: ReplaySource;
+};
+type BroadcasterMetrics = {
+  clients: number;
+  subscribers: number;
+  eventsBroadcast: number;
+  droppedSlowClients: number;
+  lastBroadcastAt: string | null; /** Latest emitted offset. Clients can `?since=<offset>` to ask for events strictly after this point. */
+  latestOffset: number; /** Oldest offset still held in the replay buffer. Older values cannot be replayed and trigger a full resync. */
+  oldestReplayableOffset: number | null;
 };
 /**
- * Launches Claude Code with funnel pre-wired: ensures the gateway is running,
- * installs the funnel MCP into the target repo's `.mcp.json` if missing,
- * injects `FUNNEL_CHANNEL_ID` into the child env, and writes a per-profile
- * PID file to enforce singleton launches.
+ * In-process pub/sub for connector events.
+ *
+ * Two outbound paths:
+ *   - WS clients connected via the gateway's `/ws` endpoint, scoped per channel
+ *   - In-process subscribers registered via `subscribe()` (programmable API)
+ *
+ * Backpressure: if a WS client's `bufferedAmount` exceeds `maxBufferedBytes`
+ * (default 1 MiB), the client is closed with code 1009 and dropped from the
+ * registry to keep one slow consumer from blocking the daemon.
+ *
+ * Replay: every emitted event gets a strictly increasing `offset`. The latest
+ * `replayBufferSize` events are kept in memory; reconnecting WS clients can
+ * pass `?since=<offset>` and the broadcaster resends matching events before
+ * resuming the live stream. The in-memory ring covers short reconnects;
+ * older history is served from the event log wired in as `persistentReplay`.
  */
-declare class FunnelClaude {
-  private readonly channels;
-  private readonly mcp;
-  private readonly gateway;
-  private readonly profiles;
-  private readonly process;
-  private readonly fs;
-  private readonly idGenerator;
+declare class FunnelBroadcaster {
+  private readonly clients;
+  private readonly subscribers;
   private readonly logger;
-  private readonly pidDir;
-  constructor(deps: Deps$11);
-  launch(options: LaunchOptions): Promise<number>;
-  isRunning(profileId: string): boolean;
-  private pidPath;
-  private readPid;
-  private writePidFile;
-  private removePidFile;
-  private installCleanup;
-  private isProcessAlive;
-  private buildArgs;
+  private readonly onError;
+  private readonly maxBufferedBytes;
+  private readonly now;
+  private readonly replayBufferSize;
+  private readonly replayBufferMaxBytes;
+  private readonly replayBuffer;
+  private readonly persistentReplay;
+  private readonly exclusiveCursor;
+  private replayBufferBytes;
+  private eventsBroadcast;
+  private droppedSlowClients;
+  private lastBroadcastAt;
+  private latestOffset;
+  constructor(deps?: Deps$13);
+  getMetrics(): BroadcasterMetrics;
   /**
-   * Decides whether funnel should resume an existing claude session or start
-   * a freshly minted one. Backs off when the user already passed a
-   * session-shaping flag, since combining them would either confuse claude
-   * or override the explicit user intent.
+   * Returns events with offset > since, filtered by the connector subscription
+   * rules of `data`. Used at WS upgrade time when the client passes `?since=<offset>`.
    *
-   * The session is owned by the profile (by id), not by cwd: two profiles
-   * pointing at the same repo each keep their own conversation, and a launch
-   * with no profile never resumes — so an unrelated session in the same repo
-   * can't bleed in. The channel never enters into it; sessions belong to the
-   * launch layer (profiles), keeping the transport layer ignorant of them.
+   * Two-tier lookup:
+   *   1. The in-memory ring buffer (covers short reconnects, last `replayBufferSize` events).
+   *   2. If `since` predates the oldest in-memory entry and a persistent replay source
+   *      is wired in (SQLite by default), the gap is filled from it. This covers reconnects
+   *      across daemon restarts where the in-memory buffer was lost.
    *
-   * A persisted id is only resumed when its session jsonl still exists on
-   * disk. claude errors out on `--resume <id>` for a missing conversation, and
-   * a persisted id can outlive its jsonl (claude pruned it, or the very first
-   * launch was aborted after the id was written but before the jsonl
-   * appeared). When the file is gone we mint a fresh session instead, which
-   * overwrites the dangling entry — so the store self-heals.
+   * Result is sorted ascending by offset and de-duplicated against the in-memory buffer.
    */
-  private resolveSession;
+  replaySince(since: number, data: ClientData): ReplayableEvent[];
+  private matchesClient;
   /**
-   * Mirrors claude's session storage path
-   * (`<config-dir>/projects/<cwd-with-slashes-as-dashes>/<id>.jsonl`) to check
-   * whether a recorded session still exists AND is non-empty. Reads the same
-   * `CLAUDE_CONFIG_DIR` the child will run under so the check matches reality; a
-   * wrong guess can only ever produce a false negative (start fresh), never a
-   * bad resume.
+   * Returns the list of WS clients that should receive `event`. Tap=all clients always
+   * receive (passive observation). For each per-channel group:
+   *   - fanout → every matching client receives
+   *   - exclusive → exactly one client receives, picked round-robin per channel
    */
-  private sessionFileExists;
-  private buildEnv;
-}
-//#endregion
-//#region lib/engine/error/on-funnel-error.d.ts
-/**
- * Host integration hook called when Funnel catches an exception that would
- * otherwise be silently swallowed (subscriber throw, listener start failure,
- * MCP forward failure, etc.). Pass `Sentry.captureException` from the host to
- * pipe these into your error reporter. Defaults to a no-op when omitted.
- *
- * `context` carries the component name and any extra metadata the caller had
- * at the catch site (channel / connector / subscriber id when available).
- */
-type OnFunnelError = (error: Error, context?: Record<string, unknown>) => void;
-//#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;
-  minify: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>, z.ZodObject<{
-  type: z.ZodLiteral<"discord">;
-  name: z.ZodString;
-}, 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 channelSpecSchema: z.ZodObject<{
-  name: z.ZodString;
-  connectors: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-    type: z.ZodLiteral<"slack">;
-    name: z.ZodString;
-    minify: z.ZodOptional<z.ZodBoolean>;
-  }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"discord">;
-    name: z.ZodString;
-  }, 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 ChannelSpec = z.infer<typeof channelSpecSchema>;
-declare const profileSpecSchema: z.ZodObject<{
-  name: z.ZodString;
-  channel: z.ZodString;
-  options: z.ZodOptional<z.ZodArray<z.ZodString>>;
-  env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-  resume: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-type ProfileSpec = z.infer<typeof profileSpecSchema>;
-declare const localConfigSchema: z.ZodObject<{
-  $schema: z.ZodOptional<z.ZodString>;
-  id: z.ZodOptional<z.ZodString>;
-  channels: z.ZodArray<z.ZodObject<{
-    name: z.ZodString;
-    connectors: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-      type: z.ZodLiteral<"slack">;
-      name: z.ZodString;
-      minify: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>, z.ZodObject<{
-      type: z.ZodLiteral<"discord">;
-      name: z.ZodString;
-    }, 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>>;
-  profiles: z.ZodOptional<z.ZodArray<z.ZodObject<{
-    name: z.ZodString;
-    channel: z.ZodString;
-    options: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    resume: z.ZodOptional<z.ZodBoolean>;
-  }, z.core.$strip>>>;
-}, z.core.$strip>;
-type LocalConfig = z.infer<typeof localConfigSchema>;
-declare const LOCAL_CONFIG_FILENAME = "funnel.json";
-//#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;
-  private assertProfilesValid;
-}
-//#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>;
+  private pickRecipients;
+  addClient(ws: ServerWebSocket<unknown>, data: ClientData): void;
+  removeClient(ws: ServerWebSocket<unknown>): void;
+  getClientCount(): number;
+  listChannels(): {
+    channel: string;
+    connectors: string[];
+  }[];
+  subscribe(handler: BroadcastSubscriber): () => void;
+  broadcast(content: string, meta?: Record<string, string>): ReplayableEvent;
+  /** Forward-seed the offset counter (used at startup from the persisted event store). */
+  seedLatestOffset(offset: number): void;
 }
 //#endregion
-//#region lib/engine/local-config/local-config-sync.d.ts
-type Deps$9 = {
-  channels: FunnelChannels;
-  prompter: FunnelTokenPrompter;
+//#region lib/gateway/listener-supervisor.d.ts
+type ConnectorRegistry = {
+  listAllConnectors(): ChannelConnectorView[];
+  createListener(channelName: string, connectorName: string): {
+    config: ConnectorConfig;
+    channelId: string;
+    listener: FunnelConnectorListener;
+  } | null;
 };
-type ConnectorSyncOutcome = {
-  name: string;
-  changed: boolean;
+type SupervisorNotify = (channelName: string, connectorName: string, content: string, meta?: Record<string, string>) => Promise<void>;
+type Deps$12 = {
+  channels: ConnectorRegistry;
+  notify: SupervisorNotify;
+  logger?: FunnelLogger; /** Host hook for surfacing listener lifecycle exceptions. Defaults to no-op. */
+  onError?: OnFunnelError;
+  healthCheckIntervalMs?: number;
+  maxBackoffMs?: number;
+  sleep?: (ms: number) => Promise<void>;
+  now?: () => number;
 };
-type LocalConfigSyncResult = {
-  touched: ConnectorSyncOutcome[];
-  removed: string[];
+type ListenerEntryStatus = {
+  channelName: string;
+  channelId: string;
+  name: string;
+  type: ConnectorConfig["type"];
+  alive: boolean;
+  events: number;
+  errors: number;
+  failureCount: number;
+  lastEventAt: string | null;
 };
 /**
- * Reconciles a single funnel.json channel 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
+ * Owns the running listener instances and their lifecycle.
  *
- * Removal only fires when the channel spec has a `connectors` field. An
- * absent field means "do not manage connectors from here" and leaves
- * everything in `~/.funnel` alone. Other channels in funnel.json (not
- * passed to this call) are untouched.
+ * Lives in the gateway process and is the only place that calls
+ * `listener.start()` / `listener.stop()`. Each entry is keyed by
+ * `${channelName}/${connectorName}` so the same connector name can exist in
+ * multiple channels without colliding.
  *
- * Returns the per-connector change set so callers (e.g. the claude launcher)
- * can drive listener hot-reload on the gateway after settings are written.
+ * Periodically polls each running listener's `isAlive()` and auto-restarts
+ * dead listeners with exponential backoff (1s, 2s, 4s, ... capped). Resets
+ * the backoff counter on successful restart.
  */
-declare class FunnelLocalConfigSync {
+declare class FunnelListenerSupervisor {
   private readonly channels;
-  private readonly prompter;
-  constructor(deps: Deps$9);
-  ensure(channel: ChannelSpec): Promise<LocalConfigSyncResult>;
-  private ensureConnector;
-  private ensureSlack;
-  private ensureDiscord;
-  private ensureGh;
-  private ensureSchedule;
-  private findExistingSlack;
-  private findExistingDiscord;
-  private removeExtras;
-  /**
-   * Decides how a single token slot is stored in settings.json. funnel.json
-   * never carries tokens, so the only sources are a value already in
-   * settings.json (carried over verbatim, whichever form it was — literal or an
-   * `env`-var reference set via the CLI) or, on first sync, a TTY prompt for a
-   * literal (throws when stdin is not a TTY). Either way the secret lands in the
-   * repo-scoped settings, never in the repo itself.
-   */
-  private resolveSlot;
+  private readonly notify;
+  private readonly logger;
+  private readonly onError;
+  private readonly running;
+  private readonly failureCounts;
+  private readonly stats;
+  private readonly healthCheckIntervalMs;
+  private readonly maxBackoffMs;
+  private readonly sleep;
+  private readonly now;
+  private healthCheckTimer;
+  private healthCheckInFlight;
+  constructor(deps: Deps$12);
+  static keyOf(channelName: string, connectorName: string): string;
+  isRunning(channelName: string, connectorName: string): boolean;
+  list(): ListenerEntryStatus[];
+  start(channelName: string, connectorName: string): Promise<{
+    ok: boolean;
+    reason?: string;
+  }>;
+  stop(channelName: string, connectorName: string): Promise<{
+    ok: boolean;
+    reason?: string;
+  }>;
+  restart(channelName: string, connectorName: string): Promise<{
+    ok: boolean;
+    reason?: string;
+  }>;
+  startAll(): Promise<void>;
+  stopAll(): Promise<void>;
+  private ensureStats;
+  private recordEvent;
+  private recordError;
+  private startHealthCheck;
+  private stopHealthCheck;
+  private runHealthCheck;
+  private recoverDead;
 }
 //#endregion
-//#region lib/engine/local-config/local-config-writer.d.ts
-type Deps$8 = {
-  fs: FunnelFileSystem;
+//#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;
+  };
 };
-/**
- * The one path that mutates the repo-committed funnel.json, and it only ever
- * inserts `id`. On first launch a repo has no `id`; funnel generates one and
- * writes it back here so future launches resolve the same `~/.funnel/projects/<id>/`.
- * Idempotent — a no-op once `id` is present. Kept separate from the read-only
- * FunnelLocalConfig so reads stay side-effect free.
- */
-declare class FunnelLocalConfigWriter {
-  private readonly fs;
-  constructor(deps: Deps$8);
-  ensureId(cwd: string, id: string): void;
-}
 //#endregion
-//#region lib/gateway/publish-schema.d.ts
+//#region lib/gateway/factory.d.ts
+type Env$1 = {
+  Variables: {
+    deps: GatewayRouteDeps;
+  };
+};
+//#endregion
+//#region lib/gateway/routes/index.d.ts
 /**
- * Shared schema for `POST /channels/:channel/publish` — used by both the
- * gateway route handler (input validation) and the CLI / programmable client
- * (request shape). The route resolves `channel` from the path; this body
- * covers everything else.
+ * Top-level Hono app for the gateway daemon. Mounts every HTTP endpoint flat
+ * (the WebSocket /ws upgrade is handled directly by `Bun.serve`). Deps come
+ * from the `deps` variable set by `FunnelGatewayServer`'s middleware — same
+ * shape as CLI's `c.var.funnel`.
  */
-declare const publishRequestSchema: z.ZodObject<{
-  content: z.ZodString;
-  meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-  connector: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-type PublishRequest = z.infer<typeof publishRequestSchema>;
-declare const publishResponseSchema: z.ZodObject<{
-  ok: z.ZodLiteral<true>;
-  offset: z.ZodNumber;
-}, z.core.$strip>;
-type PublishResponse = z.infer<typeof publishResponseSchema>;
-type PublishResult = {
-  state: "ok";
-  offset: number;
-} | {
-  state: "offline";
-} | {
-  state: "error";
-  reason: string;
+type GatewayApp = ReturnType<typeof buildGatewayRoutes>;
+declare function buildGatewayRoutes(): _$hono_hono_base0.HonoBase<Env$1, {
+  "/health": {
+    $get: {
+      input: {};
+      output: {
+        ok: true;
+        pid: number;
+        clients: number;
+        listeners: {
+          channelName: string;
+          channelId: string;
+          name: string;
+          type: ConnectorConfig["type"];
+          alive: boolean;
+          events: number;
+          errors: number;
+          failureCount: number;
+          lastEventAt: string | null;
+        }[];
+      };
+      outputFormat: "json";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/status": {
+    $get: {
+      input: {};
+      output: {
+        ok: true;
+        pid: number;
+        uptimeMs: number;
+        clients: {
+          channel: string;
+          connectors: string[];
+        }[];
+        listeners: {
+          channelName: string;
+          channelId: string;
+          name: string;
+          type: ConnectorConfig["type"];
+          alive: boolean;
+          events: number;
+          errors: number;
+          failureCount: number;
+          lastEventAt: string | null;
+        }[];
+        broadcaster: {
+          clients: number;
+          subscribers: number;
+          eventsBroadcast: number;
+          droppedSlowClients: number;
+          lastBroadcastAt: string | null;
+          latestOffset: number;
+          oldestReplayableOffset: number | null;
+        };
+      };
+      outputFormat: "json";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/debug": {
+    $get: {
+      input: {};
+      output: {
+        pid: number;
+        uptimeMs: number;
+        eventsBroadcast: number;
+        channels: {
+          id: string;
+          name: string;
+          connectors: string[];
+          listener: {
+            alive: boolean;
+            events: number;
+            errors: number;
+            lastEventAt: string | null;
+          } | null;
+          claudeClients: number;
+          recentEvents: {
+            seq: number | null;
+            ts: number | null;
+            type: string;
+            outcome: string;
+            payload: string | null;
+            payloadParsed: {
+              [x: string]: _$hono_utils_types0.JSONValue;
+            } | null;
+            preview: string | null;
+          }[];
+          connectionErrors: {
+            ts: number | null;
+            type: string;
+            status: string;
+            detail: string | null;
+          }[];
+          diagnosis: {
+            status: "ok" | "warn" | "error";
+            message: string;
+            nextActions: string[];
+            rootCause: string | null;
+          };
+        }[];
+      };
+      outputFormat: "json";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/listeners": {
+    $get: {
+      input: {};
+      output: {
+        listeners: {
+          channelName: string;
+          channelId: string;
+          name: string;
+          type: ConnectorConfig["type"];
+          alive: boolean;
+          events: number;
+          errors: number;
+          failureCount: number;
+          lastEventAt: string | null;
+        }[];
+      };
+      outputFormat: "json";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/listeners/:channel/:connector/start": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      };
+      output: {
+        ok: boolean;
+        reason: string;
+      };
+      outputFormat: "json";
+      status: 400;
+    } | {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      };
+      output: {
+        ok: boolean;
+        reason?: string | undefined;
+      };
+      outputFormat: "json";
+      status: 200 | 400;
+    };
+  };
+} & {
+  "/listeners/:channel/:connector": {
+    $delete: {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      };
+      output: {
+        ok: boolean;
+        reason: string;
+      };
+      outputFormat: "json";
+      status: 400;
+    } | {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      };
+      output: {
+        ok: boolean;
+        reason?: string | undefined;
+      };
+      outputFormat: "json";
+      status: 200 | 400;
+    };
+  };
+} & {
+  "/listeners/:channel/:connector/restart": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      };
+      output: {
+        ok: boolean;
+        reason: string;
+      };
+      outputFormat: "json";
+      status: 400;
+    } | {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      };
+      output: {
+        ok: boolean;
+        reason?: string | undefined;
+      };
+      outputFormat: "json";
+      status: 200 | 400;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/:connector/call": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      };
+      output: {
+        ok: boolean;
+        reason: string;
+      };
+      outputFormat: "json";
+      status: 400;
+    } | {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      };
+      output: {
+        ok: true;
+        result: _$hono_utils_types0.JSONValue;
+      };
+      outputFormat: "json";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/publish": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+        };
+      } & {
+        json: {
+          content: string;
+          meta?: Record<string, string> | undefined;
+          connector?: string | undefined;
+        };
+      };
+      output: {
+        ok: boolean;
+        reason: string;
+      };
+      outputFormat: "json";
+      status: 400;
+    } | {
+      input: {
+        param: {
+          channel: string;
+        };
+      } & {
+        json: {
+          content: string;
+          meta?: Record<string, string> | undefined;
+          connector?: string | undefined;
+        };
+      };
+      output: {
+        ok: boolean;
+        reason: string;
+      };
+      outputFormat: "json";
+      status: 400;
+    } | {
+      input: {
+        param: {
+          channel: string;
+        };
+      } & {
+        json: {
+          content: string;
+          meta?: Record<string, string> | undefined;
+          connector?: string | undefined;
+        };
+      };
+      output: {
+        ok: true;
+        offset: number;
+      };
+      outputFormat: "json";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+}, "/", "/channels/:channel/publish">;
+//#endregion
+//#region lib/engine/claude/gateway-controller.d.ts
+type GatewayController = {
+  isRunning(): boolean;
+  start(options?: {
+    caffeinate?: boolean;
+  }): Promise<boolean>;
 };
 //#endregion
-//#region lib/gateway/channel-publisher.d.ts
-type Deps$7 = {
-  port: number;
-  isDaemonRunning: () => boolean; /** Returns the daemon's gateway token, or null if unavailable. Sent as `Authorization: Bearer`. */
-  getToken?: () => string | null;
+//#region lib/engine/mcp/mcp.d.ts
+declare const FUNNEL_MCP_COMMAND = "bun";
+declare const FUNNEL_MCP_ARGS: string[];
+declare const FUNNEL_MCP_NAME = "funnel";
+type Deps$11 = {
+  fs?: FunnelFileSystem;
 };
 /**
- * HTTP client for `POST /channels/:channel/publish` on a running gateway
- * daemon. Returns `{ state: "offline" }` when the daemon isn't up so callers
- * can branch without exceptions, mirroring `FunnelListenersClient`.
+ * Installs/uninstalls the funnel MCP entry into a target repository's
+ * `.mcp.json`. Detects an existing entry by command match so renaming is
+ * preserved across re-installs.
  */
-declare class FunnelChannelPublisher {
-  private readonly port;
-  private readonly isDaemonRunning;
-  private readonly getToken;
-  constructor(deps: Deps$7);
-  publish(channelName: string, request: PublishRequest): Promise<PublishResult>;
-  private authHeaders;
+declare class FunnelMcp {
+  private readonly fs;
+  constructor(deps?: Deps$11);
+  install(repoPath: string): void;
+  uninstall(repoPath: string): void;
+  findInstalledName(cwd: string): string | null;
+  private findServerName;
+  private isFunnelEntry;
+  private readConfig;
+  private writeConfig;
 }
 //#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. */
-  channelName?: string | null; /** Connector names belonging to that channel; used by tap-all replay filtering. */
-  connectors: string[];
-  tapAll?: boolean; /** Routing mode resolved from channel config at upgrade time. Defaults to fanout. */
-  delivery?: "fanout" | "exclusive";
+//#region lib/engine/profiles/profiles.d.ts
+type Deps$10 = {
+  store: FunnelSettingsReader;
+  idGenerator: FunnelIdGenerator;
 };
-type BroadcastEvent = {
-  content: string;
-  meta?: Record<string, string>;
-};
-type ReplayableEvent = BroadcastEvent & {
-  offset: number;
-};
-type BroadcastSubscriber = (event: ReplayableEvent) => void;
 /**
- * Optional persistent replay source. Wired in by the gateway-server with a
- * `FunnelEventLog` (SQLite-backed by default) so reconnects across daemon
- * restarts can recover events older than the in-memory buffer via an indexed
- * `seq > since` range scan.
+ * Named launch presets for `fnl claude`. Each profile bundles a working
+ * directory, the channel id its Claude instance subscribes to, and the launch
+ * recipe (`options` prepended to the claude argv, `env` layered under the
+ * process, `resume` toggling session reuse). Implements ProfileChannelChecker
+ * so FunnelChannels can refuse to remove a channel that is still referenced.
+ *
+ * Each profile has a stable `id` (uuid) minted at `add`. That id is the unit
+ * everything internal keys on — the PID file, the resumable session id — so a
+ * rename never strands either. `name` is purely the CLI/TUI handle; the CRUD
+ * methods here take it because that is what the user types, but resolve to the
+ * id before touching id-keyed state. The first array entry is the default
+ * profile; `asDefault` reorders to put one first.
+ *
+ * `channelId` always stores the channel's stable id (uuid). CLI surfaces
+ * resolve channel name → id before calling `add`/`update` here.
  */
-type ReplaySource = {
-  loadSince(since: number): ReplayableEvent[];
-};
-type Deps$6 = {
-  logger?: FunnelLogger; /** Host hook for surfacing subscriber-throw exceptions. Defaults to no-op. */
-  onError?: OnFunnelError;
-  maxBufferedBytes?: number;
-  now?: () => number; /** Number of recent events kept in the in-memory replay buffer. */
-  replayBufferSize?: number; /** Hard byte cap on replay buffer payloads. Older events are evicted FIFO until under this cap. */
-  replayBufferMaxBytes?: number; /** Persistent replay source consulted when the in-memory buffer cannot satisfy `since`. */
-  persistentReplay?: ReplaySource;
+declare class FunnelProfiles {
+  private readonly store;
+  private readonly idGenerator;
+  constructor(deps: Deps$10);
+  list(): ProfileConfig[];
+  get(name: string): ProfileConfig | null;
+  getById(id: string): ProfileConfig | null;
+  getDefault(): ProfileConfig | null;
+  add(input: {
+    name: string;
+    path: string;
+    channelId: string;
+    options?: string[];
+    env?: Record<string, string>;
+    resume?: boolean;
+  }): void;
+  remove(name: string): void;
+  rename(oldName: string, newName: string): void;
+  asDefault(name: string): void;
+  hasChannelRef(channelId: string): boolean;
+  /** Resumable claude session id last launched by this profile (by id), or null. */
+  getSessionId(id: string): string | null;
+  /** Records the claude session id this profile launched, overwriting any prior one. */
+  setSessionId(id: string, sessionId: string): void;
+  update(name: string, fields: Partial<Omit<ProfileConfig, "name">>): void;
+}
+//#endregion
+//#region lib/engine/claude/claude.d.ts
+type LaunchOptions = {
+  channel: string;
+  cwd?: string;
+  userArgs?: string[];
+  /** Stable id of the launching profile (uuid). Keys the singleton PID file and
+   *  the resumable session. Absent for a profile-less launch (raw `--channel`),
+   *  which never enforces singleton-ness and never resumes. */
+  profileId?: string; /** Args prepended to the claude argv (typically a profile's recipe). Defaults to none. */
+  options?: string[]; /** Env vars layered under the launched claude process. process.env wins on collision. */
+  env?: Record<string, string>;
+  /** Whether to inject a `--session-id`/`--resume` for this profile.
+   *  Defaults to false: resuming is opt-in and only meaningful for a profile,
+   *  since the persisted session is owned by the profile (by id). A launch
+   *  without a profile always starts a fresh session regardless of this flag. */
+  resume?: boolean;
+  /** Invoked synchronously after the child claude process has been spawned, with its PID.
+   *  Useful for hosts that need to register the spawned process before it exits
+   *  (e.g. multi-session registries that track per-claude liveness). */
+  onSpawned?: (pid: number) => void;
+  /** Whether to install the funnel MCP entry into `.mcp.json` (default: true).
+   *  Set to false when the host already provides its own MCP server entry and
+   *  does not need the funnel binary as an MCP endpoint. */
+  installMcp?: boolean;
 };
-type BroadcasterMetrics = {
-  clients: number;
-  subscribers: number;
-  eventsBroadcast: number;
-  droppedSlowClients: number;
-  lastBroadcastAt: string | null; /** Latest emitted offset. Clients can `?since=<offset>` to ask for events strictly after this point. */
-  latestOffset: number; /** Oldest offset still held in the replay buffer. Older values cannot be replayed and trigger a full resync. */
-  oldestReplayableOffset: number | null;
+type Deps$9 = {
+  channels: FunnelChannels;
+  mcp: FunnelMcp;
+  gateway: GatewayController;
+  profiles: FunnelProfiles;
+  process?: FunnelProcessRunner;
+  fs?: FunnelFileSystem;
+  idGenerator?: FunnelIdGenerator;
+  logger?: FunnelLogger;
+  dir?: string;
 };
 /**
- * In-process pub/sub for connector events.
- *
- * Two outbound paths:
- *   - WS clients connected via the gateway's `/ws` endpoint, scoped per channel
- *   - In-process subscribers registered via `subscribe()` (programmable API)
- *
- * Backpressure: if a WS client's `bufferedAmount` exceeds `maxBufferedBytes`
- * (default 1 MiB), the client is closed with code 1009 and dropped from the
- * registry to keep one slow consumer from blocking the daemon.
- *
- * Replay: every emitted event gets a strictly increasing `offset`. The latest
- * `replayBufferSize` events are kept in memory; reconnecting WS clients can
- * pass `?since=<offset>` and the broadcaster resends matching events before
- * resuming the live stream. The in-memory ring covers short reconnects;
- * older history is served from the event log wired in as `persistentReplay`.
+ * Launches Claude Code with funnel pre-wired: ensures the gateway is running,
+ * installs the funnel MCP into the target repo's `.mcp.json` if missing,
+ * injects `FUNNEL_CHANNEL_ID` into the child env, and writes a per-profile
+ * PID file to enforce singleton launches.
  */
-declare class FunnelBroadcaster {
-  private readonly clients;
-  private readonly subscribers;
+declare class FunnelClaude {
+  private readonly channels;
+  private readonly mcp;
+  private readonly gateway;
+  private readonly profiles;
+  private readonly process;
+  private readonly fs;
+  private readonly idGenerator;
   private readonly logger;
-  private readonly onError;
-  private readonly maxBufferedBytes;
-  private readonly now;
-  private readonly replayBufferSize;
-  private readonly replayBufferMaxBytes;
-  private readonly replayBuffer;
-  private readonly persistentReplay;
-  private readonly exclusiveCursor;
-  private replayBufferBytes;
-  private eventsBroadcast;
-  private droppedSlowClients;
-  private lastBroadcastAt;
-  private latestOffset;
-  constructor(deps?: Deps$6);
-  getMetrics(): BroadcasterMetrics;
+  private readonly pidDir;
+  constructor(deps: Deps$9);
+  launch(options: LaunchOptions): Promise<number>;
+  isRunning(profileId: string): boolean;
+  private pidPath;
+  private readPid;
+  private writePidFile;
+  private removePidFile;
+  private installCleanup;
+  private isProcessAlive;
+  private buildArgs;
   /**
-   * Returns events with offset > since, filtered by the connector subscription
-   * rules of `data`. Used at WS upgrade time when the client passes `?since=<offset>`.
+   * Decides whether funnel should resume an existing claude session or start
+   * a freshly minted one. Backs off when the user already passed a
+   * session-shaping flag, since combining them would either confuse claude
+   * or override the explicit user intent.
    *
-   * Two-tier lookup:
-   *   1. The in-memory ring buffer (covers short reconnects, last `replayBufferSize` events).
-   *   2. If `since` predates the oldest in-memory entry and a persistent replay source
-   *      is wired in (SQLite by default), the gap is filled from it. This covers reconnects
-   *      across daemon restarts where the in-memory buffer was lost.
+   * The session is owned by the profile (by id), not by cwd: two profiles
+   * pointing at the same repo each keep their own conversation, and a launch
+   * with no profile never resumes — so an unrelated session in the same repo
+   * can't bleed in. The channel never enters into it; sessions belong to the
+   * launch layer (profiles), keeping the transport layer ignorant of them.
    *
-   * Result is sorted ascending by offset and de-duplicated against the in-memory buffer.
+   * A persisted id is only resumed when its session jsonl still exists on
+   * disk. claude errors out on `--resume <id>` for a missing conversation, and
+   * a persisted id can outlive its jsonl (claude pruned it, or the very first
+   * launch was aborted after the id was written but before the jsonl
+   * appeared). When the file is gone we mint a fresh session instead, which
+   * overwrites the dangling entry — so the store self-heals.
    */
-  replaySince(since: number, data: ClientData): ReplayableEvent[];
-  private matchesClient;
+  private resolveSession;
   /**
-   * Returns the list of WS clients that should receive `event`. Tap=all clients always
-   * receive (passive observation). For each per-channel group:
-   *   - fanout → every matching client receives
-   *   - exclusive → exactly one client receives, picked round-robin per channel
+   * Mirrors claude's session storage path
+   * (`<config-dir>/projects/<cwd-with-slashes-as-dashes>/<id>.jsonl`) to check
+   * whether a recorded session still exists AND is non-empty. Reads the same
+   * `CLAUDE_CONFIG_DIR` the child will run under so the check matches reality; a
+   * wrong guess can only ever produce a false negative (start fresh), never a
+   * bad resume.
    */
-  private pickRecipients;
-  addClient(ws: ServerWebSocket<unknown>, data: ClientData): void;
-  removeClient(ws: ServerWebSocket<unknown>): void;
-  getClientCount(): number;
-  listChannels(): {
-    channel: string;
-    connectors: string[];
-  }[];
-  subscribe(handler: BroadcastSubscriber): () => void;
-  broadcast(content: string, meta?: Record<string, string>): ReplayableEvent;
-  /** Forward-seed the offset counter (used at startup from the persisted event store). */
-  seedLatestOffset(offset: number): void;
+  private sessionFileExists;
+  private buildEnv;
 }
 //#endregion
-//#region lib/gateway/listener-supervisor.d.ts
-type ConnectorRegistry = {
-  listAllConnectors(): ChannelConnectorView[];
-  createListener(channelName: string, connectorName: string): {
-    config: ConnectorConfig;
-    channelId: string;
-    listener: FunnelConnectorListener;
-  } | null;
-};
-type SupervisorNotify = (channelName: string, connectorName: string, content: string, meta?: Record<string, string>) => Promise<void>;
-type Deps$5 = {
-  channels: ConnectorRegistry;
-  notify: SupervisorNotify;
-  logger?: FunnelLogger; /** Host hook for surfacing listener lifecycle exceptions. Defaults to no-op. */
-  onError?: OnFunnelError;
-  healthCheckIntervalMs?: number;
-  maxBackoffMs?: number;
-  sleep?: (ms: number) => Promise<void>;
-  now?: () => number;
-};
-type ListenerEntryStatus = {
-  channelName: string;
-  channelId: string;
-  name: string;
-  type: ConnectorConfig["type"];
-  alive: boolean;
-  events: number;
-  errors: number;
-  failureCount: number;
-  lastEventAt: string | null;
-};
-/**
- * Owns the running listener instances and their lifecycle.
- *
- * Lives in the gateway process and is the only place that calls
- * `listener.start()` / `listener.stop()`. Each entry is keyed by
- * `${channelName}/${connectorName}` so the same connector name can exist in
- * multiple channels without colliding.
- *
- * Periodically polls each running listener's `isAlive()` and auto-restarts
- * dead listeners with exponential backoff (1s, 2s, 4s, ... capped). Resets
- * the backoff counter on successful restart.
- */
-declare class FunnelListenerSupervisor {
-  private readonly channels;
-  private readonly notify;
-  private readonly logger;
-  private readonly onError;
-  private readonly running;
-  private readonly failureCounts;
-  private readonly stats;
-  private readonly healthCheckIntervalMs;
-  private readonly maxBackoffMs;
-  private readonly sleep;
-  private readonly now;
-  private healthCheckTimer;
-  private healthCheckInFlight;
-  constructor(deps: Deps$5);
-  static keyOf(channelName: string, connectorName: string): string;
-  isRunning(channelName: string, connectorName: string): boolean;
-  list(): ListenerEntryStatus[];
-  start(channelName: string, connectorName: string): Promise<{
-    ok: boolean;
-    reason?: string;
-  }>;
-  stop(channelName: string, connectorName: string): Promise<{
-    ok: boolean;
-    reason?: string;
-  }>;
-  restart(channelName: string, connectorName: string): Promise<{
-    ok: boolean;
-    reason?: string;
-  }>;
-  startAll(): Promise<void>;
-  stopAll(): Promise<void>;
-  private ensureStats;
-  private recordEvent;
-  private recordError;
-  private startHealthCheck;
-  private stopHealthCheck;
-  private runHealthCheck;
-  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;
-  };
-};
+//#region lib/engine/local-config/local-config-schema.d.ts
+declare const connectorSpecSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  type: z.ZodLiteral<"slack">;
+  name: z.ZodString;
+  minify: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"discord">;
+  name: z.ZodString;
+}, 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 channelSpecSchema: z.ZodObject<{
+  name: z.ZodString;
+  connectors: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"slack">;
+    name: z.ZodString;
+    minify: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"discord">;
+    name: z.ZodString;
+  }, 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 ChannelSpec = z.infer<typeof channelSpecSchema>;
+declare const profileSpecSchema: z.ZodObject<{
+  name: z.ZodString;
+  channel: z.ZodString;
+  options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  resume: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type ProfileSpec = z.infer<typeof profileSpecSchema>;
+declare const localConfigSchema: z.ZodObject<{
+  $schema: z.ZodOptional<z.ZodString>;
+  id: z.ZodOptional<z.ZodString>;
+  channels: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    connectors: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      type: z.ZodLiteral<"slack">;
+      name: z.ZodString;
+      minify: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"discord">;
+      name: z.ZodString;
+    }, 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>>;
+  profiles: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    channel: z.ZodString;
+    options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    resume: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strip>>>;
+}, z.core.$strip>;
+type LocalConfig = z.infer<typeof localConfigSchema>;
+declare const LOCAL_CONFIG_FILENAME = "funnel.json";
 //#endregion
-//#region lib/gateway/factory.d.ts
-type Env$1 = {
-  Variables: {
-    deps: GatewayRouteDeps;
-  };
+//#region lib/engine/local-config/local-config.d.ts
+type Deps$8 = {
+  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$8);
+  read(cwd: string): LocalConfig | null;
+  private assertProfilesValid;
+}
 //#endregion
-//#region lib/gateway/funnel-event-log.d.ts
+//#region lib/engine/token-prompter/token-prompter.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 log, which keeps the offset space clean for replay.
+ * 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 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>;
-/** One broadcast event to persist, carrying the offset the broadcaster assigned. */
-type FunnelEventRecord = {
-  content: string;
-  channelId: string | null;
-  connectorId: string | null;
-  meta: Record<string, string> | null;
-  offset: number;
+declare abstract class FunnelTokenPrompter {
+  abstract promptSecret(label: string): Promise<string>;
+}
+//#endregion
+//#region lib/engine/local-config/local-config-sync.d.ts
+type Deps$7 = {
+  channels: FunnelChannels;
+  prompter: FunnelTokenPrompter;
+};
+type ConnectorSyncOutcome = {
+  name: string;
+  changed: boolean;
+};
+type LocalConfigSyncResult = {
+  touched: ConnectorSyncOutcome[];
+  removed: string[];
 };
 /**
- * Durable, append-only log of broadcaster events keyed by the offset the
- * broadcaster assigns. The gateway persists every domain event here, and
- * across restarts it both seeds the broadcaster's offset counter
- * (`findMaxOffset`) and serves reconnect replay (`loadSince`) from it.
+ * Reconciles a single funnel.json channel spec with `~/.funnel/settings.json`.
+ * The spec is the source of truth for the channel it declares:
  *
- * `loadSince` is the only method the broadcaster itself needs, which makes
- * any implementation assignable to the broadcaster's narrow `ReplaySource`.
+ *   - 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
  *
- * Implementations:
- *   - `SqliteFunnelEventLog` — the default; durable across daemon restarts.
- *   - `MemoryFunnelEventLog` — an in-process double for tests and embedders
- *     that do not need durability (replay is lost when the process exits).
+ * Removal only fires when the channel spec has a `connectors` field. An
+ * absent field means "do not manage connectors from here" and leaves
+ * everything in `~/.funnel` alone. Other channels in funnel.json (not
+ * passed to this call) are untouched.
+ *
+ * Returns the per-connector change set so callers (e.g. the claude launcher)
+ * can drive listener hot-reload on the gateway after settings are written.
  */
-declare abstract class FunnelEventLog {
-  abstract record(record: FunnelEventRecord): void;
-  abstract loadSince(since: number): ReplayableEvent[];
-  abstract findMaxOffset(): number;
-  /** Drop every stored event and reclaim the file. The broadcaster's in-memory
-   *  offset counter is unaffected, so offsets keep increasing after a clear. */
-  abstract clear(): void;
-  abstract close(): void;
+declare class FunnelLocalConfigSync {
+  private readonly channels;
+  private readonly prompter;
+  constructor(deps: Deps$7);
+  ensure(channel: ChannelSpec): Promise<LocalConfigSyncResult>;
+  private ensureConnector;
+  private ensureSlack;
+  private ensureDiscord;
+  private ensureGh;
+  private ensureSchedule;
+  private findExistingSlack;
+  private findExistingDiscord;
+  private removeExtras;
+  /**
+   * Decides how a single token slot is stored in settings.json. funnel.json
+   * never carries tokens, so the only sources are a value already in
+   * settings.json (carried over verbatim, whichever form it was — literal or an
+   * `env`-var reference set via the CLI) or, on first sync, a TTY prompt for a
+   * literal (throws when stdin is not a TTY). Either way the secret lands in the
+   * repo-scoped settings, never in the repo itself.
+   */
+  private resolveSlot;
 }
 //#endregion
-//#region lib/gateway/gateway.d.ts
-type Deps$4 = {
-  process?: FunnelProcessRunner;
-  fs?: FunnelFileSystem;
-  clock?: FunnelClock;
-  dir?: string;
-  tmpDir?: string;
-  port?: number;
+//#region lib/engine/local-config/local-config-writer.d.ts
+type Deps$6 = {
+  fs: FunnelFileSystem;
+};
+/**
+ * The one path that mutates the repo-committed funnel.json, and it only ever
+ * inserts `id`. On first launch a repo has no `id`; funnel generates one and
+ * writes it back here so future launches resolve the same `~/.funnel/projects/<id>/`.
+ * Idempotent — a no-op once `id` is present. Kept separate from the read-only
+ * FunnelLocalConfig so reads stay side-effect free.
+ */
+declare class FunnelLocalConfigWriter {
+  private readonly fs;
+  constructor(deps: Deps$6);
+  ensureId(cwd: string, id: string): void;
+}
+//#endregion
+//#region lib/gateway/publish-schema.d.ts
+/**
+ * Shared schema for `POST /channels/:channel/publish` — used by both the
+ * gateway route handler (input validation) and the CLI / programmable client
+ * (request shape). The route resolves `channel` from the path; this body
+ * covers everything else.
+ */
+declare const publishRequestSchema: z.ZodObject<{
+  content: z.ZodString;
+  meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  connector: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type PublishRequest = z.infer<typeof publishRequestSchema>;
+declare const publishResponseSchema: z.ZodObject<{
+  ok: z.ZodLiteral<true>;
+  offset: z.ZodNumber;
+}, z.core.$strip>;
+type PublishResponse = z.infer<typeof publishResponseSchema>;
+type PublishResult = {
+  state: "ok";
+  offset: number;
+} | {
+  state: "offline";
+} | {
+  state: "error";
+  reason: string;
+};
+//#endregion
+//#region lib/gateway/channel-publisher.d.ts
+type Deps$5 = {
+  port: number;
+  isDaemonRunning: () => boolean; /** Returns the daemon's gateway token, or null if unavailable. Sent as `Authorization: Bearer`. */
+  getToken?: () => string | null;
+};
+/**
+ * HTTP client for `POST /channels/:channel/publish` on a running gateway
+ * daemon. Returns `{ state: "offline" }` when the daemon isn't up so callers
+ * can branch without exceptions, mirroring `FunnelListenersClient`.
+ */
+declare class FunnelChannelPublisher {
+  private readonly port;
+  private readonly isDaemonRunning;
+  private readonly getToken;
+  constructor(deps: Deps$5);
+  publish(channelName: string, request: PublishRequest): Promise<PublishResult>;
+  private authHeaders;
+}
+//#endregion
+//#region lib/gateway/funnel-event-log.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 log, which keeps the offset 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>;
+/** One broadcast event to persist, carrying the offset the broadcaster assigned. */
+type FunnelEventRecord = {
+  content: string;
+  channelId: string | null;
+  connectorId: string | null;
+  meta: Record<string, string> | null;
+  offset: number;
+};
+/**
+ * Durable, append-only log of broadcaster events keyed by the offset the
+ * broadcaster assigns. The gateway persists every domain event here, and
+ * across restarts it both seeds the broadcaster's offset counter
+ * (`findMaxOffset`) and serves reconnect replay (`loadSince`) from it.
+ *
+ * `loadSince` is the only method the broadcaster itself needs, which makes
+ * any implementation assignable to the broadcaster's narrow `ReplaySource`.
+ *
+ * Implementations:
+ *   - `SqliteFunnelEventLog` — the default; durable across daemon restarts.
+ *   - `MemoryFunnelEventLog` — an in-process double for tests and embedders
+ *     that do not need durability (replay is lost when the process exits).
+ */
+declare abstract class FunnelEventLog {
+  abstract record(record: FunnelEventRecord): void;
+  abstract loadSince(since: number): ReplayableEvent[];
+  abstract findMaxOffset(): number;
+  /** Drop every stored event and reclaim the file. The broadcaster's in-memory
+   *  offset counter is unaffected, so offsets keep increasing after a clear. */
+  abstract clear(): void;
+  abstract close(): void;
+}
+//#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>;
 };
 /**
@@ -1324,6 +1644,34 @@ declare class FunnelListenersClient {
   private call;
 }
 //#endregion
+//#region lib/gateway/funnel-debug.d.ts
+type FunnelDebugReport = {
+  gateway: {
+    running: boolean;
+    pid: number | null;
+    port: number | null;
+    uptimeMs: number | null;
+  };
+  channels: Array<{
+    name: string;
+    connectors: string[];
+    listener: {
+      alive: boolean;
+      events: number;
+      errors: number;
+      lastEventAt: string | null;
+    } | null;
+    claudeConnected: boolean;
+    claudeClientCount: number;
+  }>;
+  recentEvents: Array<{
+    ts: number;
+    outcome: string;
+    payload: string | null;
+    preview: string | null;
+  }> | null;
+};
+//#endregion
 //#region lib/funnel.d.ts
 type Props$8 = {
   /** 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. */
@@ -1466,6 +1814,8 @@ declare class Funnel {
      */
     extraRoutes?: Hono<Env$1>;
   }): FunnelGatewayServer;
+  debug(channelName?: string): Promise<FunnelDebugReport>;
+  gatewayClient(): ReturnType<typeof hc<GatewayApp>>;
 }
 //#endregion
 //#region lib/engine/mcp/channel-server.d.ts
@@ -1742,1543 +2092,219 @@ type Props$3 = {
 };
 /**
  * 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$3);
-  promptSecret(label: string): Promise<string>;
-}
-//#endregion
-//#region lib/gateway/sqlite-funnel-event-log.d.ts
-type Props$2 = {
-  /** 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; /** Optional on-disk byte cap. Checked periodically; on overflow the oldest rows are dropped toward targetBytes and the file is VACUUMed. */
-  maxBytes?: number; /** Shrink target when maxBytes is exceeded. Defaults to maxBytes/4. */
-  targetBytes?: number;
-};
-/**
- * SQLite-backed `FunnelEventLog`. 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 SqliteFunnelEventLog extends FunnelEventLog {
-  private readonly sink;
-  private readonly now;
-  constructor(props: Props$2);
-  /**
-   * 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(record: FunnelEventRecord): 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;
-  clear(): void;
-  close(): void;
-}
-//#endregion
-//#region lib/gateway/memory-funnel-event-log.d.ts
-/**
- * In-process `FunnelEventLog` backed by a plain array. Used by tests and by
- * embedders that do not need durability — replay works within the process
- * lifetime but is lost when the process exits. Unlike the SQLite log it does
- * not truncate content or prune, so it is not meant for unbounded production
- * traffic.
- */
-declare class MemoryFunnelEventLog extends FunnelEventLog {
-  private readonly events;
-  constructor();
-  record(record: FunnelEventRecord): void;
-  loadSince(since: number): ReplayableEvent[];
-  findMaxOffset(): number;
-  clear(): void;
-  close(): void;
-}
-//#endregion
-//#region lib/gateway/sqlite-connector-diagnostic-log.d.ts
-type Props$1 = {
-  /** SQLite file for the raw (pre-filter) table. ":memory:" for tests. */rawPath: string; /** SQLite file for the processed (verdict) table. ":memory:" for tests. */
-  processedPath: string; /** SQLite file for the connection (lifecycle) table. ":memory:" for tests. */
-  connectionPath: string;
-  now?: () => number; /** Row cap for the processed and connection tables. Pruned on every insert. */
-  maxRows?: number;
-  /**
-   * Row cap for the raw table specifically. Raw rows can each hold up to
-   * `RAW_PAYLOAD_CAP` bytes, so they want a tighter cap than the small
-   * processed/connection verdict rows. Defaults to `maxRows` when unset.
-   */
-  rawMaxRows?: number; /** Age cap in ms for all tables — bounds how long untouched payloads (with PII) live. Pruned on every insert. */
-  maxAgeMs?: number; /** When set, `insert()` errors (disk full, WAL lock) are logged instead of silently dropped. */
-  logger?: FunnelLogger;
-};
-/**
- * Default `ConnectorDiagnosticLog`: three independent `LeucoLoggerSqliteSink`s, one
- * per table (raw / processed / connection), in separate files. Each sink
- * indexes the columns its queries filter on — `event_id` / `connector_id` /
- * `channel_id` for raw, plus `outcome` for processed and `status` for
- * connection — so those lookups are indexed scans (`type` is a fixed column
- * the sink extracts separately, not an index, so filtering by it is a scan).
- *
- * The raw table offloads any payload over `RAW_PAYLOAD_CAP`: rather than
- * truncating mid-string (which yields unparseable JSON), it replaces the
- * body with a small JSON object that keeps the diagnostic essentials and
- * records the dropped size under `_funnel_oversized`. Every stored payload
- * therefore stays valid JSON.
- */
-declare class SqliteConnectorDiagnosticLog extends ConnectorDiagnosticLog {
-  private readonly raw;
-  private readonly processed;
-  private readonly connection;
-  private readonly now;
-  private readonly logger;
-  constructor(props: Props$1);
-  recordRaw(record: ConnectorRawRecord): void;
-  recordProcessed(record: ConnectorProcessedRecord): void;
-  recordConnection(record: ConnectorConnectionRecord): void;
-  private report;
-  queryRaw(query: ConnectorRawQuery): StoredRawEvent[];
-  queryProcessed(query: ConnectorProcessedQuery): StoredProcessedEvent[];
-  queryConnection(query: ConnectorConnectionQuery): StoredConnectionEvent[];
-  clear(): void;
-  close(): void;
-}
-//#endregion
-//#region lib/gateway/memory-connector-diagnostic-log.d.ts
-/**
- * In-process `ConnectorDiagnosticLog` backed by one array per table. Used by tests
- * and embedders that do not need durability. Like the SQLite log it keeps
- * `seq` per-table (each array's 1-based position) and returns the most recent
- * `limit` rows oldest-first; unlike it, it never prunes and never offloads
- * oversized payloads — it keeps whatever the caller hands it, which is fine
- * for the bounded volumes a test produces. Payload-validity is therefore a
- * SQLite-only guarantee; do not write a test that leans on this double
- * rejecting a malformed payload.
- */
-declare class MemoryConnectorDiagnosticLog extends ConnectorDiagnosticLog {
-  private readonly now;
-  private readonly raws;
-  private readonly processeds;
-  private readonly connections;
-  constructor(now?: () => number);
-  recordRaw(record: ConnectorRawRecord): void;
-  recordProcessed(record: ConnectorProcessedRecord): void;
-  recordConnection(record: ConnectorConnectionRecord): void;
-  queryRaw(query: ConnectorRawQuery): StoredRawEvent[];
-  queryProcessed(query: ConnectorProcessedQuery): StoredProcessedEvent[];
-  queryConnection(query: ConnectorConnectionQuery): StoredConnectionEvent[];
-  clear(): void;
-  close(): void;
-}
-//#endregion
-//#region lib/gateway/connector-diagnostic-sql-reader.d.ts
-type Props = {
-  /** 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. */
-  connectionPath: string;
-};
-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
- * inside a JSON `event` blob): the views surface the columns as plain fields,
- * with `payload` already pulled out of the nested JSON.
- *
- * The tables are separate files. `raw` and `processed` share an `event_id`,
- * so a `JOIN` answers "the event arrived, but what verdict did it get?";
- * `connection` answers the other half — "did the listener ever connect at
- * all?". Writes are impossible: the connection is read-only and `query`
- * rejects anything but a single `SELECT`.
- */
-declare class ConnectorDiagnosticSqlReader {
-  private readonly db;
-  constructor(props: Props);
-  /**
-   * Run one read-only `SELECT` and return the rows. Returns an `Error` (rather
-   * than throwing) for a non-SELECT statement or a SQL error, so the caller
-   * can surface the message without a stack trace.
-   */
-  query(sql: string): Row[] | Error;
-  close(): void;
-}
-//#endregion
-//#region lib/cli/factory.d.ts
-type Env = {
-  Variables: {
-    funnel: Funnel;
-  };
-};
-declare const factory: _$hono_factory0.Factory<Env, string>;
-//#endregion
-//#region lib/cli/router/to-request.d.ts
-declare const toRequest: (args: string[]) => {
-  method: string;
-  path: string;
-  url: string;
-};
-//#endregion
-//#region lib/cli/router/query-to-cli-args.d.ts
-declare const queryToCliArgs: (url: string, reservedKeys?: string[]) => string[];
-//#endregion
-//#region lib/cli/routes/index.d.ts
-/**
- * Build the CLI Hono app wired to a specific Funnel instance.
- * Exposed so library consumers can mount the same routes their `fnl` CLI
- * uses against a custom Funnel (e.g. one with sandboxed boundaries).
- *
- * All CLI verbs (`add` / `remove` / `set` / `rename` / `as-default` / `request`) map to POST in
- * to-request.ts and stay in the URL as a literal segment. Read paths (list / show / launch) keep GET.
- * Help shortcuts at parameterless URLs return the help text directly so `funnel <verb>` (no args) is
- * informative instead of 404.
- */
-declare const createCliApp: (funnel: Funnel) => _$hono_hono_base0.HonoBase<Env, {
-  "/claude": {
-    $get: {
-      input: {
-        query: {
-          [x: string]: string | string[];
-          profile?: string | undefined;
-          channel?: string | undefined;
-        };
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        query: {
-          [x: string]: string | string[];
-          profile?: string | undefined;
-          channel?: string | undefined;
-        };
-      };
-      output: "funnel claude — launch Claude Code\n\nusage:\n  funnel claude                          launch the first channel from funnel.json, or the default profile\n  funnel claude --channel <name>         with funnel.json: select that channel; without: raw launch\n  funnel claude -p <name>                launch a named profile\n  funnel claude --profile <name>         (long form)\n  funnel claude [...]                    any other argument is forwarded to the claude CLI\n\nresolution order:\n  1. --help                              print this help\n  2. --profile <name>                    named profile (ignores funnel.json)\n  3. ./funnel.json in the current directory + --channel selects (or first wins)\n  4. --channel <name> with no funnel.json → raw launch using an existing settings.json channel\n  5. 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 (selects from funnel.json, or raw-launches if no funnel.json)\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;
-    };
-  };
-} & {
-  "/channels": {
-    $get: {
-      input: {
-        query: Record<string, never>;
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/channels/add": {
-    $post: {
-      input: {};
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/channels/add/:channel": {
-    $post: {
-      input: {
-        param: {
-          channel: string;
-        };
-      } & {
-        query: {
-          delivery?: "fanout" | "exclusive" | undefined;
-        };
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        param: {
-          channel: string;
-        };
-      } & {
-        query: {
-          delivery?: "fanout" | "exclusive" | undefined;
-        };
-      };
-      output: `added channel "${string}" (id: ${string})`;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/channels/remove": {
-    $post: {
-      input: {};
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/channels/remove/:channel": {
-    $post: {
-      input: {
-        param: {
-          channel: string;
-        };
-      } & {
-        query: Record<string, never>;
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        param: {
-          channel: string;
-        };
-      } & {
-        query: Record<string, never>;
-      };
-      output: `removed channel "${string}"`;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/channels/rename/:channel/:newName": {
-    $post: {
-      input: {
-        param: {
-          channel: string;
-          newName: string;
-        };
-      } & {
-        query: Record<string, never>;
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        param: {
-          channel: string;
-          newName: string;
-        };
-      } & {
-        query: Record<string, never>;
-      };
-      output: `renamed channel "${string}" to "${string}"`;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/channels/:channel/rename/:newName": {
-    $post: {
-      input: {
-        param: {
-          channel: string;
-          newName: string;
-        };
-      } & {
-        query: Record<string, never>;
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        param: {
-          channel: string;
-          newName: string;
-        };
-      } & {
-        query: Record<string, never>;
-      };
-      output: `renamed channel "${string}" to "${string}"`;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/channels/rename": {
-    $post: {
-      input: {};
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/channels/:channel/rename": {
-    $post: {
-      input: {
-        param: {
-          channel: string;
-        };
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/channels/:channel/set/delivery/:mode": {
-    $post: {
-      input: {
-        param: {
-          channel: string;
-          mode: "fanout" | "exclusive";
-        };
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        param: {
-          channel: string;
-          mode: "fanout" | "exclusive";
-        };
-      };
-      output: `channel "${string}" delivery set to fanout` | `channel "${string}" delivery set to exclusive`;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/channels/publish": {
-    $post: {
-      input: {};
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/channels/:channel/publish": {
-    $post: {
-      input: {
-        param: {
-          channel: string;
-        };
-      } & {
-        query: {
-          [x: string]: string | string[];
-          content: string | string[];
-          connector?: string | undefined;
-        };
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        param: {
-          channel: string;
-        };
-      } & {
-        query: {
-          [x: string]: string | string[];
-          content: string | string[];
-          connector?: string | undefined;
-        };
-      };
-      output: `published (offset=${number})`;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/channels/:channel": {
-    $get: {
-      input: {
-        param: {
-          channel: string;
-        };
-      } & {
-        query: Record<string, never>;
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/channels/:channel/connectors": {
-    $get: {
-      input: {
-        param: {
-          channel: string;
-        };
-      } & {
-        query: Record<string, never>;
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/channels/:channel/connectors/add": {
-    $post: {
-      input: {
-        param: {
-          channel: string;
-        };
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/channels/:channel/connectors/add/:connector": {
-    $post: {
-      input: {
-        param: {
-          channel: string;
-          connector: string;
-        };
-      } & {
-        query: {
-          type: string | string[];
-          "bot-token": string | string[];
-          "app-token": string | string[];
-        } | {
-          type: string | string[];
-          "poll-interval"?: string | string[] | undefined;
-        } | {
-          type: string | string[];
-          "bot-token": string | string[];
-        } | {
-          type: string | string[];
-        };
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        param: {
-          channel: string;
-          connector: string;
-        };
-      } & {
-        query: {
-          type: string | string[];
-          "bot-token": string | string[];
-          "app-token": string | string[];
-        } | {
-          type: string | string[];
-          "poll-interval"?: string | string[] | undefined;
-        } | {
-          type: string | string[];
-          "bot-token": string | string[];
-        } | {
-          type: string | string[];
-        };
-      };
-      output: `added slack connector "${string}" to channel "${string}"`;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        param: {
-          channel: string;
-          connector: string;
-        };
-      } & {
-        query: {
-          type: string | string[];
-          "bot-token": string | string[];
-          "app-token": string | string[];
-        } | {
-          type: string | string[];
-          "poll-interval"?: string | string[] | undefined;
-        } | {
-          type: string | string[];
-          "bot-token": string | string[];
-        } | {
-          type: string | string[];
-        };
-      };
-      output: `added gh connector "${string}" to channel "${string}"`;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        param: {
-          channel: string;
-          connector: string;
-        };
-      } & {
-        query: {
-          type: string | string[];
-          "bot-token": string | string[];
-          "app-token": string | string[];
-        } | {
-          type: string | string[];
-          "poll-interval"?: string | string[] | undefined;
-        } | {
-          type: string | string[];
-          "bot-token": string | string[];
-        } | {
-          type: string | string[];
-        };
-      };
-      output: `added discord connector "${string}" to channel "${string}"`;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        param: {
-          channel: string;
-          connector: string;
-        };
-      } & {
-        query: {
-          type: string | string[];
-          "bot-token": string | string[];
-          "app-token": string | string[];
-        } | {
-          type: string | string[];
-          "poll-interval"?: string | string[] | undefined;
-        } | {
-          type: string | string[];
-          "bot-token": string | string[];
-        } | {
-          type: string | string[];
-        };
-      };
-      output: `added schedule connector "${string}" to channel "${string}"`;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/channels/:channel/connectors/remove": {
-    $post: {
-      input: {
-        param: {
-          channel: string;
-        };
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/channels/:channel/connectors/remove/:connector": {
-    $post: {
-      input: {
-        param: {
-          channel: string;
-          connector: string;
-        };
-      } & {
-        query: Record<string, never>;
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        param: {
-          channel: string;
-          connector: string;
-        };
-      } & {
-        query: Record<string, never>;
-      };
-      output: `removed connector "${string}" from channel "${string}"`;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/channels/:channel/connectors/set": {
-    $post: {
-      input: {
-        param: {
-          channel: string;
-        };
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/channels/:channel/connectors/set/:connector": {
-    $post: {
-      input: {
-        param: {
-          channel: string;
-          connector: string;
-        };
-      } & {
-        query: {
-          [x: string]: string | string[];
-          "bot-token"?: string | undefined;
-          "app-token"?: string | undefined;
-          "poll-interval"?: string | string[] | undefined;
-        };
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        param: {
-          channel: string;
-          connector: string;
-        };
-      } & {
-        query: {
-          [x: string]: string | string[];
-          "bot-token"?: string | undefined;
-          "app-token"?: string | undefined;
-          "poll-interval"?: string | string[] | undefined;
-        };
-      };
-      output: `updated connector "${string}" in channel "${string}"`;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/channels/:channel/connectors/rename/:connector/:newName": {
-    $post: {
-      input: {
-        param: {
-          channel: string;
-          connector: string;
-          newName: string;
-        };
-      } & {
-        query: Record<string, never>;
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        param: {
-          channel: string;
-          connector: string;
-          newName: string;
-        };
-      } & {
-        query: Record<string, never>;
-      };
-      output: `renamed connector "${string}" to "${string}"`;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/channels/:channel/connectors/:connector/rename/:newName": {
-    $post: {
-      input: {
-        param: {
-          channel: string;
-          connector: string;
-          newName: string;
-        };
-      } & {
-        query: Record<string, never>;
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        param: {
-          channel: string;
-          connector: string;
-          newName: string;
-        };
-      } & {
-        query: Record<string, never>;
-      };
-      output: `renamed connector "${string}" to "${string}"`;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/channels/:channel/connectors/rename": {
-    $post: {
-      input: {
-        param: {
-          channel: string;
-        };
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/channels/:channel/connectors/:connector/rename": {
-    $post: {
-      input: {
-        param: {
-          channel: string;
-        } & {
-          connector: string;
-        };
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/channels/:channel/connectors/:connector/request": {
-    $post: {
-      input: {
-        param: {
-          channel: string;
-          connector: string;
-        };
-      } & {
-        query: {
-          [x: string]: string | string[];
-          method: string | string[];
-        };
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/channels/:channel/connectors/:connector": {
-    $get: {
-      input: {
-        param: {
-          channel: string;
-          connector: string;
-        };
-      } & {
-        query: Record<string, never>;
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/channels/:channel/connectors/:connector/schedules": {
-    $get: {
-      input: {
-        param: {
-          channel: string;
-          connector: string;
-        };
-      } & {
-        query: Record<string, never>;
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/channels/:channel/connectors/:connector/schedules/add": {
-    $post: {
-      input: {
-        param: {
-          channel: string;
-        } & {
-          connector: string;
-        };
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/channels/:channel/connectors/:connector/schedules/add/:id": {
-    $post: {
-      input: {
-        param: {
-          channel: string;
-          connector: string;
-          id: string;
-        };
-      } & {
-        query: {
-          cron: string | string[];
-          prompt: string | string[];
-          enabled?: string | string[] | undefined;
-          "catchup-policy"?: "latest" | "all" | "skip" | undefined;
-        };
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        param: {
-          channel: string;
-          connector: string;
-          id: string;
-        };
-      } & {
-        query: {
-          cron: string | string[];
-          prompt: string | string[];
-          enabled?: string | string[] | undefined;
-          "catchup-policy"?: "latest" | "all" | "skip" | undefined;
-        };
-      };
-      output: `added schedule entry "${string}"`;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/channels/:channel/connectors/:connector/schedules/remove": {
-    $post: {
-      input: {
-        param: {
-          channel: string;
-        } & {
-          connector: string;
-        };
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/channels/:channel/connectors/:connector/schedules/remove/:id": {
-    $post: {
-      input: {
-        param: {
-          channel: string;
-          connector: string;
-          id: string;
-        };
-      } & {
-        query: Record<string, never>;
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        param: {
-          channel: string;
-          connector: string;
-          id: string;
-        };
-      } & {
-        query: Record<string, never>;
-      };
-      output: `removed schedule entry "${string}"`;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/profiles": {
-    $get: {
-      input: {
-        query: Record<string, never>;
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/profiles/add": {
-    $post: {
-      input: {};
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/profiles/add/:profile": {
-    $post: {
-      input: {
-        param: {
-          profile: string;
-        };
-      } & {
-        query: {
-          path: string;
-          channel: string;
-          agent?: string | undefined;
-          options?: string | undefined;
-          env?: string | undefined;
-          resume?: string | undefined;
-          "no-resume"?: string | undefined;
-        };
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        param: {
-          profile: string;
-        };
-      } & {
-        query: {
-          path: string;
-          channel: string;
-          agent?: string | undefined;
-          options?: string | undefined;
-          env?: string | undefined;
-          resume?: string | undefined;
-          "no-resume"?: string | undefined;
-        };
-      };
-      output: `added profile "${string}"`;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/profiles/set": {
-    $post: {
-      input: {};
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/profiles/set/:profile": {
-    $post: {
-      input: {
-        param: {
-          profile: string;
-        };
-      } & {
-        query: {
-          path?: string | undefined;
-          channel?: string | undefined;
-          agent?: string | undefined;
-          options?: string | undefined;
-          env?: string | undefined;
-          resume?: string | undefined;
-          "no-resume"?: string | undefined;
-        };
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        param: {
-          profile: string;
-        };
-      } & {
-        query: {
-          path?: string | undefined;
-          channel?: string | undefined;
-          agent?: string | undefined;
-          options?: string | undefined;
-          env?: string | undefined;
-          resume?: string | undefined;
-          "no-resume"?: string | undefined;
-        };
-      };
-      output: `updated profile "${string}"`;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/profiles/remove": {
-    $post: {
-      input: {};
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/profiles/remove/:profile": {
-    $post: {
-      input: {
-        param: {
-          profile: string;
-        };
-      } & {
-        query: Record<string, never>;
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        param: {
-          profile: string;
-        };
-      } & {
-        query: Record<string, never>;
-      };
-      output: `removed profile "${string}"`;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/profiles/rename/:profile/:newName": {
-    $post: {
-      input: {
-        param: {
-          profile: string;
-          newName: string;
-        };
-      } & {
-        query: Record<string, never>;
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        param: {
-          profile: string;
-          newName: string;
-        };
-      } & {
-        query: Record<string, never>;
-      };
-      output: `renamed profile "${string}" to "${string}"`;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/profiles/:profile/rename/:newName": {
-    $post: {
-      input: {
-        param: {
-          profile: string;
-          newName: string;
-        };
-      } & {
-        query: Record<string, never>;
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        param: {
-          profile: string;
-          newName: string;
-        };
-      } & {
-        query: Record<string, never>;
-      };
-      output: `renamed profile "${string}" to "${string}"`;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/profiles/rename": {
-    $post: {
-      input: {};
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/profiles/:profile/rename": {
-    $post: {
-      input: {
-        param: {
-          profile: string;
-        };
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/profiles/:profile/as-default": {
-    $post: {
-      input: {
-        param: {
-          profile: string;
-        };
-      } & {
-        query: Record<string, never>;
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        param: {
-          profile: string;
-        };
-      } & {
-        query: Record<string, never>;
-      };
-      output: `profile "${string}" is now the default`;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/profiles/:profile/run": {
-    $get: {
-      input: {
-        param: {
-          profile: string;
-        };
-      } & {
-        query: {
-          [x: string]: string | string[];
-        };
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        param: {
-          profile: string;
-        };
-      } & {
-        query: {
-          [x: string]: string | string[];
-        };
-      };
-      output: Promise<never>;
-      outputFormat: "json";
-      status: _$hono_utils_http_status0.StatusCode;
-    };
-  };
-} & {
-  "/profiles/:profile": {
-    $get: {
-      input: {
-        param: {
-          profile: string;
-        };
-      } & {
-        query: {
-          [x: string]: string | string[];
-        };
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        param: {
-          profile: string;
-        };
-      } & {
-        query: {
-          [x: string]: string | string[];
-        };
-      };
-      output: Promise<never>;
-      outputFormat: "json";
-      status: _$hono_utils_http_status0.StatusCode;
-    };
-  };
-} & {
-  "/gateway": {
-    $get: {
-      input: {};
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {};
-      output: "funnel gateway: running (pid null) — health check failed" | `funnel gateway: running (pid ${number}) \u2014 health check failed`;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {};
-      output: `funnel gateway: running (pid null)
-  port: ${number}
-  clients: ${string}` | `funnel gateway: running (pid ${number})
-  port: ${number}
-  clients: ${string}`;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/gateway/status": {
-    $get: {
-      input: {};
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {};
-      output: "funnel gateway: running (pid null) — health check failed" | `funnel gateway: running (pid ${number}) \u2014 health check failed`;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {};
-      output: `funnel gateway: running (pid null)
-  port: ${number}
-  clients: ${string}` | `funnel gateway: running (pid ${number})
-  port: ${number}
-  clients: ${string}`;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/gateway/start": {
-    $get: {
-      input: {
-        query: {
-          "no-caffeine"?: string | undefined;
-        };
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        query: {
-          "no-caffeine"?: string | undefined;
-        };
-      };
-      output: "funnel gateway: already running (pid null)" | `funnel gateway: already running (pid ${number})`;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        query: {
-          "no-caffeine"?: string | undefined;
-        };
-      };
-      output: "funnel gateway: started";
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/gateway/stop": {
-    $get: {
-      input: {
-        query: Record<string, never>;
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        query: Record<string, never>;
-      };
-      output: "funnel gateway: no running process";
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        query: Record<string, never>;
-      };
-      output: "funnel gateway: stopped";
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/gateway/restart": {
-    $get: {
-      input: {
-        query: {
-          "no-caffeine"?: string | undefined;
-        };
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/gateway/run": {
-    $get: {
-      input: {
-        query: {
-          "no-caffeine"?: string | undefined;
-        };
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        query: {
-          "no-caffeine"?: string | undefined;
-        };
-      };
-      output: Promise<never>;
-      outputFormat: "json";
-      status: _$hono_utils_http_status0.StatusCode;
-    };
-  };
-} & {
-  "/gateway/logs": {
-    $get: {
-      input: {
-        query: {
-          n?: string | undefined;
-        };
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        query: {
-          n?: string | undefined;
-        };
-      };
-      output: "no logs";
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/gateway/sql": {
-    $get: {
-      input: {
-        query: {
-          query?: string | undefined;
-        };
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/gateway/listeners": {
-    $get: {
-      input: {
-        query: Record<string, never>;
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        query: Record<string, never>;
-      };
-      output: "funnel gateway: no running listeners";
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        query: Record<string, never>;
-      };
-      output: `funnel gateway: running listeners
-${string}`;
-      outputFormat: "text";
-      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: {
-      input: {
-        query: Record<string, never>;
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/update": {
-    $get: {
-      input: {
-        query: Record<string, never>;
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        query: Record<string, never>;
-      };
-      output: "updated @interactive-inc/claude-funnel";
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
+ * unmapped labels throw so the test surfaces unexpected prompts loudly.
+ */
+declare class MemoryFunnelTokenPrompter extends FunnelTokenPrompter {
+  private readonly answers;
+  readonly asked: string[];
+  constructor(props?: Props$3);
+  promptSecret(label: string): Promise<string>;
+}
+//#endregion
+//#region lib/gateway/sqlite-funnel-event-log.d.ts
+type Props$2 = {
+  /** 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; /** Optional on-disk byte cap. Checked periodically; on overflow the oldest rows are dropped toward targetBytes and the file is VACUUMed. */
+  maxBytes?: number; /** Shrink target when maxBytes is exceeded. Defaults to maxBytes/4. */
+  targetBytes?: number;
+};
+/**
+ * SQLite-backed `FunnelEventLog`. 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 SqliteFunnelEventLog extends FunnelEventLog {
+  private readonly sink;
+  private readonly now;
+  constructor(props: Props$2);
+  /**
+   * 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(record: FunnelEventRecord): 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;
+  clear(): void;
+  close(): void;
+}
+//#endregion
+//#region lib/gateway/memory-funnel-event-log.d.ts
+/**
+ * In-process `FunnelEventLog` backed by a plain array. Used by tests and by
+ * embedders that do not need durability — replay works within the process
+ * lifetime but is lost when the process exits. Unlike the SQLite log it does
+ * not truncate content or prune, so it is not meant for unbounded production
+ * traffic.
+ */
+declare class MemoryFunnelEventLog extends FunnelEventLog {
+  private readonly events;
+  constructor();
+  record(record: FunnelEventRecord): void;
+  loadSince(since: number): ReplayableEvent[];
+  findMaxOffset(): number;
+  clear(): void;
+  close(): void;
+}
+//#endregion
+//#region lib/gateway/sqlite-connector-diagnostic-log.d.ts
+type Props$1 = {
+  /** SQLite file for the raw (pre-filter) table. ":memory:" for tests. */rawPath: string; /** SQLite file for the processed (verdict) table. ":memory:" for tests. */
+  processedPath: string; /** SQLite file for the connection (lifecycle) table. ":memory:" for tests. */
+  connectionPath: string;
+  now?: () => number; /** Row cap for the processed and connection tables. Pruned on every insert. */
+  maxRows?: number;
+  /**
+   * Row cap for the raw table specifically. Raw rows can each hold up to
+   * `RAW_PAYLOAD_CAP` bytes, so they want a tighter cap than the small
+   * processed/connection verdict rows. Defaults to `maxRows` when unset.
+   */
+  rawMaxRows?: number; /** Age cap in ms for all tables — bounds how long untouched payloads (with PII) live. Pruned on every insert. */
+  maxAgeMs?: number; /** When set, `insert()` errors (disk full, WAL lock) are logged instead of silently dropped. */
+  logger?: FunnelLogger;
+};
+/**
+ * Default `ConnectorDiagnosticLog`: three independent `LeucoLoggerSqliteSink`s, one
+ * per table (raw / processed / connection), in separate files. Each sink
+ * indexes the columns its queries filter on — `event_id` / `connector_id` /
+ * `channel_id` for raw, plus `outcome` for processed and `status` for
+ * connection — so those lookups are indexed scans (`type` is a fixed column
+ * the sink extracts separately, not an index, so filtering by it is a scan).
+ *
+ * The raw table offloads any payload over `RAW_PAYLOAD_CAP`: rather than
+ * truncating mid-string (which yields unparseable JSON), it replaces the
+ * body with a small JSON object that keeps the diagnostic essentials and
+ * records the dropped size under `_funnel_oversized`. Every stored payload
+ * therefore stays valid JSON.
+ */
+declare class SqliteConnectorDiagnosticLog extends ConnectorDiagnosticLog {
+  private readonly raw;
+  private readonly processed;
+  private readonly connection;
+  private readonly now;
+  private readonly logger;
+  constructor(props: Props$1);
+  recordRaw(record: ConnectorRawRecord): void;
+  recordProcessed(record: ConnectorProcessedRecord): void;
+  recordConnection(record: ConnectorConnectionRecord): void;
+  private report;
+  queryRaw(query: ConnectorRawQuery): StoredRawEvent[];
+  queryProcessed(query: ConnectorProcessedQuery): StoredProcessedEvent[];
+  queryConnection(query: ConnectorConnectionQuery): StoredConnectionEvent[];
+  clear(): void;
+  close(): void;
+}
+//#endregion
+//#region lib/gateway/memory-connector-diagnostic-log.d.ts
+/**
+ * In-process `ConnectorDiagnosticLog` backed by one array per table. Used by tests
+ * and embedders that do not need durability. Like the SQLite log it keeps
+ * `seq` per-table (each array's 1-based position) and returns the most recent
+ * `limit` rows oldest-first; unlike it, it never prunes and never offloads
+ * oversized payloads — it keeps whatever the caller hands it, which is fine
+ * for the bounded volumes a test produces. Payload-validity is therefore a
+ * SQLite-only guarantee; do not write a test that leans on this double
+ * rejecting a malformed payload.
+ */
+declare class MemoryConnectorDiagnosticLog extends ConnectorDiagnosticLog {
+  private readonly now;
+  private readonly raws;
+  private readonly processeds;
+  private readonly connections;
+  constructor(now?: () => number);
+  recordRaw(record: ConnectorRawRecord): void;
+  recordProcessed(record: ConnectorProcessedRecord): void;
+  recordConnection(record: ConnectorConnectionRecord): void;
+  queryRaw(query: ConnectorRawQuery): StoredRawEvent[];
+  queryProcessed(query: ConnectorProcessedQuery): StoredProcessedEvent[];
+  queryConnection(query: ConnectorConnectionQuery): StoredConnectionEvent[];
+  clear(): void;
+  close(): void;
+}
+//#endregion
+//#region lib/gateway/connector-diagnostic-sql-reader.d.ts
+type Props = {
+  /** 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. */
+  connectionPath: string;
+};
+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
+ * inside a JSON `event` blob): the views surface the columns as plain fields,
+ * with `payload` already pulled out of the nested JSON.
+ *
+ * The tables are separate files. `raw` and `processed` share an `event_id`,
+ * so a `JOIN` answers "the event arrived, but what verdict did it get?";
+ * `connection` answers the other half — "did the listener ever connect at
+ * all?". Writes are impossible: the connection is read-only and `query`
+ * rejects anything but a single `SELECT`.
+ */
+declare class ConnectorDiagnosticSqlReader {
+  private readonly db;
+  constructor(props: Props);
+  /**
+   * Run one read-only `SELECT` and return the rows. Returns an `Error` (rather
+   * than throwing) for a non-SELECT statement or a SQL error, so the caller
+   * can surface the message without a stack trace.
+   */
+  query(sql: string, params?: (string | number | null)[]): Row[] | Error;
+  close(): void;
+}
+//#endregion
+//#region lib/cli/factory.d.ts
+type Env = {
+  Bindings: {
+    funnel: Funnel;
   };
-}, "/", "/update">;
-/** CLI Hono app wired to a default `new Funnel()`. For embedding with a custom Funnel use `createCliApp`. */
-declare const app: _$hono_hono_base0.HonoBase<Env, {
+};
+declare const factory: _$hono_factory0.Factory<Env, string>;
+//#endregion
+//#region lib/cli/router/to-request.d.ts
+declare const toRequest: (args: string[]) => {
+  method: string;
+  path: string;
+  url: string;
+};
+//#endregion
+//#region lib/cli/router/query-to-cli-args.d.ts
+declare const queryToCliArgs: (url: string, reservedKeys?: string[]) => string[];
+//#endregion
+//#region lib/cli/routes/index.d.ts
+declare const routes: _$hono_hono_base0.HonoBase<Env, {
   "/claude": {
     $get: {
       input: {
@@ -3308,18 +2334,38 @@ declare const app: _$hono_hono_base0.HonoBase<Env, {
   "/channels": {
     $get: {
       input: {
-        query: Record<string, never>;
+        query: {
+          json?: "" | "true" | "false" | undefined;
+        };
       };
       output: string;
       outputFormat: "text";
       status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: {
+          json?: "" | "true" | "false" | undefined;
+        };
+      };
+      output: {
+        id: string;
+        name: string;
+        delivery: "fanout" | "exclusive";
+        connectors: {
+          id: string;
+          name: string;
+          type: "schedule" | "slack" | "gh" | "discord";
+        }[];
+      }[];
+      outputFormat: "json";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
     };
   };
 } & {
   "/channels/add": {
     $post: {
       input: {};
-      output: string;
+      output: "funnel channels add — add a channel\n\nusage: funnel channels add <name> [--delivery fanout|exclusive]\n\noptions:\n  --delivery    routing mode (default fanout):\n                  fanout      every connected client receives every event\n                  exclusive   each event delivered to exactly one client (round-robin)";
       outputFormat: "text";
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     };
@@ -3358,7 +2404,7 @@ declare const app: _$hono_hono_base0.HonoBase<Env, {
   "/channels/remove": {
     $post: {
       input: {};
-      output: string;
+      output: "funnel channels remove — remove a channel\n\nusage: funnel channels remove <name>";
       outputFormat: "text";
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     };
@@ -3449,7 +2495,7 @@ declare const app: _$hono_hono_base0.HonoBase<Env, {
   "/channels/rename": {
     $post: {
       input: {};
-      output: string;
+      output: "funnel channels rename — rename a channel\n\nusage:\n  funnel channels rename <old> <new>\n  funnel channels <old> rename <new>";
       outputFormat: "text";
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     };
@@ -3462,7 +2508,7 @@ declare const app: _$hono_hono_base0.HonoBase<Env, {
           channel: string;
         };
       };
-      output: string;
+      output: "funnel channels rename — rename a channel\n\nusage:\n  funnel channels rename <old> <new>\n  funnel channels <old> rename <new>";
       outputFormat: "text";
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     };
@@ -3495,7 +2541,7 @@ declare const app: _$hono_hono_base0.HonoBase<Env, {
   "/channels/publish": {
     $post: {
       input: {};
-      output: string;
+      output: "funnel channels <channel> publish — push arbitrary content into a channel\n\nusage: funnel channels <channel> publish --content=\"<text>\" [--connector=<name>] [--meta-<key>=<value> ...]\n\noptions:\n  --content       Required. The event body delivered to subscribers.\n  --connector     Optional. Stamp the event with a connector name (resolved to id when found).\n  --meta-<key>    Optional. Repeatable. Added to meta. Example: --meta-source=cron";
       outputFormat: "text";
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     };
@@ -3534,6 +2580,53 @@ declare const app: _$hono_hono_base0.HonoBase<Env, {
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     };
   };
+} & {
+  "/channels/:channel/validate": {
+    $get: {
+      input: {
+        param: {
+          channel: string;
+        };
+      } & {
+        query: {
+          json?: "" | "true" | "false" | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          channel: string;
+        };
+      } & {
+        query: {
+          json?: "" | "true" | "false" | undefined;
+        };
+      };
+      output: {
+        channel: string;
+        valid: boolean;
+        issues: {
+          connector: string;
+          field: string;
+          message: string;
+        }[];
+      };
+      outputFormat: "json";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/validate": {
+    $get: {
+      input: {};
+      output: "funnel channels <channel> validate — check connector configuration\n\nusage: funnel channels <channel> validate [--json]\n\noptions:\n  --json   output as JSON\n\nChecks that each connector has the required tokens and fields set.\nDoes not make any network calls — static config check only.\n\nexamples:\n  funnel channels open-karte validate\n  funnel channels open-karte validate --json";
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
 } & {
   "/channels/:channel": {
     $get: {
@@ -3572,7 +2665,7 @@ declare const app: _$hono_hono_base0.HonoBase<Env, {
           channel: string;
         };
       };
-      output: string;
+      output: "funnel channels <channel> connectors add <connector> — add a connector to a channel\n\nusage:\n  funnel channels <channel> connectors add <connector> --type=slack --bot-token=xoxb-... --app-token=xapp-...\n  funnel channels <channel> connectors add <connector> --type=gh [--poll-interval=60]\n  funnel channels <channel> connectors add <connector> --type=discord --bot-token=...\n  funnel channels <channel> connectors add <connector> --type=schedule\n\nToken uniqueness is enforced across all channels.";
       outputFormat: "text";
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     };
@@ -3709,7 +2802,7 @@ declare const app: _$hono_hono_base0.HonoBase<Env, {
           channel: string;
         };
       };
-      output: string;
+      output: "funnel channels <channel> connectors remove <connector> — remove a connector\n\nusage: funnel channels <channel> connectors remove <connector>";
       outputFormat: "text";
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     };
@@ -3750,7 +2843,7 @@ declare const app: _$hono_hono_base0.HonoBase<Env, {
           channel: string;
         };
       };
-      output: string;
+      output: "funnel channels <channel> connectors set <connector> — update connector fields\n\nusage:\n  funnel channels <ch> connectors set <conn> [--bot-token=...] [--app-token=...]   # slack\n  funnel channels <ch> connectors set <conn> [--bot-token=...]                    # discord\n  funnel channels <ch> connectors set <conn> [--poll-interval=N]                  # gh";
       outputFormat: "text";
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     };
@@ -3861,7 +2954,7 @@ declare const app: _$hono_hono_base0.HonoBase<Env, {
           channel: string;
         };
       };
-      output: string;
+      output: "funnel channels <channel> connectors rename <connector> <new-name>\n\nusage: funnel channels <channel> connectors rename <connector> <new-name>";
       outputFormat: "text";
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     };
@@ -3876,7 +2969,7 @@ declare const app: _$hono_hono_base0.HonoBase<Env, {
           connector: string;
         };
       };
-      output: string;
+      output: "funnel channels <channel> connectors rename <connector> <new-name>\n\nusage: funnel channels <channel> connectors rename <connector> <new-name>";
       outputFormat: "text";
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     };
@@ -3942,7 +3035,7 @@ declare const app: _$hono_hono_base0.HonoBase<Env, {
           connector: string;
         };
       };
-      output: string;
+      output: "funnel channels <ch> connectors <conn> schedules add <id> — add a schedule entry\n\nusage: funnel channels <ch> connectors <conn> schedules add <id> --cron=\"*/5 * * * *\" --prompt=\"...\" [--enabled=true] [--catchup-policy=latest|all|skip]";
       outputFormat: "text";
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     };
@@ -3997,7 +3090,7 @@ declare const app: _$hono_hono_base0.HonoBase<Env, {
           connector: string;
         };
       };
-      output: string;
+      output: "funnel channels <ch> connectors <conn> schedules remove <id>\n\nusage: funnel channels <ch> connectors <conn> schedules remove <id>";
       outputFormat: "text";
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     };
@@ -4047,7 +3140,7 @@ declare const app: _$hono_hono_base0.HonoBase<Env, {
   "/profiles/add": {
     $post: {
       input: {};
-      output: string;
+      output: "funnel profiles add — add a profile\n\nusage: funnel profiles add <name> --path <path> --channel <channel-name> [recipe]\n\noptions:\n  --path        working directory passed to claude as cwd\n  --channel     channel name (resolved to channel id internally)\n  --agent       sub-agent name, prepended to the launch argv as --agent <name>\n  --options     extra launch argv as one whitespace-split string (e.g. \"--brief\")\n  --env         env vars layered under the process, as \"KEY=VAL,KEY2=VAL2\"\n  --no-resume   start a fresh claude session every launch (default resumes)\n\nThe launch recipe (--agent / --options / --env / --resume) lives on the\nprofile; the channel only declares transport (connectors / delivery).";
       outputFormat: "text";
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     };
@@ -4098,7 +3191,7 @@ declare const app: _$hono_hono_base0.HonoBase<Env, {
   "/profiles/set": {
     $post: {
       input: {};
-      output: string;
+      output: "funnel profiles <name> set — update a profile\n\nusage: funnel profiles <name> set [--path <path>] [--channel <channel-name>] [recipe]\n\noptions:\n  --path        working directory passed to claude as cwd\n  --channel     channel name (resolved to channel id internally)\n  --agent       sub-agent name, prepended to the launch argv as --agent <name>\n  --options     extra launch argv as one whitespace-split string (e.g. \"--brief\")\n  --env         env vars layered under the process, as \"KEY=VAL,KEY2=VAL2\"\n  --resume / --no-resume  toggle claude session reuse\n\nOnly the flags you pass are changed; --agent and --options together replace\nthe profile's whole options list.";
       outputFormat: "text";
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     };
@@ -4149,7 +3242,7 @@ declare const app: _$hono_hono_base0.HonoBase<Env, {
   "/profiles/remove": {
     $post: {
       input: {};
-      output: string;
+      output: "funnel profiles remove — remove a profile\n\nusage: funnel profiles remove <name>";
       outputFormat: "text";
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     };
@@ -4240,7 +3333,7 @@ declare const app: _$hono_hono_base0.HonoBase<Env, {
   "/profiles/rename": {
     $post: {
       input: {};
-      output: string;
+      output: "funnel profiles rename — rename a profile\n\nusage:\n  funnel profiles rename <old> <new>\n  funnel profiles <old> rename <new>";
       outputFormat: "text";
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     };
@@ -4253,19 +3346,266 @@ declare const app: _$hono_hono_base0.HonoBase<Env, {
           profile: string;
         };
       };
+      output: "funnel profiles rename — rename a profile\n\nusage:\n  funnel profiles rename <old> <new>\n  funnel profiles <old> rename <new>";
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/profiles/:profile/as-default": {
+    $post: {
+      input: {
+        param: {
+          profile: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          profile: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: `profile "${string}" is now the default`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/profiles/:profile/run": {
+    $get: {
+      input: {
+        param: {
+          profile: string;
+        };
+      } & {
+        query: {
+          [x: string]: string | string[];
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          profile: string;
+        };
+      } & {
+        query: {
+          [x: string]: string | string[];
+        };
+      };
+      output: Promise<never>;
+      outputFormat: "json";
+      status: _$hono_utils_http_status0.StatusCode;
+    };
+  };
+} & {
+  "/profiles/:profile": {
+    $get: {
+      input: {
+        param: {
+          profile: string;
+        };
+      } & {
+        query: {
+          [x: string]: string | string[];
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          profile: string;
+        };
+      } & {
+        query: {
+          [x: string]: string | string[];
+        };
+      };
+      output: Promise<never>;
+      outputFormat: "json";
+      status: _$hono_utils_http_status0.StatusCode;
+    };
+  };
+} & {
+  "/gateway": {
+    $get: {
+      input: {};
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/gateway/status": {
+    $get: {
+      input: {
+        query: {
+          json?: "" | "true" | "false" | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: {
+          json?: "" | "true" | "false" | undefined;
+        };
+      };
+      output: {
+        running: true;
+        port: number;
+      };
+      outputFormat: "json";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/gateway/start": {
+    $get: {
+      input: {
+        query: {
+          "no-caffeine"?: string | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: {
+          "no-caffeine"?: string | undefined;
+        };
+      };
+      output: "funnel gateway: already running (pid null)" | `funnel gateway: already running (pid ${number})`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: {
+          "no-caffeine"?: string | undefined;
+        };
+      };
+      output: "funnel gateway: started";
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/gateway/stop": {
+    $get: {
+      input: {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: Record<string, never>;
+      };
+      output: "funnel gateway: no running process";
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: Record<string, never>;
+      };
+      output: "funnel gateway: stopped";
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/gateway/restart": {
+    $get: {
+      input: {
+        query: {
+          "no-caffeine"?: string | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/gateway/run": {
+    $get: {
+      input: {
+        query: {
+          "no-caffeine"?: string | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: {
+          "no-caffeine"?: string | undefined;
+        };
+      };
+      output: Promise<never>;
+      outputFormat: "json";
+      status: _$hono_utils_http_status0.StatusCode;
+    };
+  };
+} & {
+  "/gateway/logs": {
+    $get: {
+      input: {
+        query: {
+          n?: string | undefined;
+          format?: "json" | "plain" | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: {
+          n?: string | undefined;
+          format?: "json" | "plain" | undefined;
+        };
+      };
+      output: "no logs";
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/gateway/sql": {
+    $get: {
+      input: {
+        query: {
+          query?: string | undefined;
+          preset?: string | undefined;
+          channel?: string | undefined;
+          limit?: string | undefined;
+        };
+      };
       output: string;
       outputFormat: "text";
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     };
   };
 } & {
-  "/profiles/:profile/as-default": {
-    $post: {
+  "/gateway/listeners": {
+    $get: {
       input: {
-        param: {
-          profile: string;
-        };
-      } & {
         query: Record<string, never>;
       };
       output: string;
@@ -4273,27 +3613,30 @@ declare const app: _$hono_hono_base0.HonoBase<Env, {
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     } | {
       input: {
-        param: {
-          profile: string;
-        };
-      } & {
         query: Record<string, never>;
       };
-      output: `profile "${string}" is now the default`;
+      output: "funnel gateway: no running listeners";
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: Record<string, never>;
+      };
+      output: `funnel gateway: running listeners
+${string}`;
       outputFormat: "text";
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     };
   };
 } & {
-  "/profiles/:profile/run": {
+  "/debug": {
     $get: {
       input: {
-        param: {
-          profile: string;
-        };
-      } & {
         query: {
-          [x: string]: string | string[];
+          channel?: string | undefined;
+          all?: "" | "true" | "false" | undefined;
+          json?: "" | "true" | "false" | undefined;
+          limit?: string | undefined;
         };
       };
       output: string;
@@ -4301,101 +3644,246 @@ declare const app: _$hono_hono_base0.HonoBase<Env, {
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     } | {
       input: {
-        param: {
-          profile: string;
-        };
-      } & {
         query: {
-          [x: string]: string | string[];
+          channel?: string | undefined;
+          all?: "" | "true" | "false" | undefined;
+          json?: "" | "true" | "false" | undefined;
+          limit?: string | undefined;
         };
       };
-      output: Promise<never>;
+      output: {
+        error: string;
+        nextAction: string;
+      };
       outputFormat: "json";
-      status: _$hono_utils_http_status0.StatusCode;
-    };
-  };
-} & {
-  "/profiles/:profile": {
-    $get: {
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
       input: {
-        param: {
-          profile: string;
-        };
-      } & {
         query: {
-          [x: string]: string | string[];
-        };
+          channel?: string | undefined;
+          all?: "" | "true" | "false" | undefined;
+          json?: "" | "true" | "false" | undefined;
+          limit?: string | undefined;
+        };
+      };
+      output: {
+        summary: {
+          total: number;
+          ok: number;
+          warn: number;
+          error: number;
+          criticalChannels: string[];
+          warnChannels: string[];
+          suggestedActions: string[];
+        };
+        channels: {
+          channel: string;
+          gateway: {
+            running: boolean;
+            pid: number | null;
+            port: number | null;
+            uptimeMs: number | null;
+          };
+          listeners: {
+            name: string;
+            type: string;
+            alive: boolean;
+            events: number;
+            errors: number;
+            lastEventAt: string | null;
+          }[];
+          claudeClients: number;
+          channelId: string;
+          recentEvents: {
+            seq: number | null;
+            ts: number | null;
+            type: string;
+            outcome: string;
+            eventId: string | null;
+            payload: string | null;
+            payloadParsed: {
+              [x: string]: _$hono_utils_types0.JSONValue;
+            } | null;
+            preview: string | null;
+          }[];
+          connectionErrors: {
+            seq: number | null;
+            ts: number | null;
+            type: string;
+            status: string;
+            detail: string | null;
+          }[];
+          diagnosis: {
+            status: "ok" | "warn" | "error";
+            message: string;
+            nextActions: string[];
+            rootCause: string | null;
+          };
+        }[];
       };
-      output: string;
-      outputFormat: "text";
+      outputFormat: "json";
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     } | {
       input: {
-        param: {
-          profile: string;
-        };
-      } & {
         query: {
-          [x: string]: string | string[];
+          channel?: string | undefined;
+          all?: "" | "true" | "false" | undefined;
+          json?: "" | "true" | "false" | undefined;
+          limit?: string | undefined;
         };
       };
-      output: Promise<never>;
+      output: {
+        error: string;
+        availableChannels: string[];
+      };
       outputFormat: "json";
-      status: _$hono_utils_http_status0.StatusCode;
-    };
-  };
-} & {
-  "/gateway": {
-    $get: {
-      input: {};
-      output: string;
-      outputFormat: "text";
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     } | {
-      input: {};
-      output: "funnel gateway: running (pid null) — health check failed" | `funnel gateway: running (pid ${number}) \u2014 health check failed`;
-      outputFormat: "text";
+      input: {
+        query: {
+          channel?: string | undefined;
+          all?: "" | "true" | "false" | undefined;
+          json?: "" | "true" | "false" | undefined;
+          limit?: string | undefined;
+        };
+      };
+      output: {
+        error: string;
+        channels: string[];
+        hint: string;
+      };
+      outputFormat: "json";
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     } | {
-      input: {};
-      output: `funnel gateway: running (pid null)
-  port: ${number}
-  clients: ${string}` | `funnel gateway: running (pid ${number})
-  port: ${number}
-  clients: ${string}`;
-      outputFormat: "text";
+      input: {
+        query: {
+          channel?: string | undefined;
+          all?: "" | "true" | "false" | undefined;
+          json?: "" | "true" | "false" | undefined;
+          limit?: string | undefined;
+        };
+      };
+      output: {
+        channel: string;
+        gateway: {
+          running: boolean;
+          pid: number | null;
+          port: number | null;
+          uptimeMs: number | null;
+        };
+        listeners: {
+          name: string;
+          type: string;
+          alive: boolean;
+          events: number;
+          errors: number;
+          lastEventAt: string | null;
+        }[];
+        claudeClients: number;
+        channelId: string;
+        recentEvents: {
+          seq: number | null;
+          ts: number | null;
+          type: string;
+          outcome: string;
+          eventId: string | null;
+          payload: string | null;
+          payloadParsed: {
+            [x: string]: _$hono_utils_types0.JSONValue;
+          } | null;
+          preview: string | null;
+        }[];
+        connectionErrors: {
+          seq: number | null;
+          ts: number | null;
+          type: string;
+          status: string;
+          detail: string | null;
+        }[];
+        diagnosis: {
+          status: "ok" | "warn" | "error";
+          message: string;
+          nextActions: string[];
+          rootCause: string | null;
+        };
+      };
+      outputFormat: "json";
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     };
   };
 } & {
-  "/gateway/status": {
+  "/debug/events": {
     $get: {
-      input: {};
+      input: {
+        query: {
+          channel?: string | undefined;
+          limit?: string | undefined;
+          json?: "" | "true" | "false" | undefined;
+        };
+      };
       output: string;
       outputFormat: "text";
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     } | {
-      input: {};
-      output: "funnel gateway: running (pid null) — health check failed" | `funnel gateway: running (pid ${number}) \u2014 health check failed`;
-      outputFormat: "text";
+      input: {
+        query: {
+          channel?: string | undefined;
+          limit?: string | undefined;
+          json?: "" | "true" | "false" | undefined;
+        };
+      };
+      output: {
+        error: string;
+        availableChannels: string[];
+      };
+      outputFormat: "json";
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     } | {
-      input: {};
-      output: `funnel gateway: running (pid null)
-  port: ${number}
-  clients: ${string}` | `funnel gateway: running (pid ${number})
-  port: ${number}
-  clients: ${string}`;
-      outputFormat: "text";
+      input: {
+        query: {
+          channel?: string | undefined;
+          limit?: string | undefined;
+          json?: "" | "true" | "false" | undefined;
+        };
+      };
+      output: {
+        error: string;
+        channels: string[];
+      };
+      outputFormat: "json";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: {
+          channel?: string | undefined;
+          limit?: string | undefined;
+          json?: "" | "true" | "false" | undefined;
+        };
+      };
+      output: {
+        seq: number | null;
+        ts: number | null;
+        type: string;
+        outcome: string;
+        eventId: string | null;
+        payload: string | null;
+        payloadParsed: {
+          [x: string]: _$hono_utils_types0.JSONValue;
+        } | null;
+        preview: string | null;
+      }[];
+      outputFormat: "json";
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     };
   };
 } & {
-  "/gateway/start": {
+  "/debug/dropped": {
     $get: {
       input: {
         query: {
-          "no-caffeine"?: string | undefined;
+          channel?: string | undefined;
+          limit?: string | undefined;
+          json?: "" | "true" | "false" | undefined;
         };
       };
       output: string;
@@ -4404,140 +3892,244 @@ declare const app: _$hono_hono_base0.HonoBase<Env, {
     } | {
       input: {
         query: {
-          "no-caffeine"?: string | undefined;
+          channel?: string | undefined;
+          limit?: string | undefined;
+          json?: "" | "true" | "false" | undefined;
+        };
+      };
+      output: {
+        seq: number | null;
+        ts: number | null;
+        type: string;
+        outcome: string;
+        eventId: string | null;
+        payload: string | null;
+        payloadParsed: {
+          [x: string]: _$hono_utils_types0.JSONValue;
+        } | null;
+        preview: string | null;
+      }[];
+      outputFormat: "json";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: {
+          channel?: string | undefined;
+          limit?: string | undefined;
+          json?: "" | "true" | "false" | undefined;
         };
       };
-      output: "funnel gateway: already running (pid null)" | `funnel gateway: already running (pid ${number})`;
-      outputFormat: "text";
+      output: {
+        error: string;
+        availableChannels: string[];
+      };
+      outputFormat: "json";
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     } | {
       input: {
         query: {
-          "no-caffeine"?: string | undefined;
+          channel?: string | undefined;
+          limit?: string | undefined;
+          json?: "" | "true" | "false" | undefined;
         };
       };
-      output: "funnel gateway: started";
-      outputFormat: "text";
+      output: {
+        error: string;
+        channels: string[];
+      };
+      outputFormat: "json";
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     };
   };
 } & {
-  "/gateway/stop": {
+  "/debug/errors": {
     $get: {
       input: {
-        query: Record<string, never>;
+        query: {
+          channel?: string | undefined;
+          limit?: string | undefined;
+          json?: "" | "true" | "false" | undefined;
+        };
       };
       output: string;
       outputFormat: "text";
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     } | {
       input: {
-        query: Record<string, never>;
+        query: {
+          channel?: string | undefined;
+          limit?: string | undefined;
+          json?: "" | "true" | "false" | undefined;
+        };
       };
-      output: "funnel gateway: no running process";
-      outputFormat: "text";
+      output: {
+        error: string;
+        availableChannels: string[];
+      };
+      outputFormat: "json";
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     } | {
       input: {
-        query: Record<string, never>;
+        query: {
+          channel?: string | undefined;
+          limit?: string | undefined;
+          json?: "" | "true" | "false" | undefined;
+        };
       };
-      output: "funnel gateway: stopped";
-      outputFormat: "text";
+      output: {
+        error: string;
+        channels: string[];
+      };
+      outputFormat: "json";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: {
+          channel?: string | undefined;
+          limit?: string | undefined;
+          json?: "" | "true" | "false" | undefined;
+        };
+      };
+      output: {
+        seq: number | null;
+        ts: number | null;
+        type: string;
+        status: string;
+        detail: string | null;
+      }[];
+      outputFormat: "json";
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     };
   };
 } & {
-  "/gateway/restart": {
+  "/debug/replay": {
     $get: {
       input: {
         query: {
-          "no-caffeine"?: string | undefined;
+          channel?: string | undefined;
+          seq?: string | undefined;
+          json?: "" | "true" | "false" | undefined;
         };
       };
       output: string;
       outputFormat: "text";
       status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/gateway/run": {
-    $get: {
+    } | {
       input: {
         query: {
-          "no-caffeine"?: string | undefined;
+          channel?: string | undefined;
+          seq?: string | undefined;
+          json?: "" | "true" | "false" | undefined;
         };
       };
-      output: string;
+      output: `error: ${string}`;
       outputFormat: "text";
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     } | {
       input: {
         query: {
-          "no-caffeine"?: string | undefined;
+          channel?: string | undefined;
+          seq?: string | undefined;
+          json?: "" | "true" | "false" | undefined;
         };
       };
-      output: Promise<never>;
-      outputFormat: "json";
-      status: _$hono_utils_http_status0.StatusCode;
-    };
-  };
-} & {
-  "/gateway/logs": {
-    $get: {
+      output: `channel not found: ${string}`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
       input: {
         query: {
-          n?: string | undefined;
+          channel?: string | undefined;
+          seq?: string | undefined;
+          json?: "" | "true" | "false" | undefined;
         };
       };
-      output: string;
+      output: "no diagnostic store yet (start the gateway first)";
       outputFormat: "text";
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     } | {
       input: {
         query: {
-          n?: string | undefined;
+          channel?: string | undefined;
+          seq?: string | undefined;
+          json?: "" | "true" | "false" | undefined;
         };
       };
-      output: "no logs";
+      output: `multiple channels \u2014 specify one with --channel:
+${string}`;
       outputFormat: "text";
       status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/gateway/sql": {
-    $get: {
+    } | {
       input: {
         query: {
-          query?: string | undefined;
+          channel?: string | undefined;
+          seq?: string | undefined;
+          json?: "" | "true" | "false" | undefined;
         };
       };
-      output: string;
+      output: "no channels configured";
       outputFormat: "text";
       status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/gateway/listeners": {
-    $get: {
+    } | {
       input: {
-        query: Record<string, never>;
+        query: {
+          channel?: string | undefined;
+          seq?: string | undefined;
+          json?: "" | "true" | "false" | undefined;
+        };
       };
-      output: string;
+      output: {
+        error: string;
+      };
+      outputFormat: "json";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: {
+          channel?: string | undefined;
+          seq?: string | undefined;
+          json?: "" | "true" | "false" | undefined;
+        };
+      };
+      output: "no matching event found";
       outputFormat: "text";
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     } | {
       input: {
-        query: Record<string, never>;
+        query: {
+          channel?: string | undefined;
+          seq?: string | undefined;
+          json?: "" | "true" | "false" | undefined;
+        };
       };
-      output: "funnel gateway: no running listeners";
+      output: "event has no payload to replay";
       outputFormat: "text";
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     } | {
       input: {
-        query: Record<string, never>;
+        query: {
+          channel?: string | undefined;
+          seq?: string | undefined;
+          json?: "" | "true" | "false" | undefined;
+        };
       };
-      output: `funnel gateway: running listeners
-${string}`;
+      output: {
+        replayed: true;
+        seq: number | null;
+        offset: number;
+        preview: string | null;
+      };
+      outputFormat: "json";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: {
+          channel?: string | undefined;
+          seq?: string | undefined;
+          json?: "" | "true" | "false" | undefined;
+        };
+      };
+      output: `replayed seq=${number} \u2192 offset=${number}${string}` | `replayed seq=? \u2192 offset=${number}${string}`;
       outputFormat: "text";
       status: _$hono_utils_http_status0.ContentfulStatusCode;
     };
@@ -4565,7 +4157,10 @@ ${string}`;
   "/status": {
     $get: {
       input: {
-        query: Record<string, never>;
+        query: {
+          watch?: "" | "true" | "false" | undefined;
+          interval?: string | undefined;
+        };
       };
       output: string;
       outputFormat: "text";
@@ -4591,5 +4186,6 @@ ${string}`;
     };
   };
 }, "/", "/update">;
+type CliApp = typeof routes;
 //#endregion
-export { AliveStub, AttachOptions, BroadcastEvent, BroadcastSubscriber, CONNECTOR_CONNECTION_STATUSES, ChannelConfig, ChannelConnectorView, ChannelDeliveryMode, ChannelServerOptions, ChannelSpec, ConnectorConfig, ConnectorConnectionEvent, ConnectorConnectionQuery, ConnectorConnectionRecord, ConnectorConnectionStatus, ConnectorDiagnosticLog, ConnectorDiagnosticSqlReader, ConnectorProcessedEvent, ConnectorProcessedQuery, ConnectorProcessedRecord, ConnectorQuery, ConnectorRawEvent, ConnectorRawQuery, ConnectorRawRecord, ConnectorSpec, ConnectorSyncOutcome, ConnectorType, DEFAULT_GATEWAY_PORT, DEFAULT_GATEWAY_TOKEN_PATH, DetachOptions, DiscordConnectorConfig, Env, FUNNEL_DIR, FUNNEL_MCP_ARGS, FUNNEL_MCP_COMMAND, FUNNEL_MCP_NAME, FileStat, Funnel, FunnelBroadcaster, FunnelChannelPublisher, FunnelChannels, FunnelClaude, FunnelClock, FunnelConnectorFactory, FunnelConnectorListener, FunnelEvent, FunnelEventLog, FunnelEventRecord, FunnelFileSystem, FunnelGateway, FunnelGatewayServer, FunnelGatewayToken, FunnelIdGenerator, FunnelListenerSupervisor, FunnelListenersClient, FunnelLocalConfig, FunnelLocalConfigSync, FunnelLocalConfigWriter, FunnelLogger, FunnelMcp, FunnelProcessRunner, FunnelProfiles, FunnelSettingsReader, FunnelSettingsStore, FunnelSlackEventProcessor, FunnelTokenPrompter, type GatewayEmitInput, type GatewayRouteDeps, type Env$1 as GatewayServerEnv, GhConnectorConfig, LOCAL_CONFIG_FILENAME, LaunchOptions, ListListenersResult, ListenerEntry, ListenerOpResult, LocalConfig, LocalConfigSyncResult, LogEntry, MemoryConnectorDiagnosticLog, MemoryFunnelClock, MemoryFunnelEventLog, MemoryFunnelFileSystem, MemoryFunnelIdGenerator, MemoryFunnelLogger, MemoryFunnelProcessRunner, MemoryFunnelTokenPrompter, MemoryProcessCall, MemoryProcessHandler, MemoryProcessResponse, MemoryProcessSyncHandler, MockFunnelSettingsReader, NodeFunnelClock, NodeFunnelFileSystem, NodeFunnelIdGenerator, NodeFunnelLogger, NodeFunnelProcessRunner, NodeFunnelTokenPrompter, NoopFunnelLogger, NotifyFn, OnFunnelError, ProcessListStub, ProcessSnapshot, ProfileConfig, ProfileSpec, PublishRequest, PublishResponse, PublishResult, ReplayableEvent, RunOptions, RunResult, SETTINGS_PATH, SETTINGS_VERSION, ScheduleCatchupPolicy, ScheduleConnectorConfig, ScheduleEntry, ScheduleListenerOptions, Settings, SlackConnectorConfig, SlackListenerOptions, SlackProcessed, SlackProcessedEmit, SlackProcessedSkip, SlackRawEvent, SlackSkipReason, SqliteConnectorDiagnosticLog, SqliteFunnelEventLog, StoredConnectionEvent, StoredProcessedEvent, StoredRawEvent, channelConfigSchema, channelDeliveryModeSchema, channelSpecSchema, app as cliApp, connectorConfigSchema, connectorConnectionEventSchema, connectorProcessedEventSchema, connectorRawEventSchema, connectorSpecSchema, createCliApp, createSettings, discordConnectorSchema, factory, funnelEventSchema, funnelJsonSchema, ghConnectorSchema, localConfigSchema, profileConfigSchema, profileSpecSchema, publishRequestSchema, publishResponseSchema, queryToCliArgs, resolveFunnelDir, resolveFunnelPort, scheduleCatchupPolicySchema, scheduleConnectorSchema, scheduleEntrySchema, settingsSchema, slackConnectorSchema, startChannelServer, toRequest };
+export { AliveStub, AttachOptions, BroadcastEvent, BroadcastSubscriber, CONNECTOR_CONNECTION_STATUSES, ChannelConfig, ChannelConnectorView, ChannelDeliveryMode, ChannelServerOptions, ChannelSpec, type CliApp, ConnectorConfig, ConnectorConnectionEvent, ConnectorConnectionQuery, ConnectorConnectionRecord, ConnectorConnectionStatus, ConnectorDiagnosticLog, ConnectorDiagnosticSqlReader, ConnectorProcessedEvent, ConnectorProcessedQuery, ConnectorProcessedRecord, ConnectorQuery, ConnectorRawEvent, ConnectorRawQuery, ConnectorRawRecord, ConnectorSpec, ConnectorSyncOutcome, ConnectorType, DEFAULT_GATEWAY_PORT, DEFAULT_GATEWAY_TOKEN_PATH, DetachOptions, DiscordConnectorConfig, Env, FUNNEL_DIR, FUNNEL_MCP_ARGS, FUNNEL_MCP_COMMAND, FUNNEL_MCP_NAME, FileStat, Funnel, FunnelBroadcaster, FunnelChannelPublisher, FunnelChannels, FunnelClaude, FunnelClock, FunnelConnectorFactory, FunnelConnectorListener, type FunnelDebugReport, FunnelEvent, FunnelEventLog, FunnelEventRecord, FunnelFileSystem, FunnelGateway, FunnelGatewayServer, FunnelGatewayToken, FunnelIdGenerator, FunnelListenerSupervisor, FunnelListenersClient, FunnelLocalConfig, FunnelLocalConfigSync, FunnelLocalConfigWriter, FunnelLogger, FunnelMcp, FunnelProcessRunner, FunnelProfiles, FunnelSettingsReader, FunnelSettingsStore, FunnelSlackEventProcessor, FunnelTokenPrompter, type GatewayApp, type GatewayEmitInput, type GatewayRouteDeps, type Env$1 as GatewayServerEnv, GhConnectorConfig, LOCAL_CONFIG_FILENAME, LaunchOptions, ListListenersResult, ListenerEntry, ListenerOpResult, LocalConfig, LocalConfigSyncResult, LogEntry, MemoryConnectorDiagnosticLog, MemoryFunnelClock, MemoryFunnelEventLog, MemoryFunnelFileSystem, MemoryFunnelIdGenerator, MemoryFunnelLogger, MemoryFunnelProcessRunner, MemoryFunnelTokenPrompter, MemoryProcessCall, MemoryProcessHandler, MemoryProcessResponse, MemoryProcessSyncHandler, MockFunnelSettingsReader, NodeFunnelClock, NodeFunnelFileSystem, NodeFunnelIdGenerator, NodeFunnelLogger, NodeFunnelProcessRunner, NodeFunnelTokenPrompter, NoopFunnelLogger, NotifyFn, OnFunnelError, ProcessListStub, ProcessSnapshot, ProfileConfig, ProfileSpec, PublishRequest, PublishResponse, PublishResult, ReplayableEvent, RunOptions, RunResult, SETTINGS_PATH, SETTINGS_VERSION, ScheduleCatchupPolicy, ScheduleConnectorConfig, ScheduleEntry, ScheduleListenerOptions, Settings, SlackConnectorConfig, SlackListenerOptions, SlackProcessed, SlackProcessedEmit, SlackProcessedSkip, SlackRawEvent, SlackSkipReason, SqliteConnectorDiagnosticLog, SqliteFunnelEventLog, StoredConnectionEvent, StoredProcessedEvent, StoredRawEvent, channelConfigSchema, channelDeliveryModeSchema, channelSpecSchema, routes as cliRoutes, connectorConfigSchema, connectorConnectionEventSchema, connectorProcessedEventSchema, connectorRawEventSchema, connectorSpecSchema, createSettings, discordConnectorSchema, factory, funnelEventSchema, funnelJsonSchema, ghConnectorSchema, localConfigSchema, profileConfigSchema, profileSpecSchema, publishRequestSchema, publishResponseSchema, queryToCliArgs, resolveFunnelDir, resolveFunnelPort, scheduleCatchupPolicySchema, scheduleConnectorSchema, scheduleEntrySchema, settingsSchema, slackConnectorSchema, startChannelServer, toRequest };