@interactive-inc/claude-funnel 0.49.0 → 0.51.0

package/dist/local-config-sync-BdsrDZOu.d.ts

@@ -0,0 +1,381 @@
+import { i as ChannelDeliveryMode, n as FunnelIdGenerator, r as ChannelConfig, t as FunnelSettingsReader } from "./settings-reader-BSU6JyvM.js";
+import { S as FunnelLogger, b as FunnelConnectorListener, o as ConnectorDiagnosticLog } from "./connector-diagnostic-log-yTOojKUR.js";
+import { r as FunnelProcessRunner } from "./process-runner-DfniuWVU.js";
+import { n as FunnelFileSystem } from "./file-system-BeOKXjlV.js";
+import { n as FunnelConnectorAdapter, t as CallInput } from "./connector-adapter-DKgsVuMH.js";
+import { a as ScheduleEntry, n as ScheduleOnFired } from "./schedule-listener-CUyUFFR1.js";
+import { n as SlackOnAppCreated, r as SlackPreprocessEvent } from "./slack-listener-Bv5xI9gC.js";
+import { z } from "zod";
+
+//#region lib/engine/local-config/local-config-schema.d.ts
+declare const connectorSpecSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  type: z.ZodLiteral<"slack">;
+  name: z.ZodString;
+  minify: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"discord">;
+  name: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"gh">;
+  name: z.ZodString;
+  pollInterval: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"schedule">;
+  name: z.ZodString;
+}, z.core.$strip>], "type">;
+type ConnectorSpec = z.infer<typeof connectorSpecSchema>;
+declare const channelSpecSchema: z.ZodObject<{
+  name: z.ZodString;
+  connectors: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"slack">;
+    name: z.ZodString;
+    minify: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"discord">;
+    name: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"gh">;
+    name: z.ZodString;
+    pollInterval: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"schedule">;
+    name: z.ZodString;
+  }, z.core.$strip>], "type">>>;
+}, z.core.$strip>;
+type ChannelSpec = z.infer<typeof channelSpecSchema>;
+declare const profileSpecSchema: z.ZodObject<{
+  name: z.ZodString;
+  channel: z.ZodString;
+  options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  resume: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type ProfileSpec = z.infer<typeof profileSpecSchema>;
+declare const localConfigSchema: z.ZodObject<{
+  $schema: z.ZodOptional<z.ZodString>;
+  id: z.ZodOptional<z.ZodString>;
+  channels: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    connectors: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      type: z.ZodLiteral<"slack">;
+      name: z.ZodString;
+      minify: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"discord">;
+      name: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"gh">;
+      name: z.ZodString;
+      pollInterval: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"schedule">;
+      name: z.ZodString;
+    }, z.core.$strip>], "type">>>;
+  }, z.core.$strip>>;
+  profiles: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    channel: z.ZodString;
+    options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    resume: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strip>>>;
+}, z.core.$strip>;
+type LocalConfig = z.infer<typeof localConfigSchema>;
+declare const LOCAL_CONFIG_FILENAME = "funnel.json";
+//#endregion
+//#region lib/engine/local-config/local-config.d.ts
+type Deps$3 = {
+  fs: FunnelFileSystem;
+};
+/**
+ * Reads `funnel.json` from a directory. Returns `null` when the file is
+ * absent so callers can fall through to other resolution paths (default
+ * profile, help). Throws on present-but-invalid files so misconfiguration
+ * surfaces loudly instead of silently launching the wrong channel.
+ */
+declare class FunnelLocalConfig {
+  private readonly fs;
+  constructor(deps: Deps$3);
+  read(cwd: string): LocalConfig | null;
+  private assertProfilesValid;
+}
+//#endregion
+//#region lib/connectors/connector-config-schema.d.ts
+declare const connectorConfigSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  type: z.ZodLiteral<"slack">;
+  botToken: z.ZodOptional<z.ZodString>;
+  appToken: z.ZodOptional<z.ZodString>;
+  botTokenEnv: z.ZodOptional<z.ZodString>;
+  appTokenEnv: z.ZodOptional<z.ZodString>;
+  minify: z.ZodDefault<z.ZodBoolean>;
+  createdAt: z.ZodOptional<z.ZodString>;
+  updatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  type: z.ZodLiteral<"gh">;
+  pollInterval: z.ZodOptional<z.ZodNumber>;
+  createdAt: z.ZodOptional<z.ZodString>;
+  updatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  type: z.ZodLiteral<"discord">;
+  botToken: z.ZodOptional<z.ZodString>;
+  botTokenEnv: z.ZodOptional<z.ZodString>;
+  createdAt: z.ZodOptional<z.ZodString>;
+  updatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  type: z.ZodLiteral<"schedule">;
+  entries: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    cron: z.ZodString;
+    prompt: z.ZodString;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    catchupPolicy: z.ZodDefault<z.ZodEnum<{
+      latest: "latest";
+      all: "all";
+      skip: "skip";
+    }>>;
+  }, z.core.$strip>>>;
+  createdAt: z.ZodOptional<z.ZodString>;
+  updatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "type">;
+type ConnectorConfig = z.infer<typeof connectorConfigSchema>;
+type ConnectorType = ConnectorConfig["type"];
+//#endregion
+//#region lib/connectors/connector-factory.d.ts
+type SlackListenerOptions = {
+  onAppCreated?: SlackOnAppCreated;
+  preprocessEvent?: SlackPreprocessEvent;
+};
+type ScheduleListenerOptions = {
+  onFired?: ScheduleOnFired;
+};
+type Deps$2 = {
+  fs?: FunnelFileSystem;
+  process?: FunnelProcessRunner;
+  logger?: FunnelLogger;
+  dir?: string; /** Diagnostic log of inbound connector traffic. Threaded into listeners that record raw/processed events. No-op when absent. */
+  diagnosticLog?: ConnectorDiagnosticLog; /** Per-listener hooks for the slack connector type. Threaded into every Slack listener built by this factory. */
+  slackListenerOptions?: SlackListenerOptions; /** Per-listener hooks for the schedule connector type. Threaded into every Schedule listener built by this factory. */
+  scheduleListenerOptions?: ScheduleListenerOptions;
+};
+/**
+ * Pure factory for per-type listeners and adapters. The factory has no CRUD
+ * responsibility — connector configs live inside settings.json under their
+ * channel, and FunnelChannels passes them in by value.
+ *
+ * `dir` is the funnel home (defaults to ~/.funnel); per-connector state files
+ * land at `<dir>/channels/<channel-id>/connectors/<connector-id>/state.json`.
+ *
+ * Host integrations can supply per-type listener hooks via
+ * `slackListenerOptions` / `scheduleListenerOptions` — e.g. to attach a
+ * Bolt `app.action` handler or to drop one-shot schedule entries on fire.
+ */
+declare class FunnelConnectorFactory {
+  private readonly fs;
+  private readonly process;
+  private readonly logger;
+  private readonly diagnosticLog;
+  private readonly dir;
+  private readonly slackListenerOptions;
+  private readonly scheduleListenerOptions;
+  constructor(deps?: Deps$2);
+  createListener(channelId: string, config: ConnectorConfig): FunnelConnectorListener;
+  createAdapter(config: ConnectorConfig): FunnelConnectorAdapter | null;
+  connectorDir(channelId: string, connectorId: string): string;
+  channelDir(channelId: string): string;
+}
+//#endregion
+//#region lib/engine/profiles/profile-channel-checker.d.ts
+/**
+ * Read-side dependency that lets FunnelChannels ask whether a profile
+ * references a given channel id, without depending on FunnelProfiles directly.
+ */
+type ProfileChannelChecker = {
+  hasChannelRef(channelId: string): boolean;
+};
+//#endregion
+//#region lib/engine/time/clock.d.ts
+/**
+ * Time boundary. Default NodeFunnelClock returns `new Date()`; MemoryFunnelClock
+ * is settable and `advance(ms)`-able for deterministic schedule / timeout tests.
+ */
+declare abstract class FunnelClock {
+  abstract now(): Date;
+  millis(): number;
+  iso(): string;
+}
+//#endregion
+//#region lib/engine/channels/channels.d.ts
+type Deps$1 = {
+  store: FunnelSettingsReader;
+  factory: FunnelConnectorFactory;
+  profileChecker?: ProfileChannelChecker;
+  clock?: FunnelClock;
+  idGenerator?: FunnelIdGenerator;
+};
+type ChannelConnectorView = ConnectorConfig & {
+  channelId: string;
+  channelName: string;
+};
+type AddConnectorInput = {
+  type: "slack";
+  name: string;
+  botToken?: string;
+  appToken?: string;
+  botTokenEnv?: string;
+  appTokenEnv?: string;
+  minify?: boolean;
+} | {
+  type: "gh";
+  name: string;
+  pollInterval?: number;
+} | {
+  type: "discord";
+  name: string;
+  botToken?: string;
+  botTokenEnv?: string;
+} | {
+  type: "schedule";
+  name: string;
+  entries?: ScheduleEntry[];
+};
+/**
+ * Channels own their connectors. Each channel has a stable id (UUID); the
+ * `name` is the human-facing label used by the CLI. Connectors live nested
+ * inside `channel.connectors[]`, so add/remove/rename are channel-scoped — no
+ * global connector namespace exists. Token uniqueness is enforced across all
+ * channels at add/update time so the same Slack/Discord credentials cannot
+ * be registered twice.
+ */
+declare class FunnelChannels {
+  private readonly store;
+  private readonly factory;
+  private readonly profileChecker;
+  private readonly clock;
+  private readonly idGenerator;
+  constructor(deps: Deps$1);
+  list(): ChannelConfig[];
+  get(name: string): ChannelConfig | null;
+  getById(id: string): ChannelConfig | null;
+  add(input: {
+    name: string;
+    delivery?: ChannelDeliveryMode;
+  }): ChannelConfig;
+  setDelivery(name: string, delivery: ChannelDeliveryMode): void;
+  remove(name: string): void;
+  rename(oldName: string, newName: string): void;
+  listConnectors(channelName: string): ConnectorConfig[];
+  getConnector(channelName: string, connectorName: string): ConnectorConfig | null;
+  listAllConnectors(): ChannelConnectorView[];
+  addConnector(channelName: string, input: AddConnectorInput): ConnectorConfig;
+  private fromInput;
+  removeConnector(channelName: string, connectorName: string): void;
+  renameConnector(channelName: string, oldName: string, newName: string): void;
+  updateSlackConnector(channelName: string, connectorName: string, fields: {
+    botToken?: string;
+    appToken?: string;
+    botTokenEnv?: string;
+    appTokenEnv?: string;
+  }): void;
+  updateGhConnector(channelName: string, connectorName: string, fields: {
+    pollInterval?: number;
+  }): void;
+  updateDiscordConnector(channelName: string, connectorName: string, fields: {
+    botToken?: string;
+    botTokenEnv?: string;
+  }): void;
+  listScheduleEntries(channelName: string, connectorName: string): ScheduleEntry[];
+  addScheduleEntry(channelName: string, connectorName: string, entry: Pick<ScheduleEntry, "cron" | "prompt"> & Partial<Pick<ScheduleEntry, "id" | "enabled" | "catchupPolicy">>): ScheduleEntry;
+  removeScheduleEntry(channelName: string, connectorName: string, id: string): void;
+  call(channelName: string, connectorName: string, input: CallInput): Promise<unknown>;
+  createListener(channelName: string, connectorName: string): {
+    config: ConnectorConfig;
+    channelId: string;
+    listener: FunnelConnectorListener;
+  } | null;
+  createAllListeners(): {
+    config: ConnectorConfig;
+    channelId: string;
+    channelName: string;
+    listener: FunnelConnectorListener;
+  }[];
+  private requireChannel;
+  private replaceConnector;
+  private assertNoTokenCollision;
+}
+//#endregion
+//#region lib/engine/token-prompter/token-prompter.d.ts
+/**
+ * Asks the user for a secret value on stdin. Used as a last resort when a
+ * funnel.json token field is absent and not present in `~/.funnel`. The Node
+ * implementation refuses to prompt when stdin is not a TTY so non-interactive
+ * launches (CI, agent spawning agent, daemons) fail fast instead of hanging.
+ */
+declare abstract class FunnelTokenPrompter {
+  abstract promptSecret(label: string): Promise<string>;
+}
+//#endregion
+//#region lib/engine/local-config/local-config-sync.d.ts
+type Deps = {
+  channels: FunnelChannels;
+  prompter: FunnelTokenPrompter;
+};
+type ConnectorSyncOutcome = {
+  name: string;
+  changed: boolean;
+};
+type LocalConfigSyncResult = {
+  touched: ConnectorSyncOutcome[];
+  removed: string[];
+};
+/**
+ * Reconciles a single funnel.json channel spec with `~/.funnel/settings.json`.
+ * The spec is the source of truth for the channel it declares:
+ *
+ *   - missing channel → created
+ *   - declared connector matched by name → tokens reconciled
+ *   - declared connector matched by token in the same channel under a
+ *     different name → renamed in place (then tokens reconciled)
+ *   - declared connector with no match → added
+ *   - any connector left in the channel that the spec did not touch → removed
+ *
+ * Removal only fires when the channel spec has a `connectors` field. An
+ * absent field means "do not manage connectors from here" and leaves
+ * everything in `~/.funnel` alone. Other channels in funnel.json (not
+ * passed to this call) are untouched.
+ *
+ * Returns the per-connector change set so callers (e.g. the claude launcher)
+ * can drive listener hot-reload on the gateway after settings are written.
+ */
+declare class FunnelLocalConfigSync {
+  private readonly channels;
+  private readonly prompter;
+  constructor(deps: Deps);
+  ensure(channel: ChannelSpec): Promise<LocalConfigSyncResult>;
+  private ensureConnector;
+  private ensureSlack;
+  private ensureDiscord;
+  private ensureGh;
+  private ensureSchedule;
+  private findExistingSlack;
+  private findExistingDiscord;
+  private removeExtras;
+  /**
+   * Decides how a single token slot is stored in settings.json. funnel.json
+   * never carries tokens, so the only sources are a value already in
+   * settings.json (carried over verbatim, whichever form it was — literal or an
+   * `env`-var reference set via the CLI) or, on first sync, a TTY prompt for a
+   * literal (throws when stdin is not a TTY). Either way the secret lands in the
+   * repo-scoped settings, never in the repo itself.
+   */
+  private resolveSlot;
+}
+//#endregion
+export { profileSpecSchema as C, localConfigSchema as S, LOCAL_CONFIG_FILENAME as _, ChannelConnectorView as a, channelSpecSchema as b, FunnelConnectorFactory as c, ConnectorConfig as d, ConnectorType as f, ConnectorSpec as g, ChannelSpec as h, FunnelTokenPrompter as i, ScheduleListenerOptions as l, FunnelLocalConfig as m, FunnelLocalConfigSync as n, FunnelChannels as o, connectorConfigSchema as p, LocalConfigSyncResult as r, FunnelClock as s, ConnectorSyncOutcome as t, SlackListenerOptions as u, LocalConfig as v, connectorSpecSchema as x, ProfileSpec as y };

