@hasna/bridge 0.1.1 → 0.2.0

package/dist/cli/index.js

@@ -2064,7 +2064,7 @@ var require_commander = __commonJS((exports) => {
 
 // src/cli/index.ts
 import { readFileSync } from "fs";
-import { dirname as dirname3, join as join3 } from "path";
+import { dirname as dirname4, join as join5 } from "path";
 import { fileURLToPath } from "url";
 
 // node_modules/commander/esm.mjs
@@ -2103,6 +2103,11 @@ function mergeEnv(profile, agent) {
     env["HOME"] = profile.home;
   return Object.keys(env).length ? env : undefined;
 }
+function compatibilityDetail(kind) {
+  if (kind === "shell")
+    return "shell command session; local bridge state is durable";
+  return "compatibility mode: this adapter invokes the current CLI one message at a time until a stable create/send/resume API is wired";
+}
 function resolveAgent(config, agentId) {
   const agent = config.agents[agentId];
   if (!agent)
@@ -2121,7 +2126,7 @@ function buildAgentCommand(config, agentId, input) {
   const kind = agent.kind;
   const command = agent.command || profile?.command;
   const args = agent.args || profile?.args;
-  const cwd = agent.cwd || profile?.cwd;
+  const cwd = input.session?.cwd || agent.cwd || profile?.cwd;
   const env = mergeEnv(profile, agent);
   if (command) {
     return { command: [command, ...renderCustomArgs(args, prompt)], cwd, env };
@@ -2143,6 +2148,32 @@ function buildAgentCommand(config, agentId, input) {
   }
   return { command: ["sh", "-lc", prompt], cwd, env };
 }
+function createAgentSessionRef(config, agentId) {
+  const { agent } = resolveAgent(config, agentId);
+  const timestamp = new Date().toISOString();
+  return {
+    kind: agent.kind,
+    mode: "compatibility",
+    createdAt: timestamp,
+    updatedAt: timestamp,
+    detail: compatibilityDetail(agent.kind)
+  };
+}
+function closeAgentSession(session) {
+  return {
+    supported: session.agentSession?.mode === "durable",
+    ref: session.agentSession,
+    detail: session.agentSession?.mode === "durable" ? "durable close is adapter-owned" : "compatibility close only updates bridge session state"
+  };
+}
+async function sendAgentSessionMessage(config, session, message, options = {}) {
+  const run = options.run || runAgent;
+  return run(config, session.agentId, {
+    message,
+    route: { id: `session:${session.id}`, fromChannel: message.channelId, toAgent: session.agentId },
+    session
+  });
+}
 async function runAgent(config, agentId, input) {
   const { agent } = resolveAgent(config, agentId);
   const built = buildAgentCommand(config, agentId, input);
@@ -6200,7 +6231,14 @@ var channelSchema = exports_external.discriminatedUnion("kind", [
     kind: exports_external.literal("imessage"),
     label: exports_external.string().optional(),
     enabled: exports_external.boolean().optional(),
-    account: exports_external.string().optional()
+    account: exports_external.string().optional(),
+    serviceName: exports_external.string().optional(),
+    defaultHandle: exports_external.string().optional(),
+    allowedHandles: exports_external.array(exports_external.string()).optional(),
+    allowAllHandles: exports_external.boolean().optional(),
+    receiveMode: exports_external.enum(["disabled", "chat-db"]).optional(),
+    chatDbPath: exports_external.string().optional(),
+    pollLimit: exports_external.number().int().positive().max(500).optional()
   })
 ]);
 var envSchema = exports_external.record(exports_external.string(), exports_external.string());
@@ -6304,25 +6342,44 @@ async function upsertRoute(route, configPath = defaultConfigPath()) {
   await saveConfig(config, configPath);
   return config;
 }
-// src/lib/doctor.ts
-import { stat } from "fs/promises";
+// src/lib/daemon.ts
+import { spawn } from "child_process";
+import { closeSync, openSync } from "fs";
+import { chmod as chmod3, mkdir as mkdir3, readFile as readFile3, rename, rm, rmdir, stat, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname3, join as join3, resolve } from "path";
 
 // src/lib/state.ts
 import { chmod as chmod2, mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
 import { dirname as dirname2, join as join2 } from "path";
+var STATE_SCHEMA_VERSION = 2;
 function defaultStatePath() {
   return process.env["BRIDGE_STATE"] || join2(bridgeHome(), "state.json");
 }
 function emptyState() {
-  return { telegramOffsets: {} };
+  return {
+    schemaVersion: STATE_SCHEMA_VERSION,
+    telegramOffsets: {},
+    sessions: {},
+    bindings: {},
+    messageLedger: {},
+    cursors: {}
+  };
+}
+function normalizeState(value) {
+  return {
+    schemaVersion: STATE_SCHEMA_VERSION,
+    telegramOffsets: value.telegramOffsets && typeof value.telegramOffsets === "object" ? value.telegramOffsets : {},
+    sessions: value.sessions && typeof value.sessions === "object" ? value.sessions : {},
+    bindings: value.bindings && typeof value.bindings === "object" ? value.bindings : {},
+    messageLedger: value.messageLedger && typeof value.messageLedger === "object" ? value.messageLedger : {},
+    cursors: value.cursors && typeof value.cursors === "object" ? value.cursors : {}
+  };
 }
 async function loadState(statePath = defaultStatePath()) {
   try {
     const raw = await readFile2(statePath, "utf-8");
     const parsed = JSON.parse(raw);
-    return {
-      telegramOffsets: parsed.telegramOffsets && typeof parsed.telegramOffsets === "object" ? parsed.telegramOffsets : {}
-    };
+    return normalizeState(parsed);
   } catch (err) {
     if (err && typeof err === "object" && "code" in err && err.code === "ENOENT") {
       return emptyState();
@@ -6331,71 +6388,44 @@ async function loadState(statePath = defaultStatePath()) {
   }
 }
 async function saveState(state, statePath = defaultStatePath()) {
+  const normalized = normalizeState(state);
   await mkdir2(dirname2(statePath), { recursive: true, mode: 448 });
-  await writeFile2(statePath, `${JSON.stringify(state, null, 2)}
+  await writeFile2(statePath, `${JSON.stringify(normalized, null, 2)}
 `, { encoding: "utf-8", mode: 384 });
   await chmod2(statePath, 384);
 }
 
-// src/lib/doctor.ts
-function isNotFound(err) {
-  return Boolean(err && typeof err === "object" && "code" in err && err.code === "ENOENT");
-}
-async function privateFileCheck(name, path) {
-  try {
-    const info = await stat(path);
-    const mode = info.mode & 511;
-    const ok = (mode & 63) === 0;
-    return { name, ok, detail: `${path} mode=${mode.toString(8)}` };
-  } catch (err) {
-    if (isNotFound(err))
-      return { name, ok: true, detail: `not created yet: ${path}` };
-    return { name, ok: false, detail: `${path}: ${err instanceof Error ? err.message : String(err)}` };
-  }
-}
-async function commandExists(command) {
-  const proc = Bun.spawn(["sh", "-lc", `command -v ${command} >/dev/null 2>&1`], {
-    stdout: "ignore",
-    stderr: "ignore"
-  });
-  return await proc.exited === 0;
-}
-async function doctor(configPath = defaultConfigPath(), statePath = defaultStatePath()) {
-  const checks = [];
-  let config = await loadConfig(configPath);
-  checks.push(await privateFileCheck("config", configPath));
-  checks.push(await privateFileCheck("state", statePath));
-  for (const command of ["bridge", "codewith", "claude", "aicopilot"]) {
-    checks.push({
-      name: `command:${command}`,
-      ok: command === "bridge" ? true : await commandExists(command),
-      detail: command === "bridge" ? "current package" : undefined
-    });
+// src/lib/telegram.ts
+var DEFAULT_TELEGRAM_API_BASE = "https://api.telegram.org";
+function telegramApiBase() {
+  const raw = process.env["BRIDGE_TELEGRAM_API_BASE"] || DEFAULT_TELEGRAM_API_BASE;
+  const parsed = new URL(raw);
+  if (!["http:", "https:"].includes(parsed.protocol)) {
+    throw new Error("BRIDGE_TELEGRAM_API_BASE must use http or https");
   }
-  const telegramChannels = Object.values(config.channels).filter((channel) => channel.kind === "telegram");
-  for (const channel of telegramChannels) {
-    const envName = channel.botTokenEnv || "TELEGRAM_BOT_TOKEN";
-    checks.push({
-      name: `telegram-token:${channel.id}`,
-      ok: Boolean(process.env[envName]),
-      detail: envName
-    });
-    checks.push({
-      name: `telegram-allowlist:${channel.id}`,
-      ok: Boolean(channel.allowAllChats || channel.allowedChatIds?.length),
-      detail: channel.allowAllChats ? "allowAllChats=true" : `${channel.allowedChatIds?.length || 0} chat id(s)`
-    });
+  if (parsed.username || parsed.password) {
+    throw new Error("BRIDGE_TELEGRAM_API_BASE must not contain credentials");
   }
-  for (const route of config.routes) {
-    checks.push({
-      name: `route:${route.id}`,
-      ok: Boolean(config.channels[route.fromChannel] && config.agents[route.toAgent]),
-      detail: `${route.fromChannel} -> ${route.toAgent}`
-    });
+  if (parsed.search || parsed.hash) {
+    throw new Error("BRIDGE_TELEGRAM_API_BASE must not contain query strings or fragments");
   }
-  return { ok: checks.every((check) => check.ok), configPath, checks };
+  return parsed;
+}
+function telegramApiBaseInfo() {
+  const parsed = telegramApiBase();
+  return {
+    overridden: parsed.href.replace(/\/$/, "") !== DEFAULT_TELEGRAM_API_BASE,
+    origin: parsed.origin,
+    pathname: parsed.pathname
+  };
+}
+function telegramMethodUrl(token, method) {
+  const base = telegramApiBase();
+  const prefix = base.pathname.replace(/\/$/, "");
+  base.pathname = `${prefix}/bot${token}/${method}`;
+  base.search = "";
+  return base.toString();
 }
-// src/lib/telegram.ts
 function telegramToken(channel) {
   const envName = channel.botTokenEnv || "TELEGRAM_BOT_TOKEN";
   const token = process.env[envName];
@@ -6411,7 +6441,7 @@ function telegramChatAllowed(channel, chatId) {
   return Boolean(chatId && channel.allowedChatIds.includes(chatId));
 }
 async function sendTelegramMessage(token, chatId, text) {
-  const response = await fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
+  const response = await fetch(telegramMethodUrl(token, "sendMessage"), {
     method: "POST",
     headers: { "content-type": "application/json" },
     body: JSON.stringify({ chat_id: chatId, text })
@@ -6428,7 +6458,7 @@ async function getTelegramUpdates(token, options = {}) {
   if (options.offset !== undefined)
     params.set("offset", String(options.offset));
   params.set("timeout", String(options.timeoutSeconds ?? 20));
-  const response = await fetch(`https://api.telegram.org/bot${token}/getUpdates?${params.toString()}`);
+  const response = await fetch(`${telegramMethodUrl(token, "getUpdates")}?${params.toString()}`);
   const body = await response.json().catch(() => {
     return;
   });
@@ -6447,12 +6477,854 @@ function telegramUpdateToMessage(channelId, update) {
     channelId,
     text,
     chatId: String(chatId),
+    threadId: update.message?.message_thread_id !== undefined ? String(update.message.message_thread_id) : undefined,
     from: update.message?.from?.username || (update.message?.from?.id !== undefined ? String(update.message.from.id) : undefined),
     receivedAt: update.message?.date ? new Date(update.message.date * 1000).toISOString() : new Date().toISOString(),
     raw: update
   };
 }
 
+// src/lib/daemon.ts
+function isNotFound(err) {
+  return Boolean(err && typeof err === "object" && "code" in err && err.code === "ENOENT");
+}
+function currentPlatformSupervisor() {
+  if (process.platform === "darwin")
+    return "launchd";
+  if (process.platform === "linux")
+    return "systemd";
+  return "process";
+}
+function resolveSupervisor(supervisor = "process") {
+  return supervisor === "auto" ? currentPlatformSupervisor() : supervisor;
+}
+function defaultDaemonDir() {
+  return join3(bridgeHome(), "daemon");
+}
+function daemonPaths(daemonDir = defaultDaemonDir()) {
+  const dir = resolve(daemonDir);
+  return {
+    dir,
+    lockDir: join3(dir, "lock"),
+    metadataFile: join3(dir, "bridge-daemon.json"),
+    stdoutLog: join3(dir, "bridge.out.log"),
+    stderrLog: join3(dir, "bridge.err.log"),
+    launchdPlist: join3(process.env["HOME"] || process.cwd(), "Library", "LaunchAgents", "com.hasna.bridge.plist"),
+    systemdUnit: join3(process.env["HOME"] || process.cwd(), ".config", "systemd", "user", "hasna-bridge.service")
+  };
+}
+async function ensureDaemonDir(dir = defaultDaemonDir()) {
+  const paths = daemonPaths(dir);
+  await mkdir3(paths.dir, { recursive: true, mode: 448 });
+  await chmod3(paths.dir, 448);
+  return paths;
+}
+async function fileExists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch (err) {
+    if (isNotFound(err))
+      return false;
+    throw err;
+  }
+}
+async function readMetadata(paths) {
+  try {
+    return JSON.parse(await readFile3(paths.metadataFile, "utf-8"));
+  } catch (err) {
+    if (isNotFound(err))
+      return;
+    throw err;
+  }
+}
+async function writeMetadata(paths, metadata) {
+  const tmp = `${paths.metadataFile}.${process.pid}.${Date.now()}.tmp`;
+  await writeFile3(tmp, `${JSON.stringify(metadata, null, 2)}
+`, { encoding: "utf-8", mode: 384 });
+  await chmod3(tmp, 384);
+  await rename(tmp, paths.metadataFile);
+  await chmod3(paths.metadataFile, 384);
+}
+async function withDaemonLock(paths, fn) {
+  try {
+    await mkdir3(paths.lockDir, { mode: 448 });
+  } catch (err) {
+    if (err && typeof err === "object" && "code" in err && err.code === "EEXIST") {
+      throw new Error(`Another bridge daemon operation is already running: ${paths.lockDir}`);
+    }
+    throw err;
+  }
+  try {
+    return await fn();
+  } finally {
+    await rmdir(paths.lockDir).catch(() => {
+      return;
+    });
+  }
+}
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function processCommand(pid) {
+  const proc = Bun.spawn(["ps", "-p", String(pid), "-o", "command="], {
+    stdout: "pipe",
+    stderr: "ignore"
+  });
+  if (await proc.exited !== 0)
+    return;
+  return (await new Response(proc.stdout).text()).trim();
+}
+async function processPgid(pid) {
+  const proc = Bun.spawn(["ps", "-p", String(pid), "-o", "pgid="], {
+    stdout: "pipe",
+    stderr: "ignore"
+  });
+  if (await proc.exited !== 0)
+    return;
+  const parsed = Number.parseInt((await new Response(proc.stdout).text()).trim(), 10);
+  return Number.isInteger(parsed) ? parsed : undefined;
+}
+function shellQuote(value) {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function commandPattern(command) {
+  return command.map(shellQuote).join(" ");
+}
+async function processMatches(metadata) {
+  if (!pidAlive(metadata.pid))
+    return false;
+  const command = await processCommand(metadata.pid);
+  if (!command)
+    return false;
+  if (!metadata.pgid)
+    return false;
+  const pgid = await processPgid(metadata.pid);
+  if (pgid !== metadata.pgid)
+    return false;
+  const requiredArgs = [
+    metadata.command[1],
+    "serve",
+    "--config",
+    metadata.configPath,
+    "--state",
+    metadata.statePath,
+    "--interval",
+    String(metadata.intervalMs)
+  ].filter((arg) => Boolean(arg));
+  if (metadata.serveJson)
+    requiredArgs.push("--json");
+  return requiredArgs.every((arg) => command.includes(arg));
+}
+async function removeMetadata(paths) {
+  await rm(paths.metadataFile, { force: true });
+}
+function safeTelegramApiBaseInfo() {
+  try {
+    return telegramApiBaseInfo();
+  } catch (err) {
+    return {
+      overridden: true,
+      origin: "",
+      pathname: "",
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+function startCommand(options) {
+  const scriptPath = process.argv[1];
+  const base = scriptPath ? [process.execPath, scriptPath] : ["bridge"];
+  const command = [
+    ...base,
+    "serve",
+    "--config",
+    options.configPath,
+    "--state",
+    options.statePath,
+    "--interval",
+    String(options.intervalMs)
+  ];
+  if (options.serveJson)
+    command.push("--json");
+  return command;
+}
+function telegramChannels(config) {
+  return Object.values(config.channels).filter((channel) => channel.kind === "telegram" && channel.enabled !== false);
+}
+function imessagePollChannels(config) {
+  return Object.values(config.channels).filter((channel) => channel.kind === "imessage" && channel.enabled !== false && channel.receiveMode === "chat-db");
+}
+function requiredTelegramEnvVars(config) {
+  return [...new Set(telegramChannels(config).map((channel) => channel.botTokenEnv || "TELEGRAM_BOT_TOKEN"))];
+}
+async function validateStartConfig(configPath) {
+  const config = await loadConfig(configPath);
+  const channels = [...telegramChannels(config), ...imessagePollChannels(config)];
+  if (!channels.length)
+    throw new Error("No enabled pollable channels configured; add Telegram or iMessage receive before starting the daemon");
+  for (const envName of requiredTelegramEnvVars(config)) {
+    if (!process.env[envName])
+      throw new Error(`Missing Telegram bot token env var for daemon start: ${envName}`);
+  }
+}
+function openPrivateLog(path) {
+  const fd = openSync(path, "a", 384);
+  return fd;
+}
+async function ensurePrivateLogFiles(paths) {
+  for (const path of [paths.stdoutLog, paths.stderrLog]) {
+    const fd = openPrivateLog(path);
+    closeSync(fd);
+    await chmod3(path, 384);
+  }
+}
+async function runCapture(command) {
+  const proc = Bun.spawn(command, { stdout: "pipe", stderr: "pipe" });
+  const [exitCode, stdout, stderr] = await Promise.all([
+    proc.exited,
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text()
+  ]);
+  return { exitCode, stdout, stderr };
+}
+async function installedSupervisorStatus(supervisor, paths) {
+  if (supervisor === "launchd") {
+    if (!await fileExists(paths.launchdPlist))
+      return { running: false, detail: "launchd plist not installed" };
+    const uid = typeof process.getuid === "function" ? process.getuid() : undefined;
+    if (uid === undefined)
+      return { running: false, detail: "launchd status requires a numeric uid" };
+    const result = await runCapture(["launchctl", "print", `gui/${uid}/com.hasna.bridge`]);
+    if (result.exitCode !== 0)
+      return { running: false, detail: result.stderr.trim() || result.stdout.trim() || "launchd service not loaded" };
+    const running = /state\s*=\s*running/.test(result.stdout);
+    return { running, detail: running ? "launchd running" : "launchd loaded but not running" };
+  }
+  if (supervisor === "systemd") {
+    if (!await fileExists(paths.systemdUnit))
+      return { running: false, detail: "systemd unit not installed" };
+    const result = await runCapture(["systemctl", "--user", "is-active", "hasna-bridge.service"]);
+    const state = result.stdout.trim() || result.stderr.trim() || "unknown";
+    return { running: result.exitCode === 0 && state === "active", detail: `systemd ${state}` };
+  }
+  return { running: false, detail: "process supervisor has no installed status" };
+}
+async function daemonStatus(options = {}) {
+  const supervisor = resolveSupervisor(options.supervisor);
+  const paths = daemonPaths(options.daemonDir);
+  const metadata = await readMetadata(paths);
+  const live = metadata ? await processMatches(metadata) : false;
+  const stale = Boolean(metadata && !live);
+  const startedAt = metadata?.startedAt;
+  const uptimeSeconds = live && startedAt ? Math.max(0, Math.floor((Date.now() - Date.parse(startedAt)) / 1000)) : undefined;
+  const installed = {
+    launchd: await fileExists(paths.launchdPlist),
+    systemd: await fileExists(paths.systemdUnit)
+  };
+  const installedRuntime = supervisor === "process" ? undefined : await installedSupervisorStatus(supervisor, paths);
+  return {
+    running: installedRuntime ? installedRuntime.running : live,
+    stale: installedRuntime ? false : stale,
+    supervisor,
+    pid: metadata?.pid,
+    startedAt,
+    uptimeSeconds,
+    detail: installedRuntime?.detail || (stale ? "stale process metadata" : live ? "running" : "not running"),
+    installedDetail: installedRuntime?.detail,
+    metadata,
+    paths,
+    installed,
+    telegramApiBase: safeTelegramApiBaseInfo()
+  };
+}
+async function startProcessDaemon(options = {}) {
+  const paths = await ensureDaemonDir(options.daemonDir);
+  return withDaemonLock(paths, async () => {
+    const existing = await daemonStatus({ daemonDir: paths.dir, supervisor: "process" });
+    if (existing.running)
+      return existing;
+    if (existing.stale)
+      await removeMetadata(paths);
+    const configPath = resolve(options.configPath || defaultConfigPath());
+    const statePath = resolve(options.statePath || defaultStatePath());
+    const intervalMs = options.intervalMs ?? 1000;
+    const serveJson = Boolean(options.serveJson);
+    if (!Number.isInteger(intervalMs) || intervalMs < 0)
+      throw new Error("--interval must be a non-negative integer");
+    await validateStartConfig(configPath);
+    const stdoutFd = openPrivateLog(paths.stdoutLog);
+    const stderrFd = openPrivateLog(paths.stderrLog);
+    try {
+      const command = startCommand({ configPath, statePath, intervalMs, serveJson });
+      const child = spawn(command[0], command.slice(1), {
+        cwd: process.cwd(),
+        detached: true,
+        env: process.env,
+        stdio: ["ignore", stdoutFd, stderrFd]
+      });
+      child.unref();
+      const metadata = {
+        version: 1,
+        supervisor: "process",
+        pid: child.pid || 0,
+        pgid: child.pid || undefined,
+        startedAt: new Date().toISOString(),
+        identity: {
+          command: commandPattern(command),
+          cwd: process.cwd(),
+          configPath,
+          statePath,
+          daemonDir: paths.dir,
+          bridgeHome: bridgeHome()
+        },
+        command,
+        cwd: process.cwd(),
+        configPath,
+        statePath,
+        intervalMs,
+        serveJson,
+        daemonDir: paths.dir,
+        bridgeHome: bridgeHome(),
+        stdoutLog: paths.stdoutLog,
+        stderrLog: paths.stderrLog
+      };
+      if (!metadata.pid)
+        throw new Error("Failed to start bridge daemon process");
+      await writeMetadata(paths, metadata);
+      await Bun.sleep(200);
+      const status = await daemonStatus({ daemonDir: paths.dir, supervisor: "process" });
+      if (!status.running) {
+        await removeMetadata(paths);
+        throw new Error(`Bridge daemon failed to stay running; inspect ${paths.stderrLog}`);
+      }
+      return status;
+    } finally {
+      closeSync(stdoutFd);
+      closeSync(stderrFd);
+      await chmod3(paths.stdoutLog, 384).catch(() => {
+        return;
+      });
+      await chmod3(paths.stderrLog, 384).catch(() => {
+        return;
+      });
+    }
+  });
+}
+async function stopPid(pid, force) {
+  process.kill(-pid, force ? "SIGKILL" : "SIGTERM");
+}
+async function waitForExit(pid, timeoutMs) {
+  const started = Date.now();
+  while (Date.now() - started < timeoutMs) {
+    if (!pidAlive(pid))
+      return true;
+    await Bun.sleep(100);
+  }
+  return !pidAlive(pid);
+}
+async function stopProcessDaemon(options = {}) {
+  const paths = await ensureDaemonDir(options.daemonDir);
+  return withDaemonLock(paths, async () => {
+    const metadata = await readMetadata(paths);
+    if (!metadata)
+      return daemonStatus({ daemonDir: paths.dir, supervisor: "process" });
+    if (!await processMatches(metadata)) {
+      await removeMetadata(paths);
+      return daemonStatus({ daemonDir: paths.dir, supervisor: "process" });
+    }
+    await stopPid(metadata.pid, false);
+    let exited = await waitForExit(metadata.pid, options.timeoutMs ?? 5000);
+    if (!exited && options.force) {
+      await stopPid(metadata.pid, true);
+      exited = await waitForExit(metadata.pid, 2000);
+    }
+    if (!exited)
+      throw new Error(`Bridge daemon did not stop within ${options.timeoutMs ?? 5000}ms`);
+    await removeMetadata(paths);
+    return daemonStatus({ daemonDir: paths.dir, supervisor: "process" });
+  });
+}
+async function restartProcessDaemon(options = {}) {
+  const paths = daemonPaths(options.daemonDir);
+  const metadata = await readMetadata(paths);
+  await stopProcessDaemon(options);
+  return startProcessDaemon({
+    ...options,
+    configPath: options.configPath || metadata?.configPath,
+    statePath: options.statePath || metadata?.statePath,
+    intervalMs: options.intervalMs ?? metadata?.intervalMs,
+    serveJson: options.serveJson ?? metadata?.serveJson
+  });
+}
+function xmlEscape(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+function plistArray(values) {
+  return values.map((value) => `    <string>${xmlEscape(value)}</string>`).join(`
+`);
+}
+function renderLaunchdPlist(command, paths) {
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "https://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>com.hasna.bridge</string>
+  <key>ProgramArguments</key>
+  <array>
+${plistArray(command)}
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${xmlEscape(paths.stdoutLog)}</string>
+  <key>StandardErrorPath</key>
+  <string>${xmlEscape(paths.stderrLog)}</string>
+  <key>WorkingDirectory</key>
+  <string>${xmlEscape(process.cwd())}</string>
+</dict>
+</plist>
+`;
+}
+function systemdEscape(value) {
+  return value.replaceAll("%", "%%").replaceAll(`
+`, " ");
+}
+function systemdQuote(value) {
+  return `"${systemdEscape(value).replaceAll("\\", "\\\\").replaceAll('"', "\\\"")}"`;
+}
+function renderSystemdUnit(command, paths) {
+  return `[Unit]
+Description=Hasna Bridge daemon
+After=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${command.map(systemdQuote).join(" ")}
+Restart=always
+RestartSec=5
+WorkingDirectory=${systemdEscape(process.cwd())}
+StandardOutput=append:${systemdEscape(paths.stdoutLog)}
+StandardError=append:${systemdEscape(paths.stderrLog)}
+
+[Install]
+WantedBy=default.target
+`;
+}
+async function installFile(path, content) {
+  await mkdir3(dirname3(path), { recursive: true, mode: 448 });
+  await writeFile3(path, content, { encoding: "utf-8", mode: 384 });
+  await chmod3(path, 384);
+}
+async function installDaemon(options = {}) {
+  const supervisor = resolveSupervisor(options.supervisor || "auto");
+  if (supervisor === "process") {
+    throw new Error("The process supervisor does not need install; use `bridge daemon start`");
+  }
+  const paths = await ensureDaemonDir(options.daemonDir);
+  await ensurePrivateLogFiles(paths);
+  const configPath = resolve(options.configPath || defaultConfigPath());
+  const statePath = resolve(options.statePath || defaultStatePath());
+  const intervalMs = options.intervalMs ?? 1000;
+  const serveJson = Boolean(options.serveJson);
+  const command = startCommand({ configPath, statePath, intervalMs, serveJson });
+  const config = await loadConfig(configPath);
+  const requiredEnv = requiredTelegramEnvVars(config);
+  if (supervisor === "launchd") {
+    await installFile(paths.launchdPlist, renderLaunchdPlist(command, paths));
+    return {
+      supervisor,
+      path: paths.launchdPlist,
+      command,
+      requiredEnv,
+      warning: "Telegram token values are not written to launchd files. Set them in the launchd environment before starting."
+    };
+  }
+  await installFile(paths.systemdUnit, renderSystemdUnit(command, paths));
+  return {
+    supervisor,
+    path: paths.systemdUnit,
+    command,
+    requiredEnv,
+    warning: "Telegram token values are not written to systemd files. Import them into the user manager environment before starting."
+  };
+}
+async function runCommand(command) {
+  const { exitCode, stdout, stderr } = await runCapture(command);
+  if (exitCode !== 0)
+    throw new Error(`${command.join(" ")} failed (${exitCode}): ${stderr || stdout}`);
+}
+async function waitForInstalledRunning(supervisor, paths, timeoutMs = 5000) {
+  const started = Date.now();
+  let last = "";
+  while (Date.now() - started < timeoutMs) {
+    const status = await installedSupervisorStatus(supervisor, paths);
+    last = status.detail;
+    if (status.running)
+      return;
+    await Bun.sleep(250);
+  }
+  throw new Error(`${supervisor} service did not report running: ${last}`);
+}
+async function startInstalledDaemon(options = {}) {
+  const result = await installDaemon(options);
+  const paths = daemonPaths(options.daemonDir);
+  if (result.supervisor === "launchd") {
+    const uid = typeof process.getuid === "function" ? process.getuid() : undefined;
+    if (uid === undefined)
+      throw new Error("launchd start requires a numeric uid");
+    await runCommand(["launchctl", "bootstrap", `gui/${uid}`, result.path]).catch(async (err) => {
+      if (!String(err).includes("Input/output error"))
+        throw err;
+      await runCommand(["launchctl", "kickstart", "-k", `gui/${uid}/com.hasna.bridge`]);
+    });
+    await waitForInstalledRunning(result.supervisor, paths);
+    return result;
+  }
+  await runCommand(["systemctl", "--user", "daemon-reload"]);
+  await runCommand(["systemctl", "--user", "enable", "--now", "hasna-bridge.service"]);
+  await waitForInstalledRunning(result.supervisor, paths);
+  return result;
+}
+async function stopInstalledDaemon(options = {}) {
+  const supervisor = resolveSupervisor(options.supervisor || "auto");
+  const paths = daemonPaths(options.daemonDir);
+  if (supervisor === "launchd") {
+    const uid = typeof process.getuid === "function" ? process.getuid() : undefined;
+    if (uid === undefined)
+      throw new Error("launchd stop requires a numeric uid");
+    await runCommand(["launchctl", "bootout", `gui/${uid}`, paths.launchdPlist]);
+    return;
+  }
+  if (supervisor === "systemd") {
+    await runCommand(["systemctl", "--user", "disable", "--now", "hasna-bridge.service"]);
+    return;
+  }
+  await stopProcessDaemon(options);
+}
+async function restartInstalledDaemon(options = {}) {
+  const supervisor = resolveSupervisor(options.supervisor || "auto");
+  if (supervisor === "process")
+    return restartProcessDaemon(options);
+  await stopInstalledDaemon({ ...options, supervisor }).catch(() => {
+    return;
+  });
+  return startInstalledDaemon({ ...options, supervisor });
+}
+async function uninstallDaemon(options = {}) {
+  const supervisor = resolveSupervisor(options.supervisor || "auto");
+  const paths = daemonPaths(options.daemonDir);
+  const removed = [];
+  if (supervisor === "launchd") {
+    await stopInstalledDaemon({ ...options, supervisor }).catch(() => {
+      return;
+    });
+    await rm(paths.launchdPlist, { force: true });
+    removed.push(paths.launchdPlist);
+  } else if (supervisor === "systemd") {
+    await stopInstalledDaemon({ ...options, supervisor }).catch(() => {
+      return;
+    });
+    await rm(paths.systemdUnit, { force: true });
+    await runCommand(["systemctl", "--user", "daemon-reload"]).catch(() => {
+      return;
+    });
+    removed.push(paths.systemdUnit);
+  } else {
+    await stopProcessDaemon({ ...options, supervisor }).catch(() => {
+      return;
+    });
+    await removeMetadata(paths);
+    removed.push(paths.metadataFile);
+  }
+  return { supervisor, removed };
+}
+async function tailFile(path, lines) {
+  try {
+    const raw = await readFile3(path, "utf-8");
+    return raw.split(/\r?\n/).slice(-Math.max(1, lines)).join(`
+`);
+  } catch (err) {
+    if (isNotFound(err))
+      return "";
+    throw err;
+  }
+}
+async function daemonLogs(options = {}) {
+  const paths = daemonPaths(options.daemonDir);
+  const lines = options.lines ?? 100;
+  return {
+    stdout: await tailFile(paths.stdoutLog, lines),
+    stderr: await tailFile(paths.stderrLog, lines),
+    paths
+  };
+}
+// src/lib/doctor.ts
+import { stat as stat2 } from "fs/promises";
+
+// src/lib/imessage.ts
+import { access } from "fs/promises";
+import { join as join4 } from "path";
+import { Database } from "bun:sqlite";
+function defaultMessagesDbPath() {
+  return join4(homeDir(), "Library", "Messages", "chat.db");
+}
+function imessageHandleAllowed(channel, handle) {
+  if (channel.allowAllHandles)
+    return true;
+  if (!channel.allowedHandles?.length)
+    return false;
+  return Boolean(handle && channel.allowedHandles.includes(handle));
+}
+function appleScriptString(value) {
+  return `"${value.replaceAll("\\", "\\\\").replaceAll('"', "\\\"")}"`;
+}
+function renderSendIMessageScript(channel, handle, text) {
+  const service = channel.serviceName || "iMessage";
+  const serviceSelector = channel.account ? `1st service whose name = ${appleScriptString(service)} and account = ${appleScriptString(channel.account)}` : `1st service whose name = ${appleScriptString(service)}`;
+  const targetLines = handle.startsWith("chat:") ? [
+    `set targetChat to 1st chat whose id = ${appleScriptString(handle.slice("chat:".length))}`,
+    `send ${appleScriptString(text)} to targetChat`
+  ] : [
+    `set targetBuddy to buddy ${appleScriptString(handle)} of targetService`,
+    `send ${appleScriptString(text)} to targetBuddy`
+  ];
+  return [
+    'tell application "Messages"',
+    `set targetService to ${serviceSelector}`,
+    ...targetLines,
+    "end tell"
+  ].join(`
+`);
+}
+async function defaultRun(command) {
+  const proc = Bun.spawn(command, { stdout: "pipe", stderr: "pipe" });
+  const [exitCode, stdout, stderr] = await Promise.all([
+    proc.exited,
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text()
+  ]);
+  return { exitCode, stdout, stderr };
+}
+async function sendIMessage(channel, handle, text, options = {}) {
+  if (!(options.allowChatTarget && handle.startsWith("chat:")) && !imessageHandleAllowed(channel, handle)) {
+    throw new Error(`iMessage handle is not allowed for channel ${channel.id}: ${handle}`);
+  }
+  const script = renderSendIMessageScript(channel, handle, text);
+  const result = await (options.run || defaultRun)(["osascript", "-e", script]);
+  if (result.exitCode !== 0) {
+    throw new Error(`iMessage send failed: ${result.stderr || result.stdout || `exit ${result.exitCode}`}`);
+  }
+  return { ok: true };
+}
+function imessageDateToIso(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0)
+    return new Date().toISOString();
+  const appleEpochMs = Date.UTC(2001, 0, 1);
+  if (value > 1000000000000000)
+    return new Date(appleEpochMs + Math.floor(value / 1e6)).toISOString();
+  if (value > 1e9)
+    return new Date(appleEpochMs + value * 1000).toISOString();
+  return new Date(appleEpochMs + value).toISOString();
+}
+function getIMessageDbPath(channel) {
+  return channel.chatDbPath || defaultMessagesDbPath();
+}
+function getIMessageMessages(channel, options = {}) {
+  if ((channel.receiveMode || "disabled") !== "chat-db")
+    return [];
+  const db = new Database(getIMessageDbPath(channel), { readonly: true });
+  try {
+    const limit = options.limit || channel.pollLimit || 50;
+    const scanLimit = Math.max(limit * 10, limit);
+    const rows = db.query(`
+      select
+        message.ROWID as rowId,
+        handle.id as handle,
+        chat.guid as chatGuid,
+        chat.display_name as displayName,
+        message.text as text,
+        message.date as date
+      from message
+      left join handle on message.handle_id = handle.ROWID
+      left join chat_message_join on chat_message_join.message_id = message.ROWID
+      left join chat on chat.ROWID = chat_message_join.chat_id
+      where message.ROWID > ?
+        and message.is_from_me = 0
+        and message.text is not null
+      order by message.ROWID asc
+      limit ?
+    `).all(options.afterRowId || 0, scanLimit);
+    return rows.filter((row) => row.handle && row.text && imessageHandleAllowed(channel, row.handle)).slice(0, limit).map((row) => {
+      const item = { rowId: row.rowId, handle: row.handle, text: row.text, date: row.date };
+      if (row.chatGuid)
+        item.chatGuid = row.chatGuid;
+      if (row.displayName)
+        item.displayName = row.displayName;
+      return item;
+    });
+  } finally {
+    db.close();
+  }
+}
+function imessageRowToMessage(channelId, row) {
+  return {
+    id: `imessage:${row.rowId}`,
+    channelId,
+    chatId: row.chatGuid ? `chat:${row.chatGuid}` : row.handle,
+    responseTargetId: row.chatGuid ? `chat:${row.chatGuid}` : row.handle,
+    from: row.handle,
+    text: row.text,
+    receivedAt: imessageDateToIso(row.date),
+    raw: row
+  };
+}
+async function commandExists(command) {
+  const proc = Bun.spawn(["sh", "-lc", `command -v ${command} >/dev/null 2>&1`], {
+    stdout: "ignore",
+    stderr: "ignore"
+  });
+  return await proc.exited === 0;
+}
+async function diagnoseIMessage(channel) {
+  const checks = [];
+  checks.push({
+    name: `imessage-platform:${channel.id}`,
+    ok: process.platform === "darwin",
+    detail: process.platform === "darwin" ? "macOS" : `unsupported platform: ${process.platform}`
+  });
+  checks.push({
+    name: `imessage-osascript:${channel.id}`,
+    ok: await commandExists("osascript"),
+    detail: "required for Messages send automation"
+  });
+  checks.push({
+    name: `imessage-allowlist:${channel.id}`,
+    ok: Boolean(channel.allowAllHandles || channel.allowedHandles?.length),
+    detail: channel.allowAllHandles ? "allowAllHandles=true" : `${channel.allowedHandles?.length || 0} handle(s)`
+  });
+  if ((channel.receiveMode || "disabled") === "chat-db") {
+    const path = getIMessageDbPath(channel);
+    try {
+      await access(path);
+      checks.push({ name: `imessage-chat-db:${channel.id}`, ok: true, detail: path });
+    } catch (err) {
+      checks.push({
+        name: `imessage-chat-db:${channel.id}`,
+        ok: false,
+        detail: `${path}: ${err instanceof Error ? err.message : String(err)}. Grant Full Disk Access to the terminal/daemon host or disable receive mode.`
+      });
+    }
+  } else {
+    checks.push({ name: `imessage-receive:${channel.id}`, ok: true, detail: "receiveMode=disabled" });
+  }
+  return checks;
+}
+
+// src/lib/doctor.ts
+function isNotFound2(err) {
+  return Boolean(err && typeof err === "object" && "code" in err && err.code === "ENOENT");
+}
+async function privateFileCheck(name, path) {
+  try {
+    const info = await stat2(path);
+    const mode = info.mode & 511;
+    const ok = (mode & 63) === 0;
+    return { name, ok, detail: `${path} mode=${mode.toString(8)}` };
+  } catch (err) {
+    if (isNotFound2(err))
+      return { name, ok: true, detail: `not created yet: ${path}` };
+    return { name, ok: false, detail: `${path}: ${err instanceof Error ? err.message : String(err)}` };
+  }
+}
+async function privateDirCheck(name, path) {
+  try {
+    const info = await stat2(path);
+    const mode = info.mode & 511;
+    const ok = (mode & 63) === 0;
+    return { name, ok, detail: `${path} mode=${mode.toString(8)}` };
+  } catch (err) {
+    if (isNotFound2(err))
+      return { name, ok: true, detail: `not created yet: ${path}` };
+    return { name, ok: false, detail: `${path}: ${err instanceof Error ? err.message : String(err)}` };
+  }
+}
+async function commandExists2(command) {
+  const proc = Bun.spawn(["sh", "-lc", `command -v ${command} >/dev/null 2>&1`], {
+    stdout: "ignore",
+    stderr: "ignore"
+  });
+  return await proc.exited === 0;
+}
+async function doctor(configPath = defaultConfigPath(), statePath = defaultStatePath()) {
+  const checks = [];
+  const config = await loadConfig(configPath);
+  const daemon = await daemonStatus();
+  const paths = daemonPaths();
+  checks.push(await privateFileCheck("config", configPath));
+  checks.push(await privateFileCheck("state", statePath));
+  checks.push(await privateDirCheck("daemon-dir", paths.dir));
+  checks.push(await privateFileCheck("daemon-metadata", paths.metadataFile));
+  checks.push({
+    name: "daemon-status",
+    ok: !daemon.stale,
+    detail: daemon.running ? `running pid=${daemon.pid}` : daemon.stale ? `stale pid=${daemon.pid}` : "not running"
+  });
+  try {
+    const apiBase = telegramApiBaseInfo();
+    checks.push({
+      name: "telegram-api-base",
+      ok: true,
+      detail: apiBase.overridden ? `overridden: ${apiBase.origin}${apiBase.pathname}` : apiBase.origin
+    });
+  } catch (err) {
+    checks.push({
+      name: "telegram-api-base",
+      ok: false,
+      detail: err instanceof Error ? err.message : String(err)
+    });
+  }
+  for (const command of ["bridge", "codewith", "claude", "aicopilot"]) {
+    checks.push({
+      name: `command:${command}`,
+      ok: command === "bridge" ? true : await commandExists2(command),
+      detail: command === "bridge" ? "current package" : undefined
+    });
+  }
+  const telegramChannels2 = Object.values(config.channels).filter((channel) => channel.kind === "telegram");
+  for (const channel of telegramChannels2) {
+    const envName = channel.botTokenEnv || "TELEGRAM_BOT_TOKEN";
+    checks.push({
+      name: `telegram-token:${channel.id}`,
+      ok: Boolean(process.env[envName]),
+      detail: envName
+    });
+    checks.push({
+      name: `telegram-allowlist:${channel.id}`,
+      ok: Boolean(channel.allowAllChats || channel.allowedChatIds?.length),
+      detail: channel.allowAllChats ? "allowAllChats=true" : `${channel.allowedChatIds?.length || 0} chat id(s)`
+    });
+  }
+  for (const route of config.routes) {
+    checks.push({
+      name: `route:${route.id}`,
+      ok: Boolean(config.channels[route.fromChannel] && config.agents[route.toAgent]),
+      detail: `${route.fromChannel} -> ${route.toAgent}`
+    });
+  }
+  const imessageChannels = Object.values(config.channels).filter((channel) => channel.kind === "imessage");
+  for (const channel of imessageChannels) {
+    checks.push(...await diagnoseIMessage(channel));
+  }
+  return { ok: checks.every((check) => check.ok), configPath, checks };
+}
 // src/lib/router.ts
 function matchingRoutes(config, message) {
   const channel = config.channels[message.channelId];
@@ -6461,6 +7333,9 @@ function matchingRoutes(config, message) {
   if (channel?.kind === "telegram" && !telegramChatAllowed(channel, message.chatId)) {
     return [];
   }
+  if (channel?.kind === "imessage" && !imessageHandleAllowed(channel, message.from || (message.chatId?.startsWith("chat:") ? undefined : message.chatId))) {
+    return [];
+  }
   return config.routes.filter((route) => {
     if (route.enabled === false)
       return false;
@@ -6500,15 +7375,359 @@ async function routeMessage(config, message, options = {}) {
       if (options.writeConsole !== false)
         (options.writeConsole || console.log)(responseText);
       deliveredResponse = true;
+    } else if (responseText && channel?.kind === "imessage") {
+      const handle = message.responseTargetId || message.chatId || message.from;
+      const allowedIdentity = message.from || (handle?.startsWith("chat:") ? undefined : handle);
+      if (handle && imessageHandleAllowed(channel, allowedIdentity)) {
+        await sendIMessage(channel, handle, responseText, { allowChatTarget: handle.startsWith("chat:") });
+        deliveredResponse = true;
+      }
     }
     results.push({ route, agent, deliveredResponse });
   }
   return results;
 }
+// src/lib/sessions.ts
+import { randomUUID } from "crypto";
+function nowIso() {
+  return new Date().toISOString();
+}
+function newSessionId() {
+  return `ses_${randomUUID()}`;
+}
+function normalizeConversationId(channel, conversation) {
+  if (conversation.includes(":") && conversation.startsWith(`${channel.kind}:`))
+    return conversation;
+  if (channel.kind === "telegram")
+    return `telegram:${channel.id}:${conversation}`;
+  if (channel.kind === "imessage")
+    return `imessage:${channel.id}:${conversation}`;
+  return `${channel.kind}:${channel.id}:${conversation || "default"}`;
+}
+function messageConversationId(config, message) {
+  const channel = config.channels[message.channelId];
+  if (!channel)
+    return;
+  if (channel.kind === "telegram") {
+    if (!message.chatId)
+      return;
+    return normalizeConversationId(channel, message.threadId ? `${message.chatId}:${message.threadId}` : message.chatId);
+  }
+  if (channel.kind === "imessage") {
+    const conversation = message.chatId || message.from;
+    return conversation ? normalizeConversationId(channel, conversation) : undefined;
+  }
+  return normalizeConversationId(channel, message.chatId || message.from || "default");
+}
+function bindingId(channelId, conversationId) {
+  return `${channelId}::${conversationId}`;
+}
+function ledgerId(message) {
+  return `${message.channelId}::${message.id}`;
+}
+function createBridgeSession(config, state, input) {
+  const { agent, profile } = resolveAgent(config, input.agentId);
+  const timestamp = nowIso();
+  const session = {
+    id: input.id || newSessionId(),
+    agentId: agent.id,
+    profileId: agent.profileId,
+    cwd: input.cwd || agent.cwd || profile?.cwd,
+    title: input.title,
+    status: "active",
+    createdAt: timestamp,
+    updatedAt: timestamp,
+    agentSession: createAgentSessionRef(config, agent.id)
+  };
+  state.sessions[session.id] = session;
+  return session;
+}
+function getBridgeSession(state, sessionId) {
+  const session = state.sessions[sessionId];
+  if (!session)
+    throw new Error(`Session not found: ${sessionId}`);
+  return session;
+}
+function listBridgeSessions(state) {
+  return Object.values(state.sessions).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+}
+function updateBridgeSessionStatus(state, sessionId, status) {
+  const session = getBridgeSession(state, sessionId);
+  if (status === "closed")
+    closeAgentSession(session);
+  session.status = status;
+  session.updatedAt = nowIso();
+  return session;
+}
+function attachBridgeSession(config, state, input) {
+  const channel = config.channels[input.channelId];
+  if (!channel)
+    throw new Error(`Channel not found: ${input.channelId}`);
+  const session = getBridgeSession(state, input.sessionId);
+  if (session.status === "closed")
+    throw new Error(`Cannot attach closed session: ${session.id}`);
+  const conversationId = normalizeConversationId(channel, input.conversation);
+  const id = bindingId(channel.id, conversationId);
+  const existing = state.bindings[id];
+  const timestamp = nowIso();
+  const binding = {
+    id,
+    channelId: channel.id,
+    conversationId,
+    activeSessionId: session.id,
+    defaultSessionId: input.makeDefault ? session.id : existing?.defaultSessionId,
+    createdAt: existing?.createdAt || timestamp,
+    updatedAt: timestamp,
+    authorization: input.authorization || existing?.authorization || (channel.kind === "telegram" ? { chatId: input.conversation.split(":")[0] } : undefined)
+  };
+  state.bindings[id] = binding;
+  return binding;
+}
+function detachBridgeBinding(config, state, channelId, conversation) {
+  const channel = config.channels[channelId];
+  if (!channel)
+    throw new Error(`Channel not found: ${channelId}`);
+  const conversationId = normalizeConversationId(channel, conversation);
+  const id = bindingId(channel.id, conversationId);
+  const existing = state.bindings[id];
+  delete state.bindings[id];
+  return existing;
+}
+function noSessionText(channelId, conversationId) {
+  return [
+    "No bridge session is attached to this conversation.",
+    "Create and attach one locally:",
+    "bridge sessions create --agent <agent-id>",
+    `bridge sessions attach <session-id> --channel ${channelId}${conversationId ? ` --conversation ${conversationId}` : " --conversation <conversation-id>"}`
+  ].join(`
+`);
+}
+async function deliverResponse(config, message, text, options) {
+  const channel = config.channels[message.channelId];
+  if (!text || !channel || channel.enabled === false)
+    return false;
+  if (channel.kind === "telegram" && message.chatId) {
+    if (!telegramChatAllowed(channel, message.chatId))
+      return false;
+    await (options.sendTelegram || sendTelegramMessage)(telegramToken(channel), message.chatId, text);
+    return true;
+  }
+  if (channel.kind === "console") {
+    if (options.writeConsole !== false)
+      (options.writeConsole || console.log)(text);
+    return true;
+  }
+  if (channel.kind === "imessage" && message.chatId) {
+    const allowedIdentity = message.from || (message.chatId.startsWith("chat:") ? undefined : message.chatId);
+    if (!imessageHandleAllowed(channel, allowedIdentity))
+      return false;
+    await sendIMessage(channel, message.responseTargetId || message.chatId, text, { allowChatTarget: Boolean(message.responseTargetId?.startsWith("chat:") || message.chatId.startsWith("chat:")) });
+    return true;
+  }
+  return false;
+}
+async function deliverStoredResponse(config, state, binding, message, entry, options) {
+  const session = getBridgeSession(state, binding.activeSessionId);
+  const responseText = entry.responseText || "";
+  const deliveredResponse = responseText ? await deliverResponse(config, message, responseText, options) : false;
+  completeLedger(entry, "delivered", session.id);
+  entry.deliveredResponse = deliveredResponse;
+  return {
+    kind: "session",
+    session,
+    binding,
+    conversationId: binding.conversationId,
+    deliveredResponse,
+    status: responseText ? "delivered" : "no_output"
+  };
+}
+function channelAuthorized(config, message) {
+  const channel = config.channels[message.channelId];
+  if (!channel || channel.enabled === false)
+    return false;
+  if (channel.kind === "telegram")
+    return telegramChatAllowed(channel, message.chatId);
+  if (channel.kind === "imessage")
+    return imessageHandleAllowed(channel, message.from || (message.chatId?.startsWith("chat:") ? undefined : message.chatId));
+  return true;
+}
+function bindingAuthorized(binding, message) {
+  if (binding.authorization?.chatId && binding.authorization.chatId !== message.chatId)
+    return false;
+  if (binding.authorization?.from && binding.authorization.from !== message.from)
+    return false;
+  return true;
+}
+async function sendBridgeSessionMessage(config, state, sessionId, message, options = {}) {
+  const session = getBridgeSession(state, sessionId);
+  if (session.status === "paused")
+    return { kind: "session", session, status: "paused", message: "Session is paused" };
+  if (session.status === "closed")
+    return { kind: "session", session, status: "closed", message: "Session is closed" };
+  const agent = await sendAgentSessionMessage(config, session, message, { run: options.run });
+  const timestamp = nowIso();
+  session.lastMessageAt = timestamp;
+  session.updatedAt = timestamp;
+  if (session.agentSession)
+    session.agentSession.updatedAt = timestamp;
+  if (agent.timedOut || agent.exitCode !== null && agent.exitCode !== 0) {
+    return {
+      kind: "session",
+      session,
+      agent,
+      deliveredResponse: false,
+      status: "failed",
+      message: agent.stderr.trim() || agent.stdout.trim() || (agent.timedOut ? "Agent timed out" : `Agent exited ${agent.exitCode}`)
+    };
+  }
+  const responseText = agent.stdout.trim();
+  await options.beforeDeliver?.(agent, responseText);
+  const deliveredResponse = responseText ? await deliverResponse(config, message, responseText, options) : false;
+  return {
+    kind: "session",
+    session,
+    agent,
+    deliveredResponse,
+    status: responseText ? "delivered" : "no_output"
+  };
+}
+async function routeSessionMessage(config, state, message, options = {}) {
+  const channel = config.channels[message.channelId];
+  if (!channel || channel.enabled === false) {
+    return { kind: "session", status: "unauthorized", message: `Channel not enabled: ${message.channelId}` };
+  }
+  if (!channelAuthorized(config, message)) {
+    return { kind: "session", status: "unauthorized", message: "Message is not authorized for this channel" };
+  }
+  const conversationId = messageConversationId(config, message);
+  const binding = conversationId ? state.bindings[bindingId(message.channelId, conversationId)] : undefined;
+  if (!binding) {
+    const text = noSessionText(message.channelId, conversationId);
+    if (options.respondOnNoSession !== false)
+      await deliverResponse(config, message, text, options);
+    return { kind: "session", conversationId, status: "no_session", message: text };
+  }
+  if (!bindingAuthorized(binding, message)) {
+    return { kind: "session", binding, conversationId, status: "unauthorized", message: "Message does not match binding authorization" };
+  }
+  const result = await sendBridgeSessionMessage(config, state, binding.activeSessionId, message, options);
+  return { ...result, binding, conversationId };
+}
+function beginLedger(state, message, conversationId) {
+  const id = ledgerId(message);
+  const existing = state.messageLedger[id];
+  if (existing && ["delivered", "skipped", "unauthorized"].includes(existing.status)) {
+    return { entry: existing, shouldProcess: false };
+  }
+  const timestamp = nowIso();
+  const entry = existing || {
+    id,
+    channelId: message.channelId,
+    messageId: message.id,
+    conversationId,
+    status: "processing",
+    attempts: 0,
+    firstSeenAt: timestamp,
+    updatedAt: timestamp
+  };
+  if (entry.status !== "agent_completed")
+    entry.status = "processing";
+  entry.attempts += 1;
+  entry.conversationId = conversationId || entry.conversationId;
+  entry.updatedAt = timestamp;
+  delete entry.error;
+  state.messageLedger[id] = entry;
+  return { entry, shouldProcess: true };
+}
+function completeLedger(entry, status, sessionId, error) {
+  const timestamp = nowIso();
+  entry.status = status;
+  entry.sessionId = sessionId || entry.sessionId;
+  entry.updatedAt = timestamp;
+  if (["delivered", "skipped", "unauthorized"].includes(status))
+    entry.terminalAt = timestamp;
+  if (error)
+    entry.error = error;
+  return entry;
+}
+function recordAgentCompleted(entry, sessionId, agent, responseText) {
+  const timestamp = nowIso();
+  entry.status = "agent_completed";
+  entry.sessionId = sessionId || entry.sessionId;
+  entry.responseText = responseText;
+  entry.agentExitCode = agent.exitCode;
+  entry.agentTimedOut = agent.timedOut;
+  entry.updatedAt = timestamp;
+  delete entry.error;
+  return entry;
+}
+async function dispatchMessageWithSessions(config, state, message, options = {}) {
+  const conversationId = messageConversationId(config, message);
+  const { entry, shouldProcess } = beginLedger(state, message, conversationId);
+  if (!shouldProcess)
+    return { message, ledger: entry };
+  await options.persistState?.(state);
+  try {
+    const binding = conversationId ? state.bindings[bindingId(message.channelId, conversationId)] : undefined;
+    if (binding) {
+      if (!bindingAuthorized(binding, message)) {
+        const session3 = {
+          kind: "session",
+          binding,
+          conversationId,
+          status: "unauthorized",
+          message: "Message does not match binding authorization"
+        };
+        completeLedger(entry, "unauthorized");
+        return { message, session: session3, ledger: entry };
+      }
+      if (entry.status === "agent_completed") {
+        const session3 = await deliverStoredResponse(config, state, binding, message, entry, options);
+        return { message, session: session3, ledger: entry };
+      }
+      const session2 = await routeSessionMessage(config, state, message, {
+        ...options,
+        beforeDeliver: async (agent, responseText) => {
+          recordAgentCompleted(entry, binding.activeSessionId, agent, responseText);
+          await options.persistState?.(state);
+          await options.beforeDeliver?.(agent, responseText);
+        }
+      });
+      if (session2.status === "failed") {
+        completeLedger(entry, "failed", session2.session?.id, session2.message);
+        throw new Error(session2.message || "Agent session failed");
+      }
+      const terminal = session2.status === "unauthorized" ? "unauthorized" : session2.status === "delivered" || session2.status === "no_output" ? "delivered" : "skipped";
+      completeLedger(entry, terminal, session2.session?.id);
+      entry.deliveredResponse = session2.deliveredResponse;
+      return { message, session: session2, ledger: entry };
+    }
+    if (options.fallbackToRoutes) {
+      const routes = await routeMessage(config, message, options);
+      if (routes.length) {
+        completeLedger(entry, "delivered");
+        return { message, routes, ledger: entry };
+      }
+    }
+    const session = await routeSessionMessage(config, state, message, options);
+    const status = session.status === "unauthorized" ? "unauthorized" : "skipped";
+    completeLedger(entry, status, session.session?.id);
+    return { message, session, ledger: entry };
+  } catch (err) {
+    const messageText = err instanceof Error ? err.message : String(err);
+    if (entry.status === "agent_completed") {
+      entry.error = messageText;
+      entry.updatedAt = nowIso();
+    } else {
+      completeLedger(entry, "failed", undefined, messageText);
+    }
+    throw err;
+  }
+}
 // src/cli/index.ts
 function version() {
   try {
-    const pkgPath = join3(dirname3(fileURLToPath(import.meta.url)), "..", "..", "package.json");
+    const pkgPath = join5(dirname4(fileURLToPath(import.meta.url)), "..", "..", "package.json");
     return JSON.parse(readFileSync(pkgPath, "utf-8")).version || "0.0.0";
   } catch {
     return "0.0.0";
@@ -6532,6 +7751,12 @@ function parseEnv(values) {
 function splitCsv(value) {
   return value?.split(",").map((item) => item.trim()).filter(Boolean);
 }
+function parseNonNegativeInt(value, name) {
+  const raw = value || "0";
+  if (!/^\d+$/.test(raw))
+    throw new Error(`${name} must be a non-negative integer`);
+  return Number.parseInt(raw, 10);
+}
 function printList(items) {
   const rows = Array.isArray(items) ? items : Object.values(items);
   if (!rows.length) {
@@ -6543,35 +7768,112 @@ function printList(items) {
 }
 async function runServe(options) {
   const config2 = await loadConfig(options.config);
-  const telegramChannels = Object.values(config2.channels).filter((channel) => channel.kind === "telegram" && channel.enabled !== false);
-  const intervalMs = Number.parseInt(options.interval || "1000", 10);
-  if (!Number.isInteger(intervalMs) || intervalMs < 0)
-    throw new Error("--interval must be a non-negative integer");
-  if (!telegramChannels.length)
-    throw new Error("No enabled Telegram channels configured");
+  const telegramChannels2 = Object.values(config2.channels).filter((channel) => channel.kind === "telegram" && channel.enabled !== false);
+  const imessageChannels = Object.values(config2.channels).filter((channel) => channel.kind === "imessage" && channel.enabled !== false && channel.receiveMode === "chat-db");
+  const intervalMs = parseNonNegativeInt(options.interval || "1000", "--interval");
+  if (!telegramChannels2.length && !imessageChannels.length)
+    throw new Error("No enabled pollable channels configured");
   const statePath = options.state || defaultStatePath();
-  const state2 = await loadState(statePath);
-  while (true) {
-    for (const channel of telegramChannels) {
-      const updates = await getTelegramUpdates(telegramToken(channel), {
-        offset: state2.telegramOffsets[channel.id],
-        timeoutSeconds: channel.pollTimeoutSeconds || 20
-      });
-      for (const update of updates) {
-        state2.telegramOffsets[channel.id] = update.update_id + 1;
-        await saveState(state2, statePath);
-        const message = telegramUpdateToMessage(channel.id, update);
-        if (!message)
-          continue;
-        const results = await routeMessage(config2, message, { writeConsole: options.json ? false : undefined });
-        if (options.json)
-          asJson({ message, results });
+  const errorCounts = new Map;
+  let stopping = false;
+  const stop = () => {
+    stopping = true;
+  };
+  process.once("SIGTERM", stop);
+  process.once("SIGINT", stop);
+  while (!stopping) {
+    for (const channel of telegramChannels2) {
+      try {
+        const pollState = await loadState(statePath);
+        const updates = await getTelegramUpdates(telegramToken(channel), {
+          offset: pollState.telegramOffsets[channel.id],
+          timeoutSeconds: channel.pollTimeoutSeconds || 20
+        });
+        errorCounts.delete(channel.id);
+        for (const update of updates) {
+          const state2 = await loadState(statePath);
+          const message = telegramUpdateToMessage(channel.id, update);
+          if (message) {
+            try {
+              const results = await dispatchMessageWithSessions(config2, state2, message, {
+                writeConsole: options.json ? false : undefined,
+                fallbackToRoutes: true,
+                persistState: async (nextState) => saveState(nextState, statePath)
+              });
+              if (results.ledger?.status === "failed" || results.ledger?.status === "processing" || results.ledger?.status === "agent_completed") {
+                await saveState(state2, statePath);
+                throw new Error(results.ledger.error || `Message ${message.id} did not reach a terminal state`);
+              }
+              state2.telegramOffsets[channel.id] = update.update_id + 1;
+              await saveState(state2, statePath);
+              if (options.json)
+                asJson(results);
+            } catch (err) {
+              await saveState(state2, statePath);
+              throw err;
+            }
+          } else {
+            state2.telegramOffsets[channel.id] = update.update_id + 1;
+            await saveState(state2, statePath);
+          }
+        }
+      } catch (err) {
+        if (options.once)
+          throw err;
+        const count = (errorCounts.get(channel.id) || 0) + 1;
+        errorCounts.set(channel.id, count);
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`[bridge] ${channel.id} poll failed (${count}): ${message}`);
+        await Bun.sleep(Math.min(30000, Math.max(1000, intervalMs * Math.min(count, 30))));
+      }
+    }
+    for (const channel of imessageChannels) {
+      try {
+        const pollState = await loadState(statePath);
+        const cursorKey = `imessage:${channel.id}`;
+        const rows = getIMessageMessages(channel, {
+          afterRowId: Number(pollState.cursors[cursorKey] || 0),
+          limit: channel.pollLimit || 50
+        });
+        errorCounts.delete(channel.id);
+        for (const row of rows) {
+          const state2 = await loadState(statePath);
+          const message = imessageRowToMessage(channel.id, row);
+          try {
+            const results = await dispatchMessageWithSessions(config2, state2, message, {
+              writeConsole: options.json ? false : undefined,
+              fallbackToRoutes: true,
+              persistState: async (nextState) => saveState(nextState, statePath)
+            });
+            if (results.ledger?.status === "failed" || results.ledger?.status === "processing" || results.ledger?.status === "agent_completed") {
+              await saveState(state2, statePath);
+              throw new Error(results.ledger.error || `Message ${message.id} did not reach a terminal state`);
+            }
+            state2.cursors[cursorKey] = row.rowId;
+            await saveState(state2, statePath);
+            if (options.json)
+              asJson(results);
+          } catch (err) {
+            await saveState(state2, statePath);
+            throw err;
+          }
+        }
+      } catch (err) {
+        if (options.once)
+          throw err;
+        const count = (errorCounts.get(channel.id) || 0) + 1;
+        errorCounts.set(channel.id, count);
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`[bridge] ${channel.id} poll failed (${count}): ${message}`);
+        await Bun.sleep(Math.min(30000, Math.max(1000, intervalMs * Math.min(count, 30))));
       }
     }
     if (options.once)
       break;
     await Bun.sleep(intervalMs);
   }
+  process.removeListener("SIGTERM", stop);
+  process.removeListener("SIGINT", stop);
 }
 var program2 = new Command;
 program2.name("bridge").description("Agent messaging bridge for Telegram and other channels").version(version());
@@ -6622,6 +7924,27 @@ channels.command("add-console").argument("<id>").description("Add a console chan
   const config2 = await upsertChannel({ id, kind: "console", enabled: true }, options.config);
   options.json ? asJson(config2.channels[id]) : console.log(`Added console channel ${id}`);
 });
+channels.command("add-imessage").argument("<id>").description("Add a local macOS iMessage channel").option("--default-handle <handle>", "default iMessage handle for bridge send").option("--allowed-handles <handles>", "comma-separated allowed handles").option("--allow-all-handles", "explicitly allow every local iMessage handle").option("--account <account>", "Messages account selector for multi-account Macs").option("--service-name <name>", "Messages service name", "iMessage").option("--receive", "enable local Messages chat.db polling").option("--chat-db-path <path>", "override Messages chat.db path").option("--poll-limit <n>", "maximum rows per poll").option("-c, --config <path>", "config path", defaultConfigPath()).option("--json", "output JSON").action(async (id, options) => {
+  const allowedHandles = splitCsv(options.allowedHandles);
+  if (!allowedHandles?.length && !options.allowAllHandles) {
+    throw new Error("iMessage channels require --allowed-handles or explicit --allow-all-handles");
+  }
+  const pollLimit = options.pollLimit ? Number.parseInt(options.pollLimit, 10) : undefined;
+  const config2 = await upsertChannel({
+    id,
+    kind: "imessage",
+    enabled: true,
+    defaultHandle: options.defaultHandle,
+    allowedHandles,
+    allowAllHandles: Boolean(options.allowAllHandles),
+    account: options.account,
+    serviceName: options.serviceName,
+    receiveMode: options.receive ? "chat-db" : "disabled",
+    chatDbPath: options.chatDbPath,
+    pollLimit
+  }, options.config);
+  options.json ? asJson(config2.channels[id]) : console.log(`Added imessage channel ${id}`);
+});
 var profiles = program2.command("profiles").description("Manage reusable agent profiles");
 profiles.command("list").option("-c, --config <path>", "config path", defaultConfigPath()).option("--json", "output JSON").action(async (options) => {
   const config2 = await loadConfig(options.config);
@@ -6678,14 +8001,103 @@ routes.command("add").argument("<id>").requiredOption("--from <channel>", "sourc
   }, options.config);
   options.json ? asJson(config2.routes.find((route) => route.id === id)) : console.log(`Added route ${id}`);
 });
+var sessions2 = program2.command("sessions").description("Manage durable bridge sessions and channel bindings");
+sessions2.command("list").description("List bridge sessions").option("--state <path>", "state path", defaultStatePath()).option("--json", "output JSON").action(async (options) => {
+  const state2 = await loadState(options.state);
+  const items = listBridgeSessions(state2);
+  options.json ? asJson(items) : printList(items);
+});
+sessions2.command("show").argument("<id>").description("Show one bridge session").option("--state <path>", "state path", defaultStatePath()).option("--json", "output JSON").action(async (id, options) => {
+  const state2 = await loadState(options.state);
+  const session = getBridgeSession(state2, id);
+  options.json ? asJson(session) : console.log(JSON.stringify(session, null, 2));
+});
+sessions2.command("create").description("Create a bridge-owned session for an agent").requiredOption("--agent <id>", "agent id").option("--id <id>", "explicit session id").option("--title <text>", "session title").option("--cwd <path>", "session working directory override").option("-c, --config <path>", "config path", defaultConfigPath()).option("--state <path>", "state path", defaultStatePath()).option("--json", "output JSON").action(async (options) => {
+  const config2 = await loadConfig(options.config);
+  const state2 = await loadState(options.state);
+  const session = createBridgeSession(config2, state2, {
+    id: options.id,
+    agentId: options.agent,
+    title: options.title,
+    cwd: options.cwd
+  });
+  await saveState(state2, options.state);
+  options.json ? asJson(session) : console.log(session.id);
+});
+async function attachSessionAction(sessionId, options) {
+  const config2 = await loadConfig(options.config);
+  const state2 = await loadState(options.state);
+  const binding = attachBridgeSession(config2, state2, {
+    sessionId,
+    channelId: options.channel,
+    conversation: options.conversation,
+    makeDefault: Boolean(options.default)
+  });
+  await saveState(state2, options.state);
+  options.json ? asJson(binding) : console.log(binding.id);
+}
+sessions2.command("attach").argument("<id>").description("Attach a session to a channel conversation").requiredOption("--channel <id>", "channel id").requiredOption("--conversation <id>", "external conversation id, such as a Telegram chat id").option("--default", "also make this the default session for the conversation").option("-c, --config <path>", "config path", defaultConfigPath()).option("--state <path>", "state path", defaultStatePath()).option("--json", "output JSON").action(attachSessionAction);
+sessions2.command("use").argument("<id>").description("Set the active session for a channel conversation").requiredOption("--channel <id>", "channel id").requiredOption("--conversation <id>", "external conversation id, such as a Telegram chat id").option("-c, --config <path>", "config path", defaultConfigPath()).option("--state <path>", "state path", defaultStatePath()).option("--json", "output JSON").action(async (id, options) => attachSessionAction(id, { ...options, default: true }));
+sessions2.command("detach").description("Detach the active session from a channel conversation").requiredOption("--channel <id>", "channel id").requiredOption("--conversation <id>", "external conversation id, such as a Telegram chat id").option("-c, --config <path>", "config path", defaultConfigPath()).option("--state <path>", "state path", defaultStatePath()).option("--json", "output JSON").action(async (options) => {
+  const config2 = await loadConfig(options.config);
+  const state2 = await loadState(options.state);
+  const binding = detachBridgeBinding(config2, state2, options.channel, options.conversation);
+  await saveState(state2, options.state);
+  options.json ? asJson(binding || null) : console.log(binding ? `detached ${binding.id}` : "No binding.");
+});
+for (const status of ["pause", "resume", "close"]) {
+  const nextStatus = status === "pause" ? "paused" : status === "resume" ? "active" : "closed";
+  sessions2.command(status).argument("<id>").description(`${status} a bridge session`).option("--state <path>", "state path", defaultStatePath()).option("--json", "output JSON").action(async (id, options) => {
+    const state2 = await loadState(options.state);
+    const session = updateBridgeSessionStatus(state2, id, nextStatus);
+    await saveState(state2, options.state);
+    options.json ? asJson(session) : console.log(`${session.id} ${session.status}`);
+  });
+}
+sessions2.command("send").argument("<id>").argument("<text...>").description("Send one message directly to a bridge session").option("-c, --config <path>", "config path", defaultConfigPath()).option("--state <path>", "state path", defaultStatePath()).option("--json", "output JSON").action(async (id, textParts, options) => {
+  const config2 = await loadConfig(options.config);
+  const state2 = await loadState(options.state);
+  const message = {
+    id: `cli:${Date.now()}`,
+    channelId: "cli",
+    text: textParts.join(" "),
+    receivedAt: new Date().toISOString()
+  };
+  const result = await sendBridgeSessionMessage(config2, state2, id, message, { writeConsole: false });
+  await saveState(state2, options.state);
+  if (options.json)
+    asJson(result);
+  else
+    process.stdout.write(result.agent?.stdout || result.agent?.stderr || result.message || "");
+  process.exitCode = result.agent?.exitCode ?? 0;
+});
+sessions2.command("route-message").description("Route one synthetic message through session bindings").requiredOption("--channel <id>", "source channel id").requiredOption("--text <text>", "message text").option("--chat-id <id>", "chat id").option("--from <from>", "sender").option("--fallback-routes", "fall back to compatibility routes when no session is bound").option("-c, --config <path>", "config path", defaultConfigPath()).option("--state <path>", "state path", defaultStatePath()).option("--json", "output JSON").action(async (options) => {
+  const config2 = await loadConfig(options.config);
+  const state2 = await loadState(options.state);
+  const result = await dispatchMessageWithSessions(config2, state2, {
+    id: `cli:${Date.now()}`,
+    channelId: options.channel,
+    text: options.text,
+    chatId: options.chatId,
+    from: options.from,
+    receivedAt: new Date().toISOString()
+  }, {
+    writeConsole: options.json ? false : undefined,
+    fallbackToRoutes: Boolean(options.fallbackRoutes),
+    persistState: async (nextState) => saveState(nextState, options.state)
+  });
+  await saveState(state2, options.state);
+  options.json ? asJson(result) : printList(result.session ? [result.session] : result.routes || []);
+});
 program2.command("send").argument("<channel>").argument("[chatId]").argument("[text...]").description("Send a message through a channel").option("-c, --config <path>", "config path", defaultConfigPath()).option("--json", "output JSON").action(async (channelId, chatId, textParts, options) => {
   const config2 = await loadConfig(options.config);
   const channel = config2.channels[channelId];
   if (!channel)
     throw new Error(`Channel not found: ${channelId}`);
   let targetChat = chatId;
-  let text = textParts.join(" ");
-  if (channel.kind !== "telegram" && !text && targetChat) {
+  const textArgParts = textParts;
+  let text = textArgParts.join(" ");
+  if (channel.kind === "console" && !text && targetChat) {
     text = targetChat;
     targetChat = undefined;
   }
@@ -6707,6 +8119,26 @@ program2.command("send").argument("<channel>").argument("[chatId]").argument("[t
       console.log(text);
     return;
   }
+  if (channel.kind === "imessage") {
+    if (!text && targetChat) {
+      const looksLikeHandle = targetChat.startsWith("+") || targetChat.includes("@") || imessageHandleAllowed(channel, targetChat);
+      if (looksLikeHandle)
+        throw new Error("message text is required when an iMessage handle is provided");
+      text = targetChat;
+      targetChat = undefined;
+    }
+    targetChat = targetChat || channel.defaultHandle;
+    if (!targetChat)
+      throw new Error("chatId/handle argument or channel.defaultHandle is required");
+    if (!text)
+      throw new Error("message text is required");
+    if (!imessageHandleAllowed(channel, targetChat)) {
+      throw new Error(`iMessage handle ${targetChat} is not allowed for channel ${channel.id}`);
+    }
+    const result = await sendIMessage(channel, targetChat, text);
+    options.json ? asJson(result) : console.log("sent");
+    return;
+  }
   throw new Error(`Sending through ${channel.kind} is not implemented yet`);
 });
 program2.command("ask").argument("<agent>").argument("<text...>").description("Run one agent directly").option("-c, --config <path>", "config path", defaultConfigPath()).option("--json", "output JSON").action(async (agentId, textParts, options) => {
@@ -6722,6 +8154,84 @@ program2.command("ask").argument("<agent>").argument("<text...>").description("R
   process.exitCode = result.exitCode ?? 1;
 });
 program2.command("serve").description("Poll configured channels and route messages to agents").option("--once", "poll once and exit").option("--interval <ms>", "delay between polls", "1000").option("-c, --config <path>", "config path", defaultConfigPath()).option("--state <path>", "state path", defaultStatePath()).option("--json", "emit routed message JSON").action(runServe);
+var daemon2 = program2.command("daemon").description("Manage the bridge background daemon");
+daemon2.command("status").description("Show daemon status").option("--supervisor <type>", "process, launchd, systemd, or auto", "process").option("--daemon-dir <path>", "daemon metadata/log directory").option("--json", "output JSON").action(async (options) => {
+  const status = await daemonStatus({ supervisor: options.supervisor, daemonDir: options.daemonDir });
+  if (options.json)
+    asJson(status);
+  else {
+    console.log(`${status.running ? "running" : status.stale ? "stale" : "stopped"} ${status.supervisor}${status.pid ? ` pid=${status.pid}` : ""}`);
+    console.log(`daemonDir=${status.paths.dir}`);
+    console.log(`stdout=${status.paths.stdoutLog}`);
+    console.log(`stderr=${status.paths.stderrLog}`);
+    if (status.telegramApiBase.error) {
+      console.log(`telegramApiBaseError=${status.telegramApiBase.error}`);
+    } else if (status.telegramApiBase.overridden) {
+      console.log(`telegramApiBase=${status.telegramApiBase.origin}${status.telegramApiBase.pathname}`);
+    }
+  }
+});
+daemon2.command("start").description("Start bridge serve in the background").option("--supervisor <type>", "process, launchd, systemd, or auto", "process").option("--daemon-dir <path>", "daemon metadata/log directory").option("--interval <ms>", "delay between polls", "1000").option("-c, --config <path>", "config path", defaultConfigPath()).option("--state <path>", "state path", defaultStatePath()).option("--serve-json", "emit routed message JSON to daemon stdout log").option("--json", "output JSON").action(async (options) => {
+  const intervalMs = parseNonNegativeInt(options.interval, "--interval");
+  const supervisor = options.supervisor;
+  const result = supervisor === "process" ? await startProcessDaemon({ daemonDir: options.daemonDir, configPath: options.config, statePath: options.state, intervalMs, serveJson: options.serveJson }) : await startInstalledDaemon({ supervisor, daemonDir: options.daemonDir, configPath: options.config, statePath: options.state, intervalMs, serveJson: options.serveJson });
+  options.json ? asJson(result) : console.log("started");
+});
+daemon2.command("stop").description("Stop the bridge daemon").option("--supervisor <type>", "process, launchd, systemd, or auto", "process").option("--daemon-dir <path>", "daemon metadata/log directory").option("--timeout-ms <ms>", "graceful stop timeout", "5000").option("--force", "force kill after timeout").option("--json", "output JSON").action(async (options) => {
+  const timeoutMs = parseNonNegativeInt(options.timeoutMs, "--timeout-ms");
+  const result = options.supervisor === "process" ? await stopProcessDaemon({ daemonDir: options.daemonDir, timeoutMs, force: options.force }) : await stopInstalledDaemon({ supervisor: options.supervisor, daemonDir: options.daemonDir, timeoutMs, force: options.force });
+  options.json ? asJson(result || { stopped: true }) : console.log("stopped");
+});
+daemon2.command("restart").description("Restart the bridge daemon").option("--supervisor <type>", "process, launchd, systemd, or auto", "process").option("--daemon-dir <path>", "daemon metadata/log directory").option("--interval <ms>", "delay between polls").option("-c, --config <path>", "config path").option("--state <path>", "state path").option("--serve-json", "emit routed message JSON to daemon stdout log").option("--timeout-ms <ms>", "graceful stop timeout", "5000").option("--force", "force kill after timeout").option("--json", "output JSON").action(async (options) => {
+  const restartOptions = {
+    supervisor: options.supervisor,
+    daemonDir: options.daemonDir,
+    configPath: options.config,
+    statePath: options.state,
+    intervalMs: options.interval ? parseNonNegativeInt(options.interval, "--interval") : undefined,
+    serveJson: options.serveJson,
+    timeoutMs: parseNonNegativeInt(options.timeoutMs, "--timeout-ms"),
+    force: options.force
+  };
+  const result = options.supervisor === "process" ? await restartProcessDaemon(restartOptions) : await restartInstalledDaemon(restartOptions);
+  options.json ? asJson(result) : console.log("restarted");
+});
+daemon2.command("logs").description("Print daemon logs").option("--daemon-dir <path>", "daemon metadata/log directory").option("--lines <n>", "number of lines", "100").option("--follow", "follow logs").option("--json", "output JSON").action(async (options) => {
+  const lines = parseNonNegativeInt(options.lines, "--lines") || 100;
+  if (options.follow) {
+    const paths2 = daemonPaths(options.daemonDir);
+    const tail = Bun.spawn(["tail", "-n", String(lines), "-f", paths2.stdoutLog, paths2.stderrLog], {
+      stdout: "inherit",
+      stderr: "inherit"
+    });
+    await tail.exited;
+    return;
+  }
+  const logs = await daemonLogs({ daemonDir: options.daemonDir, lines });
+  if (options.json)
+    asJson(logs);
+  else {
+    if (logs.stdout)
+      console.log(logs.stdout);
+    if (logs.stderr)
+      console.error(logs.stderr);
+  }
+});
+daemon2.command("install").description("Write launchd or systemd user supervisor files").option("--supervisor <type>", "launchd, systemd, or auto", "auto").option("--daemon-dir <path>", "daemon metadata/log directory").option("--interval <ms>", "delay between polls", "1000").option("-c, --config <path>", "config path", defaultConfigPath()).option("--state <path>", "state path", defaultStatePath()).option("--serve-json", "emit routed message JSON to daemon stdout log").option("--json", "output JSON").action(async (options) => {
+  const result = await installDaemon({
+    supervisor: options.supervisor,
+    daemonDir: options.daemonDir,
+    configPath: options.config,
+    statePath: options.state,
+    intervalMs: parseNonNegativeInt(options.interval, "--interval"),
+    serveJson: options.serveJson
+  });
+  options.json ? asJson(result) : console.log(`installed ${result.supervisor}: ${result.path}`);
+});
+daemon2.command("uninstall").description("Remove launchd/systemd supervisor files or process metadata").option("--supervisor <type>", "process, launchd, systemd, or auto", "auto").option("--daemon-dir <path>", "daemon metadata/log directory").option("--json", "output JSON").action(async (options) => {
+  const result = await uninstallDaemon({ supervisor: options.supervisor, daemonDir: options.daemonDir });
+  options.json ? asJson(result) : console.log(`removed ${result.removed.join(", ")}`);
+});
 program2.command("route-message").description("Route one synthetic message; useful for tests and MCP-style probes").requiredOption("--channel <id>", "source channel id").requiredOption("--text <text>", "message text").option("--chat-id <id>", "chat id").option("--from <from>", "sender").option("-c, --config <path>", "config path", defaultConfigPath()).option("--json", "output JSON").action(async (options) => {
   const config2 = await loadConfig(options.config);
   const result = await routeMessage(config2, {