@mrciphersmith/keryx 0.3.48 → 0.3.49

package/dist/cli.js

@@ -20094,7 +20094,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@mrciphersmith/keryx",
-    version: "0.3.48",
+    version: "0.3.49",
     description: "Version-controlled project context for AI coding agents: code graph, architecture wiki, project memory, relevant tests, quality signals, and task flows.",
     private: false,
     publishConfig: {
@@ -99482,6 +99482,12 @@ var init_help_groups = __esm(() => {
       group: "Automation",
       summary: "Drive this session from a Telegram topic: send lines, get replies, answer approvals. Off by default; [name|off|status]."
     },
+    {
+      kind: "slash",
+      name: "/channels",
+      group: "Automation",
+      summary: "Connect, test or disconnect Telegram for this machine: bot token, one-time code, group. [status]."
+    },
     {
       kind: "cli",
       name: "acp",
@@ -102043,6 +102049,9 @@ function ensureHost(otui, chrome) {
     if (!state.open || state.input === undefined) {
       return;
     }
+    if (state.input.ownsKeys?.() === true) {
+      return;
+    }
     const focused = r.currentFocusedRenderable;
     const inBody = focused !== null && containsNode(state.scroll, focused);
     if (key.name === "escape") {
@@ -108724,6 +108733,9 @@ var init_serve_config = __esm(() => {
 function remoteRoutePath(route) {
   return `${REMOTE_API_PREFIX}/${route}`;
 }
+function channelsRoutePath(route) {
+  return `${REMOTE_API_PREFIX}/${route}`;
+}
 function isSessionId(value) {
   return typeof value === "string" && SESSION_ID_PATTERN.test(value);
 }
@@ -108786,7 +108798,7 @@ class SseParser {
     return frames;
   }
 }
-var REMOTE_API_PREFIX = "/v1/remote", REMOTE_SCHEMA_VERSION = "1.0.0", REMOTE_ROUTE_METHODS, MAX_REMOTE_BODY_BYTES, MAX_PROJECT_CHARS = 256, MAX_APPROVAL_PROMPT_CHARS = 3000, MAX_KEYBOARD_ROWS = 8, MAX_KEYBOARD_BUTTONS_PER_ROW = 8, MAX_BUTTON_TEXT_CHARS = 64, MAX_CALLBACK_DATA_BYTES = 64, DEFAULT_APPROVAL_TIMEOUT_MS, MAX_APPROVAL_TIMEOUT_MS, MIN_APPROVAL_TIMEOUT_MS = 100, DEFAULT_KEEPALIVE_MS = 15000, DEFAULT_ACK_TIMEOUT_MS = 30000, SESSION_ID_PATTERN, APPROVAL_CALLBACK_PATTERN, RESERVED_CALLBACK_PREFIX = "ap:", SSE_KEEPALIVE_FRAME = `: keepalive
+var REMOTE_API_PREFIX = "/v1/remote", REMOTE_SCHEMA_VERSION = "1.0.0", REMOTE_ROUTE_METHODS, CHANNELS_ROUTE_METHODS, MAX_REMOTE_BODY_BYTES, MAX_PROJECT_CHARS = 256, MAX_APPROVAL_PROMPT_CHARS = 3000, MAX_KEYBOARD_ROWS = 8, MAX_KEYBOARD_BUTTONS_PER_ROW = 8, MAX_BUTTON_TEXT_CHARS = 64, MAX_CALLBACK_DATA_BYTES = 64, DEFAULT_APPROVAL_TIMEOUT_MS, MAX_APPROVAL_TIMEOUT_MS, MIN_APPROVAL_TIMEOUT_MS = 100, DEFAULT_KEEPALIVE_MS = 15000, DEFAULT_ACK_TIMEOUT_MS = 30000, SESSION_ID_PATTERN, APPROVAL_CALLBACK_PATTERN, RESERVED_CALLBACK_PREFIX = "ap:", SSE_KEEPALIVE_FRAME = `: keepalive
 
 `;
 var init_protocol2 = __esm(() => {
@@ -108799,6 +108811,15 @@ var init_protocol2 = __esm(() => {
     ack: "POST",
     stream: "GET"
   };
+  CHANNELS_ROUTE_METHODS = {
+    "channels-status": "GET",
+    "channels-pair": "POST",
+    "channels-pairing": "GET",
+    "channels-cancel": "POST",
+    "channels-reload": "POST",
+    "channels-test": "POST",
+    "channels-disconnect": "POST"
+  };
   MAX_REMOTE_BODY_BYTES = 64 * 1024;
   DEFAULT_APPROVAL_TIMEOUT_MS = 5 * 60000;
   MAX_APPROVAL_TIMEOUT_MS = 60 * 60000;
@@ -109803,6 +109824,1457 @@ var init_shell_bridge = __esm(() => {
   init_protocol2();
 });
 
+// src/remote/config.ts
+import { statSync as statSync17, unlinkSync as unlinkSync6 } from "fs";
+function isSafeInt(value) {
+  return typeof value === "number" && Number.isSafeInteger(value);
+}
+function parseRemoteConfig(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return { ok: false, reason: "remote config must be a JSON object" };
+  }
+  const doc = value;
+  for (const key of Object.keys(doc)) {
+    if (!CONFIG_KEYS2.has(key)) {
+      const shown = /^[A-Za-z_][A-Za-z0-9_]{0,30}$/.test(key) ? key : "<not shown>";
+      return { ok: false, reason: `remote config has an unknown key "${shown}" (the schema is closed)` };
+    }
+  }
+  if (doc.schemaVersion !== REMOTE_CONFIG_SCHEMA_VERSION) {
+    return { ok: false, reason: `remote config schemaVersion must be ${REMOTE_CONFIG_SCHEMA_VERSION}` };
+  }
+  if (!isSafeInt(doc.chatId) || doc.chatId === 0) {
+    return { ok: false, reason: "remote config chatId must be a non-zero integer (the supergroup id)" };
+  }
+  const ids = doc.allowedUserIds;
+  if (!Array.isArray(ids) || ids.length === 0 || !ids.every((id) => isSafeInt(id) && id > 0)) {
+    return { ok: false, reason: "remote config allowedUserIds must be a non-empty array of positive integers" };
+  }
+  const timeout = (key, fallback) => {
+    const raw = doc[key];
+    if (raw === undefined) {
+      return { ok: true, value: fallback };
+    }
+    if (!isSafeInt(raw) || raw < 1 || raw > MAX_TIMEOUT_MS3) {
+      return { ok: false, reason: `remote config ${key} must be an integer from 1 to ${MAX_TIMEOUT_MS3} (milliseconds)` };
+    }
+    return { ok: true, value: raw };
+  };
+  const orphan = timeout("orphanMs", DEFAULT_ORPHAN_MS);
+  if (!orphan.ok) {
+    return orphan;
+  }
+  const run = timeout("runTimeoutMs", DEFAULT_RUN_TIMEOUT_MS);
+  if (!run.ok) {
+    return run;
+  }
+  return {
+    ok: true,
+    value: {
+      schemaVersion: REMOTE_CONFIG_SCHEMA_VERSION,
+      chatId: doc.chatId,
+      allowedUserIds: [...new Set(ids)],
+      orphanMs: orphan.value,
+      runTimeoutMs: run.value
+    }
+  };
+}
+function loadRemoteConfig(dir) {
+  const file = remoteConfigPath(dir);
+  const read = readConfigFile(file);
+  if (!read.ok) {
+    return {
+      ok: false,
+      reason: read.reason === "absent" ? `no remote-control config at ${file}; create it with chatId and allowedUserIds` : `remote-control config at ${file} cannot be read (${read.reason})`
+    };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(read.text);
+  } catch {
+    return { ok: false, reason: `remote-control config at ${file} is not valid JSON` };
+  }
+  return parseRemoteConfig(parsed);
+}
+function saveRemoteConfig(config, dir) {
+  const checked = parseRemoteConfig(config);
+  if (!checked.ok) {
+    return checked;
+  }
+  ensureRemoteDir(dir);
+  writeOwnerOnlyFileAtomic(remoteConfigPath(dir), `${JSON.stringify(checked.value, null, 2)}
+`);
+  return checked;
+}
+function loadBotToken(dir) {
+  const file = botTokenPath(dir);
+  let mode;
+  try {
+    const stats = statSync17(file);
+    if (!stats.isFile()) {
+      return { ok: false, reason: `bot token path ${file} is not a regular file` };
+    }
+    mode = stats.mode & 511;
+  } catch {
+    return {
+      ok: false,
+      reason: `no bot token file at ${file}; put the token on one line in it and run: chmod 600 ${file}`
+    };
+  }
+  if (process.platform !== "win32" && (mode & 63) !== 0) {
+    return {
+      ok: false,
+      reason: `bot token file ${file} is accessible to other users (mode ${mode.toString(8)}); run: chmod 600 ${file}`
+    };
+  }
+  const read = readConfigFile(file);
+  if (!read.ok) {
+    return { ok: false, reason: `bot token file ${file} cannot be read (${read.reason})` };
+  }
+  const token = read.text.trim();
+  if (!TOKEN_SHAPE2.test(token)) {
+    return {
+      ok: false,
+      reason: `bot token file ${file} does not hold a bot token (expected <digits>:<secret> on a single line)`
+    };
+  }
+  return { ok: true, value: token };
+}
+function saveBotToken(token, dir) {
+  const trimmed = token.trim();
+  if (!TOKEN_SHAPE2.test(trimmed)) {
+    return { ok: false, reason: "that does not look like a bot token (expected <digits>:<secret>, as BotFather gives it)" };
+  }
+  const file = botTokenPath(dir);
+  try {
+    ensureRemoteDir(dir);
+    writeOwnerOnlyFileAtomic(file, `${trimmed}
+`);
+  } catch {
+    return { ok: false, reason: `could not write the bot token file at ${file}` };
+  }
+  return { ok: true, value: true };
+}
+function removeFile2(file) {
+  try {
+    unlinkSync6(file);
+    return true;
+  } catch (error) {
+    return error.code === "ENOENT";
+  }
+}
+function removeBotToken(dir) {
+  return removeFile2(botTokenPath(dir));
+}
+function removeRemoteConfig(dir) {
+  return removeFile2(remoteConfigPath(dir));
+}
+var REMOTE_CONFIG_SCHEMA_VERSION = 1, DEFAULT_ORPHAN_MS, DEFAULT_RUN_TIMEOUT_MS, MAX_TIMEOUT_MS3, CONFIG_KEYS2, TOKEN_SHAPE2;
+var init_config10 = __esm(() => {
+  init_config_dir();
+  init_paths4();
+  DEFAULT_ORPHAN_MS = 10 * 60000;
+  DEFAULT_RUN_TIMEOUT_MS = 30 * 60000;
+  MAX_TIMEOUT_MS3 = 7 * 24 * 60 * 60000;
+  CONFIG_KEYS2 = new Set(["schemaVersion", "chatId", "allowedUserIds", "orphanMs", "runTimeoutMs"]);
+  TOKEN_SHAPE2 = /^\d{5,}:[A-Za-z0-9_-]{20,}$/;
+});
+
+// src/remote/channels-client.ts
+function fileExists(file) {
+  const read = readConfigFile(file);
+  return read.ok || read.reason !== "absent";
+}
+function isObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function plural2(count, one, many) {
+  return `${count} ${count === 1 ? one : many}`;
+}
+
+class ChannelsClient {
+  options;
+  fetchImpl;
+  requestTimeoutMs;
+  isAlive;
+  constructor(options = {}) {
+    this.options = options;
+    this.fetchImpl = options.fetchImpl ?? fetch;
+    this.requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS2;
+    this.isAlive = options.isAlive ?? ownProcessIsAlive;
+  }
+  localFiles() {
+    return {
+      tokenFile: fileExists(botTokenPath(this.options.dir)),
+      configFile: fileExists(remoteConfigPath(this.options.dir))
+    };
+  }
+  status() {
+    return this.call("channels-status", (body) => {
+      const telegram = body.telegram;
+      return typeof body.machine === "string" && isObject2(telegram) && typeof telegram.state === "string" && typeof telegram.sessions === "number";
+    });
+  }
+  async startPairing(token) {
+    const reachable = this.reachable();
+    if (!reachable.ok) {
+      return reachable;
+    }
+    const file = botTokenPath(this.options.dir);
+    const before = readConfigFile(file);
+    const saved = saveBotToken(token, this.options.dir);
+    if (!saved.ok) {
+      return { ok: false, code: "invalid", reason: saved.reason };
+    }
+    const result = await this.call("channels-pair", isPairing);
+    if (!result.ok) {
+      this.restore(file, before);
+    }
+    return result;
+  }
+  pairingStatus() {
+    return this.call("channels-pairing", isPairing);
+  }
+  async cancelPairing() {
+    const result = await this.call("channels-cancel", (body) => typeof body.cancelled === "boolean");
+    if (!fileExists(remoteConfigPath(this.options.dir))) {
+      removeBotToken(this.options.dir);
+    }
+    return result;
+  }
+  async connectFinish(ids) {
+    const reachable = this.reachable();
+    if (!reachable.ok) {
+      this.dropUnusedToken();
+      return reachable;
+    }
+    const configFile = remoteConfigPath(this.options.dir);
+    const before = readConfigFile(configFile);
+    const saved = saveRemoteConfig({
+      schemaVersion: REMOTE_CONFIG_SCHEMA_VERSION,
+      chatId: ids.chatId,
+      allowedUserIds: [ids.userId],
+      orphanMs: DEFAULT_ORPHAN_MS,
+      runTimeoutMs: DEFAULT_RUN_TIMEOUT_MS
+    }, this.options.dir);
+    if (!saved.ok) {
+      this.dropUnusedToken();
+      return { ok: false, code: "invalid", reason: saved.reason };
+    }
+    const result = await this.call("channels-reload", (body) => typeof body.state === "string");
+    if (!result.ok && result.code !== "no-answer") {
+      this.restore(configFile, before);
+      if (!before.ok) {
+        removeBotToken(this.options.dir);
+      }
+    }
+    return result;
+  }
+  dropUnusedToken() {
+    if (!fileExists(remoteConfigPath(this.options.dir))) {
+      removeBotToken(this.options.dir);
+    }
+  }
+  test() {
+    return this.call("channels-test", (body) => body.delivered === true && typeof body.machine === "string");
+  }
+  async disconnect() {
+    const result = await this.call("channels-disconnect", (body) => typeof body.deleted === "number" && typeof body.remaining === "number" && typeof body.hubWasRunning === "boolean");
+    if (!result.ok && result.code !== "serve-down") {
+      return result.code === "no-answer" ? { ...result, reason: `${result.reason} Nothing was erased on this machine.` } : result;
+    }
+    const erasedToken = removeBotToken(this.options.dir);
+    const erasedConfig = removeRemoteConfig(this.options.dir);
+    const erased = erasedToken && erasedConfig;
+    const gone = erased ? "The bot token and the config were erased." : "The bot token or the config could not be erased; remove the files in the keryx remote directory by hand.";
+    if (!result.ok) {
+      return {
+        ok: true,
+        value: {
+          deleted: 0,
+          remaining: 0,
+          topicsDeleted: false,
+          erased,
+          message: `keryx serve is not running, so the topics could not be deleted: they remain in the group. ${gone}`
+        }
+      };
+    }
+    const { deleted, remaining, hubWasRunning } = result.value;
+    const topics = !hubWasRunning ? "Telegram was not running in serve, so the topics could not be deleted: they remain in the group." : remaining > 0 ? `${plural2(deleted, "topic", "topics")} deleted; ${plural2(remaining, "topic", "topics")} could not be deleted and remain in the group.` : `${plural2(deleted, "topic", "topics")} deleted.`;
+    return { ok: true, value: { deleted, remaining, topicsDeleted: hubWasRunning && remaining === 0, erased, message: `${topics} ${gone}` } };
+  }
+  target(route) {
+    const endpoint = readEndpoint(this.options.dir);
+    if (!endpoint.ok) {
+      throw new ServeDown("serve-down", `keryx serve is not running (${endpoint.reason})`);
+    }
+    if (!isLoopbackAddress(endpoint.value.address)) {
+      throw new ServeDown("unsafe-endpoint", "the serve endpoint is not a loopback address; refusing to send the shell token there");
+    }
+    if (!this.isAlive(endpoint.value.pid)) {
+      throw new ServeDown("serve-down", `keryx serve is not running (pid ${endpoint.value.pid} is gone); start it with \`keryx serve\``);
+    }
+    const token = readShellToken(this.options.dir);
+    if (!token.ok) {
+      throw new ServeDown("serve-down", `keryx serve is not accepting the shell yet (${token.reason})`);
+    }
+    return { url: `http://${authority(endpoint.value.address, endpoint.value.port)}${channelsRoutePath(route)}`, token: token.value };
+  }
+  async post(route) {
+    const { url, token } = this.target(route);
+    return this.fetchImpl(url, {
+      method: "POST",
+      headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+      body: "{}",
+      signal: AbortSignal.timeout(route === "channels-disconnect" ? this.requestTimeoutMs * DISCONNECT_TIMEOUT_FACTOR : this.requestTimeoutMs)
+    });
+  }
+  async get(route) {
+    const { url, token } = this.target(route);
+    return this.fetchImpl(url, {
+      method: "GET",
+      headers: { authorization: `Bearer ${token}` },
+      signal: AbortSignal.timeout(this.requestTimeoutMs)
+    });
+  }
+  reachable() {
+    try {
+      this.target("channels-status");
+      return { ok: true };
+    } catch (error) {
+      if (error instanceof ServeDown) {
+        return { ok: false, code: error.code, reason: error.message };
+      }
+      throw error;
+    }
+  }
+  async call(route, guard) {
+    let response;
+    try {
+      response = CHANNELS_ROUTE_METHODS[route] === "GET" ? await this.get(route) : await this.post(route);
+    } catch (error) {
+      if (error instanceof ServeDown) {
+        return { ok: false, code: error.code, reason: error.message };
+      }
+      if (refusedConnection(error)) {
+        return { ok: false, code: "serve-down", reason: "keryx serve is not accepting connections; is it still running?" };
+      }
+      return {
+        ok: false,
+        code: "no-answer",
+        reason: "keryx serve did not answer in time or dropped the connection, so the outcome is unknown. Check /channels, then retry if needed."
+      };
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(await response.text());
+    } catch {
+      parsed = undefined;
+    }
+    if (!response.ok) {
+      const error = isObject2(parsed) && isObject2(parsed.error) ? parsed.error : undefined;
+      const code = typeof error?.code === "string" ? error.code : `http-${response.status}`;
+      const message = typeof error?.message === "string" ? error.message : `keryx serve refused the request (HTTP ${response.status})`;
+      return { ok: false, code, reason: message };
+    }
+    if (!isObject2(parsed) || !guard(parsed)) {
+      return { ok: false, code: "unexpected-response", reason: "keryx serve sent an answer this shell does not understand; update keryx on both sides" };
+    }
+    return { ok: true, value: parsed };
+  }
+  restore(file, before) {
+    try {
+      if (before.ok) {
+        ensureRemoteDir(this.options.dir);
+        writeOwnerOnlyFileAtomic(file, before.text);
+      } else if (file === botTokenPath(this.options.dir)) {
+        removeBotToken(this.options.dir);
+      } else {
+        removeRemoteConfig(this.options.dir);
+      }
+    } catch {}
+  }
+}
+function refusedConnection(error) {
+  const seen = new Set;
+  for (let current = error;isObject2(current) || current instanceof Error; ) {
+    if (seen.has(current))
+      break;
+    seen.add(current);
+    const { code, message, cause } = current;
+    if (code === "ECONNREFUSED" || code === "ConnectionRefused" || code === "EHOSTUNREACH" || code === "ENETUNREACH")
+      return true;
+    if (typeof message === "string" && /ECONNREFUSED|Unable to connect|connection refused/i.test(message))
+      return true;
+    current = cause;
+  }
+  return false;
+}
+function isPairing(body) {
+  return typeof body.state === "string" && typeof body.expiresAt === "number" && Array.isArray(body.problems);
+}
+var DEFAULT_REQUEST_TIMEOUT_MS2 = 15000, DISCONNECT_TIMEOUT_FACTOR = 8, ServeDown;
+var init_channels_client = __esm(() => {
+  init_serve_config();
+  init_config_dir();
+  init_client3();
+  init_config10();
+  init_endpoint();
+  init_paths4();
+  init_protocol2();
+  init_shell_token();
+  ServeDown = class ServeDown extends Error {
+    code;
+    constructor(code, message) {
+      super(message);
+      this.code = code;
+    }
+  };
+});
+
+// src/tui/action-button.ts
+function smallActionButton(otui, r, label, id, color, onMouseDown) {
+  const box = new otui.BoxRenderable(r, {
+    id,
+    flexShrink: 0,
+    marginLeft: 1,
+    paddingLeft: 1,
+    paddingRight: 1,
+    onMouseDown: (event) => {
+      event.stopPropagation();
+      onMouseDown();
+    }
+  });
+  const text = new otui.TextRenderable(r, { id: `${id}-t`, content: `[${label}]` });
+  text.fg = color;
+  box.add(text);
+  const setActive = (active) => {
+    box.backgroundColor = active ? getTheme().highlight : undefined;
+    text.content = active ? otui.t`${boldChunk(otui, `[${label}]`)}` : `[${label}]`;
+    text.fg = color;
+  };
+  return { box, setActive };
+}
+var init_action_button = __esm(() => {
+  init_theme();
+  init_theme_text();
+});
+
+// src/tui/queue-nav.ts
+function stepQueueNavIndex(selected, count, direction) {
+  if (count <= 0)
+    return 0;
+  if (direction === "up") {
+    return selected > 0 ? selected - 1 : count - 1;
+  }
+  return selected < count - 1 ? selected + 1 : 0;
+}
+function clampQueueNavIndex(selected, count) {
+  if (count <= 0)
+    return 0;
+  return Math.min(Math.max(selected, 0), count - 1);
+}
+function stepQueueNavAction(selected, direction) {
+  const idx = QUEUE_NAV_ACTIONS.indexOf(selected);
+  const count = QUEUE_NAV_ACTIONS.length;
+  const nextIdx = direction === "left" ? idx > 0 ? idx - 1 : count - 1 : idx < count - 1 ? idx + 1 : 0;
+  return QUEUE_NAV_ACTIONS[nextIdx];
+}
+function stepConnectNavAction(selected, direction) {
+  const idx = CONNECT_NAV_ACTIONS.indexOf(selected);
+  const count = CONNECT_NAV_ACTIONS.length;
+  const nextIdx = direction === "left" ? idx > 0 ? idx - 1 : count - 1 : idx < count - 1 ? idx + 1 : 0;
+  return CONNECT_NAV_ACTIONS[nextIdx];
+}
+var QUEUE_NAV_ACTIONS, CONNECT_NAV_ACTIONS;
+var init_queue_nav = __esm(() => {
+  QUEUE_NAV_ACTIONS = ["force", "edit", "delete"];
+  CONNECT_NAV_ACTIONS = ["label", "test", "disconnect"];
+});
+
+// src/tui/settings-modal.ts
+function isSettingsCommand(line) {
+  const token = line.trim().split(/\s+/)[0] ?? "";
+  return token === SETTINGS_COMMAND;
+}
+function settingsSidebarHint(readOnlyShown) {
+  return readOnlyShown ? undefined : SETTINGS_COMMAND;
+}
+function settingsWindow(rows, selected, top, budget) {
+  let start = Math.min(top, selected);
+  while (start < selected && lineCount(rows, start, selected) > budget)
+    start++;
+  let end = start;
+  while (end + 1 < rows.length && lineCount(rows, start, end + 1) <= budget)
+    end++;
+  return { top: start, end };
+}
+function openSettings(otui, chrome, options) {
+  const core = otui;
+  const r = options.renderer;
+  const now = options.now ?? Date.now;
+  let rows = options.rows;
+  let selectedRow = 0;
+  let selectedAction = 0;
+  let top = 0;
+  let armed;
+  let busy = false;
+  let closed = false;
+  let body;
+  let budget = Number.MAX_SAFE_INTEGER;
+  let blocks = [];
+  const activeIndex = (row) => Math.max(0, row?.actions.findIndex((a) => a.active) ?? 0);
+  const disarm = () => {
+    armed = undefined;
+  };
+  const blocked = () => closed || options.inputBlocked?.() === true;
+  function paint() {
+    if (closed || body === undefined)
+      return;
+    for (const block of blocks) {
+      try {
+        body.remove(block);
+      } catch {}
+    }
+    blocks = [];
+    selectedRow = clampQueueNavIndex(selectedRow, rows.length);
+    const win = settingsWindow(rows, selectedRow, top, budget);
+    top = win.top;
+    const labelWidth = Math.max(...rows.map((row) => row.label.length));
+    const valueWidth = Math.max(...rows.map((row) => row.value.length));
+    for (let i = win.top;i <= win.end; i++) {
+      const row = rows[i];
+      const selected = i === selectedRow;
+      if (i === win.top || rows[i - 1].group !== row.group) {
+        const heading = new core.TextRenderable(r, { id: `st-group-${row.group}`, content: core.t`${boldChunk(core, row.group)}` });
+        body.add(heading);
+        blocks.push(heading);
+      }
+      const outer = new core.BoxRenderable(r, {
+        id: `st-${row.id}`,
+        width: "100%",
+        flexDirection: "column",
+        ...selected ? { backgroundColor: getTheme().highlight } : {},
+        onMouseDown: (event) => {
+          event.stopPropagation();
+          if (blocked())
+            return;
+          select(i, activeIndex(row));
+        }
+      });
+      const label = row.label.padEnd(labelWidth);
+      const confirming = armed?.id === row.id ? row.actions[armed.action] : undefined;
+      const detail = row.detail === undefined ? "" : dimChunk(core, `  ${row.detail}`);
+      const armedNote = confirming === undefined ? "" : roleChunk(core, "attention", `  Enter again to confirm ${confirming.label}: it skips confirmation for every action`);
+      outer.add(new core.TextRenderable(r, {
+        id: `st-${row.id}-line`,
+        marginLeft: 2,
+        content: core.t`${selected ? boldChunk(core, label) : label}  ${roleChunk(core, "ok", row.value.padEnd(valueWidth))}  ${dimChunk(core, `[${row.scope}]`)}${detail}${armedNote}`
+      }));
+      const buttons = new core.BoxRenderable(r, { id: `st-${row.id}-buttons`, width: "100%", flexDirection: "row", marginLeft: 1 });
+      if (row.actions.length === 0) {
+        buttons.add(new core.TextRenderable(r, { id: `st-${row.id}-hint`, marginLeft: 1, content: core.t`${dimChunk(core, `run ${row.usage}`)}` }));
+      }
+      row.actions.forEach((action, index) => {
+        const color = action.active ? getTheme().ok : action.confirm ? getTheme().error : getTheme().tool;
+        const button = smallActionButton(core, r, action.active ? `\u2713 ${action.label}` : action.label, `st-${row.id}-${index}`, color, () => {
+          if (blocked())
+            return;
+          select(i, index);
+          press();
+        });
+        button.setActive(selected && index === selectedAction);
+        buttons.add(button.box);
+      });
+      outer.add(buttons);
+      body.add(outer);
+      blocks.push(outer);
+    }
+  }
+  function select(row, action) {
+    if (row !== selectedRow || action !== selectedAction)
+      disarm();
+    selectedRow = row;
+    selectedAction = action;
+    paint();
+  }
+  const report = (what, error) => {
+    options.onError?.(`/settings: ${what}: ${error instanceof Error ? error.message : String(error)}
+`);
+  };
+  async function press(viaKey = false) {
+    if (blocked())
+      return;
+    const row = rows[selectedRow];
+    const action = row?.actions[selectedAction];
+    if (row === undefined || action === undefined || busy)
+      return;
+    if (action.confirm) {
+      if (armed?.id !== row.id || armed.action !== selectedAction) {
+        armed = { id: row.id, action: selectedAction, at: now() };
+        paint();
+        return;
+      }
+      if (viaKey && now() - armed.at < CONFIRM_MIN_GAP_MS)
+        return;
+    }
+    disarm();
+    busy = true;
+    try {
+      try {
+        await options.run(action.command);
+      } catch (error) {
+        report(action.command, error);
+      }
+      try {
+        rows = await options.load();
+      } catch (error) {
+        report("could not reload the rows", error);
+      }
+    } finally {
+      busy = false;
+    }
+    const at = rows.findIndex((candidate) => candidate.id === row.id);
+    if (at >= 0)
+      selectedRow = at;
+    selectedAction = clampQueueNavIndex(selectedAction, rows[selectedRow]?.actions.length ?? 0);
+    paint();
+  }
+  const swallow = (key) => {
+    key.preventDefault?.();
+    key.stopPropagation?.();
+  };
+  const unsubscribeKeys = options.onKeypress((key) => {
+    if (blocked())
+      return;
+    if (key.name === "escape") {
+      if (armed === undefined)
+        return;
+      disarm();
+      paint();
+      swallow(key);
+      return;
+    }
+    if (busy)
+      return;
+    const row = rows[selectedRow];
+    if (key.name === "up" || key.name === "down") {
+      const next = stepQueueNavIndex(selectedRow, rows.length, key.name);
+      select(next, activeIndex(rows[next]));
+    } else if (key.name === "left" || key.name === "right") {
+      const count = row?.actions.length ?? 0;
+      if (count > 0)
+        select(selectedRow, stepQueueNavIndex(selectedAction, count, key.name === "left" ? "up" : "down"));
+    } else if (key.name === "return" || key.name === "linefeed" || key.name === "kpenter") {
+      press(true);
+    } else {
+      return;
+    }
+    swallow(key);
+  });
+  let unsubscribeTheme = () => {};
+  const groups = new Set(rows.map((row) => row.group)).size;
+  selectedAction = activeIndex(rows[0]);
+  const handle = openModal(core, chrome, {
+    title: SETTINGS_COMMAND,
+    tabs: [{ id: "settings", label: "Settings" }],
+    footer: SETTINGS_FOOTER,
+    contentRows: rows.length * 2 + groups,
+    renderTab: (_tabId, tabBody, ctx) => {
+      body = tabBody;
+      budget = ctx.height;
+      blocks = [];
+      paint();
+    },
+    onClose: () => {
+      closed = true;
+      unsubscribeKeys();
+      unsubscribeTheme();
+    }
+  });
+  if (handle === undefined) {
+    unsubscribeKeys();
+    return;
+  }
+  unsubscribeTheme = onThemeChange(guardedThemeRepaint("settings-modal", paint, () => closed || isRenderableGone(body) || r.isDestroyed === true));
+  return handle;
+}
+var SETTINGS_COMMAND = "/settings", CONFIRM_MIN_GAP_MS = 400, SETTINGS_FOOTER, lineCount = (rows, from, to) => {
+  let lines = 0;
+  for (let i = from;i <= to; i++) {
+    lines += 2 + (i === from || rows[i - 1].group !== rows[i].group ? 1 : 0);
+  }
+  return lines;
+};
+var init_settings_modal = __esm(() => {
+  init_action_button();
+  init_modal_host();
+  init_queue_nav();
+  init_theme();
+  init_theme_repaint();
+  init_theme_text();
+  SETTINGS_FOOTER = [
+    { key: "\u2191/\u2193", label: "setting" },
+    { key: "\u2190/\u2192", label: "value" },
+    { key: "Enter", label: "apply" },
+    { key: "esc", label: "close" }
+  ];
+});
+
+// src/tui/channels-surface.ts
+function isChannelsCommand(line) {
+  return (line.trim().split(/\s+/)[0] ?? "") === CHANNELS_COMMAND;
+}
+function parseChannelsArgs(line) {
+  const words = line.trim().split(/\s+/).slice(1);
+  if (words.length === 0 || words.length === 1 && words[0].toLowerCase() === "status")
+    return { action: "open" };
+  return { action: "invalid", message: CHANNELS_USAGE };
+}
+async function loadChannelsSnapshot(client) {
+  const status = await client.status();
+  const local = client.localFiles();
+  if (status.ok) {
+    const { machine, telegram } = status.value;
+    return {
+      state: telegram.state,
+      configured: telegram.state !== "not-connected" || local.tokenFile || local.configFile,
+      machine,
+      sessions: telegram.sessions,
+      ...telegram.reason !== undefined ? { reason: telegram.reason } : {}
+    };
+  }
+  const configured = local.tokenFile || local.configFile;
+  const down = status.code === "serve-down" || status.code === "unsafe-endpoint";
+  return { state: down ? "serve-down" : "error", configured, reason: status.reason };
+}
+function fit2(text, width) {
+  if (width <= 0)
+    return "";
+  return text.length <= width ? text : `${text.slice(0, Math.max(0, width - 1))}\u2026`;
+}
+function projectChannelsRow(snapshot, width) {
+  if (snapshot === undefined)
+    return { text: fit2("\u2026", width), role: "muted", action: "open" };
+  switch (snapshot.state) {
+    case "connected":
+      return { text: fit2("connected", width), role: "ok", action: "open" };
+    case "pairing":
+      return { text: fit2("pairing", width), role: "attention", action: "open" };
+    case "off":
+      return { text: fit2("off", width), role: "attention", action: "open" };
+    case "serve-down":
+      return snapshot.configured ? { text: fit2("serve down", width), role: "attention", action: "open" } : { text: fit2("off", width), role: "muted", action: "open" };
+    case "error":
+      return { text: fit2("error", width), role: "attention", action: "open" };
+    default:
+      return { text: fit2("off", width), role: "muted", action: "open" };
+  }
+}
+function channelsStatusLines(snapshot) {
+  const machine = snapshot.machine === undefined ? [] : [`Machine: ${snapshot.machine}`];
+  switch (snapshot.state) {
+    case "not-connected":
+      return [
+        "Telegram: not connected",
+        ...machine,
+        ...snapshot.configured ? ["A bot token is left on this machine from an unfinished connection. Connect starts over; Disconnect erases it."] : [
+          "This machine has no bot yet. Connect it to drive keryx sessions from Telegram topics.",
+          "You need a bot token from @BotFather and a Telegram group with topics turned on."
+        ]
+      ];
+    case "pairing":
+      return [
+        "Telegram: pairing in progress",
+        ...machine,
+        "Resume shows the one-time code again; Cancel pairing abandons it and erases the token."
+      ];
+    case "connected":
+      return [
+        "Telegram: connected",
+        ...machine,
+        `Sessions in Telegram: ${snapshot.sessions ?? 0}`,
+        "Test sends one message to the General topic. Disconnect deletes the topics and erases the token.",
+        "Sessions join through /remote-control in each shell."
+      ];
+    case "off":
+      return [
+        "Telegram: configured, but not running",
+        ...machine,
+        ...snapshot.reason === undefined ? [] : [`Why: ${snapshot.reason}`],
+        "Disconnect erases the token and config. Test works once Telegram is running again."
+      ];
+    case "serve-down":
+      return [
+        "Telegram: keryx serve is not running",
+        ...snapshot.reason === undefined ? [] : [snapshot.reason],
+        snapshot.configured ? "A bot is configured on this machine; it works again once `keryx serve` runs. Disconnect still erases the token." : "Start `keryx serve`, then connect."
+      ];
+    case "error":
+      return ["Telegram: status unavailable", ...snapshot.reason === undefined ? [] : [snapshot.reason]];
+  }
+}
+function readlineChannelsText(line, snapshot) {
+  const request = parseChannelsArgs(line);
+  if (request.action === "invalid")
+    return `${request.message}
+`;
+  const how = snapshot.state === "not-connected" || snapshot.state === "serve-down" || snapshot.state === "error" ? "Connecting needs a hidden token entry, which this line-based shell cannot give: run `keryx shell` (the full-screen shell) and use /channels there." : "Test and Disconnect are in the full-screen shell: run `keryx shell` and use /channels there.";
+  return `${[...channelsStatusLines(snapshot), "", how].join(`
+`)}
+`;
+}
+function codeLifetime(expiresAt, now) {
+  const left = expiresAt - now;
+  if (left <= 0)
+    return "expired";
+  if (left < 60000)
+    return "less than a minute";
+  return `${Math.ceil(left / 60000)} min`;
+}
+function channelsViewLines(view, snapshot, ctx) {
+  switch (view.kind) {
+    case "list": {
+      const lines = [];
+      if (view.notice !== undefined)
+        lines.push({ text: view.notice.text, tone: view.notice.tone }, { text: "", tone: "text" });
+      if (snapshot === undefined)
+        return [...lines, { text: "Reading the Telegram state\u2026", tone: "muted" }];
+      const [first, ...rest] = channelsStatusLines(snapshot);
+      return [...lines, { text: first, tone: "heading" }, ...rest.map((text) => ({ text, tone: "text" }))];
+    }
+    case "token":
+      return [
+        { text: "Step 1 of 4 \xB7 Bot token", tone: "heading" },
+        { text: "Create a bot with @BotFather in Telegram, then paste its token here.", tone: "text" },
+        { text: "", tone: "text" },
+        { text: `Token: ${"*".repeat(Math.min(ctx.tokenLength, 60))}${ctx.tokenLength === 0 ? "(waiting for the token)" : ""}`, tone: "code" },
+        ...view.error === undefined ? [] : [{ text: view.error, tone: "error" }],
+        { text: "", tone: "text" },
+        { text: "Typed hidden: the token is not shown, not kept in history and not logged. It goes only to this machine's owner-only keryx config.", tone: "muted" },
+        { text: "Enter to continue \xB7 Esc to go back", tone: "muted" }
+      ];
+    case "working":
+      return [{ text: view.text, tone: "heading" }];
+    case "pairing": {
+      const { pairing } = view;
+      const bot = pairing.botUsername === undefined ? "the bot" : `@${pairing.botUsername}`;
+      if (pairing.state === "waiting-for-user") {
+        return [
+          { text: "Step 2 of 4 \xB7 Send the code to the bot", tone: "heading" },
+          { text: `Open a private chat with ${bot} in Telegram and send it this code:`, tone: "text" },
+          { text: "", tone: "text" },
+          { text: `    ${pairing.code ?? "(no code: cancel and connect again)"}`, tone: "code" },
+          { text: "", tone: "text" },
+          { text: `Waiting for your message\u2026 the code is valid for ${codeLifetime(pairing.expiresAt, ctx.now)} and works once.`, tone: "muted" },
+          ...pairing.problems.length === 0 ? [] : pairing.problems.map((text) => ({ text, tone: "attention" }))
+        ];
+      }
+      return [
+        { text: "Step 3 of 4 \xB7 Add the bot to your group", tone: "heading" },
+        { text: `Add ${bot} to your Telegram group as an administrator with the "Manage topics" right. The group must have topics turned on.`, tone: "text" },
+        ...pairing.chatTitle === undefined ? [] : [{ text: `Group: ${pairing.chatTitle}`, tone: "text" }],
+        ...pairing.problems.length === 0 ? [{ text: "Waiting for the group\u2026", tone: "muted" }] : [{ text: "Still missing:", tone: "attention" }, ...pairing.problems.map((text) => ({ text: `  - ${text}`, tone: "attention" }))]
+      ];
+    }
+    case "connected":
+      return [
+        { text: "Step 4 of 4 \xB7 Connected", tone: "heading" },
+        ...view.group === undefined ? [] : [{ text: `Group: ${view.group}`, tone: "text" }],
+        ...snapshot?.machine === undefined ? [] : [{ text: `Machine: ${snapshot.machine}`, tone: "text" }],
+        { text: view.test.text, tone: view.test.tone },
+        { text: "Turn a session on with /remote-control in each shell.", tone: "muted" }
+      ];
+    case "failed":
+      return [
+        { text: view.title, tone: "error" },
+        { text: view.reason, tone: "text" },
+        { text: "Nothing was kept on this machine for the attempt that failed.", tone: "muted" }
+      ];
+    case "confirm-disconnect":
+      return [
+        { text: "Disconnect Telegram from this machine?", tone: "heading" },
+        { text: "This deletes every keryx topic in the group, stops polling, and erases the bot token and the config.", tone: "attention" },
+        { text: "The group itself and the bot stay in Telegram.", tone: "muted" }
+      ];
+  }
+}
+function defaultSchedule(fn, ms) {
+  const timer = setInterval(fn, ms);
+  return () => clearInterval(timer);
+}
+function openChannels(otui, chrome, options) {
+  const core = otui;
+  const r = options.renderer;
+  const { client } = options;
+  const now = options.now ?? Date.now;
+  const schedule = options.schedule ?? defaultSchedule;
+  let snapshot = options.snapshot;
+  let view = { kind: "list" };
+  let secret = "";
+  let selected = 0;
+  let busy = false;
+  let closed = false;
+  let epoch = 0;
+  let confirmArmedAt = 0;
+  let stopPolling = () => {};
+  let polling = false;
+  let body;
+  let blocks = [];
+  const blocked = () => closed || options.inputBlocked?.() === true;
+  const learn = (next) => {
+    snapshot = next;
+    options.onChanged?.(next);
+  };
+  const reload = async () => {
+    try {
+      learn(await loadChannelsSnapshot(client));
+    } catch {}
+  };
+  function actions() {
+    switch (view.kind) {
+      case "list": {
+        if (snapshot === undefined)
+          return [];
+        const disconnectButton = { id: "disconnect", label: "Disconnect", tone: "danger", run: () => askDisconnect() };
+        switch (snapshot.state) {
+          case "pairing":
+            return [
+              { id: "resume", label: "Resume", tone: "primary", run: () => void resume() },
+              { id: "cancel-pairing", label: "Cancel pairing", tone: "danger", run: () => void cancelPairing() }
+            ];
+          case "connected":
+            return [{ id: "test", label: "Test", tone: "primary", run: () => void runTest(false) }, disconnectButton];
+          case "not-connected":
+            return [{ id: "connect", label: "Connect", tone: "primary", run: () => void beginConnect() }, ...snapshot.configured ? [disconnectButton] : []];
+          default:
+            return snapshot.configured ? [disconnectButton] : [];
+        }
+      }
+      case "token":
+        return [
+          { id: "continue", label: "Continue", tone: "primary", run: () => void submitToken() },
+          { id: "back", label: "Back", tone: "plain", run: () => backToList() }
+        ];
+      case "pairing":
+        return [
+          { id: "cancel-pairing", label: "Cancel pairing", tone: "danger", run: () => void cancelPairing() },
+          { id: "back", label: "Back", tone: "plain", run: () => backToList() }
+        ];
+      case "connected":
+        return [
+          { id: "test", label: "Test again", tone: "primary", run: () => void runTest(true) },
+          { id: "back", label: "Done", tone: "plain", run: () => backToList() }
+        ];
+      case "failed":
+        return [
+          { id: "retry", label: "Try again", tone: "primary", run: () => void beginConnect() },
+          { id: "back", label: "Back", tone: "plain", run: () => backToList() }
+        ];
+      case "confirm-disconnect":
+        return [
+          { id: "cancel", label: "Cancel", tone: "plain", run: () => backToList() },
+          { id: "confirm-disconnect", label: "Yes, disconnect", tone: "danger", run: () => void disconnect() }
+        ];
+      case "working":
+        return [];
+    }
+  }
+  function chunkFor(line) {
+    const text = line.text === "" ? " " : line.text;
+    switch (line.tone) {
+      case "heading":
+        return boldChunk(core, text);
+      case "muted":
+        return dimChunk(core, text);
+      case "code":
+        return core.bold(roleChunk(core, "accent", text));
+      case "text":
+        return roleChunk(core, "text", text);
+      default:
+        return roleChunk(core, line.tone, text);
+    }
+  }
+  function paint() {
+    if (closed || body === undefined)
+      return;
+    for (const block of blocks) {
+      try {
+        body.remove(block);
+      } catch {}
+    }
+    blocks = [];
+    const lines = channelsViewLines(view, snapshot, { tokenLength: secret.length, now: now() });
+    lines.forEach((line, index) => {
+      const node = new core.TextRenderable(r, { id: `ch-line-${index}`, content: core.t`${chunkFor(line)}` });
+      body.add(node);
+      blocks.push(node);
+    });
+    const available = actions();
+    if (available.length > 0) {
+      selected = Math.min(selected, available.length - 1);
+      const row = new core.BoxRenderable(r, { id: "ch-buttons", width: "100%", flexDirection: "row", marginTop: 1 });
+      available.forEach((action, index) => {
+        const color = action.tone === "primary" ? getTheme().ok : action.tone === "danger" ? getTheme().error : getTheme().tool;
+        const button = smallActionButton(core, r, action.label, `ch-btn-${action.id}`, color, () => {
+          if (blocked() || busy)
+            return;
+          selected = index;
+          press(false);
+        });
+        button.setActive(index === selected);
+        row.add(button.box);
+      });
+      body.add(row);
+      blocks.push(row);
+    }
+  }
+  function go(next, selection = 0) {
+    epoch += 1;
+    stopPolling();
+    stopPolling = () => {};
+    polling = false;
+    view = next;
+    selected = selection;
+    if (next.kind === "pairing") {
+      stopPolling = schedule(() => void pollPairing(), options.pollMs ?? PAIRING_POLL_MS);
+    }
+    paint();
+  }
+  function backToList(notice) {
+    secret = "";
+    go(notice === undefined ? { kind: "list" } : { kind: "list", notice });
+  }
+  function press(viaKey) {
+    const action = actions()[selected];
+    if (action === undefined)
+      return;
+    if (view.kind === "confirm-disconnect" && action.id === "confirm-disconnect" && viaKey && now() - confirmArmedAt < CONFIRM_MIN_GAP_MS) {
+      return;
+    }
+    action.run();
+  }
+  async function beginConnect() {
+    if (busy)
+      return;
+    busy = true;
+    const mine = epoch + 1;
+    go({ kind: "working", text: "Looking for keryx serve\u2026" });
+    try {
+      await reload();
+      if (closed || epoch !== mine)
+        return;
+      if (snapshot?.state === "serve-down" || snapshot?.state === "error") {
+        backToList({ tone: "attention", text: snapshot.reason ?? "keryx serve is not reachable; start it with `keryx serve`." });
+        return;
+      }
+      if (snapshot?.state === "connected" || snapshot?.state === "off") {
+        backToList({ tone: "attention", text: "Telegram is already configured on this machine. Disconnect it first to connect a different bot." });
+        return;
+      }
+      if (snapshot?.state === "pairing") {
+        busy = false;
+        await resume();
+        return;
+      }
+      secret = "";
+      go({ kind: "token" });
+    } finally {
+      busy = false;
+    }
+  }
+  async function submitToken() {
+    if (view.kind !== "token" || busy || secret.length === 0)
+      return;
+    busy = true;
+    const token = secret;
+    secret = "";
+    go({ kind: "working", text: "Checking the token with Telegram\u2026" });
+    const mine = epoch;
+    try {
+      const result = await client.startPairing(token);
+      if (closed || epoch !== mine)
+        return;
+      if (!result.ok) {
+        go({ kind: "token", error: result.reason });
+        return;
+      }
+      await reload();
+      if (closed || epoch !== mine)
+        return;
+      go({ kind: "pairing", pairing: result.value });
+    } finally {
+      busy = false;
+    }
+  }
+  async function resume() {
+    if (busy)
+      return;
+    busy = true;
+    const mine = epoch + 1;
+    go({ kind: "working", text: "Reading the pairing\u2026" });
+    try {
+      const result = await client.pairingStatus();
+      if (closed || epoch !== mine)
+        return;
+      if (!result.ok) {
+        if (result.code === "no-pairing") {
+          await settlePairing(lostPairing());
+          return;
+        }
+        backToList({ tone: "attention", text: result.reason });
+        return;
+      }
+      await settlePairing(result.value);
+    } finally {
+      busy = false;
+    }
+  }
+  async function settlePairing(pairing) {
+    if (pairing.state === "ready") {
+      await finishConnect(pairing);
+    } else if (pairing.state === "waiting-for-user" || pairing.state === "waiting-for-group") {
+      go({ kind: "pairing", pairing });
+    } else {
+      const mine = epoch;
+      await client.cancelPairing();
+      await reload();
+      if (closed || epoch !== mine)
+        return;
+      go({
+        kind: "failed",
+        title: pairing.state === "expired" ? "The pairing code expired" : pairing.state === "cancelled" ? "Pairing was cancelled" : "Pairing failed",
+        reason: pairing.reason ?? (pairing.state === "expired" ? "The code is valid for 10 minutes. Connect again for a new one." : "Connect again to start over.")
+      });
+    }
+  }
+  function lostPairing() {
+    return {
+      schemaVersion: "1",
+      state: "expired",
+      expiresAt: 0,
+      problems: [],
+      reason: "keryx serve no longer has this pairing (it was restarted or the pairing was dropped), so the code on screen does not work. Connect again for a new one."
+    };
+  }
+  async function pollPairing() {
+    if (polling || closed || view.kind !== "pairing" || busy)
+      return;
+    polling = true;
+    const mine = epoch;
+    try {
+      const result = await client.pairingStatus();
+      if (closed || epoch !== mine)
+        return;
+      if (!result.ok && result.code === "no-pairing") {
+        polling = false;
+        busy = true;
+        try {
+          await settlePairing(lostPairing());
+        } finally {
+          busy = false;
+        }
+        return;
+      }
+      if (!result.ok) {
+        view = { kind: "pairing", pairing: { ...view.pairing, problems: [...view.pairing.problems.filter((p) => !p.startsWith("serve: ")), `serve: ${result.reason}`] } };
+        paint();
+        return;
+      }
+      polling = false;
+      const next = result.value;
+      if (next.state === "ready" || next.state === "failed" || next.state === "expired" || next.state === "cancelled") {
+        busy = true;
+        try {
+          await settlePairing(next);
+        } finally {
+          busy = false;
+        }
+        return;
+      }
+      view = { kind: "pairing", pairing: next };
+      paint();
+    } finally {
+      polling = false;
+    }
+  }
+  async function finishConnect(pairing) {
+    if (pairing.userId === undefined || pairing.chatId === undefined) {
+      await client.cancelPairing();
+      await reload();
+      go({ kind: "failed", title: "Pairing is incomplete", reason: "Telegram did not report both the user and the group. Connect again." });
+      return;
+    }
+    go({ kind: "working", text: "Connecting\u2026" });
+    const mine = epoch;
+    const connected = await client.connectFinish({ userId: pairing.userId, chatId: pairing.chatId });
+    if (closed || epoch !== mine)
+      return;
+    if (!connected.ok) {
+      await reload();
+      if (closed || epoch !== mine)
+        return;
+      go({ kind: "failed", title: "Could not connect", reason: connected.reason });
+      return;
+    }
+    await reload();
+    const group = pairing.chatTitle;
+    const test = await client.test();
+    if (closed || epoch !== mine)
+      return;
+    go({ kind: "connected", ...group === undefined ? {} : { group }, test: testNotice(test) });
+  }
+  function testNotice(result) {
+    return result.ok ? { tone: "ok", text: `Test message delivered to the General topic (machine: ${result.value.machine}).` } : { tone: "error", text: `Test message not delivered: ${result.reason}` };
+  }
+  async function runTest(fromConnected) {
+    if (busy)
+      return;
+    busy = true;
+    const group = view.kind === "connected" ? view.group : undefined;
+    go({ kind: "working", text: "Sending a test message\u2026" });
+    const mine = epoch;
+    try {
+      const result = await client.test();
+      if (closed || epoch !== mine)
+        return;
+      const notice = testNotice(result);
+      await reload();
+      if (closed || epoch !== mine)
+        return;
+      if (fromConnected)
+        go({ kind: "connected", ...group === undefined ? {} : { group }, test: notice });
+      else
+        backToList(notice);
+    } finally {
+      busy = false;
+    }
+  }
+  async function cancelPairing() {
+    if (busy)
+      return;
+    busy = true;
+    go({ kind: "working", text: "Cancelling the pairing\u2026" });
+    const mine = epoch;
+    try {
+      const result = await client.cancelPairing();
+      await reload();
+      if (closed || epoch !== mine)
+        return;
+      backToList(result.ok ? { tone: "ok", text: "Pairing cancelled. The token was erased." } : { tone: "attention", text: result.reason });
+    } finally {
+      busy = false;
+    }
+  }
+  function askDisconnect() {
+    confirmArmedAt = now();
+    go({ kind: "confirm-disconnect" }, 0);
+  }
+  async function disconnect() {
+    if (busy)
+      return;
+    busy = true;
+    go({ kind: "working", text: "Deleting the topics and erasing the token\u2026" });
+    const mine = epoch;
+    try {
+      const result = await client.disconnect();
+      await reload();
+      if (closed || epoch !== mine)
+        return;
+      if (!result.ok) {
+        backToList({ tone: "error", text: result.code === "no-answer" ? result.reason : `Not disconnected: ${result.reason}` });
+        return;
+      }
+      backToList({ tone: result.value.erased && result.value.remaining === 0 && result.value.topicsDeleted ? "ok" : "attention", text: result.value.message });
+    } finally {
+      busy = false;
+    }
+  }
+  function appendToken(text) {
+    for (const ch of text) {
+      if (TOKEN_CHAR.test(ch) && secret.length < TOKEN_MAX)
+        secret += ch;
+    }
+    paint();
+  }
+  function tokenKey(key) {
+    const name = key.name;
+    if (key.ctrl === true && name === "c")
+      return;
+    swallow(key);
+    if (name === "escape") {
+      backToList();
+    } else if (name === "return" || name === "linefeed" || name === "kpenter") {
+      submitToken();
+    } else if (name === "backspace" || name === "delete") {
+      secret = secret.slice(0, -1);
+      paint();
+    } else if (key.ctrl === true && name === "u") {
+      secret = "";
+      paint();
+    } else if (key.ctrl !== true && key.meta !== true && key.sequence.length === 1) {
+      appendToken(key.sequence);
+    }
+  }
+  const unsubscribeKeys = options.onKeypress((key) => {
+    if (blocked())
+      return;
+    if (view.kind === "token") {
+      tokenKey(key);
+      return;
+    }
+    const name = key.name;
+    const isEnter = name === "return" || name === "linefeed" || name === "kpenter";
+    if (name === "escape") {
+      if (view.kind === "list" || view.kind === "working")
+        return;
+      backToList();
+      swallow(key);
+      return;
+    }
+    if (busy)
+      return;
+    const available = actions();
+    if (name === "left" || name === "right") {
+      if (available.length < 2)
+        return;
+      selected = name === "left" ? Math.max(0, selected - 1) : Math.min(available.length - 1, selected + 1);
+      paint();
+      swallow(key);
+    } else if (isEnter) {
+      if (available.length === 0)
+        return;
+      press(true);
+      swallow(key);
+    } else if (view.kind === "list" || view.kind === "connected") {
+      const shortcuts = { c: "connect", t: "test", d: "disconnect" };
+      const shortcut = shortcuts[key.sequence.toLowerCase()];
+      const hit = shortcut === undefined ? undefined : available.find((a) => a.id === shortcut || shortcut === "connect" && a.id === "resume");
+      if (hit !== undefined && key.ctrl !== true && key.meta !== true) {
+        hit.run();
+        swallow(key);
+      }
+    }
+  });
+  const unsubscribePaste = options.onPaste?.((event) => {
+    if (blocked() || view.kind !== "token")
+      return;
+    swallow(event);
+    appendToken(new TextDecoder().decode(event.bytes));
+  });
+  let unsubscribeTheme = () => {};
+  const handle = openModal(core, chrome, {
+    title: CHANNELS_COMMAND,
+    tabs: [{ id: "telegram", label: "Telegram" }],
+    ownsKeys: () => view.kind === "token",
+    footer: CHANNELS_FOOTER,
+    contentRows: 14,
+    renderTab: (_tabId, tabBody) => {
+      body = tabBody;
+      blocks = [];
+      paint();
+    },
+    onClose: () => {
+      closed = true;
+      secret = "";
+      stopPolling();
+      unsubscribeKeys();
+      unsubscribePaste?.();
+      unsubscribeTheme();
+    }
+  });
+  if (handle === undefined) {
+    closed = true;
+    unsubscribeKeys();
+    unsubscribePaste?.();
+    return;
+  }
+  unsubscribeTheme = onThemeChange(guardedThemeRepaint("channels-modal", paint, () => closed || isRenderableGone(body) || r.isDestroyed === true));
+  reload().then(() => {
+    if (!closed && view.kind === "list")
+      paint();
+  });
+  return handle;
+}
+function mountChannelsPanel(otui, renderer, parent, options) {
+  const core = otui;
+  const box = new core.BoxRenderable(renderer, { id: "sb-channels", flexDirection: "column", flexShrink: 0 });
+  parent.add(box);
+  let disposed = false;
+  let snapshot;
+  const label = new core.TextRenderable(renderer, { id: "sb-channels-k", content: core.t`${dimChunk(core, "Telegram")}`, marginTop: 1 });
+  const value = new core.TextRenderable(renderer, { id: "sb-channels-v", content: "" });
+  box.add(label);
+  box.add(value);
+  const currentRow = () => projectChannelsRow(snapshot, options.width);
+  const draw = () => {
+    if (disposed)
+      return;
+    const row = currentRow();
+    label.content = core.t`${dimChunk(core, "Telegram")}`;
+    value.content = core.t`${roleChunk(core, row.role, row.text)}`;
+  };
+  const activate = () => {
+    options.onOpen();
+    return "open";
+  };
+  label.onMouseDown = () => {
+    activate();
+  };
+  value.onMouseDown = () => {
+    activate();
+  };
+  const refresh = async () => {
+    try {
+      const next = await options.load();
+      if (disposed)
+        return;
+      snapshot = next;
+      draw();
+    } catch {}
+  };
+  const stop = (options.schedule ?? defaultSchedule)(() => void refresh(), options.intervalMs ?? CHANNELS_ROW_POLL_MS);
+  const unsubscribeTheme = onThemeChange(guardedThemeRepaint("channels-panel", draw, () => disposed || isRenderableGone(box)));
+  draw();
+  refresh();
+  return {
+    refresh,
+    update(next) {
+      snapshot = next;
+      draw();
+    },
+    row: currentRow,
+    activate,
+    dispose() {
+      disposed = true;
+      stop();
+      unsubscribeTheme();
+    }
+  };
+}
+var CHANNELS_COMMAND = "/channels", CHANNELS_USAGE, CHANNELS_FOOTER, TOKEN_CHAR, TOKEN_MAX = 200, PAIRING_POLL_MS = 2000, swallow = (event) => {
+  event.preventDefault?.();
+  event.stopPropagation?.();
+}, CHANNELS_ROW_POLL_MS = 1e4;
+var init_channels_surface = __esm(() => {
+  init_action_button();
+  init_modal_host();
+  init_settings_modal();
+  init_theme();
+  init_theme_repaint();
+  init_theme_text();
+  CHANNELS_USAGE = `Usage: ${CHANNELS_COMMAND} [status]`;
+  CHANNELS_FOOTER = [
+    { key: "c", label: "connect" },
+    { key: "t", label: "test" },
+    { key: "d", label: "disconnect" },
+    { key: "\u2190/\u2192", label: "button" },
+    { key: "Enter", label: "press" },
+    { key: "esc", label: "back" }
+  ];
+  TOKEN_CHAR = /^[A-Za-z0-9_:-]$/;
+});
+
 // src/tui/remote-control-surface.ts
 function labelTelegramLine(text) {
   return `[${TG_LABEL}] ${text}`;
@@ -109946,17 +111418,17 @@ function presentRemoteControl(open, otui, chrome, options) {
 function openRemoteControl(otui, chrome, options) {
   return presentRemoteControl((hostOtui, hostChrome, input) => openModal(hostOtui, hostChrome, input), otui, chrome, options);
 }
-function fit2(text, width) {
+function fit3(text, width) {
   if (width <= 0)
     return "";
   return text.length <= width ? text : `${text.slice(0, Math.max(0, width - 1))}\u2026`;
 }
 function projectRemoteRow(status, width) {
   if (status === undefined || status.state === "off")
-    return { text: fit2("off", width), role: "muted", action: "open" };
+    return { text: fit3("off", width), role: "muted", action: "open" };
   if (status.state === "offline")
-    return { text: fit2("offline", width), role: "attention", action: "open" };
-  return { text: fit2(status.name ?? "connecting", width), role: "ok", action: "open" };
+    return { text: fit3("offline", width), role: "attention", action: "open" };
+  return { text: fit3(status.name ?? "connecting", width), role: "ok", action: "open" };
 }
 function mountRemotePanel(otui, renderer, parent, options) {
   const core = otui;
@@ -110241,6 +111713,11 @@ var init_agent_commands = __esm(() => {
       description: "Drive this session from a Telegram topic: /remote-control [name|off|status]. Off by default",
       modes: AGENT_ONLY
     },
+    {
+      name: "/channels",
+      description: "Connect, test or disconnect Telegram for this machine: /channels [status]",
+      modes: AGENT_ONLY
+    },
     {
       name: "/product",
       description: "Intents closed in code that nobody looked back at, with their outcome criteria",
@@ -110474,6 +111951,8 @@ function classifyBusyDispatch(params) {
     return "reviews";
   if (commandName === "/remote-control")
     return "remote-control";
+  if (commandName === "/channels")
+    return "channels";
   if (commandName === "/schedules")
     return "schedules";
   if (commandName === "/approvals")
@@ -111063,26 +112542,26 @@ function createGovernanceRunner(options) {
 function formatReportDate(iso) {
   return iso.trim().replace("T", " ").slice(0, 16);
 }
-function fit3(text, width) {
+function fit4(text, width) {
   if (width <= 0)
     return "";
   return text.length <= width ? text : `${text.slice(0, Math.max(0, width - 1))}\u2026`;
 }
 function projectGovernanceRow(read, run, width, options = {}) {
   if (run.kind === "running")
-    return { text: fit3(GOVERNANCE_RUNNING, width), role: "accent", action: "none" };
+    return { text: fit4(GOVERNANCE_RUNNING, width), role: "accent", action: "none" };
   const stored = read?.state === "present" ? read.report.generatedAt : undefined;
   if (run.kind === "failed" && !(stored !== undefined && stored > run.at)) {
-    return { text: fit3(GOVERNANCE_FAILED, width), role: "error", action: "run" };
+    return { text: fit4(GOVERNANCE_FAILED, width), role: "error", action: "run" };
   }
   const ran = run.kind === "done" && options.readIsStale === true ? run.generatedAt : undefined;
   const newest = stored === undefined ? ran : ran === undefined || stored >= ran ? stored : ran;
   if (newest === undefined) {
     if (read?.state === "malformed")
-      return { text: fit3(GOVERNANCE_UNREADABLE, width), role: "error", action: "open" };
-    return { text: fit3(GOVERNANCE_NO_REPORT, width), role: "attention", action: "run" };
+      return { text: fit4(GOVERNANCE_UNREADABLE, width), role: "error", action: "open" };
+    return { text: fit4(GOVERNANCE_NO_REPORT, width), role: "attention", action: "run" };
   }
-  return { text: fit3(`last report ${formatReportDate(newest)}`, width), role: "muted", action: "open" };
+  return { text: fit4(`last report ${formatReportDate(newest)}`, width), role: "muted", action: "open" };
 }
 function mountGovernancePanel(otui, renderer, parent, options) {
   const core = otui;
@@ -111526,7 +113005,7 @@ function outcomeRole(outcome) {
     return "attention";
   return "muted";
 }
-function fit4(text, width) {
+function fit5(text, width) {
   if (width <= 0)
     return "";
   return text.length <= width ? text : `${text.slice(0, Math.max(0, width - 1))}\u2026`;
@@ -111545,23 +113024,23 @@ function projectTriggersPanel(view, options) {
   const list = { kind: "list" };
   const rows = [];
   if (options.loadError !== undefined) {
-    rows.push({ id: "sb-triggers-error", chunks: [{ role: "error", text: fit4(`could not read: ${options.loadError}`, w) }], target: list });
+    rows.push({ id: "sb-triggers-error", chunks: [{ role: "error", text: fit5(`could not read: ${options.loadError}`, w) }], target: list });
     return { visible: true, rows };
   }
   if (view === undefined || view.config.kind === "absent")
     return { visible: false, rows: [] };
   if (view.config.kind === "broken") {
-    rows.push({ id: "sb-triggers-broken", chunks: [{ role: "error", text: fit4(`config unreadable (${view.config.problem})`, w) }], target: list });
+    rows.push({ id: "sb-triggers-broken", chunks: [{ role: "error", text: fit5(`config unreadable (${view.config.problem})`, w) }], target: list });
     return { visible: true, rows };
   }
   const spend = formatTriggerSpend(view.spend);
-  rows.push({ id: "sb-triggers-spend", chunks: [{ role: spend.role, text: fit4(spend.text, w) }], target: list });
+  rows.push({ id: "sb-triggers-spend", chunks: [{ role: spend.role, text: fit5(spend.text, w) }], target: list });
   const open = view.openReservations.length;
   if (open > 0) {
     const held = usd(view.openReservations.reduce((sum, r) => sum + r.usd, 0));
     rows.push({
       id: "sb-triggers-reservations",
-      chunks: [{ role: "attention", text: fit4(`! ${open} open \xB7 ${held} reserved`, w) }],
+      chunks: [{ role: "attention", text: fit5(`! ${open} open \xB7 ${held} reserved`, w) }],
       target: list
     });
   }
@@ -111577,18 +113056,18 @@ function projectTriggersPanel(view, options) {
     const lastRole = latest === undefined ? "muted" : outcomeRole(latest.outcome);
     const state = ` \xB7 ${entry.enabled ? "enabled" : "disabled"} \xB7 `;
     const nameRoom = Math.max(1, budget - state.length - last.length);
-    chunks.push({ role: "text", text: `${fit4(entry.name, nameRoom)}${state}` });
-    chunks.push({ role: lastRole, text: fit4(last, Math.max(0, budget - Math.min(entry.name.length, nameRoom) - state.length)) });
+    chunks.push({ role: "text", text: `${fit5(entry.name, nameRoom)}${state}` });
+    chunks.push({ role: lastRole, text: fit5(last, Math.max(0, budget - Math.min(entry.name.length, nameRoom) - state.length)) });
     rows.push({ id: `sb-triggers-${entry.name}`, chunks, target: { kind: "trigger", name: entry.name } });
   }
   const scheduled = scheduledEntries(view).length;
   if (scheduled > 0) {
-    rows.push({ id: "sb-triggers-scheduled", chunks: [{ role: "muted", text: fit4(`${scheduled} scheduled`, w) }], target: list });
+    rows.push({ id: "sb-triggers-scheduled", chunks: [{ role: "muted", text: fit5(`${scheduled} scheduled`, w) }], target: list });
   }
   if (view.rejected.length > 0) {
     rows.push({
       id: "sb-triggers-rejected",
-      chunks: [{ role: "error", text: fit4(`${view.rejected.length} rejected entr${view.rejected.length === 1 ? "y" : "ies"}`, w) }],
+      chunks: [{ role: "error", text: fit5(`${view.rejected.length} rejected entr${view.rejected.length === 1 ? "y" : "ies"}`, w) }],
       target: list
     });
   }
@@ -111994,7 +113473,7 @@ var init_triggers_inspector = __esm(() => {
 
 // src/tui/trigger-run-now.ts
 import { spawn as nodeSpawn2 } from "child_process";
-import { closeSync as closeSync6, constants as constants3, fstatSync as fstatSync3, lstatSync as lstatSync8, mkdirSync as mkdirSync8, openSync as openSync6, readdirSync as readdirSync8, readSync as readSync3, unlinkSync as unlinkSync6, writeSync } from "fs";
+import { closeSync as closeSync6, constants as constants3, fstatSync as fstatSync3, lstatSync as lstatSync8, mkdirSync as mkdirSync8, openSync as openSync6, readdirSync as readdirSync8, readSync as readSync3, unlinkSync as unlinkSync7, writeSync } from "fs";
 import path251 from "path";
 function triggerRunArgv(name, invocation = resolveKeryxInvocation(), options = {}) {
   return [...invocationArgv(invocation), "trigger", "run", ...options.schedule === true ? ["--schedule"] : [], name];
@@ -112080,7 +113559,7 @@ function pruneRunLogs(dir, name, keep) {
   }
   for (const old of names.slice(0, Math.max(0, names.length - keep))) {
     try {
-      unlinkSync6(path251.join(dir, old));
+      unlinkSync7(path251.join(dir, old));
     } catch {}
   }
 }
@@ -114382,7 +115861,7 @@ function compactOutcome(record) {
   const cost = usd === undefined ? "" : usd > 0 && usd < 0.001 ? " <$0.001" : ` $${Number(usd.toFixed(3))}`;
   return `${shortOutcome(record.outcome)}${cost}`;
 }
-function fit5(text, width) {
+function fit6(text, width) {
   if (width <= 0)
     return "";
   return text.length <= width ? text : `${text.slice(0, Math.max(0, width - 1))}\u2026`;
@@ -114390,7 +115869,7 @@ function fit5(text, width) {
 function projectSchedulesPanel(view, options) {
   const w = options.width;
   if (options.loadError !== undefined) {
-    return { visible: true, rows: [{ id: "sb-schedules-error", name: "", chunks: [{ role: "error", text: fit5(`could not read: ${options.loadError}`, w) }] }] };
+    return { visible: true, rows: [{ id: "sb-schedules-error", name: "", chunks: [{ role: "error", text: fit6(`could not read: ${options.loadError}`, w) }] }] };
   }
   if (view === undefined)
     return { visible: false, rows: [] };
@@ -114406,7 +115885,7 @@ function projectSchedulesPanel(view, options) {
     const last = compactOutcome(latest);
     const middle = ` ${state} `;
     const nameRoom = Math.max(1, w - middle.length - last.length);
-    const name = fit5(entry.name, nameRoom);
+    const name = fit6(entry.name, nameRoom);
     const lastRoom = Math.max(0, w - name.length - middle.length);
     return {
       id: `sb-schedules-${entry.name}`,
@@ -114414,7 +115893,7 @@ function projectSchedulesPanel(view, options) {
       chunks: [
         { role: "text", text: name },
         { role: entry.enabled && !missing ? "dim" : "attention", text: middle },
-        { role: latest === undefined ? "muted" : scheduleOutcomeRole(latest.outcome), text: fit5(last, lastRoom) }
+        { role: latest === undefined ? "muted" : scheduleOutcomeRole(latest.outcome), text: fit6(last, lastRoom) }
       ]
     };
   });
@@ -127332,7 +128811,7 @@ async function loadMcpConfig(cwd) {
   return mergeMcpConfig(parsed);
 }
 var MCP_CONFIG_DEFAULTS;
-var init_config10 = __esm(() => {
+var init_config11 = __esm(() => {
   init_fs();
   init_json();
   MCP_CONFIG_DEFAULTS = {
@@ -127796,7 +129275,7 @@ var MCP_MANAGED_KEY = "_keryxManaged", MCP_MANAGED_SENTINEL = "mcp-client-config
 var init_client_config = __esm(() => {
   init_fs();
   init_contained_write();
-  init_config10();
+  init_config11();
   MCP_SERVER_ARGS = ["serve-mcp"];
   CURSOR_RUNTIME = fileRuntime("cursor", ".cursor/mcp.json");
   CLAUDE_RUNTIME = fileRuntime("claude", ".mcp.json");
@@ -128537,34 +130016,6 @@ var init_session_info = __esm(() => {
   ];
 });
 
-// src/tui/action-button.ts
-function smallActionButton(otui, r, label, id, color, onMouseDown) {
-  const box = new otui.BoxRenderable(r, {
-    id,
-    flexShrink: 0,
-    marginLeft: 1,
-    paddingLeft: 1,
-    paddingRight: 1,
-    onMouseDown: (event) => {
-      event.stopPropagation();
-      onMouseDown();
-    }
-  });
-  const text = new otui.TextRenderable(r, { id: `${id}-t`, content: `[${label}]` });
-  text.fg = color;
-  box.add(text);
-  const setActive = (active) => {
-    box.backgroundColor = active ? getTheme().highlight : undefined;
-    text.content = active ? otui.t`${boldChunk(otui, `[${label}]`)}` : `[${label}]`;
-    text.fg = color;
-  };
-  return { box, setActive };
-}
-var init_action_button = __esm(() => {
-  init_theme();
-  init_theme_text();
-});
-
 // src/tui/help-modal.ts
 function tabStripWidth(labels) {
   return labels.reduce((total, label, i) => total + label.length + 2 + (i === 0 ? 0 : 1), 0);
@@ -129110,267 +130561,6 @@ function settingsOpenDecision(state) {
   return { open: true };
 }
 
-// src/tui/queue-nav.ts
-function stepQueueNavIndex(selected, count, direction) {
-  if (count <= 0)
-    return 0;
-  if (direction === "up") {
-    return selected > 0 ? selected - 1 : count - 1;
-  }
-  return selected < count - 1 ? selected + 1 : 0;
-}
-function clampQueueNavIndex(selected, count) {
-  if (count <= 0)
-    return 0;
-  return Math.min(Math.max(selected, 0), count - 1);
-}
-function stepQueueNavAction(selected, direction) {
-  const idx = QUEUE_NAV_ACTIONS.indexOf(selected);
-  const count = QUEUE_NAV_ACTIONS.length;
-  const nextIdx = direction === "left" ? idx > 0 ? idx - 1 : count - 1 : idx < count - 1 ? idx + 1 : 0;
-  return QUEUE_NAV_ACTIONS[nextIdx];
-}
-function stepConnectNavAction(selected, direction) {
-  const idx = CONNECT_NAV_ACTIONS.indexOf(selected);
-  const count = CONNECT_NAV_ACTIONS.length;
-  const nextIdx = direction === "left" ? idx > 0 ? idx - 1 : count - 1 : idx < count - 1 ? idx + 1 : 0;
-  return CONNECT_NAV_ACTIONS[nextIdx];
-}
-var QUEUE_NAV_ACTIONS, CONNECT_NAV_ACTIONS;
-var init_queue_nav = __esm(() => {
-  QUEUE_NAV_ACTIONS = ["force", "edit", "delete"];
-  CONNECT_NAV_ACTIONS = ["label", "test", "disconnect"];
-});
-
-// src/tui/settings-modal.ts
-function isSettingsCommand(line) {
-  const token = line.trim().split(/\s+/)[0] ?? "";
-  return token === SETTINGS_COMMAND;
-}
-function settingsSidebarHint(readOnlyShown) {
-  return readOnlyShown ? undefined : SETTINGS_COMMAND;
-}
-function settingsWindow(rows, selected, top, budget) {
-  let start = Math.min(top, selected);
-  while (start < selected && lineCount(rows, start, selected) > budget)
-    start++;
-  let end = start;
-  while (end + 1 < rows.length && lineCount(rows, start, end + 1) <= budget)
-    end++;
-  return { top: start, end };
-}
-function openSettings(otui, chrome, options) {
-  const core = otui;
-  const r = options.renderer;
-  const now = options.now ?? Date.now;
-  let rows = options.rows;
-  let selectedRow = 0;
-  let selectedAction = 0;
-  let top = 0;
-  let armed;
-  let busy = false;
-  let closed = false;
-  let body;
-  let budget = Number.MAX_SAFE_INTEGER;
-  let blocks = [];
-  const activeIndex = (row) => Math.max(0, row?.actions.findIndex((a) => a.active) ?? 0);
-  const disarm = () => {
-    armed = undefined;
-  };
-  const blocked = () => closed || options.inputBlocked?.() === true;
-  function paint() {
-    if (closed || body === undefined)
-      return;
-    for (const block of blocks) {
-      try {
-        body.remove(block);
-      } catch {}
-    }
-    blocks = [];
-    selectedRow = clampQueueNavIndex(selectedRow, rows.length);
-    const win = settingsWindow(rows, selectedRow, top, budget);
-    top = win.top;
-    const labelWidth = Math.max(...rows.map((row) => row.label.length));
-    const valueWidth = Math.max(...rows.map((row) => row.value.length));
-    for (let i = win.top;i <= win.end; i++) {
-      const row = rows[i];
-      const selected = i === selectedRow;
-      if (i === win.top || rows[i - 1].group !== row.group) {
-        const heading = new core.TextRenderable(r, { id: `st-group-${row.group}`, content: core.t`${boldChunk(core, row.group)}` });
-        body.add(heading);
-        blocks.push(heading);
-      }
-      const outer = new core.BoxRenderable(r, {
-        id: `st-${row.id}`,
-        width: "100%",
-        flexDirection: "column",
-        ...selected ? { backgroundColor: getTheme().highlight } : {},
-        onMouseDown: (event) => {
-          event.stopPropagation();
-          if (blocked())
-            return;
-          select(i, activeIndex(row));
-        }
-      });
-      const label = row.label.padEnd(labelWidth);
-      const confirming = armed?.id === row.id ? row.actions[armed.action] : undefined;
-      const detail = row.detail === undefined ? "" : dimChunk(core, `  ${row.detail}`);
-      const armedNote = confirming === undefined ? "" : roleChunk(core, "attention", `  Enter again to confirm ${confirming.label}: it skips confirmation for every action`);
-      outer.add(new core.TextRenderable(r, {
-        id: `st-${row.id}-line`,
-        marginLeft: 2,
-        content: core.t`${selected ? boldChunk(core, label) : label}  ${roleChunk(core, "ok", row.value.padEnd(valueWidth))}  ${dimChunk(core, `[${row.scope}]`)}${detail}${armedNote}`
-      }));
-      const buttons = new core.BoxRenderable(r, { id: `st-${row.id}-buttons`, width: "100%", flexDirection: "row", marginLeft: 1 });
-      if (row.actions.length === 0) {
-        buttons.add(new core.TextRenderable(r, { id: `st-${row.id}-hint`, marginLeft: 1, content: core.t`${dimChunk(core, `run ${row.usage}`)}` }));
-      }
-      row.actions.forEach((action, index) => {
-        const color = action.active ? getTheme().ok : action.confirm ? getTheme().error : getTheme().tool;
-        const button = smallActionButton(core, r, action.active ? `\u2713 ${action.label}` : action.label, `st-${row.id}-${index}`, color, () => {
-          if (blocked())
-            return;
-          select(i, index);
-          press();
-        });
-        button.setActive(selected && index === selectedAction);
-        buttons.add(button.box);
-      });
-      outer.add(buttons);
-      body.add(outer);
-      blocks.push(outer);
-    }
-  }
-  function select(row, action) {
-    if (row !== selectedRow || action !== selectedAction)
-      disarm();
-    selectedRow = row;
-    selectedAction = action;
-    paint();
-  }
-  const report = (what, error) => {
-    options.onError?.(`/settings: ${what}: ${error instanceof Error ? error.message : String(error)}
-`);
-  };
-  async function press(viaKey = false) {
-    if (blocked())
-      return;
-    const row = rows[selectedRow];
-    const action = row?.actions[selectedAction];
-    if (row === undefined || action === undefined || busy)
-      return;
-    if (action.confirm) {
-      if (armed?.id !== row.id || armed.action !== selectedAction) {
-        armed = { id: row.id, action: selectedAction, at: now() };
-        paint();
-        return;
-      }
-      if (viaKey && now() - armed.at < CONFIRM_MIN_GAP_MS)
-        return;
-    }
-    disarm();
-    busy = true;
-    try {
-      try {
-        await options.run(action.command);
-      } catch (error) {
-        report(action.command, error);
-      }
-      try {
-        rows = await options.load();
-      } catch (error) {
-        report("could not reload the rows", error);
-      }
-    } finally {
-      busy = false;
-    }
-    const at = rows.findIndex((candidate) => candidate.id === row.id);
-    if (at >= 0)
-      selectedRow = at;
-    selectedAction = clampQueueNavIndex(selectedAction, rows[selectedRow]?.actions.length ?? 0);
-    paint();
-  }
-  const swallow = (key) => {
-    key.preventDefault?.();
-    key.stopPropagation?.();
-  };
-  const unsubscribeKeys = options.onKeypress((key) => {
-    if (blocked())
-      return;
-    if (key.name === "escape") {
-      if (armed === undefined)
-        return;
-      disarm();
-      paint();
-      swallow(key);
-      return;
-    }
-    if (busy)
-      return;
-    const row = rows[selectedRow];
-    if (key.name === "up" || key.name === "down") {
-      const next = stepQueueNavIndex(selectedRow, rows.length, key.name);
-      select(next, activeIndex(rows[next]));
-    } else if (key.name === "left" || key.name === "right") {
-      const count = row?.actions.length ?? 0;
-      if (count > 0)
-        select(selectedRow, stepQueueNavIndex(selectedAction, count, key.name === "left" ? "up" : "down"));
-    } else if (key.name === "return" || key.name === "linefeed" || key.name === "kpenter") {
-      press(true);
-    } else {
-      return;
-    }
-    swallow(key);
-  });
-  let unsubscribeTheme = () => {};
-  const groups = new Set(rows.map((row) => row.group)).size;
-  selectedAction = activeIndex(rows[0]);
-  const handle = openModal(core, chrome, {
-    title: SETTINGS_COMMAND,
-    tabs: [{ id: "settings", label: "Settings" }],
-    footer: SETTINGS_FOOTER,
-    contentRows: rows.length * 2 + groups,
-    renderTab: (_tabId, tabBody, ctx) => {
-      body = tabBody;
-      budget = ctx.height;
-      blocks = [];
-      paint();
-    },
-    onClose: () => {
-      closed = true;
-      unsubscribeKeys();
-      unsubscribeTheme();
-    }
-  });
-  if (handle === undefined) {
-    unsubscribeKeys();
-    return;
-  }
-  unsubscribeTheme = onThemeChange(guardedThemeRepaint("settings-modal", paint, () => closed || isRenderableGone(body) || r.isDestroyed === true));
-  return handle;
-}
-var SETTINGS_COMMAND = "/settings", CONFIRM_MIN_GAP_MS = 400, SETTINGS_FOOTER, lineCount = (rows, from, to) => {
-  let lines = 0;
-  for (let i = from;i <= to; i++) {
-    lines += 2 + (i === from || rows[i - 1].group !== rows[i].group ? 1 : 0);
-  }
-  return lines;
-};
-var init_settings_modal = __esm(() => {
-  init_action_button();
-  init_modal_host();
-  init_queue_nav();
-  init_theme();
-  init_theme_repaint();
-  init_theme_text();
-  SETTINGS_FOOTER = [
-    { key: "\u2191/\u2193", label: "setting" },
-    { key: "\u2190/\u2192", label: "value" },
-    { key: "Enter", label: "apply" },
-    { key: "esc", label: "close" }
-  ];
-});
-
 // src/tui/theme-picker.ts
 function isThemeCommand(line) {
   const token = line.trim().split(/\s+/)[0] ?? "";
@@ -130551,7 +131741,7 @@ function booleanOr(value, fallback) {
   return typeof value === "boolean" ? value : fallback;
 }
 var DEFAULT_WIKI_CONFIG;
-var init_config11 = __esm(() => {
+var init_config12 = __esm(() => {
   init_fs();
   init_json();
   DEFAULT_WIKI_CONFIG = {
@@ -131998,7 +133188,7 @@ var init_enrich2 = __esm(() => {
   init_fs();
   init_shell_config();
   init_collect();
-  init_config11();
+  init_config12();
   init_deep_enrich();
   init_service4();
   init_staleness2();
@@ -134220,13 +135410,13 @@ function formatExternalWork(events, options = {}) {
 }
 function formatTranscriptFooter(summary) {
   const parts = [
-    plural2(summary.toolCalls, "tool call"),
-    `${plural2(summary.turns, "turn")} (derived)`,
-    plural2(summary.retries, "retry", "retries"),
+    plural3(summary.toolCalls, "tool call"),
+    `${plural3(summary.turns, "turn")} (derived)`,
+    plural3(summary.retries, "retry", "retries"),
     `cost ${formatCostUnits(summary.costUnits)}`
   ];
   if (summary.operatorMessages > 0)
-    parts.push(plural2(summary.operatorMessages, "operator message"));
+    parts.push(plural3(summary.operatorMessages, "operator message"));
   const status = summary.outcome === undefined ? "running" : summary.outcome.kind === "finished" ? "finished" : "failed";
   return `\u2500\u2500 ${status} \xB7 ${parts.join(" \xB7 ")}`;
 }
@@ -134374,7 +135564,7 @@ function describeSkips(skippedLines) {
     return "(not counted)";
   return skippedLines === 0 ? "0" : `${skippedLines} (possible CLI version drift)`;
 }
-function plural2(count, singular, pluralForm) {
+function plural3(count, singular, pluralForm) {
   return `${count} ${count === 1 ? singular : pluralForm ?? `${singular}s`}`;
 }
 function clip6(value, width) {
@@ -137985,7 +139175,7 @@ import http from "http";
 import https from "https";
 import net2 from "net";
 import dns from "dns";
-import { unlinkSync as unlinkSync7 } from "fs";
+import { unlinkSync as unlinkSync8 } from "fs";
 function normalizeHost(host) {
   return host.toLowerCase().replace(/\.$/, "");
 }
@@ -138298,7 +139488,7 @@ async function createAllowlistProxy(opts) {
   });
   if (opts.unixSocketPath !== undefined) {
     try {
-      unlinkSync7(opts.unixSocketPath);
+      unlinkSync8(opts.unixSocketPath);
     } catch {}
     await new Promise((resolve) => server.listen(opts.unixSocketPath, () => resolve()));
   } else {
@@ -142171,6 +143361,8 @@ async function launchTuiAgentShell(opts) {
   let liveReviewsPanel;
   let remoteBridge;
   let liveRemotePanel;
+  let liveChannelsPanel;
+  const channelsClient = new ChannelsClient;
   let liveApprovals;
   let liveExternalDiff;
   let detachExternal;
@@ -142199,6 +143391,7 @@ async function launchTuiAgentShell(opts) {
         liveSchedules?.dispose();
         liveReviewsPanel?.dispose();
         liveRemotePanel?.dispose();
+        liveChannelsPanel?.dispose();
         remoteBridge?.disable();
         liveApprovals?.dispose();
         liveExternalDiff?.dispose();
@@ -142498,6 +143691,11 @@ async function launchTuiAgentShell(opts) {
       getStatus: remoteStatus,
       onOpen: () => showRemoteControl()
     });
+    liveChannelsPanel = mountChannelsPanel(otui, r, sidebar, {
+      width: SIDEBAR_TEXT_WIDTH,
+      load: () => loadChannelsSnapshot(channelsClient),
+      onOpen: () => showChannels()
+    });
     const approvals = mountApprovalsSidebar({
       otui,
       chrome,
@@ -143942,6 +145140,28 @@ Staying in the current session.
         enableRemoteControl(request.name);
       }
     };
+    const showChannels = () => {
+      openChannels(otui, chrome, {
+        client: channelsClient,
+        renderer: r,
+        ...inspectorKeys,
+        onPaste: (handler) => {
+          r._internalKeyInput.onInternal("paste", handler);
+          return () => r._internalKeyInput.offInternal("paste", handler);
+        },
+        inputBlocked: () => chrome.keyboardOwnedElsewhere(),
+        onChanged: (next) => liveChannelsPanel?.update(next)
+      });
+    };
+    const runChannelsCommand = (line) => {
+      const request = parseChannelsArgs(line);
+      if (request.action === "invalid") {
+        io.onSystem?.(`${request.message}
+`);
+        return;
+      }
+      showChannels();
+    };
     const showGame = (line) => {
       const timeoutMatch = /\/game\s+(\d+)/.exec(line);
       openGamesModal(otui, chrome, {
@@ -145030,6 +146250,10 @@ ${formatThemeList(getThemeId())}`);
             runRemoteControlCommand(line);
             return;
           }
+          case "channels": {
+            runChannelsCommand(line);
+            return;
+          }
           case "schedules": {
             routeSchedulesCommand(line, true, schedules);
             return;
@@ -145352,6 +146576,10 @@ ${formatThemeList(getThemeId())}`);
           runRemoteControlCommand(line);
           return;
         }
+        if (isChannelsCommand(command.name)) {
+          runChannelsCommand(line);
+          return;
+        }
         if (routeSchedulesCommand(line, false, schedules)) {
           return;
         }
@@ -146160,6 +147388,8 @@ var init_tui_shell = __esm(() => {
   init_product_open_surface();
   init_reviews_inspector();
   init_shell_bridge();
+  init_channels_client();
+  init_channels_surface();
   init_remote_control_surface();
   init_flow_check_ac();
   init_ops_sidebar();
@@ -146708,7 +147938,7 @@ var init_chat_shell = __esm(() => {
 
 // src/tui/debug-watcher.ts
 import { spawn as spawn8, spawnSync as spawnSync7 } from "child_process";
-import { closeSync as closeSync7, constants as constants4, openSync as openSync8, readdirSync as readdirSync11, readFileSync as readFileSync24, readlinkSync as readlinkSync3, statSync as statSync17 } from "fs";
+import { closeSync as closeSync7, constants as constants4, openSync as openSync8, readdirSync as readdirSync11, readFileSync as readFileSync24, readlinkSync as readlinkSync3, statSync as statSync18 } from "fs";
 import path284 from "path";
 function parseEpollFdinfo(text) {
   const out = [];
@@ -146956,7 +148186,7 @@ async function runDebugWatcher(argv) {
       sample.pending = pendingOf(ttyFd);
     }
     try {
-      sample.heartbeatAgeMs = Date.now() - statSync17(shellLog).mtimeMs;
+      sample.heartbeatAgeMs = Date.now() - statSync18(shellLog).mtimeMs;
     } catch {
       sample.heartbeatAgeMs = undefined;
     }
@@ -148764,6 +149994,8 @@ ${GUTTER}${turnSeparator()}
           }
         } else if (isRemoteControlCommand(command)) {
           agentIo.onSystem?.(readlineRemoteControlText(line));
+        } else if (isChannelsCommand(command)) {
+          agentIo.onSystem?.(readlineChannelsText(line, await loadChannelsSnapshot(new ChannelsClient)));
         } else if (isSessionInfoCommand(command)) {
           const cwd = sessionCwd;
           const [workspaces, flows] = await Promise.all([
@@ -149900,6 +151132,8 @@ var init_shell = __esm(() => {
   init_metrics();
   init_reviews_inspector();
   init_remote_control_surface();
+  init_channels_client();
+  init_channels_surface();
   init_session_info();
   init_model_limits();
   init_shell_config();
@@ -149962,6 +151196,7 @@ var init_shell = __esm(() => {
     "/setup",
     "/reviews",
     "/remote-control",
+    "/channels",
     "/theme",
     "/settings",
     "/mode",
@@ -158100,7 +159335,7 @@ var init_authoring_lint = __esm(() => {
 
 // src/gdskills/governance/stocktake.ts
 import { createHash as createHash68 } from "crypto";
-import { existsSync as existsSync54, readdirSync as readdirSync13, readFileSync as readFileSync26, statSync as statSync18 } from "fs";
+import { existsSync as existsSync54, readdirSync as readdirSync13, readFileSync as readFileSync26, statSync as statSync19 } from "fs";
 import path306 from "path";
 function cacheKeyMatches(cached, inputs, quick) {
   return cached.algorithmVersion === ALGORITHM_VERSION && cached.quick === quick && cached.sha256 === inputs.sha256 && cached.catalogFingerprint === inputs.catalogFingerprint && cached.verificationReportHash === inputs.verificationReportHash && cached.referencesHash === inputs.referencesHash;
@@ -158129,7 +159364,7 @@ function referencesHash(entry) {
     for (const name of readdirSync13(dir).sort()) {
       const full = path306.join(dir, name);
       const rel = relative.length > 0 ? `${relative}/${name}` : name;
-      if (statSync18(full).isDirectory()) {
+      if (statSync19(full).isDirectory()) {
         walk(full, rel);
       } else {
         files.push(rel);
@@ -175788,7 +177023,7 @@ async function dispatchReadResource(ctx, uri) {
   }
 }
 var init_dispatch3 = __esm(() => {
-  init_config10();
+  init_config11();
   init_discovery();
   init_tools3();
   init_resources();
@@ -183277,7 +184512,14 @@ var init_serve_server = __esm(() => {
     ["reply", "POST"],
     ["approval", "POST"],
     ["ack", "POST"],
-    ["stream", "GET"]
+    ["stream", "GET"],
+    ["channels-status", "GET"],
+    ["channels-pair", "POST"],
+    ["channels-pairing", "GET"],
+    ["channels-cancel", "POST"],
+    ["channels-reload", "POST"],
+    ["channels-test", "POST"],
+    ["channels-disconnect", "POST"]
   ]);
   JSON_HEADERS = { "content-type": "application/json; charset=utf-8" };
 });
@@ -183309,6 +184551,68 @@ var init_serve_runner = __esm(() => {
   init_serve_turn();
 });
 
+// src/remote/naming.ts
+import { createHash as createHash77 } from "crypto";
+import { hostname as hostname5 } from "os";
+import path348 from "path";
+function nameKey(name) {
+  return name.normalize("NFC").trim().toLowerCase();
+}
+function checkName(raw) {
+  const name = raw.normalize("NFC").replace(/\s+/g, " ").trim();
+  if (name.length === 0) {
+    return { ok: false, reason: "the topic name is empty" };
+  }
+  if (name.length > MAX_TOPIC_NAME_LENGTH) {
+    return { ok: false, reason: `the topic name is longer than ${MAX_TOPIC_NAME_LENGTH} characters` };
+  }
+  if (/[\u0000-\u001f\u007f]/.test(name)) {
+    return { ok: false, reason: "the topic name contains control characters" };
+  }
+  return { ok: true, name };
+}
+function projectSlug(project) {
+  const base = path348.basename(project.replace(/[\\/]+$/, "")) || project;
+  const slug = base.normalize("NFKD").replace(/[^A-Za-z0-9._-]+/g, "-").replace(/-+/g, "-").replace(/^[-.]+|[-.]+$/g, "").slice(0, MAX_PROJECT_SLUG);
+  return slug.length > 0 ? slug : "project";
+}
+function idChars(sessionId) {
+  const chars = sessionId.replace(/[^A-Za-z0-9]/g, "");
+  return chars.length > 0 ? chars : "session";
+}
+function machineSlug(machine) {
+  const slug = machine.normalize("NFKD").replace(/[^A-Za-z0-9._-]+/g, "-").replace(/-+/g, "-").replace(/^[-.]+|[-.]+$/g, "").slice(0, MAX_MACHINE_SLUG);
+  return slug.length > 0 ? slug : `host-${createHash77("sha256").update(machine.normalize("NFC")).digest("hex").slice(0, 6)}`;
+}
+function localMachineName(read = hostname5) {
+  let name = "";
+  try {
+    name = read().trim();
+  } catch {}
+  return name.length > 0 ? name : "this-machine";
+}
+function defaultName(project, sessionId, length = SHORT_ID_START, machine) {
+  const base = `${projectSlug(project)}-${idChars(sessionId).slice(0, length)}`;
+  return machine === undefined ? base : `${machineSlug(machine)}-${base}`;
+}
+function* defaultNameCandidates(project, sessionId, machine) {
+  const total = idChars(sessionId).length;
+  const seen = new Set;
+  for (let length = SHORT_ID_START;; length += 4) {
+    const bounded = Math.min(length, total);
+    const name = defaultName(project, sessionId, bounded, machine);
+    if (!seen.has(name)) {
+      seen.add(name);
+      yield name;
+    }
+    if (bounded >= total) {
+      return;
+    }
+  }
+}
+var MAX_TOPIC_NAME_LENGTH = 128, MAX_PROJECT_SLUG = 40, MAX_MACHINE_SLUG = 24, SHORT_ID_START = 8;
+var init_naming = () => {};
+
 // src/remote/types.ts
 function isBotApiError(value) {
   return value instanceof BotApiError;
@@ -183420,7 +184724,7 @@ function createHttpBotApi(options) {
       const timeoutSec = params.timeoutSec ?? 0;
       const body = {
         timeout: timeoutSec,
-        allowed_updates: ["message", "callback_query"]
+        allowed_updates: ["message", "callback_query", "my_chat_member"]
       };
       if (params.offset !== undefined) {
         body.offset = params.offset;
@@ -183463,6 +184767,15 @@ function createHttpBotApi(options) {
         body.text = params.text;
       }
       await call("answerCallbackQuery", body);
+    },
+    async getMe() {
+      return call("getMe", {});
+    },
+    async getChat(params) {
+      return call("getChat", { chat_id: params.chatId });
+    },
+    async getChatMember(params) {
+      return call("getChatMember", { chat_id: params.chatId, user_id: params.userId });
     }
   };
 }
@@ -183472,123 +184785,6 @@ var init_bot_api_http = __esm(() => {
   init_types11();
 });
 
-// src/remote/config.ts
-import { statSync as statSync19 } from "fs";
-function isSafeInt(value) {
-  return typeof value === "number" && Number.isSafeInteger(value);
-}
-function parseRemoteConfig(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    return { ok: false, reason: "remote config must be a JSON object" };
-  }
-  const doc = value;
-  for (const key of Object.keys(doc)) {
-    if (!CONFIG_KEYS2.has(key)) {
-      const shown = /^[A-Za-z_][A-Za-z0-9_]{0,30}$/.test(key) ? key : "<not shown>";
-      return { ok: false, reason: `remote config has an unknown key "${shown}" (the schema is closed)` };
-    }
-  }
-  if (doc.schemaVersion !== REMOTE_CONFIG_SCHEMA_VERSION) {
-    return { ok: false, reason: `remote config schemaVersion must be ${REMOTE_CONFIG_SCHEMA_VERSION}` };
-  }
-  if (!isSafeInt(doc.chatId) || doc.chatId === 0) {
-    return { ok: false, reason: "remote config chatId must be a non-zero integer (the supergroup id)" };
-  }
-  const ids = doc.allowedUserIds;
-  if (!Array.isArray(ids) || ids.length === 0 || !ids.every((id) => isSafeInt(id) && id > 0)) {
-    return { ok: false, reason: "remote config allowedUserIds must be a non-empty array of positive integers" };
-  }
-  const timeout = (key, fallback) => {
-    const raw = doc[key];
-    if (raw === undefined) {
-      return { ok: true, value: fallback };
-    }
-    if (!isSafeInt(raw) || raw < 1 || raw > MAX_TIMEOUT_MS3) {
-      return { ok: false, reason: `remote config ${key} must be an integer from 1 to ${MAX_TIMEOUT_MS3} (milliseconds)` };
-    }
-    return { ok: true, value: raw };
-  };
-  const orphan = timeout("orphanMs", DEFAULT_ORPHAN_MS);
-  if (!orphan.ok) {
-    return orphan;
-  }
-  const run = timeout("runTimeoutMs", DEFAULT_RUN_TIMEOUT_MS);
-  if (!run.ok) {
-    return run;
-  }
-  return {
-    ok: true,
-    value: {
-      schemaVersion: REMOTE_CONFIG_SCHEMA_VERSION,
-      chatId: doc.chatId,
-      allowedUserIds: [...new Set(ids)],
-      orphanMs: orphan.value,
-      runTimeoutMs: run.value
-    }
-  };
-}
-function loadRemoteConfig(dir) {
-  const file = remoteConfigPath(dir);
-  const read = readConfigFile(file);
-  if (!read.ok) {
-    return {
-      ok: false,
-      reason: read.reason === "absent" ? `no remote-control config at ${file}; create it with chatId and allowedUserIds` : `remote-control config at ${file} cannot be read (${read.reason})`
-    };
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(read.text);
-  } catch {
-    return { ok: false, reason: `remote-control config at ${file} is not valid JSON` };
-  }
-  return parseRemoteConfig(parsed);
-}
-function loadBotToken(dir) {
-  const file = botTokenPath(dir);
-  let mode;
-  try {
-    const stats = statSync19(file);
-    if (!stats.isFile()) {
-      return { ok: false, reason: `bot token path ${file} is not a regular file` };
-    }
-    mode = stats.mode & 511;
-  } catch {
-    return {
-      ok: false,
-      reason: `no bot token file at ${file}; put the token on one line in it and run: chmod 600 ${file}`
-    };
-  }
-  if (process.platform !== "win32" && (mode & 63) !== 0) {
-    return {
-      ok: false,
-      reason: `bot token file ${file} is accessible to other users (mode ${mode.toString(8)}); run: chmod 600 ${file}`
-    };
-  }
-  const read = readConfigFile(file);
-  if (!read.ok) {
-    return { ok: false, reason: `bot token file ${file} cannot be read (${read.reason})` };
-  }
-  const token = read.text.trim();
-  if (!TOKEN_SHAPE2.test(token)) {
-    return {
-      ok: false,
-      reason: `bot token file ${file} does not hold a bot token (expected <digits>:<secret> on a single line)`
-    };
-  }
-  return { ok: true, value: token };
-}
-var REMOTE_CONFIG_SCHEMA_VERSION = 1, DEFAULT_ORPHAN_MS, DEFAULT_RUN_TIMEOUT_MS, MAX_TIMEOUT_MS3, CONFIG_KEYS2, TOKEN_SHAPE2;
-var init_config12 = __esm(() => {
-  init_config_dir();
-  init_paths4();
-  DEFAULT_ORPHAN_MS = 10 * 60000;
-  DEFAULT_RUN_TIMEOUT_MS = 30 * 60000;
-  MAX_TIMEOUT_MS3 = 7 * 24 * 60 * 60000;
-  CONFIG_KEYS2 = new Set(["schemaVersion", "chatId", "allowedUserIds", "orphanMs", "runTimeoutMs"]);
-  TOKEN_SHAPE2 = /^\d{5,}:[A-Za-z0-9_-]{20,}$/;
-});
-
 // src/remote/durable-log.ts
 import { renameSync as renameSync6 } from "fs";
 
@@ -183730,9 +184926,9 @@ var init_durable_log = __esm(() => {
 });
 
 // src/remote/inbound.ts
-import { createHash as createHash77 } from "crypto";
-import { unlinkSync as unlinkSync8 } from "fs";
-import path348 from "path";
+import { createHash as createHash78 } from "crypto";
+import { unlinkSync as unlinkSync9 } from "fs";
+import path349 from "path";
 function parseEntry4(value) {
   if (typeof value !== "object" || value === null) {
     return;
@@ -183763,8 +184959,8 @@ class InboundQueues {
     this.directory = ensureRemoteDir(this.dir, INBOUND_DIRNAME);
   }
   fileFor(bindingKey) {
-    const name = createHash77("sha256").update(bindingKey).digest("hex").slice(0, 32);
-    return path348.join(this.directory, `${name}.jsonl`);
+    const name = createHash78("sha256").update(bindingKey).digest("hex").slice(0, 32);
+    return path349.join(this.directory, `${name}.jsonl`);
   }
   log(bindingKey) {
     let log = this.logs.get(bindingKey);
@@ -183791,7 +184987,7 @@ class InboundQueues {
   remove(bindingKey) {
     this.logs.delete(bindingKey);
     try {
-      unlinkSync8(this.fileFor(bindingKey));
+      unlinkSync9(this.fileFor(bindingKey));
     } catch {}
   }
 }
@@ -183801,7 +184997,7 @@ class PollerState {
   ids = new Set;
   top = 0;
   constructor(options) {
-    this.file = path348.join(ensureRemoteDir(options.dir), POLLER_STATE_FILE);
+    this.file = path349.join(ensureRemoteDir(options.dir), POLLER_STATE_FILE);
   }
   load() {
     this.ids.clear();
@@ -183872,13 +185068,13 @@ var init_inbound = __esm(() => {
 
 // src/remote/journal.ts
 import { renameSync as renameSync7, statSync as statSync20 } from "fs";
-import path349 from "path";
+import path350 from "path";
 
 class RejectedJournal {
   file;
   now;
   constructor(options) {
-    this.file = path349.join(ensureRemoteDir(options.dir), REJECTED_JOURNAL_FILE);
+    this.file = path350.join(ensureRemoteDir(options.dir), REJECTED_JOURNAL_FILE);
     this.now = options.now;
   }
   get path() {
@@ -183903,54 +185099,6 @@ var init_journal2 = __esm(() => {
   init_paths4();
 });
 
-// src/remote/naming.ts
-import path350 from "path";
-function nameKey(name) {
-  return name.normalize("NFC").trim().toLowerCase();
-}
-function checkName(raw) {
-  const name = raw.normalize("NFC").replace(/\s+/g, " ").trim();
-  if (name.length === 0) {
-    return { ok: false, reason: "the topic name is empty" };
-  }
-  if (name.length > MAX_TOPIC_NAME_LENGTH) {
-    return { ok: false, reason: `the topic name is longer than ${MAX_TOPIC_NAME_LENGTH} characters` };
-  }
-  if (/[\u0000-\u001f\u007f]/.test(name)) {
-    return { ok: false, reason: "the topic name contains control characters" };
-  }
-  return { ok: true, name };
-}
-function projectSlug(project) {
-  const base = path350.basename(project.replace(/[\\/]+$/, "")) || project;
-  const slug = base.normalize("NFKD").replace(/[^A-Za-z0-9._-]+/g, "-").replace(/-+/g, "-").replace(/^[-.]+|[-.]+$/g, "").slice(0, MAX_PROJECT_SLUG);
-  return slug.length > 0 ? slug : "project";
-}
-function idChars(sessionId) {
-  const chars = sessionId.replace(/[^A-Za-z0-9]/g, "");
-  return chars.length > 0 ? chars : "session";
-}
-function defaultName(project, sessionId, length = SHORT_ID_START) {
-  return `${projectSlug(project)}-${idChars(sessionId).slice(0, length)}`;
-}
-function* defaultNameCandidates(project, sessionId) {
-  const total = idChars(sessionId).length;
-  const seen = new Set;
-  for (let length = SHORT_ID_START;; length += 4) {
-    const bounded = Math.min(length, total);
-    const name = defaultName(project, sessionId, bounded);
-    if (!seen.has(name)) {
-      seen.add(name);
-      yield name;
-    }
-    if (bounded >= total) {
-      return;
-    }
-  }
-}
-var MAX_TOPIC_NAME_LENGTH = 128, MAX_PROJECT_SLUG = 40, SHORT_ID_START = 8;
-var init_naming = () => {};
-
 // src/remote/format.ts
 function openingFence(line) {
   const match = FENCE_LINE2.exec(line);
@@ -184464,6 +185612,9 @@ var init_registry6 = __esm(() => {
 function describeError4(error) {
   return redactSensitiveText(error instanceof Error ? error.message : String(error));
 }
+function isThreadGone(error) {
+  return error.kind === "rejected" && /thread not found|topic_id_invalid|topic.*not found/i.test(error.message);
+}
 function formatDuration(ms) {
   if (ms % 60000 === 0) {
     const minutes = ms / 60000;
@@ -184476,6 +185627,7 @@ function formatDuration(ms) {
 class RemoteHub {
   api;
   config;
+  machine;
   consumer;
   now;
   timers;
@@ -184500,6 +185652,7 @@ class RemoteHub {
   constructor(options) {
     this.api = options.api;
     this.config = options.config;
+    this.machine = options.machine;
     this.consumer = { deliver: options.deliver, ...options.deliverCallback === undefined ? {} : { deliverCallback: options.deliverCallback } };
     this.now = options.now ?? Date.now;
     this.timers = options.timers ?? realTimers;
@@ -184624,6 +185777,19 @@ class RemoteHub {
       return { ok: true, existed: true };
     });
   }
+  deleteAllTopics() {
+    return this.serial(async () => {
+      const records = this.registry.records();
+      for (const record of records) {
+        await this.retire(record, "channel disconnected", true);
+      }
+      const remaining = this.registry.records().length;
+      return { deleted: records.length - remaining, remaining };
+    });
+  }
+  async sendGeneral(text) {
+    await this.api.sendMessage({ chatId: this.config.chatId, text });
+  }
   heartbeat(sessionId) {
     return this.serial(async () => {
       const record = this.registry.bySession(sessionId);
@@ -184792,7 +185958,7 @@ class RemoteHub {
       name = existing.name;
     } else {
       let chosen;
-      for (const candidate of defaultNameCandidates(input.project, input.sessionId)) {
+      for (const candidate of defaultNameCandidates(input.project, input.sessionId, this.machine)) {
         const holder = this.registry.byNameKey(candidate);
         if (holder === undefined || holder.sessionId === input.sessionId || !isLive(holder, now)) {
           chosen = candidate;
@@ -184849,12 +186015,13 @@ class RemoteHub {
     await this.flushOutbound();
     return { ok: true, name, threadId: record.threadId, reused: false };
   }
-  async retire(record, why) {
+  async retire(record, why, strict = false) {
     this.outbound.discardForThread(record.chatId, record.threadId);
     try {
       await this.api.deleteForumTopic({ chatId: record.chatId, messageThreadId: record.threadId });
     } catch (error) {
-      if (isBotApiError(error) && isRetryable(error)) {
+      const stillThere = strict && isBotApiError(error) && !isThreadGone(error);
+      if (isBotApiError(error) && (isRetryable(error) || stillThere)) {
         record.sessionId = "";
         record.status = "unavailable";
         record.unavailableSince = this.now() - this.config.orphanMs;
@@ -184871,6 +186038,9 @@ class RemoteHub {
   route(update) {
     const message = update.message;
     const query = update.callback_query;
+    if (message === undefined && query === undefined) {
+      return;
+    }
     const fromId = message?.from?.id ?? query?.from.id;
     if (fromId === undefined || !this.config.allowedUserIds.includes(fromId)) {
       this.journal.record(fromId);
@@ -184985,151 +186155,43 @@ var init_hub = __esm(() => {
 });
 
 // src/remote/bootstrap.ts
+function openBotApi(options) {
+  if (options.api !== undefined) {
+    return { ok: true, api: options.api };
+  }
+  const token = loadBotToken(options.dir);
+  if (!token.ok) {
+    return { ok: false, reason: token.reason };
+  }
+  return {
+    ok: true,
+    api: createHttpBotApi({
+      token: token.value,
+      ...options.fetchImpl === undefined ? {} : { fetchImpl: options.fetchImpl },
+      ...options.baseUrl === undefined ? {} : { baseUrl: options.baseUrl }
+    })
+  };
+}
 function openRemoteHub(options) {
   const config = loadRemoteConfig(options.dir);
   if (!config.ok) {
     return { ok: false, reason: config.reason };
   }
-  let api = options.api;
-  if (api === undefined) {
-    const token = loadBotToken(options.dir);
-    if (!token.ok) {
-      return { ok: false, reason: token.reason };
-    }
-    api = createHttpBotApi({
-      token: token.value,
-      ...options.fetchImpl === undefined ? {} : { fetchImpl: options.fetchImpl },
-      ...options.baseUrl === undefined ? {} : { baseUrl: options.baseUrl }
-    });
+  const opened = openBotApi(options);
+  if (!opened.ok) {
+    return { ok: false, reason: opened.reason };
   }
   const { api: _api, fetchImpl: _fetch, baseUrl: _base, ...rest } = options;
-  return { ok: true, hub: new RemoteHub({ ...rest, api, config: config.value }) };
+  return { ok: true, hub: new RemoteHub({ ...rest, api: opened.api, config: config.value }) };
 }
 var init_bootstrap2 = __esm(() => {
   init_bot_api_http();
-  init_config12();
+  init_config10();
   init_hub();
 });
 
-// src/remote/poll-lock.ts
-import { randomBytes as randomBytes13 } from "crypto";
-import { linkSync, renameSync as renameSync8, statSync as statSync21, unlinkSync as unlinkSync9 } from "fs";
-import path353 from "path";
-function pollerLockPath(dir) {
-  return path353.join(remoteDirPath(dir), POLLER_LOCK_FILE);
-}
-function processIsAlive3(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return typeof error === "object" && error !== null && "code" in error && error.code === "EPERM";
-  }
-}
-function parsePid(text) {
-  const pid = Number.parseInt(text.trim(), 10);
-  return Number.isInteger(pid) && pid > 0 ? pid : Number.NaN;
-}
-function refusal4(holder) {
-  return {
-    ok: false,
-    holderPid: holder,
-    reason: `another keryx serve (pid ${holder}) already polls this bot token on this machine; this one will not poll. Stop it, or use a different bot.`
-  };
-}
-function createWhole(file, pid) {
-  const staging = `${file}.${pid}.${randomBytes13(6).toString("hex")}.new`;
-  createOwnerOnlyFileExclusive(staging, `${pid}
-`);
-  try {
-    linkSync(staging, file);
-    return true;
-  } catch (error) {
-    if (typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST") {
-      return false;
-    }
-    return createOwnerOnlyFileExclusive(file, `${pid}
-`);
-  } finally {
-    try {
-      unlinkSync9(staging);
-    } catch {}
-  }
-}
-function acquirePollLock(options = {}) {
-  ensureRemoteDir(options.dir);
-  const file = pollerLockPath(options.dir);
-  const pid = options.pid ?? process.pid;
-  const isAlive = options.isAlive ?? processIsAlive3;
-  const now = options.now ?? Date.now;
-  for (let attempt = 0;attempt < 4; attempt += 1) {
-    if (createWhole(file, pid)) {
-      return {
-        ok: true,
-        release() {
-          const current = readConfigFile(file);
-          if (current.ok && parsePid(current.text) === pid) {
-            try {
-              unlinkSync9(file);
-            } catch {}
-          }
-        }
-      };
-    }
-    const held = readConfigFile(file);
-    if (!held.ok && held.reason === "absent") {
-      continue;
-    }
-    const holder = held.ok ? parsePid(held.text) : Number.NaN;
-    if (Number.isInteger(holder) && isAlive(holder)) {
-      return refusal4(holder);
-    }
-    if (!Number.isInteger(holder)) {
-      let youngerThanGrace;
-      try {
-        youngerThanGrace = now() - statSync21(file).mtimeMs < EMPTY_LOCK_GRACE_MS;
-      } catch {
-        continue;
-      }
-      if (youngerThanGrace) {
-        return {
-          ok: false,
-          holderPid: 0,
-          reason: `another keryx serve is creating ${file} right now; this one will not poll. Try again in a moment.`
-        };
-      }
-    }
-    const aside = `${file}.stale-${pid}-${randomBytes13(6).toString("hex")}`;
-    try {
-      renameSync8(file, aside);
-    } catch {
-      continue;
-    }
-    const moved = readConfigFile(aside);
-    const movedPid = moved.ok ? parsePid(moved.text) : Number.NaN;
-    if (Number.isInteger(movedPid) && movedPid !== holder && isAlive(movedPid)) {
-      try {
-        linkSync(aside, file);
-      } catch {}
-      try {
-        unlinkSync9(aside);
-      } catch {}
-      return refusal4(movedPid);
-    }
-    try {
-      unlinkSync9(aside);
-    } catch {}
-  }
-  return { ok: false, holderPid: 0, reason: `could not take the poller lock at ${file}` };
-}
-var POLLER_LOCK_FILE = "poller.lock", EMPTY_LOCK_GRACE_MS = 5000;
-var init_poll_lock = __esm(() => {
-  init_config_dir();
-  init_paths4();
-});
-
 // src/remote/http-surface.ts
-import { randomBytes as randomBytes14 } from "crypto";
+import { randomBytes as randomBytes13 } from "crypto";
 function ok2(body, status = 200) {
   return new Response(`${JSON.stringify({ schemaVersion: REMOTE_SCHEMA_VERSION, ...body })}
 `, { status, headers: JSON_HEADERS2 });
@@ -185237,11 +186299,15 @@ class ShellStream {
     this.onEnded(this);
   }
 }
+function isChannelsRoute(route) {
+  return Object.hasOwn(CHANNELS_ROUTE_METHODS, route);
+}
 
 class RemoteHttpSurface {
   options;
   consumer;
   hub;
+  channels;
   unavailableReason = "remote control is not running in this serve";
   closed = false;
   now;
@@ -185261,7 +186327,7 @@ class RemoteHttpSurface {
     this.timers = options.timers ?? realTimers;
     this.keepaliveMs = options.keepaliveMs ?? DEFAULT_KEEPALIVE_MS;
     this.ackTimeoutMs = options.ackTimeoutMs ?? DEFAULT_ACK_TIMEOUT_MS;
-    this.newApprovalId = options.approvalIds ?? (() => `ap${randomBytes14(6).toString("hex")}`);
+    this.newApprovalId = options.approvalIds ?? (() => `ap${randomBytes13(6).toString("hex")}`);
     this.consumer = {
       deliver: (sessionId, line, meta) => this.deliver(sessionId, line, meta),
       deliverCallback: (sessionId, callback) => this.deliverCallback(sessionId, callback)
@@ -185271,6 +186337,15 @@ class RemoteHttpSurface {
     return this.options.verifyShellToken(presented);
   }
   async handle(route, request, io) {
+    if (isChannelsRoute(route)) {
+      if (this.closed || this.channels === undefined) {
+        return fail4(503, "remote-unavailable", "channels are not available in this serve");
+      }
+      if (request.method !== CHANNELS_ROUTE_METHODS[route]) {
+        return fail4(405, "method-not-allowed", "Method not allowed.", { allow: CHANNELS_ROUTE_METHODS[route] });
+      }
+      return this.channels(route, request);
+    }
     const hub = this.hub;
     if (this.closed || hub === undefined) {
       return fail4(503, "remote-unavailable", this.unavailableReason);
@@ -185310,6 +186385,9 @@ class RemoteHttpSurface {
       this.dropApproval(id);
     }
   }
+  setChannels(handler) {
+    this.channels = handler;
+  }
   attach(hub) {
     this.hub = hub;
   }
@@ -185709,20 +186787,536 @@ var init_http_surface = __esm(() => {
   JSON_HEADERS2 = { "content-type": "application/json; charset=utf-8" };
 });
 
-// src/remote/service.ts
-import { unlinkSync as unlinkSync10 } from "fs";
-function openRemoteService(options = {}) {
-  const present = readConfigFile(remoteConfigPath(options.dir));
-  if (!present.ok && present.reason === "absent") {
-    return { status: "disabled" };
+// src/remote/pairing.ts
+import { randomInt as randomInt2 } from "crypto";
+function newPairingCode() {
+  let code = "";
+  for (let i = 0;i < CODE_LENGTH; i += 1) {
+    code += CODE_ALPHABET[randomInt2(CODE_ALPHABET.length)];
   }
-  const config = loadRemoteConfig(options.dir);
-  if (!config.ok) {
-    return { status: "unavailable", reason: config.reason };
+  return code;
+}
+function describe3(error) {
+  return redactSensitiveText(error instanceof Error ? error.message : String(error));
+}
+function normalise2(text) {
+  return text.toUpperCase().replace(/[^A-Z0-9]/g, "");
+}
+
+class Pairing {
+  options;
+  bot;
+  state = "waiting-for-user";
+  code;
+  expiresAt;
+  userId;
+  chatId;
+  chatTitle;
+  problems = [];
+  reason;
+  candidate;
+  poller;
+  now;
+  timers;
+  expiryTimer;
+  finished = false;
+  queue = Promise.resolve();
+  constructor(options, bot) {
+    this.options = options;
+    this.bot = bot;
+    this.now = options.now ?? Date.now;
+    this.timers = options.timers ?? realTimers;
+    this.code = options.code ?? newPairingCode();
+    this.expiresAt = this.now() + (options.ttlMs ?? PAIRING_CODE_TTL_MS);
+    this.poller = new UpdatePoller({
+      api: options.api,
+      sink: { accept: (updates) => this.accept(updates) },
+      ...options.pollTimeoutSec === undefined ? {} : { timeoutSec: options.pollTimeoutSec },
+      ...options.pollBackoffMs === undefined ? {} : { backoffMs: options.pollBackoffMs },
+      ...options.pollSleep === undefined ? {} : { sleep: options.pollSleep },
+      onStatus: (status) => this.onPollerStatus(status)
+    });
+  }
+  static async open(options) {
+    let bot;
+    try {
+      bot = await options.api.getMe();
+    } catch (error) {
+      if (isBotApiError(error) && error.kind === "rejected") {
+        return { ok: false, kind: "rejected", reason: "Telegram does not accept this bot token; check it with BotFather and try again." };
+      }
+      return { ok: false, kind: "unreachable", reason: `could not reach Telegram: ${describe3(error)}` };
+    }
+    const pairing = new Pairing(options, bot);
+    pairing.begin();
+    return { ok: true, pairing };
+  }
+  begin() {
+    const handle = this.timers.setTimeout(() => this.expireIfDue(), Math.max(0, this.expiresAt - this.now()) + 1);
+    handle?.unref?.();
+    this.expiryTimer = handle;
+    this.poller.start();
+  }
+  snapshot() {
+    this.expireIfDue();
+    return {
+      state: this.state,
+      ...this.code === undefined ? {} : { code: this.code },
+      ...this.bot.username === undefined ? {} : { botUsername: this.bot.username },
+      expiresAt: this.expiresAt,
+      ...this.userId === undefined ? {} : { userId: this.userId },
+      ...this.chatId === undefined ? {} : { chatId: this.chatId },
+      ...this.chatTitle === undefined ? {} : { chatTitle: this.chatTitle },
+      problems: [...this.problems],
+      ...this.reason === undefined ? {} : { reason: this.reason }
+    };
+  }
+  isFinal() {
+    this.expireIfDue();
+    return FINAL.has(this.state);
+  }
+  async recheck() {
+    if (this.state === "waiting-for-group" && this.candidate !== undefined) {
+      const chatId = this.candidate;
+      await this.enqueue(() => this.inspectGroup(chatId));
+    }
+  }
+  async cancel() {
+    if (!FINAL.has(this.state)) {
+      this.settle("cancelled");
+    }
+    await this.poller.stop();
+  }
+  async stop() {
+    await this.poller.stop();
+  }
+  onPollerStatus(status) {
+    if (status.state === "conflict" && !FINAL.has(this.state)) {
+      this.reason = status.reason ?? "another poller owns this bot token";
+      this.settle("failed");
+    }
+  }
+  expireIfDue() {
+    if (!FINAL.has(this.state) && this.now() > this.expiresAt) {
+      this.code = undefined;
+      this.settle("expired");
+    }
+  }
+  settle(state) {
+    this.state = state;
+    if (FINAL.has(state)) {
+      this.code = undefined;
+      if (this.expiryTimer !== undefined) {
+        this.timers.clearTimeout(this.expiryTimer);
+        this.expiryTimer = undefined;
+      }
+      this.poller.stop();
+      if (!this.finished) {
+        this.finished = true;
+        this.options.onFinished?.(this.snapshot());
+      }
+    }
+  }
+  enqueue(work) {
+    const next = this.queue.then(work, work);
+    this.queue = next.catch(() => {
+      return;
+    });
+    return next;
+  }
+  accept(updates) {
+    return this.enqueue(async () => {
+      for (const update of updates) {
+        if (FINAL.has(this.state)) {
+          return;
+        }
+        if (this.now() > this.expiresAt) {
+          this.expireIfDue();
+          return;
+        }
+        if (this.state === "waiting-for-user") {
+          await this.takeCode(update);
+        } else if (this.state === "waiting-for-group") {
+          await this.takeGroup(update);
+        }
+      }
+    });
+  }
+  async takeCode(update) {
+    const message = update.message;
+    if (message === undefined || message.chat.type !== "private" || message.from === undefined || typeof message.text !== "string") {
+      return;
+    }
+    if (message.forward_origin !== undefined || message.forward_date !== undefined) {
+      return;
+    }
+    const sent = message.text.trim().replace(/^\/start(?:@\w+)?\s+/i, "");
+    if (this.code === undefined || normalise2(sent) !== this.code) {
+      return;
+    }
+    this.userId = message.from.id;
+    this.code = undefined;
+    this.state = "waiting-for-group";
+    await this.options.api.sendMessage({ chatId: message.chat.id, text: "Paired. Now add me to your group (a group with Topics turned on) and make me an administrator." }).catch(() => {
+      return;
+    });
+  }
+  async takeGroup(update) {
+    const change = update.my_chat_member;
+    if (change === undefined || change.from.id !== this.userId) {
+      return;
+    }
+    const type = change.chat.type;
+    if (type !== "group" && type !== "supergroup") {
+      return;
+    }
+    const status = change.new_chat_member.status;
+    if (status !== "member" && status !== "administrator") {
+      return;
+    }
+    this.candidate = change.chat.id;
+    if (change.chat.title !== undefined) {
+      this.chatTitle = change.chat.title;
+    }
+    await this.inspectGroup(change.chat.id);
+  }
+  async inspectGroup(chatId) {
+    if (FINAL.has(this.state)) {
+      return;
+    }
+    const problems = [];
+    try {
+      const chat = await this.options.api.getChat({ chatId });
+      if (chat.title !== undefined) {
+        this.chatTitle = chat.title;
+      }
+      if (chat.is_forum !== true) {
+        problems.push("Topics are off in this group: open the group settings and turn Topics on.");
+      }
+      const member = await this.options.api.getChatMember({ chatId, userId: this.bot.id });
+      if (member.status !== "administrator" && member.status !== "creator") {
+        problems.push("Make the bot an administrator of the group.");
+      } else if (member.status === "administrator" && member.can_manage_topics !== true) {
+        problems.push("Give the bot the Manage Topics right in the group's administrator settings.");
+      }
+    } catch (error) {
+      problems.push(`could not inspect the group: ${describe3(error)}`);
+    }
+    this.problems = problems;
+    if (problems.length === 0) {
+      this.chatId = chatId;
+      this.settle("ready");
+    }
+  }
+}
+var PAIRING_CODE_TTL_MS, CODE_ALPHABET = "ABCDEFGHJKMNPQRSTUVWXYZ23456789", CODE_LENGTH = 8, FINAL;
+var init_pairing = __esm(() => {
+  init_service2();
+  init_hub();
+  init_poller();
+  init_types11();
+  PAIRING_CODE_TTL_MS = 10 * 60000;
+  FINAL = new Set(["ready", "failed", "expired", "cancelled"]);
+});
+
+// src/remote/channels.ts
+function describe4(error) {
+  return redactSensitiveText(error instanceof Error ? error.message : String(error));
+}
+
+class ChannelsController {
+  options;
+  pairing;
+  generation = 0;
+  chain = Promise.resolve();
+  constructor(options) {
+    this.options = options;
+  }
+  get host() {
+    return this.options.host;
+  }
+  handle(route, _request) {
+    switch (route) {
+      case "channels-status":
+        return Promise.resolve(this.status());
+      case "channels-pair":
+        return this.pair();
+      case "channels-pairing":
+        return this.pairingStatus();
+      case "channels-cancel":
+        return this.cancel();
+      case "channels-reload":
+        return this.reload();
+      case "channels-test":
+        return this.test();
+      case "channels-disconnect":
+        return this.disconnect();
+    }
+  }
+  async stop() {
+    await this.dropPairing();
+  }
+  exclusive(work) {
+    const next = this.chain.then(work, work);
+    this.chain = next.catch(() => {
+      return;
+    });
+    return next;
+  }
+  configured() {
+    const read = readConfigFile(remoteConfigPath(this.host.dir));
+    return read.ok || read.reason !== "absent";
+  }
+  state() {
+    if (this.host.hub() !== undefined) {
+      return { state: "connected" };
+    }
+    if (this.pairing !== undefined && !this.pairing.isFinal()) {
+      return { state: "pairing" };
+    }
+    if (this.configured()) {
+      const reason = this.host.hubReason();
+      return { state: "off", ...reason === undefined ? {} : { reason } };
+    }
+    return { state: "not-connected" };
+  }
+  status() {
+    const { state, reason } = this.state();
+    return ok2({
+      machine: this.host.machine,
+      telegram: { state, ...reason === undefined ? {} : { reason }, sessions: this.host.hub()?.list().length ?? 0 }
+    });
+  }
+  async dropPairing() {
+    const running = this.pairing;
+    this.pairing = undefined;
+    await running?.cancel();
+  }
+  pair() {
+    const mine = ++this.generation;
+    const superseded = () => fail4(409, "superseded", "Another change to this channel came in while the pairing was starting; start again.");
+    return this.exclusive(async () => {
+      if (mine !== this.generation) {
+        return superseded();
+      }
+      if (this.host.hub() !== undefined) {
+        return fail4(409, "already-connected", "Telegram is already connected on this machine; disconnect it first.");
+      }
+      await this.dropPairing();
+      const api = this.host.openApi();
+      if (!api.ok) {
+        return fail4(422, "no-token", api.reason);
+      }
+      const opened = await Pairing.open({
+        api: api.api,
+        ...this.options.now === undefined ? {} : { now: this.options.now },
+        ...this.options.pairing
+      });
+      if (!opened.ok) {
+        return fail4(opened.kind === "rejected" ? 422 : 502, opened.kind === "rejected" ? "token-rejected" : "telegram-unreachable", opened.reason);
+      }
+      if (mine !== this.generation) {
+        await opened.pairing.cancel();
+        return superseded();
+      }
+      this.pairing = opened.pairing;
+      return ok2({ ...opened.pairing.snapshot() });
+    });
   }
+  async pairingStatus() {
+    const current = this.pairing;
+    if (current === undefined) {
+      return fail4(404, "no-pairing", "No pairing is open; start one first.");
+    }
+    await current.recheck();
+    return ok2({ ...current.snapshot() });
+  }
+  async cancel() {
+    this.generation += 1;
+    const had = this.pairing !== undefined;
+    await this.dropPairing();
+    return ok2({ cancelled: had });
+  }
+  reload() {
+    this.generation += 1;
+    return this.exclusive(async () => {
+      await this.dropPairing();
+      const config = loadRemoteConfig(this.host.dir);
+      const token = loadBotToken(this.host.dir);
+      if (!config.ok || !token.ok) {
+        const reason = !config.ok ? config.reason : !token.ok ? token.reason : "";
+        return fail4(422, "cannot-connect", this.host.hub() === undefined ? reason : `${reason} The running channel was left as it was.`);
+      }
+      if (this.host.hub() !== undefined) {
+        await this.host.stopHub("reloading remote control");
+      }
+      const started = await this.host.startHub();
+      if (!started.ok) {
+        return fail4(422, "cannot-connect", started.reason);
+      }
+      return ok2({ state: "connected" });
+    });
+  }
+  async test() {
+    const hub = this.host.hub();
+    if (hub === undefined) {
+      const reason = this.host.hubReason();
+      return fail4(409, "not-connected", reason ?? "Telegram is not connected on this machine.");
+    }
+    try {
+      await hub.sendGeneral(`Keryx test message from ${this.host.machine}: Telegram is connected.`);
+    } catch (error) {
+      return fail4(502, "send-failed", `Telegram did not accept the test message: ${describe4(error)}`);
+    }
+    return ok2({ delivered: true, machine: this.host.machine });
+  }
+  disconnect() {
+    this.generation += 1;
+    return this.exclusive(async () => {
+      await this.dropPairing();
+      const hub = this.host.hub();
+      if (hub === undefined) {
+        return ok2({ deleted: 0, remaining: 0, hubWasRunning: false });
+      }
+      const result = await hub.deleteAllTopics();
+      await this.host.stopHub("Telegram was disconnected");
+      return ok2({ deleted: result.deleted, remaining: result.remaining, hubWasRunning: true });
+    });
+  }
+}
+var init_channels = __esm(() => {
+  init_service2();
+  init_config_dir();
+  init_config10();
+  init_http_surface();
+  init_pairing();
+  init_paths4();
+});
+
+// src/remote/poll-lock.ts
+import { randomBytes as randomBytes14 } from "crypto";
+import { linkSync, renameSync as renameSync8, statSync as statSync21, unlinkSync as unlinkSync10 } from "fs";
+import path353 from "path";
+function pollerLockPath(dir) {
+  return path353.join(remoteDirPath(dir), POLLER_LOCK_FILE);
+}
+function processIsAlive3(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === "EPERM";
+  }
+}
+function parsePid(text) {
+  const pid = Number.parseInt(text.trim(), 10);
+  return Number.isInteger(pid) && pid > 0 ? pid : Number.NaN;
+}
+function refusal4(holder) {
+  return {
+    ok: false,
+    holderPid: holder,
+    reason: `another keryx serve (pid ${holder}) already polls this bot token on this machine; this one will not poll. Stop it, or use a different bot.`
+  };
+}
+function createWhole(file, pid) {
+  const staging = `${file}.${pid}.${randomBytes14(6).toString("hex")}.new`;
+  createOwnerOnlyFileExclusive(staging, `${pid}
+`);
+  try {
+    linkSync(staging, file);
+    return true;
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST") {
+      return false;
+    }
+    return createOwnerOnlyFileExclusive(file, `${pid}
+`);
+  } finally {
+    try {
+      unlinkSync10(staging);
+    } catch {}
+  }
+}
+function acquirePollLock(options = {}) {
+  ensureRemoteDir(options.dir);
+  const file = pollerLockPath(options.dir);
+  const pid = options.pid ?? process.pid;
+  const isAlive = options.isAlive ?? processIsAlive3;
+  const now = options.now ?? Date.now;
+  for (let attempt = 0;attempt < 4; attempt += 1) {
+    if (createWhole(file, pid)) {
+      return {
+        ok: true,
+        release() {
+          const current = readConfigFile(file);
+          if (current.ok && parsePid(current.text) === pid) {
+            try {
+              unlinkSync10(file);
+            } catch {}
+          }
+        }
+      };
+    }
+    const held = readConfigFile(file);
+    if (!held.ok && held.reason === "absent") {
+      continue;
+    }
+    const holder = held.ok ? parsePid(held.text) : Number.NaN;
+    if (Number.isInteger(holder) && isAlive(holder)) {
+      return refusal4(holder);
+    }
+    if (!Number.isInteger(holder)) {
+      let youngerThanGrace;
+      try {
+        youngerThanGrace = now() - statSync21(file).mtimeMs < EMPTY_LOCK_GRACE_MS;
+      } catch {
+        continue;
+      }
+      if (youngerThanGrace) {
+        return {
+          ok: false,
+          holderPid: 0,
+          reason: `another keryx serve is creating ${file} right now; this one will not poll. Try again in a moment.`
+        };
+      }
+    }
+    const aside = `${file}.stale-${pid}-${randomBytes14(6).toString("hex")}`;
+    try {
+      renameSync8(file, aside);
+    } catch {
+      continue;
+    }
+    const moved = readConfigFile(aside);
+    const movedPid = moved.ok ? parsePid(moved.text) : Number.NaN;
+    if (Number.isInteger(movedPid) && movedPid !== holder && isAlive(movedPid)) {
+      try {
+        linkSync(aside, file);
+      } catch {}
+      try {
+        unlinkSync10(aside);
+      } catch {}
+      return refusal4(movedPid);
+    }
+    try {
+      unlinkSync10(aside);
+    } catch {}
+  }
+  return { ok: false, holderPid: 0, reason: `could not take the poller lock at ${file}` };
+}
+var POLLER_LOCK_FILE = "poller.lock", EMPTY_LOCK_GRACE_MS = 5000;
+var init_poll_lock = __esm(() => {
+  init_config_dir();
+  init_paths4();
+});
+
+// src/remote/service.ts
+import { unlinkSync as unlinkSync11 } from "fs";
+function openRemoteService(options = {}) {
   const notice = options.onNotice ?? (() => {
     return;
   });
+  const machine = options.machine ?? localMachineName();
   let verifyShellToken;
   const surface = new RemoteHttpSurface({
     verifyShellToken: (presented) => verifyShellToken?.(presented) ?? false,
@@ -185734,18 +187328,130 @@ function openRemoteService(options = {}) {
   let hub;
   let lock;
   let endpointWritten = false;
-  let attached = false;
-  let conflictWhileStarting;
+  let hubReason = "remote control has not started yet";
   let stopping;
+  let hubChain = Promise.resolve();
+  const exclusive = (work) => {
+    const next = hubChain.then(work, work);
+    hubChain = next.catch(() => {
+      return;
+    });
+    return next;
+  };
+  const stopHubNow = async (reason) => {
+    const running = hub;
+    hub = undefined;
+    hubReason = reason;
+    surface.detach(reason);
+    if (running !== undefined) {
+      await running.stop();
+    }
+  };
+  const startHubNow = async () => {
+    if (hub !== undefined) {
+      return { ok: true };
+    }
+    const present = readConfigFile(remoteConfigPath(options.dir));
+    if (!present.ok && present.reason === "absent") {
+      hubReason = "Telegram is not connected on this machine";
+      surface.detach("Telegram is not connected on this machine; connect it from the shell with /channels");
+      return { ok: false, reason: hubReason, notConnected: true };
+    }
+    let started = false;
+    let conflictWhileStarting;
+    let mine;
+    const opened = openRemoteHub({
+      ...options.dir === undefined ? {} : { dir: options.dir },
+      ...options.api === undefined ? {} : { api: options.api },
+      ...options.now === undefined ? {} : { now: options.now },
+      ...options.timers === undefined ? {} : { timers: options.timers },
+      ...options.sweepIntervalMs === undefined ? {} : { sweepIntervalMs: options.sweepIntervalMs },
+      ...options.deliverRetryMs === undefined ? {} : { deliverRetryMs: options.deliverRetryMs },
+      ...options.pollTimeoutSec === undefined ? {} : { pollTimeoutSec: options.pollTimeoutSec },
+      ...options.pollBackoffMs === undefined ? {} : { pollBackoffMs: options.pollBackoffMs },
+      ...options.pollSleep === undefined ? {} : { pollSleep: options.pollSleep },
+      ...options.onEvent === undefined ? {} : { onEvent: options.onEvent },
+      ...options.beforeAck === undefined ? {} : { beforeAck: options.beforeAck },
+      ...options.nameTopicsByMachine === true ? { machine } : {},
+      deliver: surface.consumer.deliver,
+      ...surface.consumer.deliverCallback === undefined ? {} : { deliverCallback: surface.consumer.deliverCallback },
+      onPollerStatus: (status) => {
+        if (status.state !== "conflict") {
+          return;
+        }
+        const reason = status.reason ?? "another poller owns this bot token";
+        if (!started) {
+          conflictWhileStarting = reason;
+          return;
+        }
+        exclusive(async () => {
+          if (hub !== mine) {
+            return;
+          }
+          notice(`remote control is off: ${reason}`);
+          await stopHubNow(reason);
+        });
+      }
+    });
+    if (!opened.ok) {
+      notice(`remote control is off: ${opened.reason}`);
+      hubReason = opened.reason;
+      surface.detach(opened.reason);
+      return { ok: false, reason: opened.reason };
+    }
+    mine = opened.hub;
+    try {
+      await mine.start();
+    } catch (error) {
+      const reason = `could not start remote control: ${error instanceof Error ? error.message : String(error)}`;
+      await mine.stop().catch(() => {
+        return;
+      });
+      notice(`remote control is off: ${reason}`);
+      hubReason = reason;
+      surface.detach(reason);
+      return { ok: false, reason };
+    }
+    if (conflictWhileStarting !== undefined) {
+      await mine.stop().catch(() => {
+        return;
+      });
+      notice(`remote control is off: ${conflictWhileStarting}`);
+      hubReason = conflictWhileStarting;
+      surface.detach(conflictWhileStarting);
+      return { ok: false, reason: conflictWhileStarting };
+    }
+    hub = mine;
+    hubReason = undefined;
+    surface.attach(mine);
+    started = true;
+    return { ok: true };
+  };
+  const controller = new ChannelsController({
+    host: {
+      dir: options.dir,
+      machine,
+      hub: () => hub,
+      hubReason: () => hubReason,
+      startHub: () => exclusive(startHubNow),
+      stopHub: (reason) => exclusive(() => stopHubNow(reason)),
+      openApi: () => openBotApi({ ...options.api === undefined ? {} : { api: options.api }, ...options.dir === undefined ? {} : { dir: options.dir } })
+    },
+    ...options.now === undefined ? {} : { now: options.now },
+    pairing: {
+      ...options.timers === undefined ? {} : { timers: options.timers },
+      ...options.pollTimeoutSec === undefined ? {} : { pollTimeoutSec: options.pollTimeoutSec },
+      ...options.pollBackoffMs === undefined ? {} : { pollBackoffMs: options.pollBackoffMs },
+      ...options.pollSleep === undefined ? {} : { pollSleep: options.pollSleep },
+      ...options.pairing
+    }
+  });
   const shutdown = (reason) => {
     stopping ??= (async () => {
-      const running = hub;
-      hub = undefined;
       surface.detach(reason);
       await surface.close();
-      if (running !== undefined) {
-        await running.stop();
-      }
+      await controller.stop();
+      await exclusive(() => stopHubNow(reason));
       if (endpointWritten) {
         endpointWritten = false;
         removeEndpointIfOurs(options.dir);
@@ -185764,78 +187470,36 @@ function openRemoteService(options = {}) {
     return { ok: false, reason };
   };
   return {
-    status: "ready",
-    service: {
-      surface,
-      hub: () => hub,
-      async start(endpoint) {
-        if (!isLoopbackAddress(endpoint.address)) {
-          return refuse(`serve is bound to ${endpoint.address}, which is not a loopback address. Remote control is local-only; bind serve to 127.0.0.1 or ::1 to use it.`);
-        }
-        if (options.lock?.disabled !== true) {
-          lock = acquirePollLock({ dir: options.dir, ...options.lock });
-          if (!lock.ok) {
-            return refuse(lock.reason);
-          }
-        }
-        const token = mintShellToken(options.dir);
-        if (!token.ok) {
-          return refuse(token.reason);
-        }
-        verifyShellToken = createShellTokenVerifier(token.value);
-        const opened = openRemoteHub({
-          ...options.dir === undefined ? {} : { dir: options.dir },
-          ...options.api === undefined ? {} : { api: options.api },
-          ...options.now === undefined ? {} : { now: options.now },
-          ...options.timers === undefined ? {} : { timers: options.timers },
-          ...options.sweepIntervalMs === undefined ? {} : { sweepIntervalMs: options.sweepIntervalMs },
-          ...options.deliverRetryMs === undefined ? {} : { deliverRetryMs: options.deliverRetryMs },
-          ...options.pollTimeoutSec === undefined ? {} : { pollTimeoutSec: options.pollTimeoutSec },
-          ...options.pollBackoffMs === undefined ? {} : { pollBackoffMs: options.pollBackoffMs },
-          ...options.pollSleep === undefined ? {} : { pollSleep: options.pollSleep },
-          ...options.onEvent === undefined ? {} : { onEvent: options.onEvent },
-          ...options.beforeAck === undefined ? {} : { beforeAck: options.beforeAck },
-          deliver: surface.consumer.deliver,
-          ...surface.consumer.deliverCallback === undefined ? {} : { deliverCallback: surface.consumer.deliverCallback },
-          onPollerStatus: (status) => {
-            if (status.state === "conflict") {
-              const reason = status.reason ?? "another poller owns this bot token";
-              if (!attached) {
-                conflictWhileStarting = reason;
-                return;
-              }
-              (async () => {
-                surface.detach(reason);
-                notice(`remote control is off: ${reason}`);
-                await hub?.stop();
-              })();
-            }
-          }
-        });
-        if (!opened.ok) {
-          return refuse(opened.reason);
+    surface,
+    hub: () => hub,
+    async start(endpoint) {
+      if (!isLoopbackAddress(endpoint.address)) {
+        return refuse(`serve is bound to ${endpoint.address}, which is not a loopback address. Remote control is local-only; bind serve to 127.0.0.1 or ::1 to use it.`);
+      }
+      if (options.lock?.disabled !== true) {
+        lock = acquirePollLock({ dir: options.dir, ...options.lock });
+        if (!lock.ok) {
+          return refuse(lock.reason);
         }
-        hub = opened.hub;
-        try {
-          await hub.start();
-          ensureRemoteDir(options.dir);
-          const body = { address: endpoint.address, port: endpoint.port, pid: process.pid };
-          writeOwnerOnlyFileAtomic(endpointPath(options.dir), `${JSON.stringify(body)}
+      }
+      const token = mintShellToken(options.dir);
+      if (!token.ok) {
+        return refuse(token.reason);
+      }
+      verifyShellToken = createShellTokenVerifier(token.value);
+      try {
+        ensureRemoteDir(options.dir);
+        const body = { address: endpoint.address, port: endpoint.port, pid: process.pid };
+        writeOwnerOnlyFileAtomic(endpointPath(options.dir), `${JSON.stringify(body)}
 `);
-          endpointWritten = true;
-        } catch (error) {
-          hub = undefined;
-          return refuse(`could not start remote control: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        if (conflictWhileStarting !== undefined) {
-          return refuse(conflictWhileStarting);
-        }
-        surface.attach(hub);
-        attached = true;
-        return { ok: true };
-      },
-      stop
-    }
+        endpointWritten = true;
+      } catch (error) {
+        return refuse(`could not publish the local endpoint: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      surface.setChannels((route, request) => controller.handle(route, request));
+      return exclusive(startHubNow);
+    },
+    stop
   };
 }
 function removeEndpointIfOurs(dir) {
@@ -185847,7 +187511,7 @@ function removeEndpointIfOurs(dir) {
   try {
     const parsed = JSON.parse(read.text);
     if (parsed.pid === process.pid) {
-      unlinkSync10(file);
+      unlinkSync11(file);
     }
   } catch {}
 }
@@ -185855,8 +187519,9 @@ var init_service18 = __esm(() => {
   init_serve_config();
   init_config_dir();
   init_bootstrap2();
-  init_config12();
+  init_channels();
   init_endpoint();
+  init_naming();
   init_paths4();
   init_poll_lock();
   init_http_surface();
@@ -185951,20 +187616,20 @@ async function runServe(args) {
   const stored = loadServeConfig(undefined, warn);
   const runtimeAck = parsed.parsed.flags.has(ACK_FLAG);
   const config = stored === null ? null : overlay(stored, parsed.parsed, port, runtimeAck);
-  const remote = openRemoteService({ onNotice: (message) => console.log(`  ${style.yellow(symbols.bullet)} ${sanitizeForDisplay(message)}`) });
-  if (remote.status === "unavailable") {
-    console.log(`  ${style.yellow(symbols.bullet)} remote control is off: ${sanitizeForDisplay(remote.reason)}`);
-  }
-  const remoteService = remote.status === "ready" ? remote.service : undefined;
+  const remoteService = openRemoteService({
+    machine: localMachineName(),
+    nameTopicsByMachine: true,
+    onNotice: (message) => console.log(`  ${style.yellow(symbols.bullet)} ${sanitizeForDisplay(message)}`)
+  });
   const outcome = await startServeListener({
     config,
     credential: readServeCredential(),
-    remote: remoteService?.surface,
+    remote: remoteService.surface,
     configState: serveConfigState(),
     makeSubmitTurn: assembleSubmitTurn
   });
   if (!outcome.ok) {
-    await remoteService?.stop();
+    await remoteService.stop();
     fail5(sanitizeForDisplay(outcome.message));
     if (outcome.reason === "non-loopback-not-acknowledged" && stored !== null) {
       if (stored.bind.acknowledgeNonLoopback !== true) {
@@ -185982,11 +187647,11 @@ async function runServe(args) {
   if (!isLoopbackAddress(listener.address)) {
     console.log(`  ${style.yellow(symbols.bullet)} this bind is reachable beyond loopback and there is no TLS in this release`);
   }
-  if (remoteService !== undefined) {
-    const started = await remoteService.start({ address: listener.address, port: listener.port });
-    if (started.ok) {
-      console.log(`    ${style.dim("remote control on: shells register at /v1/remote/*")}`);
-    }
+  const started = await remoteService.start({ address: listener.address, port: listener.port });
+  if (started.ok) {
+    console.log(`    ${style.dim("remote control on: shells register at /v1/remote/*")}`);
+  } else if (started.notConnected === true) {
+    console.log(`    ${style.dim("channels ready: connect Telegram from the shell with /channels")}`);
   }
   await new Promise((resolve) => {
     let draining = false;
@@ -185996,7 +187661,7 @@ async function runServe(args) {
       }
       draining = true;
       console.log(`  ${style.dim("draining\u2026")}`);
-      listener.drain().then(() => remoteService?.stop()).then(() => {
+      listener.drain().then(() => remoteService.stop()).then(() => {
         console.log(`  ${style.green(symbols.ok)} stopped`);
         resolve();
       });
@@ -186347,6 +188012,7 @@ var init_serve = __esm(() => {
   init_serve_server();
   init_serve_approvals_store();
   init_serve_runner();
+  init_naming();
   init_service18();
   init_ui();
   BIND_FLAGS = ["--bind", "--port", "--profile"];