package/dist/local-config.d.ts

@@ -0,0 +1,3 @@
+import { C as profileSpecSchema, S as localConfigSchema, _ as LOCAL_CONFIG_FILENAME, b as channelSpecSchema, g as ConnectorSpec, h as ChannelSpec, i as FunnelTokenPrompter, m as FunnelLocalConfig, n as FunnelLocalConfigSync, r as LocalConfigSyncResult, t as ConnectorSyncOutcome, v as LocalConfig, x as connectorSpecSchema, y as ProfileSpec } from "./local-config-sync-BdsrDZOu.js";
+import { i as funnelJsonSchema, n as NodeFunnelTokenPrompter, r as FunnelLocalConfigWriter, t as MemoryFunnelTokenPrompter } from "./memory-token-prompter-B5FFCsGP.js";
+export { ChannelSpec, ConnectorSpec, ConnectorSyncOutcome, FunnelLocalConfig, FunnelLocalConfigSync, FunnelLocalConfigWriter, FunnelTokenPrompter, LOCAL_CONFIG_FILENAME, LocalConfig, LocalConfigSyncResult, MemoryFunnelTokenPrompter, NodeFunnelTokenPrompter, ProfileSpec, channelSpecSchema, connectorSpecSchema, funnelJsonSchema, localConfigSchema, profileSpecSchema };

