negotium 0.1.12 → 0.1.13

package/dist/chunk-0eh16bk1.js

@@ -1,2936 +0,0 @@
-// @bun
-import {
-  claimEnrollment,
-  commitEnrollment,
-  isEnrollmentPending,
-  parseEnrollmentInvite,
-  pendingEnrollmentPath,
-  previewEnrollment
-} from "./chunk-r6kdp7gn.js";
-import {
-  configureOtiumCentral,
-  listPeerNodes,
-  mintPeerToken,
-  otiumCentralConfig,
-  resetPeerCentralCaches,
-  resolvePeerNodeByCellId,
-  selfPeerNode,
-  verifyPeerToken
-} from "./chunk-cngrf7ab.js";
-import {
-  assertSecureRelayUrl,
-  isJoinPersisted,
-  joinFilePath,
-  loadJoin,
-  parseInviteCode,
-  saveJoin
-} from "./chunk-xfdkep71.js";
-import {
-  acknowledgePeerTerminal,
-  bindOtiumTopic,
-  claimPeerInboxRequest,
-  claimPeerTurnRequest,
-  cleanupPeerStateForLocalTopic,
-  createPeerSession,
-  createRemoteAsk,
-  deletePeerReplyOutbox,
-  deleteRemoteAsk,
-  failInterruptedPeerTurnRequestsOnStartup,
-  getPeerSession,
-  getPeerTurnRequest,
-  getRemoteAsk,
-  listOtiumTopicBindings,
-  listPeerReplyOutbox,
-  listPeerTerminalOutbox,
-  markPeerTurnRequestFailed,
-  markPeerTurnRequestRunning,
-  peerInboxPayloadHash,
-  pruneRemoteAsks,
-  releasePeerInboxRequest,
-  setOtiumTopicPrivate,
-  shareOtiumTopic,
-  unbindOtiumTopic,
-  upsertPeerReplyOutbox,
-  upsertPeerTerminalOutbox
-} from "./chunk-3gkfr9vb.js";
-import {
-  MAX_PEER_INPUT_FILE_BYTES,
-  MAX_PEER_INPUT_REQUEST_BYTES,
-  MAX_PEER_MESSAGE_LENGTH,
-  PEER_PROTOCOL_VERSION,
-  parseExecutionSpec
-} from "./chunk-c500xe9z.js";
-import {
-  defineNegotiumAdapter
-} from "./chunk-sa874j5c.js";
-import {
-  executeExternalUserTurn,
-  flushSessionInbox
-} from "./chunk-h7bj5zwb.js";
-import {
-  checkAgentAuth
-} from "./chunk-tcs9qjps.js";
-import {
-  sessionInboxPath
-} from "./chunk-7k19pcg8.js";
-import {
-  failInterruptedRemoteAskCallbacks
-} from "./chunk-8dy7e2a9.js";
-import {
-  clearPendingAsk
-} from "./chunk-9hjeemfz.js";
-import {
-  registerPeerSessionBridge
-} from "./chunk-1k7t7bnx.js";
-import {
-  deliverAskCallbackToCaller,
-  registerPeerRuntimeBridge
-} from "./chunk-xhm1rfpt.js";
-import"./chunk-mnwaext5.js";
-import {
-  errorResult,
-  fileHooks,
-  resolveAttachmentByFileId,
-  resolveUploadedFilePathByFileId,
-  setFileHooks
-} from "./chunk-xpcps28p.js";
-import {
-  runtimeBus
-} from "./chunk-fbtb3v0s.js";
-import {
-  clearTopicSessionId,
-  getTopic,
-  getTopicByNameForUser,
-  getTopicSessionId,
-  isTopicShared,
-  isTopicVisible,
-  listTopics,
-  upsertTopic
-} from "./chunk-ejcm6zx8.js";
-import"./chunk-hp4g7wx7.js";
-import {
-  getRegistry
-} from "./chunk-s74rdyqe.js";
-import"./chunk-k778y16p.js";
-import"./chunk-xag86ng3.js";
-import {
-  getApiTopicConfig,
-  setApiTopicConfig
-} from "./chunk-wx83ep8e.js";
-import {
-  NEGOTIUM_VERSION,
-  OPTIONAL_FORUM_MCP_SERVERS,
-  VAULT_DESCRIPTION_MAX_LENGTH,
-  VAULT_VALUE_MAX_BYTES,
-  VAULT_VALUE_MIN_BYTES,
-  normalizeVaultKey,
-  registerPeerSessionBridgeIpcConfig,
-  validateVaultKey,
-  vaultDel,
-  vaultList,
-  vaultSet
-} from "./chunk-00q25k7p.js";
-import"./chunk-gaknyw04.js";
-import {
-  appendJsonlEntry
-} from "./chunk-mh5mexsf.js";
-import {
-  DATA_DIR,
-  MAX_TELL_DEPTH,
-  SUPPORTED_AGENTS,
-  isAgentKind
-} from "./chunk-ezs352qs.js";
-import {
-  registerCanonicalMcpBridgeEnvProvider
-} from "./chunk-j0kjscb7.js";
-import {
-  abortRoom,
-  getRoomQuery
-} from "./chunk-82qhv1mq.js";
-import {
-  logger
-} from "./chunk-ffefbd3r.js";
-import {
-  db
-} from "./chunk-81tbfbmt.js";
-import"./chunk-sffqdkvq.js";
-import"./chunk-f5xgprg1.js";
-import"./chunk-hwy3n31w.js";
-
-// ../../adapters/otium/src/canonical-mcp-bridge.ts
-import { randomUUID } from "crypto";
-var MAX_BODY_BYTES = 1024 * 1024;
-var BODY_READ_TIMEOUT_MS = 1e4;
-var MAX_INFLIGHT = 32;
-var CAPABILITY_TTL_MS = 60 * 60 * 1000;
-var MAX_CAPABILITIES = 2048;
-var FORWARD_TIMEOUT_MS = 25000;
-var TOOL_ALLOWLIST = {
-  task: new Set(["task_create", "task_update", "task_list", "task_get", "task_delete"]),
-  wiki: new Set([
-    "wiki_query",
-    "wiki_topic_brief",
-    "wiki_last_conversation",
-    "save_wiki_entry",
-    "index_upsert"
-  ])
-};
-function readAuthorization(request) {
-  const value = request.headers.get("authorization");
-  return value?.startsWith("Bearer ") ? value.slice(7) : null;
-}
-async function readLimitedJson(request) {
-  const declared = Number(request.headers.get("content-length") ?? "0");
-  if (Number.isFinite(declared) && declared > MAX_BODY_BYTES)
-    return null;
-  const reader = request.body?.getReader();
-  if (!reader)
-    return null;
-  const chunks = [];
-  let size = 0;
-  const deadline = Date.now() + BODY_READ_TIMEOUT_MS;
-  try {
-    while (true) {
-      const remaining = deadline - Date.now();
-      if (remaining <= 0)
-        throw new Error("body read timeout");
-      let timer;
-      const { done, value } = await Promise.race([
-        reader.read(),
-        new Promise((_, reject) => {
-          timer = setTimeout(() => reject(new Error("body read timeout")), remaining);
-        })
-      ]).finally(() => {
-        if (timer)
-          clearTimeout(timer);
-      });
-      if (done)
-        break;
-      size += value.byteLength;
-      if (size > MAX_BODY_BYTES)
-        throw new Error("body too large");
-      chunks.push(value);
-    }
-  } catch {
-    await reader.cancel().catch(() => {
-      return;
-    });
-    return null;
-  }
-  try {
-    const parsed = JSON.parse(Buffer.concat(chunks).toString("utf8"));
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
-      return null;
-    const body = parsed;
-    if (typeof body.tool !== "string" || body.tool.length > 128)
-      return null;
-    if (!body.input || typeof body.input !== "object" || Array.isArray(body.input))
-      return null;
-    return { tool: body.tool, input: body.input };
-  } catch {
-    return null;
-  }
-}
-async function forwardCanonicalTool(capability, request) {
-  if (!TOOL_ALLOWLIST[capability.surface].has(request.tool)) {
-    return { error: `tool is not available on ${capability.surface}`, status: 403 };
-  }
-  const hub = await resolvePeerNodeByCellId(capability.hubCellId).catch(() => null);
-  if (!hub?.isPrimary || hub.self)
-    return { error: "canonical hub is unavailable", status: 503 };
-  try {
-    const peerToken = await mintPeerToken(hub.cellId);
-    const response = await fetch(`${hub.baseUrl.replace(/\/+$/, "")}/api/v1/peer/bridge/canonical-mcp`, {
-      method: "POST",
-      headers: { authorization: `Bearer ${peerToken}`, "content-type": "application/json" },
-      body: JSON.stringify({
-        v: PEER_PROTOCOL_VERSION,
-        surface: capability.surface,
-        userId: capability.userId,
-        hostTopicId: capability.hostTopicId,
-        hostQueryId: capability.hostQueryId,
-        tool: request.tool,
-        input: request.input
-      }),
-      signal: AbortSignal.timeout(FORWARD_TIMEOUT_MS)
-    });
-    const body = await response.json().catch(() => null);
-    if (!response.ok || !body?.ok || !body.result) {
-      return {
-        error: body?.error ?? `canonical hub failed (${response.status})`,
-        status: response.status
-      };
-    }
-    return { result: body.result };
-  } catch (cause) {
-    return { error: cause.message || "canonical hub unreachable", status: 502 };
-  }
-}
-function startCanonicalMcpBridge(options = {}) {
-  const capabilities = new Map;
-  let inflight = 0;
-  function sweep(now = Date.now()) {
-    for (const [token, capability] of capabilities) {
-      if (capability.expiresAt <= now)
-        capabilities.delete(token);
-    }
-    while (capabilities.size >= MAX_CAPABILITIES) {
-      const oldest = capabilities.keys().next().value;
-      if (!oldest)
-        break;
-      capabilities.delete(oldest);
-    }
-  }
-  const server = Bun.serve({
-    hostname: "127.0.0.1",
-    port: 0,
-    async fetch(request) {
-      if (request.method !== "POST")
-        return new Response("method not allowed", { status: 405 });
-      const token = readAuthorization(request);
-      if (!token)
-        return new Response("unauthorized", { status: 401 });
-      const capability = capabilities.get(token);
-      if (!capability || capability.expiresAt <= Date.now()) {
-        capabilities.delete(token);
-        return new Response("unauthorized", { status: 401 });
-      }
-      if (inflight >= MAX_INFLIGHT)
-        return new Response("busy", { status: 503 });
-      inflight += 1;
-      try {
-        const payload = await readLimitedJson(request);
-        if (!payload)
-          return new Response("invalid request", { status: 400 });
-        if (!TOOL_ALLOWLIST[capability.surface].has(payload.tool)) {
-          return new Response("tool denied", { status: 403 });
-        }
-        const result = await (options.forwardTool ?? forwardCanonicalTool)(capability, payload);
-        return Response.json(result, { status: result.status ?? (result.result ? 200 : 502) });
-      } finally {
-        inflight -= 1;
-      }
-    }
-  });
-  const url = `http://127.0.0.1:${server.port}/`;
-  const unregister = registerCanonicalMcpBridgeEnvProvider((scope) => {
-    sweep();
-    const token = `${randomUUID()}${randomUUID()}`;
-    capabilities.set(token, {
-      surface: scope.surface,
-      userId: scope.userId,
-      hostTopicId: scope.peerBridge.hostTopicId,
-      hostQueryId: scope.peerBridge.hostQueryId,
-      hubCellId: scope.peerBridge.hubCellId,
-      expiresAt: Date.now() + CAPABILITY_TTL_MS
-    });
-    return {
-      env: {
-        NEGOTIUM_CANONICAL_MCP_BRIDGE_URL: url,
-        NEGOTIUM_CANONICAL_MCP_BRIDGE_TOKEN: token
-      },
-      revoke: () => {
-        capabilities.delete(token);
-      }
-    };
-  });
-  let stopped = false;
-  return {
-    url,
-    stop() {
-      if (stopped)
-        return;
-      stopped = true;
-      unregister();
-      capabilities.clear();
-      server.stop(true);
-    }
-  };
-}
-
-// ../../adapters/otium/src/event-backflow.ts
-var FORWARDED_TYPES = new Set([
-  "message",
-  "message_updated",
-  "typing",
-  "tool_call",
-  "tool_output",
-  "tool_status",
-  "visual",
-  "file_ready",
-  "ai_done",
-  "ai_error",
-  "ai_aborted"
-]);
-var TERMINAL_TYPES = new Set(["ai_done", "ai_error", "ai_aborted"]);
-var PEER_EVENT_MAX_ATTEMPTS = 5;
-var PEER_EVENT_RETRY_BASE_MS = 100;
-var PEER_EVENT_TIMEOUT_MS = 15000;
-var PEER_EVENT_MAX_PENDING = 256;
-function hubEventSender(hubNode) {
-  return async (payload) => {
-    let token;
-    try {
-      token = await mintPeerToken(hubNode.cellId);
-    } catch (err) {
-      return { ok: false, error: `peer token mint failed: ${err.message}` };
-    }
-    let response;
-    try {
-      response = await fetch(`${hubNode.baseUrl.replace(/\/+$/, "")}/api/v1/peer/event`, {
-        method: "POST",
-        headers: {
-          authorization: `Bearer ${token}`,
-          "content-type": "application/json"
-        },
-        body: JSON.stringify(payload),
-        signal: AbortSignal.timeout(PEER_EVENT_TIMEOUT_MS)
-      });
-    } catch {
-      return { ok: false, error: `hub "${hubNode.nodeName ?? hubNode.cellId}" unreachable` };
-    }
-    const parsed = await response.json().catch(() => null);
-    if (!response.ok || !parsed?.ok) {
-      return {
-        ok: false,
-        error: parsed?.error ?? `peer event rejected (${response.status})`,
-        status: response.status
-      };
-    }
-    return { ok: true };
-  };
-}
-function defined(record) {
-  const out = {};
-  for (const [key, value] of Object.entries(record)) {
-    if (value !== undefined)
-      out[key] = value;
-  }
-  return out;
-}
-function translateBusEvent(event) {
-  const topicId = event.topicId;
-  if (event.type === "message") {
-    return { type: "message", topicId, message: event.payload };
-  }
-  if (event.type === "message-updated") {
-    const payload = event.payload;
-    return defined({
-      type: "message_updated",
-      topicId,
-      messageId: payload.messageId,
-      text: payload.patch.text,
-      deleted: payload.patch.deleted,
-      editedAt: payload.patch.editedAt,
-      usage: payload.patch.usage
-    });
-  }
-  if (event.type !== "ai-status")
-    return null;
-  const status = event.payload;
-  const kind = typeof status.kind === "string" ? status.kind : "";
-  switch (kind) {
-    case "typing":
-      return { type: "typing", topicId, userId: status.userId ?? "" };
-    case "tool_call":
-      return defined({
-        type: "tool_call",
-        topicId,
-        queryId: status.queryId,
-        name: status.name,
-        input: status.input,
-        label: status.label,
-        toolUseId: status.toolUseId
-      });
-    case "tool_output":
-      return defined({
-        type: "tool_output",
-        topicId,
-        queryId: status.queryId,
-        toolUseId: status.toolUseId,
-        content: status.content
-      });
-    case "tool_status":
-      return defined({
-        type: "tool_status",
-        topicId,
-        queryId: status.queryId,
-        kind: status.statusKind,
-        content: status.content,
-        toolName: status.toolName,
-        elapsed: status.elapsed
-      });
-    case "file_ready":
-      return defined({
-        type: "file_ready",
-        topicId,
-        queryId: status.queryId,
-        path: status.path,
-        source: status.source
-      });
-    case "visual":
-      return defined({
-        type: "visual",
-        topicId,
-        queryId: status.queryId,
-        url: status.url,
-        id: status.id,
-        title: status.title,
-        kind: status.visualKind
-      });
-    case "ai_done":
-      return defined({
-        type: "ai_done",
-        topicId,
-        queryId: status.queryId,
-        usage: status.usage,
-        agent: status.agent,
-        model: status.model
-      });
-    case "ai_error":
-      return defined({
-        type: "ai_error",
-        topicId,
-        queryId: status.queryId,
-        error: status.error
-      });
-    case "ai_aborted":
-      return defined({
-        type: "ai_aborted",
-        topicId,
-        queryId: status.queryId,
-        reason: status.reason
-      });
-    default:
-      return null;
-  }
-}
-var activeForwarders = new Map;
-function getActiveForwarder(localTopicId) {
-  return activeForwarders.get(localTopicId);
-}
-function createTurnForwarder(opts) {
-  const { hostNodeId, requestId, localTopicId, sendEvent } = opts;
-  const retryBaseMs = opts.retryBaseMs ?? PEER_EVENT_RETRY_BASE_MS;
-  const maxPendingEvents = Math.max(2, opts.maxPendingEvents ?? PEER_EVENT_MAX_PENDING);
-  const forwarder = {
-    requestId,
-    queryId: null,
-    finished: false,
-    deliveryBlocked: false,
-    pendingEvents: 0,
-    seq: 0,
-    chain: Promise.resolve(),
-    tap: () => {},
-    finish: () => {}
-  };
-  let terminalQueued = false;
-  const detach = () => {
-    forwarder.finished = true;
-    if (activeForwarders.get(localTopicId) === forwarder) {
-      activeForwarders.delete(localTopicId);
-    }
-  };
-  const post = (event) => {
-    const isTerminal = TERMINAL_TYPES.has(String(event.type ?? ""));
-    if (isTerminal)
-      terminalQueued = true;
-    forwarder.seq += 1;
-    const seq = forwarder.seq;
-    forwarder.pendingEvents += 1;
-    forwarder.chain = forwarder.chain.then(async () => {
-      try {
-        if (forwarder.deliveryBlocked)
-          return;
-        if (isTerminal) {
-          upsertPeerTerminalOutbox({ hostNodeId, requestId, seq, event });
-        }
-        for (let attempt = 1;attempt <= PEER_EVENT_MAX_ATTEMPTS; attempt++) {
-          const result = await sendEvent({ v: PEER_PROTOCOL_VERSION, requestId, seq, event });
-          if (result.ok) {
-            if (isTerminal)
-              acknowledgePeerTerminal(hostNodeId, requestId);
-            return;
-          }
-          logger.warn({ requestId, seq, type: event.type, attempt, error: result.error }, "otium: peer event delivery to hub failed");
-          if (attempt < PEER_EVENT_MAX_ATTEMPTS) {
-            const delayMs = retryBaseMs * 2 ** (attempt - 1);
-            await new Promise((resolve) => setTimeout(resolve, delayMs));
-          }
-        }
-        forwarder.deliveryBlocked = true;
-        logger.error({ requestId, seq, type: event.type }, "otium: peer event delivery exhausted");
-      } finally {
-        forwarder.pendingEvents -= 1;
-      }
-    });
-  };
-  forwarder.tap = (raw) => {
-    if (forwarder.finished)
-      return;
-    const type = String(raw.type ?? "");
-    if (!FORWARDED_TYPES.has(type))
-      return;
-    if (type === "message") {
-      const message = raw.message;
-      if (message?.authorId === "ai" && forwarder.queryId && message.queryId !== forwarder.queryId) {
-        return;
-      }
-    } else if (type !== "typing") {
-      const queryId = raw.queryId;
-      if (forwarder.queryId && typeof queryId === "string" && queryId !== forwarder.queryId) {
-        return;
-      }
-    }
-    const isTerminal = TERMINAL_TYPES.has(type);
-    if (!isTerminal && forwarder.pendingEvents >= maxPendingEvents - 1) {
-      if (!terminalQueued) {
-        post({
-          type: "ai_error",
-          topicId: localTopicId,
-          queryId: forwarder.queryId ?? requestId,
-          error: `worker event queue saturated (${maxPendingEvents})`
-        });
-        detach();
-      }
-      return;
-    }
-    post(raw);
-    if (isTerminal)
-      detach();
-  };
-  forwarder.finish = (event) => {
-    if (forwarder.finished)
-      return;
-    post(event);
-    detach();
-  };
-  return forwarder;
-}
-function registerTurnForwarder(localTopicId, forwarder) {
-  activeForwarders.set(localTopicId, forwarder);
-  ensureBackflowSubscription();
-}
-var unsubscribe = null;
-var terminalOutboxTimer = null;
-var terminalOutboxFlushInFlight = false;
-async function flushPeerTerminalOutbox() {
-  if (terminalOutboxFlushInFlight)
-    return 0;
-  terminalOutboxFlushInFlight = true;
-  let acknowledged = 0;
-  try {
-    for (const row of listPeerTerminalOutbox()) {
-      const node = await resolvePeerNodeByCellId(row.host_node_id).catch(() => null);
-      if (!node)
-        continue;
-      let event;
-      try {
-        event = JSON.parse(row.event_json);
-      } catch {
-        continue;
-      }
-      const result = await hubEventSender(node)({
-        v: PEER_PROTOCOL_VERSION,
-        requestId: row.request_id,
-        seq: row.seq,
-        event
-      });
-      if (result.ok && acknowledgePeerTerminal(row.host_node_id, row.request_id))
-        acknowledged += 1;
-    }
-    return acknowledged;
-  } finally {
-    terminalOutboxFlushInFlight = false;
-  }
-}
-function onBusEvent(event) {
-  const forwarder = activeForwarders.get(event.topicId);
-  if (!forwarder)
-    return;
-  const raw = translateBusEvent(event);
-  if (raw)
-    forwarder.tap(raw);
-}
-function ensureBackflowSubscription() {
-  if (!unsubscribe)
-    unsubscribe = runtimeBus().subscribe(onBusEvent);
-}
-function startEventBackflow() {
-  ensureBackflowSubscription();
-  if (!terminalOutboxTimer) {
-    flushPeerTerminalOutbox();
-    terminalOutboxTimer = setInterval(() => void flushPeerTerminalOutbox(), 5000);
-    terminalOutboxTimer.unref?.();
-  }
-  return stopEventBackflow;
-}
-function stopEventBackflow() {
-  unsubscribe?.();
-  unsubscribe = null;
-  if (terminalOutboxTimer)
-    clearInterval(terminalOutboxTimer);
-  terminalOutboxTimer = null;
-  activeForwarders.clear();
-}
-
-// ../../adapters/otium/src/peer-files.ts
-import { randomUUID as randomUUID2 } from "crypto";
-import { copyFileSync, mkdirSync, rmSync, statSync } from "fs";
-import { basename, extname, join } from "path";
-var PEER_FILES_DIR = join(DATA_DIR, "otium-peer-files");
-db.exec(`
-  CREATE TABLE IF NOT EXISTS otium_peer_files (
-    id TEXT PRIMARY KEY,
-    topic_id TEXT,
-    owner_user_id TEXT,
-    filename TEXT NOT NULL,
-    mime_type TEXT NOT NULL,
-    size_bytes INTEGER NOT NULL,
-    path TEXT NOT NULL,
-    created_at TEXT NOT NULL
-  )
-`);
-function fileType(mimeType) {
-  if (mimeType.startsWith("image/"))
-    return "image";
-  if (mimeType.startsWith("audio/"))
-    return "audio";
-  return "file";
-}
-function attachment(row) {
-  return {
-    id: row.id,
-    type: fileType(row.mime_type),
-    filename: row.filename,
-    url: `/api/v1/peer/files/${row.id}`,
-    mimeType: row.mime_type,
-    sizeBytes: row.size_bytes
-  };
-}
-function rowFor(fileId) {
-  return db.query("SELECT * FROM otium_peer_files WHERE id = ?").get(fileId) ?? null;
-}
-function peerFileAllowsAccess(fileId, access) {
-  const row = rowFor(fileId);
-  return row?.topic_id === access.topicId && row.owner_user_id === access.ownerUserId;
-}
-function safeFilename(filename) {
-  const value = basename(filename).replace(/[^A-Za-z0-9._ -]/g, "_").slice(0, 120);
-  return value || "upload";
-}
-function mimeFromPath(path) {
-  const extension = extname(path).toLowerCase();
-  const known = {
-    ".png": "image/png",
-    ".jpg": "image/jpeg",
-    ".jpeg": "image/jpeg",
-    ".gif": "image/gif",
-    ".webp": "image/webp",
-    ".mp4": "video/mp4",
-    ".webm": "video/webm",
-    ".pdf": "application/pdf",
-    ".txt": "text/plain"
-  };
-  return known[extension] ?? "application/octet-stream";
-}
-function recordFile(args) {
-  db.run(`INSERT INTO otium_peer_files
-       (id, topic_id, owner_user_id, filename, mime_type, size_bytes, path, created_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [
-    args.id,
-    args.topicId ?? null,
-    args.ownerUserId ?? null,
-    args.filename,
-    args.mimeType,
-    args.sizeBytes,
-    args.path,
-    new Date().toISOString()
-  ]);
-  return attachment({
-    id: args.id,
-    topic_id: args.topicId ?? null,
-    owner_user_id: args.ownerUserId ?? null,
-    filename: args.filename,
-    mime_type: args.mimeType,
-    size_bytes: args.sizeBytes,
-    path: args.path
-  });
-}
-function insertLocalFile(args) {
-  const id = randomUUID2();
-  mkdirSync(PEER_FILES_DIR, { recursive: true });
-  const path = join(PEER_FILES_DIR, `${id}-${safeFilename(args.filename)}`);
-  copyFileSync(args.sourcePath, path);
-  return recordFile({ id, path, sizeBytes: statSync(path).size, ...args });
-}
-function deletePeerFilesForTopic(topicId) {
-  const rows = db.query("SELECT path FROM otium_peer_files WHERE topic_id = ?").all(topicId);
-  db.run("DELETE FROM otium_peer_files WHERE topic_id = ?", [topicId]);
-  for (const row of rows)
-    rmSync(row.path, { force: true });
-}
-async function storePeerInputFile(file, access) {
-  const id = randomUUID2();
-  mkdirSync(PEER_FILES_DIR, { recursive: true });
-  const filename = file.name || "upload";
-  const path = join(PEER_FILES_DIR, `${id}-${safeFilename(filename)}`);
-  const sizeBytes = await Bun.write(path, file);
-  return recordFile({
-    id,
-    path,
-    sizeBytes,
-    filename,
-    mimeType: file.type || "application/octet-stream",
-    ...access
-  });
-}
-function installPeerFileHooks() {
-  const previous = fileHooks();
-  const hooks = {
-    resolveAttachmentByFileId(fileId) {
-      const row = rowFor(fileId);
-      return row ? attachment(row) : previous.resolveAttachmentByFileId(fileId);
-    },
-    resolveUploadedFilePathByFileId(fileId) {
-      return rowFor(fileId)?.path ?? previous.resolveUploadedFilePathByFileId(fileId);
-    },
-    storeLocalFileAsUpload(path, access) {
-      const existing = previous.storeLocalFileAsUpload(path, access);
-      if (existing)
-        return existing;
-      return insertLocalFile({
-        sourcePath: path,
-        filename: basename(path),
-        mimeType: mimeFromPath(path),
-        topicId: access?.topicId,
-        ownerUserId: access?.ownerUserId
-      });
-    },
-    async deleteFilesForTopic(topicId) {
-      await previous.deleteFilesForTopic?.(topicId);
-      deletePeerFilesForTopic(topicId);
-    }
-  };
-  setFileHooks(hooks);
-  return () => {
-    if (fileHooks() === hooks)
-      setFileHooks(previous);
-  };
-}
-
-// ../../adapters/otium/src/runtime-bridge.ts
-import { randomUUID as randomUUID3 } from "crypto";
-var PEER_BRIDGE_TIMEOUT_MS = 15000;
-function isMcpToolResult(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value))
-    return false;
-  const result = value;
-  return Array.isArray(result.content) && result.content.every((entry) => entry !== null && typeof entry === "object" && entry.type === "text" && typeof entry.text === "string") && (result.isError === undefined || result.isError === true);
-}
-var otiumPeerRuntimeBridge = {
-  async flushEvents(localTopicId) {
-    const forwarder = getActiveForwarder(localTopicId);
-    if (!forwarder)
-      return false;
-    await forwarder.chain;
-    return !forwarder.deliveryBlocked;
-  },
-  async spawnSubagent(request) {
-    const hubNode = await resolvePeerNodeByCellId(request.bridge.hubCellId).catch(() => null);
-    if (!hubNode)
-      return errorResult("Error: Hub node is no longer attached.");
-    let token;
-    try {
-      token = await mintPeerToken(hubNode.cellId);
-    } catch (err) {
-      return errorResult(`Error: Failed to spawn on hub: ${err.message}`);
-    }
-    let response;
-    try {
-      response = await fetch(`${hubNode.baseUrl.replace(/\/+$/, "")}/api/v1/peer/bridge/spawn`, {
-        method: "POST",
-        headers: {
-          authorization: `Bearer ${token}`,
-          "content-type": "application/json"
-        },
-        body: JSON.stringify({
-          hostQueryId: request.bridge.hostQueryId,
-          userId: request.userId,
-          agent: request.agent,
-          ...request.model ? { model: request.model } : {},
-          input: request.input
-        }),
-        signal: AbortSignal.timeout(PEER_BRIDGE_TIMEOUT_MS)
-      });
-    } catch (err) {
-      logger.warn({ err, node: hubNode.nodeName }, "otium: spawn bridge hub unreachable");
-      return errorResult(`Error: Failed to spawn on hub: node "${hubNode.nodeName ?? hubNode.cellId}" unreachable`);
-    }
-    const parsed = await response.json().catch(() => null);
-    if (!response.ok || !parsed?.ok) {
-      return errorResult(`Error: Failed to spawn on hub: ${parsed?.error ?? `peer call failed (${response.status})`}`);
-    }
-    if (!isMcpToolResult(parsed.result)) {
-      return errorResult("Error: Failed to spawn on hub: invalid tool result");
-    }
-    return parsed.result;
-  },
-  async askUser(request) {
-    const hubNode = await resolvePeerNodeByCellId(request.bridge.hubCellId).catch(() => null);
-    if (!hubNode)
-      return errorResult("Error: Hub node is no longer attached.");
-    let token;
-    try {
-      token = await mintPeerToken(hubNode.cellId);
-    } catch (error) {
-      return errorResult(`Error: Failed to open hub question: ${error.message}`);
-    }
-    const bridgeRequestId = `bridge-ask-${randomUUID3()}`;
-    const baseUrl = hubNode.baseUrl.replace(/\/+$/, "");
-    const post = async (path, body) => {
-      const response = await fetch(`${baseUrl}${path}`, {
-        method: "POST",
-        headers: {
-          authorization: `Bearer ${token}`,
-          "content-type": "application/json"
-        },
-        body: JSON.stringify(body),
-        signal: AbortSignal.timeout(PEER_BRIDGE_TIMEOUT_MS)
-      });
-      const parsed = await response.json().catch(() => null);
-      return { response, parsed };
-    };
-    try {
-      const started = await post("/api/v1/peer/bridge/ask/start", {
-        hostQueryId: request.bridge.hostQueryId,
-        bridgeRequestId,
-        userId: request.userId,
-        agent: request.agent,
-        ...request.model ? { model: request.model } : {},
-        input: request.input
-      });
-      if (!started.response.ok || !started.parsed?.ok) {
-        return errorResult(`Error: Failed to open hub question: ${started.parsed?.error ?? `peer call failed (${started.response.status})`}`);
-      }
-      for (;; ) {
-        await Bun.sleep(500);
-        const polled = await post("/api/v1/peer/bridge/ask/result", {
-          hostQueryId: request.bridge.hostQueryId,
-          bridgeRequestId
-        });
-        if (!polled.response.ok || !polled.parsed?.ok) {
-          return errorResult(`Error: Failed to read hub answer: ${polled.parsed?.error ?? `peer call failed (${polled.response.status})`}`);
-        }
-        if (polled.parsed.pending !== false)
-          continue;
-        if (!isMcpToolResult(polled.parsed.result)) {
-          return errorResult("Error: Failed to read hub answer: invalid tool result");
-        }
-        return polled.parsed.result;
-      }
-    } catch (error) {
-      return errorResult(`Error: Hub question bridge failed: ${error.message}`);
-    }
-  },
-  async selfConfig(request) {
-    const hubNode = await resolvePeerNodeByCellId(request.bridge.hubCellId).catch(() => null);
-    if (!hubNode)
-      return errorResult("Error: Hub node is no longer attached.");
-    try {
-      const token = await mintPeerToken(hubNode.cellId);
-      const response = await fetch(`${hubNode.baseUrl.replace(/\/+$/, "")}/api/v1/peer/bridge/self-config`, {
-        method: "POST",
-        headers: {
-          authorization: `Bearer ${token}`,
-          "content-type": "application/json"
-        },
-        body: JSON.stringify({
-          hostQueryId: request.bridge.hostQueryId,
-          userId: request.userId,
-          tool: request.tool,
-          input: request.input,
-          ...request.currentUserPrompt ? { currentUserPrompt: request.currentUserPrompt } : {}
-        }),
-        signal: AbortSignal.timeout(PEER_BRIDGE_TIMEOUT_MS)
-      });
-      const body = await response.json().catch(() => null);
-      if (!response.ok || !body?.ok) {
-        return errorResult(`Error: Failed to update hub topic config: ${body?.error ?? `peer call failed (${response.status})`}`);
-      }
-      return isMcpToolResult(body.result) ? body.result : errorResult("Error: Failed to update hub topic config: invalid tool result");
-    } catch (error) {
-      return errorResult(`Error: Hub self-config bridge failed: ${error.message}`);
-    }
-  },
-  async showVisual(request) {
-    const hubNode = await resolvePeerNodeByCellId(request.bridge.hubCellId).catch(() => null);
-    if (!hubNode)
-      return { ok: false, error: "hub node is no longer attached" };
-    let token;
-    try {
-      token = await mintPeerToken(hubNode.cellId);
-    } catch (error) {
-      return { ok: false, error: `peer token mint failed: ${error.message}` };
-    }
-    let hubFileId = request.fileId;
-    if (request.kind === "image" || request.kind === "video") {
-      const localPath = request.fileId ? resolveUploadedFilePathByFileId(request.fileId) : null;
-      const localAttachment = request.fileId ? resolveAttachmentByFileId(request.fileId) : null;
-      if (!localPath || !localAttachment) {
-        return { ok: false, error: "worker media file is unavailable" };
-      }
-      const form = new FormData;
-      form.set("hostQueryId", request.bridge.hostQueryId);
-      form.set("userId", request.userId);
-      form.set("agent", request.agent);
-      if (request.model)
-        form.set("model", request.model);
-      form.set("announce", "false");
-      form.set("file", Bun.file(localPath, { type: localAttachment.mimeType }), localAttachment.filename);
-      const fileResponse = await fetch(`${hubNode.baseUrl.replace(/\/+$/, "")}/api/v1/peer/bridge/file`, {
-        method: "POST",
-        headers: { authorization: `Bearer ${token}` },
-        body: form,
-        signal: AbortSignal.timeout(PEER_BRIDGE_TIMEOUT_MS)
-      }).catch(() => null);
-      const fileBody = fileResponse ? await fileResponse.json().catch(() => null) : null;
-      if (!fileResponse?.ok || !fileBody?.ok || !fileBody.attachment?.id) {
-        return { ok: false, error: fileBody?.error ?? "hub media upload failed" };
-      }
-      hubFileId = fileBody.attachment.id;
-    }
-    const response = await fetch(`${hubNode.baseUrl.replace(/\/+$/, "")}/api/v1/peer/bridge/visual`, {
-      method: "POST",
-      headers: {
-        authorization: `Bearer ${token}`,
-        "content-type": "application/json"
-      },
-      body: JSON.stringify({
-        hostQueryId: request.bridge.hostQueryId,
-        userId: request.userId,
-        kind: request.kind,
-        ...request.title ? { title: request.title } : {},
-        ...request.html ? { html: request.html } : {},
-        ...request.code ? { code: request.code } : {},
-        ...request.theme ? { theme: request.theme } : {},
-        ...hubFileId ? { fileId: hubFileId } : {},
-        ...request.mimeType ? { mimeType: request.mimeType } : {},
-        ...request.source ? { source: request.source } : {}
-      }),
-      signal: AbortSignal.timeout(PEER_BRIDGE_TIMEOUT_MS)
-    }).catch(() => null);
-    const body = response ? await response.json().catch(() => null) : null;
-    if (!response?.ok || !body?.ok || typeof body.id !== "number" || !body.url) {
-      return { ok: false, error: body?.error ?? "hub visual bridge failed" };
-    }
-    return { ok: true, id: body.id, url: body.url, title: body.title ?? null };
-  },
-  async sendFile(request) {
-    const hubNode = await resolvePeerNodeByCellId(request.bridge.hubCellId).catch(() => null);
-    if (!hubNode)
-      return { ok: false, error: "hub node is no longer attached" };
-    try {
-      const token = await mintPeerToken(hubNode.cellId);
-      const form = new FormData;
-      form.set("hostQueryId", request.bridge.hostQueryId);
-      form.set("userId", request.userId);
-      form.set("agent", request.agent);
-      if (request.model)
-        form.set("model", request.model);
-      form.set("announce", "true");
-      form.set("file", Bun.file(request.path), request.path.split("/").pop() ?? "output");
-      const response = await fetch(`${hubNode.baseUrl.replace(/\/+$/, "")}/api/v1/peer/bridge/file`, {
-        method: "POST",
-        headers: { authorization: `Bearer ${token}` },
-        body: form,
-        signal: AbortSignal.timeout(PEER_BRIDGE_TIMEOUT_MS)
-      });
-      const body = await response.json().catch(() => null);
-      return response.ok && body?.ok ? { ok: true } : { ok: false, error: body?.error ?? `peer call failed (${response.status})` };
-    } catch (error) {
-      return { ok: false, error: error.message };
-    }
-  }
-};
-
-// ../../adapters/otium/src/session-bridge.ts
-var PEER_TIMEOUT_MS = 15000;
-var PENDING_ASK_TTL_MS = 15 * 60 * 1000;
-function prunePendingRemoteAsks(now = Date.now()) {
-  pruneRemoteAsks(now - PENDING_ASK_TTL_MS);
-}
-async function postPeer(node, path, body) {
-  try {
-    const token = await mintPeerToken(node.cellId);
-    const response = await fetch(`${node.baseUrl.replace(/\/+$/, "")}${path}`, {
-      method: "POST",
-      headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
-      body: JSON.stringify(body),
-      signal: AbortSignal.timeout(PEER_TIMEOUT_MS)
-    });
-    const parsed = await response.json().catch(() => null);
-    if (!response.ok || !parsed?.ok) {
-      return {
-        ok: false,
-        error: parsed?.error ?? `peer call failed (${response.status})`,
-        status: response.status,
-        ...response.status >= 500 ? { ambiguous: true } : {}
-      };
-    }
-    return parsed;
-  } catch (error) {
-    return {
-      ok: false,
-      error: error.message || "peer node unreachable",
-      ambiguous: true
-    };
-  }
-}
-async function postPeerIdempotent(node, path, body) {
-  let result = await postPeer(node, path, body);
-  for (const delayMs of [50, 150]) {
-    if (result.ok || !result.ambiguous)
-      return result;
-    await Bun.sleep(delayMs);
-    result = await postPeer(node, path, body);
-  }
-  return result;
-}
-async function peerSupportsRemoteAsk(node) {
-  try {
-    const token = await mintPeerToken(node.cellId);
-    const response = await fetch(`${node.baseUrl.replace(/\/+$/, "")}/api/v1/peer/capabilities`, {
-      headers: { authorization: `Bearer ${token}` },
-      signal: AbortSignal.timeout(PEER_TIMEOUT_MS)
-    });
-    const body = await response.json().catch(() => null);
-    return response.ok && body?.ok === true && body.features?.remoteAsk === true;
-  } catch {
-    return false;
-  }
-}
-async function findNode(nodeName) {
-  const find = (nodes) => nodes.find((node) => node.nodeName === nodeName) ?? null;
-  return find(await listPeerNodes()) ?? find(await listPeerNodes({ fresh: true }));
-}
-async function originLabel(args) {
-  const self = await selfPeerNode();
-  const local = args.fromTitle?.trim() || args.fromKey?.trim() || "peer";
-  return self?.nodeName ? `${self.nodeName}/${local}` : local;
-}
-async function forward(args) {
-  const node = await findNode(args.toNode).catch(() => null);
-  if (!node || node.self)
-    return { ok: false, error: `unknown remote node "${args.toNode}"` };
-  const self = await selfPeerNode().catch(() => null);
-  if (!self)
-    return { ok: false, error: "local peer node is not attached" };
-  if (!self.isPrimary && !node.isPrimary) {
-    return { ok: false, error: "worker peer calls must target the primary hub" };
-  }
-  const fromLabel = await originLabel(args);
-  const requestId = args.requestId;
-  if (args.action === "ask") {
-    if (!requestId || !args.fromTopicId || !args.fromKey || !args.message) {
-      return { ok: false, error: "remote ask is missing caller metadata" };
-    }
-    if (!await peerSupportsRemoteAsk(node)) {
-      return { ok: false, error: `node "${args.toNode}" does not support remote ask` };
-    }
-    prunePendingRemoteAsks();
-    const created = createRemoteAsk({
-      requestId,
-      expectedCellId: node.cellId,
-      userId: args.userId,
-      callerTopicId: args.fromTopicId,
-      from: args.fromKey,
-      to: `${args.toNode}/${args.toTopic}`,
-      ...node.isPrimary && args.sourceQueryId ? { sourceQueryId: args.sourceQueryId } : {}
-    });
-    if (!created) {
-      return { ok: false, error: `remote ask requestId "${requestId}" is already pending` };
-    }
-    const result = await postPeerIdempotent(node, "/api/v1/peer/ask", {
-      v: PEER_PROTOCOL_VERSION,
-      requestId,
-      userId: args.userId,
-      toTopic: args.toTopic,
-      fromLabel,
-      message: args.message,
-      fromDepth: args.fromDepth ?? 0,
-      replyTo: { topicId: args.fromTopicId },
-      ...args.sourceQueryId ? { sourceQueryId: args.sourceQueryId } : {}
-    });
-    if (!result.ok) {
-      if (!result.ambiguous) {
-        deleteRemoteAsk(requestId);
-        return result;
-      }
-      logger.warn({ requestId, node: node.nodeName, error: result.error }, "otium: remote ask acceptance is uncertain; preserving durable reply route");
-      return { ok: true };
-    }
-    return result;
-  }
-  if (args.action === "tell") {
-    if (!requestId || !args.message)
-      return { ok: false, error: "remote tell is incomplete" };
-    const result = await postPeerIdempotent(node, "/api/v1/peer/tell", {
-      v: PEER_PROTOCOL_VERSION,
-      requestId,
-      userId: args.userId,
-      toTopic: args.toTopic,
-      fromLabel,
-      message: args.message,
-      depth: args.depth ?? 0,
-      ...args.sourceQueryId ? { sourceQueryId: args.sourceQueryId } : {}
-    });
-    if (!result.ok && result.ambiguous) {
-      logger.warn({ requestId, node: node.nodeName, error: result.error }, "otium: remote tell delivery is uncertain after idempotent retries");
-      return { ok: true };
-    }
-    return result;
-  }
-  return postPeer(node, "/api/v1/peer/abort", {
-    v: PEER_PROTOCOL_VERSION,
-    userId: args.userId,
-    toTopic: args.toTopic,
-    ...requestId ? { requestId } : {},
-    ...args.sourceQueryId ? { sourceQueryId: args.sourceQueryId } : {}
-  });
-}
-async function sessions(userId, sourceQueryId) {
-  const nodes = await listPeerNodes().catch(() => []);
-  const self = nodes.find((node) => node.self);
-  if (!self)
-    return { ok: false, nodes: [] };
-  return {
-    ok: true,
-    nodes: await Promise.all(nodes.filter((node) => !node.self && node.nodeName && (self.isPrimary || node.isPrimary)).map(async (node) => {
-      const result = await postPeer(node, "/api/v1/peer/sessions", {
-        v: PEER_PROTOCOL_VERSION,
-        userId,
-        ...sourceQueryId ? { sourceQueryId } : {}
-      });
-      return result.ok ? { node: node.nodeName, sessions: result.sessions } : { node: node.nodeName, error: result.error };
-    }))
-  };
-}
-async function reply(route, sourceTitle, replyText, kind) {
-  upsertPeerReplyOutbox({
-    nodeCellId: route.nodeCellId,
-    requestId: route.requestId,
-    nodeName: route.nodeName,
-    topicId: route.topicId,
-    userId: route.userId,
-    sourceTitle,
-    replyText,
-    kind
-  });
-  await flushPeerReplyOutbox();
-  return true;
-}
-var peerReplyFlush = null;
-function flushPeerReplyOutbox() {
-  if (peerReplyFlush)
-    return peerReplyFlush;
-  peerReplyFlush = (async () => {
-    for (const pending of listPeerReplyOutbox()) {
-      const node = await resolvePeerNodeByCellId(pending.node_cell_id).catch(() => null);
-      if (!node)
-        continue;
-      const fromLabel = await originLabel({
-        action: "ask",
-        toNode: pending.node_name,
-        toTopic: "",
-        userId: pending.user_id,
-        fromTitle: pending.source_title
-      });
-      const result = await postPeer(node, "/api/v1/peer/reply", {
-        v: PEER_PROTOCOL_VERSION,
-        requestId: pending.request_id,
-        userId: pending.user_id,
-        kind: pending.kind,
-        replyText: pending.reply_text,
-        fromLabel
-      });
-      if (result.ok || !result.ambiguous) {
-        deletePeerReplyOutbox(pending.node_cell_id, pending.request_id);
-        if (!result.ok && result.status !== 404) {
-          logger.warn({ requestId: pending.request_id, status: result.status, error: result.error }, "otium: dropping definitively rejected peer reply");
-        }
-        continue;
-      }
-      logger.warn({ requestId: pending.request_id, error: result.error }, "otium: peer reply delivery failed; retained for retry");
-    }
-  })().finally(() => {
-    peerReplyFlush = null;
-  });
-  return peerReplyFlush;
-}
-function startPeerReplyOutboxWorker() {
-  flushPeerReplyOutbox();
-  const timer = setInterval(() => void flushPeerReplyOutbox(), 5000);
-  timer.unref?.();
-  return () => clearInterval(timer);
-}
-async function acceptRemoteAskReplyResult(args) {
-  prunePendingRemoteAsks();
-  const pending = getRemoteAsk(args.requestId);
-  if (!pending || pending.expected_cell_id !== args.fromCellId || pending.user_id !== args.userId) {
-    return "missing";
-  }
-  if (pending.source_query_id) {
-    const node = await resolvePeerNodeByCellId(pending.expected_cell_id).catch(() => null);
-    if (!node?.isPrimary)
-      return "missing";
-    const delivered2 = await postPeer(node, "/api/v1/peer/ask-callback", {
-      v: PEER_PROTOCOL_VERSION,
-      requestId: args.requestId,
-      sourceQueryId: pending.source_query_id,
-      userId: pending.user_id,
-      fromLabel: args.fromLabel,
-      replyText: args.replyText,
-      kind: args.kind
-    });
-    if (!delivered2.ok) {
-      logger.warn({ requestId: args.requestId, error: delivered2.error }, "otium: canonical remote ask callback failed");
-      return delivered2.ambiguous ? "retry" : "missing";
-    }
-    deleteRemoteAsk(args.requestId);
-    clearPendingAsk({
-      userId: pending.user_id,
-      from: pending.from_key,
-      to: pending.to_key,
-      requestId: args.requestId
-    });
-    return "accepted";
-  }
-  const delivered = await deliverAskCallbackToCaller({
-    requestId: args.requestId,
-    callerTopicId: pending.caller_topic_id,
-    callerUserId: pending.user_id,
-    pendingAsk: {
-      userId: pending.user_id,
-      from: pending.from_key,
-      to: pending.to_key,
-      requestId: args.requestId
-    }
-  }, args.fromLabel, args.replyText, args.kind);
-  if (!delivered)
-    return "missing";
-  deleteRemoteAsk(args.requestId);
-  return "accepted";
-}
-var otiumPeerSessionBridge = { forward, sessions, reply };
-
-// ../../adapters/otium/src/session-bridge-ipc.ts
-import { timingSafeEqual } from "crypto";
-var MAX_BODY_BYTES2 = 1024 * 1024;
-var MAX_INFLIGHT2 = 32;
-var BODY_TIMEOUT_MS = 1e4;
-function authorized(request, token) {
-  const supplied = request.headers.get("authorization")?.replace(/^Bearer\s+/i, "") ?? "";
-  const expectedBytes = Buffer.from(token);
-  const suppliedBytes = Buffer.from(supplied);
-  return expectedBytes.length === suppliedBytes.length && timingSafeEqual(expectedBytes, suppliedBytes);
-}
-function boundedString(value, max = 16384) {
-  return typeof value === "string" && value.length > 0 && value.length <= max;
-}
-function validRequest(payload) {
-  if (!payload || typeof payload !== "object" || !boundedString(payload.action, 16))
-    return false;
-  if (payload.action === "sessions")
-    return boundedString(payload.userId, 512);
-  if (payload.action === "forward") {
-    const args = payload.args;
-    return Boolean(args) && ["tell", "ask", "abort"].includes(args.action) && boundedString(args.toNode, 512) && boundedString(args.toTopic, 512) && boundedString(args.userId, 512) && (args.message === undefined || boundedString(args.message, 256 * 1024));
-  }
-  if (payload.action === "reply") {
-    return Boolean(payload.route) && boundedString(payload.route.userId, 512) && boundedString(payload.route.requestId, 512) && boundedString(payload.sourceTitle, 2048) && boundedString(payload.replyText, 256 * 1024) && ["reply", "error"].includes(payload.kind);
-  }
-  return false;
-}
-async function readLimitedJson2(request) {
-  const declaredLength = Number(request.headers.get("content-length") ?? "0");
-  if (Number.isFinite(declaredLength) && declaredLength > MAX_BODY_BYTES2)
-    return null;
-  const reader = request.body?.getReader();
-  if (!reader)
-    return null;
-  const chunks = [];
-  let size = 0;
-  const timeout = setTimeout(() => void reader.cancel("peer bridge request body timeout").catch(() => {
-    return;
-  }), BODY_TIMEOUT_MS);
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done)
-        break;
-      size += value.byteLength;
-      if (size > MAX_BODY_BYTES2) {
-        await reader.cancel();
-        return null;
-      }
-      chunks.push(value);
-    }
-  } catch {
-    return null;
-  } finally {
-    clearTimeout(timeout);
-  }
-  try {
-    return JSON.parse(Buffer.concat(chunks).toString("utf8"));
-  } catch {
-    return null;
-  }
-}
-function startPeerSessionBridgeIpc(bridge) {
-  const token = crypto.randomUUID() + crypto.randomUUID();
-  let inflight = 0;
-  const server = Bun.serve({
-    hostname: "127.0.0.1",
-    port: 0,
-    async fetch(request) {
-      if (request.method !== "POST")
-        return new Response("method not allowed", { status: 405 });
-      if (!authorized(request, token))
-        return new Response("unauthorized", { status: 401 });
-      if (inflight >= MAX_INFLIGHT2)
-        return new Response("busy", { status: 503 });
-      inflight += 1;
-      try {
-        const payload = await readLimitedJson2(request);
-        if (!payload || !validRequest(payload)) {
-          return new Response("invalid request", { status: 400 });
-        }
-        if (payload.action === "forward") {
-          return Response.json(await bridge.forward(payload.args));
-        }
-        if (payload.action === "sessions") {
-          return Response.json(await bridge.sessions(payload.userId, payload.sourceQueryId));
-        }
-        if (payload.action === "reply") {
-          return Response.json(await bridge.reply(payload.route, payload.sourceTitle, payload.replyText, payload.kind));
-        }
-        return new Response("invalid action", { status: 400 });
-      } catch {
-        return new Response("bridge failed", { status: 502 });
-      } finally {
-        inflight -= 1;
-      }
-    }
-  });
-  const url = `http://127.0.0.1:${server.port}/`;
-  const unregisterConfig = registerPeerSessionBridgeIpcConfig({ url, token });
-  let stopped = false;
-  return {
-    url,
-    stop() {
-      if (stopped)
-        return;
-      stopped = true;
-      unregisterConfig();
-      server.stop(true);
-    }
-  };
-}
-
-// ../../adapters/otium/src/relay-protocol.ts
-var PROTOCOL_VERSION = 2;
-function encodeFrame(frame) {
-  const encoded = JSON.stringify(frame);
-  if (encoded.length > MAX_FRAME_CHARS || !decodeNodeFrame(encoded) && !decodeRelayFrame(encoded)) {
-    throw new TypeError("relay frame exceeds protocol limits or is invalid");
-  }
-  return encoded;
-}
-var HEADER_NAME = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
-var BASE64 = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
-var MAX_FRAME_CHARS = 512 * 1024;
-var MAX_CHUNK_BYTES = 256 * 1024;
-var MAX_ENCODED_CHUNK_CHARS = Math.ceil(MAX_CHUNK_BYTES / 3) * 4;
-var MAX_HEADER_PAIRS = 128;
-var MAX_HEADER_BYTES = 64 * 1024;
-var MAX_ID_BYTES = 256;
-var MAX_PATH_BYTES = 16 * 1024;
-var MAX_MESSAGE_BYTES = 4 * 1024;
-var MAX_REASON_BYTES = 123;
-var MAX_METHOD_BYTES = 32;
-var MAX_NODE_ID_BYTES = 256;
-var MAX_NODE_VERSION_BYTES = 256;
-function isRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function isString(value) {
-  return typeof value === "string";
-}
-function hasMaxBytes(value, maxBytes) {
-  return value.length <= maxBytes && Buffer.byteLength(value, "utf8") <= maxBytes;
-}
-function isBoundedString(value, maxBytes) {
-  return isString(value) && hasMaxBytes(value, maxBytes);
-}
-function isNonEmptyBoundedString(value, maxBytes) {
-  return isBoundedString(value, maxBytes) && value.length > 0;
-}
-function isOptionalBoundedString(value, maxBytes) {
-  return value === undefined || isBoundedString(value, maxBytes);
-}
-function isFiniteNumber(value) {
-  return typeof value === "number" && Number.isFinite(value);
-}
-function isInteger(value) {
-  return isFiniteNumber(value) && Number.isInteger(value);
-}
-function isHeaders(value) {
-  if (!Array.isArray(value) || value.length > MAX_HEADER_PAIRS)
-    return false;
-  let totalBytes = 0;
-  for (const pair of value) {
-    if (!Array.isArray(pair) || pair.length !== 2 || !isString(pair[0]) || !HEADER_NAME.test(pair[0]) || !isString(pair[1]) || /[\0\r\n]/.test(pair[1])) {
-      return false;
-    }
-    totalBytes += Buffer.byteLength(pair[0]) + Buffer.byteLength(pair[1]);
-    if (totalBytes > MAX_HEADER_BYTES)
-      return false;
-  }
-  return true;
-}
-function isBase64(value) {
-  if (!isString(value) || value.length > MAX_ENCODED_CHUNK_CHARS || value.length % 4 !== 0 || !BASE64.test(value))
-    return false;
-  const padding = value.endsWith("==") ? 2 : value.endsWith("=") ? 1 : 0;
-  return value.length / 4 * 3 - padding <= MAX_CHUNK_BYTES;
-}
-function isWsData(frame) {
-  return isBoundedString(frame.text, MAX_CHUNK_BYTES) && frame.dataB64 === undefined || frame.text === undefined && isBase64(frame.dataB64);
-}
-function isWsClose(frame) {
-  return isNonEmptyBoundedString(frame.id, MAX_ID_BYTES) && (frame.code === undefined || isInteger(frame.code) && frame.code >= 0 && frame.code <= 65535) && isOptionalBoundedString(frame.reason, MAX_REASON_BYTES);
-}
-function decodeFrame(raw) {
-  if (typeof raw !== "string" || raw.length > MAX_FRAME_CHARS)
-    return null;
-  try {
-    const parsed = JSON.parse(raw);
-    if (isRecord(parsed) && typeof parsed.type === "string")
-      return parsed;
-    return null;
-  } catch {
-    return null;
-  }
-}
-function decodeNodeFrame(raw) {
-  const frame = decodeFrame(raw);
-  if (!frame)
-    return null;
-  switch (frame.type) {
-    case "register":
-      return isInteger(frame.protocolVersion) && frame.protocolVersion > 0 && isOptionalBoundedString(frame.nodeVersion, MAX_NODE_VERSION_BYTES) ? frame : null;
-    case "pong":
-      return isFiniteNumber(frame.ts) && frame.ts >= 0 ? frame : null;
-    case "http_res_head":
-      return isNonEmptyBoundedString(frame.id, MAX_ID_BYTES) && isInteger(frame.status) && frame.status >= 200 && frame.status <= 599 && isHeaders(frame.headers) ? frame : null;
-    case "http_res_chunk":
-      return isNonEmptyBoundedString(frame.id, MAX_ID_BYTES) && isBase64(frame.dataB64) ? frame : null;
-    case "http_res_end":
-    case "ws_open_ok":
-      return isNonEmptyBoundedString(frame.id, MAX_ID_BYTES) ? frame : null;
-    case "http_res_error":
-    case "ws_open_error":
-      return isNonEmptyBoundedString(frame.id, MAX_ID_BYTES) && isBoundedString(frame.message, MAX_MESSAGE_BYTES) ? frame : null;
-    case "ws_data":
-      return isNonEmptyBoundedString(frame.id, MAX_ID_BYTES) && isWsData(frame) ? frame : null;
-    case "ws_close":
-      return isWsClose(frame) ? frame : null;
-    default:
-      return null;
-  }
-}
-function decodeRelayFrame(raw) {
-  const frame = decodeFrame(raw);
-  if (!frame)
-    return null;
-  switch (frame.type) {
-    case "registered":
-      return isNonEmptyBoundedString(frame.nodeId, MAX_NODE_ID_BYTES) && isInteger(frame.protocolVersion) && frame.protocolVersion > 0 && isInteger(frame.pingIntervalMs) && frame.pingIntervalMs > 0 ? frame : null;
-    case "register_error":
-      return (frame.code === "upgrade_required" || frame.code === "unauthorized" || frame.code === "replaced") && isBoundedString(frame.message, MAX_MESSAGE_BYTES) ? frame : null;
-    case "ping":
-      return isFiniteNumber(frame.ts) && frame.ts >= 0 ? frame : null;
-    case "http_req_head":
-      return isNonEmptyBoundedString(frame.id, MAX_ID_BYTES) && isNonEmptyBoundedString(frame.method, MAX_METHOD_BYTES) && isBoundedString(frame.path, MAX_PATH_BYTES) && frame.path.startsWith("/") && isHeaders(frame.headers) && typeof frame.hasBody === "boolean" ? frame : null;
-    case "http_req_chunk":
-      return isNonEmptyBoundedString(frame.id, MAX_ID_BYTES) && isBase64(frame.dataB64) ? frame : null;
-    case "http_req_end":
-    case "http_req_abort":
-      return isNonEmptyBoundedString(frame.id, MAX_ID_BYTES) ? frame : null;
-    case "ws_open":
-      return isNonEmptyBoundedString(frame.id, MAX_ID_BYTES) && isBoundedString(frame.path, MAX_PATH_BYTES) && frame.path.startsWith("/") && isHeaders(frame.headers) ? frame : null;
-    case "ws_data":
-      return isNonEmptyBoundedString(frame.id, MAX_ID_BYTES) && isWsData(frame) ? frame : null;
-    case "ws_close":
-      return isWsClose(frame) ? frame : null;
-    default:
-      return null;
-  }
-}
-function toB64(bytes) {
-  if (bytes.byteLength > MAX_CHUNK_BYTES) {
-    throw new RangeError(`relay chunk exceeds ${MAX_CHUNK_BYTES} bytes`);
-  }
-  return Buffer.from(bytes).toString("base64");
-}
-function fromB64(dataB64) {
-  if (!isBase64(dataB64)) {
-    throw new RangeError(`invalid relay chunk or chunk exceeds ${MAX_CHUNK_BYTES} bytes`);
-  }
-  return new Uint8Array(Buffer.from(dataB64, "base64"));
-}
-function* chunkBytes(bytes) {
-  for (let offset = 0;offset < bytes.length; offset += MAX_CHUNK_BYTES) {
-    yield bytes.subarray(offset, offset + MAX_CHUNK_BYTES);
-  }
-}
-function sanitizeCloseCode(code) {
-  if (code === undefined)
-    return;
-  if (code === 1000 || code >= 3000 && code <= 4999)
-    return code;
-  return 1000;
-}
-var DROPPED_HEADERS = new Set([
-  "connection",
-  "keep-alive",
-  "proxy-authenticate",
-  "proxy-authorization",
-  "proxy-connection",
-  "te",
-  "trailer",
-  "transfer-encoding",
-  "upgrade",
-  "host",
-  "accept-encoding",
-  "content-length",
-  "content-encoding"
-]);
-
-// ../../adapters/otium/src/tunnel-client.ts
-var MAX_WS_UPGRADE_HEADER_BYTES = 32 * 1024;
-var WS_PROTOCOL_TOKEN = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
-function localWebSocketOptions(headers) {
-  const forwarded = {};
-  let totalBytes = 0;
-  for (const pair of headers) {
-    if (!Array.isArray(pair) || pair.length !== 2)
-      return null;
-    const [rawName, value] = pair;
-    if (typeof rawName !== "string" || typeof value !== "string" || /[\0\r\n]/.test(value)) {
-      return null;
-    }
-    const name = rawName.toLowerCase();
-    if (name !== "cookie" && name !== "authorization" && name !== "sec-websocket-protocol") {
-      return null;
-    }
-    totalBytes += Buffer.byteLength(name) + Buffer.byteLength(value);
-    if (totalBytes > MAX_WS_UPGRADE_HEADER_BYTES || name in forwarded) {
-      return null;
-    }
-    if (name === "sec-websocket-protocol") {
-      if (!WS_PROTOCOL_TOKEN.test(value))
-        return null;
-    }
-    forwarded[name] = value;
-  }
-  return { headers: forwarded };
-}
-var DEFAULT_MIN_RECONNECT_MS = 1000;
-var DEFAULT_MAX_RECONNECT_MS = 30000;
-var RECONNECT_JITTER_RATIO = 0.2;
-var LIVENESS_INTERVALS = 3;
-var noop = () => {};
-var silentLogger = { info: noop, warn: noop, error: noop };
-
-class TunnelClient {
-  opts;
-  log;
-  ws = null;
-  connectionGeneration = 0;
-  statusValue = "idle";
-  reconnectDelayMs;
-  reconnectTimer = null;
-  livenessTimer = null;
-  pingIntervalMs = 30000;
-  pendingHttp = new Map;
-  bridgedSockets = new Map;
-  constructor(options) {
-    assertSecureRelayUrl(options.relayUrl);
-    this.opts = options;
-    this.log = options.logger ?? silentLogger;
-    this.reconnectDelayMs = options.minReconnectDelayMs ?? DEFAULT_MIN_RECONNECT_MS;
-  }
-  get status() {
-    return this.statusValue;
-  }
-  start() {
-    if (this.statusValue !== "idle" && this.statusValue !== "stopped")
-      return;
-    this.connect();
-  }
-  stop() {
-    this.statusValue = "stopped";
-    if (this.reconnectTimer)
-      clearTimeout(this.reconnectTimer);
-    this.reconnectTimer = null;
-    this.clearLiveness();
-    this.cleanupInFlight();
-    const ws = this.ws;
-    this.ws = null;
-    this.connectionGeneration += 1;
-    ws?.close(1000, "tunnel stopped");
-  }
-  tunnelUrl() {
-    const base = this.opts.relayUrl.replace(/\/+$/, "").replace(/^http/, "ws");
-    return `${base}/tunnel`;
-  }
-  connect() {
-    this.statusValue = "connecting";
-    const WS = WebSocket;
-    const options = { headers: { authorization: `Bearer ${this.opts.token}` } };
-    const ws = this.opts.webSocketFactory ? this.opts.webSocketFactory(this.tunnelUrl(), options) : new WS(this.tunnelUrl(), options);
-    const generation = ++this.connectionGeneration;
-    this.ws = ws;
-    ws.onopen = () => {
-      if (!this.isActiveConnection(ws, generation))
-        return;
-      this.send({
-        type: "register",
-        protocolVersion: PROTOCOL_VERSION,
-        nodeVersion: this.opts.nodeVersion
-      });
-      this.resetLiveness();
-    };
-    ws.onmessage = (event) => {
-      if (!this.isActiveConnection(ws, generation))
-        return;
-      try {
-        const frame = decodeRelayFrame(event.data);
-        if (!frame) {
-          this.rejectProtocolFrame(ws, generation, "invalid relay frame");
-          return;
-        }
-        this.resetLiveness(ws, generation);
-        this.handleFrame(frame);
-      } catch (err) {
-        this.log.error({ error: err instanceof Error ? err.message : String(err) }, "relay frame dispatch failed");
-        this.rejectProtocolFrame(ws, generation, "relay frame dispatch failed");
-      }
-    };
-    ws.onclose = (event) => {
-      this.disconnectActiveConnection(ws, generation, {
-        code: event.code,
-        reason: event.reason
-      });
-    };
-    ws.onerror = () => {};
-  }
-  isActiveConnection(ws, generation) {
-    return this.ws === ws && this.connectionGeneration === generation;
-  }
-  rejectProtocolFrame(ws, generation, reason) {
-    this.log.warn({ reason }, "closing relay tunnel after protocol error");
-    this.disconnectActiveConnection(ws, generation, { reason });
-    try {
-      ws.close(1002, reason);
-    } catch {}
-  }
-  disconnectActiveConnection(ws, generation, details, close = false) {
-    if (!this.isActiveConnection(ws, generation))
-      return;
-    this.ws = null;
-    this.connectionGeneration += 1;
-    this.clearLiveness();
-    this.cleanupInFlight();
-    if (this.statusValue !== "stopped" && this.statusValue !== "unsupported" && this.statusValue !== "superseded") {
-      this.statusValue = "connecting";
-      this.log.warn(details, "relay tunnel disconnected");
-      this.scheduleReconnect();
-    }
-    if (close) {
-      try {
-        ws.close();
-      } catch {}
-    }
-  }
-  scheduleReconnect() {
-    if (this.reconnectTimer)
-      return;
-    const jitter = 1 + (Math.random() * 2 - 1) * RECONNECT_JITTER_RATIO;
-    const delay = Math.max(1, Math.round(this.reconnectDelayMs * jitter));
-    this.reconnectDelayMs = Math.min(this.reconnectDelayMs * 2, this.opts.maxReconnectDelayMs ?? DEFAULT_MAX_RECONNECT_MS);
-    this.reconnectTimer = setTimeout(() => {
-      this.reconnectTimer = null;
-      if (this.statusValue === "stopped" || this.statusValue === "unsupported" || this.statusValue === "superseded")
-        return;
-      this.connect();
-    }, delay);
-  }
-  resetLiveness(ws = this.ws, generation = this.connectionGeneration) {
-    this.clearLiveness();
-    if (!ws)
-      return;
-    this.livenessTimer = setTimeout(() => {
-      this.log.warn({}, "relay tunnel silent past liveness window \u2014 reconnecting");
-      this.disconnectActiveConnection(ws, generation, { reason: "liveness timeout" }, true);
-    }, this.pingIntervalMs * LIVENESS_INTERVALS);
-  }
-  clearLiveness() {
-    if (this.livenessTimer)
-      clearTimeout(this.livenessTimer);
-    this.livenessTimer = null;
-  }
-  cleanupInFlight() {
-    for (const pending of this.pendingHttp.values()) {
-      pending.abort.abort();
-      try {
-        pending.bodyController?.error(new Error("relay tunnel disconnected"));
-      } catch {}
-    }
-    this.pendingHttp.clear();
-    for (const bridged of this.bridgedSockets.values()) {
-      try {
-        bridged.ws.close(1000, "relay tunnel disconnected");
-      } catch {}
-    }
-    this.bridgedSockets.clear();
-  }
-  send(frame) {
-    if (this.ws?.readyState === WebSocket.OPEN)
-      this.ws.send(encodeFrame(frame));
-  }
-  handleFrame(frame) {
-    switch (frame.type) {
-      case "registered":
-        this.statusValue = "registered";
-        this.pingIntervalMs = frame.pingIntervalMs;
-        this.reconnectDelayMs = this.opts.minReconnectDelayMs ?? DEFAULT_MIN_RECONNECT_MS;
-        this.resetLiveness(this.ws, this.connectionGeneration);
-        this.log.info({ nodeId: frame.nodeId }, "relay tunnel registered");
-        break;
-      case "register_error":
-        if (frame.code === "upgrade_required") {
-          this.statusValue = "unsupported";
-          this.log.error({ message: frame.message }, "relay rejected protocol version \u2014 update this node");
-        } else if (frame.code === "unauthorized") {
-          this.reconnectDelayMs = this.opts.maxReconnectDelayMs ?? DEFAULT_MAX_RECONNECT_MS;
-          this.log.error({ message: frame.message }, "relay rejected node credentials");
-        } else {
-          this.statusValue = "superseded";
-          this.log.info({ message: frame.message }, "relay tunnel superseded by newer connection");
-          const ws = this.ws;
-          if (ws) {
-            this.disconnectActiveConnection(ws, this.connectionGeneration, { reason: "tunnel superseded" }, true);
-          }
-        }
-        break;
-      case "ping":
-        this.send({ type: "pong", ts: frame.ts });
-        break;
-      case "http_req_head":
-        this.startHttpRequest(frame);
-        break;
-      case "http_req_chunk": {
-        const pending = this.pendingHttp.get(frame.id);
-        try {
-          pending?.bodyController?.enqueue(fromB64(frame.dataB64));
-        } catch {}
-        break;
-      }
-      case "http_req_end": {
-        const pending = this.pendingHttp.get(frame.id);
-        try {
-          pending?.bodyController?.close();
-        } catch {}
-        break;
-      }
-      case "http_req_abort": {
-        const pending = this.pendingHttp.get(frame.id);
-        if (pending) {
-          this.pendingHttp.delete(frame.id);
-          pending.abort.abort();
-          try {
-            pending.bodyController?.error(new Error("aborted by relay"));
-          } catch {}
-        }
-        break;
-      }
-      case "ws_open":
-        this.openBridgedSocket(frame.id, frame.path, frame.headers);
-        break;
-      case "ws_data": {
-        const bridged = this.bridgedSockets.get(frame.id);
-        if (!bridged)
-          break;
-        if (!bridged.opened) {
-          bridged.buffer.push(frame);
-          break;
-        }
-        this.deliverToLocal(bridged.ws, frame);
-        break;
-      }
-      case "ws_close": {
-        const bridged = this.bridgedSockets.get(frame.id);
-        if (!bridged)
-          break;
-        this.bridgedSockets.delete(frame.id);
-        try {
-          bridged.ws.close(sanitizeCloseCode(frame.code), frame.reason);
-        } catch {}
-        break;
-      }
-    }
-  }
-  startHttpRequest(frame) {
-    const abort = new AbortController;
-    const pending = { abort, bodyController: null };
-    this.pendingHttp.set(frame.id, pending);
-    let body;
-    if (frame.hasBody) {
-      body = new ReadableStream({
-        start: (controller) => {
-          pending.bodyController = controller;
-        }
-      });
-    }
-    const headers = new Headers;
-    for (const [name, value] of frame.headers)
-      headers.append(name, value);
-    this.replayHttp(frame.id, frame.method, frame.path, headers, body, abort).finally(() => {
-      this.pendingHttp.delete(frame.id);
-    });
-  }
-  async replayHttp(id, method, path, headers, body, abort) {
-    try {
-      const res = await fetch(`${this.opts.targetOrigin}${path}`, {
-        method,
-        headers,
-        body,
-        signal: abort.signal,
-        redirect: "manual"
-      });
-      const pairs = [];
-      res.headers.forEach((value, name) => {
-        const lower = name.toLowerCase();
-        if (lower === "content-encoding" || lower === "content-length" || lower === "transfer-encoding" || lower === "date")
-          return;
-        pairs.push([name, value]);
-      });
-      this.send({ type: "http_res_head", id, status: res.status, headers: pairs });
-      if (res.body) {
-        const reader = res.body.getReader();
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done)
-            break;
-          for (const chunk of chunkBytes(value)) {
-            this.send({ type: "http_res_chunk", id, dataB64: toB64(chunk) });
-          }
-        }
-      }
-      this.send({ type: "http_res_end", id });
-    } catch (err) {
-      if (!abort.signal.aborted) {
-        this.send({
-          type: "http_res_error",
-          id,
-          message: err instanceof Error ? err.message : String(err)
-        });
-      }
-    }
-  }
-  openBridgedSocket(id, path, headers) {
-    const wsOrigin = this.opts.targetOrigin.replace(/^http/, "ws");
-    let local;
-    try {
-      const upgrade = localWebSocketOptions(headers);
-      if (!upgrade)
-        throw new Error("invalid websocket upgrade headers");
-      const WS = WebSocket;
-      local = new WS(`${wsOrigin}${path}`, { headers: upgrade.headers });
-    } catch (err) {
-      this.send({
-        type: "ws_open_error",
-        id,
-        message: err instanceof Error ? err.message : String(err)
-      });
-      return;
-    }
-    const bridged = { ws: local, opened: false, buffer: [] };
-    this.bridgedSockets.set(id, bridged);
-    local.onopen = () => {
-      bridged.opened = true;
-      this.send({ type: "ws_open_ok", id });
-      for (const frame of bridged.buffer)
-        this.deliverToLocal(local, frame);
-      bridged.buffer = [];
-    };
-    local.onmessage = (event) => {
-      if (typeof event.data === "string") {
-        this.send({ type: "ws_data", id, text: event.data });
-      } else {
-        const bytes = event.data instanceof ArrayBuffer ? new Uint8Array(event.data) : new Uint8Array(event.data);
-        this.send({ type: "ws_data", id, dataB64: toB64(bytes) });
-      }
-    };
-    local.onclose = (event) => {
-      if (this.bridgedSockets.get(id) !== bridged)
-        return;
-      this.bridgedSockets.delete(id);
-      this.send({ type: "ws_close", id, code: event.code, reason: event.reason });
-    };
-    local.onerror = () => {
-      if (!bridged.opened) {
-        this.bridgedSockets.delete(id);
-        this.send({ type: "ws_open_error", id, message: "local websocket failed" });
-      }
-    };
-  }
-  deliverToLocal(local, frame) {
-    if (local.readyState !== WebSocket.OPEN)
-      return;
-    if (frame.text !== undefined)
-      local.send(frame.text);
-    else if (frame.dataB64 !== undefined)
-      local.send(fromB64(frame.dataB64));
-  }
-}
-// ../../adapters/otium/src/peer-server.ts
-import { statfsSync } from "fs";
-import { cpus, freemem, loadavg, totalmem } from "os";
-
-// ../../adapters/otium/src/turn-bridge.ts
-import { randomUUID as randomUUID4 } from "crypto";
-var EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
-function executionFor(payload) {
-  if (payload.execution)
-    return payload.execution;
-  if (!payload.agent)
-    return null;
-  return {
-    agent: payload.agent,
-    model: payload.model ?? "",
-    effort: payload.effort ?? "medium",
-    mcp: [],
-    canSpawnSubagents: false
-  };
-}
-function provisionMirrorTopic(hostCellId, payload) {
-  const execution = payload.execution;
-  if (!isAgentKind(execution.agent)) {
-    return { ok: false, error: `unknown agent "${execution.agent}"`, status: 400 };
-  }
-  const existing = getPeerSession(hostCellId, payload.hostTopicId);
-  if (existing?.binding_mode === "shared") {
-    const shared = getTopic(existing.local_topic_id);
-    if (!shared) {
-      return { ok: false, error: "bound local topic no longer exists", status: 404 };
-    }
-    if (!isTopicVisible(shared)) {
-      return { ok: false, error: "bound local topic is hidden", status: 409 };
-    }
-    if (!isTopicShared(shared)) {
-      return { ok: false, error: "bound local topic is private", status: 409 };
-    }
-    if (!shared.participants.some((participant) => participant.userId === payload.userId)) {
-      return { ok: false, error: "bound local topic is not visible to this user", status: 403 };
-    }
-    return { ok: true, localTopicId: shared.id, bindingMode: "shared" };
-  }
-  const localTopicId = existing?.local_topic_id ?? `peer-${randomUUID4()}`;
-  const now = new Date().toISOString();
-  const current = existing ? getTopic(localTopicId) : null;
-  const currentConfig = current ? getApiTopicConfig(localTopicId) : undefined;
-  const currentModel = currentConfig?.model ?? current?.defaultModel ?? "";
-  const nextModel = execution.model || current?.defaultModel || "";
-  const providerSessionIsStale = Boolean(current) && (current?.agent !== execution.agent || currentModel !== nextModel);
-  upsertTopic({
-    id: localTopicId,
-    title: payload.topicTitle,
-    kind: "agent",
-    agent: execution.agent,
-    aiMode: "always",
-    defaultModel: nextModel,
-    defaultEffort: EFFORT_LEVELS.includes(execution.effort) ? execution.effort : current?.defaultEffort ?? "medium",
-    participants: [{ userId: payload.userId, role: "owner" }],
-    isSubagent: true,
-    visibility: "hidden",
-    accessMode: "shared",
-    ...execution.description ? { description: execution.description } : {},
-    createdAt: current?.createdAt ?? now,
-    lastMessageAt: now
-  });
-  setApiTopicConfig(localTopicId, {
-    ...execution.model ? { model: execution.model } : {},
-    ...EFFORT_LEVELS.includes(execution.effort) ? { effort: execution.effort } : {},
-    mcp: execution.mcp
-  });
-  if (providerSessionIsStale) {
-    clearTopicSessionId(localTopicId, "peer-execution-spec-changed");
-  }
-  if (!existing)
-    createPeerSession(hostCellId, payload.hostTopicId, localTopicId);
-  return { ok: true, localTopicId, bindingMode: "mirror" };
-}
-var turnTrigger;
-function runPeerTurn(hubNode, hostCellId, payload, opts = {}) {
-  const execution = executionFor(payload);
-  if (!execution || !isAgentKind(execution.agent)) {
-    return { ok: false, error: `unknown agent "${execution?.agent ?? ""}"`, status: 400 };
-  }
-  const claim = claimPeerTurnRequest(hostCellId, payload.requestId, payload.hostTopicId);
-  if (!claim.claimed) {
-    if (claim.row.host_topic_id !== payload.hostTopicId) {
-      return { ok: false, error: "requestId already belongs to another room", status: 409 };
-    }
-    if (claim.row.status === "failed") {
-      return { ok: false, error: claim.row.error ?? "previous attempt failed", status: 409 };
-    }
-    logger.info({ requestId: payload.requestId, hostTopicId: payload.hostTopicId, status: claim.row.status }, "otium: peer turn replay acknowledged without re-execution");
-    return { ok: true };
-  }
-  const provisioned = provisionMirrorTopic(hostCellId, {
-    userId: payload.userId,
-    hostTopicId: payload.hostTopicId,
-    topicTitle: payload.topicTitle,
-    execution
-  });
-  if (!provisioned.ok) {
-    markPeerTurnRequestFailed(hostCellId, payload.requestId, provisioned.error);
-    return provisioned;
-  }
-  const localTopicId = provisioned.localTopicId;
-  const localTopic = getTopic(localTopicId);
-  if (payload.attachments?.some((fileId) => !peerFileAllowsAccess(fileId, { topicId: localTopicId, ownerUserId: payload.userId }))) {
-    markPeerTurnRequestFailed(hostCellId, payload.requestId, "attachment access denied");
-    return { ok: false, error: "attachment access denied", status: 403 };
-  }
-  const turnAgent = provisioned.bindingMode === "shared" && localTopic?.agent ? localTopic.agent : execution.agent;
-  const previous = getActiveForwarder(localTopicId);
-  if (previous) {
-    previous.finish({
-      type: "ai_aborted",
-      queryId: previous.queryId ?? previous.requestId,
-      topicId: localTopicId,
-      reason: "superseded"
-    });
-  }
-  const forwarder = createTurnForwarder({
-    hostNodeId: hostCellId,
-    requestId: payload.requestId,
-    localTopicId,
-    sendEvent: opts.sendEvent ?? hubEventSender(hubNode)
-  });
-  registerTurnForwarder(localTopicId, forwarder);
-  let queryId = null;
-  try {
-    queryId = executeExternalUserTurn({
-      topicId: localTopicId,
-      userId: payload.userId,
-      text: payload.message,
-      agent: turnAgent,
-      options: {
-        origin: "user",
-        requestId: payload.requestId,
-        injectAuthorId: payload.userId,
-        attachments: payload.attachments,
-        visualTools: true,
-        onDispatched: (dispatchedQueryId) => {
-          forwarder.queryId = dispatchedQueryId;
-        },
-        peerBridge: {
-          hubCellId: hostCellId,
-          hostTopicId: payload.hostTopicId,
-          hostQueryId: payload.requestId,
-          canSpawnSubagents: execution.canSpawnSubagents
-        }
-      },
-      ...turnTrigger ? { dispatch: turnTrigger } : {}
-    });
-  } catch (err) {
-    forwarder.finish({
-      type: "ai_error",
-      queryId: payload.requestId,
-      topicId: localTopicId,
-      error: `worker dispatch crashed: ${err.message}`
-    });
-    return { ok: false, error: "failed to start turn", status: 500 };
-  }
-  if (!queryId) {
-    forwarder.finish({
-      type: "ai_error",
-      queryId: payload.requestId,
-      topicId: localTopicId,
-      error: "worker could not start the turn"
-    });
-    return { ok: false, error: "failed to start turn", status: 500 };
-  }
-  forwarder.queryId = queryId;
-  markPeerTurnRequestRunning(hostCellId, payload.requestId);
-  logger.info({ requestId: payload.requestId, localTopicId, queryId, title: payload.topicTitle }, "otium: peer turn running");
-  return { ok: true };
-}
-function abortHostedPeerTurn(hostNodeId, requestId, userId, topicTitle) {
-  const request = getPeerTurnRequest(hostNodeId, requestId);
-  if (!request || request.status !== "running")
-    return false;
-  const session = getPeerSession(hostNodeId, request.host_topic_id);
-  if (!session)
-    return false;
-  const topic = getTopic(session.local_topic_id);
-  if (!topic || topic.title !== topicTitle || !topic.participants.some((participant) => participant.userId === userId)) {
-    return false;
-  }
-  const forwarder = getActiveForwarder(session.local_topic_id);
-  if (!forwarder || forwarder.requestId !== requestId)
-    return false;
-  if (!getRoomQuery(session.local_topic_id))
-    return false;
-  return abortRoom(session.local_topic_id);
-}
-
-// ../../adapters/otium/src/peer-server.ts
-var RUNTIME_VERSION = NEGOTIUM_VERSION;
-function jsonError(error, status) {
-  return Response.json({ ok: false, error }, { status });
-}
-function bearer(req) {
-  const auth = req.headers.get("authorization");
-  return auth?.startsWith("Bearer ") ? auth.slice(7) : null;
-}
-async function readBody(req) {
-  const body = await req.json().catch(() => null);
-  if (!body || typeof body !== "object" || Array.isArray(body))
-    return null;
-  return body;
-}
-function str(body, field) {
-  const value = body[field];
-  return typeof value === "string" && value.trim() ? value : null;
-}
-function checkProtocol(body) {
-  const v = body.v;
-  if (typeof v !== "number" || v > PEER_PROTOCOL_VERSION) {
-    return jsonError(`unsupported peer protocol version (mine: ${PEER_PROTOCOL_VERSION})`, 400);
-  }
-  return null;
-}
-async function requirePeer(req) {
-  if (!otiumCentralConfig()) {
-    return { ok: false, response: jsonError("multi-node is disabled", 403) };
-  }
-  const token = bearer(req);
-  if (!token)
-    return { ok: false, response: jsonError("missing peer token", 401) };
-  const verified = await verifyPeerToken(token);
-  if (!verified)
-    return { ok: false, response: jsonError("invalid peer token", 401) };
-  return { ok: true, verified };
-}
-function requirePrimaryOrigin(peer) {
-  return peer.verified.fromIsPrimary ? null : jsonError("only the workspace hub may call this endpoint", 403);
-}
-function localCapabilities() {
-  const agents = SUPPORTED_AGENTS.map((kind) => {
-    const auth = checkAgentAuth(kind);
-    const registry = getRegistry(kind);
-    return {
-      kind,
-      available: auth.ok,
-      defaultModel: registry.defaultModel,
-      validEfforts: registry.validEfforts,
-      ...!auth.ok ? { error: auth.error } : {}
-    };
-  });
-  return {
-    protocolVersion: PEER_PROTOCOL_VERSION,
-    runtimeVersion: RUNTIME_VERSION,
-    features: {
-      remoteAsk: true,
-      inputFiles: true,
-      outputFiles: true,
-      visualBridge: true,
-      askUserBridge: true,
-      selfConfigBridge: true
-    },
-    agents,
-    optionalMcp: OPTIONAL_FORUM_MCP_SERVERS
-  };
-}
-function localHealth() {
-  const memory = process.memoryUsage();
-  let disk;
-  try {
-    const stats = statfsSync(DATA_DIR);
-    disk = {
-      totalBytes: Number(stats.blocks) * Number(stats.bsize),
-      freeBytes: Number(stats.bavail) * Number(stats.bsize)
-    };
-  } catch {
-    disk = undefined;
-  }
-  return {
-    uptimeSeconds: process.uptime(),
-    cpu: { cores: cpus().length, loadAverage: loadavg() },
-    memory: {
-      totalBytes: totalmem(),
-      freeBytes: freemem(),
-      processRssBytes: memory.rss,
-      processHeapUsedBytes: memory.heapUsed
-    },
-    ...disk ? { disk } : {}
-  };
-}
-async function handleProvision(req) {
-  const peer = await requirePeer(req);
-  if (!peer.ok)
-    return peer.response;
-  const originError = requirePrimaryOrigin(peer);
-  if (originError)
-    return originError;
-  const body = await readBody(req);
-  if (!body)
-    return jsonError("invalid JSON body", 400);
-  const protocolError = checkProtocol(body);
-  if (protocolError)
-    return protocolError;
-  const userId = str(body, "userId");
-  const hostTopicId = str(body, "hostTopicId");
-  const topicTitle = str(body, "topicTitle");
-  const execution = parseExecutionSpec(body.execution);
-  if (!userId || !hostTopicId || !topicTitle || !execution) {
-    return jsonError("invalid peer provision request", 400);
-  }
-  const result = provisionMirrorTopic(peer.verified.fromCellId, {
-    userId,
-    hostTopicId,
-    topicTitle,
-    execution
-  });
-  if (!result.ok)
-    return jsonError(result.error, result.status);
-  logger.info({ hostTopicId, localTopicId: result.localTopicId, fromNode: peer.verified.fromNodeName }, "otium: hidden mirror room provisioned");
-  return Response.json({ ok: true });
-}
-async function handleBind(req) {
-  const peer = await requirePeer(req);
-  if (!peer.ok)
-    return peer.response;
-  const originError = requirePrimaryOrigin(peer);
-  if (originError)
-    return originError;
-  const body = await readBody(req);
-  if (!body)
-    return jsonError("invalid JSON body", 400);
-  const protocolError = checkProtocol(body);
-  if (protocolError)
-    return protocolError;
-  const userId = str(body, "userId");
-  const hostTopicId = str(body, "hostTopicId");
-  const localTopicId = str(body, "localTopicId");
-  if (!userId || !hostTopicId || !localTopicId) {
-    return jsonError("invalid peer bind request", 400);
-  }
-  const result = bindOtiumTopic({
-    hostNodeId: peer.verified.fromCellId,
-    hostTopicId,
-    localTopicId,
-    userId
-  });
-  if (!result.ok)
-    return jsonError(result.error, result.status);
-  return Response.json({ ok: true, localTopicId: result.localTopicId, replaced: result.replaced });
-}
-async function handleUnbind(req) {
-  const peer = await requirePeer(req);
-  if (!peer.ok)
-    return peer.response;
-  const originError = requirePrimaryOrigin(peer);
-  if (originError)
-    return originError;
-  const body = await readBody(req);
-  if (!body)
-    return jsonError("invalid JSON body", 400);
-  const protocolError = checkProtocol(body);
-  if (protocolError)
-    return protocolError;
-  const hostTopicId = str(body, "hostTopicId");
-  if (!hostTopicId)
-    return jsonError("hostTopicId is required", 400);
-  const removed = unbindOtiumTopic(peer.verified.fromCellId, hostTopicId);
-  return Response.json({ ok: true, removed });
-}
-async function handleTurn(req) {
-  const peer = await requirePeer(req);
-  if (!peer.ok)
-    return peer.response;
-  const originError = requirePrimaryOrigin(peer);
-  if (originError)
-    return originError;
-  const body = await readBody(req);
-  if (!body)
-    return jsonError("invalid JSON body", 400);
-  const protocolError = checkProtocol(body);
-  if (protocolError)
-    return protocolError;
-  const requestId = str(body, "requestId");
-  const userId = str(body, "userId");
-  const hostTopicId = str(body, "hostTopicId");
-  const topicTitle = str(body, "topicTitle");
-  const execution = parseExecutionSpec(body.execution);
-  if (body.execution !== undefined && !execution) {
-    return jsonError("invalid placed-topic execution spec", 400);
-  }
-  const agent = execution?.agent ?? str(body, "agent");
-  const message = str(body, "message");
-  if (!requestId || !userId || !hostTopicId || !topicTitle || !agent || !message) {
-    return jsonError("requestId, userId, hostTopicId, topicTitle, agent, message are required", 400);
-  }
-  if (message.length > MAX_PEER_MESSAGE_LENGTH)
-    return jsonError("message too long", 400);
-  const hubNode = await resolvePeerNodeByCellId(peer.verified.fromCellId).catch(() => null);
-  if (!hubNode)
-    return jsonError("calling node is not in this workspace", 403);
-  const payload = {
-    v: PEER_PROTOCOL_VERSION,
-    requestId,
-    userId,
-    hostTopicId,
-    topicTitle,
-    ...execution ? { execution } : {},
-    ...agent ? { agent } : {},
-    ...str(body, "model") ? { model: str(body, "model") } : {},
-    ...str(body, "effort") ? { effort: str(body, "effort") } : {},
-    ...Array.isArray(body.attachments) && body.attachments.every((entry) => typeof entry === "string") ? { attachments: body.attachments } : {},
-    message
-  };
-  const result = runPeerTurn(hubNode, peer.verified.fromCellId, payload);
-  if (!result.ok)
-    return jsonError(result.error, result.status);
-  logger.info({ requestId, hostTopicId, fromNode: peer.verified.fromNodeName }, "otium: peer turn accepted");
-  return Response.json({ ok: true });
-}
-async function handleAbort(req) {
-  const peer = await requirePeer(req);
-  if (!peer.ok)
-    return peer.response;
-  const originError = requirePrimaryOrigin(peer);
-  if (originError)
-    return originError;
-  const body = await readBody(req);
-  if (!body)
-    return jsonError("invalid JSON body", 400);
-  const protocolError = checkProtocol(body);
-  if (protocolError)
-    return protocolError;
-  const userId = str(body, "userId");
-  const toTopic = str(body, "toTopic");
-  if (!userId || !toTopic)
-    return jsonError("userId and toTopic are required", 400);
-  const requestId = str(body, "requestId");
-  if (requestId) {
-    const aborted = abortHostedPeerTurn(peer.verified.fromCellId, requestId, userId, toTopic);
-    if (!aborted)
-      return jsonError("turn not found or already completed", 404);
-    logger.info({ fromNode: peer.verified.fromNodeName, toTopic, requestId }, "otium: exact peer turn abort accepted");
-    return Response.json({ ok: true });
-  }
-  const topic = getTopicByNameForUser(toTopic, userId);
-  if (!topic || !isTopicShared(topic)) {
-    return jsonError(`shared topic "${toTopic}" not found on this node`, 404);
-  }
-  appendJsonlEntry(sessionInboxPath(userId, topic.id), {
-    type: "abort",
-    timestamp: new Date().toISOString()
-  });
-  flushSessionInbox();
-  logger.info({ fromNode: peer.verified.fromNodeName, toTopic }, "otium: peer abort accepted");
-  return Response.json({ ok: true });
-}
-async function handleTell(req) {
-  const peer = await requirePeer(req);
-  if (!peer.ok)
-    return peer.response;
-  const originError = requirePrimaryOrigin(peer);
-  if (originError)
-    return originError;
-  const body = await readBody(req);
-  if (!body)
-    return jsonError("invalid JSON body", 400);
-  const protocolError = checkProtocol(body);
-  if (protocolError)
-    return protocolError;
-  const requestId = str(body, "requestId");
-  const userId = str(body, "userId");
-  const toTopic = str(body, "toTopic");
-  const fromLabel = str(body, "fromLabel");
-  const message = str(body, "message");
-  const depth = typeof body.depth === "number" ? body.depth : Number.NaN;
-  if (!requestId || !userId || !toTopic || !fromLabel || !message) {
-    return jsonError("requestId, userId, toTopic, fromLabel, message are required", 400);
-  }
-  if (message.length > MAX_PEER_MESSAGE_LENGTH)
-    return jsonError("message too long", 400);
-  if (!Number.isInteger(depth) || depth < 0) {
-    return jsonError("depth must be a non-negative integer", 400);
-  }
-  if (depth > MAX_TELL_DEPTH) {
-    return jsonError(`tell depth limit exceeded (max ${MAX_TELL_DEPTH})`, 400);
-  }
-  const topic = getTopicByNameForUser(toTopic, userId);
-  if (!topic || !isTopicShared(topic)) {
-    return jsonError(`shared topic "${toTopic}" not found on this node`, 404);
-  }
-  const claim = claimInboundPeerMessage({
-    fromCellId: peer.verified.fromCellId,
-    requestId,
-    kind: "tell",
-    topicId: topic.id,
-    payload: { userId, toTopic, fromLabel, message, depth }
-  });
-  if (claim === "conflict")
-    return jsonError("requestId already belongs to another tell", 409);
-  if (claim === "replay")
-    return Response.json({ ok: true, replayed: true });
-  try {
-    appendJsonlEntry(sessionInboxPath(userId, topic.id), {
-      type: "tell",
-      requestId,
-      from: fromLabel,
-      fromTitle: fromLabel,
-      message,
-      depth,
-      timestamp: new Date().toISOString()
-    });
-  } catch (error) {
-    releasePeerInboxRequest(peer.verified.fromCellId, requestId, "tell");
-    throw error;
-  }
-  flushSessionInbox();
-  logger.info({ from: fromLabel, fromNode: peer.verified.fromNodeName, toTopic, requestId }, "otium: peer tell accepted");
-  return Response.json({ ok: true });
-}
-function claimInboundPeerMessage(args) {
-  return claimPeerInboxRequest({
-    fromCellId: args.fromCellId,
-    requestId: args.requestId,
-    kind: args.kind,
-    topicId: args.topicId,
-    payloadHash: peerInboxPayloadHash(args.payload)
-  }).outcome;
-}
-async function handleSessions(req) {
-  const peer = await requirePeer(req);
-  if (!peer.ok)
-    return peer.response;
-  const originError = requirePrimaryOrigin(peer);
-  if (originError)
-    return originError;
-  const body = await readBody(req);
-  if (!body)
-    return jsonError("invalid JSON body", 400);
-  const protocolError = checkProtocol(body);
-  if (protocolError)
-    return protocolError;
-  const userId = str(body, "userId");
-  if (!userId)
-    return jsonError("userId is required", 400);
-  const sessions2 = listTopics().filter((topic) => topic.kind !== "manager" && !topic.isSubagent && isTopicShared(topic) && topic.participants.some((p) => p.userId === userId)).map((topic) => ({
-    topicId: topic.id,
-    name: topic.title,
-    agent: topic.agent ?? null,
-    hasSession: Boolean(getTopicSessionId(topic.id)),
-    ...topic.description ? { description: topic.description } : {}
-  }));
-  return Response.json({ ok: true, sessions: sessions2 });
-}
-async function handleAsk(req) {
-  const peer = await requirePeer(req);
-  if (!peer.ok)
-    return peer.response;
-  const originError = requirePrimaryOrigin(peer);
-  if (originError)
-    return originError;
-  const body = await readBody(req);
-  if (!body)
-    return jsonError("invalid JSON body", 400);
-  const protocolError = checkProtocol(body);
-  if (protocolError)
-    return protocolError;
-  const requestId = str(body, "requestId");
-  const userId = str(body, "userId");
-  const toTopic = str(body, "toTopic");
-  const fromLabel = str(body, "fromLabel");
-  const message = str(body, "message");
-  const fromDepth = body.fromDepth === undefined ? 0 : typeof body.fromDepth === "number" ? body.fromDepth : Number.NaN;
-  const replyTo = body.replyTo;
-  const replyTopicId = typeof replyTo?.topicId === "string" ? replyTo.topicId : null;
-  if (!requestId || !userId || !toTopic || !fromLabel || !message || !replyTopicId) {
-    return jsonError("requestId, userId, toTopic, fromLabel, message, replyTo.topicId are required", 400);
-  }
-  if (message.length > MAX_PEER_MESSAGE_LENGTH)
-    return jsonError("message too long", 400);
-  if (!Number.isInteger(fromDepth) || fromDepth < 0) {
-    return jsonError("fromDepth must be a non-negative integer", 400);
-  }
-  const topic = getTopicByNameForUser(toTopic, userId);
-  if (!topic || !isTopicShared(topic)) {
-    return jsonError(`shared topic "${toTopic}" not found on this node`, 404);
-  }
-  if (!topic.agent)
-    return jsonError(`topic "${toTopic}" has no AI invited`, 409);
-  const claim = claimInboundPeerMessage({
-    fromCellId: peer.verified.fromCellId,
-    requestId,
-    kind: "ask",
-    topicId: topic.id,
-    payload: { userId, toTopic, fromLabel, message, fromDepth, replyTopicId }
-  });
-  if (claim === "conflict")
-    return jsonError("requestId already belongs to another ask", 409);
-  if (claim === "replay")
-    return Response.json({ ok: true, replayed: true });
-  try {
-    appendJsonlEntry(sessionInboxPath(userId, topic.id), {
-      type: "ask",
-      requestId,
-      from: fromLabel,
-      fromTitle: fromLabel,
-      message,
-      fromDepth,
-      timestamp: new Date().toISOString(),
-      remoteReply: {
-        nodeName: peer.verified.fromNodeName ?? "",
-        nodeCellId: peer.verified.fromCellId,
-        topicId: replyTopicId,
-        userId,
-        requestId
-      }
-    });
-  } catch (error) {
-    releasePeerInboxRequest(peer.verified.fromCellId, requestId, "ask");
-    throw error;
-  }
-  flushSessionInbox();
-  return Response.json({ ok: true });
-}
-async function handleReply(req) {
-  const peer = await requirePeer(req);
-  if (!peer.ok)
-    return peer.response;
-  const originError = requirePrimaryOrigin(peer);
-  if (originError)
-    return originError;
-  const body = await readBody(req);
-  if (!body)
-    return jsonError("invalid JSON body", 400);
-  const protocolError = checkProtocol(body);
-  if (protocolError)
-    return protocolError;
-  const requestId = str(body, "requestId");
-  const userId = str(body, "userId");
-  const replyText = typeof body.replyText === "string" ? body.replyText : null;
-  const fromLabel = str(body, "fromLabel") ?? "peer";
-  const kind = body.kind === "error" ? "error" : "reply";
-  if (!requestId || !userId || replyText === null) {
-    return jsonError("requestId, userId and replyText are required", 400);
-  }
-  const accepted = await acceptRemoteAskReplyResult({
-    fromCellId: peer.verified.fromCellId,
-    requestId,
-    userId,
-    fromLabel,
-    replyText,
-    kind
-  });
-  if (accepted === "accepted")
-    return Response.json({ ok: true });
-  if (accepted === "retry")
-    return jsonError("ask callback delivery is retryable", 503);
-  return jsonError("no pending ask for this requestId", 404);
-}
-async function handleInputFile(req) {
-  const peer = await requirePeer(req);
-  if (!peer.ok)
-    return peer.response;
-  const originError = requirePrimaryOrigin(peer);
-  if (originError)
-    return originError;
-  const contentLength = Number(req.headers.get("content-length"));
-  if (Number.isFinite(contentLength) && contentLength > MAX_PEER_INPUT_REQUEST_BYTES) {
-    return jsonError("file too large", 413);
-  }
-  const form = await req.formData().catch(() => null);
-  if (!form)
-    return jsonError("expected multipart/form-data", 400);
-  const hostTopicId = form.get("hostTopicId");
-  const userId = form.get("userId");
-  const file = form.get("file");
-  if (typeof hostTopicId !== "string" || typeof userId !== "string" || !(file instanceof File)) {
-    return jsonError("hostTopicId, userId, and file are required", 400);
-  }
-  if (file.size > MAX_PEER_INPUT_FILE_BYTES)
-    return jsonError("file too large", 413);
-  const session = getPeerSession(peer.verified.fromCellId, hostTopicId);
-  const topic = session ? getTopic(session.local_topic_id) : null;
-  if (!session || !topic?.participants.some((participant) => participant.userId === userId)) {
-    return jsonError("provisioned peer room not found", 404);
-  }
-  const stored = await storePeerInputFile(file, {
-    topicId: session.local_topic_id,
-    ownerUserId: userId
-  });
-  return Response.json({ ok: true, fileId: stored.id });
-}
-async function handleDeviceVault(req) {
-  const peer = await requirePeer(req);
-  if (!peer.ok)
-    return peer.response;
-  const originError = requirePrimaryOrigin(peer);
-  if (originError)
-    return originError;
-  const body = await readBody(req);
-  if (!body)
-    return jsonError("invalid JSON body", 400);
-  const protocolError = checkProtocol(body);
-  if (protocolError)
-    return protocolError;
-  const userId = str(body, "userId");
-  const operation = str(body, "operation");
-  if (!userId || !operation)
-    return jsonError("userId and operation are required", 400);
-  if (operation === "list") {
-    return Response.json({ ok: true, entries: vaultList(userId) });
-  }
-  const rawKey = str(body, "key");
-  if (!rawKey || !validateVaultKey(rawKey))
-    return jsonError("invalid vault key", 400);
-  const key = normalizeVaultKey(rawKey);
-  if (operation === "delete") {
-    return vaultDel(userId, key) ? Response.json({ ok: true, deleted: key }) : jsonError(`vault key "${key}" not found`, 404);
-  }
-  if (operation !== "set")
-    return jsonError("invalid vault operation", 400);
-  const value = typeof body.value === "string" ? body.value : "";
-  const valueBytes = Buffer.byteLength(value, "utf8");
-  if (valueBytes < VAULT_VALUE_MIN_BYTES || valueBytes > VAULT_VALUE_MAX_BYTES) {
-    return jsonError(`value must be between ${VAULT_VALUE_MIN_BYTES} and ${VAULT_VALUE_MAX_BYTES} bytes`, 400);
-  }
-  const description = body.description === undefined ? "" : body.description;
-  if (typeof description !== "string" || description.length > VAULT_DESCRIPTION_MAX_LENGTH) {
-    return jsonError(`description must be at most ${VAULT_DESCRIPTION_MAX_LENGTH} characters`, 400);
-  }
-  vaultSet(userId, key, value, description);
-  return Response.json({ ok: true, key, ...description ? { description } : {} });
-}
-async function handleOtiumPeerRequest(req) {
-  const url = new URL(req.url);
-  const path = url.pathname;
-  if (path === "/ready" && req.method === "GET") {
-    if (!otiumCentralConfig())
-      return null;
-    return Response.json({ ok: true });
-  }
-  if (!path.startsWith("/api/v1/peer/"))
-    return null;
-  if (req.method === "GET") {
-    if (path === "/api/v1/peer/capabilities") {
-      const peer = await requirePeer(req);
-      if (!peer.ok)
-        return peer.response;
-      return Response.json({ ok: true, ...localCapabilities() });
-    }
-    if (path === "/api/v1/peer/health") {
-      const peer = await requirePeer(req);
-      if (!peer.ok)
-        return peer.response;
-      return Response.json({ ok: true, ...localHealth() });
-    }
-    return jsonError("not found", 404);
-  }
-  if (req.method !== "POST")
-    return jsonError("not found", 404);
-  switch (path) {
-    case "/api/v1/peer/provision":
-      return handleProvision(req);
-    case "/api/v1/peer/bind":
-      return handleBind(req);
-    case "/api/v1/peer/unbind":
-      return handleUnbind(req);
-    case "/api/v1/peer/turn":
-      return handleTurn(req);
-    case "/api/v1/peer/abort":
-      return handleAbort(req);
-    case "/api/v1/peer/tell":
-      return handleTell(req);
-    case "/api/v1/peer/ask":
-      return handleAsk(req);
-    case "/api/v1/peer/sessions":
-      return handleSessions(req);
-    case "/api/v1/peer/reply":
-      return handleReply(req);
-    case "/api/v1/peer/input-file":
-      return handleInputFile(req);
-    case "/api/v1/peer/device-vault":
-      return handleDeviceVault(req);
-    default:
-      return jsonError("not found", 404);
-  }
-}
-
-// ../../adapters/otium/src/index.ts
-function startOtiumAdapter(options) {
-  const { join: join2 } = options;
-  configureOtiumCentral(join2);
-  const failed = failInterruptedPeerTurnRequestsOnStartup();
-  if (failed > 0) {
-    logger.warn({ failed }, "otium: failed interrupted peer turns from previous process");
-  }
-  const stopBackflow = startEventBackflow();
-  const unregisterRuntimeBridge = registerPeerRuntimeBridge(otiumPeerRuntimeBridge);
-  const unregisterSessionBridge = registerPeerSessionBridge(otiumPeerSessionBridge);
-  const sessionBridgeIpc = startPeerSessionBridgeIpc(otiumPeerSessionBridge);
-  const canonicalMcpBridge = startCanonicalMcpBridge();
-  const stopPeerReplyOutbox = startPeerReplyOutboxWorker();
-  failInterruptedRemoteAskCallbacks().then((failedAsks) => {
-    if (failedAsks > 0) {
-      logger.warn({ failedAsks }, "otium: failed remote asks interrupted by previous process");
-    }
-  });
-  const uninstallFileHooks = installPeerFileHooks();
-  const unsubscribeTopicCleanup = runtimeBus().subscribe((event) => {
-    if (event.type !== "topic-deleted")
-      return;
-    const removed = cleanupPeerStateForLocalTopic(event.topicId);
-    if (removed.sessions + removed.turns + removed.inboxRequests + removed.remoteAsks > 0) {
-      logger.info({ topicId: event.topicId, ...removed }, "otium: removed peer state for deleted local topic");
-    }
-  });
-  let stopped = false;
-  let tunnel = null;
-  logger.info({ central: join2.central, cellId: join2.cellId }, "otium: worker mode enabled");
-  selfPeerNode().then((self) => {
-    if (self) {
-      logger.info({ nodeName: self.nodeName, baseUrl: self.baseUrl }, "otium: attached to workspace");
-    }
-  }).catch((err) => {
-    logger.warn({ err }, "otium: self check against central failed (will retry per request)");
-  });
-  return {
-    name: "otium",
-    join: join2,
-    startTunnel: ({ targetOrigin, relayUrl }) => {
-      if (stopped || tunnel)
-        return;
-      const selectedRelay = relayUrl?.trim() || join2.relay || process.env.OTIUM_RELAY_URL?.trim();
-      if (!selectedRelay) {
-        logger.info({}, "otium: relay tunnel disabled (no relay URL configured)");
-        return;
-      }
-      tunnel = new TunnelClient({
-        relayUrl: selectedRelay,
-        token: join2.secret,
-        targetOrigin,
-        nodeVersion: `negotium@${NEGOTIUM_VERSION}`,
-        logger
-      });
-      tunnel.start();
-    },
-    stop: () => {
-      if (stopped)
-        return;
-      stopped = true;
-      tunnel?.stop();
-      tunnel = null;
-      unsubscribeTopicCleanup();
-      unregisterRuntimeBridge();
-      unregisterSessionBridge();
-      sessionBridgeIpc.stop();
-      canonicalMcpBridge.stop();
-      stopPeerReplyOutbox();
-      uninstallFileHooks();
-      stopBackflow();
-      configureOtiumCentral(null);
-    }
-  };
-}
-var otiumAdapter = defineNegotiumAdapter({
-  name: "otium",
-  capabilities: {
-    localUserInput: false,
-    topicManagement: false,
-    externalPlacedTurn: true
-  },
-  projection: {
-    transcript: "full",
-    historyBackfill: false,
-    externalAuthors: "relayed"
-  },
-  start: startOtiumAdapter
-});
-function startOtiumWorker() {
-  const join2 = loadJoin();
-  if (!join2)
-    return null;
-  return startOtiumAdapter({ join: join2 });
-}
-export {
-  verifyPeerToken,
-  unbindOtiumTopic,
-  translateBusEvent,
-  stopEventBackflow,
-  startOtiumWorker,
-  startOtiumAdapter,
-  startEventBackflow,
-  shareOtiumTopic,
-  setOtiumTopicPrivate,
-  selfPeerNode,
-  saveJoin,
-  runPeerTurn,
-  resolvePeerNodeByCellId,
-  resetPeerCentralCaches,
-  registerTurnForwarder,
-  provisionMirrorTopic,
-  previewEnrollment,
-  pendingEnrollmentPath,
-  parseInviteCode,
-  parseEnrollmentInvite,
-  otiumPeerRuntimeBridge,
-  otiumCentralConfig,
-  otiumAdapter,
-  mintPeerToken,
-  loadJoin,
-  listPeerNodes,
-  listOtiumTopicBindings,
-  joinFilePath,
-  isJoinPersisted,
-  isEnrollmentPending,
-  hubEventSender,
-  handleOtiumPeerRequest,
-  getActiveForwarder,
-  failInterruptedPeerTurnRequestsOnStartup,
-  createTurnForwarder,
-  configureOtiumCentral,
-  commitEnrollment,
-  cleanupPeerStateForLocalTopic,
-  claimEnrollment,
-  bindOtiumTopic,
-  abortHostedPeerTurn,
-  TunnelClient,
-  PROTOCOL_VERSION as RELAY_PROTOCOL_VERSION,
-  PEER_PROTOCOL_VERSION
-};
-
-//# debugId=F8CF1BBB03F509B664756E2164756E21