@drisp/cli 0.3.39

package/dist/athena-gateway.js

@@ -0,0 +1,3998 @@
+#!/usr/bin/env node
+import {
+  CHANNEL_REQUEST_ID_REGEX,
+  createUdsServerTransport,
+  generateChannelRequestId,
+  isLoopbackHost,
+  isValidChannelRequestId,
+  loadOrCreateToken,
+  refreshDashboardAccessToken,
+  requireTokenForBind,
+  resolveGatewayPaths,
+  resolveListenSpec,
+  timingSafeTokenEqual,
+  traceGatewayFrame,
+  trackGatewayRuntimeExpired,
+  trackGatewayRuntimeRebind,
+  trackGatewayTransportConnect,
+  trackGatewayTransportDisconnect,
+  writeGatewayTrace
+} from "./chunk-3FVULBV4.js";
+
+// src/gateway/daemon.ts
+import crypto from "crypto";
+import fs4 from "fs";
+
+// src/infra/config/channels.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+function channelSidecarDir(home = os.homedir()) {
+  return path.join(home, ".config", "athena", "channels");
+}
+function loadChannelSidecars(home = os.homedir()) {
+  const dir = channelSidecarDir(home);
+  const sidecars = [];
+  const errors = [];
+  let entries;
+  try {
+    entries = fs.readdirSync(dir);
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") return { sidecars, errors };
+    errors.push({
+      path: dir,
+      reason: `read dir failed: ${err instanceof Error ? err.message : String(err)}`
+    });
+    return { sidecars, errors };
+  }
+  for (const entry of entries) {
+    if (!entry.endsWith(".json")) continue;
+    const full = path.join(dir, entry);
+    const name = entry.slice(0, -".json".length);
+    const result = loadOne(name, full);
+    if (result.ok) sidecars.push(result.sidecar);
+    else errors.push({ path: full, reason: result.reason });
+  }
+  return { sidecars, errors };
+}
+function loadOne(name, filePath) {
+  let raw;
+  try {
+    if (process.platform !== "win32") {
+      const stat = fs.statSync(filePath);
+      if ((stat.mode & 63) !== 0) {
+        return {
+          ok: false,
+          reason: `file ${filePath} is too permissive (mode ${(stat.mode & 511).toString(8)}); chmod 600`
+        };
+      }
+    }
+    raw = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  } catch (err) {
+    return {
+      ok: false,
+      reason: err instanceof Error ? err.message : String(err)
+    };
+  }
+  if (typeof raw !== "object" || raw === null) {
+    return { ok: false, reason: "config root must be an object" };
+  }
+  const obj = raw;
+  const userIdsRaw = obj["allowed_user_ids"];
+  const allowedUserIds = [];
+  if (userIdsRaw !== void 0) {
+    if (!Array.isArray(userIdsRaw)) {
+      return { ok: false, reason: "allowed_user_ids must be an array" };
+    }
+    for (const id of userIdsRaw) {
+      if (typeof id === "string") allowedUserIds.push(id);
+      else if (typeof id === "number") allowedUserIds.push(String(id));
+      else
+        return {
+          ok: false,
+          reason: "allowed_user_ids entries must be string or number"
+        };
+    }
+  }
+  const options = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (key === "allowed_user_ids") continue;
+    options[key] = value;
+  }
+  return {
+    ok: true,
+    sidecar: { name, path: filePath, allowedUserIds, options }
+  };
+}
+
+// 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;
+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;
+  let ws = null;
+  let ready = null;
+  let closeRequested = false;
+  let reconnectAttempt = 0;
+  let reconnectTimer = null;
+  let lastHello = null;
+  let currentToken = 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 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;
+          }
+          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) => {
+      if (next !== ws) return;
+      ws = null;
+      ready = null;
+      emitClose(reasonBuf.toString() || "closed");
+      if (!closeRequested) scheduleReconnect();
+    });
+  }
+  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;
+    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_ID = "console";
+var CLIENT_NAME = "athena-cli";
+var CLIENT_VERSION = "0.0.0";
+var ConsoleAdapter = class {
+  id = CONSOLE_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) {
+    this.opts = opts;
+  }
+  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 ? {
+          conversationId: msg.location.thread.id,
+          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: CONSOLE_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: CONSOLE_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);
+    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) {
+  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: CONSOLE_ID,
+      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) {
+    return new ConsoleAdapter(config);
+  }
+};
+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_ID = "telegram";
+var TelegramAdapter = class {
+  id = TELEGRAM_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) {
+    this.opts = opts;
+    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);
+        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) {
+  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: TELEGRAM_ID,
+      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) {
+    return new TelegramAdapter(config);
+  }
+};
+
+// 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.name);
+  if (!module) {
+    return { ok: false, reason: `unknown channel: ${sidecar.name}` };
+  }
+  const parsed = module.parseConfig({
+    options: sidecar.options,
+    allowedUserIds: sidecar.allowedUserIds
+  });
+  if (!parsed.ok) {
+    return { ok: false, reason: `${sidecar.name}: ${parsed.reason}` };
+  }
+  return { ok: true, adapter: module.create(parsed.config) };
+}
+
+// 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/sessionRegistry.ts
+import { randomUUID } from "crypto";
+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";
+  }
+};
+var UnknownDispatchError = class extends Error {
+  code = "unknown_dispatch";
+  constructor(id) {
+    super(`unknown dispatchId: ${id}`);
+    this.name = "UnknownDispatchError";
+  }
+};
+function maybeLastRebindAt(value) {
+  return value !== void 0 ? { lastRebindAt: value } : {};
+}
+var SessionRegistry = class {
+  current = null;
+  binding = null;
+  dispatches = /* @__PURE__ */ new Map();
+  idFactory;
+  now;
+  constructor(opts = {}) {
+    this.idFactory = opts.idFactory ?? randomUUID;
+    this.now = opts.now ?? Date.now;
+  }
+  register(input) {
+    if (this.current) {
+      if (this.current.runtimeId === input.runtimeId) {
+        this.current = {
+          ...this.current,
+          defaultAgentId: input.defaultAgentId,
+          pid: input.pid
+        };
+        return this.current;
+      }
+      throw new AlreadyRegisteredError(this.current);
+    }
+    this.current = { ...input, registeredAt: this.now() };
+    return this.current;
+  }
+  bindConnection(runtimeId, connectionId) {
+    if (!this.current || this.current.runtimeId !== runtimeId) {
+      throw new NotRegisteredError();
+    }
+    const previous = this.binding;
+    const now = this.now();
+    const isRebind = previous !== null && (previous.state === "stale" || previous.connectionId !== connectionId);
+    const lastRebindAt = isRebind ? now : previous?.lastRebindAt;
+    const epoch = previous ? previous.epoch + (isRebind ? 1 : 0) : 1;
+    this.binding = {
+      state: "active",
+      connectionId,
+      boundAt: now,
+      epoch,
+      ...maybeLastRebindAt(lastRebindAt)
+    };
+  }
+  markConnectionStale(connectionId) {
+    if (!this.current || !this.binding || this.binding.connectionId !== connectionId || this.binding.state !== "active") {
+      return null;
+    }
+    this.binding = {
+      state: "stale",
+      connectionId,
+      staleSince: this.now(),
+      epoch: this.binding.epoch,
+      ...maybeLastRebindAt(this.binding.lastRebindAt)
+    };
+    return this.current.runtimeId;
+  }
+  hasActiveBinding(runtimeId) {
+    if (!this.current || !this.binding || this.binding.state !== "active") {
+      return false;
+    }
+    return runtimeId === void 0 || this.current.runtimeId === runtimeId;
+  }
+  getBinding() {
+    return this.binding;
+  }
+  getRuntimeIdByConnection(connectionId) {
+    if (!this.current || !this.binding) return null;
+    return this.binding.connectionId === connectionId ? this.current.runtimeId : null;
+  }
+  unregister(runtimeId) {
+    if (!this.current || this.current.runtimeId !== runtimeId) {
+      throw new NotRegisteredError();
+    }
+    this.current = null;
+    this.binding = null;
+    this.dispatches.clear();
+  }
+  getCurrent() {
+    return this.current;
+  }
+  beginDispatch(input) {
+    if (!this.current) {
+      throw new NotRegisteredError();
+    }
+    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;
+  }
+};
+
+// 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.3.39";
+    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;
+}
+function createDispatcher(deps) {
+  const handle = async (envelope, connection) => {
+    const ts = Date.now();
+    switch (envelope.kind) {
+      case "ping": {
+        const payload = {
+          pong: true,
+          daemonPid: process.pid,
+          uptimeMs: ts - deps.startedAt
+        };
+        return ok(envelope, ts, payload);
+      }
+      case "status": {
+        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.registry)
+        };
+        return ok(envelope, ts, payload);
+      }
+      case "channels.reload": {
+        if (!deps.reloadChannels) {
+          return error(
+            envelope,
+            ts,
+            "unsupported",
+            "channel reload not configured"
+          );
+        }
+        const payload = await deps.reloadChannels();
+        return ok(envelope, ts, payload);
+      }
+      case "session.register": {
+        if (!deps.registry)
+          return error(
+            envelope,
+            ts,
+            "unsupported",
+            "session.register not configured"
+          );
+        const req = envelope.payload;
+        try {
+          const reg = deps.registry.register({
+            runtimeId: req.runtimeId,
+            defaultAgentId: req.defaultAgentId,
+            pid: req.pid
+          });
+          deps.registerRuntimeConnection?.(req.runtimeId, connection);
+          try {
+            deps.dispatcher?.drainPending();
+          } catch (err) {
+            process.stderr.write(
+              `gateway: drainPending failed: ${err instanceof Error ? err.message : String(err)}
+`
+            );
+          }
+          const payload = {
+            registeredAt: reg.registeredAt,
+            gatewayStartedAt: deps.startedAt
+          };
+          return ok(envelope, ts, payload);
+        } catch (err) {
+          if (err instanceof AlreadyRegisteredError) {
+            return error(envelope, ts, err.code, err.message);
+          }
+          throw err;
+        }
+      }
+      case "session.unregister": {
+        if (!deps.registry)
+          return error(
+            envelope,
+            ts,
+            "unsupported",
+            "session.unregister not configured"
+          );
+        const req = envelope.payload;
+        try {
+          deps.registry.unregister(req.runtimeId);
+          deps.unregisterRuntimeConnection?.(req.runtimeId);
+          const payload = {
+            unregisteredAt: ts
+          };
+          return ok(envelope, ts, payload);
+        } catch (err) {
+          if (err instanceof NotRegisteredError) {
+            return error(envelope, ts, err.code, err.message);
+          }
+          throw err;
+        }
+      }
+      case "session.turn.complete": {
+        if (!deps.dispatcher)
+          return error(
+            envelope,
+            ts,
+            "unsupported",
+            "dispatcher not configured"
+          );
+        const req = envelope.payload;
+        const result = await deps.dispatcher.handleTurnComplete(req);
+        return ok(envelope, ts, result);
+      }
+      case "channel.send": {
+        if (!deps.channelManager)
+          return error(
+            envelope,
+            ts,
+            "unsupported",
+            "channel manager not configured"
+          );
+        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 ok(envelope, ts, payload);
+      }
+      case "relay.permission.request": {
+        if (!deps.relayCoordinator)
+          return error(
+            envelope,
+            ts,
+            "unsupported",
+            "relay coordinator not configured"
+          );
+        const req = envelope.payload;
+        const callerRuntimeId = deps.registry?.getRuntimeIdByConnection(connection.connectionId) ?? void 0;
+        if (deps.registry && callerRuntimeId === void 0) {
+          return error(
+            envelope,
+            ts,
+            "not_registered",
+            "relay.permission.request requires a registered runtime connection"
+          );
+        }
+        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 ok(envelope, Date.now(), payload);
+      }
+      case "relay.permission.cancel": {
+        if (!deps.relayCoordinator)
+          return error(
+            envelope,
+            ts,
+            "unsupported",
+            "relay coordinator not configured"
+          );
+        const req = envelope.payload;
+        const callerRuntimeId = deps.registry?.getRuntimeIdByConnection(connection.connectionId) ?? void 0;
+        if (deps.registry && callerRuntimeId === void 0) {
+          return error(
+            envelope,
+            ts,
+            "not_registered",
+            "relay.permission.cancel requires a registered runtime connection"
+          );
+        }
+        const cancelled = deps.relayCoordinator.cancel(
+          req.channelRequestId,
+          req.reason,
+          callerRuntimeId
+        );
+        const payload = { cancelled };
+        return ok(envelope, ts, payload);
+      }
+      case "relay.question.request": {
+        if (!deps.relayCoordinator)
+          return error(
+            envelope,
+            ts,
+            "unsupported",
+            "relay coordinator not configured"
+          );
+        const req = envelope.payload;
+        const callerRuntimeId = deps.registry?.getRuntimeIdByConnection(connection.connectionId) ?? void 0;
+        if (deps.registry && callerRuntimeId === void 0) {
+          return error(
+            envelope,
+            ts,
+            "not_registered",
+            "relay.question.request requires a registered runtime connection"
+          );
+        }
+        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 ok(envelope, Date.now(), payload);
+      }
+      case "relay.question.cancel": {
+        if (!deps.relayCoordinator)
+          return error(
+            envelope,
+            ts,
+            "unsupported",
+            "relay coordinator not configured"
+          );
+        const req = envelope.payload;
+        const callerRuntimeId = deps.registry?.getRuntimeIdByConnection(connection.connectionId) ?? void 0;
+        if (deps.registry && callerRuntimeId === void 0) {
+          return error(
+            envelope,
+            ts,
+            "not_registered",
+            "relay.question.cancel requires a registered runtime connection"
+          );
+        }
+        const cancelled = deps.relayCoordinator.cancel(
+          req.channelRequestId,
+          req.reason,
+          callerRuntimeId
+        );
+        const payload = { cancelled };
+        return ok(envelope, ts, payload);
+      }
+      default:
+        return error(
+          envelope,
+          ts,
+          "unknown_kind",
+          `unknown kind: ${envelope.kind}`
+        );
+    }
+  };
+  return handle;
+}
+function runtimeStatusEntries(registry) {
+  const runtime = registry?.getCurrent();
+  if (!runtime || !registry) return [];
+  const binding = registry.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: registry.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/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/dispatcher.ts
+var Dispatcher = class {
+  registry;
+  pushDispatch;
+  sendOutbound;
+  resolveAgent;
+  inboundQueue;
+  canDispatch;
+  log;
+  constructor(opts) {
+    this.registry = opts.registry;
+    this.pushDispatch = opts.pushDispatch;
+    this.sendOutbound = opts.sendOutbound;
+    this.resolveAgent = opts.resolveAgent ?? ((input) => input.defaultAgentId);
+    this.inboundQueue = opts.inboundQueue;
+    this.canDispatch = opts.canDispatch ?? (() => true);
+    this.log = opts.log;
+  }
+  handleInbound(inbound) {
+    const current = this.registry.getCurrent();
+    if (!current || !this.canDispatch()) {
+      if (!this.inboundQueue) {
+        this.log?.(
+          "debug",
+          `no runtime registered; dropping inbound ${inbound.idempotencyKey}`
+        );
+        return { kind: "dropped", reason: "no_runtime" };
+      }
+      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" };
+    }
+    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
+    };
+  }
+  /**
+   * Drain parked inbound messages and dispatch them in FIFO order. Called by
+   * the session.register handler after a runtime attaches. Safe to call when
+   * no queue is configured (no-op).
+   */
+  drainPending() {
+    if (!this.inboundQueue) return { dispatched: 0, dropped: 0 };
+    const current = this.registry.getCurrent();
+    if (!current || !this.canDispatch()) return { dispatched: 0, dropped: 0 };
+    const parked = this.inboundQueue.drain();
+    let dispatched = 0;
+    let dropped = 0;
+    for (const { inbound } of parked) {
+      const sessionKey = deriveSessionKey(inbound.location);
+      const agentId = this.resolveAgent({
+        sessionKey,
+        channelId: inbound.location.channelId,
+        defaultAgentId: current.defaultAgentId
+      });
+      if (!agentId) {
+        dropped += 1;
+        this.log?.(
+          "warn",
+          `drainPending: no agent for ${sessionKey}; dropping ${inbound.idempotencyKey}`
+        );
+        continue;
+      }
+      const entry = this.registry.beginDispatch({
+        sessionKey,
+        agentId,
+        location: inbound.location
+      });
+      this.pushDispatch({
+        dispatchId: entry.dispatchId,
+        sessionKey,
+        agentId,
+        inbound
+      });
+      dispatched += 1;
+    }
+    if (dispatched > 0 || dropped > 0) {
+      this.log?.(
+        "info",
+        `drainPending: dispatched=${dispatched} dropped=${dropped}`
+      );
+    }
+    return { dispatched, dropped };
+  }
+  async handleTurnComplete(payload) {
+    const current = this.registry.getCurrent();
+    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) {
+        return { delivered: false };
+      }
+      throw err;
+    }
+    const result = await this.sendOutbound(entry.location.channelId, {
+      location: payload.location,
+      text: payload.text,
+      idempotencyKey: payload.idempotencyKey
+    });
+    return {
+      delivered: true,
+      providerMessageId: result.providerMessageId
+    };
+  }
+};
+
+// src/gateway/lock.ts
+import fs2 from "fs";
+import path2 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 = fs2.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) {
+  fs2.mkdirSync(path2.dirname(lockPath), { recursive: true, mode: 448 });
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const fd = fs2.openSync(lockPath, "wx", 384);
+      fs2.writeSync(fd, String(process.pid) + "\n");
+      fs2.closeSync(fd);
+      return {
+        path: lockPath,
+        pid: process.pid,
+        release: () => {
+          try {
+            const pidNow = readPidFile(lockPath);
+            if (pidNow === process.pid) {
+              fs2.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 {
+        fs2.unlinkSync(lockPath);
+      } catch {
+      }
+    }
+  }
+  throw new Error(`failed to acquire gateway lock at ${lockPath}`);
+}
+
+// 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/relay/coordinator.ts
+var DEFAULT_RELAY_TTL_MS = 5 * 6e4;
+var RelayCoordinator = class {
+  adapters;
+  defaultTtlMs;
+  idFactory;
+  log;
+  pending = /* @__PURE__ */ new Map();
+  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 ttlMs = req.ttlMs ?? this.defaultTtlMs;
+    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 existing = this.pending.get(channelRequestId);
+    if (existing) {
+      if (existing.kind !== "permission") {
+        throw new Error(
+          `channel_request_id_collision: ${channelRequestId} is bound to a question relay`
+        );
+      }
+      if (existing.fingerprint !== fingerprint) {
+        throw new Error(
+          `channel_request_id_collision: ${channelRequestId} payload mismatch`
+        );
+      }
+      if (existing.runtimeId !== req.runtimeId) {
+        throw new Error(
+          `channel_request_owner_mismatch: ${channelRequestId} owned by a different runtime`
+        );
+      }
+      return { channelRequestId, result: existing.result };
+    }
+    const controllers = targets.map(() => new AbortController());
+    let resolveFn;
+    const result = new Promise((resolve) => {
+      resolveFn = resolve;
+    });
+    const timer = setTimeout(() => {
+      this.settlePermission(channelRequestId, {
+        kind: "cancelled",
+        reason: "timeout"
+      });
+    }, ttlMs);
+    if (typeof timer.unref === "function") timer.unref();
+    const entry = {
+      kind: "permission",
+      channelRequestId,
+      fingerprint,
+      ...req.runtimeId !== void 0 ? { runtimeId: req.runtimeId } : {},
+      controllers,
+      timer,
+      resolve: resolveFn,
+      result,
+      settled: false
+    };
+    this.pending.set(channelRequestId, entry);
+    const fullReq = {
+      channelRequestId,
+      toolName: req.toolName,
+      description: req.description,
+      inputPreview: req.inputPreview
+    };
+    targets.forEach((adapter, idx) => {
+      const ctrl = controllers[idx];
+      Promise.resolve().then(() => adapter.requestPermissionVerdict(fullReq, ctrl.signal)).then((res) => {
+        if (res.kind === "verdict") {
+          this.settlePermission(channelRequestId, {
+            ...res,
+            channelId: adapter.id
+          });
+        }
+      }).catch((err) => {
+        this.log?.(
+          "warn",
+          `adapter ${adapter.id} permission relay failed: ${err instanceof Error ? err.message : String(err)}`
+        );
+      });
+    });
+    return { channelRequestId, result };
+  }
+  requestQuestion(req) {
+    const channelRequestId = req.channelRequestId ?? this.idFactory();
+    const ttlMs = req.ttlMs ?? this.defaultTtlMs;
+    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 existing = this.pending.get(channelRequestId);
+    if (existing) {
+      if (existing.kind !== "question") {
+        throw new Error(
+          `channel_request_id_collision: ${channelRequestId} is bound to a permission relay`
+        );
+      }
+      if (existing.fingerprint !== fingerprint) {
+        throw new Error(
+          `channel_request_id_collision: ${channelRequestId} payload mismatch`
+        );
+      }
+      if (existing.runtimeId !== req.runtimeId) {
+        throw new Error(
+          `channel_request_owner_mismatch: ${channelRequestId} owned by a different runtime`
+        );
+      }
+      return { channelRequestId, result: existing.result };
+    }
+    const controllers = targets.map(() => new AbortController());
+    let resolveFn;
+    const result = new Promise((resolve) => {
+      resolveFn = resolve;
+    });
+    const timer = setTimeout(() => {
+      this.settleQuestion(channelRequestId, {
+        kind: "cancelled",
+        reason: "timeout"
+      });
+    }, ttlMs);
+    if (typeof timer.unref === "function") timer.unref();
+    const entry = {
+      kind: "question",
+      channelRequestId,
+      fingerprint,
+      ...req.runtimeId !== void 0 ? { runtimeId: req.runtimeId } : {},
+      controllers,
+      timer,
+      resolve: resolveFn,
+      result,
+      settled: false
+    };
+    this.pending.set(channelRequestId, entry);
+    const fullReq = {
+      channelRequestId,
+      title: req.title,
+      questions: req.questions
+    };
+    targets.forEach((adapter, idx) => {
+      const ctrl = controllers[idx];
+      Promise.resolve().then(() => adapter.requestQuestionAnswer(fullReq, ctrl.signal)).then((res) => {
+        if (res.kind === "answer") {
+          this.settleQuestion(channelRequestId, {
+            ...res,
+            channelId: adapter.id
+          });
+        }
+      }).catch((err) => {
+        this.log?.(
+          "warn",
+          `adapter ${adapter.id} question relay failed: ${err instanceof Error ? err.message : String(err)}`
+        );
+      });
+    });
+    return { channelRequestId, result };
+  }
+  cancel(channelRequestId, reason, expectedRuntimeId) {
+    const entry = this.pending.get(channelRequestId);
+    if (!entry) return false;
+    if (expectedRuntimeId !== void 0 && entry.runtimeId !== void 0 && entry.runtimeId !== expectedRuntimeId) {
+      return false;
+    }
+    if (entry.kind === "permission") {
+      this.settlePermission(channelRequestId, { kind: "cancelled", reason });
+    } else {
+      this.settleQuestion(channelRequestId, { kind: "cancelled", reason });
+    }
+    return true;
+  }
+  pendingCount() {
+    return this.pending.size;
+  }
+  disposeAll(reason = "auto_resolved") {
+    for (const id of [...this.pending.keys()]) {
+      this.cancel(id, reason);
+    }
+  }
+  settlePermission(channelRequestId, result) {
+    const entry = this.pending.get(channelRequestId);
+    if (!entry || entry.kind !== "permission" || entry.settled) return;
+    entry.settled = true;
+    this.pending.delete(channelRequestId);
+    clearTimeout(entry.timer);
+    for (const ctrl of entry.controllers) {
+      if (!ctrl.signal.aborted) ctrl.abort();
+    }
+    entry.resolve(result);
+  }
+  settleQuestion(channelRequestId, result) {
+    const entry = this.pending.get(channelRequestId);
+    if (!entry || entry.kind !== "question" || entry.settled) return;
+    entry.settled = true;
+    this.pending.delete(channelRequestId);
+    clearTimeout(entry.timer);
+    for (const ctrl of entry.controllers) {
+      if (!ctrl.signal.aborted) ctrl.abort();
+    }
+    entry.resolve(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 fs3 from "fs";
+import path3 from "path";
+import Database from "better-sqlite3";
+var GATEWAY_STATE_VERSION = 1;
+function openGatewayState(dbPath) {
+  if (dbPath !== ":memory:") {
+    fs3.mkdirSync(path3.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 {
+      fs3.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/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/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);
+  fs4.mkdirSync(paths.runDir, { recursive: true, mode: 448 });
+  fs4.mkdirSync(paths.configDir, { recursive: true, mode: 448 });
+  if (process.platform !== "win32") {
+    try {
+      fs4.chmodSync(paths.runDir, 448);
+      fs4.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 inboundQueue = new InboundQueue(stateDb);
+  const outbox = new Outbox(stateDb);
+  const registry = new SessionRegistry();
+  const channelManager = new ChannelManager();
+  const relayCoordinator = new RelayCoordinator({
+    adapters: () => channelManager.listAdapters()
+  });
+  const runtimeConnections = /* @__PURE__ */ new Map();
+  const staleRuntimeTimers = /* @__PURE__ */ new Map();
+  const connectionOpenedAt = /* @__PURE__ */ new Map();
+  const disconnectGracePeriodMs = opts.disconnectGracePeriodMs ?? 0;
+  let listenerStatus = null;
+  const pushDispatch = (payload) => {
+    const current = registry.getCurrent();
+    if (!current) return;
+    const ctx = runtimeConnections.get(current.runtimeId);
+    if (!ctx) return;
+    ctx.push({
+      push_id: crypto.randomUUID(),
+      ts: Date.now(),
+      kind: "session.dispatch.turn",
+      payload
+    });
+  };
+  const log = (level, message) => {
+    if (opts.silent) return;
+    const stream = level === "error" || level === "warn" ? "stderr" : "stdout";
+    process[stream].write(`athena-gateway: [${level}] ${message}
+`);
+  };
+  const outboundDispatcher = new OutboundDispatcher({
+    outbox,
+    send: (channelId, msg) => channelManager.send(channelId, msg),
+    log
+  });
+  outboundDispatcher.start();
+  const dispatcher = new Dispatcher({
+    registry,
+    pushDispatch,
+    canDispatch: () => {
+      const current = registry.getCurrent();
+      return current ? registry.hasActiveBinding(current.runtimeId) : false;
+    },
+    sendOutbound: async (channelId, msg) => {
+      const result = await outboundDispatcher.dispatch(channelId, msg);
+      if (result.kind === "sent") return result.result;
+      return {
+        providerMessageId: `outbox:${result.outboxId}`,
+        deliveredAt: Date.now()
+      };
+    },
+    inboundQueue,
+    log
+  });
+  channelManager.setInboundSink((inbound) => {
+    dispatcher.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.name));
+    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.name);
+      if (existed) {
+        try {
+          await channelManager.unregister(sidecar.name, "shutdown");
+        } catch (err) {
+          results.push({
+            id: sidecar.name,
+            ok: false,
+            action: "failed",
+            reason: err instanceof Error ? err.message : String(err)
+          });
+          continue;
+        }
+      }
+      const built = instantiateAdapter(sidecar);
+      if (!built.ok) {
+        results.push({
+          id: sidecar.name,
+          ok: false,
+          action: "failed",
+          reason: built.reason
+        });
+        continue;
+      }
+      try {
+        await channelManager.register(built.adapter);
+        results.push({
+          id: sidecar.name,
+          ok: true,
+          action: existed ? "replaced" : "registered"
+        });
+        if (!opts.silent) {
+          process.stdout.write(`athena-gateway: registered ${sidecar.name}
+`);
+        }
+      } catch (err) {
+        results.push({
+          id: sidecar.name,
+          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.name}: ${built.reason}
+`
+        );
+        continue;
+      }
+      try {
+        await channelManager.register(built.adapter);
+        if (!opts.silent) {
+          process.stdout.write(`athena-gateway: registered ${sidecar.name}
+`);
+        }
+      } catch (err) {
+        process.stderr.write(
+          `athena-gateway: register ${sidecar.name} failed: ${err instanceof Error ? err.message : String(err)}
+`
+        );
+      }
+    }
+  }
+  const handler = createDispatcher({
+    startedAt,
+    registry,
+    dispatcher,
+    channelManager,
+    relayCoordinator,
+    getListener: () => listenerStatus ?? buildListenerStatus(listenSpec, null),
+    reloadChannels,
+    registerRuntimeConnection: (runtimeId, ctx) => {
+      const timer = staleRuntimeTimers.get(runtimeId);
+      if (timer) {
+        clearTimeout(timer);
+        staleRuntimeTimers.delete(runtimeId);
+      }
+      const previousBinding = registry.getBinding();
+      const wasStale = previousBinding?.state === "stale";
+      const staleSince = wasStale ? previousBinding.staleSince : null;
+      registry.bindConnection(runtimeId, ctx.connectionId);
+      runtimeConnections.set(runtimeId, ctx);
+      writeGatewayTrace(
+        `daemon registered runtime runtimeId=${runtimeId} connectionId=${ctx.connectionId}`
+      );
+      if (wasStale && staleSince !== null) {
+        const newBinding = registry.getBinding();
+        if (newBinding?.state === "active") {
+          trackGatewayRuntimeRebind({
+            gapMs: Date.now() - staleSince,
+            epoch: newBinding.epoch
+          });
+        }
+      }
+    },
+    unregisterRuntimeConnection: (runtimeId) => {
+      const timer = staleRuntimeTimers.get(runtimeId);
+      if (timer) {
+        clearTimeout(timer);
+        staleRuntimeTimers.delete(runtimeId);
+      }
+      runtimeConnections.delete(runtimeId);
+      writeGatewayTrace(`daemon unregistered runtime runtimeId=${runtimeId}`);
+    }
+  });
+  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
+        });
+        const current = registry.getCurrent();
+        if (current && runtimeConnections.get(current.runtimeId)?.connectionId === ctx.connectionId) {
+          writeGatewayTrace(
+            `daemon runtime connection disconnected runtimeId=${current.runtimeId} connectionId=${ctx.connectionId}`
+          );
+          runtimeConnections.delete(current.runtimeId);
+          const staleAt = Date.now();
+          registry.markConnectionStale(ctx.connectionId);
+          if (disconnectGracePeriodMs <= 0) {
+            try {
+              registry.unregister(current.runtimeId);
+            } catch {
+            }
+            relayCoordinator.disposeAll("connection_lost");
+            return;
+          }
+          const runtimeId = current.runtimeId;
+          const timer = setTimeout(() => {
+            staleRuntimeTimers.delete(runtimeId);
+            const latest = registry.getCurrent();
+            if (latest?.runtimeId === runtimeId && !registry.hasActiveBinding(runtimeId)) {
+              try {
+                registry.unregister(runtimeId);
+              } catch {
+              }
+              relayCoordinator.disposeAll("connection_lost");
+              trackGatewayRuntimeExpired({
+                gapMs: Date.now() - staleAt
+              });
+            }
+          }, disconnectGracePeriodMs);
+          staleRuntimeTimers.set(runtimeId, timer);
+        }
+      }
+    });
+    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 {
+      outboundDispatcher.stop();
+      for (const timer of staleRuntimeTimers.values()) {
+        clearTimeout(timer);
+      }
+      staleRuntimeTimers.clear();
+      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,
+    registry,
+    dispatcher,
+    channelManager,
+    relayCoordinator,
+    inboundQueue,
+    outbox,
+    outboundDispatcher,
+    listener,
+    stop
+  };
+}
+
+// src/gateway/entryArgs.ts
+function parseGatewayDaemonArgs(argv) {
+  const parsed = { silent: false, insecure: false };
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "--silent") {
+      parsed.silent = true;
+      continue;
+    }
+    if (arg === "--insecure") {
+      parsed.insecure = true;
+      continue;
+    }
+    if (arg === "--bind") {
+      parsed.bind = requireValue(argv, i, "--bind");
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith("--bind=")) {
+      parsed.bind = arg.slice("--bind=".length);
+      continue;
+    }
+    if (arg === "--grace-period-ms") {
+      parsed.gracePeriodMs = parseGracePeriod(
+        requireValue(argv, i, "--grace-period-ms")
+      );
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith("--grace-period-ms=")) {
+      parsed.gracePeriodMs = parseGracePeriod(
+        arg.slice("--grace-period-ms=".length)
+      );
+      continue;
+    }
+    const tls = matchPathFlag(arg, argv, i, [
+      ["--tls-cert", "tlsCertPath"],
+      ["--tls-key", "tlsKeyPath"]
+    ]);
+    if (tls) {
+      parsed[tls.key] = tls.value;
+      i += tls.consumed;
+      continue;
+    }
+    throw new Error(`gateway: unknown daemon option ${arg}`);
+  }
+  if (parsed.tlsCertPath && !parsed.tlsKeyPath || !parsed.tlsCertPath && parsed.tlsKeyPath) {
+    throw new Error("gateway: --tls-cert and --tls-key must be used together");
+  }
+  return parsed;
+}
+function matchPathFlag(arg, argv, index, specs) {
+  for (const [flag, key] of specs) {
+    if (arg === flag) {
+      return { key, value: requireValue(argv, index, flag), consumed: 1 };
+    }
+    const prefix = `${flag}=`;
+    if (arg.startsWith(prefix)) {
+      return { key, value: arg.slice(prefix.length), consumed: 0 };
+    }
+  }
+  return null;
+}
+function requireValue(argv, index, flag) {
+  const value = argv[index + 1];
+  if (!value || value.startsWith("--")) {
+    throw new Error(`gateway: ${flag} requires a value`);
+  }
+  return value;
+}
+function parseGracePeriod(value) {
+  const n = Number(value);
+  if (!Number.isInteger(n) || n < 0) {
+    throw new Error(
+      `gateway: --grace-period-ms must be a non-negative integer`
+    );
+  }
+  return n;
+}
+
+// src/gateway/entry.ts
+async function main() {
+  const args = parseGatewayDaemonArgs(process.argv.slice(2));
+  const paths = resolveGatewayPaths();
+  const tls = args.tlsCertPath && args.tlsKeyPath ? { certPath: args.tlsCertPath, keyPath: args.tlsKeyPath } : void 0;
+  const listenSpec = resolveListenSpec({
+    paths,
+    ...args.bind !== void 0 ? { bind: args.bind } : {},
+    insecure: args.insecure,
+    ...tls ? { tls } : {}
+  });
+  await startDaemon({
+    foreground: true,
+    silent: args.silent,
+    paths,
+    listenSpec,
+    disconnectGracePeriodMs: args.gracePeriodMs ?? (listenSpec.kind === "tcp" ? 6e4 : void 0)
+  });
+  setInterval(() => {
+  }, 1 << 30);
+}
+main().catch((err) => {
+  process.stderr.write(
+    `athena-gateway: startup failed: ${err instanceof Error ? err.message : String(err)}
+`
+  );
+  process.exit(1);
+});
+//# sourceMappingURL=athena-gateway.js.map