package/dist/local-config.js

@@ -0,0 +1,3 @@
+import { a as FunnelLocalConfig, c as connectorSpecSchema, i as FunnelTokenPrompter, l as localConfigSchema, n as NodeFunnelTokenPrompter, o as LOCAL_CONFIG_FILENAME, r as FunnelLocalConfigSync, s as channelSpecSchema, t as funnelJsonSchema, u as profileSpecSchema } from "./local-config-json-schema-8IHjS4Q7.js";
+import { n as FunnelLocalConfigWriter, t as MemoryFunnelTokenPrompter } from "./memory-token-prompter-CLerGsgM.js";
+export { FunnelLocalConfig, FunnelLocalConfigSync, FunnelLocalConfigWriter, FunnelTokenPrompter, LOCAL_CONFIG_FILENAME, MemoryFunnelTokenPrompter, NodeFunnelTokenPrompter, channelSpecSchema, connectorSpecSchema, funnelJsonSchema, localConfigSchema, profileSpecSchema };

package/dist/logger-BP6SisKt.js

@@ -0,0 +1,9 @@
+//#region lib/engine/logger/logger.ts
+/**
+* Structured logger with three levels and an optional log-file path.
+* Defaults to NodeFunnelLogger (appends to `<os.tmpdir()>/funnel/funnel.log`);
+* MemoryFunnelLogger captures entries in memory and NoopFunnelLogger silences output.
+*/
+var FunnelLogger = class {};
+//#endregion
+export { FunnelLogger as t };

