@drisp/cli 0.4.5 → 0.5.0

package/dist/athena-gateway.js

@@ -1,3895 +1,12 @@
 #!/usr/bin/env node
 import {
-  loadChannelSidecars,
-  loadOrCreateToken,
-  requireTokenForBind,
-  timingSafeTokenEqual
-} from "./chunk-M44KEGM7.js";
+  startDaemon
+} from "./chunk-SHLHZL5F.js";
+import "./chunk-MRAM6EYI.js";
 import {
-  CHANNEL_REQUEST_ID_REGEX,
-  createUdsServerTransport,
-  generateChannelRequestId,
-  isLoopbackHost,
-  isValidChannelRequestId,
-  refreshDashboardAccessToken,
   resolveGatewayPaths,
-  resolveListenSpec,
-  traceGatewayFrame,
-  trackGatewayRuntimeExpired,
-  trackGatewayRuntimeRebind,
-  trackGatewayTransportConnect,
-  trackGatewayTransportDisconnect,
-  writeGatewayTrace
-} from "./chunk-4CRZXLIP.js";
-
-// src/gateway/daemon.ts
-import fs3 from "fs";
-
-// src/gateway/adapters/console/adapter.ts
-import { readFileSync as readFileSync2 } from "fs";
-
-// src/gateway/adapters/console/client.ts
-import { readFileSync } from "fs";
-import { WebSocket } from "ws";
-var DEFAULT_CONNECT_TIMEOUT_MS = 1e4;
-var DEFAULT_INITIAL_RECONNECT_MS = 1e3;
-var DEFAULT_MAX_RECONNECT_MS = 3e4;
-var DEFAULT_HEARTBEAT_INTERVAL_MS = 3e4;
-var DEFAULT_HEARTBEAT_TIMEOUT_MS = 9e4;
-function createConsoleBrokerClient(opts) {
-  const hasStatic = typeof opts.pairingToken === "string" && opts.pairingToken.length > 0;
-  const hasProvider = typeof opts.pairingTokenProvider === "function";
-  if (hasStatic === hasProvider) {
-    throw new Error(
-      "console broker client: exactly one of pairingToken or pairingTokenProvider is required"
-    );
-  }
-  const provider = hasStatic ? async () => opts.pairingToken : opts.pairingTokenProvider;
-  const initialDelay = opts.reconnect?.initialDelayMs ?? DEFAULT_INITIAL_RECONNECT_MS;
-  const maxDelay = opts.reconnect?.maxDelayMs ?? DEFAULT_MAX_RECONNECT_MS;
-  const heartbeatInterval = opts.heartbeat?.intervalMs ?? DEFAULT_HEARTBEAT_INTERVAL_MS;
-  const heartbeatTimeout = opts.heartbeat?.timeoutMs ?? DEFAULT_HEARTBEAT_TIMEOUT_MS;
-  let ws = null;
-  let ready = null;
-  let closeRequested = false;
-  let reconnectAttempt = 0;
-  let reconnectTimer = null;
-  let lastHello = null;
-  let currentToken = null;
-  let heartbeatTimer = null;
-  let lastPongAt = null;
-  const frameHandlers = /* @__PURE__ */ new Set();
-  const closeHandlers = /* @__PURE__ */ new Set();
-  const readyHandlers = /* @__PURE__ */ new Set();
-  const tokenRedacted = "<redacted>";
-  function redact(message) {
-    if (!currentToken) return message;
-    return message.split(currentToken).join(tokenRedacted);
-  }
-  function stopHeartbeat() {
-    if (heartbeatTimer) {
-      clearInterval(heartbeatTimer);
-      heartbeatTimer = null;
-    }
-    lastPongAt = null;
-  }
-  function startHeartbeat(currentWs) {
-    stopHeartbeat();
-    lastPongAt = Date.now();
-    heartbeatTimer = setInterval(() => {
-      if (currentWs !== ws || currentWs.readyState !== WebSocket.OPEN) {
-        stopHeartbeat();
-        return;
-      }
-      if (lastPongAt !== null && Date.now() - lastPongAt >= heartbeatTimeout) {
-        opts.log(
-          "warn",
-          "console broker: heartbeat watchdog fired, no pong received \u2014 terminating"
-        );
-        stopHeartbeat();
-        try {
-          currentWs.terminate();
-        } catch {
-        }
-        return;
-      }
-      const ping = {
-        kind: "console.ping",
-        frameId: makeFrameId(),
-        sentAt: Date.now()
-      };
-      try {
-        currentWs.send(JSON.stringify(ping));
-      } catch {
-      }
-    }, heartbeatInterval);
-  }
-  function emitClose(reason) {
-    for (const h of [...closeHandlers]) {
-      try {
-        h(reason);
-      } catch {
-      }
-    }
-  }
-  function scheduleReconnect() {
-    if (closeRequested || !lastHello) return;
-    const exp = Math.min(maxDelay, initialDelay * 2 ** reconnectAttempt);
-    const delay = Math.floor(Math.random() * exp);
-    reconnectAttempt++;
-    const hello = lastHello;
-    reconnectTimer = setTimeout(() => {
-      reconnectTimer = null;
-      void attemptConnect(hello).then(
-        () => {
-          reconnectAttempt = 0;
-        },
-        (err) => {
-          opts.log(
-            "warn",
-            `console broker reconnect failed: ${redact(err instanceof Error ? err.message : String(err))}`
-          );
-          scheduleReconnect();
-        }
-      );
-    }, delay);
-  }
-  async function attemptConnect(hello) {
-    const timeoutMs = opts.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
-    let token;
-    try {
-      token = await provider();
-    } catch (err) {
-      throw new Error(
-        `console broker connect failed: pairing token provider threw: ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-    if (typeof token !== "string" || token.length === 0) {
-      throw new Error(
-        "console broker connect failed: pairing token provider returned empty token"
-      );
-    }
-    currentToken = token;
-    const headers = { Authorization: `Bearer ${token}` };
-    const wsOpts = opts.tlsCaPath ? { headers, ca: readFileSync(opts.tlsCaPath) } : { headers };
-    const next = new WebSocket(opts.brokerUrl, wsOpts);
-    ws = next;
-    ready = null;
-    try {
-      await new Promise((resolve, reject) => {
-        let settled = false;
-        const finishOk = () => {
-          if (settled) return;
-          settled = true;
-          clearTimeout(timer);
-          resolve();
-        };
-        const finishErr = (err) => {
-          if (settled) return;
-          settled = true;
-          clearTimeout(timer);
-          reject(err);
-        };
-        const timer = setTimeout(() => {
-          finishErr(
-            new Error(`console broker connect timed out after ${timeoutMs}ms`)
-          );
-        }, timeoutMs);
-        next.once("open", () => {
-          try {
-            const helloFrame = {
-              kind: "console.hello",
-              frameId: makeFrameId(),
-              sentAt: Date.now(),
-              protocolVersion: 1,
-              clientName: hello.clientName,
-              clientVersion: hello.clientVersion,
-              address: {
-                runnerId: hello.runnerId,
-                ...hello.workspaceId !== void 0 ? { workspaceId: hello.workspaceId } : {}
-              }
-            };
-            next.send(JSON.stringify(helloFrame));
-          } catch (err) {
-            finishErr(err instanceof Error ? err : new Error(String(err)));
-          }
-        });
-        next.once("error", (err) => {
-          finishErr(
-            new Error(`console broker connect failed: ${redact(err.message)}`)
-          );
-        });
-        const earlyCloseListener = (code, reasonBuf) => {
-          if (!ready) {
-            const reason = reasonBuf.toString();
-            finishErr(
-              new Error(
-                `console broker closed before ready (code=${code}${reason ? ` reason=${reason}` : ""})`
-              )
-            );
-          }
-        };
-        next.once("close", earlyCloseListener);
-        next.on("message", (data) => {
-          let parsed;
-          try {
-            parsed = JSON.parse(String(data));
-          } catch (err) {
-            opts.log(
-              "warn",
-              `console broker frame parse failed: ${redact(String(err))}`
-            );
-            return;
-          }
-          if (!ready) {
-            if (parsed.kind === "console.ready") {
-              const claimedRunnerId = hello.runnerId;
-              const readyRunnerId = parsed.address.runnerId;
-              if (readyRunnerId !== claimedRunnerId) {
-                finishErr(
-                  new Error(
-                    `console broker ready runnerId mismatch: claimed ${claimedRunnerId}, got ${readyRunnerId}`
-                  )
-                );
-                return;
-              }
-              ready = parsed;
-              next.removeListener("close", earlyCloseListener);
-              const address = parsed.address;
-              for (const h of [...readyHandlers]) {
-                try {
-                  h(address);
-                } catch {
-                }
-              }
-              finishOk();
-              return;
-            }
-            if (parsed.kind === "console.error") {
-              finishErr(
-                new Error(
-                  `console broker rejected hello: ${parsed.code} ${parsed.message}`
-                )
-              );
-              return;
-            }
-            opts.log(
-              "warn",
-              `console broker pre-ready frame ignored: ${parsed.kind}`
-            );
-            return;
-          }
-          if (parsed.kind === "console.pong") {
-            lastPongAt = Date.now();
-            return;
-          }
-          for (const h of [...frameHandlers]) {
-            try {
-              h(parsed);
-            } catch (err) {
-              opts.log(
-                "warn",
-                `console frame handler threw: ${redact(err instanceof Error ? err.message : String(err))}`
-              );
-            }
-          }
-        });
-      });
-    } catch (err) {
-      try {
-        next.terminate();
-      } catch {
-      }
-      if (ws === next) {
-        ws = null;
-        ready = null;
-      }
-      throw err;
-    }
-    next.on("close", (_code, reasonBuf) => {
-      stopHeartbeat();
-      if (next !== ws) return;
-      ws = null;
-      ready = null;
-      emitClose(reasonBuf.toString() || "closed");
-      if (!closeRequested) scheduleReconnect();
-    });
-    startHeartbeat(next);
-  }
-  async function connect(hello) {
-    if (ws) throw new Error("console broker client already connected");
-    closeRequested = false;
-    lastHello = hello;
-    await attemptConnect(hello);
-  }
-  function close(reason) {
-    closeRequested = true;
-    stopHeartbeat();
-    if (reconnectTimer) {
-      clearTimeout(reconnectTimer);
-      reconnectTimer = null;
-    }
-    if (ws) {
-      try {
-        ws.close(1e3, reason);
-      } catch {
-        ws.terminate();
-      }
-    }
-    ws = null;
-    ready = null;
-    emitClose(reason);
-  }
-  function sendFrame(frame) {
-    if (!ws || ws.readyState !== WebSocket.OPEN) {
-      throw new Error("console broker client not connected");
-    }
-    ws.send(JSON.stringify(frame));
-  }
-  function onFrame(handler) {
-    frameHandlers.add(handler);
-  }
-  function onClose(handler) {
-    closeHandlers.add(handler);
-  }
-  function onReady(handler) {
-    readyHandlers.add(handler);
-  }
-  return {
-    connect,
-    close,
-    sendFrame,
-    onFrame,
-    onReady,
-    onClose,
-    getReadyAddress: () => ready?.address ?? null,
-    isReady: () => ready !== null
-  };
-}
-var frameCounter = 0;
-function makeFrameId() {
-  frameCounter = (frameCounter + 1) % 1e6;
-  return `f${Date.now().toString(36)}-${frameCounter.toString(36)}`;
-}
-
-// src/gateway/adapters/console/adapter.ts
-var CONSOLE_DEFAULT_ID = "console";
-var CLIENT_NAME = "athena-cli";
-var CLIENT_VERSION = "0.0.0";
-var ConsoleAdapter = class {
-  id;
-  capabilities = {
-    chat: true,
-    threads: true,
-    relayPermission: true,
-    relayQuestion: true
-  };
-  opts;
-  client = null;
-  ctx = null;
-  pendingPermissions = /* @__PURE__ */ new Map();
-  pendingQuestions = /* @__PURE__ */ new Map();
-  constructor(opts, id = CONSOLE_DEFAULT_ID) {
-    this.opts = opts;
-    this.id = id;
-  }
-  async start(ctx) {
-    if (this.client) {
-      throw new Error("console adapter already started");
-    }
-    this.ctx = ctx;
-    const tokenSource = resolvePairingTokenSource(this.opts);
-    const factory = this.opts.brokerClientFactory ?? ((input) => createConsoleBrokerClient(input));
-    const client = factory({
-      brokerUrl: this.opts.brokerUrl,
-      ...tokenSource.kind === "static" ? { pairingToken: tokenSource.token } : { pairingTokenProvider: tokenSource.provider },
-      ...this.opts.tlsCaPath !== void 0 ? { tlsCaPath: this.opts.tlsCaPath } : {},
-      log: ctx.log
-    });
-    client.onFrame((frame) => this.handleInboundFrame(frame));
-    client.onReady(() => {
-      ctx.emitHealth({ at: Date.now(), transportOk: true });
-    });
-    client.onClose((reason) => {
-      this.disposePermissions("connection_lost");
-      this.disposeQuestions("connection_lost");
-      ctx.emitHealth({
-        at: Date.now(),
-        transportOk: false,
-        note: `broker connection closed: ${reason}`
-      });
-    });
-    await client.connect({
-      runnerId: this.opts.runnerId,
-      ...this.opts.workspaceId !== void 0 ? { workspaceId: this.opts.workspaceId } : {},
-      clientName: CLIENT_NAME,
-      clientVersion: CLIENT_VERSION
-    });
-    this.client = client;
-    ctx.signal.addEventListener("abort", () => {
-      this.client?.close("manager abort");
-    });
-  }
-  async stop(_reason) {
-    this.disposePermissions();
-    this.disposeQuestions();
-    this.client?.close("shutdown");
-    this.client = null;
-    this.ctx = null;
-  }
-  async send(msg) {
-    const client = this.client;
-    if (!client || !client.isReady()) {
-      throw new Error("console adapter: send called before broker is ready");
-    }
-    const messageId = makeOutboundMessageId();
-    const workspaceId = this.opts.workspaceId ?? msg.location.accountId;
-    const frame = {
-      kind: "console.message.out",
-      frameId: makeFrameId2(),
-      sentAt: Date.now(),
-      address: {
-        runnerId: this.opts.runnerId,
-        ...workspaceId.length > 0 ? { workspaceId } : {},
-        ...msg.location.peer?.id !== void 0 ? { userId: msg.location.peer.id } : {},
-        ...msg.location.thread?.id !== void 0 ? { threadId: msg.location.thread.id } : {}
-      },
-      messageId,
-      idempotencyKey: msg.idempotencyKey,
-      text: msg.text
-    };
-    client.sendFrame(frame);
-    return {
-      providerMessageId: messageId,
-      deliveredAt: Date.now()
-    };
-  }
-  async probe() {
-    const ok2 = this.client?.isReady() ?? false;
-    return {
-      ok: ok2,
-      detail: ok2 ? "broker connected" : "broker not connected",
-      checkedAt: Date.now()
-    };
-  }
-  requestPermissionVerdict(req, signal) {
-    const client = this.client;
-    if (!client || !client.isReady()) {
-      return Promise.resolve({ kind: "no_relay" });
-    }
-    if (signal.aborted) {
-      return Promise.resolve({ kind: "cancelled", reason: "auto_resolved" });
-    }
-    client.sendFrame({
-      kind: "console.permission.request",
-      frameId: makeFrameId2(),
-      sentAt: Date.now(),
-      address: {
-        runnerId: this.opts.runnerId,
-        ...this.opts.workspaceId !== void 0 ? { workspaceId: this.opts.workspaceId } : {}
-      },
-      channelRequestId: req.channelRequestId,
-      toolName: req.toolName,
-      description: req.description,
-      inputPreview: req.inputPreview
-    });
-    return new Promise((resolve) => {
-      const abortListener = () => {
-        const entry = this.pendingPermissions.get(req.channelRequestId);
-        if (!entry) return;
-        this.pendingPermissions.delete(req.channelRequestId);
-        try {
-          this.client?.sendFrame({
-            kind: "console.permission.cancel",
-            frameId: makeFrameId2(),
-            sentAt: Date.now(),
-            channelRequestId: req.channelRequestId,
-            reason: "resolved_by_other_channel"
-          });
-        } catch {
-        }
-        resolve({ kind: "cancelled", reason: "resolved_by_other_channel" });
-      };
-      signal.addEventListener("abort", abortListener);
-      this.pendingPermissions.set(req.channelRequestId, {
-        resolve,
-        abortListener,
-        signal
-      });
-    });
-  }
-  settlePermissionResponse(channelRequestId, decision) {
-    const entry = this.pendingPermissions.get(channelRequestId);
-    if (!entry) return;
-    this.pendingPermissions.delete(channelRequestId);
-    entry.signal.removeEventListener("abort", entry.abortListener);
-    entry.resolve({ kind: "verdict", behavior: decision, channelId: this.id });
-  }
-  disposePermissions(reason = "auto_resolved") {
-    for (const [id, entry] of [...this.pendingPermissions.entries()]) {
-      this.pendingPermissions.delete(id);
-      entry.signal.removeEventListener("abort", entry.abortListener);
-      entry.resolve({ kind: "cancelled", reason });
-    }
-  }
-  requestQuestionAnswer(req, signal) {
-    const client = this.client;
-    if (!client || !client.isReady()) {
-      return Promise.resolve({ kind: "no_relay" });
-    }
-    if (signal.aborted) {
-      return Promise.resolve({ kind: "cancelled", reason: "auto_resolved" });
-    }
-    client.sendFrame({
-      kind: "console.question.request",
-      frameId: makeFrameId2(),
-      sentAt: Date.now(),
-      address: {
-        runnerId: this.opts.runnerId,
-        ...this.opts.workspaceId !== void 0 ? { workspaceId: this.opts.workspaceId } : {}
-      },
-      channelRequestId: req.channelRequestId,
-      title: req.title,
-      questions: req.questions
-    });
-    return new Promise((resolve) => {
-      const abortListener = () => {
-        const entry = this.pendingQuestions.get(req.channelRequestId);
-        if (!entry) return;
-        this.pendingQuestions.delete(req.channelRequestId);
-        try {
-          this.client?.sendFrame({
-            kind: "console.question.cancel",
-            frameId: makeFrameId2(),
-            sentAt: Date.now(),
-            channelRequestId: req.channelRequestId,
-            reason: "resolved_by_other_channel"
-          });
-        } catch {
-        }
-        resolve({ kind: "cancelled", reason: "resolved_by_other_channel" });
-      };
-      signal.addEventListener("abort", abortListener);
-      this.pendingQuestions.set(req.channelRequestId, {
-        questionKeys: req.questions.map((q) => q.key),
-        resolve,
-        abortListener,
-        signal
-      });
-    });
-  }
-  settleQuestionResponse(channelRequestId, answers) {
-    const entry = this.pendingQuestions.get(channelRequestId);
-    if (!entry) return;
-    const filtered = {};
-    for (const key of entry.questionKeys) {
-      const value = answers[key];
-      if (typeof value === "string") filtered[key] = value;
-    }
-    this.pendingQuestions.delete(channelRequestId);
-    entry.signal.removeEventListener("abort", entry.abortListener);
-    if (Object.keys(filtered).length === 0) {
-      entry.resolve({ kind: "cancelled", reason: "auto_resolved" });
-      return;
-    }
-    entry.resolve({ kind: "answer", answers: filtered, channelId: this.id });
-  }
-  disposeQuestions(reason = "auto_resolved") {
-    for (const [id, entry] of [...this.pendingQuestions.entries()]) {
-      this.pendingQuestions.delete(id);
-      entry.signal.removeEventListener("abort", entry.abortListener);
-      entry.resolve({ kind: "cancelled", reason });
-    }
-  }
-  handleInboundFrame(frame) {
-    switch (frame.kind) {
-      case "console.message.in":
-        this.handleInboundMessage(frame);
-        return;
-      case "console.permission.response":
-        this.handlePermissionResponse(frame);
-        return;
-      case "console.question.response":
-        this.handleQuestionResponse(frame);
-        return;
-      default:
-        return;
-    }
-  }
-  handleInboundMessage(frame) {
-    if (frame.kind !== "console.message.in") return;
-    if (!isValidConsoleAddress(frame.address)) {
-      this.ctx?.log("warn", "console.message.in dropped: invalid address");
-      return;
-    }
-    if (frame.address.runnerId !== this.opts.runnerId) {
-      this.ctx?.log(
-        "warn",
-        `console.message.in dropped: runner mismatch (claimed ${frame.address.runnerId}, expected ${this.opts.runnerId})`
-      );
-      return;
-    }
-    if (typeof frame.messageId !== "string" || frame.messageId.length === 0) {
-      this.ctx?.log("warn", "console.message.in dropped: missing messageId");
-      return;
-    }
-    const inbound = normalizeInbound(frame, this.opts.runnerId, this.id);
-    if (!inbound || !this.ctx) return;
-    try {
-      this.ctx.emitInbound(inbound);
-    } catch (err) {
-      this.ctx.log(
-        "warn",
-        `console emitInbound threw: ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-  }
-  handlePermissionResponse(frame) {
-    if (frame.kind !== "console.permission.response") return;
-    if (typeof frame.channelRequestId !== "string" || frame.channelRequestId.length === 0) {
-      this.ctx?.log(
-        "warn",
-        "console.permission.response dropped: missing channelRequestId"
-      );
-      return;
-    }
-    if (frame.decision !== "allow" && frame.decision !== "deny") {
-      this.ctx?.log(
-        "warn",
-        `console.permission.response dropped: invalid decision ${String(frame.decision)}`
-      );
-      return;
-    }
-    this.settlePermissionResponse(frame.channelRequestId, frame.decision);
-  }
-  handleQuestionResponse(frame) {
-    if (frame.kind !== "console.question.response") return;
-    if (typeof frame.channelRequestId !== "string" || frame.channelRequestId.length === 0) {
-      this.ctx?.log(
-        "warn",
-        "console.question.response dropped: missing channelRequestId"
-      );
-      return;
-    }
-    if (typeof frame.answers !== "object" || frame.answers === null || Array.isArray(frame.answers)) {
-      this.ctx?.log(
-        "warn",
-        "console.question.response dropped: answers must be a record"
-      );
-      return;
-    }
-    const cleaned = {};
-    for (const [key, value] of Object.entries(frame.answers)) {
-      if (typeof key !== "string" || key.length === 0) continue;
-      if (typeof value !== "string") continue;
-      cleaned[key] = value;
-    }
-    this.settleQuestionResponse(frame.channelRequestId, cleaned);
-  }
-};
-function resolvePairingTokenSource(opts) {
-  if (opts.dashboardConfig === true) {
-    const provider = opts.pairingTokenProvider ?? (async () => {
-      const result = await refreshDashboardAccessToken();
-      return result.accessToken;
-    });
-    return { kind: "provider", provider };
-  }
-  if (opts.pairingToken !== void 0 && opts.pairingToken.length > 0) {
-    return { kind: "static", token: opts.pairingToken };
-  }
-  if (opts.tokenPath !== void 0 && opts.tokenPath.length > 0) {
-    try {
-      const value = readFileSync2(opts.tokenPath, "utf-8").trim();
-      if (value.length === 0) {
-        throw new Error(
-          `console adapter: token_path ${opts.tokenPath} is empty`
-        );
-      }
-      return { kind: "static", token: value };
-    } catch (err) {
-      const code = err.code;
-      throw new Error(
-        `console adapter: failed to read token_path ${opts.tokenPath}` + (code ? ` (${code})` : "") + (err instanceof Error ? `: ${err.message}` : "")
-      );
-    }
-  }
-  throw new Error(
-    "console adapter: no pairing_token, token_path, or dashboard_config configured"
-  );
-}
-var outboundCounter = 0;
-function makeOutboundMessageId() {
-  outboundCounter = (outboundCounter + 1) % 1e6;
-  return `console-out-${Date.now().toString(36)}-${outboundCounter.toString(36)}`;
-}
-var frameCounter2 = 0;
-function makeFrameId2() {
-  frameCounter2 = (frameCounter2 + 1) % 1e6;
-  return `f${Date.now().toString(36)}-${frameCounter2.toString(36)}`;
-}
-function isValidConsoleAddress(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const v = value;
-  if (typeof v["runnerId"] !== "string" || v["runnerId"].length === 0) {
-    return false;
-  }
-  for (const key of [
-    "workspaceId",
-    "conversationId",
-    "threadId",
-    "userId"
-  ]) {
-    if (v[key] !== void 0 && typeof v[key] !== "string") return false;
-  }
-  return true;
-}
-function normalizeInbound(frame, runnerId, channelId) {
-  if (typeof frame.text !== "string" || frame.text.length === 0) return null;
-  const userId = frame.address.userId ?? "console-user";
-  const idempotencyKey = typeof frame.idempotencyKey === "string" && frame.idempotencyKey.length > 0 ? frame.idempotencyKey : `console:${runnerId}:${frame.messageId}`;
-  return {
-    location: {
-      channelId,
-      accountId: frame.address.workspaceId ?? runnerId,
-      peer: { id: userId, kind: "user" },
-      ...frame.address.threadId !== void 0 ? { thread: { id: frame.address.threadId } } : frame.address.conversationId !== void 0 ? { thread: { id: frame.address.conversationId } } : {}
-    },
-    sender: { id: userId },
-    text: frame.text,
-    receivedAt: frame.sentAt,
-    idempotencyKey,
-    providerMessageId: frame.messageId
-  };
-}
-
-// src/gateway/adapters/console/module.ts
-var consoleModule = {
-  name: "console",
-  parseConfig({ options }) {
-    const brokerUrl = options["broker_url"];
-    if (typeof brokerUrl !== "string" || brokerUrl.length === 0) {
-      return { ok: false, reason: "broker_url missing" };
-    }
-    if (!/^wss?:\/\//.test(brokerUrl)) {
-      return { ok: false, reason: "broker_url must start with ws:// or wss://" };
-    }
-    if (brokerUrl.startsWith("ws://") && !isLoopbackUrl(brokerUrl)) {
-      return {
-        ok: false,
-        reason: "broker_url must use wss:// for non-loopback hosts"
-      };
-    }
-    const runnerId = options["runner_id"];
-    if (typeof runnerId !== "string" || runnerId.length === 0) {
-      return { ok: false, reason: "runner_id missing" };
-    }
-    const pairingToken = options["pairing_token"];
-    const tokenPath = options["token_path"];
-    const dashboardConfig = options["dashboard_config"];
-    if (dashboardConfig !== void 0 && typeof dashboardConfig !== "boolean") {
-      return { ok: false, reason: "dashboard_config must be a boolean" };
-    }
-    const useDashboardConfig = dashboardConfig === true;
-    const hasInline = typeof pairingToken === "string" && pairingToken.length > 0;
-    const hasTokenPath = typeof tokenPath === "string" && tokenPath.length > 0;
-    if (useDashboardConfig && (hasInline || hasTokenPath)) {
-      return {
-        ok: false,
-        reason: "dashboard_config is mutually exclusive with pairing_token and token_path"
-      };
-    }
-    if (!useDashboardConfig && !hasInline && !hasTokenPath) {
-      return {
-        ok: false,
-        reason: "either pairing_token, token_path, or dashboard_config is required"
-      };
-    }
-    if (pairingToken !== void 0 && typeof pairingToken !== "string") {
-      return { ok: false, reason: "pairing_token must be a string" };
-    }
-    if (tokenPath !== void 0 && typeof tokenPath !== "string") {
-      return { ok: false, reason: "token_path must be a string" };
-    }
-    const workspaceId = options["workspace_id"];
-    if (workspaceId !== void 0 && typeof workspaceId !== "string") {
-      return { ok: false, reason: "workspace_id must be a string" };
-    }
-    const tlsCaPath = options["tls_ca_path"];
-    if (tlsCaPath !== void 0 && typeof tlsCaPath !== "string") {
-      return { ok: false, reason: "tls_ca_path must be a string" };
-    }
-    const config = {
-      brokerUrl,
-      runnerId,
-      ...workspaceId !== void 0 ? { workspaceId } : {},
-      ...useDashboardConfig ? { dashboardConfig: true } : {
-        ...pairingToken !== void 0 ? { pairingToken } : {},
-        ...tokenPath !== void 0 ? { tokenPath } : {}
-      },
-      ...tlsCaPath !== void 0 ? { tlsCaPath } : {}
-    };
-    return { ok: true, config };
-  },
-  create(config, instanceId) {
-    return new ConsoleAdapter(config, instanceId);
-  }
-};
-function isLoopbackUrl(url) {
-  try {
-    const parsed = new URL(url);
-    const host = parsed.hostname;
-    return host === "localhost" || host === "127.0.0.1" || host === "::1";
-  } catch {
-    return false;
-  }
-}
-
-// src/shared/utils/errorMessage.ts
-function errorMessage(err) {
-  return err instanceof Error ? err.message : String(err);
-}
-
-// src/shared/telegram/bot.ts
-var TelegramApiError = class extends Error {
-  constructor(status, message, retryAfterMs) {
-    super(message);
-    this.status = status;
-    this.retryAfterMs = retryAfterMs;
-    this.name = "TelegramApiError";
-  }
-};
-var TelegramBot = class {
-  token;
-  apiBase;
-  pollTimeoutSec;
-  offset = 0;
-  stopped = false;
-  log;
-  consecutiveAuthFailures = 0;
-  consecutiveErrors = 0;
-  constructor(opts, log) {
-    this.token = opts.token;
-    this.apiBase = opts.apiBase ?? "https://api.telegram.org";
-    this.pollTimeoutSec = opts.pollTimeoutSec ?? 25;
-    this.log = log;
-  }
-  /** Strip the bot token from any string before logging or surfacing. */
-  redact(text) {
-    if (!this.token) return text;
-    return text.split(this.token).join("<redacted>");
-  }
-  stop() {
-    this.stopped = true;
-  }
-  isStopped() {
-    return this.stopped;
-  }
-  /** Current update offset; persist to skip already-seen updates on restart. */
-  getOffset() {
-    return this.offset;
-  }
-  setOffset(offset) {
-    if (offset > this.offset) this.offset = offset;
-  }
-  async *poll() {
-    while (!this.isStopped()) {
-      try {
-        const updates = await this.getUpdates();
-        this.consecutiveAuthFailures = 0;
-        this.consecutiveErrors = 0;
-        for (const update of updates) {
-          if (this.isStopped()) return;
-          if (update.update_id >= this.offset) {
-            this.offset = update.update_id + 1;
-          }
-          yield update;
-        }
-      } catch (err) {
-        const message = this.redact(errorMessage(err));
-        const apiErr = err instanceof TelegramApiError ? err : void 0;
-        const status = apiErr?.status;
-        const retryAfterMs = apiErr?.retryAfterMs;
-        if (status === 401 || status === 409) {
-          this.consecutiveAuthFailures++;
-          this.log(
-            "error",
-            `getUpdates failed (HTTP ${status}, attempt ${this.consecutiveAuthFailures}): ${message}`
-          );
-          if (this.consecutiveAuthFailures >= 3) {
-            this.stopped = true;
-            throw new Error(
-              `telegram channel: persistent HTTP ${status} from getUpdates after 3 attempts`
-            );
-          }
-        } else if (status === 429 && retryAfterMs) {
-          this.log(
-            "warn",
-            `getUpdates rate-limited; sleeping ${retryAfterMs}ms`
-          );
-          await sleep(retryAfterMs);
-          continue;
-        } else {
-          this.consecutiveErrors++;
-          this.log("warn", `getUpdates failed: ${message}`);
-        }
-        const backoffMs = Math.min(
-          1500 * Math.pow(2, Math.max(0, this.consecutiveErrors - 1)),
-          3e4
-        );
-        await sleep(backoffMs);
-      }
-    }
-  }
-  async sendMessage(chatId, text, options = {}) {
-    try {
-      const params = { chat_id: chatId, text };
-      if (options.parse_mode) params["parse_mode"] = options.parse_mode;
-      if (options.reply_markup) params["reply_markup"] = options.reply_markup;
-      if (options.message_thread_id !== void 0)
-        params["message_thread_id"] = options.message_thread_id;
-      const result = await this.call("sendMessage", params);
-      return result;
-    } catch (err) {
-      this.log("warn", `sendMessage failed: ${this.redact(errorMessage(err))}`);
-      return null;
-    }
-  }
-  async createForumTopic(chatId, name) {
-    try {
-      return await this.call("createForumTopic", {
-        chat_id: chatId,
-        name
-      });
-    } catch (err) {
-      this.log(
-        "warn",
-        `createForumTopic failed: ${this.redact(errorMessage(err))}`
-      );
-      return null;
-    }
-  }
-  async editForumTopic(chatId, messageThreadId, name) {
-    try {
-      await this.call("editForumTopic", {
-        chat_id: chatId,
-        message_thread_id: messageThreadId,
-        name
-      });
-    } catch (err) {
-      this.log(
-        "debug",
-        `editForumTopic failed: ${this.redact(errorMessage(err))}`
-      );
-    }
-  }
-  async closeForumTopic(chatId, messageThreadId) {
-    try {
-      await this.call("closeForumTopic", {
-        chat_id: chatId,
-        message_thread_id: messageThreadId
-      });
-    } catch (err) {
-      this.log(
-        "debug",
-        `closeForumTopic failed: ${this.redact(errorMessage(err))}`
-      );
-    }
-  }
-  async editMessageText(chatId, messageId, text, options = {}) {
-    try {
-      const params = {
-        chat_id: chatId,
-        message_id: messageId,
-        text
-      };
-      if (options.parse_mode) params["parse_mode"] = options.parse_mode;
-      if (options.reply_markup) params["reply_markup"] = options.reply_markup;
-      await this.call("editMessageText", params);
-    } catch (err) {
-      this.log(
-        "debug",
-        `editMessageText failed: ${this.redact(errorMessage(err))}`
-      );
-    }
-  }
-  async editMessageReplyMarkup(chatId, messageId, replyMarkup) {
-    try {
-      await this.call("editMessageReplyMarkup", {
-        chat_id: chatId,
-        message_id: messageId,
-        reply_markup: replyMarkup ?? { inline_keyboard: [] }
-      });
-    } catch (err) {
-      this.log(
-        "debug",
-        `editMessageReplyMarkup failed: ${this.redact(errorMessage(err))}`
-      );
-    }
-  }
-  async answerCallbackQuery(callbackQueryId, text) {
-    try {
-      const params = {
-        callback_query_id: callbackQueryId
-      };
-      if (text) params["text"] = text;
-      await this.call("answerCallbackQuery", params);
-    } catch (err) {
-      this.log(
-        "debug",
-        `answerCallbackQuery failed: ${this.redact(errorMessage(err))}`
-      );
-    }
-  }
-  async setMyCommands(commands) {
-    try {
-      await this.call("setMyCommands", { commands });
-    } catch (err) {
-      this.log(
-        "debug",
-        `setMyCommands failed: ${this.redact(errorMessage(err))}`
-      );
-    }
-  }
-  async getUpdates() {
-    const result = await this.call("getUpdates", {
-      offset: this.offset,
-      timeout: this.pollTimeoutSec,
-      allowed_updates: ["message", "callback_query"]
-    });
-    return result;
-  }
-  async call(method, params) {
-    const url = `${this.apiBase}/bot${this.token}/${method}`;
-    const ctrl = new AbortController();
-    const timeoutMs = (this.pollTimeoutSec + 5) * 1e3 * 2;
-    const timer = setTimeout(() => ctrl.abort(), timeoutMs);
-    let res;
-    try {
-      res = await fetch(url, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(params),
-        signal: ctrl.signal
-      });
-    } finally {
-      clearTimeout(timer);
-    }
-    if (!res.ok) {
-      let retryAfterSec;
-      try {
-        const body = await res.json();
-        retryAfterSec = body.parameters?.retry_after;
-      } catch {
-      }
-      throw new TelegramApiError(
-        res.status,
-        `HTTP ${res.status}`,
-        typeof retryAfterSec === "number" ? retryAfterSec * 1e3 : void 0
-      );
-    }
-    const json = await res.json();
-    if (!json.ok) {
-      throw new Error(json.description ?? "telegram api returned ok=false");
-    }
-    return json.result;
-  }
-};
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-// src/shared/telegram/markdown.ts
-function escapeMarkdownV2(text) {
-  return text.replace(/([_*[\]()~`>#+\-=|{}.!\\])/g, "\\$1");
-}
-function escapeMarkdownV2CodeBlock(text) {
-  return text.replace(/\\/g, "\\\\").replace(/`/g, "\\`");
-}
-
-// src/gateway/adapters/telegram/verdict.ts
-var CB_PERMISSION = "v";
-var CB_QUESTION = "q";
-var CB_ALLOW = "a";
-var CB_DENY = "d";
-var CB_VERDICT = {
-  allow: CB_ALLOW,
-  deny: CB_DENY
-};
-var ID_PATTERN = CHANNEL_REQUEST_ID_REGEX.source.replace(/^\^|\$$/g, "");
-var VERDICT_RE = new RegExp(`^\\s*(y|yes|n|no)\\s+(${ID_PATTERN})\\s*$`, "i");
-var ANSWER_RE = new RegExp(
-  `^\\s*(a|answer)\\s+(${ID_PATTERN})\\s+([\\s\\S]+?)\\s*$`,
-  "i"
-);
-var ANSWER_ID_RE = new RegExp(`^\\s*(a|answer)\\s+(${ID_PATTERN})\\s+`, "i");
-var NON_NEG_INT_RE = /^\d+$/;
-var MAX_JSON_ANSWER_BYTES = 8 * 1024;
-function parseVerdict(text) {
-  const m = VERDICT_RE.exec(text);
-  if (!m) return null;
-  const verdictWord = m[1].toLowerCase();
-  const id = m[2].toLowerCase();
-  return {
-    channelRequestId: id,
-    behavior: verdictWord.startsWith("y") ? "allow" : "deny"
-  };
-}
-function parseQuestionAnswer(text, questionKeys) {
-  const m = ANSWER_RE.exec(text);
-  if (!m) return null;
-  const channelRequestId = m[2].toLowerCase();
-  const rawAnswer = m[3].trim();
-  if (rawAnswer.length === 0) return null;
-  if (rawAnswer.startsWith("{")) {
-    if (rawAnswer.length > MAX_JSON_ANSWER_BYTES) return null;
-    try {
-      const parsed = JSON.parse(rawAnswer);
-      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-        return null;
-      }
-      const answers = {};
-      for (const [key, value] of Object.entries(parsed)) {
-        if (typeof value !== "string") return null;
-        answers[key] = value;
-      }
-      return { channelRequestId, answers };
-    } catch {
-      return null;
-    }
-  }
-  const firstKey = questionKeys[0];
-  if (!firstKey) return null;
-  return {
-    channelRequestId,
-    answers: { [firstKey]: rawAnswer }
-  };
-}
-function parseQuestionAnswerId(text) {
-  const m = ANSWER_ID_RE.exec(text);
-  return m ? m[2].toLowerCase() : null;
-}
-function buildPlainTextQuestionAnswer(channelRequestId, text, questionKeys) {
-  const answer = text.trim();
-  const firstKey = questionKeys[0];
-  if (!firstKey || answer.length === 0) return null;
-  return {
-    channelRequestId,
-    answers: { [firstKey]: answer }
-  };
-}
-function parseCallbackData(data) {
-  const parts = data.split(":");
-  const kind = parts[0];
-  const id = parts[1];
-  if (!id || !isValidChannelRequestId(id)) return null;
-  if (kind === CB_PERMISSION && parts.length === 3) {
-    const verb = parts[2];
-    if (verb !== CB_ALLOW && verb !== CB_DENY) return null;
-    return {
-      kind: "permission",
-      channelRequestId: id,
-      behavior: verb === CB_ALLOW ? "allow" : "deny"
-    };
-  }
-  if (kind === CB_QUESTION && parts.length === 3) {
-    const idxStr = parts[2];
-    if (!NON_NEG_INT_RE.test(idxStr)) return null;
-    const optionIndex = Number.parseInt(idxStr, 10);
-    return { kind: "question", channelRequestId: id, optionIndex };
-  }
-  return null;
-}
-function buildPermissionCallbackData(channelRequestId, behavior) {
-  return `${CB_PERMISSION}:${channelRequestId}:${CB_VERDICT[behavior]}`;
-}
-function buildQuestionCallbackData(channelRequestId, optionIndex) {
-  return `${CB_QUESTION}:${channelRequestId}:${optionIndex}`;
-}
-
-// src/gateway/adapters/telegram/relay.ts
-var MD_OPTIONS = {
-  parse_mode: "MarkdownV2"
-};
-var TELEGRAM_MAX_TEXT = 4096;
-var TELEGRAM_TEXT_SAFE_MARGIN = 96;
-var TelegramRelay = class {
-  pending = /* @__PURE__ */ new Map();
-  resolveTarget;
-  log;
-  bot = null;
-  constructor(opts) {
-    this.resolveTarget = opts.resolveTarget;
-    this.log = opts.log;
-  }
-  bindBot(bot) {
-    this.bot = bot;
-  }
-  async requestPermission(req, signal) {
-    const bot = this.bot;
-    const target = this.resolveTarget();
-    if (!bot || !target) {
-      return { kind: "no_relay" };
-    }
-    if (signal.aborted) {
-      return { kind: "cancelled", reason: "auto_resolved" };
-    }
-    const headline = `${req.toolName} \u2014 ${req.description}`;
-    const text = buildPromptMarkdown(
-      req.toolName,
-      req.description,
-      req.inputPreview,
-      req.channelRequestId
-    );
-    const reply_markup = buildPermissionKeyboard(req.channelRequestId);
-    const sent = await bot.sendMessage(target.chatId, text, {
-      ...MD_OPTIONS,
-      reply_markup,
-      ...target.threadId !== void 0 ? { message_thread_id: target.threadId } : {}
-    });
-    if (!sent) {
-      return { kind: "no_relay" };
-    }
-    return new Promise((resolve) => {
-      const abortListener = () => {
-        const entry = this.pending.get(req.channelRequestId);
-        if (!entry || entry.kind !== "permission") return;
-        this.pending.delete(req.channelRequestId);
-        void this.editToCancelled(entry);
-        resolve({ kind: "cancelled", reason: "resolved_by_other_channel" });
-      };
-      signal.addEventListener("abort", abortListener);
-      this.pending.set(req.channelRequestId, {
-        kind: "permission",
-        channelRequestId: req.channelRequestId,
-        chatId: sent.chat.id,
-        messageId: sent.message_id,
-        headline,
-        resolve,
-        abortListener,
-        signal
-      });
-    });
-  }
-  async requestQuestion(req, signal) {
-    const bot = this.bot;
-    const target = this.resolveTarget();
-    if (!bot || !target) {
-      return { kind: "no_relay" };
-    }
-    if (signal.aborted) {
-      return { kind: "cancelled", reason: "auto_resolved" };
-    }
-    const headline = req.title.trim() || "Question";
-    const keyboard = buildQuestionKeyboard(req.channelRequestId, req.questions);
-    const text = buildQuestionMarkdown(
-      headline,
-      req.questions,
-      req.channelRequestId,
-      keyboard !== null
-    );
-    const sent = await bot.sendMessage(target.chatId, text, {
-      ...MD_OPTIONS,
-      ...keyboard !== null ? { reply_markup: keyboard.markup } : {},
-      ...target.threadId !== void 0 ? { message_thread_id: target.threadId } : {}
-    });
-    if (!sent) {
-      return { kind: "no_relay" };
-    }
-    return new Promise((resolve) => {
-      const abortListener = () => {
-        const entry = this.pending.get(req.channelRequestId);
-        if (!entry || entry.kind !== "question") return;
-        this.pending.delete(req.channelRequestId);
-        void this.editToCancelled(entry);
-        resolve({ kind: "cancelled", reason: "resolved_by_other_channel" });
-      };
-      signal.addEventListener("abort", abortListener);
-      this.pending.set(req.channelRequestId, {
-        kind: "question",
-        channelRequestId: req.channelRequestId,
-        chatId: sent.chat.id,
-        messageId: sent.message_id,
-        headline,
-        questionKeys: req.questions.map((q) => q.key),
-        buttonOptions: keyboard?.options ?? null,
-        resolve,
-        abortListener,
-        signal
-      });
-    });
-  }
-  /** Returns true if the update was consumed by a relay (verdict/answer). */
-  handleUpdate(update) {
-    const bot = this.bot;
-    if (!bot) return false;
-    const cb = update.callback_query;
-    if (cb?.data) {
-      const parsed = parseCallbackData(cb.data);
-      if (!parsed) return false;
-      const entry = this.pending.get(parsed.channelRequestId);
-      if (!entry) {
-        void bot.answerCallbackQuery(cb.id, "request expired");
-        return true;
-      }
-      if (parsed.kind === "permission" && entry.kind === "permission") {
-        this.settlePermission(entry, parsed.behavior);
-        void bot.answerCallbackQuery(cb.id, parsed.behavior);
-        return true;
-      }
-      if (parsed.kind === "question" && entry.kind === "question") {
-        const opt = entry.buttonOptions?.[parsed.optionIndex];
-        if (!opt) {
-          void bot.answerCallbackQuery(cb.id, "unknown option");
-          return true;
-        }
-        this.settleQuestion(entry, { [opt.key]: opt.label });
-        void bot.answerCallbackQuery(cb.id, opt.label);
-        return true;
-      }
-      return false;
-    }
-    const message = update.message ?? update.edited_message;
-    const text = message?.text;
-    if (typeof text !== "string" || text.length === 0) return false;
-    const verdict = parseVerdict(text);
-    if (verdict) {
-      const entry = this.pending.get(verdict.channelRequestId);
-      if (entry?.kind === "permission") {
-        this.settlePermission(entry, verdict.behavior);
-        return true;
-      }
-      return false;
-    }
-    const answerId = parseQuestionAnswerId(text);
-    if (answerId) {
-      const entry = this.pending.get(answerId);
-      if (entry?.kind === "question") {
-        const parsed = parseQuestionAnswer(text, entry.questionKeys);
-        if (!parsed) return false;
-        this.settleQuestion(entry, parsed.answers);
-        return true;
-      }
-      return false;
-    }
-    if (message && "reply_to_message" in message && message.reply_to_message) {
-      const replyTo = message.reply_to_message.message_id;
-      for (const entry of this.pending.values()) {
-        if (entry.kind !== "question") continue;
-        if (entry.messageId !== replyTo) continue;
-        const parsed = buildPlainTextQuestionAnswer(
-          entry.channelRequestId,
-          text,
-          entry.questionKeys
-        );
-        if (!parsed) return false;
-        this.settleQuestion(entry, parsed.answers);
-        return true;
-      }
-    }
-    return false;
-  }
-  disposeAll() {
-    for (const entry of [...this.pending.values()]) {
-      this.pending.delete(entry.channelRequestId);
-      entry.signal.removeEventListener("abort", entry.abortListener);
-      if (entry.kind === "permission") {
-        entry.resolve({ kind: "cancelled", reason: "auto_resolved" });
-      } else {
-        entry.resolve({ kind: "cancelled", reason: "auto_resolved" });
-      }
-    }
-  }
-  settlePermission(entry, behavior) {
-    this.pending.delete(entry.channelRequestId);
-    entry.signal.removeEventListener("abort", entry.abortListener);
-    void this.editToResolved(
-      entry,
-      behavior === "allow" ? "Allowed" : "Denied"
-    );
-    entry.resolve({ kind: "verdict", behavior, channelId: "telegram" });
-  }
-  settleQuestion(entry, answers) {
-    this.pending.delete(entry.channelRequestId);
-    entry.signal.removeEventListener("abort", entry.abortListener);
-    const summary = Object.values(answers).join(", ").slice(0, 120);
-    void this.editToResolved(entry, summary || "Answered");
-    entry.resolve({ kind: "answer", answers, channelId: "telegram" });
-  }
-  async editToResolved(entry, label) {
-    const bot = this.bot;
-    if (!bot) return;
-    try {
-      await bot.editMessageText(
-        entry.chatId,
-        entry.messageId,
-        buildResolvedText(entry.headline, label),
-        MD_OPTIONS
-      );
-    } catch (err) {
-      this.log(
-        "debug",
-        `telegram relay: edit-to-resolved failed: ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-  }
-  async editToCancelled(entry) {
-    const bot = this.bot;
-    if (!bot) return;
-    try {
-      await bot.editMessageText(
-        entry.chatId,
-        entry.messageId,
-        buildCancelText("resolved elsewhere"),
-        MD_OPTIONS
-      );
-    } catch (err) {
-      this.log(
-        "debug",
-        `telegram relay: edit-to-cancelled failed: ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-  }
-};
-function clampToTelegramLimit(text) {
-  if (text.length <= TELEGRAM_MAX_TEXT) return text;
-  return text.slice(0, TELEGRAM_MAX_TEXT - 1) + "\u2026";
-}
-function buildPromptMarkdown(toolName, description, inputPreview, channelRequestId) {
-  const trimmedPreview = inputPreview.trim();
-  const render = (preview) => {
-    const lines = [
-      `*${escapeMarkdownV2(toolName)}* \u2014 ${escapeMarkdownV2(description)}`
-    ];
-    if (preview.length > 0) {
-      lines.push("", "```", escapeMarkdownV2CodeBlock(preview), "```");
-    }
-    lines.push(
-      "",
-      escapeMarkdownV2(
-        `Tap a button below, or reply "yes ${channelRequestId}" / "no ${channelRequestId}".`
-      )
-    );
-    return lines.join("\n");
-  };
-  const first = render(trimmedPreview);
-  const budget = TELEGRAM_MAX_TEXT - TELEGRAM_TEXT_SAFE_MARGIN;
-  if (first.length <= budget) return first;
-  const overflow = first.length - budget;
-  const safePreview = trimmedPreview.length > overflow ? trimmedPreview.slice(0, Math.max(0, trimmedPreview.length - overflow)) + "\u2026" : "";
-  return clampToTelegramLimit(render(safePreview));
-}
-function buildPermissionKeyboard(channelRequestId) {
-  return {
-    inline_keyboard: [
-      [
-        {
-          text: "\u2705 Allow",
-          callback_data: buildPermissionCallbackData(channelRequestId, "allow")
-        },
-        {
-          text: "\u274C Deny",
-          callback_data: buildPermissionCallbackData(channelRequestId, "deny")
-        }
-      ]
-    ]
-  };
-}
-function buildQuestionMarkdown(title, questions, channelRequestId, hasButtons) {
-  const lines = [`*${escapeMarkdownV2(title)}*`];
-  for (const [index, q] of questions.entries()) {
-    lines.push("");
-    lines.push(
-      `${index + 1}\\. *${escapeMarkdownV2(q.header)}*: ${escapeMarkdownV2(q.question)}`
-    );
-    if (q.options.length > 0 && !hasButtons) {
-      for (const option of q.options) {
-        const suffix = option.description ? ` \u2014 ${option.description}` : "";
-        lines.push(`   \u2022 ${escapeMarkdownV2(option.label + suffix)}`);
-      }
-    }
-  }
-  const trailer = hasButtons ? escapeMarkdownV2("Tap an option below.") : questions.length <= 1 ? escapeMarkdownV2(
-    `Reply with your answer, or "answer ${channelRequestId} your response".`
-  ) : escapeMarkdownV2(
-    `Reply 'answer ${channelRequestId} {"Question":"Answer"}' to respond.`
-  );
-  lines.push("", trailer);
-  return clampToTelegramLimit(lines.join("\n"));
-}
-function buildQuestionKeyboard(channelRequestId, questions) {
-  if (questions.length !== 1) return null;
-  const q = questions[0];
-  if (q.multi_select || q.options.length === 0) return null;
-  const rows = [];
-  const options = [];
-  for (const [optIdx, option] of q.options.entries()) {
-    const data = buildQuestionCallbackData(channelRequestId, optIdx);
-    if (Buffer.byteLength(data, "utf8") > 64) return null;
-    rows.push([{ text: option.label, callback_data: data }]);
-    options.push({ key: q.key, label: option.label });
-  }
-  return { markup: { inline_keyboard: rows }, options };
-}
-function buildResolvedText(headline, label) {
-  return `*${escapeMarkdownV2(headline)}*
-
-${escapeMarkdownV2(`\u2713 ${label}`)}`;
-}
-function buildCancelText(reason) {
-  return escapeMarkdownV2(`~ resolved (${reason}) ~`);
-}
-
-// src/gateway/adapters/telegram/adapter.ts
-var TELEGRAM_DEFAULT_ID = "telegram";
-var TelegramAdapter = class {
-  id;
-  capabilities = {
-    chat: true,
-    threads: true,
-    relayPermission: true,
-    relayQuestion: true,
-    // Telegram caps text at 4096 chars; we leave chunking to the manager.
-    maxMessageBytes: 4096
-  };
-  bot = null;
-  opts;
-  relay;
-  pollTask = null;
-  lastInboundAt;
-  lastTransportOk = true;
-  ctx = null;
-  constructor(opts, id = TELEGRAM_DEFAULT_ID) {
-    this.opts = opts;
-    this.id = id;
-    this.relay = new TelegramRelay({
-      resolveTarget: () => {
-        if (this.opts.defaultChatId === void 0) return null;
-        return {
-          chatId: this.opts.defaultChatId,
-          ...this.opts.defaultThreadId !== void 0 ? { threadId: this.opts.defaultThreadId } : {}
-        };
-      },
-      log: (level, msg) => this.ctx?.log(level, msg)
-    });
-  }
-  requestPermissionVerdict(req, signal) {
-    return this.relay.requestPermission(req, signal);
-  }
-  requestQuestionAnswer(req, signal) {
-    return this.relay.requestQuestion(req, signal);
-  }
-  async start(ctx) {
-    if (this.bot) {
-      throw new Error("telegram adapter already started");
-    }
-    this.ctx = ctx;
-    const factory = this.opts.botFactory ?? ((o) => new TelegramBot(
-      {
-        token: o.token,
-        apiBase: o.apiBase,
-        pollTimeoutSec: o.pollTimeoutSec
-      },
-      o.log
-    ));
-    this.bot = factory({
-      token: this.opts.token,
-      apiBase: this.opts.apiBase,
-      pollTimeoutSec: this.opts.pollTimeoutSec,
-      log: ctx.log
-    });
-    this.relay.bindBot(this.bot);
-    this.pollTask = this.runPollLoop();
-    ctx.signal.addEventListener("abort", () => {
-      this.bot?.stop();
-    });
-  }
-  async stop(_reason) {
-    this.relay.disposeAll();
-    this.bot?.stop();
-    const task = this.pollTask;
-    this.pollTask = null;
-    if (task) {
-      try {
-        await task;
-      } catch {
-      }
-    }
-    this.relay.bindBot(null);
-    this.bot = null;
-    this.ctx = null;
-  }
-  async send(msg) {
-    const bot = this.bot;
-    if (!bot) {
-      throw new Error("telegram adapter: send called before start");
-    }
-    const chatId = msg.location.peer?.id ?? msg.location.room?.id;
-    if (!chatId) {
-      throw new Error(
-        "telegram adapter: outbound location has no peer or room"
-      );
-    }
-    const threadId = msg.location.thread?.id ? Number(msg.location.thread.id) : void 0;
-    const result = await bot.sendMessage(chatId, msg.text, {
-      ...threadId !== void 0 && Number.isFinite(threadId) ? { message_thread_id: threadId } : {}
-    });
-    if (!result) {
-      throw new Error("telegram adapter: sendMessage returned null");
-    }
-    return {
-      providerMessageId: String(result.message_id),
-      deliveredAt: Date.now()
-    };
-  }
-  async probe() {
-    return {
-      ok: this.lastTransportOk,
-      detail: this.lastTransportOk ? "long-poll healthy" : "long-poll erroring",
-      checkedAt: Date.now()
-    };
-  }
-  async runPollLoop() {
-    const bot = this.bot;
-    const ctx = this.ctx;
-    if (!bot || !ctx) return;
-    const allow = this.opts.allowedUserIds.length === 0 ? null : new Set(this.opts.allowedUserIds.map(String));
-    try {
-      for await (const update of bot.poll()) {
-        if (this.relay.handleUpdate(update)) {
-          this.markHealth(true);
-          continue;
-        }
-        const inbound = normalizeInbound2(update, allow, this.id);
-        if (!inbound) continue;
-        this.lastInboundAt = inbound.receivedAt;
-        this.markHealth(true);
-        try {
-          ctx.emitInbound(inbound);
-        } catch (err) {
-          ctx.log(
-            "warn",
-            `telegram emitInbound threw: ${err instanceof Error ? err.message : String(err)}`
-          );
-        }
-      }
-    } catch (err) {
-      this.markHealth(false, err instanceof Error ? err.message : String(err));
-      ctx.log(
-        "error",
-        `telegram poll loop terminated: ${err instanceof Error ? err.message : String(err)}`
-      );
-      throw err;
-    }
-  }
-  markHealth(ok2, note) {
-    this.lastTransportOk = ok2;
-    const ctx = this.ctx;
-    if (!ctx) return;
-    const sample = {
-      at: Date.now(),
-      transportOk: ok2,
-      ...this.lastInboundAt !== void 0 ? { lastInboundAt: this.lastInboundAt } : {},
-      ...note !== void 0 ? { note } : {}
-    };
-    try {
-      ctx.emitHealth(sample);
-    } catch {
-    }
-  }
-};
-function normalizeInbound2(update, allow, channelId) {
-  const message = update.message ?? update.edited_message;
-  if (!message) return null;
-  const text = message.text;
-  if (typeof text !== "string" || text.length === 0) return null;
-  const sender = message.from;
-  if (!sender) return null;
-  const senderId = String(sender.id);
-  if (allow && !allow.has(senderId)) return null;
-  const accountId = String(sender.is_bot ? `bot:${sender.id}` : "user");
-  const chatId = String(message.chat.id);
-  const isPrivate = message.chat.type === "private";
-  const threadId = typeof message.message_thread_id === "number" ? String(message.message_thread_id) : void 0;
-  return {
-    location: {
-      channelId,
-      accountId,
-      ...isPrivate ? { peer: { id: chatId, kind: "user" } } : {
-        room: {
-          id: chatId,
-          kind: message.chat.type === "channel" ? "channel" : "group"
-        }
-      },
-      ...threadId !== void 0 ? { thread: { id: threadId } } : {}
-    },
-    sender: {
-      id: senderId,
-      ...sender.username !== void 0 ? { displayName: sender.username } : sender.first_name !== void 0 ? { displayName: sender.first_name } : {}
-    },
-    text,
-    receivedAt: Date.now(),
-    idempotencyKey: `tg:${update.update_id}`,
-    providerMessageId: String(message.message_id)
-  };
-}
-
-// src/gateway/adapters/telegram/module.ts
-var telegramModule = {
-  name: "telegram",
-  parseConfig({ options, allowedUserIds }) {
-    const token = options["bot_token"];
-    if (typeof token !== "string" || token.length === 0) {
-      return { ok: false, reason: "bot_token missing" };
-    }
-    const defaultChatRaw = options["default_chat_id"];
-    const defaultThreadRaw = options["default_thread_id"];
-    const apiBaseRaw = options["api_base"];
-    const pollTimeoutRaw = options["poll_timeout_sec"];
-    if (defaultChatRaw !== void 0 && typeof defaultChatRaw !== "string" && typeof defaultChatRaw !== "number") {
-      return { ok: false, reason: "default_chat_id must be string or number" };
-    }
-    if (defaultThreadRaw !== void 0 && typeof defaultThreadRaw !== "number") {
-      return { ok: false, reason: "default_thread_id must be number" };
-    }
-    if (apiBaseRaw !== void 0 && typeof apiBaseRaw !== "string") {
-      return { ok: false, reason: "api_base must be string" };
-    }
-    if (pollTimeoutRaw !== void 0 && typeof pollTimeoutRaw !== "number") {
-      return { ok: false, reason: "poll_timeout_sec must be number" };
-    }
-    const config = {
-      token,
-      allowedUserIds,
-      ...defaultChatRaw !== void 0 ? { defaultChatId: defaultChatRaw } : {},
-      ...defaultThreadRaw !== void 0 ? { defaultThreadId: defaultThreadRaw } : {},
-      ...apiBaseRaw !== void 0 ? { apiBase: apiBaseRaw } : {},
-      ...pollTimeoutRaw !== void 0 ? { pollTimeoutSec: pollTimeoutRaw } : {}
-    };
-    return { ok: true, config };
-  },
-  create(config, instanceId) {
-    return new TelegramAdapter(config, instanceId);
-  }
-};
-
-// src/gateway/adapters/registry.ts
-var BUILTIN_MODULES = [
-  telegramModule,
-  consoleModule
-];
-function findAdapterModule(name) {
-  return BUILTIN_MODULES.find((m) => m.name === name);
-}
-
-// src/gateway/adapters/factory.ts
-function instantiateAdapter(sidecar) {
-  const module = findAdapterModule(sidecar.kind);
-  if (!module) {
-    return { ok: false, reason: `unknown channel kind: ${sidecar.kind}` };
-  }
-  const parsed = module.parseConfig({
-    options: sidecar.options,
-    allowedUserIds: sidecar.allowedUserIds
-  });
-  if (!parsed.ok) {
-    return { ok: false, reason: `${sidecar.instanceId}: ${parsed.reason}` };
-  }
-  return { ok: true, adapter: module.create(parsed.config, sidecar.instanceId) };
-}
-
-// src/gateway/channelManager.ts
-var DEFAULT_DEDUP_WINDOW = 1024;
-var DuplicateChannelError = class extends Error {
-  constructor(id) {
-    super(`channel ${id} already registered`);
-    this.name = "DuplicateChannelError";
-  }
-};
-var UnknownChannelError = class extends Error {
-  constructor(id) {
-    super(`channel ${id} not registered`);
-    this.name = "UnknownChannelError";
-  }
-};
-var ChannelManager = class {
-  entries = /* @__PURE__ */ new Map();
-  dedup = [];
-  dedupSet = /* @__PURE__ */ new Set();
-  dedupMax;
-  log;
-  inboundSink = null;
-  healthSink = null;
-  stopped = false;
-  constructor(opts = {}) {
-    this.dedupMax = opts.dedupWindow ?? DEFAULT_DEDUP_WINDOW;
-    this.log = opts.log;
-  }
-  /** Register the single inbound dispatch target. M5 wires the router here. */
-  setInboundSink(sink) {
-    this.inboundSink = sink;
-  }
-  setHealthSink(sink) {
-    this.healthSink = sink;
-  }
-  listChannels() {
-    return [...this.entries.values()].map((e) => ({
-      id: e.adapter.id,
-      health: e.lastHealth
-    }));
-  }
-  /** Snapshot of currently registered adapters; used by the relay coordinator. */
-  listAdapters() {
-    return [...this.entries.values()].map((e) => e.adapter);
-  }
-  async register(adapter) {
-    if (this.stopped) {
-      throw new Error("channel manager already stopped");
-    }
-    if (this.entries.has(adapter.id)) {
-      throw new DuplicateChannelError(adapter.id);
-    }
-    const abort = new AbortController();
-    const inboundListener = (msg) => this.handleInbound(msg);
-    const healthListener = (sample) => {
-      const entry = this.entries.get(adapter.id);
-      if (entry) entry.lastHealth = sample;
-      this.healthSink?.(sample);
-    };
-    const startPromise = adapter.start({
-      log: (level, msg) => this.log?.(level, `[${adapter.id}] ${msg}`),
-      signal: abort.signal,
-      emitInbound: inboundListener,
-      emitHealth: healthListener
-    });
-    this.entries.set(adapter.id, {
-      adapter,
-      abort,
-      startPromise
-    });
-    try {
-      await startPromise;
-    } catch (err) {
-      this.entries.delete(adapter.id);
-      throw err;
-    }
-  }
-  async unregister(id, reason) {
-    const entry = this.entries.get(id);
-    if (!entry) {
-      throw new UnknownChannelError(id);
-    }
-    this.entries.delete(id);
-    entry.abort.abort();
-    await entry.adapter.stop(reason);
-  }
-  async send(channelId, msg) {
-    const entry = this.entries.get(channelId);
-    if (!entry) {
-      throw new UnknownChannelError(channelId);
-    }
-    return entry.adapter.send(msg);
-  }
-  async probe(channelId) {
-    const entry = this.entries.get(channelId);
-    if (!entry) {
-      throw new UnknownChannelError(channelId);
-    }
-    return entry.adapter.probe();
-  }
-  async stop(reason = "shutdown") {
-    if (this.stopped) return;
-    this.stopped = true;
-    const ids = [...this.entries.keys()];
-    for (const id of ids.reverse()) {
-      try {
-        await this.unregister(id, reason);
-      } catch (err) {
-        this.log?.(
-          "warn",
-          `channel ${id} stop failed: ${err instanceof Error ? err.message : String(err)}`
-        );
-      }
-    }
-  }
-  handleInbound(msg) {
-    if (this.dedupSet.has(msg.idempotencyKey)) {
-      this.log?.("debug", `dropping duplicate inbound ${msg.idempotencyKey}`);
-      return;
-    }
-    this.dedupSet.add(msg.idempotencyKey);
-    this.dedup.push(msg.idempotencyKey);
-    while (this.dedup.length > this.dedupMax) {
-      const evicted = this.dedup.shift();
-      if (evicted !== void 0) this.dedupSet.delete(evicted);
-    }
-    const sink = this.inboundSink;
-    if (!sink) {
-      this.log?.(
-        "debug",
-        `no inbound sink registered; dropping ${msg.idempotencyKey}`
-      );
-      return;
-    }
-    try {
-      sink(msg);
-    } catch (err) {
-      this.log?.(
-        "warn",
-        `inbound sink threw: ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-  }
-};
-
-// src/gateway/control/handlers.ts
-import { createRequire } from "module";
-
-// src/gateway/runtimeBindingStore.ts
-var AlreadyRegisteredError = class extends Error {
-  code = "already_registered";
-  constructor(existing) {
-    super(
-      `gateway already has a registered runtime (pid=${existing.pid}, runtimeId=${existing.runtimeId})`
-    );
-    this.name = "AlreadyRegisteredError";
-  }
-};
-var NotRegisteredError = class extends Error {
-  code = "not_registered";
-  constructor() {
-    super("no runtime registered with gateway");
-    this.name = "NotRegisteredError";
-  }
-};
-function maybeLastRebindAt(value) {
-  return value !== void 0 ? { lastRebindAt: value } : {};
-}
-var RuntimeBindingStore = class {
-  current = null;
-  bindingState = null;
-  staleTimer = null;
-  staleSince = null;
-  gracePeriodMs;
-  observers;
-  now;
-  constructor(opts = {}) {
-    this.gracePeriodMs = opts.gracePeriodMs ?? 0;
-    this.observers = opts.observers ?? {};
-    this.now = opts.now ?? Date.now;
-  }
-  // ── lifecycle ─────────────────────────────────────────────
-  /** Register a runtime and bind its connection in one atomic step. */
-  bind(input) {
-    const previous = this.bindingState;
-    const wasStale = previous?.state === "stale";
-    const staleSince = wasStale ? previous.staleSince : null;
-    if (!this.current) {
-      this.current = {
-        runtimeId: input.runtimeId,
-        defaultAgentId: input.defaultAgentId,
-        pid: input.pid,
-        registeredAt: this.now()
-      };
-    } else if (this.current.runtimeId === input.runtimeId) {
-      this.current = {
-        ...this.current,
-        defaultAgentId: input.defaultAgentId,
-        pid: input.pid
-      };
-    } else {
-      throw new AlreadyRegisteredError(this.current);
-    }
-    const now = this.now();
-    const isRebind = previous !== null && (previous.state === "stale" || previous.connectionId !== input.connectionId);
-    const lastRebindAt = isRebind ? now : previous?.lastRebindAt;
-    const epoch = previous ? previous.epoch + (isRebind ? 1 : 0) : 1;
-    this.bindingState = {
-      state: "active",
-      connectionId: input.connectionId,
-      boundAt: now,
-      epoch,
-      ...maybeLastRebindAt(lastRebindAt)
-    };
-    this.clearStaleTimer();
-    if (wasStale && staleSince !== null) {
-      this.observers.onRuntimeRebind?.({
-        runtimeId: input.runtimeId,
-        gapMs: now - staleSince,
-        epoch: this.bindingState.epoch
-      });
-    }
-    return { registeredAt: this.current.registeredAt };
-  }
-  /** Fully unregister a runtime. Throws NotRegisteredError if id does not match. */
-  unbind(runtimeId) {
-    if (!this.current || this.current.runtimeId !== runtimeId) {
-      throw new NotRegisteredError();
-    }
-    this.current = null;
-    this.bindingState = null;
-    this.clearStaleTimer();
-  }
-  /**
-   * Called when the transport connection closes.
-   * Returns the runtimeId if the close was for the current binding (caller should
-   * clear the push handle); returns null if the connectionId was not recognised.
-   */
-  notifyConnectionClosed(connectionId) {
-    if (!this.current || !this.bindingState || this.bindingState.connectionId !== connectionId) {
-      return null;
-    }
-    const runtimeId = this.current.runtimeId;
-    const now = this.now();
-    this.bindingState = {
-      state: "stale",
-      connectionId,
-      staleSince: now,
-      epoch: this.bindingState.epoch,
-      ...maybeLastRebindAt(this.bindingState.lastRebindAt)
-    };
-    if (this.gracePeriodMs <= 0) {
-      this.current = null;
-      this.bindingState = null;
-      this.observers.onRuntimeConnectionLost?.({ runtimeId, graceful: false });
-      return runtimeId;
-    }
-    this.staleSince = now;
-    this.staleTimer = setTimeout(() => {
-      this.expireStaleBinding(runtimeId);
-    }, this.gracePeriodMs);
-    return runtimeId;
-  }
-  stop() {
-    this.clearStaleTimer();
-  }
-  // ── reads ─────────────────────────────────────────────────
-  hasActiveBinding(runtimeId) {
-    if (!this.current || !this.bindingState || this.bindingState.state !== "active") {
-      return false;
-    }
-    return runtimeId === void 0 || this.current.runtimeId === runtimeId;
-  }
-  getCurrent() {
-    return this.current;
-  }
-  getBinding() {
-    return this.bindingState;
-  }
-  getRuntimeIdByConnection(connectionId) {
-    if (!this.current || !this.bindingState) return null;
-    return this.bindingState.connectionId === connectionId ? this.current.runtimeId : null;
-  }
-  // ── private ───────────────────────────────────────────────
-  expireStaleBinding(runtimeId) {
-    this.staleTimer = null;
-    const since = this.staleSince;
-    this.staleSince = null;
-    if (!this.current || this.current.runtimeId !== runtimeId || this.hasActiveBinding(runtimeId)) {
-      return;
-    }
-    this.current = null;
-    this.bindingState = null;
-    this.observers.onRuntimeConnectionLost?.({ runtimeId, graceful: false });
-    if (since !== null) {
-      this.observers.onRuntimeExpired?.({ runtimeId, gapMs: this.now() - since });
-    }
-  }
-  clearStaleTimer() {
-    if (this.staleTimer) {
-      clearTimeout(this.staleTimer);
-      this.staleTimer = null;
-    }
-    this.staleSince = null;
-  }
-};
-
-// src/gateway/control/handlers.ts
-var require_ = createRequire(import.meta.url);
-var cachedVersion = null;
-function readVersion() {
-  if (cachedVersion !== null) return cachedVersion;
-  try {
-    const injected = "0.4.5";
-    if (typeof injected === "string" && injected.length > 0) {
-      cachedVersion = injected;
-      return cachedVersion;
-    }
-  } catch {
-  }
-  try {
-    const pkg = require_("../../../package.json");
-    cachedVersion = pkg.version ?? "0.0.0";
-  } catch {
-    cachedVersion = "0.0.0";
-  }
-  return cachedVersion;
-}
-var PING = {
-  kind: "ping",
-  handle: (_envelope, { ts, deps }) => {
-    const payload = {
-      pong: true,
-      daemonPid: process.pid,
-      uptimeMs: ts - deps.startedAt
-    };
-    return payload;
-  }
-};
-var STATUS = {
-  kind: "status",
-  handle: (_envelope, { ts, deps }) => {
-    const channels = (deps.channelManager?.listChannels() ?? []).map((c) => ({
-      id: c.id,
-      state: c.health?.transportOk === false ? "degraded" : "running",
-      ...c.health?.at !== void 0 ? { lastHealthAt: c.health.at } : {},
-      ...c.health?.note !== void 0 ? { note: c.health.note } : {}
-    }));
-    const payload = {
-      daemonPid: process.pid,
-      startedAt: deps.startedAt,
-      uptimeMs: ts - deps.startedAt,
-      version: readVersion(),
-      listener: deps.getListener?.() ?? {
-        kind: "uds",
-        socketPath: "<unknown>"
-      },
-      channels,
-      runtimes: runtimeStatusEntries(deps.pipeline)
-    };
-    return payload;
-  }
-};
-var CHANNELS_RELOAD = {
-  kind: "channels.reload",
-  requires: ["reloadChannels"],
-  unsupportedMessage: "channel reload not configured",
-  handle: async (_envelope, { deps }) => {
-    const payload = await deps.reloadChannels();
-    return payload;
-  }
-};
-var SESSION_REGISTER = {
-  kind: "session.register",
-  requires: ["pipeline"],
-  unsupportedMessage: "session.register not configured",
-  handle: (envelope, { deps, connection }) => {
-    const req = envelope.payload;
-    const reg = deps.pipeline.registerRuntime({
-      runtimeId: req.runtimeId,
-      defaultAgentId: req.defaultAgentId,
-      pid: req.pid,
-      connectionId: connection.connectionId,
-      push: connection.push
-    });
-    const payload = {
-      registeredAt: reg.registeredAt,
-      gatewayStartedAt: deps.startedAt
-    };
-    return payload;
-  }
-};
-var SESSION_UNREGISTER = {
-  kind: "session.unregister",
-  requires: ["pipeline"],
-  unsupportedMessage: "session.unregister not configured",
-  handle: (envelope, { deps, ts }) => {
-    const req = envelope.payload;
-    deps.pipeline.unregisterRuntime(req.runtimeId);
-    const payload = {
-      unregisteredAt: ts
-    };
-    return payload;
-  }
-};
-var SESSION_TURN_COMPLETE = {
-  kind: "session.turn.complete",
-  requires: ["pipeline"],
-  unsupportedMessage: "pipeline not configured",
-  handle: async (envelope, { deps }) => {
-    const req = envelope.payload;
-    return await deps.pipeline.handleTurnComplete(req);
-  }
-};
-var CHANNEL_SEND = {
-  kind: "channel.send",
-  requires: ["channelManager"],
-  unsupportedMessage: "channel manager not configured",
-  handle: async (envelope, { deps }) => {
-    const req = envelope.payload;
-    const result = await deps.channelManager.send(
-      req.message.location.channelId,
-      req.message
-    );
-    const payload = {
-      providerMessageId: result.providerMessageId,
-      deliveredAt: result.deliveredAt
-    };
-    return payload;
-  }
-};
-var RELAY_PERMISSION_REQUEST = {
-  kind: "relay.permission.request",
-  requires: ["relayCoordinator"],
-  unsupportedMessage: "relay coordinator not configured",
-  requireRegisteredRuntime: true,
-  handle: async (envelope, { deps, callerRuntimeId }) => {
-    const req = envelope.payload;
-    const broadcast = deps.relayCoordinator.requestPermission({
-      ...req.channelRequestId !== void 0 ? { channelRequestId: req.channelRequestId } : {},
-      toolName: req.toolName,
-      description: req.description,
-      inputPreview: req.inputPreview,
-      ...req.ttlMs !== void 0 ? { ttlMs: req.ttlMs } : {},
-      ...callerRuntimeId !== void 0 ? { runtimeId: callerRuntimeId } : {}
-    });
-    const result = await broadcast.result;
-    const payload = {
-      channelRequestId: broadcast.channelRequestId,
-      result
-    };
-    return payload;
-  }
-};
-var RELAY_PERMISSION_CANCEL = {
-  kind: "relay.permission.cancel",
-  requires: ["relayCoordinator"],
-  unsupportedMessage: "relay coordinator not configured",
-  requireRegisteredRuntime: true,
-  handle: (envelope, { deps, callerRuntimeId }) => {
-    const req = envelope.payload;
-    const cancelled = deps.relayCoordinator.cancel(
-      req.channelRequestId,
-      req.reason,
-      callerRuntimeId
-    );
-    const payload = { cancelled };
-    return payload;
-  }
-};
-var RELAY_QUESTION_REQUEST = {
-  kind: "relay.question.request",
-  requires: ["relayCoordinator"],
-  unsupportedMessage: "relay coordinator not configured",
-  requireRegisteredRuntime: true,
-  handle: async (envelope, { deps, callerRuntimeId }) => {
-    const req = envelope.payload;
-    const broadcast = deps.relayCoordinator.requestQuestion({
-      ...req.channelRequestId !== void 0 ? { channelRequestId: req.channelRequestId } : {},
-      title: req.title,
-      questions: req.questions,
-      ...req.ttlMs !== void 0 ? { ttlMs: req.ttlMs } : {},
-      ...callerRuntimeId !== void 0 ? { runtimeId: callerRuntimeId } : {}
-    });
-    const result = await broadcast.result;
-    const payload = {
-      channelRequestId: broadcast.channelRequestId,
-      result
-    };
-    return payload;
-  }
-};
-var RELAY_QUESTION_CANCEL = {
-  kind: "relay.question.cancel",
-  requires: ["relayCoordinator"],
-  unsupportedMessage: "relay coordinator not configured",
-  requireRegisteredRuntime: true,
-  handle: (envelope, { deps, callerRuntimeId }) => {
-    const req = envelope.payload;
-    const cancelled = deps.relayCoordinator.cancel(
-      req.channelRequestId,
-      req.reason,
-      callerRuntimeId
-    );
-    const payload = { cancelled };
-    return payload;
-  }
-};
-var HANDLERS = new Map(
-  [
-    PING,
-    STATUS,
-    CHANNELS_RELOAD,
-    SESSION_REGISTER,
-    SESSION_UNREGISTER,
-    SESSION_TURN_COMPLETE,
-    CHANNEL_SEND,
-    RELAY_PERMISSION_REQUEST,
-    RELAY_PERMISSION_CANCEL,
-    RELAY_QUESTION_REQUEST,
-    RELAY_QUESTION_CANCEL
-  ].map((spec) => [spec.kind, spec])
-);
-function createDispatcher(deps) {
-  const handle = async (envelope, connection) => {
-    const ts = Date.now();
-    const spec = HANDLERS.get(envelope.kind);
-    if (!spec) {
-      return error(
-        envelope,
-        ts,
-        "unknown_kind",
-        `unknown kind: ${envelope.kind}`
-      );
-    }
-    if (spec.requires) {
-      for (const name of spec.requires) {
-        if (deps[name] === void 0) {
-          return error(
-            envelope,
-            ts,
-            "unsupported",
-            spec.unsupportedMessage ?? `${spec.kind} not configured`
-          );
-        }
-      }
-    }
-    let callerRuntimeId;
-    if (spec.requireRegisteredRuntime) {
-      callerRuntimeId = deps.pipeline?.getRuntimeIdByConnection(connection.connectionId) ?? void 0;
-      if (deps.pipeline && callerRuntimeId === void 0) {
-        return error(
-          envelope,
-          ts,
-          "not_registered",
-          `${spec.kind} requires a registered runtime connection`
-        );
-      }
-    }
-    try {
-      const payload = await spec.handle(envelope, {
-        deps,
-        connection,
-        callerRuntimeId,
-        ts
-      });
-      return ok(envelope, Date.now(), payload);
-    } catch (err) {
-      if (err instanceof AlreadyRegisteredError || err instanceof NotRegisteredError) {
-        return error(envelope, ts, err.code, err.message);
-      }
-      throw err;
-    }
-  };
-  return handle;
-}
-function runtimeStatusEntries(pipeline) {
-  const runtime = pipeline?.getCurrentRuntime();
-  if (!runtime || !pipeline) return [];
-  const binding = pipeline.getBinding();
-  return [
-    {
-      runtimeId: runtime.runtimeId,
-      defaultAgentId: runtime.defaultAgentId,
-      pid: runtime.pid,
-      registeredAt: runtime.registeredAt,
-      binding: binding?.state === "active" ? {
-        state: "active",
-        boundAt: binding.boundAt,
-        epoch: binding.epoch,
-        ...maybeLastRebindAt(binding.lastRebindAt)
-      } : binding?.state === "stale" ? {
-        state: "stale",
-        staleSince: binding.staleSince,
-        epoch: binding.epoch,
-        ...maybeLastRebindAt(binding.lastRebindAt)
-      } : { state: "none" },
-      pendingDispatchCount: pipeline.pendingDispatchCount()
-    }
-  ];
-}
-function ok(envelope, ts, payload) {
-  return { request_id: envelope.request_id, ts, ok: true, payload };
-}
-function error(envelope, ts, code, message) {
-  return {
-    request_id: envelope.request_id,
-    ts,
-    ok: false,
-    error: { code, message }
-  };
-}
-
-// src/gateway/control/server.ts
-var CONNECT_TIMEOUT_MS = 2e3;
-function isStringRecord(v) {
-  return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-function nowError(requestId, code, message) {
-  return {
-    request_id: requestId,
-    ts: Date.now(),
-    ok: false,
-    error: { code, message }
-  };
-}
-var connectionCounter = 0;
-function nextConnectionId() {
-  connectionCounter = connectionCounter + 1 >>> 0;
-  return `c${connectionCounter}-${process.pid}`;
-}
-async function startControlServer(opts) {
-  const { socketPath, token, startedAt, handler } = opts;
-  const logError = opts.logError ?? ((m) => process.stderr.write(m + "\n"));
-  const transport = opts.transport ?? createUdsServerTransport({
-    socketPath,
-    logError
-  });
-  const listener = await transport.listen((connection) => {
-    handleConnection(
-      connection,
-      token,
-      startedAt,
-      handler,
-      logError,
-      opts.onConnect,
-      opts.onDisconnect
-    );
-  });
-  return {
-    close: () => listener.close()
-  };
-}
-function handleConnection(connection, expectedToken, startedAt, handler, logError, onConnect, onDisconnect) {
-  let authed = false;
-  const connectTimer = setTimeout(() => {
-    connection.close();
-  }, CONNECT_TIMEOUT_MS);
-  const ctx = {
-    connectionId: nextConnectionId(),
-    push: (env) => connection.send(env),
-    disconnect: () => connection.close()
-  };
-  connection.onFrame((parsed) => {
-    if (!isStringRecord(parsed)) {
-      connection.close();
-      return;
-    }
-    if (!authed) {
-      if (parsed["kind"] !== "connect") {
-        connection.close();
-        return;
-      }
-      const tok = parsed["token"];
-      if (typeof tok !== "string" || !timingSafeTokenEqual(tok, expectedToken)) {
-        connection.send({
-          ok: false,
-          error: { code: "unauthorized", message: "invalid token" }
-        });
-        connection.close();
-        return;
-      }
-      authed = true;
-      clearTimeout(connectTimer);
-      connection.send({
-        ok: true,
-        hello: { daemonPid: process.pid, startedAt }
-      });
-      onConnect?.(ctx);
-      return;
-    }
-    const requestId = typeof parsed["request_id"] === "string" ? parsed["request_id"] : "";
-    if (typeof parsed["kind"] !== "string" || typeof parsed["ts"] !== "number" || !("payload" in parsed) || requestId.length === 0) {
-      connection.send(nowError(requestId, "bad_request", "malformed envelope"));
-      return;
-    }
-    void Promise.resolve().then(() => handler(parsed, ctx)).then((res) => connection.send(res)).catch(
-      (err) => connection.send(
-        nowError(
-          requestId,
-          "handler_error",
-          err instanceof Error ? err.message : String(err)
-        )
-      )
-    );
-  });
-  connection.onError((err) => {
-    const code = err.code;
-    if (code !== "EPIPE" && code !== "ECONNRESET") {
-      logError(`gateway: socket error: ${err.message}`);
-    }
-  });
-  connection.onClose(() => {
-    clearTimeout(connectTimer);
-    if (authed) {
-      onDisconnect?.(ctx);
-    }
-  });
-}
-
-// src/gateway/dispatchPipeline.ts
-import crypto from "crypto";
-
-// src/gateway/outboundDispatcher.ts
-var DEFAULT_BACKOFF = [
-  1e3,
-  // 1s
-  2e3,
-  // 2s
-  4e3,
-  // 4s
-  8e3,
-  // 8s
-  16e3,
-  // 16s
-  3e4
-  // 30s
-];
-var DEFAULT_MAX_ATTEMPTS = 10;
-var DEFAULT_TICK_MS = 1e3;
-var DEFAULT_BATCH = 16;
-var OutboundDispatcher = class {
-  outbox;
-  send;
-  backoff;
-  maxAttempts;
-  tickMs;
-  batchSize;
-  now;
-  log;
-  timer = null;
-  draining = false;
-  stopped = false;
-  constructor(opts) {
-    this.outbox = opts.outbox;
-    this.send = opts.send;
-    this.backoff = opts.backoffSchedule ?? DEFAULT_BACKOFF;
-    this.maxAttempts = opts.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
-    this.tickMs = opts.tickIntervalMs ?? DEFAULT_TICK_MS;
-    this.batchSize = opts.drainBatchSize ?? DEFAULT_BATCH;
-    this.now = opts.now ?? Date.now;
-    this.log = opts.log;
-  }
-  start() {
-    if (this.timer) return;
-    this.timer = setInterval(() => {
-      void this.drain();
-    }, this.tickMs);
-    this.timer.unref();
-  }
-  stop() {
-    this.stopped = true;
-    if (this.timer) {
-      clearInterval(this.timer);
-      this.timer = null;
-    }
-  }
-  async dispatch(channelId, msg) {
-    try {
-      const result = await this.send(channelId, msg);
-      return { kind: "sent", result };
-    } catch (err) {
-      const error2 = err instanceof Error ? err.message : String(err);
-      const nextAttemptAt = this.now() + this.backoffFor(0);
-      const id = this.outbox.enqueue({
-        channelId,
-        message: msg,
-        nextAttemptAt,
-        lastError: error2
-      });
-      this.log?.(
-        "warn",
-        `send to ${channelId} failed; parked as outbox#${id}: ${error2}`
-      );
-      return { kind: "queued", outboxId: id, error: error2 };
-    }
-  }
-  /**
-   * Drain due entries. Exposed for tests; the timer also calls this. Safe
-   * to call concurrently — a re-entry guard short-circuits.
-   */
-  async drain() {
-    if (this.draining || this.stopped) {
-      return { retried: 0, succeeded: 0, dropped: 0 };
-    }
-    this.draining = true;
-    let retried = 0;
-    let succeeded = 0;
-    let dropped = 0;
-    try {
-      const due = this.outbox.peekDue(this.now(), this.batchSize);
-      for (const row of due) {
-        retried += 1;
-        const outcome = await this.attempt(row);
-        if (outcome === "succeeded") succeeded += 1;
-        else if (outcome === "dropped") dropped += 1;
-      }
-    } finally {
-      this.draining = false;
-    }
-    return { retried, succeeded, dropped };
-  }
-  async attempt(row) {
-    try {
-      await this.send(row.channelId, row.message);
-      this.outbox.delete(row.id);
-      this.log?.(
-        "info",
-        `outbox#${row.id} delivered to ${row.channelId} on attempt ${row.attempt + 1}`
-      );
-      return "succeeded";
-    } catch (err) {
-      const error2 = err instanceof Error ? err.message : String(err);
-      const nextAttempt = row.attempt + 1;
-      if (nextAttempt >= this.maxAttempts) {
-        this.outbox.delete(row.id);
-        this.log?.(
-          "error",
-          `outbox#${row.id} dropped after ${nextAttempt} attempts: ${error2}`
-        );
-        return "dropped";
-      }
-      const nextAttemptAt = this.now() + this.backoffFor(nextAttempt);
-      this.outbox.recordFailure({
-        id: row.id,
-        nextAttemptAt,
-        lastError: error2
-      });
-      return "requeued";
-    }
-  }
-  backoffFor(attempt) {
-    if (this.backoff.length === 0) return 1e3;
-    const idx = Math.min(attempt, this.backoff.length - 1);
-    return this.backoff[idx];
-  }
-};
-
-// src/gateway/router/sessionKey.ts
-function deriveSessionKey(loc) {
-  const c = loc.channelId;
-  const a = loc.accountId;
-  if (loc.peer?.id) {
-    const peer = loc.peer.id;
-    if (loc.thread?.id) {
-      return `peer:${c}:${a}:${peer}:${loc.thread.id}`;
-    }
-    return `peer:${c}:${a}:${peer}`;
-  }
-  if (loc.room?.id) {
-    const room = loc.room.id;
-    if (loc.thread?.id) {
-      return `room:${c}:${a}:${room}:${loc.thread.id}`;
-    }
-    return `room:${c}:${a}:${room}`;
-  }
-  return `default:${c}:${a}`;
-}
-
-// src/gateway/sessionRegistry.ts
-import { randomUUID } from "crypto";
-var UnknownDispatchError = class extends Error {
-  code = "unknown_dispatch";
-  constructor(id) {
-    super(`unknown dispatchId: ${id}`);
-    this.name = "UnknownDispatchError";
-  }
-};
-var SessionRegistry = class {
-  dispatches = /* @__PURE__ */ new Map();
-  idFactory;
-  now;
-  constructor(opts = {}) {
-    this.idFactory = opts.idFactory ?? randomUUID;
-    this.now = opts.now ?? Date.now;
-  }
-  beginDispatch(input) {
-    const dispatchId = this.idFactory();
-    const entry = {
-      dispatchId,
-      sessionKey: input.sessionKey,
-      agentId: input.agentId,
-      location: input.location,
-      createdAt: this.now()
-    };
-    this.dispatches.set(dispatchId, entry);
-    return entry;
-  }
-  completeDispatch(dispatchId) {
-    const entry = this.dispatches.get(dispatchId);
-    if (!entry) {
-      throw new UnknownDispatchError(dispatchId);
-    }
-    this.dispatches.delete(dispatchId);
-    return entry;
-  }
-  pendingDispatchCount() {
-    return this.dispatches.size;
-  }
-  clearDispatches() {
-    this.dispatches.clear();
-  }
-};
-
-// src/gateway/state/inboundQueue.ts
-var DEFAULT_MAX_ENTRIES = 1e3;
-var InboundQueue = class {
-  db;
-  maxEntries;
-  constructor(db, opts = {}) {
-    this.db = db;
-    this.maxEntries = opts.maxEntries ?? DEFAULT_MAX_ENTRIES;
-  }
-  size() {
-    const row = this.db.prepare("SELECT COUNT(*) as n FROM inbound_queue").get();
-    return row.n;
-  }
-  enqueue(inbound) {
-    if (this.size() >= this.maxEntries) {
-      return { kind: "rejected", reason: "queue_full" };
-    }
-    const stmt = this.db.prepare(
-      `INSERT INTO inbound_queue
-				(channel_id, account_id, idempotency_key, payload_json, created_at)
-			 VALUES (?, ?, ?, ?, ?)
-			 ON CONFLICT(channel_id, account_id, idempotency_key) DO NOTHING`
-    );
-    const result = stmt.run(
-      inbound.location.channelId,
-      inbound.location.accountId,
-      inbound.idempotencyKey,
-      JSON.stringify(inbound),
-      Date.now()
-    );
-    if (result.changes === 0) {
-      return { kind: "duplicate" };
-    }
-    return { kind: "queued", id: Number(result.lastInsertRowid) };
-  }
-  /** Atomically read and remove all parked entries in FIFO order. */
-  drain() {
-    return this.db.transaction(() => {
-      const rows = this.db.prepare("SELECT id, payload_json FROM inbound_queue ORDER BY id ASC").all();
-      if (rows.length > 0) {
-        this.db.prepare("DELETE FROM inbound_queue").run();
-      }
-      return rows.map((r) => ({
-        id: r.id,
-        inbound: JSON.parse(r.payload_json)
-      }));
-    })();
-  }
-};
-
-// src/gateway/state/outbox.ts
-var Outbox = class {
-  db;
-  constructor(db) {
-    this.db = db;
-  }
-  size() {
-    const row = this.db.prepare("SELECT COUNT(*) as n FROM channel_outbox").get();
-    return row.n;
-  }
-  enqueue(input) {
-    const result = this.db.prepare(
-      `INSERT INTO channel_outbox
-					(channel_id, payload_json, attempt, next_attempt_at, last_error, created_at)
-				 VALUES (?, ?, 0, ?, ?, ?)`
-    ).run(
-      input.channelId,
-      JSON.stringify(input.message),
-      input.nextAttemptAt,
-      input.lastError ?? null,
-      Date.now()
-    );
-    return Number(result.lastInsertRowid);
-  }
-  /** Rows whose `next_attempt_at` is at or before `now`, oldest first. */
-  peekDue(now, limit) {
-    const rows = this.db.prepare(
-      `SELECT id, channel_id, payload_json, attempt, next_attempt_at, last_error
-				 FROM channel_outbox
-				 WHERE next_attempt_at <= ?
-				 ORDER BY next_attempt_at ASC, id ASC
-				 LIMIT ?`
-    ).all(now, limit);
-    return rows.map((r) => ({
-      id: r.id,
-      channelId: r.channel_id,
-      message: JSON.parse(r.payload_json),
-      attempt: r.attempt,
-      nextAttemptAt: r.next_attempt_at,
-      lastError: r.last_error
-    }));
-  }
-  delete(id) {
-    this.db.prepare("DELETE FROM channel_outbox WHERE id = ?").run(id);
-  }
-  recordFailure(input) {
-    this.db.prepare(
-      `UPDATE channel_outbox
-				 SET attempt = attempt + 1,
-				     next_attempt_at = ?,
-				     last_error = ?
-				 WHERE id = ?`
-    ).run(input.nextAttemptAt, input.lastError, input.id);
-  }
-};
-
-// src/gateway/dispatchPipeline.ts
-var DispatchPipeline = class {
-  bindingStore;
-  registry;
-  inboundQueue;
-  outbox;
-  outboundDispatcher;
-  resolveAgent;
-  log;
-  now;
-  idFactory;
-  push = null;
-  constructor(opts) {
-    this.bindingStore = new RuntimeBindingStore({
-      gracePeriodMs: opts.gracePeriodMs,
-      observers: opts.observers,
-      now: opts.now
-    });
-    this.registry = new SessionRegistry({
-      now: opts.now ?? Date.now,
-      ...opts.idFactory ? { idFactory: opts.idFactory } : {}
-    });
-    this.inboundQueue = new InboundQueue(opts.stateDb, opts.inboundQueue ?? {});
-    this.outbox = new Outbox(opts.stateDb);
-    this.outboundDispatcher = new OutboundDispatcher({
-      outbox: this.outbox,
-      send: opts.send,
-      ...opts.outbox?.backoffSchedule ? { backoffSchedule: opts.outbox.backoffSchedule } : {},
-      ...opts.outbox?.maxAttempts !== void 0 ? { maxAttempts: opts.outbox.maxAttempts } : {},
-      ...opts.outbox?.tickIntervalMs !== void 0 ? { tickIntervalMs: opts.outbox.tickIntervalMs } : {},
-      ...opts.outbox?.drainBatchSize !== void 0 ? { drainBatchSize: opts.outbox.drainBatchSize } : {},
-      ...opts.now ? { now: opts.now } : {},
-      ...opts.log ? { log: opts.log } : {}
-    });
-    this.resolveAgent = opts.resolveAgent ?? ((input) => input.defaultAgentId);
-    this.log = opts.log;
-    this.now = opts.now ?? Date.now;
-    this.idFactory = opts.idFactory ?? crypto.randomUUID;
-  }
-  // ── lifecycle ────────────────────────────────────────────
-  start() {
-    this.outboundDispatcher.start();
-  }
-  async stop() {
-    this.outboundDispatcher.stop();
-    this.bindingStore.stop();
-  }
-  // ── inbound (channel side) ───────────────────────────────
-  handleInbound(inbound) {
-    const current = this.bindingStore.getCurrent();
-    if (!current || !this.bindingStore.hasActiveBinding(current.runtimeId)) {
-      const result = this.inboundQueue.enqueue(inbound);
-      if (result.kind === "queued") {
-        this.log?.(
-          "info",
-          `no runtime registered; parked inbound ${inbound.idempotencyKey} as queue#${result.id}`
-        );
-        return { kind: "queued", queueId: result.id };
-      }
-      if (result.kind === "duplicate") {
-        this.log?.(
-          "debug",
-          `inbound ${inbound.idempotencyKey} already parked; ignoring duplicate`
-        );
-        return { kind: "dropped", reason: "no_runtime" };
-      }
-      this.log?.(
-        "warn",
-        `inbound queue full (>=${this.inboundQueue.size()}); dropping ${inbound.idempotencyKey}`
-      );
-      return { kind: "dropped", reason: "queue_full" };
-    }
-    return this.dispatchInboundToRuntime(inbound, current);
-  }
-  dispatchInboundToRuntime(inbound, current) {
-    const sessionKey = deriveSessionKey(inbound.location);
-    const agentId = this.resolveAgent({
-      sessionKey,
-      channelId: inbound.location.channelId,
-      defaultAgentId: current.defaultAgentId
-    });
-    if (!agentId) {
-      this.log?.(
-        "warn",
-        `agent resolution returned empty for sessionKey=${sessionKey}`
-      );
-      return { kind: "dropped", reason: "no_default_agent" };
-    }
-    const entry = this.registry.beginDispatch({
-      sessionKey,
-      agentId,
-      location: inbound.location
-    });
-    this.pushDispatch({
-      dispatchId: entry.dispatchId,
-      sessionKey,
-      agentId,
-      inbound
-    });
-    return { kind: "dispatched", dispatchId: entry.dispatchId, sessionKey };
-  }
-  pushDispatch(payload) {
-    if (!this.push) return;
-    this.push.push({
-      push_id: this.idFactory(),
-      ts: this.now(),
-      kind: "session.dispatch.turn",
-      payload
-    });
-  }
-  // ── runtime side ─────────────────────────────────────────
-  registerRuntime(input) {
-    const result = this.bindingStore.bind({
-      runtimeId: input.runtimeId,
-      defaultAgentId: input.defaultAgentId,
-      pid: input.pid,
-      connectionId: input.connectionId
-    });
-    this.push = { connectionId: input.connectionId, push: input.push };
-    writeGatewayTrace(
-      `pipeline registered runtime runtimeId=${input.runtimeId} connectionId=${input.connectionId}`
-    );
-    this.drainPending();
-    return { registeredAt: result.registeredAt };
-  }
-  unregisterRuntime(runtimeId) {
-    this.bindingStore.unbind(runtimeId);
-    this.registry.clearDispatches();
-    this.push = null;
-    writeGatewayTrace(`pipeline unregistered runtime runtimeId=${runtimeId}`);
-  }
-  notifyConnectionClosed(connectionId) {
-    const runtimeId = this.bindingStore.notifyConnectionClosed(connectionId);
-    if (runtimeId === null) return;
-    writeGatewayTrace(
-      `pipeline runtime connection closed runtimeId=${runtimeId} connectionId=${connectionId}`
-    );
-    this.push = null;
-  }
-  async handleTurnComplete(payload) {
-    const current = this.bindingStore.getCurrent();
-    writeGatewayTrace(
-      `pipeline turn.complete received runtimeId=${payload.runtimeId} dispatchId=${payload.dispatchId} channel=${payload.location.channelId} account=${payload.location.accountId} thread=${payload.location.thread?.id ?? ""} textLength=${payload.text.length}`
-    );
-    if (!current || current.runtimeId !== payload.runtimeId) {
-      throw new Error("runtime mismatch on session.turn.complete");
-    }
-    let entry;
-    try {
-      entry = this.registry.completeDispatch(payload.dispatchId);
-    } catch (err) {
-      if (err instanceof UnknownDispatchError) {
-        writeGatewayTrace(
-          `pipeline turn.complete unknown dispatchId=${payload.dispatchId}`
-        );
-        return { delivered: false };
-      }
-      throw err;
-    }
-    const result = await this.sendOutbound(entry.location, payload);
-    writeGatewayTrace(
-      `pipeline sendOutbound delivered dispatchId=${payload.dispatchId} providerMessageId=${result.providerMessageId}`
-    );
-    return { delivered: true, providerMessageId: result.providerMessageId };
-  }
-  async sendOutbound(_parkedLocation, payload) {
-    const out = {
-      location: payload.location,
-      text: payload.text,
-      idempotencyKey: payload.idempotencyKey
-    };
-    const result = await this.outboundDispatcher.dispatch(
-      payload.location.channelId,
-      out
-    );
-    if (result.kind === "sent") return result.result;
-    return {
-      providerMessageId: `outbox:${result.outboxId}`,
-      deliveredAt: this.now()
-    };
-  }
-  drainPending() {
-    const current = this.bindingStore.getCurrent();
-    if (!current || !this.bindingStore.hasActiveBinding(current.runtimeId))
-      return;
-    const parked = this.inboundQueue.drain();
-    let dispatched = 0;
-    let dropped = 0;
-    for (const { inbound } of parked) {
-      const result = this.dispatchInboundToRuntime(inbound, current);
-      if (result.kind === "dispatched") dispatched += 1;
-      else dropped += 1;
-    }
-    if (dispatched > 0 || dropped > 0) {
-      this.log?.(
-        "info",
-        `drainPending: dispatched=${dispatched} dropped=${dropped}`
-      );
-    }
-  }
-  // ── reads ────────────────────────────────────────────────
-  getCurrentRuntime() {
-    return this.bindingStore.getCurrent();
-  }
-  getBinding() {
-    return this.bindingStore.getBinding();
-  }
-  hasActiveBinding(runtimeId) {
-    return this.bindingStore.hasActiveBinding(runtimeId);
-  }
-  getRuntimeIdByConnection(connectionId) {
-    return this.bindingStore.getRuntimeIdByConnection(connectionId);
-  }
-  pendingDispatchCount() {
-    return this.registry.pendingDispatchCount();
-  }
-  pendingInboundCount() {
-    return this.inboundQueue.size();
-  }
-  pendingOutboxCount() {
-    return this.outbox.size();
-  }
-};
-
-// src/gateway/lock.ts
-import fs from "fs";
-import path from "path";
-var GatewayAlreadyRunningError = class extends Error {
-  otherPid;
-  constructor(otherPid) {
-    super(`gateway already running (pid=${otherPid})`);
-    this.name = "GatewayAlreadyRunningError";
-    this.otherPid = otherPid;
-  }
-};
-function isProcessAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err) {
-    const code = err.code;
-    return code === "EPERM";
-  }
-}
-function readPidFile(p) {
-  try {
-    const text = fs.readFileSync(p, "utf-8").trim();
-    const pid = Number.parseInt(text, 10);
-    return Number.isInteger(pid) && pid > 0 ? pid : null;
-  } catch {
-    return null;
-  }
-}
-function acquireLock(lockPath) {
-  fs.mkdirSync(path.dirname(lockPath), { recursive: true, mode: 448 });
-  for (let attempt = 0; attempt < 2; attempt++) {
-    try {
-      const fd = fs.openSync(lockPath, "wx", 384);
-      fs.writeSync(fd, String(process.pid) + "\n");
-      fs.closeSync(fd);
-      return {
-        path: lockPath,
-        pid: process.pid,
-        release: () => {
-          try {
-            const pidNow = readPidFile(lockPath);
-            if (pidNow === process.pid) {
-              fs.unlinkSync(lockPath);
-            }
-          } catch {
-          }
-        }
-      };
-    } catch (err) {
-      const code = err.code;
-      if (code !== "EEXIST") throw err;
-      const otherPid = readPidFile(lockPath);
-      if (otherPid !== null && isProcessAlive(otherPid)) {
-        throw new GatewayAlreadyRunningError(otherPid);
-      }
-      try {
-        fs.unlinkSync(lockPath);
-      } catch {
-      }
-    }
-  }
-  throw new Error(`failed to acquire gateway lock at ${lockPath}`);
-}
-
-// src/gateway/relay/pendingRegistry.ts
-var PendingRegistry = class {
-  entries = /* @__PURE__ */ new Map();
-  inspect(channelRequestId, kind, fingerprint, runtimeId) {
-    const existing = this.entries.get(channelRequestId);
-    if (!existing) return { kind: "absent" };
-    if (existing.kind !== kind) return { kind: "collision", reason: "kind" };
-    if (existing.fingerprint !== fingerprint) {
-      return { kind: "collision", reason: "payload" };
-    }
-    if (existing.runtimeId !== runtimeId) {
-      return { kind: "collision", reason: "owner" };
-    }
-    return { kind: "attach", entry: existing };
-  }
-  register(entry) {
-    this.entries.set(entry.channelRequestId, entry);
-  }
-  settle(channelRequestId, result) {
-    const entry = this.entries.get(channelRequestId);
-    if (!entry || entry.settled) return false;
-    entry.settled = true;
-    this.entries.delete(channelRequestId);
-    clearTimeout(entry.timer);
-    for (const ctrl of entry.controllers) {
-      if (!ctrl.signal.aborted) ctrl.abort();
-    }
-    entry.resolve(result);
-    return true;
-  }
-  cancel(channelRequestId, reason, expectedRuntimeId) {
-    const entry = this.entries.get(channelRequestId);
-    if (!entry) return false;
-    if (expectedRuntimeId !== void 0 && entry.runtimeId !== void 0 && entry.runtimeId !== expectedRuntimeId) {
-      return false;
-    }
-    return this.settle(channelRequestId, { kind: "cancelled", reason });
-  }
-  disposeAll(reason) {
-    for (const id of [...this.entries.keys()]) {
-      this.cancel(id, reason, void 0);
-    }
-  }
-  count() {
-    return this.entries.size;
-  }
-};
-function collisionMessage(channelRequestId, reason, newKind) {
-  if (reason === "owner") {
-    return `channel_request_owner_mismatch: ${channelRequestId} owned by a different runtime`;
-  }
-  if (reason === "kind") {
-    const otherKind = newKind === "permission" ? "question" : "permission";
-    return `channel_request_id_collision: ${channelRequestId} is bound to a ${otherKind} relay`;
-  }
-  return `channel_request_id_collision: ${channelRequestId} payload mismatch`;
-}
-
-// src/gateway/relay/coordinator.ts
-var DEFAULT_RELAY_TTL_MS = 5 * 6e4;
-var RelayCoordinator = class {
-  adapters;
-  defaultTtlMs;
-  idFactory;
-  log;
-  registry = new PendingRegistry();
-  constructor(opts) {
-    this.adapters = opts.adapters;
-    this.defaultTtlMs = opts.defaultTtlMs ?? DEFAULT_RELAY_TTL_MS;
-    this.idFactory = opts.idFactory ?? generateChannelRequestId;
-    this.log = opts.log;
-  }
-  requestPermission(req) {
-    const channelRequestId = req.channelRequestId ?? this.idFactory();
-    const targets = this.adapters().filter(
-      (a) => a.capabilities.relayPermission && typeof a.requestPermissionVerdict === "function"
-    );
-    if (targets.length === 0) {
-      return { channelRequestId, result: Promise.resolve({ kind: "no_relay" }) };
-    }
-    const fingerprint = permissionFingerprint(req);
-    const inspect = this.registry.inspect(
-      channelRequestId,
-      "permission",
-      fingerprint,
-      req.runtimeId
-    );
-    if (inspect.kind === "collision") {
-      throw new Error(
-        collisionMessage(channelRequestId, inspect.reason, "permission")
-      );
-    }
-    if (inspect.kind === "attach") {
-      return {
-        channelRequestId,
-        result: inspect.entry.result
-      };
-    }
-    const fullReq = {
-      channelRequestId,
-      toolName: req.toolName,
-      description: req.description,
-      inputPreview: req.inputPreview
-    };
-    const result = this.broadcast({
-      kind: "permission",
-      channelRequestId,
-      ttlMs: req.ttlMs ?? this.defaultTtlMs,
-      runtimeId: req.runtimeId,
-      fingerprint,
-      targets,
-      perAdapter: async (adapter, signal) => {
-        const res = await adapter.requestPermissionVerdict(fullReq, signal);
-        return res.kind === "verdict" ? { ...res, channelId: adapter.id } : null;
-      }
-    });
-    return { channelRequestId, result };
-  }
-  requestQuestion(req) {
-    const channelRequestId = req.channelRequestId ?? this.idFactory();
-    const targets = this.adapters().filter(
-      (a) => a.capabilities.relayQuestion && typeof a.requestQuestionAnswer === "function"
-    );
-    if (targets.length === 0) {
-      return { channelRequestId, result: Promise.resolve({ kind: "no_relay" }) };
-    }
-    const fingerprint = questionFingerprint(req);
-    const inspect = this.registry.inspect(
-      channelRequestId,
-      "question",
-      fingerprint,
-      req.runtimeId
-    );
-    if (inspect.kind === "collision") {
-      throw new Error(
-        collisionMessage(channelRequestId, inspect.reason, "question")
-      );
-    }
-    if (inspect.kind === "attach") {
-      return {
-        channelRequestId,
-        result: inspect.entry.result
-      };
-    }
-    const fullReq = {
-      channelRequestId,
-      title: req.title,
-      questions: req.questions
-    };
-    const result = this.broadcast({
-      kind: "question",
-      channelRequestId,
-      ttlMs: req.ttlMs ?? this.defaultTtlMs,
-      runtimeId: req.runtimeId,
-      fingerprint,
-      targets,
-      perAdapter: async (adapter, signal) => {
-        const res = await adapter.requestQuestionAnswer(fullReq, signal);
-        return res.kind === "answer" ? { ...res, channelId: adapter.id } : null;
-      }
-    });
-    return { channelRequestId, result };
-  }
-  cancel(channelRequestId, reason, expectedRuntimeId) {
-    return this.registry.cancel(channelRequestId, reason, expectedRuntimeId);
-  }
-  pendingCount() {
-    return this.registry.count();
-  }
-  disposeAll(reason = "auto_resolved") {
-    this.registry.disposeAll(reason);
-  }
-  broadcast(args) {
-    const {
-      kind,
-      channelRequestId,
-      ttlMs,
-      runtimeId,
-      fingerprint,
-      targets,
-      perAdapter
-    } = args;
-    const controllers = targets.map(() => new AbortController());
-    let resolveFn;
-    const result = new Promise((resolve) => {
-      resolveFn = resolve;
-    });
-    const timer = setTimeout(() => {
-      this.registry.settle(channelRequestId, {
-        kind: "cancelled",
-        reason: "timeout"
-      });
-    }, ttlMs);
-    if (typeof timer.unref === "function") timer.unref();
-    this.registry.register({
-      kind,
-      channelRequestId,
-      fingerprint,
-      runtimeId,
-      controllers,
-      timer,
-      resolve: resolveFn,
-      result,
-      settled: false
-    });
-    targets.forEach((adapter, idx) => {
-      const ctrl = controllers[idx];
-      Promise.resolve().then(() => perAdapter(adapter, ctrl.signal)).then((res) => {
-        if (res !== null) {
-          this.registry.settle(channelRequestId, res);
-        }
-      }).catch((err) => {
-        this.log?.(
-          "warn",
-          `adapter ${adapter.id} ${kind} relay failed: ${err instanceof Error ? err.message : String(err)}`
-        );
-      });
-    });
-    return result;
-  }
-};
-function permissionFingerprint(req) {
-  return JSON.stringify([req.toolName, req.description, req.inputPreview]);
-}
-function questionFingerprint(req) {
-  return JSON.stringify([req.title, req.questions]);
-}
-
-// src/gateway/state/db.ts
-import fs2 from "fs";
-import path2 from "path";
-import Database from "better-sqlite3";
-var GATEWAY_STATE_VERSION = 1;
-function openGatewayState(dbPath) {
-  if (dbPath !== ":memory:") {
-    fs2.mkdirSync(path2.dirname(dbPath), { recursive: true, mode: 448 });
-  }
-  const db = new Database(dbPath);
-  db.exec("PRAGMA journal_mode = WAL");
-  db.exec("PRAGMA foreign_keys = ON");
-  initGatewayStateSchema(db);
-  if (dbPath !== ":memory:" && process.platform !== "win32") {
-    try {
-      fs2.chmodSync(dbPath, 384);
-    } catch {
-    }
-  }
-  return db;
-}
-function initGatewayStateSchema(db) {
-  db.exec(`
-		CREATE TABLE IF NOT EXISTS schema_version (
-			version INTEGER NOT NULL
-		);
-
-		-- Inbound chat messages parked while no runtime is registered. Drained
-		-- in FIFO id order on session.register. Idempotency key prevents the
-		-- same provider message from being parked twice if an adapter retries.
-		CREATE TABLE IF NOT EXISTS inbound_queue (
-			id INTEGER PRIMARY KEY AUTOINCREMENT,
-			channel_id TEXT NOT NULL,
-			account_id TEXT NOT NULL,
-			idempotency_key TEXT NOT NULL,
-			payload_json TEXT NOT NULL,
-			created_at INTEGER NOT NULL
-		);
-		CREATE UNIQUE INDEX IF NOT EXISTS ix_inbound_queue_idem
-			ON inbound_queue(channel_id, account_id, idempotency_key);
-
-		-- Outbound messages whose adapter send() failed transiently. Drained
-		-- by a periodic retry loop with exponential backoff. Idempotency key
-		-- on the OutboundMessage prevents double-delivery if the adapter
-		-- partially succeeded before throwing.
-		CREATE TABLE IF NOT EXISTS channel_outbox (
-			id INTEGER PRIMARY KEY AUTOINCREMENT,
-			channel_id TEXT NOT NULL,
-			payload_json TEXT NOT NULL,
-			attempt INTEGER NOT NULL DEFAULT 0,
-			next_attempt_at INTEGER NOT NULL,
-			last_error TEXT,
-			created_at INTEGER NOT NULL
-		);
-		CREATE INDEX IF NOT EXISTS ix_channel_outbox_due
-			ON channel_outbox(next_attempt_at);
-	`);
-  const existing = db.prepare("SELECT version FROM schema_version").get();
-  if (existing && existing.version > GATEWAY_STATE_VERSION) {
-    throw new Error(
-      `Gateway state DB has newer schema version ${existing.version} (expected <= ${GATEWAY_STATE_VERSION}). Update athena-cli.`
-    );
-  }
-  if (!existing) {
-    db.prepare("INSERT INTO schema_version (version) VALUES (?)").run(
-      GATEWAY_STATE_VERSION
-    );
-  }
-}
-
-// src/gateway/transport/tlsWs.ts
-import { WebSocketServer } from "ws";
-import { createServer as createHttpsServer } from "https";
-import { readFileSync as readFileSync3 } from "fs";
-function createWsServerTransport(opts) {
-  if (!opts.allowNonLoopback && !isLoopbackHost(opts.host)) {
-    throw new Error(`gateway: refusing non-loopback bind without --insecure`);
-  }
-  let endpoint = null;
-  const scheme = opts.tls ? "wss" : "ws";
-  const rateLimit = createConnectRateLimiter(opts.rateLimitPerMin ?? 10);
-  return {
-    kind: "ws",
-    endpoint: () => {
-      if (!endpoint) {
-        throw new Error("gateway: WS transport has not started listening");
-      }
-      return endpoint;
-    },
-    listen: (onConnection) => new Promise((resolve, reject) => {
-      const verifyClient = (info) => rateLimit.allow(info.req.socket.remoteAddress ?? "unknown");
-      const { wss, httpsServer } = createWss({
-        host: opts.host,
-        port: opts.port,
-        tls: opts.tls,
-        verifyClient
-      });
-      const onError = (err) => reject(err);
-      wss.once("error", onError);
-      if (httpsServer) httpsServer.once("error", onError);
-      const onListening = () => {
-        wss.off("error", onError);
-        if (httpsServer) httpsServer.off("error", onError);
-        const addr = httpsServer ? httpsServer.address() : wss.address();
-        if (typeof addr === "string" || addr === null) {
-          wss.close();
-          httpsServer?.close();
-          reject(
-            new Error("gateway: WS listener did not expose TCP address")
-          );
-          return;
-        }
-        endpoint = {
-          host: opts.host,
-          port: addr.port,
-          url: `${scheme}://${opts.host}:${addr.port}`
-        };
-        resolve({
-          close: () => new Promise((closeResolve) => {
-            for (const client of wss.clients) client.terminate();
-            wss.close(() => {
-              if (httpsServer) httpsServer.close(() => closeResolve());
-              else closeResolve();
-            });
-          })
-        });
-      };
-      if (httpsServer) httpsServer.once("listening", onListening);
-      else wss.once("listening", onListening);
-      const pingIntervalMs = opts.pingIntervalMs ?? 15e3;
-      const pongTimeoutMs = opts.pongTimeoutMs ?? 3e4;
-      wss.on("connection", (ws) => {
-        attachHeartbeat(ws, pingIntervalMs, pongTimeoutMs);
-        onConnection(createWsConnection(ws, `${scheme}:${opts.host}`));
-      });
-    })
-  };
-}
-function loadTlsOptions(tls) {
-  return {
-    cert: readFileSync3(tls.certPath),
-    key: readFileSync3(tls.keyPath)
-  };
-}
-function createWss(input) {
-  if (input.tls) {
-    const httpsServer = createHttpsServer(loadTlsOptions(input.tls));
-    httpsServer.listen({ host: input.host, port: input.port });
-    return {
-      wss: new WebSocketServer({
-        server: httpsServer,
-        verifyClient: input.verifyClient
-      }),
-      httpsServer
-    };
-  }
-  return {
-    wss: new WebSocketServer({
-      host: input.host,
-      port: input.port,
-      verifyClient: input.verifyClient
-    }),
-    httpsServer: null
-  };
-}
-function createConnectRateLimiter(maxPerMin) {
-  if (maxPerMin <= 0) return { allow: () => true };
-  const buckets = /* @__PURE__ */ new Map();
-  let pruneCountdown = 256;
-  const prune = (cutoff) => {
-    for (const [ip, arr] of buckets) {
-      const fresh = arr.filter((t) => t > cutoff);
-      if (fresh.length === 0) buckets.delete(ip);
-      else if (fresh.length !== arr.length) buckets.set(ip, fresh);
-    }
-  };
-  return {
-    allow(ip) {
-      const now = Date.now();
-      const cutoff = now - 6e4;
-      pruneCountdown -= 1;
-      if (pruneCountdown <= 0) {
-        prune(cutoff);
-        pruneCountdown = 256;
-      }
-      const recent = (buckets.get(ip) ?? []).filter((t) => t > cutoff);
-      if (recent.length >= maxPerMin) {
-        buckets.set(ip, recent);
-        return false;
-      }
-      recent.push(now);
-      buckets.set(ip, recent);
-      return true;
-    }
-  };
-}
-function attachHeartbeat(ws, pingIntervalMs, pongTimeoutMs) {
-  if (pingIntervalMs <= 0) return;
-  let pongTimer = null;
-  const clearPongTimer = () => {
-    if (pongTimer) {
-      clearTimeout(pongTimer);
-      pongTimer = null;
-    }
-  };
-  ws.on("pong", clearPongTimer);
-  const interval = setInterval(() => {
-    if (ws.readyState !== ws.OPEN) return;
-    try {
-      ws.ping();
-    } catch {
-      return;
-    }
-    if (!pongTimer) {
-      pongTimer = setTimeout(() => ws.terminate(), pongTimeoutMs);
-    }
-  }, pingIntervalMs);
-  const stop = () => {
-    clearInterval(interval);
-    clearPongTimer();
-  };
-  ws.on("close", stop);
-  ws.on("error", stop);
-}
-function createWsConnection(ws, peer) {
-  const frameHandlers = /* @__PURE__ */ new Set();
-  const closeHandlers = /* @__PURE__ */ new Set();
-  const errorHandlers = /* @__PURE__ */ new Set();
-  ws.on("message", (data) => {
-    let parsed;
-    try {
-      parsed = JSON.parse(data.toString());
-    } catch {
-      ws.close();
-      return;
-    }
-    traceGatewayFrame("ws", peer, "in", parsed);
-    for (const handler of frameHandlers) handler(parsed);
-  });
-  ws.on("error", (err) => {
-    for (const handler of errorHandlers) handler(err);
-  });
-  ws.on("close", () => {
-    for (const handler of closeHandlers) handler();
-  });
-  return {
-    kind: "ws",
-    peer,
-    send: (frame) => {
-      if (ws.readyState !== ws.OPEN) return;
-      traceGatewayFrame("ws", peer, "out", frame);
-      ws.send(JSON.stringify(frame));
-    },
-    close: () => ws.close(),
-    onFrame: (cb) => {
-      frameHandlers.add(cb);
-      return () => frameHandlers.delete(cb);
-    },
-    onClose: (cb) => {
-      closeHandlers.add(cb);
-      return () => closeHandlers.delete(cb);
-    },
-    onError: (cb) => {
-      errorHandlers.add(cb);
-      return () => errorHandlers.delete(cb);
-    }
-  };
-}
-
-// src/gateway/daemon.ts
-function buildListenerStatus(spec, resolvedPort) {
-  if (spec.kind === "uds") {
-    return { kind: "uds", socketPath: spec.socketPath };
-  }
-  const port = resolvedPort ?? spec.port;
-  const tls = Boolean(spec.tls);
-  const scheme = tls ? "wss" : "ws";
-  return {
-    kind: "tcp",
-    host: spec.host,
-    port,
-    url: `${scheme}://${spec.host}:${port}`,
-    tls,
-    insecure: spec.insecure,
-    loopback: isLoopbackHost(spec.host)
-  };
-}
-function pathIdFromSidecarPath(filePath) {
-  const base = filePath.split(/[\\/]/).pop() ?? filePath;
-  return base.endsWith(".json") ? base.slice(0, -".json".length) : base;
-}
-async function startDaemon(opts) {
-  const startedAt = Date.now();
-  const pid = process.pid;
-  const paths = opts.paths ?? resolveGatewayPaths(opts.env);
-  fs3.mkdirSync(paths.runDir, { recursive: true, mode: 448 });
-  fs3.mkdirSync(paths.configDir, { recursive: true, mode: 448 });
-  if (process.platform !== "win32") {
-    try {
-      fs3.chmodSync(paths.runDir, 448);
-      fs3.chmodSync(paths.configDir, 448);
-    } catch {
-    }
-  }
-  const lock = acquireLock(paths.lockPath);
-  const token = loadOrCreateToken(paths.tokenPath);
-  const listenSpec = opts.listenSpec ?? resolveListenSpec({ paths });
-  requireTokenForBind(listenSpec, token);
-  const listenerHints = {
-    transport: listenSpec.kind === "tcp" ? "ws" : "uds",
-    tls: listenSpec.kind === "tcp" && Boolean(listenSpec.tls),
-    loopback: listenSpec.kind === "uds" || isLoopbackHost(listenSpec.host)
-  };
-  const stateDb = openGatewayState(paths.statePath);
-  const channelManager = new ChannelManager();
-  const relayCoordinator = new RelayCoordinator({
-    adapters: () => channelManager.listAdapters()
-  });
-  const connectionOpenedAt = /* @__PURE__ */ new Map();
-  const disconnectGracePeriodMs = opts.disconnectGracePeriodMs ?? 0;
-  let listenerStatus = null;
-  const log = (level, message) => {
-    if (opts.silent) return;
-    const stream = level === "error" || level === "warn" ? "stderr" : "stdout";
-    process[stream].write(`athena-gateway: [${level}] ${message}
-`);
-  };
-  const pipeline = new DispatchPipeline({
-    stateDb,
-    send: (channelId, msg) => channelManager.send(channelId, msg),
-    gracePeriodMs: disconnectGracePeriodMs,
-    log,
-    observers: {
-      onRuntimeRebind: ({ gapMs, epoch }) => trackGatewayRuntimeRebind({ gapMs, epoch }),
-      onRuntimeExpired: ({ gapMs }) => trackGatewayRuntimeExpired({ gapMs }),
-      // Single-runtime v1: blanket dispose is safe. Multi-runtime must
-      // scope to the disconnecting runtime via disposeAllForRuntime.
-      onRuntimeConnectionLost: () => relayCoordinator.disposeAll("connection_lost")
-    }
-  });
-  pipeline.start();
-  channelManager.setInboundSink((inbound) => {
-    pipeline.handleInbound(inbound);
-  });
-  const channelConfigHome = opts.env?.HOME;
-  const reloadChannels = async () => {
-    const results = [];
-    const { sidecars, errors } = loadChannelSidecars(channelConfigHome);
-    for (const err of errors) {
-      const id = pathIdFromSidecarPath(err.path);
-      results.push({
-        id,
-        ok: false,
-        action: "failed",
-        reason: err.reason
-      });
-    }
-    const sidecarIds = new Set(sidecars.map((s) => s.instanceId));
-    for (const channel of channelManager.listChannels()) {
-      if (sidecarIds.has(channel.id)) continue;
-      try {
-        await channelManager.unregister(channel.id, "shutdown");
-        results.push({
-          id: channel.id,
-          ok: true,
-          action: "unregistered"
-        });
-      } catch (err) {
-        results.push({
-          id: channel.id,
-          ok: false,
-          action: "failed",
-          reason: err instanceof Error ? err.message : String(err)
-        });
-      }
-    }
-    for (const sidecar of sidecars) {
-      const existed = channelManager.listChannels().some((channel) => channel.id === sidecar.instanceId);
-      if (existed) {
-        try {
-          await channelManager.unregister(sidecar.instanceId, "shutdown");
-        } catch (err) {
-          results.push({
-            id: sidecar.instanceId,
-            ok: false,
-            action: "failed",
-            reason: err instanceof Error ? err.message : String(err)
-          });
-          continue;
-        }
-      }
-      const built = instantiateAdapter(sidecar);
-      if (!built.ok) {
-        results.push({
-          id: sidecar.instanceId,
-          ok: false,
-          action: "failed",
-          reason: built.reason
-        });
-        continue;
-      }
-      try {
-        await channelManager.register(built.adapter);
-        results.push({
-          id: sidecar.instanceId,
-          ok: true,
-          action: existed ? "replaced" : "registered"
-        });
-        if (!opts.silent) {
-          process.stdout.write(
-            `athena-gateway: registered ${sidecar.instanceId}
-`
-          );
-        }
-      } catch (err) {
-        results.push({
-          id: sidecar.instanceId,
-          ok: false,
-          action: "failed",
-          reason: err instanceof Error ? err.message : String(err)
-        });
-      }
-    }
-    return { results };
-  };
-  if (!opts.skipChannelLoad) {
-    const { sidecars, errors } = loadChannelSidecars(channelConfigHome);
-    for (const err of errors) {
-      process.stderr.write(
-        `athena-gateway: skipping ${err.path}: ${err.reason}
-`
-      );
-    }
-    for (const sidecar of sidecars) {
-      const built = instantiateAdapter(sidecar);
-      if (!built.ok) {
-        process.stderr.write(
-          `athena-gateway: ${sidecar.instanceId}: ${built.reason}
-`
-        );
-        continue;
-      }
-      try {
-        await channelManager.register(built.adapter);
-        if (!opts.silent) {
-          process.stdout.write(
-            `athena-gateway: registered ${sidecar.instanceId}
-`
-          );
-        }
-      } catch (err) {
-        process.stderr.write(
-          `athena-gateway: register ${sidecar.instanceId} failed: ${err instanceof Error ? err.message : String(err)}
-`
-        );
-      }
-    }
-  }
-  const handler = createDispatcher({
-    startedAt,
-    pipeline,
-    channelManager,
-    relayCoordinator,
-    getListener: () => listenerStatus ?? buildListenerStatus(listenSpec, null),
-    reloadChannels
-  });
-  let server;
-  let listener;
-  try {
-    const transport = listenSpec.kind === "tcp" ? createWsServerTransport({
-      host: listenSpec.host,
-      port: listenSpec.port,
-      allowNonLoopback: listenSpec.insecure || Boolean(listenSpec.tls),
-      ...listenSpec.tls ? { tls: listenSpec.tls } : {}
-    }) : void 0;
-    server = await startControlServer({
-      socketPath: paths.socketPath,
-      token,
-      startedAt,
-      handler,
-      ...transport !== void 0 ? { transport } : {},
-      onConnect: (ctx) => {
-        connectionOpenedAt.set(ctx.connectionId, Date.now());
-        trackGatewayTransportConnect({
-          transport: listenerHints.transport,
-          tls: listenerHints.tls,
-          loopback: listenerHints.loopback
-        });
-      },
-      onDisconnect: (ctx) => {
-        const openedAt = connectionOpenedAt.get(ctx.connectionId);
-        connectionOpenedAt.delete(ctx.connectionId);
-        const durationMs = openedAt !== void 0 ? Date.now() - openedAt : 0;
-        trackGatewayTransportDisconnect({
-          transport: listenerHints.transport,
-          reason: "closed",
-          durationMs
-        });
-        pipeline.notifyConnectionClosed(ctx.connectionId);
-      }
-    });
-    if (listenSpec.kind === "tcp") {
-      const endpoint = transport.endpoint();
-      listener = {
-        kind: "tcp",
-        host: endpoint.host,
-        port: endpoint.port,
-        url: endpoint.url
-      };
-      listenerStatus = buildListenerStatus(listenSpec, endpoint.port);
-    } else {
-      listener = { kind: "uds", socketPath: listenSpec.socketPath };
-      listenerStatus = buildListenerStatus(listenSpec, null);
-    }
-  } catch (err) {
-    lock.release();
-    throw err;
-  }
-  if (!opts.silent) {
-    const target = listener.kind === "tcp" ? listener.url : `socket=${paths.socketPath}`;
-    process.stdout.write(`athena-gateway: ok pid=${pid} ${target}
-`);
-  }
-  if (listenSpec.kind === "tcp" && listenSpec.insecure && !listenSpec.tls && !isLoopbackHost(listenSpec.host)) {
-    process.stderr.write(
-      `athena-gateway: WARNING --insecure is set on a non-loopback bind (${listenSpec.host}:${listenSpec.port}); token travels in plaintext. Use only behind TLS-terminating reverse proxy or Tailscale/WireGuard tunnel.
-`
-    );
-  }
-  let stopping = false;
-  const stop = async () => {
-    if (stopping) return;
-    stopping = true;
-    try {
-      await pipeline.stop();
-      relayCoordinator.disposeAll("auto_resolved");
-      await channelManager.stop();
-      await server.close();
-    } finally {
-      try {
-        stateDb.close();
-      } catch {
-      }
-      lock.release();
-    }
-  };
-  if (!opts.skipSignalHandlers) {
-    const onSignal = (signal) => {
-      process.stderr.write(`athena-gateway: received ${signal}, stopping
-`);
-      void stop().then(() => process.exit(0));
-    };
-    process.once("SIGINT", onSignal);
-    process.once("SIGTERM", onSignal);
-  }
-  return {
-    startedAt,
-    pid,
-    paths,
-    pipeline,
-    channelManager,
-    relayCoordinator,
-    listener,
-    stop
-  };
-}
+  resolveListenSpec
+} from "./chunk-BTY7MYYT.js";
 
 // src/gateway/entryArgs.ts
 function parseGatewayDaemonArgs(argv) {