@interactive-inc/claude-funnel 0.41.0 → 0.50.0

package/dist/index-ChomoTZ5.d.ts

@@ -0,0 +1,3404 @@
+import { n as FunnelIdGenerator, s as Settings, t as FunnelSettingsReader } from "./settings-reader-BSU6JyvM.js";
+import { t as FunnelClaude } from "./claude-CB1WkV77.js";
+import { S as FunnelLogger, b as FunnelConnectorListener, c as ConnectorProcessedQuery, f as ConnectorRawQuery, g as StoredRawEvent, h as StoredProcessedEvent, i as ConnectorConnectionRecord, l as ConnectorProcessedRecord, m as StoredConnectionEvent, o as ConnectorDiagnosticLog, p as ConnectorRawRecord, r as ConnectorConnectionQuery } from "./connector-diagnostic-log-yTOojKUR.js";
+import { a as RunOptions, i as ProcessSnapshot, n as DetachOptions, o as RunResult, r as FunnelProcessRunner, t as AttachOptions } from "./process-runner-DfniuWVU.js";
+import { n as FunnelFileSystem, t as FileStat } from "./file-system-BeOKXjlV.js";
+import { t as FunnelProfiles } from "./profiles-f0mNmEyP.js";
+import { a as ChannelConnectorView, d as ConnectorConfig, i as FunnelTokenPrompter, l as ScheduleListenerOptions, m as FunnelLocalConfig, n as FunnelLocalConfigSync, o as FunnelChannels, s as FunnelClock, u as SlackListenerOptions } from "./local-config-sync-BdsrDZOu.js";
+import { hc } from "hono/client";
+import { z } from "zod";
+import * as _$hono_factory0 from "hono/factory";
+import { Server, ServerWebSocket } from "bun";
+import { Hono } from "hono";
+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/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/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. */
+  connectors: string[]; /** Routing mode resolved from channel config at upgrade time. Defaults to fanout. */
+  delivery?: "fanout" | "exclusive";
+  /**
+   * Opaque per-client id declared at upgrade time (`?id=<subscriberId>`). When an
+   * event carries `meta.target`, only the client whose `subscriberId` equals it
+   * receives the event among that channel's regular subscribers. Targeted delivery
+   * is how a publisher addresses one specific instance (e.g. a single agent
+   * session) without every subscriber having to receive and discard it.
+   */
+  subscriberId?: string;
+};
+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.
+ */
+type ReplaySource = {
+  loadSince(since: number): ReplayableEvent[];
+};
+type Deps$7 = {
+  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;
+};
+/**
+ * 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 FunnelBroadcaster {
+  private readonly clients;
+  private readonly subscribers;
+  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$7);
+  getMetrics(): BroadcasterMetrics;
+  /**
+   * Returns events with offset > since, filtered by the connector subscription
+   * rules of `data`. Used at WS upgrade time when the client passes `?since=<offset>`.
+   *
+   * 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.
+   *
+   * Result is sorted ascending by offset and de-duplicated against the in-memory buffer.
+   */
+  replaySince(since: number, data: ClientData): ReplayableEvent[];
+  private matchesClient;
+  /**
+   * Returns the list of WS clients that should receive `event`. For each per-channel group:
+   *   - fanout → every matching client receives
+   *   - exclusive → exactly one client receives, picked round-robin per channel
+   *
+   * `meta.target` narrows the recipient set via `matchesClient`: only the subscriber
+   * whose `subscriberId` equals `target` receives a targeted event.
+   */
+  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/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$6 = {
+  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$6);
+  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;
+  };
+};
+//#endregion
+//#region lib/gateway/factory.d.ts
+type Env$1 = {
+  Variables: {
+    deps: GatewayRouteDeps;
+  };
+};
+//#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-server.d.ts
+type Deps$5 = {
+  channels: FunnelChannels;
+  port?: number; /** Bind address for `Bun.serve`. Defaults to `127.0.0.1` (loopback only). Set to `0.0.0.0` to expose on the network. */
+  hostname?: string; /** SQLite event store file path. Parent directory is created on demand. Defaults to `<os.tmpdir()>/funnel/events.db`. Ignored when `eventLog` is supplied. */
+  dbPath?: string; /** Durable replay log. Defaults to a `SqliteFunnelEventLog` at `dbPath`. Inject a `MemoryFunnelEventLog` (or any `FunnelEventLog`) to swap or disable persistence. */
+  eventLog?: FunnelEventLog;
+  process?: FunnelProcessRunner;
+  clock?: FunnelClock;
+  logger?: FunnelLogger; /** Host hook for surfacing internal exceptions (broadcaster / supervisor). Defaults to no-op. */
+  onError?: OnFunnelError;
+  selfPid?: number; /** Funnel home dir, used to scope kill-competing to daemons rooted at the same dir. Defaults to FUNNEL_DIR. */
+  dir?: string;
+  killCompetingSlack?: boolean; /** Bearer token required for `/listeners*`, `/status`, and `/ws`. Empty string disables auth (tests only). */
+  token?: string;
+  /**
+   * Additional hono app mounted before the built-in gateway routes.
+   * Use to embed host-specific endpoints (e.g. an MCP route, custom `/api/*`).
+   * Host routes are mounted first; built-in `/listeners`, `/status`,
+   * `/channels`, `/health` are mounted after and take precedence on conflict.
+   */
+  extraRoutes?: Hono<Env$1>;
+};
+type WsData = {
+  /** Stable channel id (uuid) the client subscribed to. */channel: string; /** Resolved channel name (for log readability). null for unknown. */
+  channelName: string | null; /** Connector names belonging to that channel. */
+  connectors: string[]; /** Routing mode for this channel; resolved at upgrade time from settings. */
+  delivery: "fanout" | "exclusive"; /** Opaque client id from `?id=<subscriberId>`; lets publishers target this client via `meta.target`. */
+  subscriberId?: string; /** Replay any events with offset strictly greater than this on open, then resume the live stream. */
+  since?: number;
+};
+/**
+ * In-process gateway: runs `Bun.serve` (HTTP + WebSocket /ws), boots connector
+ * listeners through `FunnelListenerSupervisor`, fans events out via
+ * `FunnelBroadcaster`, and persists them via a `FunnelEventLog` (SQLite by default).
+ * System events (gateway lifecycle, connect/disconnect) flow to `FunnelLogger`
+ * instead — keeping the SQLite seq space exclusive to broadcaster traffic so
+ * the broadcaster's offset counter and `getMaxSeq()` stay aligned without
+ * per-event coordination. Exposes `/listeners` HTTP for runtime
+ * start/stop/restart of individual connectors.
+ */
+declare class FunnelGatewayServer {
+  private readonly channels;
+  private readonly port;
+  private readonly hostname;
+  private readonly dbPath;
+  private readonly process?;
+  private readonly logger;
+  private readonly onError;
+  private readonly selfPid;
+  private readonly dir;
+  private readonly killCompetingSlack;
+  private readonly token;
+  private readonly broadcaster;
+  private readonly eventLog;
+  private readonly supervisor;
+  private readonly nowMs;
+  private readonly extraRoutes;
+  private startedAt;
+  private server;
+  constructor(deps: Deps$5);
+  start(): Promise<Server<WsData>>;
+  stop(): Promise<void>;
+  getStatus(): {
+    clients: number;
+    channels: {
+      channel: string;
+      connectors: string[];
+    }[];
+  };
+  getBroadcaster(): FunnelBroadcaster;
+  getSupervisor(): FunnelListenerSupervisor;
+  getEventLog(): FunnelEventLog;
+  /**
+   * Register an in-process observer for every broadcast event. Fires after
+   * the event is fanned out to WS clients and recorded in the event log.
+   * Returns an unsubscribe function. Only meaningful in-process (embedded
+   * hosts / `new Funnel(...)` running their own gateway-server); a separate
+   * daemon process cannot be observed this way — use a WS client for that.
+   */
+  onEvent(handler: BroadcastSubscriber): () => void;
+  private handleFetch;
+  private handleWsOpen;
+  private handleWsClose;
+  private logServerStarted;
+  private buildApp;
+  /**
+   * Reads the bearer token from the WebSocket upgrade request. Accepts:
+   *   - `Sec-WebSocket-Protocol: funnel.token.<value>` (preferred — header, never logged in URLs)
+   *   - `Authorization: Bearer <value>` (also header-based)
+   * Returns true on a constant-time match against the daemon token.
+   */
+  private tokenMatchesUpgrade;
+  private resolveChannel;
+  private bootListeners;
+  /**
+   * Broadcast `content` to subscribers of `channel`, persisting the event in
+   * the SQLite store and stamping `meta.channel{,Id}` / `meta.connector{,Id}`
+   * when they resolve. Used by both the connector-listener path (via the
+   * supervisor's `notify` callback) and the public `/channels/:channel/publish`
+   * route. Returns the assigned event offset.
+   */
+  emit(input: {
+    channel: string;
+    connector?: string;
+    content: string;
+    meta?: Record<string, string>;
+  }): {
+    offset: number;
+  };
+  private lookupChannelId;
+  private lookupConnectorId;
+}
+//#endregion
+//#region lib/gateway/gateway-token.d.ts
+type Deps$4 = {
+  fs?: FunnelFileSystem;
+  dir?: string;
+  generate?: () => string;
+};
+/**
+ * Reads / generates the gateway daemon token used to authenticate
+ * `/listeners*`, `/status`, and `/ws` connections.
+ *
+ * Token file: `<dir>/gateway.token` (default `~/.funnel/gateway.token`),
+ * written with mode 0600. Clients on the same machine as the daemon read
+ * the file directly; the token never leaves the user's home directory.
+ */
+declare class FunnelGatewayToken {
+  private readonly fs;
+  private readonly path;
+  private readonly generate;
+  constructor(deps?: Deps$4);
+  read(): string | null;
+  /**
+   * Returns the existing token or, if missing, generates one and writes it with mode 0600.
+   *
+   * NOTE: not atomic — two concurrent `ensure()` calls (e.g., `fnl gateway start` racing
+   * itself before the PID lock is acquired) could each generate independent tokens. The
+   * gateway PID file makes this practically a non-issue; if you need stronger guarantees,
+   * take a file lock around this call externally.
+   */
+  ensure(): string;
+  getPath(): string;
+}
+declare const DEFAULT_GATEWAY_TOKEN_PATH: string;
+//#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>;
+  target: 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$3 = {
+  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$3);
+  publish(channelName: string, request: PublishRequest): Promise<PublishResult>;
+  private authHeaders;
+}
+//#endregion
+//#region lib/gateway/sqlite-funnel-event-log.d.ts
+type Props$7 = {
+  /** 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$7);
+  /**
+   * 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$6 = {
+  /** 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$6);
+  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/gateway.d.ts
+type Deps$2 = {
+  process?: FunnelProcessRunner;
+  fs?: FunnelFileSystem;
+  clock?: FunnelClock;
+  dir?: string;
+  tmpDir?: string;
+  port?: number;
+  sleep?: (ms: number) => Promise<void>;
+};
+/**
+ * Manages the gateway daemon as a separate process via PID file.
+ * Use `start()` to spawn `bun daemon.ts` in the background and `stop()` to
+ * terminate it. For an in-process gateway, use `Funnel.gatewayServer` instead.
+ */
+declare class FunnelGateway {
+  private readonly process;
+  private readonly fs;
+  private readonly clock;
+  private readonly dir;
+  private readonly pidFile;
+  private readonly gatewayLog;
+  private readonly tmpDir;
+  private readonly port;
+  private readonly sleep;
+  constructor(deps?: Deps$2);
+  isRunning(): boolean;
+  getStatus(): {
+    running: boolean;
+    pid: number | null;
+    port: number;
+  };
+  start(options?: {
+    caffeinate?: boolean;
+  }): Promise<boolean>;
+  buildStartCommand(gatewayScript: string, options?: {
+    caffeinate?: boolean;
+  }): string[];
+  stop(): Promise<boolean>;
+  restart(options?: {
+    onlyIfRunning?: boolean;
+    caffeinate?: boolean;
+  }): Promise<{
+    ok: boolean;
+    wasRunning: boolean;
+    stopped: boolean;
+    started: boolean;
+  }>;
+  getGatewayLog(): string;
+  getPort(): number;
+  private readPid;
+  private removePid;
+  private isProcessAlive;
+}
+//#endregion
+//#region lib/gateway/listeners-client.d.ts
+type Deps$1 = {
+  port: number;
+  isDaemonRunning: () => boolean; /** Returns the daemon's gateway token, or null if unavailable. Sent as `Authorization: Bearer`. */
+  getToken?: () => string | null;
+};
+declare const listenerEntrySchema: z.ZodObject<{
+  channelName: z.ZodString;
+  channelId: z.ZodString;
+  name: z.ZodString;
+  type: z.ZodString;
+  alive: z.ZodBoolean;
+}, z.core.$strip>;
+type ListenerEntry = z.infer<typeof listenerEntrySchema>;
+type ListenerOpResult = {
+  state: "ok";
+} | {
+  state: "offline";
+} | {
+  state: "error";
+  reason: string;
+};
+type ListListenersResult = {
+  state: "ok";
+  listeners: ListenerEntry[];
+} | {
+  state: "offline";
+} | {
+  state: "error";
+  reason: string;
+};
+/**
+ * HTTP client for listener operations on a running gateway daemon.
+ *
+ * Returns `{ state: "offline" }` when the daemon isn't running so callers
+ * (CLI hot-reload paths) can treat that as a no-op without parsing strings.
+ * Pair this with `FunnelGateway` (process control) for the full picture.
+ */
+declare class FunnelListenersClient {
+  private readonly port;
+  private readonly isDaemonRunning;
+  private readonly getToken;
+  constructor(deps: Deps$1);
+  list(): Promise<ListListenersResult>;
+  start(channelName: string, connectorName: string): Promise<ListenerOpResult>;
+  stop(channelName: string, connectorName: string): Promise<ListenerOpResult>;
+  restart(channelName: string, connectorName: string): Promise<ListenerOpResult>;
+  private path;
+  private authHeaders;
+  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$5 = {
+  /** Settings persistence (channels with nested connectors / profiles). Defaults to a FunnelSettingsStore rooted at `dir`. */store?: FunnelSettingsReader; /** Filesystem boundary. Replace with MemoryFunnelFileSystem to sandbox all disk I/O. */
+  fs?: FunnelFileSystem; /** Process runner used by gateway / claude / gh listener. Replace with MemoryFunnelProcessRunner for tests. */
+  process?: FunnelProcessRunner; /** Logger flowed into every facet. Replace with MemoryFunnelLogger or NoopFunnelLogger to silence/inspect. */
+  logger?: FunnelLogger; /** Clock used by schedule listener, gh poll watermarks, and gateway timeouts. */
+  clock?: FunnelClock; /** ID generator for channel and connector ids. Use MemoryFunnelIdGenerator for deterministic tests. */
+  idGenerator?: FunnelIdGenerator; /** Funnel home directory (settings.json + per-channel/per-connector dirs). Defaults to ~/.funnel. */
+  dir?: string; /** Temp / runtime directory (gateway logs and PID adjacent files). Defaults to `<os.tmpdir()>/funnel`. */
+  tmpDir?: string;
+  /**
+   * Host integration hooks for Slack listeners — `onAppCreated` for attaching
+   * Bolt `app.action` handlers, `preprocessEvent` for transforming/dropping
+   * raw Slack events before the built-in processor sees them.
+   */
+  slackListenerOptions?: SlackListenerOptions;
+  /**
+   * Host integration hooks for Schedule listeners — `onFired` is invoked after
+   * each successful fire, useful for dropping one-shot entries.
+   */
+  scheduleListenerOptions?: ScheduleListenerOptions;
+  /**
+   * Diagnostic log of inbound connector traffic (raw events before filtering
+   * and the processor's verdict after). Threaded into listeners that record
+   * it. Only the gateway daemon injects a `SqliteConnectorDiagnosticLog`; everywhere
+   * else this stays absent and recording is a no-op.
+   */
+  diagnosticLog?: ConnectorDiagnosticLog;
+  /**
+   * Called when Funnel catches an exception that would otherwise be silently
+   * swallowed (subscriber throw, listener start/stop failure, etc.). Pass
+   * `Sentry.captureException` from the host to surface these. Defaults to no-op.
+   */
+  onError?: OnFunnelError;
+  /**
+   * Gateway daemon port. Passed directly to FunnelGateway so hosts can override
+   * the default (9742) without setting FUNNEL_PORT in the environment.
+   */
+  port?: number;
+  /**
+   * Token prompter used by FunnelLocalConfigSync when funnel.json omits a token.
+   * Defaults to a TTY-only stdin prompter. Inject MemoryFunnelTokenPrompter in tests.
+   */
+  tokenPrompter?: FunnelTokenPrompter;
+};
+/**
+ * Facade that wires every funnel facet together and exposes the public surface.
+ *
+ * All side-effecting boundaries (filesystem, process, logger, clock, id, paths)
+ * are injected via Props — passing memory implementations gives a fully sandboxed
+ * Funnel that touches no real disk, processes, or wall-clock time.
+ *
+ * Fully immutable: all fields are resolved in the constructor and frozen.
+ * No lazy initialisation — every dependency is wired at construction time.
+ *
+ * @example
+ * ```ts
+ * const funnel = new Funnel({})
+ * const channel = funnel.channels.add({ name: "inbox" })
+ * funnel.channels.addConnector("inbox", { type: "slack", name: "ops", botToken, appToken })
+ * await funnel.gatewayServer({ port: 9742 }).start()
+ * ```
+ */
+declare class Funnel {
+  readonly paths: {
+    dir: string;
+    tmpDir: string;
+    settings: string;
+  };
+  readonly channels: FunnelChannels;
+  readonly gateway: FunnelGateway;
+  readonly gatewayToken: FunnelGatewayToken;
+  readonly publisher: FunnelChannelPublisher;
+  readonly listeners: FunnelListenersClient;
+  readonly claude: FunnelClaude;
+  readonly profiles: FunnelProfiles;
+  readonly localConfig: FunnelLocalConfig;
+  readonly localConfigSync: FunnelLocalConfigSync;
+  private readonly fs;
+  private readonly process;
+  private readonly logger;
+  private readonly clock;
+  private readonly onError;
+  constructor(props?: Props$5);
+  /**
+   * Sandboxed Funnel wired with in-memory implementations for every IO boundary.
+   * Touches no real disk, processes, wall-clock time, or UUIDs — safe for tests
+   * and ad-hoc experiments. Override individual fields by passing them in `props`.
+   */
+  static inMemory(props?: Props$5): Funnel;
+  /**
+   * In-process gateway server. Unlike `gateway.start()` (which spawns a daemon),
+   * this returns a class that runs `Bun.serve` + listeners inside the current process —
+   * useful for tests, embedding, or custom hosts.
+   */
+  gatewayServer(options?: {
+    port?: number;
+    hostname?: string;
+    dbPath?: string;
+    killCompetingSlack?: boolean;
+    token?: string;
+    eventLog?: FunnelEventLog;
+    extraRoutes?: Hono<Env$1>;
+  }): FunnelGatewayServer;
+  /**
+   * Run the gateway daemon in the foreground (tied to this terminal).
+   * For background daemon management, use `funnel.gateway.start()` instead.
+   */
+  runGatewayForeground(options?: {
+    caffeinate?: boolean;
+  }): Promise<number>;
+  debug(channelName?: string): Promise<FunnelDebugReport>;
+  gatewayClient(): ReturnType<typeof hc<GatewayApp>>;
+}
+//#endregion
+//#region lib/engine/settings/settings-store.d.ts
+/**
+ * Resolves the funnel home dir. Defaults to `~/.funnel`, overridable via
+ * `FUNNEL_DIR` so a funnel.json-scoped launch can point everything (settings,
+ * gateway pid/token, claude pids) at a repo-local `<repo>/.funnel` and never
+ * touch the global home. Read at call time, not module load, so a daemon
+ * spawned with the env set resolves the override.
+ */
+declare function resolveFunnelDir(): string;
+declare const DEFAULT_GATEWAY_PORT = 9742;
+/**
+ * Resolves the gateway port. Defaults to 9742 — the port a programmatically
+ * hosted gateway (`new Funnel().gatewayServer()`) uses. The `funnel` CLI entry
+ * sets `FUNNEL_PORT` to a distinct default so a CLI launch never collides with
+ * an embedding app's gateway on 9742. Read at call time so a daemon spawned
+ * with the env set resolves the override.
+ */
+declare function resolveFunnelPort(): number;
+declare const FUNNEL_DIR: string;
+declare const SETTINGS_PATH: string;
+type Deps = {
+  path?: string;
+  fs?: FunnelFileSystem;
+  idGenerator?: FunnelIdGenerator;
+};
+declare class FunnelSettingsStore extends FunnelSettingsReader {
+  private readonly path;
+  private readonly fs;
+  private readonly idGenerator;
+  constructor(deps?: Deps);
+  read(): Settings;
+  private looksLikeLegacy;
+  /**
+   * Non-destructive migration for profiles written before `id` existed. Mints a
+   * uuid for each profile lacking one and returns whether anything was minted, so
+   * `read` can persist it immediately — a profile id must be STABLE across reads,
+   * otherwise `setSessionId` (a second read) sees a different id and can't match
+   * the one the launch used. Mutates `parsed` in place (freshly JSON-parsed).
+   */
+  private backfillProfileIds;
+  write(settings: Settings): void;
+}
+//#endregion
+//#region lib/engine/settings/mock-settings-reader.d.ts
+declare const createSettings: (partial?: Partial<Settings>) => Settings;
+declare class MockFunnelSettingsReader extends FunnelSettingsReader {
+  private state;
+  constructor(initial?: Partial<Settings>);
+  read(): Settings;
+  write(settings: Settings): void;
+}
+//#endregion
+//#region lib/engine/fs/node-file-system.d.ts
+declare class NodeFunnelFileSystem extends FunnelFileSystem {
+  constructor();
+  existsSync(path: string): boolean;
+  readFileSync(path: string): string;
+  writeFileSync(path: string, data: string): void;
+  writeSecretFileSync(path: string, data: string): void;
+  appendFileSync(path: string, data: string): void;
+  unlink(path: string): void;
+  mkdirSync(path: string, options?: {
+    recursive?: boolean;
+  }): void;
+  readdirSync(path: string): string[];
+  statSync(path: string): FileStat;
+}
+//#endregion
+//#region lib/engine/fs/memory-file-system.d.ts
+type Props$4 = {
+  dirs?: string[];
+  files?: Record<string, string>;
+  mtimes?: Record<string, number>;
+  modes?: Record<string, number>;
+  now?: () => number;
+};
+declare class MemoryFunnelFileSystem extends FunnelFileSystem {
+  private readonly dirs;
+  private readonly files;
+  private readonly mtimes;
+  private readonly modes;
+  private readonly now;
+  constructor(props?: Props$4);
+  existsSync(path: string): boolean;
+  readFileSync(path: string): string;
+  writeFileSync(path: string, data: string): void;
+  writeSecretFileSync(path: string, data: string): void;
+  appendFileSync(path: string, data: string): void;
+  unlink(path: string): void;
+  mkdirSync(path: string, options?: {
+    recursive?: boolean;
+  }): void;
+  readdirSync(path: string): string[];
+  statSync(path: string): FileStat;
+  setMtime(path: string, mtimeMs: number): void;
+  setMode(path: string, mode: number): void;
+  private touch;
+}
+//#endregion
+//#region lib/engine/process/node-process-runner.d.ts
+declare class NodeFunnelProcessRunner extends FunnelProcessRunner {
+  constructor();
+  runSync(command: string[]): RunResult;
+  run(command: string[], options?: RunOptions): Promise<RunResult>;
+  attach(command: string[], options?: AttachOptions): Promise<number>;
+  detach(command: string[], options?: DetachOptions): void;
+  kill(pid: number, signal?: string): void;
+  isAlive(pid: number): boolean;
+  listProcessesContaining(marker: string): ProcessSnapshot[];
+  private isAlivePosix;
+  private isAliveWindows;
+  private listProcessesContainingPosix;
+  private listProcessesContainingWindows;
+}
+//#endregion
+//#region lib/engine/process/memory-process-runner.d.ts
+type MemoryProcessResponse = {
+  exitCode?: number;
+  stdout?: string;
+  stderr?: string;
+};
+type MemoryProcessHandler = (command: string[]) => MemoryProcessResponse | Promise<MemoryProcessResponse>;
+type MemoryProcessSyncHandler = (command: string[]) => MemoryProcessResponse;
+type MemoryProcessCall = {
+  kind: "run";
+  command: string[];
+  options: RunOptions;
+} | {
+  kind: "runSync";
+  command: string[];
+} | {
+  kind: "attach";
+  command: string[];
+  options: AttachOptions;
+} | {
+  kind: "detach";
+  command: string[];
+  options: DetachOptions;
+} | {
+  kind: "kill";
+  command: string[];
+};
+type AliveStub = (pid: number) => boolean;
+type ProcessListStub = (marker: string) => ProcessSnapshot[];
+declare class MemoryFunnelProcessRunner extends FunnelProcessRunner {
+  readonly calls: MemoryProcessCall[];
+  readonly killed: {
+    pid: number;
+    signal: string;
+  }[];
+  private handler;
+  private syncHandler;
+  private aliveStub;
+  private listStub;
+  on(handler: MemoryProcessHandler): this;
+  onSync(handler: MemoryProcessSyncHandler): this;
+  onIsAlive(stub: AliveStub): this;
+  onListProcessesContaining(stub: ProcessListStub): this;
+  run(command: string[], options?: RunOptions): Promise<RunResult>;
+  runSync(command: string[]): RunResult;
+  attach(command: string[], options?: AttachOptions): Promise<number>;
+  detach(command: string[], options?: DetachOptions): void;
+  kill(pid: number, signal?: string): void;
+  isAlive(pid: number): boolean;
+  listProcessesContaining(marker: string): ProcessSnapshot[];
+}
+//#endregion
+//#region lib/engine/logger/node-logger.d.ts
+type Props$3 = {
+  file?: string;
+  now?: () => Date;
+};
+declare class NodeFunnelLogger extends FunnelLogger {
+  readonly file: string;
+  private readonly now;
+  constructor(props?: Props$3);
+  info(message: string, meta?: Record<string, unknown>): void;
+  warn(message: string, meta?: Record<string, unknown>): void;
+  error(message: string, meta?: Record<string, unknown>): void;
+  private write;
+}
+//#endregion
+//#region lib/engine/logger/memory-logger.d.ts
+type LogEntry = {
+  level: "info" | "warn" | "error";
+  message: string;
+  meta?: Record<string, unknown>;
+};
+declare class MemoryFunnelLogger extends FunnelLogger {
+  readonly file: null;
+  readonly entries: LogEntry[];
+  info(message: string, meta?: Record<string, unknown>): void;
+  warn(message: string, meta?: Record<string, unknown>): void;
+  error(message: string, meta?: Record<string, unknown>): void;
+  clear(): void;
+}
+//#endregion
+//#region lib/engine/logger/noop-logger.d.ts
+declare class NoopFunnelLogger extends FunnelLogger {
+  readonly file: null;
+  info(): void;
+  warn(): void;
+  error(): void;
+}
+//#endregion
+//#region lib/engine/time/node-clock.d.ts
+declare class NodeFunnelClock extends FunnelClock {
+  now(): Date;
+}
+//#endregion
+//#region lib/engine/time/memory-clock.d.ts
+type Props$2 = {
+  start?: Date;
+};
+declare class MemoryFunnelClock extends FunnelClock {
+  private current;
+  constructor(props?: Props$2);
+  now(): Date;
+  set(date: Date): void;
+  advance(ms: number): void;
+}
+//#endregion
+//#region lib/engine/id/node-id-generator.d.ts
+declare class NodeFunnelIdGenerator extends FunnelIdGenerator {
+  generate(): string;
+}
+//#endregion
+//#region lib/engine/id/memory-id-generator.d.ts
+type Props$1 = {
+  prefix?: string;
+};
+declare class MemoryFunnelIdGenerator extends FunnelIdGenerator {
+  private counter;
+  private readonly prefix;
+  constructor(props?: Props$1);
+  generate(): string;
+}
+//#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;
+    claude: FunnelClaude;
+    profiles: FunnelProfiles;
+    localConfig: FunnelLocalConfig;
+    localConfigSync: FunnelLocalConfigSync;
+  };
+};
+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: {
+        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: {
+          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: "gh" | "discord" | "schedule" | "slack";
+        }[];
+      }[];
+      outputFormat: "json";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/add": {
+    $post: {
+      input: {};
+      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;
+    };
+  };
+} & {
+  "/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: "funnel channels remove — remove a channel\n\nusage: funnel channels remove <name>";
+      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: "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;
+    };
+  };
+} & {
+  "/channels/:channel/rename": {
+    $post: {
+      input: {
+        param: {
+          channel: 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;
+    };
+  };
+} & {
+  "/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: "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;
+    };
+  };
+} & {
+  "/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/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: {
+      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: "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;
+    };
+  };
+} & {
+  "/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: "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;
+    };
+  };
+} & {
+  "/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: "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;
+    };
+  };
+} & {
+  "/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: "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;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/:connector/rename": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+        } & {
+          connector: 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;
+    };
+  };
+} & {
+  "/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: "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;
+    };
+  };
+} & {
+  "/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: "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;
+    };
+  };
+} & {
+  "/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: "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;
+    };
+  };
+} & {
+  "/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: "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;
+    };
+  };
+} & {
+  "/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: "funnel profiles remove — remove a profile\n\nusage: funnel profiles remove <name>";
+      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: "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/rename": {
+    $post: {
+      input: {
+        param: {
+          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;
+    };
+  };
+} & {
+  "/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;
+    };
+  };
+} & {
+  "/debug": {
+    $get: {
+      input: {
+        query: {
+          channel?: string | undefined;
+          all?: "" | "true" | "false" | undefined;
+          json?: "" | "true" | "false" | undefined;
+          limit?: string | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: {
+          channel?: string | undefined;
+          all?: "" | "true" | "false" | undefined;
+          json?: "" | "true" | "false" | undefined;
+          limit?: string | undefined;
+        };
+      };
+      output: {
+        error: string;
+        nextAction: string;
+      };
+      outputFormat: "json";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: {
+          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;
+          };
+        }[];
+      };
+      outputFormat: "json";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: {
+          channel?: string | undefined;
+          all?: "" | "true" | "false" | undefined;
+          json?: "" | "true" | "false" | undefined;
+          limit?: string | undefined;
+        };
+      };
+      output: {
+        error: string;
+        availableChannels: string[];
+      };
+      outputFormat: "json";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      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: {
+        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;
+    };
+  };
+} & {
+  "/debug/events": {
+    $get: {
+      input: {
+        query: {
+          channel?: string | undefined;
+          limit?: string | undefined;
+          json?: "" | "true" | "false" | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      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: {
+        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;
+    };
+  };
+} & {
+  "/debug/dropped": {
+    $get: {
+      input: {
+        query: {
+          channel?: string | undefined;
+          limit?: string | undefined;
+          json?: "" | "true" | "false" | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      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;
+    } | {
+      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: {
+        query: {
+          channel?: string | undefined;
+          limit?: string | undefined;
+          json?: "" | "true" | "false" | undefined;
+        };
+      };
+      output: {
+        error: string;
+        channels: string[];
+      };
+      outputFormat: "json";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/debug/errors": {
+    $get: {
+      input: {
+        query: {
+          channel?: string | undefined;
+          limit?: string | undefined;
+          json?: "" | "true" | "false" | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      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: {
+        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;
+        status: string;
+        detail: string | null;
+      }[];
+      outputFormat: "json";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/debug/replay": {
+    $get: {
+      input: {
+        query: {
+          channel?: string | undefined;
+          seq?: string | undefined;
+          json?: "" | "true" | "false" | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: {
+          channel?: string | undefined;
+          seq?: string | undefined;
+          json?: "" | "true" | "false" | undefined;
+        };
+      };
+      output: `error: ${string}`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: {
+          channel?: string | undefined;
+          seq?: string | undefined;
+          json?: "" | "true" | "false" | undefined;
+        };
+      };
+      output: `channel not found: ${string}`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: {
+          channel?: string | undefined;
+          seq?: string | undefined;
+          json?: "" | "true" | "false" | undefined;
+        };
+      };
+      output: "no diagnostic store yet (start the gateway first)";
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: {
+          channel?: string | undefined;
+          seq?: string | undefined;
+          json?: "" | "true" | "false" | undefined;
+        };
+      };
+      output: `multiple channels \u2014 specify one with --channel:
+${string}`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: {
+          channel?: string | undefined;
+          seq?: string | undefined;
+          json?: "" | "true" | "false" | undefined;
+        };
+      };
+      output: "no channels configured";
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: {
+          channel?: string | undefined;
+          seq?: string | undefined;
+          json?: "" | "true" | "false" | undefined;
+        };
+      };
+      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: {
+          channel?: string | undefined;
+          seq?: string | undefined;
+          json?: "" | "true" | "false" | undefined;
+        };
+      };
+      output: "event has no payload to replay";
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: {
+          channel?: string | undefined;
+          seq?: string | undefined;
+          json?: "" | "true" | "false" | undefined;
+        };
+      };
+      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;
+    };
+  };
+} & {
+  "/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: {
+          watch?: "" | "true" | "false" | undefined;
+          interval?: string | undefined;
+        };
+      };
+      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;
+    };
+  };
+}, "/", "/update">;
+type CliApp = typeof routes;
+//#endregion
+//#region lib/gateway/routes/index.d.ts
+/**
+ * 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`.
+ */
+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;
+          target?: 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;
+          target?: 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;
+          target?: string | undefined;
+        };
+      };
+      output: {
+        ok: true;
+        offset: number;
+      };
+      outputFormat: "json";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+}, "/", "/channels/:channel/publish">;
+//#endregion
+export { FunnelGatewayToken as $, FUNNEL_DIR as A, ListenerOpResult as B, ProcessListStub as C, MockFunnelSettingsReader as D, NodeFunnelFileSystem as E, Funnel as F, SqliteFunnelEventLog as G, MemoryConnectorDiagnosticLog as H, FunnelDebugReport as I, PublishResponse as J, FunnelChannelPublisher as K, FunnelListenersClient as L, SETTINGS_PATH as M, resolveFunnelDir as N, createSettings as O, resolveFunnelPort as P, DEFAULT_GATEWAY_TOKEN_PATH as Q, ListListenersResult as R, MemoryProcessSyncHandler as S, MemoryFunnelFileSystem as T, SqliteConnectorDiagnosticLog as U, FunnelGateway as V, MemoryFunnelEventLog as W, publishRequestSchema as X, PublishResult as Y, publishResponseSchema as Z, AliveStub as _, toRequest as a, Env$1 as at, MemoryProcessHandler as b, ConnectorDiagnosticSqlReader as c, FunnelListenerSupervisor as ct, MemoryFunnelClock as d, FunnelBroadcaster as dt, FunnelGatewayServer as et, NodeFunnelClock as f, ReplayableEvent as ft, NodeFunnelLogger as g, MemoryFunnelLogger as h, queryToCliArgs as i, funnelEventSchema as it, FunnelSettingsStore as j, DEFAULT_GATEWAY_PORT as k, MemoryFunnelIdGenerator as l, BroadcastEvent as lt, LogEntry as m, CliApp as n, FunnelEventLog as nt, Env as o, GatewayEmitInput as ot, NoopFunnelLogger as p, OnFunnelError as pt, PublishRequest as q, routes as r, FunnelEventRecord as rt, factory as s, GatewayRouteDeps as st, GatewayApp as t, FunnelEvent as tt, NodeFunnelIdGenerator as u, BroadcastSubscriber as ut, MemoryFunnelProcessRunner as v, NodeFunnelProcessRunner as w, MemoryProcessResponse as x, MemoryProcessCall as y, ListenerEntry as z };