package/dist/mcp-Dr-nIBwN.js

@@ -0,0 +1,253 @@
+import { n as NodeFunnelProcessRunner } from "./gh-connector-schema-o3Q1-ojL.js";
+import { t as NodeFunnelFileSystem } from "./node-file-system-BcrmWN9I.js";
+import { n as FUNNEL_DIR, o as resolveFunnelPort, p as NodeFunnelIdGenerator } from "./settings-store-D2XSXTyt.js";
+import { join } from "node:path";
+import { z } from "zod";
+//#region lib/engine/claude/claude.ts
+const defaultProcess$1 = new NodeFunnelProcessRunner();
+const defaultIdGenerator = new NodeFunnelIdGenerator();
+/**
+* Launches Claude Code with funnel pre-wired: ensures the gateway is running,
+* installs the funnel MCP into the target repo's `.mcp.json` if missing,
+* injects `FUNNEL_CHANNEL_ID` into the child env, and delegates singleton
+* enforcement to a ProcessGuard.
+*/
+var FunnelClaude = class {
+	channels;
+	mcp;
+	gateway;
+	sessions;
+	guard;
+	process;
+	idGenerator;
+	logger;
+	constructor(deps) {
+		this.channels = deps.channels;
+		this.mcp = deps.mcp;
+		this.gateway = deps.gateway;
+		this.sessions = deps.sessions;
+		this.guard = deps.guard;
+		this.process = deps.process ?? defaultProcess$1;
+		this.idGenerator = deps.idGenerator ?? defaultIdGenerator;
+		this.logger = deps.logger;
+		Object.freeze(this);
+	}
+	async launch(options) {
+		const channel = this.channels.get(options.channel) ?? this.channels.getById(options.channel);
+		if (!channel) throw new Error(`channel "${options.channel}" not found`);
+		if (options.profileId && this.guard.isRunning(options.profileId)) throw new Error(`profile "${options.profileId}" is already running`);
+		const cwd = options.cwd ?? globalThis.process.cwd();
+		if ((options.installMcp ?? true) && !this.mcp.findInstalledName(cwd)) {
+			this.mcp.install(cwd);
+			this.logger?.info(`added funnel MCP to .mcp.json`, { cwd });
+		}
+		if (!this.gateway.isRunning()) {
+			this.logger?.info(`starting gateway automatically`);
+			await this.gateway.start();
+		}
+		if (options.profileId) this.guard.acquire(options.profileId);
+		const session = (options.resume ?? false) && options.profileId ? this.resolveSession(options.profileId, cwd, options.userArgs ?? [], options.env ?? {}) : null;
+		const claudeArgs = this.buildArgs(options.options ?? [], options.userArgs ?? [], cwd, session);
+		const env = this.buildEnv(channel.id, options.env ?? {});
+		this.logger?.info(`claude launch`, {
+			channel: options.channel,
+			channelId: channel.id,
+			cwd
+		});
+		try {
+			return await this.process.attach(["claude", ...claudeArgs], {
+				cwd,
+				env,
+				onSpawned: options.onSpawned
+			});
+		} finally {
+			if (options.profileId) this.guard.release(options.profileId);
+		}
+	}
+	buildArgs(recipeOptions, userArgs, cwd, session) {
+		const result = [...recipeOptions, ...userArgs];
+		if (session !== null) if (session.mode === "resume") result.push("--resume", session.id);
+		else result.push("--session-id", session.id);
+		const mcpName = this.mcp.findInstalledName(cwd);
+		if (mcpName && !result.includes("--dangerously-load-development-channels") && !result.includes("--channels")) result.push("--dangerously-load-development-channels", `server:${mcpName}`);
+		return result;
+	}
+	/**
+	* Decides whether funnel should resume an existing claude session or start
+	* a freshly minted one. Backs off when the user already passed a
+	* session-shaping flag, since combining them would either confuse claude
+	* or override the explicit user intent.
+	*
+	* The session is owned by the profile (by id), not by cwd: two profiles
+	* pointing at the same repo each keep their own conversation, and a launch
+	* with no profile never resumes — so an unrelated session in the same repo
+	* can't bleed in. The channel never enters into it; sessions belong to the
+	* launch layer (profiles), keeping the transport layer ignorant of them.
+	*
+	* A persisted id is only resumed when its session jsonl still exists on
+	* disk. claude errors out on `--resume <id>` for a missing conversation, and
+	* a persisted id can outlive its jsonl (claude pruned it, or the very first
+	* launch was aborted after the id was written but before the jsonl
+	* appeared). When the file is gone we mint a fresh session instead, which
+	* overwrites the dangling entry — so the store self-heals.
+	*/
+	resolveSession(profileId, cwd, userArgs, recipeEnv) {
+		for (const arg of userArgs) {
+			if (arg === "-c" || arg === "--continue") return null;
+			if (arg === "--resume" || arg.startsWith("--resume=")) return null;
+			if (arg === "--session-id" || arg.startsWith("--session-id=")) return null;
+		}
+		const existing = this.sessions.getSessionId(profileId);
+		if (existing !== null && this.sessions.sessionFileExists(cwd, existing, recipeEnv)) return {
+			id: existing,
+			mode: "resume"
+		};
+		const fresh = this.idGenerator.generate();
+		this.sessions.setSessionId(profileId, fresh);
+		return {
+			id: fresh,
+			mode: "new"
+		};
+	}
+	buildEnv(channelId, recipeEnv) {
+		const env = {};
+		for (const [key, value] of Object.entries(recipeEnv)) env[key] = value;
+		for (const [key, value] of Object.entries(globalThis.process.env)) if (typeof value === "string") env[key] = value;
+		env.FUNNEL_CHANNEL_ID = channelId;
+		env.FUNNEL_PORT = String(resolveFunnelPort());
+		return env;
+	}
+};
+//#endregion
+//#region lib/engine/claude/file-process-guard.ts
+const defaultFs$1 = new NodeFunnelFileSystem();
+const defaultProcess = new NodeFunnelProcessRunner();
+var FileProcessGuard = class {
+	fs;
+	process;
+	pidDir;
+	constructor(deps = {}) {
+		this.fs = deps.fs ?? defaultFs$1;
+		this.process = deps.process ?? defaultProcess;
+		this.pidDir = join(deps.dir ?? FUNNEL_DIR, "claude");
+		Object.freeze(this);
+	}
+	isRunning(profileId) {
+		const pid = this.readPid(profileId);
+		if (!pid) return false;
+		return this.process.isAlive(pid);
+	}
+	acquire(profileId) {
+		this.fs.mkdirSync(this.pidDir, { recursive: true });
+		this.fs.writeFileSync(this.pidPath(profileId), String(globalThis.process.pid));
+		globalThis.process.once("exit", () => this.release(profileId));
+	}
+	release(profileId) {
+		const path = this.pidPath(profileId);
+		if (this.fs.existsSync(path)) this.fs.unlink(path);
+	}
+	pidPath(profileId) {
+		return join(this.pidDir, `${profileId}.pid`);
+	}
+	readPid(profileId) {
+		const path = this.pidPath(profileId);
+		if (!this.fs.existsSync(path)) return null;
+		try {
+			const content = this.fs.readFileSync(path).trim();
+			const pid = Number(content);
+			if (!pid || pid <= 0) return null;
+			return pid;
+		} catch {
+			return null;
+		}
+	}
+};
+//#endregion
+//#region lib/engine/mcp/mcp.ts
+const FUNNEL_MCP_COMMAND = "bun";
+const FUNNEL_MCP_ARGS = ["funnel", "mcp"];
+const FUNNEL_MCP_NAME = "funnel";
+const mcpEntrySchema = z.object({
+	command: z.string().optional(),
+	args: z.array(z.string()).optional()
+});
+const mcpConfigSchema = z.object({ mcpServers: z.record(z.string(), mcpEntrySchema).optional() });
+const defaultFs = new NodeFunnelFileSystem();
+/**
+* Installs/uninstalls the funnel MCP entry into a target repository's
+* `.mcp.json`. Detects an existing entry by command match so renaming is
+* preserved across re-installs.
+*/
+var FunnelMcp = class {
+	fs;
+	constructor(deps = {}) {
+		this.fs = deps.fs ?? defaultFs;
+		Object.freeze(this);
+	}
+	install(repoPath) {
+		if (!this.fs.existsSync(repoPath)) throw new Error(`repository does not exist: ${repoPath}`);
+		const config = this.readConfig(repoPath);
+		const servers = config.mcpServers ?? {};
+		const targetName = this.findServerName(servers) ?? "funnel";
+		servers[targetName] = {
+			command: "bun",
+			args: FUNNEL_MCP_ARGS
+		};
+		this.writeConfig(repoPath, {
+			...config,
+			mcpServers: servers
+		});
+	}
+	uninstall(repoPath) {
+		if (!this.fs.existsSync(repoPath)) return;
+		const config = this.readConfig(repoPath);
+		const servers = config.mcpServers ?? {};
+		const name = this.findServerName(servers);
+		if (!name) return;
+		const next = { ...servers };
+		delete next[name];
+		this.writeConfig(repoPath, {
+			...config,
+			mcpServers: next
+		});
+	}
+	findInstalledName(cwd) {
+		const config = this.readConfig(cwd);
+		return this.findServerName(config.mcpServers ?? {});
+	}
+	findServerName(servers) {
+		for (const entry of Object.entries(servers)) {
+			const name = entry[0];
+			const value = entry[1];
+			if (this.isFunnelEntry(value)) return name;
+		}
+		return null;
+	}
+	isFunnelEntry(value) {
+		if (!value) return false;
+		if (value.command === "bun" && value.args?.[0] === "funnel") return true;
+		if (value.command === "funnel") return true;
+		return false;
+	}
+	readConfig(repoPath) {
+		const mcpPath = join(repoPath, ".mcp.json");
+		if (!this.fs.existsSync(mcpPath)) return {};
+		const content = this.fs.readFileSync(mcpPath).trim();
+		if (!content) return {};
+		let parsed;
+		try {
+			parsed = JSON.parse(content);
+		} catch (error) {
+			throw new Error(`invalid .mcp.json (${mcpPath}): ${error instanceof Error ? error.message : String(error)}`);
+		}
+		const result = mcpConfigSchema.safeParse(parsed);
+		if (!result.success) throw new Error(`invalid .mcp.json (${mcpPath}): ${result.error.message}`);
+		return result.data;
+	}
+	writeConfig(repoPath, config) {
+		const mcpPath = join(repoPath, ".mcp.json");
+		this.fs.writeFileSync(mcpPath, `${JSON.stringify(config, null, 2)}\n`);
+	}
+};
+//#endregion
+export { FileProcessGuard as a, FunnelMcp as i, FUNNEL_MCP_COMMAND as n, FunnelClaude as o, FUNNEL_MCP_NAME as r, FUNNEL_MCP_ARGS as t };