@interactive-inc/claude-funnel 0.59.1 → 0.60.1

package/dist/index-D7mjirUL.d.ts

@@ -1,3602 +0,0 @@
-import { a as Settings } from "./settings-schema-1hh11jnN.js";
-import { n as FunnelClaude, t as FileProcessGuard } from "./file-process-guard-JhFpmHYo.js";
-import { n as FunnelIdGenerator, t as FunnelSettingsReader } from "./settings-reader-DPwqOVUm.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 "./diagnostic-log-Cb3v8P7p.js";
-import { a as RunOptions, i as ProcessSnapshot, n as DetachOptions, o as RunResult, r as FunnelProcessRunner, t as AttachOptions } from "./process-runner-DIm1cy95.js";
-import { n as FunnelFileSystem, t as FileStat } from "./file-system-DxpnnUVb.js";
-import { t as FunnelProfiles } from "./profiles-g2qGVOWv.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-BGPAS9Be.js";
-import { c as FunnelDiagnostics } from "./funnel-diagnostics-K-wON25Y.js";
-import { n as FunnelDocs } from "./funnel-docs-DYBs1-H_.js";
-import { t as FunnelRecovery } from "./funnel-recovery-COExL9MD.js";
-import { r as FunnelDoctor } from "./funnel-doctor-vxO96TCA.js";
-import { a as HttpResponse, i as HttpRequest, r as FunnelHttpClient } from "./discord-connector-schema-CQyfDkLD.js";
-import { hc } from "hono/client";
-import * as _$zod from "zod";
-import { z } from "zod";
-import * as _$hono_factory0 from "hono/factory";
-import { Hono } from "hono";
-import { Server, ServerWebSocket } from "bun";
-import * as _$hono_utils_http_status0 from "hono/utils/http-status";
-import * as _$hono_hono_base0 from "hono/hono-base";
-import * as _$hono_utils_types0 from "hono/utils/types";
-
-//#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$8 = {
-  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$8);
-  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$7 = {
-  channels: ConnectorRegistry;
-  notify: SupervisorNotify;
-  logger?: FunnelLogger; /** Host hook for surfacing listener lifecycle exceptions. Defaults to no-op. */
-  onError?: OnFunnelError;
-  healthCheckIntervalMs?: number;
-  maxBackoffMs?: number;
-  /** Per-listener timeout for `start()`. A listener that hangs beyond this is
-   *  treated as a startup failure — it won't block other listeners or the
-   *  health-check loop. Defaults to 30 seconds. */
-  startTimeoutMs?: 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 startTimeoutMs;
-  private readonly sleep;
-  private readonly now;
-  private healthCheckTimer;
-  private healthCheckInFlight;
-  /** Connectors that failed initial start — retried by the health check. */
-  private readonly pendingRetry;
-  constructor(deps: Deps$7);
-  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;
-  /** Run one health-check pass synchronously. Test-only seam. */
-  runHealthCheckForTest(): Promise<void>;
-  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;
-  /** Funnel home dir this daemon is rooted at. Lets a probe tell whether the
-   *  daemon answering on a shared port belongs to the expected repo/scope. */
-  dir: string;
-  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/event-log/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
-/**
- * Where the gateway's durable replay log lives. The two ways to specify it are
- * mutually exclusive — modeled as a union so you can't pass both (the old shape
- * silently ignored `dbPath` when `eventLog` was also given).
- *
- * - omit both → SQLite at the default path (`<os.tmpdir()>/funnel/events.db`)
- * - `dbPath` → SQLite at a custom path (parent dir created on demand)
- * - `eventLog` → bring your own `FunnelEventLog` (e.g. `MemoryFunnelEventLog`)
- */
-type GatewayEventStore = {
-  dbPath?: string;
-  eventLog?: undefined;
-} | {
-  dbPath?: undefined;
-  eventLog: FunnelEventLog;
-};
-type Deps$6 = GatewayEventStore & {
-  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;
-  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;
-  /**
-   * Permit binding a non-loopback hostname without a token. Off by default:
-   * `start()` throws when `hostname` is reachable off-box and `token` is empty,
-   * because every privileged endpoint would then be open to the network. Set
-   * this only when you've deliberately fronted the gateway with your own auth.
-   */
-  allowInsecureHost?: boolean;
-  /**
-   * 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 allowInsecureHost;
-  private readonly broadcaster;
-  private readonly eventLog;
-  private readonly supervisor;
-  private readonly nowMs;
-  private readonly extraRoutes;
-  private startedAt;
-  private server;
-  constructor(deps: Deps$6);
-  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 killCompetingSlackIfNeeded;
-  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/channel-ws-url.d.ts
-/**
- * Builds the WebSocket URL a client uses to subscribe to a gateway channel.
- *
- * The gateway's `/ws` upgrade handler reads three query params — `channel`
- * (required), `id` (the subscriber id for targeted delivery), and `since`
- * (replay offset). Forgetting `channel=` silently drops the subscription
- * (the broadcaster never matches the client), which has caused outages when
- * callers hand-built the URL with string concatenation. This builder makes
- * `channel` a required field, so the mistake becomes a compile error.
- *
- * `subscriberId` enables targeted delivery: events carrying `meta.target=<id>`
- * reach only this client. Omit it to receive the channel's fanout.
- *
- * Pair with `channelWsProtocols()` to authenticate the upgrade when the
- * gateway requires a token.
- */
-type ChannelWsUrlInput = {
-  /** Base WS endpoint, e.g. `ws://localhost:9743/ws`. Existing query is preserved. */base: string; /** Channel name to subscribe to. Required — the broadcaster filters by it. */
-  channel: string; /** Opaque subscriber id for targeted delivery (`meta.target=<id>`). Omit for fanout. */
-  subscriberId?: string; /** Replay from this event offset (inclusive). Omit to receive only new events. */
-  since?: number;
-};
-declare function channelWsUrl(input: ChannelWsUrlInput): string;
-/**
- * Builds the `Sec-WebSocket-Protocol` values that authenticate a gateway WS
- * upgrade. Browser `WebSocket` cannot set an `Authorization` header, so the
- * gateway also accepts the token as a `funnel.token.<token>` subprotocol.
- * Returns an empty array when no token is given (auth disabled / loopback).
- *
- * Usage: `new WebSocket(channelWsUrl({ base, channel }), channelWsProtocols(token))`
- */
-declare function channelWsProtocols(token?: string | null): string[];
-//#endregion
-//#region lib/gateway/gateway-base-url.d.ts
-/**
- * The HTTP base URL of a gateway daemon on the loopback interface. The daemon
- * always binds 127.0.0.1 for its management API (only the WS `/ws` endpoint is
- * ever exposed off-box), so every in-process HTTP client — publisher, listeners
- * client, MCP channel server — talks to it here. Centralizing the construction
- * keeps the host/port shape in one place instead of re-spelling
- * `http://127.0.0.1:${port}` at each call site.
- */
-declare function gatewayLoopbackUrl(port: number): string;
-//#endregion
-//#region lib/gateway/gateway-token.d.ts
-type Deps$5 = {
-  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$5);
-  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$4 = {
-  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$4);
-  publish(channelName: string, request: PublishRequest): Promise<PublishResult>;
-  private authHeaders;
-}
-//#endregion
-//#region lib/gateway/event-log/sqlite-event-log.d.ts
-type Props$6 = {
-  /** SQLite database file path. Created on first write. ":memory:" for tests. */path: string; /** Override for tests. Defaults to `Date.now`. */
-  now?: () => number; /** Surfaces a failed persist (PK collision, disk-full, locked WAL). Silent if absent. */
-  logger?: FunnelLogger; /** 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;
-  private readonly logger;
-  constructor(props: Props$6);
-  /**
-   * Persist a broadcaster-driven event with its assigned offset. Caller
-   * (the gateway-server) supplies the offset from `broadcaster.broadcast()`
-   * so this store and the broadcaster's in-memory ring stay aligned.
-   */
-  record(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/event-log/memory-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/diagnostic-log/sqlite-diagnostic-log.d.ts
-type Props$5 = {
-  /** 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 `FunnelLogSqliteSink`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$5);
-  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/diagnostic-log/memory-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$3 = {
-  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$3);
-  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$2 = {
-  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$2);
-  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/funnel.d.ts
-type Props$4 = {
-  /** 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;
-};
-/**
- * Options for `Funnel.gatewayServer()`. The event store is a union (`dbPath`
- * xor `eventLog`) so the two storage modes can't be mixed.
- */
-type GatewayServerOptions = GatewayEventStore & {
-  port?: number;
-  hostname?: string;
-  killCompetingSlack?: boolean;
-  token?: string; /** Permit a non-loopback `hostname` without a token. See FunnelGatewayServer. */
-  allowInsecureHost?: boolean;
-  extraRoutes?: Hono<Env$1>;
-};
-/**
- * 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;
-  readonly diagnostics: FunnelDiagnostics;
-  readonly recovery: FunnelRecovery;
-  readonly doctor: FunnelDoctor;
-  readonly docs: FunnelDocs;
-  private readonly fs;
-  private readonly process;
-  private readonly logger;
-  private readonly clock;
-  private readonly onError;
-  constructor(props?: Props$4);
-  /**
-   * Sandboxed Funnel wired with in-memory implementations for every IO boundary.
-   * Touches no real disk, processes, wall-clock time, or UUIDs — safe for tests
-   * and ad-hoc experiments. Override individual fields by passing them in `props`.
-   */
-  static inMemory(props?: Props$4): Funnel;
-  /**
-   * 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?: GatewayServerOptions): FunnelGatewayServer;
-  /**
-   * Create a ProcessGuard scoped to this Funnel's home directory.
-   * Useful for hosts that need to check or manage singleton PID files
-   * independently of FunnelClaude (e.g. checking if a named profile is running).
-   */
-  createProcessGuard(): FileProcessGuard;
-  /**
-   * 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>;
-  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$1 = {
-  path?: string;
-  fs?: FunnelFileSystem;
-  idGenerator?: FunnelIdGenerator;
-};
-declare class FunnelSettingsStore extends FunnelSettingsReader {
-  private readonly path;
-  private readonly fs;
-  private readonly idGenerator;
-  constructor(deps?: Deps$1);
-  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$3 = {
-  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$3);
-  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[];
-  getStartTime(pid: number): string | null;
-  private isAlivePosix;
-  private isAliveWindows;
-  private listProcessesContainingPosix;
-  private getStartTimePosix;
-  private getStartTimeWindows;
-  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[];
-type StartTimeStub = (pid: number) => string | null;
-declare class MemoryFunnelProcessRunner extends FunnelProcessRunner {
-  readonly calls: MemoryProcessCall[];
-  readonly killed: {
-    pid: number;
-    signal: string;
-  }[];
-  private handler;
-  private syncHandler;
-  private aliveStub;
-  private listStub;
-  private startTimeStub;
-  on(handler: MemoryProcessHandler): this;
-  onSync(handler: MemoryProcessSyncHandler): this;
-  onIsAlive(stub: AliveStub): this;
-  onListProcessesContaining(stub: ProcessListStub): this;
-  onGetStartTime(stub: StartTimeStub): 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[];
-  getStartTime(pid: number): string | null;
-}
-//#endregion
-//#region lib/engine/logger/node-logger.d.ts
-type Props$2 = {
-  file?: string;
-  now?: () => Date;
-};
-declare class NodeFunnelLogger extends FunnelLogger {
-  readonly file: string;
-  private readonly now;
-  constructor(props?: Props$2);
-  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$1 = {
-  start?: Date;
-};
-declare class MemoryFunnelClock extends FunnelClock {
-  private current;
-  constructor(props?: Props$1);
-  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 = {
-  prefix?: string;
-};
-declare class MemoryFunnelIdGenerator extends FunnelIdGenerator {
-  private counter;
-  private readonly prefix;
-  constructor(props?: Props);
-  generate(): string;
-}
-//#endregion
-//#region lib/engine/http/node-http-client.d.ts
-declare class NodeFunnelHttpClient extends FunnelHttpClient {
-  constructor();
-  fetch(request: HttpRequest): Promise<HttpResponse>;
-}
-//#endregion
-//#region lib/engine/http/memory-http-client.d.ts
-type MemoryHttpResponse = {
-  status?: number;
-  body?: string;
-};
-type MemoryHttpHandler = (request: HttpRequest) => MemoryHttpResponse | Promise<MemoryHttpResponse>;
-declare class MemoryFunnelHttpClient extends FunnelHttpClient {
-  readonly calls: HttpRequest[];
-  private handler;
-  on(handler: MemoryHttpHandler): this;
-  fetch(request: HttpRequest): Promise<HttpResponse>;
-}
-//#endregion
-//#region lib/gateway/service-routes.d.ts
-type Deps = {
-  diagnostics: FunnelDiagnostics;
-  doctor: FunnelDoctor; /** Bearer token to gate every endpoint. Empty string disables auth (tests only). */
-  token: string;
-};
-/**
- * Mountable Hono app that exposes the service layer (`FunnelDiagnostics` +
- * `FunnelDoctor`) over loopback HTTP. The MCP server, which lives in a
- * different process, calls these endpoints to drive the autonomous
- * troubleshooting loop. The CLI bypasses HTTP and calls the same services
- * directly through the in-process funnel facade, so CLI and MCP share one
- * code path.
- */
-declare const buildServiceRoutes: (deps: Deps) => Hono<Env$1>;
-//#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: _$zod.ZodSafeParseError<{
-        [x: string]: unknown;
-        profile?: string | undefined;
-        channel?: string | undefined;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      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.\n\nsee also:\n  fnl docs claude              full resolution order, side effects, double-launch guard\n  fnl docs mcp                 what the MCP server exposes once Claude is up\n  fnl docs debugging           the diagnose → recover → verify loop\n\nprogrammable: funnel.claude.launch({ profileId | channelId, options, env, resume })";
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/channels": {
-    $get: {
-      input: {};
-      output: string;
-      outputFormat: "text";
-      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)\n\nA channel is a named event stream. After creating it, add connectors\n(Slack, Discord, GitHub, schedule) to feed events into it, then connect\nClaude Code clients to consume them.\n\nexamples:\n  funnel channels add production\n  funnel channels add ci-events --delivery exclusive\n\nsee also: funnel channels, funnel channels <name> connectors add";
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/channels/add/:channel": {
-    $post: {
-      input: {
-        param: {
-          channel: string;
-        };
-      } & {
-        query: {
-          delivery?: "fanout" | "exclusive" | undefined;
-        };
-      };
-      output: _$zod.ZodSafeParseError<{
-        channel: string;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      input: {
-        param: {
-          channel: string;
-        };
-      } & {
-        query: {
-          delivery?: "fanout" | "exclusive" | undefined;
-        };
-      };
-      output: _$zod.ZodSafeParseError<{
-        delivery?: "fanout" | "exclusive" | undefined;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      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 and all its connectors\n\nusage: funnel channels remove <name>\n\nThe channel, its connectors, and their schedules are deleted from the\nconfiguration file. The gateway drops the channel on the next reload.\nNo external resources (Slack apps, Discord bots, etc.) are touched.\n\nexamples:\n  funnel channels remove staging\n\nsee also: funnel channels, funnel channels add";
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/channels/remove/:channel": {
-    $post: {
-      input: {
-        param: {
-          channel: string;
-        };
-      } & {
-        query: Record<string, never>;
-      };
-      output: _$zod.ZodSafeParseError<{
-        channel: string;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      input: {
-        param: {
-          channel: string;
-        };
-      } & {
-        query: Record<string, never>;
-      };
-      output: _$zod.ZodSafeParseError<Record<string, never>>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      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: _$zod.ZodSafeParseError<{
-        channel: string;
-        newName: string;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      input: {
-        param: {
-          channel: string;
-          newName: string;
-        };
-      } & {
-        query: Record<string, never>;
-      };
-      output: _$zod.ZodSafeParseError<Record<string, never>>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      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: _$zod.ZodSafeParseError<{
-        channel: string;
-        newName: string;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      input: {
-        param: {
-          channel: string;
-          newName: string;
-        };
-      } & {
-        query: Record<string, never>;
-      };
-      output: _$zod.ZodSafeParseError<Record<string, never>>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      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>\n\nRenames the channel in the configuration file. Connectors, schedules,\nand delivery mode are preserved. The gateway picks up the new name on\nthe next reload.\n\nexamples:\n  funnel channels rename staging production\n  funnel channels staging rename production\n\nsee also: funnel channels, funnel channels <name>";
-      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: _$zod.ZodSafeParseError<{
-        channel: string;
-        mode: "fanout" | "exclusive";
-      }>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      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: _$zod.ZodSafeParseError<{
-        channel: string;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      input: {
-        param: {
-          channel: string;
-        };
-      } & {
-        query: {
-          [x: string]: string | string[];
-          content: string | string[];
-          connector?: string | undefined;
-        };
-      };
-      output: _$zod.ZodSafeParseError<{
-        [x: string]: unknown;
-        content: string;
-        connector?: string | undefined;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      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: Record<string, never>;
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        param: {
-          channel: string;
-        };
-      } & {
-        query: Record<string, never>;
-      };
-      output: _$zod.ZodSafeParseError<{
-        channel: string;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      input: {
-        param: {
-          channel: string;
-        };
-      } & {
-        query: Record<string, never>;
-      };
-      output: _$zod.ZodSafeParseError<Record<string, never>>;
-      outputFormat: "json";
-      status: 400;
-    };
-  };
-} & {
-  "/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;
-        };
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        param: {
-          channel: string;
-        };
-      };
-      output: _$zod.ZodSafeParseError<{
-        channel: string;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    };
-  };
-} & {
-  "/channels/:channel/connectors": {
-    $get: {
-      input: {
-        param: {
-          channel: string;
-        };
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        param: {
-          channel: string;
-        };
-      };
-      output: _$zod.ZodSafeParseError<{
-        channel: string;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    };
-  };
-} & {
-  "/channels/:channel/connectors/add": {
-    $post: {
-      input: {
-        param: {
-          channel: string;
-        };
-      };
-      output: "funnel channels <channel> connectors add <name> — add a connector to a channel\n\nusage:\n  funnel channels <channel> connectors add <name> --type=slack --bot-token=xoxb-... --app-token=xapp-...\n  funnel channels <channel> connectors add <name> --type=gh [--poll-interval=60]\n  funnel channels <channel> connectors add <name> --type=discord --bot-token=...\n  funnel channels <channel> connectors add <name> --type=schedule\n\nconnector types:\n  slack      Slack Socket Mode (requires bot-token + app-token)\n  gh         GitHub webhook polling\n  discord    Discord bot gateway\n  schedule   cron / one-shot timer (no external service)\n\nToken uniqueness is enforced across all channels — the same bot-token\ncannot appear in two connectors.\n\nexamples:\n  funnel channels prod connectors add main-slack --type=slack --bot-token=xoxb-... --app-token=xapp-...\n  funnel channels ci connectors add gh-events --type=gh --poll-interval=30\n  funnel channels alerts connectors add daily --type=schedule\n\nsee also: funnel channels <channel> connectors, funnel channels <channel> connectors remove";
-      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: _$zod.ZodSafeParseError<{
-        channel: string;
-        connector: string;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      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: _$zod.ZodSafeParseError<{
-        type: "slack";
-        "bot-token": string;
-        "app-token": string;
-      } | {
-        type: "gh";
-        "poll-interval"?: number | undefined;
-      } | {
-        type: "discord";
-        "bot-token": string;
-      } | {
-        type: "schedule";
-      }>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      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>\n\nRemoves the connector from the channel configuration. The gateway drops\nit on the next reload. No external resources (Slack apps, Discord bots,\nGitHub webhooks) are touched.\n\nexamples:\n  funnel channels production connectors remove slack-main\n\nsee also: funnel channels <channel> connectors, funnel channels <channel> connectors add";
-      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: _$zod.ZodSafeParseError<{
-        channel: string;
-        connector: string;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      input: {
-        param: {
-          channel: string;
-          connector: string;
-        };
-      } & {
-        query: Record<string, never>;
-      };
-      output: _$zod.ZodSafeParseError<Record<string, never>>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      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: _$zod.ZodSafeParseError<{
-        channel: string;
-        connector: string;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      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: _$zod.ZodSafeParseError<{
-        [x: string]: unknown;
-        "bot-token"?: string | undefined;
-        "app-token"?: string | undefined;
-        "poll-interval"?: number | undefined;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      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: _$zod.ZodSafeParseError<{
-        channel: string;
-        connector: string;
-        newName: string;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      input: {
-        param: {
-          channel: string;
-          connector: string;
-          newName: string;
-        };
-      } & {
-        query: Record<string, never>;
-      };
-      output: _$zod.ZodSafeParseError<Record<string, never>>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      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: _$zod.ZodSafeParseError<{
-        channel: string;
-        connector: string;
-        newName: string;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      input: {
-        param: {
-          channel: string;
-          connector: string;
-          newName: string;
-        };
-      } & {
-        query: Record<string, never>;
-      };
-      output: _$zod.ZodSafeParseError<Record<string, never>>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      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 <old> <new> — rename a connector\n\nusage: funnel channels <channel> connectors rename <old> <new>\n\nRenames the connector in the configuration file. Tokens, type, and\nschedules are preserved. The gateway picks up the new name on the\nnext reload.\n\nexamples:\n  funnel channels production connectors rename slack-1 slack-main\n\nsee also: funnel channels <channel> connectors";
-      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[];
-          path?: string | undefined;
-        };
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        param: {
-          channel: string;
-          connector: string;
-        };
-      } & {
-        query: {
-          [x: string]: string | string[];
-          method: string | string[];
-          path?: string | undefined;
-        };
-      };
-      output: _$zod.ZodSafeParseError<{
-        channel: string;
-        connector: string;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      input: {
-        param: {
-          channel: string;
-          connector: string;
-        };
-      } & {
-        query: {
-          [x: string]: string | string[];
-          method: string | string[];
-          path?: string | undefined;
-        };
-      };
-      output: _$zod.ZodSafeParseError<{
-        [x: string]: unknown;
-        method: string;
-        path?: string | undefined;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    };
-  };
-} & {
-  "/channels/:channel/connectors/:connector": {
-    $get: {
-      input: {
-        param: {
-          channel: string;
-          connector: string;
-        };
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        param: {
-          channel: string;
-          connector: string;
-        };
-      };
-      output: _$zod.ZodSafeParseError<{
-        channel: string;
-        connector: string;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    };
-  };
-} & {
-  "/channels/:channel/connectors/:connector/schedules": {
-    $get: {
-      input: {
-        param: {
-          channel: string;
-          connector: string;
-        };
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        param: {
-          channel: string;
-          connector: string;
-        };
-      };
-      output: _$zod.ZodSafeParseError<{
-        channel: string;
-        connector: string;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    };
-  };
-} & {
-  "/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;
-          prompt: string;
-          enabled?: "true" | "false" | undefined;
-          "catchup-policy"?: "latest" | "all" | "skip" | undefined;
-        };
-      };
-      output: _$zod.ZodSafeParseError<{
-        channel: string;
-        connector: string;
-        id: string;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      input: {
-        param: {
-          channel: string;
-          connector: string;
-          id: string;
-        };
-      } & {
-        query: {
-          cron: string;
-          prompt: string;
-          enabled?: "true" | "false" | undefined;
-          "catchup-policy"?: "latest" | "all" | "skip" | undefined;
-        };
-      };
-      output: _$zod.ZodSafeParseError<{
-        cron: string;
-        prompt: string;
-        enabled?: "true" | "false" | undefined;
-        "catchup-policy"?: "latest" | "all" | "skip" | undefined;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      input: {
-        param: {
-          channel: string;
-          connector: string;
-          id: string;
-        };
-      } & {
-        query: {
-          cron: string;
-          prompt: string;
-          enabled?: "true" | "false" | 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: _$zod.ZodSafeParseError<{
-        channel: string;
-        connector: string;
-        id: string;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      input: {
-        param: {
-          channel: string;
-          connector: string;
-          id: string;
-        };
-      } & {
-        query: Record<string, never>;
-      };
-      output: _$zod.ZodSafeParseError<Record<string, never>>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      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: {};
-      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: _$zod.ZodSafeParseError<{
-        profile: string;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      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: _$zod.ZodSafeParseError<{
-        path: string;
-        channel: string;
-        agent?: string | undefined;
-        options?: string | undefined;
-        env?: string | undefined;
-        resume?: string | undefined;
-        "no-resume"?: string | undefined;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      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: _$zod.ZodSafeParseError<{
-        profile: string;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      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: _$zod.ZodSafeParseError<{
-        path?: string | undefined;
-        channel?: string | undefined;
-        agent?: string | undefined;
-        options?: string | undefined;
-        env?: string | undefined;
-        resume?: string | undefined;
-        "no-resume"?: string | undefined;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      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: _$zod.ZodSafeParseError<{
-        profile: string;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      input: {
-        param: {
-          profile: string;
-        };
-      } & {
-        query: Record<string, never>;
-      };
-      output: _$zod.ZodSafeParseError<Record<string, never>>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      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: _$zod.ZodSafeParseError<{
-        profile: string;
-        newName: string;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      input: {
-        param: {
-          profile: string;
-          newName: string;
-        };
-      } & {
-        query: Record<string, never>;
-      };
-      output: _$zod.ZodSafeParseError<Record<string, never>>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      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: _$zod.ZodSafeParseError<{
-        profile: string;
-        newName: string;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      input: {
-        param: {
-          profile: string;
-          newName: string;
-        };
-      } & {
-        query: Record<string, never>;
-      };
-      output: _$zod.ZodSafeParseError<Record<string, never>>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      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;
-        };
-      };
-      output: _$zod.ZodSafeParseError<{
-        profile: string;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      input: {
-        param: {
-          profile: string;
-        };
-      };
-      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: _$zod.ZodSafeParseError<{
-        profile: string;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      input: {
-        param: {
-          profile: string;
-        };
-      } & {
-        query: {
-          [x: string]: string | string[];
-        };
-      };
-      output: _$zod.ZodSafeParseError<{
-        [x: string]: unknown;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      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: _$zod.ZodSafeParseError<{
-        profile: string;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      input: {
-        param: {
-          profile: string;
-        };
-      } & {
-        query: {
-          [x: string]: string | string[];
-        };
-      };
-      output: _$zod.ZodSafeParseError<{
-        [x: string]: unknown;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      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: {};
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/gateway/start": {
-    $get: {
-      input: {
-        query: {
-          "no-caffeine"?: string | undefined;
-        };
-      };
-      output: _$zod.ZodSafeParseError<{
-        "no-caffeine"?: string | undefined;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      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: {};
-      output: "funnel gateway: no running process";
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {};
-      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;
-    } | {
-      input: {
-        query: {
-          "no-caffeine"?: string | undefined;
-        };
-      };
-      output: _$zod.ZodSafeParseError<{
-        "no-caffeine"?: string | undefined;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    };
-  };
-} & {
-  "/gateway/run": {
-    $get: {
-      input: {
-        query: {
-          "no-caffeine"?: string | undefined;
-        };
-      };
-      output: Promise<never>;
-      outputFormat: "json";
-      status: _$hono_utils_http_status0.StatusCode;
-    } | {
-      input: {
-        query: {
-          "no-caffeine"?: string | undefined;
-        };
-      };
-      output: _$zod.ZodSafeParseError<{
-        "no-caffeine"?: string | undefined;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    };
-  };
-} & {
-  "/gateway/logs": {
-    $get: {
-      input: {
-        query: {
-          n?: string | undefined;
-          format?: "json" | "plain" | undefined;
-        };
-      };
-      output: _$zod.ZodSafeParseError<{
-        n?: string | undefined;
-        format?: "json" | "plain" | undefined;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    } | {
-      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;
-    } | {
-      input: {
-        query: {
-          query?: string | undefined;
-          preset?: string | undefined;
-          channel?: string | undefined;
-          limit?: string | undefined;
-        };
-      };
-      output: _$zod.ZodSafeParseError<{
-        query?: string | undefined;
-        preset?: string | undefined;
-        channel?: string | undefined;
-        limit?: string | undefined;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    };
-  };
-} & {
-  "/gateway/listeners": {
-    $get: {
-      input: {};
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/debug": {
-    $get: {
-      input: {
-        query: {
-          channel?: string | undefined;
-          all?: "" | "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;
-          limit?: string | undefined;
-        };
-      };
-      output: _$zod.ZodSafeParseError<{
-        channel?: string | undefined;
-        all?: "" | "true" | "false" | undefined;
-        limit?: string | undefined;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    };
-  };
-} & {
-  "/debug/events": {
-    $get: {
-      input: {
-        query: {
-          channel?: string | undefined;
-          limit?: string | undefined;
-        };
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        query: {
-          channel?: string | undefined;
-          limit?: string | undefined;
-        };
-      };
-      output: _$zod.ZodSafeParseError<{
-        channel?: string | undefined;
-        limit?: string | undefined;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    };
-  };
-} & {
-  "/debug/dropped": {
-    $get: {
-      input: {
-        query: {
-          channel?: string | undefined;
-          limit?: string | undefined;
-        };
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        query: {
-          channel?: string | undefined;
-          limit?: string | undefined;
-        };
-      };
-      output: _$zod.ZodSafeParseError<{
-        channel?: string | undefined;
-        limit?: string | undefined;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    };
-  };
-} & {
-  "/debug/errors": {
-    $get: {
-      input: {
-        query: {
-          channel?: string | undefined;
-          limit?: string | undefined;
-        };
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        query: {
-          channel?: string | undefined;
-          limit?: string | undefined;
-        };
-      };
-      output: _$zod.ZodSafeParseError<{
-        channel?: string | undefined;
-        limit?: string | undefined;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    };
-  };
-} & {
-  "/debug/replay": {
-    $get: {
-      input: {
-        query: {
-          channel?: string | undefined;
-          seq?: string | undefined;
-        };
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        query: {
-          channel?: string | undefined;
-          seq?: string | undefined;
-        };
-      };
-      output: _$zod.ZodSafeParseError<{
-        channel?: string | undefined;
-        seq?: string | undefined;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    };
-  };
-} & {
-  "/docs": {
-    $get: {
-      input: {};
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    };
-  };
-} & {
-  "/docs/:topic": {
-    $get: {
-      input: {
-        param: {
-          topic: string;
-        };
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        param: {
-          topic: string;
-        };
-      };
-      output: _$zod.ZodSafeParseError<{
-        topic: string;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    };
-  };
-} & {
-  "/doctor": {
-    $get: {
-      input: {
-        query: {
-          fix?: "" | "true" | "false" | undefined;
-          aggressive?: "" | "true" | "false" | undefined;
-        };
-      };
-      output: string;
-      outputFormat: "text";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
-    } | {
-      input: {
-        query: {
-          fix?: "" | "true" | "false" | undefined;
-          aggressive?: "" | "true" | "false" | undefined;
-        };
-      };
-      output: _$zod.ZodSafeParseError<{
-        fix?: "" | "true" | "false" | undefined;
-        aggressive?: "" | "true" | "false" | undefined;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    };
-  };
-} & {
-  "/schema": {
-    $get: {
-      input: {};
-      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;
-    } | {
-      input: {
-        query: {
-          watch?: "" | "true" | "false" | undefined;
-          interval?: string | undefined;
-        };
-      };
-      output: _$zod.ZodSafeParseError<{
-        watch?: "" | "true" | "false" | undefined;
-        interval?: string | undefined;
-      }>;
-      outputFormat: "json";
-      status: 400;
-    };
-  };
-} & {
-  "/update": {
-    $get: {
-      input: {};
-      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;
-        funnelDir: string;
-        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;
-        funnelDir: string;
-        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 { PublishResponse as $, MemoryFunnelFileSystem as A, Funnel as B, MemoryProcessCall as C, OnFunnelError as Ct, ProcessListStub as D, MemoryProcessSyncHandler as E, FUNNEL_DIR as F, ListenerOpResult as G, FunnelListenersClient as H, FunnelSettingsStore as I, SqliteConnectorDiagnosticLog as J, FunnelGateway as K, SETTINGS_PATH as L, MockFunnelSettingsReader as M, createSettings as N, StartTimeStub as O, DEFAULT_GATEWAY_PORT as P, PublishRequest as Q, resolveFunnelDir as R, MemoryFunnelProcessRunner as S, ReplayableEvent as St, MemoryProcessResponse as T, ListListenersResult as U, GatewayServerOptions as V, ListenerEntry as W, SqliteFunnelEventLog as X, MemoryFunnelEventLog as Y, FunnelChannelPublisher as Z, NoopFunnelLogger as _, GatewayRouteDeps as _t, toRequest as a, gatewayLoopbackUrl as at, NodeFunnelLogger as b, BroadcastSubscriber as bt, buildServiceRoutes as c, channelWsUrl as ct, MemoryHttpResponse as d, FunnelEvent as dt, PublishResult as et, NodeFunnelHttpClient as f, FunnelEventLog as ft, NodeFunnelClock as g, GatewayEmitInput as gt, MemoryFunnelClock as h, Env$1 as ht, queryToCliArgs as i, FunnelGatewayToken as it, NodeFunnelFileSystem as j, NodeFunnelProcessRunner as k, MemoryFunnelHttpClient as l, FunnelGatewayServer as lt, NodeFunnelIdGenerator as m, funnelEventSchema as mt, CliApp as n, publishResponseSchema as nt, Env as o, ChannelWsUrlInput as ot, MemoryFunnelIdGenerator as p, FunnelEventRecord as pt, MemoryConnectorDiagnosticLog as q, routes as r, DEFAULT_GATEWAY_TOKEN_PATH as rt, factory as s, channelWsProtocols as st, GatewayApp as t, publishRequestSchema as tt, MemoryHttpHandler as u, GatewayEventStore as ut, LogEntry as v, FunnelListenerSupervisor as vt, MemoryProcessHandler as w, AliveStub as x, FunnelBroadcaster as xt, MemoryFunnelLogger as y, BroadcastEvent as yt, resolveFunnelPort as z };