negotium 0.2.22 → 0.2.23

package/dist/main.js

@@ -1867,7 +1867,7 @@ var exports_version = {};
 __export(exports_version, {
   NEGOTIUM_VERSION: () => NEGOTIUM_VERSION
 });
-var NEGOTIUM_VERSION = "0.2.22";
+var NEGOTIUM_VERSION = "0.2.23";
 
 // ../../packages/core/src/agents/codex-native-multi-agent.ts
 import { spawn } from "child_process";
@@ -29442,7 +29442,8 @@ function createNodeControlHandler(options) {
               "turn-events-sse-resume",
               "canonical-topic-read",
               "canonical-message-read",
-              "canonical-topic-list"
+              "canonical-topic-list",
+              "canonical-topic-create"
             ],
             cursor: latestRuntimeEventSeq()
           });
@@ -29519,6 +29520,25 @@ function createNodeControlHandler(options) {
             cursor: latestRuntimeEventSeq()
           });
         }
+        if (req.method === "POST" && runtimePath === "/topics") {
+          const body = await bodyRecord(req);
+          if (body.v !== NODE_RUNTIME_CONTRACT_VERSION)
+            return jsonError(400, "Unsupported v");
+          const userId = requiredText(body.userId, "userId");
+          const title = requiredText(body.title, "title");
+          const agent = body.agent;
+          if (agent !== undefined && !["claude", "codex", "maestro"].includes(String(agent))) {
+            return jsonError(400, "Invalid agent");
+          }
+          const topic = topicService.create({
+            title,
+            userId,
+            kind: "agent",
+            accessMode: "shared",
+            ...agent ? { agent } : {}
+          });
+          return Response.json({ ok: true, v: NODE_RUNTIME_CONTRACT_VERSION, topic }, { status: 201 });
+        }
         const runtimeTopicMatch = runtimePath.match(/^\/topics\/([^/]+)$/);
         if (runtimeTopicMatch && req.method === "GET") {
           const topic = getTopic(decodeURIComponent(runtimeTopicMatch[1]));
@@ -41439,18 +41459,30 @@ var init_cli2 = __esm(async () => {
   if (false) {}
 });
 
-// ../../adapters/otium/src/central.ts
-var exports_central = {};
-__export(exports_central, {
-  verifyPeerToken: () => verifyPeerToken,
-  selfPeerNode: () => selfPeerNode,
-  resolvePeerNodeByCellId: () => resolvePeerNodeByCellId,
-  resetPeerCentralCaches: () => resetPeerCentralCaches,
-  otiumCentralConfig: () => otiumCentralConfig,
-  mintPeerToken: () => mintPeerToken,
-  listPeerNodes: () => listPeerNodes,
-  configureOtiumCentral: () => configureOtiumCentral
+// ../../packages/core/src/config-public.ts
+var init_config_public = __esm(() => {
+  init_config();
 });
+
+// ../../adapters/otium/src/join-status.ts
+var exports_join_status = {};
+__export(exports_join_status, {
+  hasConfiguredOtiumJoin: () => hasConfiguredOtiumJoin
+});
+import { existsSync as existsSync36 } from "fs";
+import { resolve as resolve23 } from "path";
+function hasConfiguredOtiumJoin() {
+  const envJoin = Boolean(process.env.OTIUM_CENTRAL_URL?.trim() && process.env.OTIUM_CELL_ID?.trim() && process.env.OTIUM_CELL_SECRET?.trim());
+  return envJoin || existsSync36(resolve23(DATA_DIR, "otium-join.json"));
+}
+var init_join_status = __esm(() => {
+  init_config_public();
+});
+
+// ../../adapters/otium/src/control-protocol.ts
+var OTIUM_ADAPTER_CONTROL_PREFIX = "/api/v1/adapter/otium", OTIUM_ADAPTER_CONTROL_HEADER = "x-negotium-adapter-token";
+
+// ../../adapters/otium/src/central.ts
 function configureOtiumCentral(join42) {
   joinConfig = join42;
   resetPeerCentralCaches();
@@ -41555,418 +41587,14 @@ var init_central = __esm(async () => {
   tokenCache = new Map;
 });
 
-// ../../adapters/otium/src/secure-transport.ts
-function isLoopbackHostname(hostname2) {
-  const normalized = hostname2.toLowerCase();
-  if (normalized === "localhost" || normalized === "::1" || normalized === "[::1]")
-    return true;
-  const octets = normalized.split(".");
-  return octets.length === 4 && octets[0] === "127" && octets.every((octet) => /^\d{1,3}$/.test(octet) && Number(octet) <= 255);
-}
-function credentialTransportUrl(value, label) {
-  let url;
-  try {
-    url = new URL(value);
-  } catch {
-    throw new Error(`${label} is not a valid URL`);
-  }
-  if (url.username || url.password)
-    throw new Error(`${label} must not contain URL credentials`);
-  return url;
-}
-function assertSecureCentralUrl(value) {
-  const url = credentialTransportUrl(value, "Otium central URL");
-  if (url.protocol === "https:")
-    return;
-  if (url.protocol === "http:" && isLoopbackHostname(url.hostname))
-    return;
-  throw new Error("Otium central requires HTTPS or loopback HTTP");
-}
-function assertSecureRelayUrl(value) {
-  const url = credentialTransportUrl(value, "Otium relay URL");
-  if (url.protocol === "https:" || url.protocol === "wss:")
-    return;
-  if ((url.protocol === "http:" || url.protocol === "ws:") && isLoopbackHostname(url.hostname)) {
-    return;
-  }
-  throw new Error("Otium relay requires HTTPS/WSS or loopback HTTP/WS");
-}
-
-// ../../adapters/otium/src/join.ts
-var exports_join = {};
-__export(exports_join, {
-  withJoinCredentialLock: () => withJoinCredentialLock,
-  saveJoinWhileLocked: () => saveJoinWhileLocked,
-  saveJoin: () => saveJoin,
-  removeJoin: () => removeJoin,
-  parseInviteCode: () => parseInviteCode,
-  loadJoin: () => loadJoin,
-  joinFilePath: () => joinFilePath,
-  joinCredentialDigest: () => joinCredentialDigest,
-  isJoinPersisted: () => isJoinPersisted
-});
-import { createHash as createHash11, randomUUID as randomUUID27 } from "crypto";
-import {
-  chmodSync as chmodSync7,
-  closeSync as closeSync5,
-  existsSync as existsSync36,
-  fsyncSync as fsyncSync2,
-  linkSync,
-  lstatSync,
-  mkdirSync as mkdirSync32,
-  openSync as openSync5,
-  readFileSync as readFileSync28,
-  renameSync as renameSync16,
-  rmSync as rmSync10,
-  statSync as statSync20,
-  unlinkSync as unlinkSync23,
-  writeFileSync as writeFileSync23
-} from "fs";
-import { dirname as dirname21, resolve as resolve23 } from "path";
-function joinFilePath() {
-  return resolve23(DATA_DIR, "otium-join.json");
-}
-function isHttpUrl(value) {
-  return /^https?:\/\//.test(value);
-}
-function isRelayUrl(value) {
-  return /^(?:https?|wss?):\/\//.test(value);
-}
-function normalizeJoin(raw) {
-  const central = typeof raw.central === "string" ? raw.central.trim().replace(/\/+$/, "") : "";
-  const relay = typeof raw.relay === "string" ? raw.relay.trim().replace(/\/+$/, "") : "";
-  const cellId = typeof raw.cellId === "string" ? raw.cellId.trim() : "";
-  const secret = typeof raw.secret === "string" ? raw.secret.trim() : "";
-  if (!central || !isHttpUrl(central)) {
-    throw new Error("invite code is missing a valid http(s) central URL");
-  }
-  if (relay && !isRelayUrl(relay))
-    throw new Error("invite code has an invalid relay URL");
-  if (!cellId)
-    throw new Error("invite code is missing cellId");
-  if (!secret)
-    throw new Error("invite code is missing secret");
-  assertSecureCentralUrl(central);
-  if (relay)
-    assertSecureRelayUrl(relay);
-  return {
-    ...typeof raw.v === "number" ? { v: raw.v } : {},
-    central,
-    ...relay ? { relay } : {},
-    cellId,
-    secret
-  };
-}
-function parseInviteCode(code) {
-  const trimmed = code.trim();
-  if (!trimmed)
-    throw new Error("invite code is empty");
-  let decoded;
-  try {
-    decoded = Buffer.from(trimmed, "base64url").toString("utf-8");
-  } catch {
-    throw new Error("invite code is not valid base64url");
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(decoded);
-  } catch {
-    throw new Error("invite code does not decode to JSON");
-  }
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new Error("invite code does not decode to a JSON object");
-  }
-  return normalizeJoin(parsed);
-}
-function joinLockPath() {
-  return resolve23(DATA_DIR, ".otium-join.lock");
-}
-function processIsAlive(pid) {
-  if (!Number.isSafeInteger(pid) || pid <= 0)
-    return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error2) {
-    return error2.code !== "ESRCH";
-  }
-}
-function withJoinCredentialLock(operation) {
-  const lockPath = joinLockPath();
-  const ownerPath = resolve23(lockPath, "owner.json");
-  const owner = { pid: process.pid, token: randomUUID27() };
-  mkdirSync32(dirname21(lockPath), { recursive: true });
-  for (let attempt = 0;; attempt += 1) {
-    let created = false;
-    try {
-      mkdirSync32(lockPath, { mode: 448 });
-      created = true;
-      writeFileSync23(ownerPath, `${JSON.stringify(owner)}
-`, { mode: 384 });
-      const ownerFd = openSync5(ownerPath, "r");
-      try {
-        fsyncSync2(ownerFd);
-      } finally {
-        closeSync5(ownerFd);
-      }
-      break;
-    } catch (error2) {
-      if (created) {
-        rmSync10(lockPath, { recursive: true, force: true });
-        throw error2;
-      }
-      if (error2.code !== "EEXIST")
-        throw error2;
-      let current3 = null;
-      try {
-        current3 = JSON.parse(readFileSync28(ownerPath, "utf8"));
-      } catch {}
-      let ageMs;
-      try {
-        ageMs = Date.now() - statSync20(lockPath).mtimeMs;
-      } catch (statError) {
-        if (statError.code === "ENOENT")
-          continue;
-        throw statError;
-      }
-      if (current3 && processIsAlive(current3.pid) || !current3 && ageMs <= JOIN_LOCK_STALE_MS) {
-        throw new Error(`another Otium join credential operation is in progress at ${lockPath}`);
-      }
-      if (attempt > 0) {
-        throw new Error(`could not recover stale Otium join credential lock at ${lockPath}`);
-      }
-      const stalePath = `${lockPath}.stale.${process.pid}.${randomUUID27()}`;
-      try {
-        renameSync16(lockPath, stalePath);
-        rmSync10(stalePath, { recursive: true, force: true });
-      } catch (staleError) {
-        if (staleError.code !== "ENOENT")
-          throw staleError;
-      }
-    }
-  }
-  try {
-    return operation();
-  } finally {
-    try {
-      const current3 = JSON.parse(readFileSync28(ownerPath, "utf8"));
-      if (current3.pid === owner.pid && current3.token === owner.token) {
-        rmSync10(lockPath, { recursive: true, force: true });
-      }
-    } catch {}
-  }
-}
-function joinsEqual(left, right) {
-  return left.central === right.central && left.relay === right.relay && left.cellId === right.cellId && left.secret === right.secret;
-}
-function normalizedJoin(join42) {
-  return normalizeJoin({
-    v: join42.v,
-    central: join42.central,
-    relay: join42.relay,
-    cellId: join42.cellId,
-    secret: join42.secret
-  });
-}
-function joinCredentialDigest(join42) {
-  return createHash11("sha256").update(JSON.stringify(normalizedJoin(join42))).digest("base64url");
-}
-function readPersistedJoin(path = joinFilePath()) {
-  if (!existsSync36(path))
-    return null;
-  const parsed = JSON.parse(readFileSync28(path, "utf-8"));
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new Error("persisted join credentials are not a JSON object");
-  }
-  return normalizeJoin(parsed);
-}
-function isJoinPersisted(join42) {
-  try {
-    const persisted = readPersistedJoin();
-    return persisted !== null && joinsEqual(persisted, normalizedJoin(join42));
-  } catch {
-    return false;
-  }
-}
-function saveJoinWhileLocked(join42, options = {}) {
-  const path = joinFilePath();
-  const directory = dirname21(path);
-  const normalized = normalizedJoin(join42);
-  mkdirSync32(directory, { recursive: true });
-  if (existsSync36(path)) {
-    if (lstatSync(path).isSymbolicLink()) {
-      throw new Error(`refusing to replace symlinked Otium join file at ${path}`);
-    }
-    let existing = null;
-    try {
-      existing = readPersistedJoin(path);
-    } catch (error2) {
-      if (!options.replaceExisting) {
-        throw new Error(`existing Otium join file at ${path} is invalid; pass --replace to replace it`, { cause: error2 });
-      }
-    }
-    if (existing && joinsEqual(existing, normalized)) {
-      chmodSync7(path, 384);
-      const fileFd = openSync5(path, "r");
-      try {
-        fsyncSync2(fileFd);
-      } finally {
-        closeSync5(fileFd);
-      }
-      const directoryFd = openSync5(directory, "r");
-      try {
-        fsyncSync2(directoryFd);
-      } finally {
-        closeSync5(directoryFd);
-      }
-      return path;
-    }
-    if (!options.replaceExisting) {
-      throw new Error(`this node is already joined${existing ? ` as ${existing.cellId}` : " with an invalid join file"}; pass --replace to replace its credentials`);
-    }
-  }
-  const temporaryPath = resolve23(directory, `.otium-join.json.${process.pid}.${randomUUID27()}.tmp`);
-  let fd;
-  try {
-    fd = openSync5(temporaryPath, "wx", 384);
-    writeFileSync23(fd, `${JSON.stringify(normalized, null, 2)}
-`, "utf8");
-    fsyncSync2(fd);
-    closeSync5(fd);
-    fd = undefined;
-    if (options.replaceExisting) {
-      renameSync16(temporaryPath, path);
-    } else {
-      linkSync(temporaryPath, path);
-      unlinkSync23(temporaryPath);
-    }
-    chmodSync7(path, 384);
-    const directoryFd = openSync5(directory, "r");
-    try {
-      fsyncSync2(directoryFd);
-    } finally {
-      closeSync5(directoryFd);
-    }
-  } catch (error2) {
-    if (fd !== undefined)
-      closeSync5(fd);
-    if (existsSync36(temporaryPath))
-      unlinkSync23(temporaryPath);
-    throw error2;
-  }
-  return path;
-}
-function saveJoin(join42, options = {}) {
-  return withJoinCredentialLock(() => saveJoinWhileLocked(join42, options));
-}
-function removeJoin() {
-  return withJoinCredentialLock(() => {
-    const path = joinFilePath();
-    if (!existsSync36(path))
-      return false;
-    if (lstatSync(path).isSymbolicLink()) {
-      throw new Error(`refusing to remove symlinked Otium join file at ${path}`);
-    }
-    unlinkSync23(path);
-    const directoryFd = openSync5(dirname21(path), "r");
-    try {
-      fsyncSync2(directoryFd);
-    } finally {
-      closeSync5(directoryFd);
-    }
-    return true;
-  });
-}
-function loadJoin() {
-  const central = process.env.OTIUM_CENTRAL_URL?.trim();
-  const cellId = process.env.OTIUM_CELL_ID?.trim();
-  const secret = process.env.OTIUM_CELL_SECRET?.trim();
-  const relay = process.env.OTIUM_RELAY_URL?.trim();
-  if (central && cellId && secret) {
-    try {
-      return normalizeJoin({ central, relay, cellId, secret });
-    } catch (err2) {
-      logger.warn({ err: err2 }, "otium: invalid OTIUM_CENTRAL_URL/OTIUM_CELL_ID/OTIUM_CELL_SECRET env");
-      return null;
-    }
-  }
-  if (central || cellId || secret) {
-    logger.warn("otium: OTIUM_CENTRAL_URL, OTIUM_CELL_ID, OTIUM_CELL_SECRET must be set together \u2014 ignoring partial env");
-  }
-  const path = joinFilePath();
-  if (!existsSync36(path))
-    return null;
-  try {
-    const parsed = JSON.parse(readFileSync28(path, "utf-8"));
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
-      return null;
-    return normalizeJoin(parsed);
-  } catch (err2) {
-    logger.warn({ err: err2, path }, "otium: failed to read join file");
-    return null;
-  }
-}
-var JOIN_LOCK_STALE_MS = 30000;
-var init_join = __esm(async () => {
-  await init_src();
-});
-
-// ../../packages/core/src/config-public.ts
-var init_config_public = __esm(() => {
-  init_config();
-});
-
-// ../../adapters/otium/src/join-status.ts
-var exports_join_status = {};
-__export(exports_join_status, {
-  hasConfiguredOtiumJoin: () => hasConfiguredOtiumJoin
-});
-import { existsSync as existsSync37 } from "fs";
-import { resolve as resolve24 } from "path";
-function hasConfiguredOtiumJoin() {
-  const envJoin = Boolean(process.env.OTIUM_CENTRAL_URL?.trim() && process.env.OTIUM_CELL_ID?.trim() && process.env.OTIUM_CELL_SECRET?.trim());
-  return envJoin || existsSync37(resolve24(DATA_DIR, "otium-join.json"));
-}
-var init_join_status = __esm(() => {
-  init_config_public();
-});
-
-// ../../adapters/otium/src/control-protocol.ts
-var OTIUM_ADAPTER_CONTROL_PREFIX = "/api/v1/adapter/otium", OTIUM_ADAPTER_CONTROL_HEADER = "x-negotium-adapter-token";
-
 // ../../adapters/otium/src/protocol.ts
-function str(body, field) {
-  const value = body[field];
-  return typeof value === "string" && value.trim() ? value : null;
-}
-function parseExecutionSpec(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value))
-    return null;
-  const raw = value;
-  const agent = str(raw, "agent");
-  const model = str(raw, "model");
-  const effort = str(raw, "effort");
-  const rawMcp = raw.mcp;
-  if (!agent || !model || !effort || !Array.isArray(rawMcp) || !rawMcp.every((entry) => typeof entry === "string" && entry.trim().length > 0) || typeof raw.canSpawnSubagents !== "boolean") {
-    return null;
-  }
-  return {
-    agent,
-    model,
-    effort,
-    ...str(raw, "description") ? { description: str(raw, "description") } : {},
-    mcp: [...new Set(rawMcp.map((entry) => entry.trim()))],
-    canSpawnSubagents: raw.canSpawnSubagents
-  };
-}
-var PEER_PROTOCOL_VERSION = 1, MAX_PEER_MESSAGE_LENGTH = 1e4, MAX_PEER_INPUT_FILE_BYTES, MAX_PEER_INPUT_REQUEST_BYTES;
+var PEER_PROTOCOL_VERSION = 1, MAX_PEER_MESSAGE_LENGTH = 1e4, MAX_PEER_REQUEST_BODY_BYTES;
 var init_protocol = __esm(() => {
-  MAX_PEER_INPUT_FILE_BYTES = 2 * 1024 * 1024 * 1024;
-  MAX_PEER_INPUT_REQUEST_BYTES = MAX_PEER_INPUT_FILE_BYTES + 8 * 1024 * 1024;
+  MAX_PEER_REQUEST_BODY_BYTES = 2 * 1024 * 1024 * 1024 + 8 * 1024 * 1024;
 });
 
 // ../../adapters/otium/src/canonical-mcp-bridge.ts
-import { randomUUID as randomUUID28 } from "crypto";
+import { randomUUID as randomUUID27 } from "crypto";
 function readAuthorization(request) {
   const value = request.headers.get("authorization");
   return value?.startsWith("Bearer ") ? value.slice(7) : null;
@@ -42107,7 +41735,7 @@ function startCanonicalMcpBridge(options = {}) {
   const url = `http://127.0.0.1:${server.port}/`;
   const unregister = registerCanonicalMcpBridgeEnvProvider((scope) => {
     sweep();
-    const token = `${randomUUID28()}${randomUUID28()}`;
+    const token = `${randomUUID27()}${randomUUID27()}`;
     capabilities.set(token, {
       surface: scope.surface,
       userId: scope.userId,
@@ -42159,736 +41787,360 @@ var init_canonical_mcp_bridge = __esm(async () => {
   };
 });
 
-// ../../adapters/otium/src/store.ts
-import { createHash as createHash12 } from "crypto";
-function isPeerDetached(hubNodeId) {
-  const row = db.query("SELECT status FROM otium_peer_lifecycle WHERE hub_node_id = ?").get(hubNodeId);
-  return row?.status === "detached";
-}
-function enqueueSharedMessage(args) {
-  db.run(`INSERT OR REPLACE INTO otium_shared_message_outbox
-       (local_topic_id, source_message_id, message_json, created_at)
-     VALUES (?, ?, ?, ?)`, [
-    args.localTopicId,
-    args.sourceMessageId,
-    JSON.stringify(args.message),
-    new Date().toISOString()
-  ]);
-}
-function listSharedMessages(localTopicId) {
-  return db.query("SELECT * FROM otium_shared_message_outbox WHERE local_topic_id = ? ORDER BY created_at").all(localTopicId);
-}
-function deleteSharedMessage(localTopicId, sourceMessageId) {
-  return db.run("DELETE FROM otium_shared_message_outbox WHERE local_topic_id = ? AND source_message_id = ?", [localTopicId, sourceMessageId]).changes === 1;
-}
-function getSharedTopicState(localTopicId) {
-  return db.query("SELECT * FROM otium_shared_topic_state WHERE local_topic_id = ?").get(localTopicId) ?? null;
-}
-function listSharedTopicStates() {
-  return db.query("SELECT * FROM otium_shared_topic_state ORDER BY updated_at").all();
-}
-function setSharedTopicState(args) {
-  db.run(`INSERT INTO otium_shared_topic_state (local_topic_id, host_topic_id, status, updated_at)
-     VALUES (?, ?, ?, ?)
-     ON CONFLICT(local_topic_id) DO UPDATE SET
-       host_topic_id = excluded.host_topic_id,
-       status = excluded.status,
-       updated_at = excluded.updated_at`, [args.localTopicId, args.hostTopicId ?? null, args.status, new Date().toISOString()]);
-}
-function deleteSharedTopicState(localTopicId) {
-  return db.run("DELETE FROM otium_shared_topic_state WHERE local_topic_id = ?", [localTopicId]).changes === 1;
-}
-function getPeerSession(hostNodeId, hostTopicId) {
-  return db.query("SELECT * FROM otium_peer_sessions WHERE host_node_id = ? AND host_topic_id = ?").get(hostNodeId, hostTopicId) ?? null;
-}
-function createPeerSession(hostNodeId, hostTopicId, localTopicId) {
-  const row = {
-    host_node_id: hostNodeId,
-    host_topic_id: hostTopicId,
-    local_topic_id: localTopicId,
-    binding_mode: "mirror",
-    created_at: new Date().toISOString()
-  };
-  db.run("INSERT INTO otium_peer_sessions (host_node_id, host_topic_id, local_topic_id, binding_mode, created_at) VALUES (?, ?, ?, ?, ?)", [row.host_node_id, row.host_topic_id, row.local_topic_id, row.binding_mode, row.created_at]);
-  return row;
-}
-function bindPeerSession(hostNodeId, hostTopicId, localTopicId, mode = "shared") {
-  const row = {
-    host_node_id: hostNodeId,
-    host_topic_id: hostTopicId,
-    local_topic_id: localTopicId,
-    binding_mode: mode,
-    created_at: new Date().toISOString()
-  };
-  db.run(`INSERT INTO otium_peer_sessions
-       (host_node_id, host_topic_id, local_topic_id, binding_mode, created_at)
-     VALUES (?, ?, ?, ?, ?)
-     ON CONFLICT(host_node_id, host_topic_id) DO UPDATE SET
-       local_topic_id = excluded.local_topic_id,
-       binding_mode = excluded.binding_mode,
-       created_at = excluded.created_at`, [hostNodeId, hostTopicId, localTopicId, mode, row.created_at]);
-  return row;
-}
-function unbindPeerSession(hostNodeId, hostTopicId) {
-  return db.run("DELETE FROM otium_peer_sessions WHERE host_node_id = ? AND host_topic_id = ?", [
-    hostNodeId,
-    hostTopicId
-  ]).changes === 1;
-}
-function unbindSharedPeerSessionsForLocalTopic(localTopicId) {
-  return db.run("DELETE FROM otium_peer_sessions WHERE local_topic_id = ? AND binding_mode = 'shared'", [localTopicId]).changes;
-}
-function downgradeSharedTopicsLocally(hubNodeId) {
-  return db.transaction(() => {
-    const topics = db.query("SELECT id FROM api_topics WHERE access_mode = 'shared'").all().map((row) => row.id);
-    db.run("UPDATE api_topics SET access_mode = 'private' WHERE access_mode = 'shared'");
-    db.run("DELETE FROM otium_peer_sessions WHERE host_node_id = ?", [hubNodeId]);
-    db.run("DELETE FROM otium_shared_message_outbox");
-    db.run("DELETE FROM otium_shared_topic_state");
-    db.run(`INSERT INTO otium_peer_lifecycle (hub_node_id, status, updated_at)
-       VALUES (?, 'detached', ?)
-       ON CONFLICT(hub_node_id) DO UPDATE SET status = 'detached', updated_at = excluded.updated_at`, [hubNodeId, new Date().toISOString()]);
-    return topics;
-  })();
-}
-function listPeerSessions() {
-  return db.query("SELECT * FROM otium_peer_sessions").all();
-}
-function cleanupPeerStateForLocalTopic(localTopicId) {
-  return db.transaction(() => {
-    const terminalOutbox = db.run(`DELETE FROM otium_peer_terminal_outbox
-       WHERE EXISTS (
-         SELECT 1 FROM otium_peer_turn_requests turn_request
-         JOIN otium_peer_sessions session
-           ON session.host_node_id = turn_request.host_node_id
-          AND session.host_topic_id = turn_request.host_topic_id
-         WHERE session.local_topic_id = ?
-           AND turn_request.host_node_id = otium_peer_terminal_outbox.host_node_id
-           AND turn_request.request_id = otium_peer_terminal_outbox.request_id
-       )`, [localTopicId]).changes;
-    const turns = db.run(`DELETE FROM otium_peer_turn_requests
-       WHERE EXISTS (
-         SELECT 1 FROM otium_peer_sessions session
-         WHERE session.local_topic_id = ?
-           AND session.host_node_id = otium_peer_turn_requests.host_node_id
-           AND session.host_topic_id = otium_peer_turn_requests.host_topic_id
-       )`, [localTopicId]).changes;
-    const inboxRequests = db.run("DELETE FROM otium_peer_inbox_requests WHERE topic_id = ?", [
-      localTopicId
-    ]).changes;
-    const remoteAsks = db.run("DELETE FROM otium_remote_asks WHERE caller_topic_id = ?", [
-      localTopicId
-    ]).changes;
-    const sessions = db.run("DELETE FROM otium_peer_sessions WHERE local_topic_id = ?", [
-      localTopicId
-    ]).changes;
-    return { sessions, turns, terminalOutbox, inboxRequests, remoteAsks };
-  })();
-}
-function sweepStalePeerBindings(topicExists) {
-  const stale = [
-    ...new Set(listPeerSessions().map((row) => row.local_topic_id).filter((localTopicId) => localTopicId && !topicExists(localTopicId)))
-  ];
-  const removed = {
-    sessions: 0,
-    turns: 0,
-    terminalOutbox: 0,
-    inboxRequests: 0,
-    remoteAsks: 0
-  };
-  for (const localTopicId of stale) {
-    const result = cleanupPeerStateForLocalTopic(localTopicId);
-    removed.sessions += result.sessions;
-    removed.turns += result.turns;
-    removed.terminalOutbox += result.terminalOutbox;
-    removed.inboxRequests += result.inboxRequests;
-    removed.remoteAsks += result.remoteAsks;
-  }
-  return { topicIds: stale, removed };
-}
-function failInterruptedPeerTurnRequestsOnStartup() {
-  return db.run(`UPDATE otium_peer_turn_requests
-     SET status = 'failed', error = 'worker restarted during turn', updated_at = ?
-     WHERE status IN ('claimed', 'running')
-       AND NOT EXISTS (
-         SELECT 1 FROM otium_peer_terminal_outbox terminal
-         WHERE terminal.host_node_id = otium_peer_turn_requests.host_node_id
-           AND terminal.request_id = otium_peer_turn_requests.request_id
-       )`, [new Date().toISOString()]).changes;
-}
-function claimPeerTurnRequest(hostNodeId, requestId, hostTopicId) {
-  const now = new Date().toISOString();
-  const inserted = db.run(`INSERT OR IGNORE INTO otium_peer_turn_requests
-       (host_node_id, request_id, host_topic_id, status, created_at, updated_at)
-     VALUES (?, ?, ?, 'claimed', ?, ?)`, [hostNodeId, requestId, hostTopicId, now, now]);
-  const row = getPeerTurnRequest(hostNodeId, requestId);
-  if (!row)
-    throw new Error("otium peer turn request claim disappeared");
-  return { claimed: inserted.changes === 1, row };
-}
-function getPeerTurnRequest(hostNodeId, requestId) {
-  return db.query("SELECT * FROM otium_peer_turn_requests WHERE host_node_id = ? AND request_id = ?").get(hostNodeId, requestId) ?? null;
-}
-function setPeerTurnRequestStatus(hostNodeId, requestId, status, error2 = null) {
-  db.run(`UPDATE otium_peer_turn_requests
-     SET status = ?, error = ?, updated_at = ?
-     WHERE host_node_id = ? AND request_id = ?`, [status, error2, new Date().toISOString(), hostNodeId, requestId]);
-}
-function markPeerTurnRequestRunning(hostNodeId, requestId) {
-  setPeerTurnRequestStatus(hostNodeId, requestId, "running");
-}
-function markPeerTurnRequestFinished(hostNodeId, requestId) {
-  setPeerTurnRequestStatus(hostNodeId, requestId, "finished");
-}
-function markPeerTurnRequestFailed(hostNodeId, requestId, error2) {
-  setPeerTurnRequestStatus(hostNodeId, requestId, "failed", error2);
-}
-function upsertPeerTerminalOutbox(args) {
-  const now = Date.now();
-  db.run(`INSERT INTO otium_peer_terminal_outbox
-       (host_node_id, request_id, seq, event_json, created_at, updated_at)
-     VALUES (?, ?, ?, ?, ?, ?)
-     ON CONFLICT(host_node_id, request_id) DO UPDATE SET
-       seq = excluded.seq, event_json = excluded.event_json, updated_at = excluded.updated_at`, [args.hostNodeId, args.requestId, args.seq, JSON.stringify(args.event), now, now]);
-}
-function listPeerTerminalOutbox(limit = 100) {
-  return db.query("SELECT * FROM otium_peer_terminal_outbox ORDER BY created_at LIMIT ?").all(limit);
-}
-function acknowledgePeerTerminal(hostNodeId, requestId) {
-  return db.transaction(() => {
-    const removed = db.run("DELETE FROM otium_peer_terminal_outbox WHERE host_node_id = ? AND request_id = ?", [hostNodeId, requestId]).changes;
-    if (removed !== 1)
-      return false;
-    markPeerTurnRequestFinished(hostNodeId, requestId);
+// ../../adapters/otium/src/secure-transport.ts
+function isLoopbackHostname(hostname2) {
+  const normalized = hostname2.toLowerCase();
+  if (normalized === "localhost" || normalized === "::1" || normalized === "[::1]")
     return true;
-  })();
+  const octets = normalized.split(".");
+  return octets.length === 4 && octets[0] === "127" && octets.every((octet) => /^\d{1,3}$/.test(octet) && Number(octet) <= 255);
 }
-function peerInboxPayloadHash(value) {
-  return createHash12("sha256").update(JSON.stringify(value)).digest("hex");
+function credentialTransportUrl(value, label) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error(`${label} is not a valid URL`);
+  }
+  if (url.username || url.password)
+    throw new Error(`${label} must not contain URL credentials`);
+  return url;
 }
-function claimPeerInboxRequest(args) {
-  const inserted = db.run(`INSERT OR IGNORE INTO otium_peer_inbox_requests
-       (from_cell_id, request_id, kind, topic_id, payload_hash, created_at)
-     VALUES (?, ?, ?, ?, ?, ?)`, [
-    args.fromCellId,
-    args.requestId,
-    args.kind,
-    args.topicId,
-    args.payloadHash,
-    new Date().toISOString()
-  ]);
-  if (inserted.changes === 1)
-    return { outcome: "claimed" };
-  const existing = db.query("SELECT payload_hash FROM otium_peer_inbox_requests WHERE from_cell_id = ? AND request_id = ? AND kind = ?").get(args.fromCellId, args.requestId, args.kind);
-  if (!existing)
-    return { outcome: "conflict" };
-  return { outcome: existing.payload_hash === args.payloadHash ? "replay" : "conflict" };
+function assertSecureCentralUrl(value) {
+  const url = credentialTransportUrl(value, "Otium central URL");
+  if (url.protocol === "https:")
+    return;
+  if (url.protocol === "http:" && isLoopbackHostname(url.hostname))
+    return;
+  throw new Error("Otium central requires HTTPS or loopback HTTP");
 }
-function releasePeerInboxRequest(fromCellId, requestId, kind) {
-  db.run("DELETE FROM otium_peer_inbox_requests WHERE from_cell_id = ? AND request_id = ? AND kind = ?", [fromCellId, requestId, kind]);
+function assertSecureRelayUrl(value) {
+  const url = credentialTransportUrl(value, "Otium relay URL");
+  if (url.protocol === "https:" || url.protocol === "wss:")
+    return;
+  if ((url.protocol === "http:" || url.protocol === "ws:") && isLoopbackHostname(url.hostname)) {
+    return;
+  }
+  throw new Error("Otium relay requires HTTPS/WSS or loopback HTTP/WS");
 }
-function createRemoteAsk(args) {
-  const result = db.run(`INSERT OR IGNORE INTO otium_remote_asks
-       (request_id, expected_cell_id, user_id, caller_topic_id, from_key, to_key,
-        source_query_id, created_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [
-    args.requestId,
-    args.expectedCellId,
-    args.userId,
-    args.callerTopicId,
-    args.from,
-    args.to,
-    args.sourceQueryId ?? null,
-    args.createdAt ?? Date.now()
-  ]);
-  return result.changes === 1;
+
+// ../../adapters/otium/src/join.ts
+var exports_join = {};
+__export(exports_join, {
+  withJoinCredentialLock: () => withJoinCredentialLock,
+  saveJoinWhileLocked: () => saveJoinWhileLocked,
+  saveJoin: () => saveJoin,
+  removeJoin: () => removeJoin,
+  parseInviteCode: () => parseInviteCode,
+  loadJoin: () => loadJoin,
+  joinFilePath: () => joinFilePath,
+  joinCredentialDigest: () => joinCredentialDigest,
+  isJoinPersisted: () => isJoinPersisted
+});
+import { createHash as createHash11, randomUUID as randomUUID28 } from "crypto";
+import {
+  chmodSync as chmodSync7,
+  closeSync as closeSync5,
+  existsSync as existsSync37,
+  fsyncSync as fsyncSync2,
+  linkSync,
+  lstatSync,
+  mkdirSync as mkdirSync32,
+  openSync as openSync5,
+  readFileSync as readFileSync28,
+  renameSync as renameSync16,
+  rmSync as rmSync10,
+  statSync as statSync20,
+  unlinkSync as unlinkSync23,
+  writeFileSync as writeFileSync23
+} from "fs";
+import { dirname as dirname21, resolve as resolve24 } from "path";
+function joinFilePath() {
+  return resolve24(DATA_DIR, "otium-join.json");
 }
-function getRemoteAsk(requestId) {
-  return db.query("SELECT * FROM otium_remote_asks WHERE request_id = ?").get(requestId) ?? null;
+function isHttpUrl(value) {
+  return /^https?:\/\//.test(value);
 }
-function deleteRemoteAsk(requestId) {
-  return db.run("DELETE FROM otium_remote_asks WHERE request_id = ?", [requestId]).changes === 1;
+function isRelayUrl(value) {
+  return /^(?:https?|wss?):\/\//.test(value);
 }
-function pruneRemoteAsks(olderThan) {
-  return db.run("DELETE FROM otium_remote_asks WHERE created_at < ?", [olderThan]).changes;
+function normalizeJoin(raw) {
+  const central = typeof raw.central === "string" ? raw.central.trim().replace(/\/+$/, "") : "";
+  const relay = typeof raw.relay === "string" ? raw.relay.trim().replace(/\/+$/, "") : "";
+  const cellId = typeof raw.cellId === "string" ? raw.cellId.trim() : "";
+  const secret = typeof raw.secret === "string" ? raw.secret.trim() : "";
+  if (!central || !isHttpUrl(central)) {
+    throw new Error("invite code is missing a valid http(s) central URL");
+  }
+  if (relay && !isRelayUrl(relay))
+    throw new Error("invite code has an invalid relay URL");
+  if (!cellId)
+    throw new Error("invite code is missing cellId");
+  if (!secret)
+    throw new Error("invite code is missing secret");
+  assertSecureCentralUrl(central);
+  if (relay)
+    assertSecureRelayUrl(relay);
+  return {
+    ...typeof raw.v === "number" ? { v: raw.v } : {},
+    central,
+    ...relay ? { relay } : {},
+    cellId,
+    secret
+  };
 }
-function upsertPeerReplyOutbox(args) {
-  const now = Date.now();
-  db.run(`INSERT INTO otium_peer_reply_outbox
-       (node_cell_id, request_id, node_name, topic_id, user_id, source_title,
-        reply_text, kind, created_at, updated_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-     ON CONFLICT(node_cell_id, request_id) DO UPDATE SET
-       node_name = excluded.node_name,
-       topic_id = excluded.topic_id,
-       user_id = excluded.user_id,
-       source_title = excluded.source_title,
-       reply_text = excluded.reply_text,
-       kind = excluded.kind,
-       updated_at = excluded.updated_at`, [
-    args.nodeCellId,
-    args.requestId,
-    args.nodeName,
-    args.topicId,
-    args.userId,
-    args.sourceTitle,
-    args.replyText,
-    args.kind,
-    now,
-    now
-  ]);
+function parseInviteCode(code) {
+  const trimmed = code.trim();
+  if (!trimmed)
+    throw new Error("invite code is empty");
+  let decoded;
+  try {
+    decoded = Buffer.from(trimmed, "base64url").toString("utf-8");
+  } catch {
+    throw new Error("invite code is not valid base64url");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(decoded);
+  } catch {
+    throw new Error("invite code does not decode to JSON");
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("invite code does not decode to a JSON object");
+  }
+  return normalizeJoin(parsed);
 }
-function listPeerReplyOutbox(limit = 100) {
-  return db.query("SELECT * FROM otium_peer_reply_outbox ORDER BY created_at LIMIT ?").all(limit);
+function joinLockPath() {
+  return resolve24(DATA_DIR, ".otium-join.lock");
 }
-function deletePeerReplyOutbox(nodeCellId, requestId) {
-  return db.run("DELETE FROM otium_peer_reply_outbox WHERE node_cell_id = ? AND request_id = ?", [
-    nodeCellId,
-    requestId
-  ]).changes === 1;
+function processIsAlive(pid) {
+  if (!Number.isSafeInteger(pid) || pid <= 0)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error2) {
+    return error2.code !== "ESRCH";
+  }
 }
-var peerSessionColumns;
-var init_store2 = __esm(async () => {
-  await init_src();
-  db.exec(`
-  CREATE TABLE IF NOT EXISTS otium_peer_sessions (
-    host_node_id    TEXT NOT NULL,
-    host_topic_id   TEXT NOT NULL,
-    local_topic_id  TEXT NOT NULL,
-    binding_mode    TEXT NOT NULL DEFAULT 'mirror',
-    created_at      TEXT NOT NULL,
-    PRIMARY KEY (host_node_id, host_topic_id)
-  )
-`);
-  peerSessionColumns = new Set(db.query("PRAGMA table_info(otium_peer_sessions)").all().map((row) => row.name));
-  if (!peerSessionColumns.has("binding_mode")) {
-    db.exec("ALTER TABLE otium_peer_sessions ADD COLUMN binding_mode TEXT NOT NULL DEFAULT 'mirror'");
-  }
-  db.run(`UPDATE api_topics
-   SET visibility = 'visible', access_mode = 'shared', is_subagent = 0
-   WHERE id IN (
-     SELECT local_topic_id FROM otium_peer_sessions WHERE binding_mode = 'mirror'
-   )`);
-  db.run(`UPDATE api_topics
-   SET access_mode = 'shared'
-   WHERE id IN (SELECT local_topic_id FROM otium_peer_sessions)`);
-  db.exec(`
-  CREATE TABLE IF NOT EXISTS otium_peer_turn_requests (
-    host_node_id   TEXT NOT NULL,
-    request_id     TEXT NOT NULL,
-    host_topic_id  TEXT NOT NULL,
-    status         TEXT NOT NULL CHECK (status IN
-                   ('claimed', 'running', 'finished', 'failed')),
-    error          TEXT,
-    created_at     TEXT NOT NULL,
-    updated_at     TEXT NOT NULL,
-    PRIMARY KEY (host_node_id, request_id)
-  )
-`);
-  db.exec(`
-  CREATE TABLE IF NOT EXISTS otium_peer_terminal_outbox (
-    host_node_id  TEXT NOT NULL,
-    request_id    TEXT NOT NULL,
-    seq           INTEGER NOT NULL,
-    event_json    TEXT NOT NULL,
-    created_at    INTEGER NOT NULL,
-    updated_at    INTEGER NOT NULL,
-    PRIMARY KEY (host_node_id, request_id)
-  )
-`);
-  db.exec(`
-  CREATE TABLE IF NOT EXISTS otium_peer_inbox_requests (
-    from_cell_id  TEXT NOT NULL,
-    request_id    TEXT NOT NULL,
-    kind          TEXT NOT NULL CHECK (kind IN ('tell', 'ask')),
-    topic_id      TEXT NOT NULL,
-    payload_hash  TEXT NOT NULL,
-    created_at    TEXT NOT NULL,
-    PRIMARY KEY (from_cell_id, request_id, kind)
-  )
-`);
-  db.exec(`
-  CREATE TABLE IF NOT EXISTS otium_remote_asks (
-    request_id       TEXT PRIMARY KEY,
-    expected_cell_id TEXT NOT NULL,
-    user_id          TEXT NOT NULL,
-    caller_topic_id  TEXT NOT NULL,
-    from_key         TEXT NOT NULL,
-    to_key           TEXT NOT NULL,
-    source_query_id  TEXT,
-    created_at       INTEGER NOT NULL
-  )
-`);
-  db.exec(`
-  CREATE INDEX IF NOT EXISTS idx_otium_remote_asks_created
-  ON otium_remote_asks(created_at)
-`);
-  db.exec(`
-  CREATE TABLE IF NOT EXISTS otium_peer_reply_outbox (
-    node_cell_id TEXT NOT NULL,
-    request_id   TEXT NOT NULL,
-    node_name    TEXT NOT NULL,
-    topic_id     TEXT NOT NULL,
-    user_id      TEXT NOT NULL,
-    source_title TEXT NOT NULL,
-    reply_text   TEXT NOT NULL,
-    kind         TEXT NOT NULL CHECK (kind IN ('reply', 'error')),
-    created_at   INTEGER NOT NULL,
-    updated_at   INTEGER NOT NULL,
-    PRIMARY KEY (node_cell_id, request_id)
-  )
-`);
-  db.exec(`
-  CREATE TABLE IF NOT EXISTS otium_shared_topic_state (
-    local_topic_id TEXT PRIMARY KEY,
-    host_topic_id  TEXT,
-    status         TEXT NOT NULL CHECK (status IN ('publishing', 'published', 'unpublishing')),
-    updated_at     TEXT NOT NULL
-  )
-`);
-  db.exec(`
-  CREATE TABLE IF NOT EXISTS otium_shared_message_outbox (
-    local_topic_id TEXT NOT NULL,
-    source_message_id TEXT NOT NULL,
-    message_json TEXT NOT NULL,
-    created_at TEXT NOT NULL,
-    PRIMARY KEY (local_topic_id, source_message_id)
-  )
-`);
-  db.exec(`
-  CREATE TABLE IF NOT EXISTS otium_peer_lifecycle (
-    hub_node_id TEXT PRIMARY KEY,
-    status TEXT NOT NULL CHECK (status IN ('attached', 'detached')),
-    updated_at TEXT NOT NULL
-  )
-`);
-});
-
-// ../../adapters/otium/src/event-backflow.ts
-function hubEventSender(hubNode) {
-  return async (payload) => {
-    let token;
+function withJoinCredentialLock(operation) {
+  const lockPath = joinLockPath();
+  const ownerPath = resolve24(lockPath, "owner.json");
+  const owner = { pid: process.pid, token: randomUUID28() };
+  mkdirSync32(dirname21(lockPath), { recursive: true });
+  for (let attempt = 0;; attempt += 1) {
+    let created = false;
     try {
-      token = await mintPeerToken(hubNode.cellId);
-    } catch (err2) {
-      return { ok: false, error: `peer token mint failed: ${err2.message}` };
+      mkdirSync32(lockPath, { mode: 448 });
+      created = true;
+      writeFileSync23(ownerPath, `${JSON.stringify(owner)}
+`, { mode: 384 });
+      const ownerFd = openSync5(ownerPath, "r");
+      try {
+        fsyncSync2(ownerFd);
+      } finally {
+        closeSync5(ownerFd);
+      }
+      break;
+    } catch (error2) {
+      if (created) {
+        rmSync10(lockPath, { recursive: true, force: true });
+        throw error2;
+      }
+      if (error2.code !== "EEXIST")
+        throw error2;
+      let current3 = null;
+      try {
+        current3 = JSON.parse(readFileSync28(ownerPath, "utf8"));
+      } catch {}
+      let ageMs;
+      try {
+        ageMs = Date.now() - statSync20(lockPath).mtimeMs;
+      } catch (statError) {
+        if (statError.code === "ENOENT")
+          continue;
+        throw statError;
+      }
+      if (current3 && processIsAlive(current3.pid) || !current3 && ageMs <= JOIN_LOCK_STALE_MS) {
+        throw new Error(`another Otium join credential operation is in progress at ${lockPath}`);
+      }
+      if (attempt > 0) {
+        throw new Error(`could not recover stale Otium join credential lock at ${lockPath}`);
+      }
+      const stalePath = `${lockPath}.stale.${process.pid}.${randomUUID28()}`;
+      try {
+        renameSync16(lockPath, stalePath);
+        rmSync10(stalePath, { recursive: true, force: true });
+      } catch (staleError) {
+        if (staleError.code !== "ENOENT")
+          throw staleError;
+      }
     }
-    let response;
+  }
+  try {
+    return operation();
+  } finally {
     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;
+      const current3 = JSON.parse(readFileSync28(ownerPath, "utf8"));
+      if (current3.pid === owner.pid && current3.token === owner.token) {
+        rmSync10(lockPath, { recursive: true, force: true });
+      }
+    } catch {}
   }
-  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")
+function joinsEqual(left, right) {
+  return left.central === right.central && left.relay === right.relay && left.cellId === right.cellId && left.secret === right.secret;
+}
+function normalizedJoin(join42) {
+  return normalizeJoin({
+    v: join42.v,
+    central: join42.central,
+    relay: join42.relay,
+    cellId: join42.cellId,
+    secret: join42.secret
+  });
+}
+function joinCredentialDigest(join42) {
+  return createHash11("sha256").update(JSON.stringify(normalizedJoin(join42))).digest("base64url");
+}
+function readPersistedJoin(path = joinFilePath()) {
+  if (!existsSync37(path))
     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,
-        isError: status.isError
-      });
-    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;
+  const parsed = JSON.parse(readFileSync28(path, "utf-8"));
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("persisted join credentials are not a JSON object");
   }
+  return normalizeJoin(parsed);
 }
-function getActiveForwarder(localTopicId) {
-  return activeForwarders.get(localTopicId);
+function isJoinPersisted(join42) {
+  try {
+    const persisted = readPersistedJoin();
+    return persisted !== null && joinsEqual(persisted, normalizedJoin(join42));
+  } catch {
+    return false;
+  }
 }
-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 () => {
+function saveJoinWhileLocked(join42, options = {}) {
+  const path = joinFilePath();
+  const directory = dirname21(path);
+  const normalized = normalizedJoin(join42);
+  mkdirSync32(directory, { recursive: true });
+  if (existsSync37(path)) {
+    if (lstatSync(path).isSymbolicLink()) {
+      throw new Error(`refusing to replace symlinked Otium join file at ${path}`);
+    }
+    let existing = null;
+    try {
+      existing = readPersistedJoin(path);
+    } catch (error2) {
+      if (!options.replaceExisting) {
+        throw new Error(`existing Otium join file at ${path} is invalid; pass --replace to replace it`, { cause: error2 });
+      }
+    }
+    if (existing && joinsEqual(existing, normalized)) {
+      chmodSync7(path, 384);
+      const fileFd = openSync5(path, "r");
       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((resolve25) => setTimeout(resolve25, delayMs));
-          }
-        }
-        forwarder.deliveryBlocked = true;
-        logger.error({ requestId, seq, type: event.type }, "otium: peer event delivery exhausted");
+        fsyncSync2(fileFd);
       } 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;
+        closeSync5(fileFd);
       }
-    } else if (type !== "typing") {
-      const queryId = raw.queryId;
-      if (forwarder.queryId && typeof queryId === "string" && queryId !== forwarder.queryId) {
-        return;
+      const directoryFd = openSync5(directory, "r");
+      try {
+        fsyncSync2(directoryFd);
+      } finally {
+        closeSync5(directoryFd);
       }
+      return path;
     }
-    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;
+    if (!options.replaceExisting) {
+      throw new Error(`this node is already joined${existing ? ` as ${existing.cellId}` : " with an invalid join file"}; pass --replace to replace its credentials`);
     }
-    post(raw);
-    if (isTerminal)
-      detach();
-  };
-  forwarder.finish = (event) => {
-    if (forwarder.finished)
-      return;
-    post(event);
-    detach();
-  };
-  return forwarder;
+  }
+  const temporaryPath = resolve24(directory, `.otium-join.json.${process.pid}.${randomUUID28()}.tmp`);
+  let fd;
+  try {
+    fd = openSync5(temporaryPath, "wx", 384);
+    writeFileSync23(fd, `${JSON.stringify(normalized, null, 2)}
+`, "utf8");
+    fsyncSync2(fd);
+    closeSync5(fd);
+    fd = undefined;
+    if (options.replaceExisting) {
+      renameSync16(temporaryPath, path);
+    } else {
+      linkSync(temporaryPath, path);
+      unlinkSync23(temporaryPath);
+    }
+    chmodSync7(path, 384);
+    const directoryFd = openSync5(directory, "r");
+    try {
+      fsyncSync2(directoryFd);
+    } finally {
+      closeSync5(directoryFd);
+    }
+  } catch (error2) {
+    if (fd !== undefined)
+      closeSync5(fd);
+    if (existsSync37(temporaryPath))
+      unlinkSync23(temporaryPath);
+    throw error2;
+  }
+  return path;
 }
-function registerTurnForwarder(localTopicId, forwarder) {
-  activeForwarders.set(localTopicId, forwarder);
-  ensureBackflowSubscription();
+function saveJoin(join42, options = {}) {
+  return withJoinCredentialLock(() => saveJoinWhileLocked(join42, options));
 }
-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;
+function removeJoin() {
+  return withJoinCredentialLock(() => {
+    const path = joinFilePath();
+    if (!existsSync37(path))
+      return false;
+    if (lstatSync(path).isSymbolicLink()) {
+      throw new Error(`refusing to remove symlinked Otium join file at ${path}`);
     }
-    return acknowledged;
-  } finally {
-    terminalOutboxFlushInFlight = false;
+    unlinkSync23(path);
+    const directoryFd = openSync5(dirname21(path), "r");
+    try {
+      fsyncSync2(directoryFd);
+    } finally {
+      closeSync5(directoryFd);
+    }
+    return true;
+  });
+}
+function loadJoin() {
+  const central = process.env.OTIUM_CENTRAL_URL?.trim();
+  const cellId = process.env.OTIUM_CELL_ID?.trim();
+  const secret = process.env.OTIUM_CELL_SECRET?.trim();
+  const relay = process.env.OTIUM_RELAY_URL?.trim();
+  if (central && cellId && secret) {
+    try {
+      return normalizeJoin({ central, relay, cellId, secret });
+    } catch (err2) {
+      logger.warn({ err: err2 }, "otium: invalid OTIUM_CENTRAL_URL/OTIUM_CELL_ID/OTIUM_CELL_SECRET env");
+      return null;
+    }
+  }
+  if (central || cellId || secret) {
+    logger.warn("otium: OTIUM_CENTRAL_URL, OTIUM_CELL_ID, OTIUM_CELL_SECRET must be set together \u2014 ignoring partial env");
+  }
+  const path = joinFilePath();
+  if (!existsSync37(path))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync28(path, "utf-8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+      return null;
+    return normalizeJoin(parsed);
+  } catch (err2) {
+    logger.warn({ err: err2, path }, "otium: failed to read join file");
+    return null;
   }
 }
-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();
-}
-var FORWARDED_TYPES, TERMINAL_TYPES, PEER_EVENT_MAX_ATTEMPTS = 5, PEER_EVENT_RETRY_BASE_MS = 100, PEER_EVENT_TIMEOUT_MS = 15000, PEER_EVENT_MAX_PENDING = 256, activeForwarders, unsubscribe = null, terminalOutboxTimer = null, terminalOutboxFlushInFlight = false;
-var init_event_backflow = __esm(async () => {
+var JOIN_LOCK_STALE_MS = 30000;
+var init_join = __esm(async () => {
   await init_src();
-  await init_central();
-  init_protocol();
-  await init_store2();
-  FORWARDED_TYPES = new Set([
-    "message",
-    "message_updated",
-    "typing",
-    "tool_call",
-    "tool_output",
-    "tool_status",
-    "visual",
-    "file_ready",
-    "ai_done",
-    "ai_error",
-    "ai_aborted"
-  ]);
-  TERMINAL_TYPES = new Set(["ai_done", "ai_error", "ai_aborted"]);
-  activeForwarders = new Map;
 });
 
 // ../../adapters/otium/src/peer-files.ts
@@ -42915,10 +42167,6 @@ function attachment(row) {
 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 = basename13(filename).replace(/[^A-Za-z0-9._ -]/g, "_").slice(0, 120);
   return value || "upload";
@@ -42974,21 +42222,6 @@ function deletePeerFilesForTopic(topicId) {
   for (const row of rows)
     rmSync11(row.path, { force: true });
 }
-async function storePeerInputFile(file, access) {
-  const id = randomUUID29();
-  mkdirSync33(PEER_FILES_DIR, { recursive: true });
-  const filename = file.name || "upload";
-  const path = join42(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 = {
@@ -43052,15 +42285,7 @@ var PEER_BRIDGE_TIMEOUT_MS2 = 15000, otiumPeerRuntimeBridge;
 var init_runtime_bridge = __esm(async () => {
   await init_src();
   await init_central();
-  await init_event_backflow();
   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)
@@ -43280,6 +42505,149 @@ var init_runtime_bridge = __esm(async () => {
   };
 });
 
+// ../../adapters/otium/src/store.ts
+import { createHash as createHash12 } from "crypto";
+function cleanupPeerStateForLocalTopic(localTopicId) {
+  return db.transaction(() => {
+    const inboxRequests = db.run("DELETE FROM otium_peer_inbox_requests WHERE topic_id = ?", [
+      localTopicId
+    ]).changes;
+    const remoteAsks = db.run("DELETE FROM otium_remote_asks WHERE caller_topic_id = ?", [
+      localTopicId
+    ]).changes;
+    return { inboxRequests, remoteAsks };
+  })();
+}
+function peerInboxPayloadHash(value) {
+  return createHash12("sha256").update(JSON.stringify(value)).digest("hex");
+}
+function claimPeerInboxRequest(args) {
+  const inserted = db.run(`INSERT OR IGNORE INTO otium_peer_inbox_requests
+       (from_cell_id, request_id, kind, topic_id, payload_hash, created_at)
+     VALUES (?, ?, ?, ?, ?, ?)`, [
+    args.fromCellId,
+    args.requestId,
+    args.kind,
+    args.topicId,
+    args.payloadHash,
+    new Date().toISOString()
+  ]);
+  if (inserted.changes === 1)
+    return { outcome: "claimed" };
+  const existing = db.query("SELECT payload_hash FROM otium_peer_inbox_requests WHERE from_cell_id = ? AND request_id = ? AND kind = ?").get(args.fromCellId, args.requestId, args.kind);
+  if (!existing)
+    return { outcome: "conflict" };
+  return { outcome: existing.payload_hash === args.payloadHash ? "replay" : "conflict" };
+}
+function releasePeerInboxRequest(fromCellId, requestId, kind) {
+  db.run("DELETE FROM otium_peer_inbox_requests WHERE from_cell_id = ? AND request_id = ? AND kind = ?", [fromCellId, requestId, kind]);
+}
+function createRemoteAsk(args) {
+  const result = db.run(`INSERT OR IGNORE INTO otium_remote_asks
+       (request_id, expected_cell_id, user_id, caller_topic_id, from_key, to_key,
+        source_query_id, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [
+    args.requestId,
+    args.expectedCellId,
+    args.userId,
+    args.callerTopicId,
+    args.from,
+    args.to,
+    args.sourceQueryId ?? null,
+    args.createdAt ?? Date.now()
+  ]);
+  return result.changes === 1;
+}
+function getRemoteAsk(requestId) {
+  return db.query("SELECT * FROM otium_remote_asks WHERE request_id = ?").get(requestId) ?? null;
+}
+function deleteRemoteAsk(requestId) {
+  return db.run("DELETE FROM otium_remote_asks WHERE request_id = ?", [requestId]).changes === 1;
+}
+function pruneRemoteAsks(olderThan) {
+  return db.run("DELETE FROM otium_remote_asks WHERE created_at < ?", [olderThan]).changes;
+}
+function upsertPeerReplyOutbox(args) {
+  const now = Date.now();
+  db.run(`INSERT INTO otium_peer_reply_outbox
+       (node_cell_id, request_id, node_name, topic_id, user_id, source_title,
+        reply_text, kind, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(node_cell_id, request_id) DO UPDATE SET
+       node_name = excluded.node_name,
+       topic_id = excluded.topic_id,
+       user_id = excluded.user_id,
+       source_title = excluded.source_title,
+       reply_text = excluded.reply_text,
+       kind = excluded.kind,
+       updated_at = excluded.updated_at`, [
+    args.nodeCellId,
+    args.requestId,
+    args.nodeName,
+    args.topicId,
+    args.userId,
+    args.sourceTitle,
+    args.replyText,
+    args.kind,
+    now,
+    now
+  ]);
+}
+function listPeerReplyOutbox(limit = 100) {
+  return db.query("SELECT * FROM otium_peer_reply_outbox ORDER BY created_at LIMIT ?").all(limit);
+}
+function deletePeerReplyOutbox(nodeCellId, requestId) {
+  return db.run("DELETE FROM otium_peer_reply_outbox WHERE node_cell_id = ? AND request_id = ?", [
+    nodeCellId,
+    requestId
+  ]).changes === 1;
+}
+var init_store2 = __esm(async () => {
+  await init_src();
+  db.exec(`
+  CREATE TABLE IF NOT EXISTS otium_peer_inbox_requests (
+    from_cell_id  TEXT NOT NULL,
+    request_id    TEXT NOT NULL,
+    kind          TEXT NOT NULL CHECK (kind IN ('tell', 'ask')),
+    topic_id      TEXT NOT NULL,
+    payload_hash  TEXT NOT NULL,
+    created_at    TEXT NOT NULL,
+    PRIMARY KEY (from_cell_id, request_id, kind)
+  )
+`);
+  db.exec(`
+  CREATE TABLE IF NOT EXISTS otium_remote_asks (
+    request_id       TEXT PRIMARY KEY,
+    expected_cell_id TEXT NOT NULL,
+    user_id          TEXT NOT NULL,
+    caller_topic_id  TEXT NOT NULL,
+    from_key         TEXT NOT NULL,
+    to_key           TEXT NOT NULL,
+    source_query_id  TEXT,
+    created_at       INTEGER NOT NULL
+  )
+`);
+  db.exec(`
+  CREATE INDEX IF NOT EXISTS idx_otium_remote_asks_created
+  ON otium_remote_asks(created_at)
+`);
+  db.exec(`
+  CREATE TABLE IF NOT EXISTS otium_peer_reply_outbox (
+    node_cell_id TEXT NOT NULL,
+    request_id   TEXT NOT NULL,
+    node_name    TEXT NOT NULL,
+    topic_id     TEXT NOT NULL,
+    user_id      TEXT NOT NULL,
+    source_title TEXT NOT NULL,
+    reply_text   TEXT NOT NULL,
+    kind         TEXT NOT NULL CHECK (kind IN ('reply', 'error')),
+    created_at   INTEGER NOT NULL,
+    updated_at   INTEGER NOT NULL,
+    PRIMARY KEY (node_cell_id, request_id)
+  )
+`);
+});
+
 // ../../adapters/otium/src/session-bridge.ts
 function prunePendingRemoteAsks(now = Date.now()) {
   pruneRemoteAsks(now - PENDING_ASK_TTL_MS2);
@@ -43671,287 +43039,6 @@ var init_session_bridge_ipc = __esm(() => {
   MAX_BODY_BYTES2 = 1024 * 1024;
 });
 
-// ../../adapters/otium/src/shared-topic-sync.ts
-var exports_shared_topic_sync = {};
-__export(exports_shared_topic_sync, {
-  startSharedTopicSync: () => startSharedTopicSync,
-  forwardSharedTopicMessage: () => forwardSharedTopicMessage,
-  downgradeSharedTopicsForHub: () => downgradeSharedTopicsForHub,
-  disconnectSharedTopics: () => disconnectSharedTopics,
-  checkPeerAttachment: () => checkPeerAttachment,
-  acceptSharedTopicMessages: () => acceptSharedTopicMessages
-});
-function isMirrorTopic(topicId) {
-  return listPeerSessions().some((row) => row.local_topic_id === topicId && row.binding_mode === "mirror");
-}
-function metadata(topic) {
-  if (!topic.agent)
-    throw new Error(`topic ${topic.id} has no executable agent`);
-  const registry = getRegistry(topic.agent);
-  return {
-    localTopicId: topic.id,
-    title: topic.title,
-    ...topic.description ? { description: topic.description } : {},
-    agent: topic.agent,
-    model: topic.defaultModel || registry.defaultModel,
-    effort: topic.defaultEffort ?? "medium"
-  };
-}
-async function peerRequest(node, path, init) {
-  const token = await mintPeerToken(node.cellId);
-  const response = await fetch(`${node.baseUrl.replace(/\/+$/, "")}${path}`, {
-    ...init,
-    headers: {
-      authorization: `Bearer ${token}`,
-      "content-type": "application/json",
-      ...init.headers ?? {}
-    },
-    signal: AbortSignal.timeout(15000)
-  });
-  const body = await response.json().catch(() => null);
-  if (!response.ok || !body?.ok)
-    throw new Error(String(body?.error ?? `peer request failed (${response.status})`));
-  return body;
-}
-function messageEnvelope(message) {
-  const author = message.agentType ? "ai" : message.kind === "system" || message.kind === "tool" ? "system" : "user";
-  return {
-    sourceMessageId: message.sourceMessageId ?? message.id,
-    author,
-    text: message.text,
-    createdAt: message.createdAt,
-    ...message.agentType ? { agent: message.agentType } : {},
-    ...message.model ? { model: message.model } : {},
-    ...message.kind ? { kind: message.kind } : {}
-  };
-}
-async function publishTopic(join43, topicId, node) {
-  const topic = getTopic(topicId);
-  if (!topic || topic.kind !== "agent" || !topic.agent || !isTopicShared(topic) || !topic.visibility || topic.visibility === "hidden" || isMirrorTopic(topicId))
-    return;
-  const state2 = getSharedTopicState(topicId);
-  setSharedTopicState({
-    localTopicId: topicId,
-    hostTopicId: state2?.host_topic_id,
-    status: "publishing"
-  });
-  try {
-    const body = await peerRequest(node, "/api/v1/peer/shared-topic", {
-      method: "POST",
-      body: JSON.stringify({
-        v: PEER_PROTOCOL_VERSION,
-        ...metadata(topic)
-      })
-    });
-    const hostTopicId = typeof body.hostTopicId === "string" ? body.hostTopicId : state2?.host_topic_id;
-    if (!hostTopicId)
-      throw new Error("shared-topic response omitted hostTopicId");
-    setSharedTopicState({ localTopicId: topicId, hostTopicId, status: "published" });
-    const messages = listApiMessages(topicId, { limit: 200 }).page.filter((message) => !message.sourceNode).map(messageEnvelope);
-    if (messages.length) {
-      await peerRequest(node, "/api/v1/peer/shared-topic/messages", {
-        method: "POST",
-        body: JSON.stringify({
-          v: PEER_PROTOCOL_VERSION,
-          localTopicId: topicId,
-          hostTopicId,
-          messages
-        })
-      });
-    }
-    for (const row of listSharedMessages(topicId)) {
-      await peerRequest(node, "/api/v1/peer/shared-topic/messages", {
-        method: "POST",
-        body: JSON.stringify({
-          v: PEER_PROTOCOL_VERSION,
-          localTopicId: topicId,
-          hostTopicId,
-          messages: [JSON.parse(row.message_json)]
-        })
-      });
-      deleteSharedMessage(topicId, row.source_message_id);
-    }
-  } catch (error2) {
-    logger.warn({ error: error2, topicId }, "otium: shared topic publish deferred");
-    setTimeout(() => void reconcileTopic(join43, topicId), RETRY_MS).unref?.();
-  }
-}
-async function unpublishTopic(join43, topicId, node) {
-  const state2 = getSharedTopicState(topicId);
-  if (!state2)
-    return;
-  setSharedTopicState({
-    localTopicId: topicId,
-    hostTopicId: state2.host_topic_id,
-    status: "unpublishing"
-  });
-  try {
-    await peerRequest(node, `/api/v1/peer/shared-topic/${encodeURIComponent(topicId)}`, {
-      method: "DELETE"
-    });
-    deleteSharedTopicState(topicId);
-  } catch (error2) {
-    logger.warn({ error: error2, topicId }, "otium: shared topic unpublish deferred");
-    setTimeout(() => void reconcileTopic(join43, topicId), RETRY_MS).unref?.();
-  }
-}
-async function reconcileTopic(join43, topicId, explicit = false) {
-  if (!otiumCentralConfig())
-    return;
-  if (!explicit && isPeerDetached(join43.cellId))
-    return;
-  const target = (await listPeerNodes()).find((node) => node.isPrimary) ?? null;
-  if (!target)
-    return;
-  const topic = getTopic(topicId);
-  if (topic?.kind === "agent" && topic.agent && isTopicShared(topic) && topic.visibility !== "hidden" && !isMirrorTopic(topicId))
-    return publishTopic(join43, topicId, target);
-  return unpublishTopic(join43, topicId, target);
-}
-function disconnectSharedTopics(join43) {
-  const states = listSharedTopicStates();
-  const hubPromise = listPeerNodes({ fresh: true }).then((nodes) => nodes.find((node) => node.isPrimary) ?? null, () => null);
-  const updated = downgradeSharedTopicsLocally(join43.cellId);
-  for (const topicId of updated)
-    WsHub.get().broadcastTopicUpdated(topicId);
-  const deletions = states.map(async (state2) => {
-    const hub = await hubPromise;
-    if (!hub)
-      return;
-    try {
-      await peerRequest(hub, `/api/v1/peer/shared-topic/${encodeURIComponent(state2.local_topic_id)}`, {
-        method: "DELETE"
-      });
-    } catch {}
-  });
-  return Promise.all(deletions).then(() => {
-    return;
-  });
-}
-function downgradeSharedTopicsForHub(hubNodeId) {
-  const updated = downgradeSharedTopicsLocally(hubNodeId);
-  for (const topicId of updated)
-    WsHub.get().broadcastTopicUpdated(topicId);
-  return updated.length;
-}
-async function checkPeerAttachment(join43) {
-  const nodes = await listPeerNodes({ fresh: true });
-  if (nodes.some((node) => node.cellId === join43.cellId))
-    return true;
-  downgradeSharedTopicsForHub(join43.cellId);
-  return false;
-}
-function startSharedTopicSync(join43) {
-  let stopped = false;
-  let detached = isPeerDetached(join43.cellId);
-  const queue = new Set;
-  const schedule = (topicId, explicit = false) => {
-    if (stopped || queue.has(topicId))
-      return;
-    queue.add(topicId);
-    queueMicrotask(async () => {
-      queue.delete(topicId);
-      try {
-        await reconcileTopic(join43, topicId, explicit);
-      } catch (error2) {
-        logger.warn({ error: error2, topicId }, "otium: shared topic reconciliation failed");
-      }
-    });
-  };
-  for (const topic of listTopics())
-    schedule(topic.id, false);
-  for (const state2 of listSharedTopicStates())
-    schedule(state2.local_topic_id);
-  const attachmentCheck = setInterval(async () => {
-    if (stopped || detached)
-      return;
-    try {
-      if (!await checkPeerAttachment(join43))
-        detached = true;
-    } catch {}
-  }, 30000);
-  attachmentCheck.unref?.();
-  const unsubscribe2 = runtimeBus().subscribe((event) => {
-    if (event.type === "topic-created" || event.type === "topic-updated" || event.type === "topic-deleted")
-      schedule(event.topicId, true);
-    if (event.type === "message") {
-      const message = event.payload;
-      if (!message.sourceNode) {
-        schedule(event.topicId);
-        forwardSharedTopicMessage(join43, message).catch((error2) => logger.warn({ error: error2, topicId: event.topicId }, "otium: shared message deferred"));
-      }
-    }
-  });
-  return () => {
-    stopped = true;
-    clearInterval(attachmentCheck);
-    unsubscribe2();
-  };
-}
-async function forwardSharedTopicMessage(_join, message) {
-  if (message.sourceNode || isMirrorTopic(message.topicId))
-    return;
-  if (getActiveForwarder(message.topicId))
-    return;
-  const state2 = getSharedTopicState(message.topicId);
-  if (!state2?.host_topic_id || state2.status !== "published")
-    return;
-  const hub = (await listPeerNodes()).find((node) => node.isPrimary) ?? null;
-  if (!hub)
-    return;
-  const envelope = messageEnvelope(message);
-  try {
-    await peerRequest(hub, "/api/v1/peer/shared-topic/messages", {
-      method: "POST",
-      body: JSON.stringify({
-        v: PEER_PROTOCOL_VERSION,
-        localTopicId: message.topicId,
-        hostTopicId: state2.host_topic_id,
-        messages: [envelope]
-      })
-    });
-  } catch (error2) {
-    enqueueSharedMessage({
-      localTopicId: message.topicId,
-      sourceMessageId: envelope.sourceMessageId,
-      message: envelope
-    });
-    throw error2;
-  }
-}
-function acceptSharedTopicMessages(messages, localTopicId, sourceNode) {
-  let inserted = 0;
-  for (const incoming of messages) {
-    if (!incoming.sourceMessageId || typeof incoming.text !== "string")
-      continue;
-    if (getApiMessage(localTopicId, incoming.sourceMessageId))
-      continue;
-    const message = {
-      id: incoming.sourceMessageId,
-      topicId: localTopicId,
-      authorId: sourceNode,
-      text: incoming.text,
-      createdAt: incoming.createdAt,
-      ...incoming.agent ? { agentType: incoming.agent } : {},
-      ...incoming.model ? { model: incoming.model } : {},
-      ...incoming.kind ? { kind: incoming.kind } : {},
-      sourceNode,
-      sourceMessageId: incoming.sourceMessageId
-    };
-    appendApiMessage(message);
-    inserted++;
-  }
-  return inserted;
-}
-var RETRY_MS = 1000;
-var init_shared_topic_sync = __esm(async () => {
-  await init_src();
-  await init_central();
-  await init_event_backflow();
-  init_protocol();
-  await init_store2();
-});
-
 // ../../adapters/otium/src/relay-protocol.ts
 function encodeFrame(frame) {
   const encoded = JSON.stringify(frame);
@@ -44520,109 +43607,6 @@ var init_tunnel_client = __esm(() => {
   silentLogger = { info: noop, warn: noop, error: noop };
 });
 
-// ../../adapters/otium/src/bindings.ts
-var exports_bindings = {};
-__export(exports_bindings, {
-  unbindOtiumTopic: () => unbindOtiumTopic,
-  shareOtiumTopic: () => shareOtiumTopic,
-  setOtiumTopicPrivate: () => setOtiumTopicPrivate,
-  listOtiumTopicBindings: () => listOtiumTopicBindings,
-  bindOtiumTopic: () => bindOtiumTopic
-});
-function ownsTopic(localTopicId, userId) {
-  const topic = getTopic(localTopicId);
-  if (!topic)
-    return { ok: false, error: "local topic not found", status: 404 };
-  if (!isTopicVisible(topic)) {
-    return { ok: false, error: "internal topics have no user access mode", status: 409 };
-  }
-  if (!topic.participants.some((participant) => participant.userId === userId)) {
-    return { ok: false, error: "local topic is not visible to this user", status: 403 };
-  }
-  if (!topic.participants.some((participant) => participant.userId === userId && participant.role === "owner")) {
-    return {
-      ok: false,
-      error: "only a topic owner can change its access mode",
-      status: 403
-    };
-  }
-  return { ok: true, topic };
-}
-function bindOtiumTopic(options) {
-  const topic = getTopic(options.localTopicId);
-  if (!topic)
-    return { ok: false, error: "local topic not found", status: 404 };
-  if (!isTopicVisible(topic)) {
-    return { ok: false, error: "hidden local topics cannot be shared", status: 409 };
-  }
-  if (!topic.participants.some((participant) => participant.userId === options.userId)) {
-    return { ok: false, error: "local topic is not visible to this user", status: 403 };
-  }
-  if (!isTopicShared(topic)) {
-    return { ok: false, error: "private topics must be shared explicitly first", status: 409 };
-  }
-  const previous = getPeerSession(options.hostNodeId, options.hostTopicId);
-  bindPeerSession(options.hostNodeId, options.hostTopicId, options.localTopicId, "shared");
-  return {
-    ok: true,
-    localTopicId: options.localTopicId,
-    replaced: Boolean(previous && previous.local_topic_id !== options.localTopicId)
-  };
-}
-function shareOtiumTopic(options) {
-  const owned = ownsTopic(options.localTopicId, options.userId);
-  if (!owned.ok)
-    return owned;
-  if (!isTopicShared(owned.topic)) {
-    const switched = switchTopicAccessMode({
-      topicId: options.localTopicId,
-      userId: options.userId,
-      accessMode: "shared"
-    });
-    if (!switched.ok)
-      return { ok: false, error: switched.error, status: 409 };
-  }
-  return bindOtiumTopic(options);
-}
-function setOtiumTopicPrivate(options) {
-  const owned = ownsTopic(options.localTopicId, options.userId);
-  if (!owned.ok)
-    return owned;
-  const removedBindings = unbindSharedPeerSessionsForLocalTopic(options.localTopicId);
-  if (isTopicShared(owned.topic)) {
-    const switched = switchTopicAccessMode({
-      topicId: options.localTopicId,
-      userId: options.userId,
-      accessMode: "private"
-    });
-    if (!switched.ok)
-      return { ok: false, error: switched.error, status: 409 };
-  }
-  return { ok: true, localTopicId: options.localTopicId, removedBindings };
-}
-function unbindOtiumTopic(hostNodeId, hostTopicId) {
-  return unbindPeerSession(hostNodeId, hostTopicId);
-}
-function listOtiumTopicBindings() {
-  return listPeerSessions().map((row) => {
-    const topic = getTopic(row.local_topic_id);
-    return {
-      hostNodeId: row.host_node_id,
-      hostTopicId: row.host_topic_id,
-      localTopicId: row.local_topic_id,
-      transport: row.binding_mode === "shared" ? "shared-binding" : "internal-mirror",
-      ...topic ? { topicAccessMode: topic.accessMode ?? "private" } : {},
-      ...topic ? { localTopicTitle: topic.title } : {},
-      localTopicExists: Boolean(topic),
-      createdAt: row.created_at
-    };
-  });
-}
-var init_bindings = __esm(async () => {
-  await init_src();
-  await init_store2();
-});
-
 // ../../adapters/otium/src/enrollment.ts
 import {
   createDecipheriv as createDecipheriv2,
@@ -44907,205 +43891,6 @@ var init_gateway_forward = __esm(async () => {
   await init_src();
 });
 
-// ../../adapters/otium/src/turn-bridge.ts
-import { randomUUID as randomUUID32 } from "crypto";
-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-${randomUUID32()}`;
-  const now = new Date().toISOString();
-  const current3 = existing ? getTopic(localTopicId) : null;
-  const currentConfig = current3 ? getApiTopicConfig(localTopicId) : undefined;
-  const currentModel = currentConfig?.model ?? current3?.defaultModel ?? "";
-  const nextModel = execution.model || current3?.defaultModel || "";
-  const providerSessionIsStale = Boolean(current3) && (current3?.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 : current3?.defaultEffort ?? "medium",
-    participants: [{ userId: payload.userId, role: "owner" }],
-    isSubagent: undefined,
-    visibility: "visible",
-    accessMode: "shared",
-    ...execution.description ? { description: execution.description } : {},
-    createdAt: current3?.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" };
-}
-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,
-        injectSourceNode: hostCellId,
-        ...payload.sourceMessageId ? { injectSourceMessageId: payload.sourceMessageId } : {},
-        attachments: payload.attachments,
-        visualTools: true,
-        fileDeliveryTools: true,
-        onDispatched: (dispatchedQueryId) => {
-          forwarder.queryId = dispatchedQueryId;
-        },
-        peerBridge: {
-          hubCellId: hostCellId,
-          hostTopicId: payload.hostTopicId,
-          hostQueryId: payload.requestId,
-          canSpawnSubagents: execution.canSpawnSubagents
-        }
-      },
-      ...turnTrigger ? { dispatch: turnTrigger } : {}
-    });
-  } catch (err2) {
-    forwarder.finish({
-      type: "ai_error",
-      queryId: payload.requestId,
-      topicId: localTopicId,
-      error: `worker dispatch crashed: ${err2.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);
-}
-var EFFORT_LEVELS, turnTrigger;
-var init_turn_bridge = __esm(async () => {
-  await init_src();
-  await init_event_backflow();
-  await init_peer_files();
-  await init_store2();
-  EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
-});
-
 // ../../adapters/otium/src/peer-server.ts
 import { statfsSync } from "fs";
 import { cpus as cpus2, freemem as freemem2, loadavg as loadavg2, totalmem as totalmem2 } from "os";
@@ -45122,7 +43907,7 @@ async function readBody(req) {
     return null;
   return body;
 }
-function str2(body, field) {
+function str(body, field) {
   const value = body[field];
   return typeof value === "string" && value.trim() ? value : null;
 }
@@ -45148,6 +43933,9 @@ async function requirePeer(req) {
 function requirePrimaryOrigin(peer) {
   return peer.verified.fromIsPrimary ? null : jsonError2("only the workspace hub may call this endpoint", 403);
 }
+function peerAddressable(topic) {
+  return isTopicShared(topic);
+}
 function localCapabilities() {
   const agents = SUPPORTED_AGENTS.map((kind) => {
     const registry = getRegistry(kind);
@@ -45165,7 +43953,7 @@ function localCapabilities() {
     runtimeVersion: RUNTIME_VERSION,
     features: {
       remoteAsk: true,
-      inputFiles: true,
+      inputFiles: false,
       outputFiles: true,
       visualBridge: true,
       askUserBridge: true,
@@ -45199,180 +43987,6 @@ function localHealth() {
     ...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 jsonError2("invalid JSON body", 400);
-  const protocolError = checkProtocol(body);
-  if (protocolError)
-    return protocolError;
-  const userId = str2(body, "userId");
-  const hostTopicId = str2(body, "hostTopicId");
-  const topicTitle = str2(body, "topicTitle");
-  const execution = parseExecutionSpec(body.execution);
-  if (!userId || !hostTopicId || !topicTitle || !execution) {
-    return jsonError2("invalid peer provision request", 400);
-  }
-  const result = provisionMirrorTopic(peer.verified.fromCellId, {
-    userId,
-    hostTopicId,
-    topicTitle,
-    execution
-  });
-  if (!result.ok)
-    return jsonError2(result.error, result.status);
-  logger.info({ hostTopicId, localTopicId: result.localTopicId, fromNode: peer.verified.fromNodeName }, "otium: 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 jsonError2("invalid JSON body", 400);
-  const protocolError = checkProtocol(body);
-  if (protocolError)
-    return protocolError;
-  const userId = str2(body, "userId");
-  const hostTopicId = str2(body, "hostTopicId");
-  const localTopicId = str2(body, "localTopicId");
-  if (!userId || !hostTopicId || !localTopicId) {
-    return jsonError2("invalid peer bind request", 400);
-  }
-  const result = bindOtiumTopic({
-    hostNodeId: peer.verified.fromCellId,
-    hostTopicId,
-    localTopicId,
-    userId
-  });
-  if (!result.ok)
-    return jsonError2(result.error, result.status);
-  return Response.json({ ok: true, localTopicId: result.localTopicId, replaced: result.replaced });
-}
-async function handleSharedTopicMessages(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 jsonError2("invalid JSON body", 400);
-  const protocolError = checkProtocol(body);
-  if (protocolError)
-    return protocolError;
-  const localTopicId = str2(body, "localTopicId");
-  const hostTopicId = str2(body, "hostTopicId");
-  const messages = body.messages;
-  if (!localTopicId || !hostTopicId || !Array.isArray(messages)) {
-    return jsonError2("localTopicId, hostTopicId and messages are required", 400);
-  }
-  const session = getPeerSession(peer.verified.fromCellId, hostTopicId);
-  if (!session || session.local_topic_id !== localTopicId) {
-    return jsonError2("shared topic binding not found", 404);
-  }
-  const accepted = acceptSharedTopicMessages(messages, localTopicId, peer.verified.fromCellId);
-  return Response.json({ ok: true, accepted });
-}
-async function handleSharedTopicsPrivate(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 jsonError2("invalid JSON body", 400);
-  const protocolError = checkProtocol(body);
-  if (protocolError)
-    return protocolError;
-  if (body.reason !== "hub-removal")
-    return jsonError2("reason must be hub-removal", 400);
-  const updated = downgradeSharedTopicsForHub(peer.verified.fromCellId);
-  return Response.json({ ok: true, updated });
-}
-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 jsonError2("invalid JSON body", 400);
-  const protocolError = checkProtocol(body);
-  if (protocolError)
-    return protocolError;
-  const hostTopicId = str2(body, "hostTopicId");
-  if (!hostTopicId)
-    return jsonError2("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 jsonError2("invalid JSON body", 400);
-  const protocolError = checkProtocol(body);
-  if (protocolError)
-    return protocolError;
-  const requestId = str2(body, "requestId");
-  const userId = str2(body, "userId");
-  const hostTopicId = str2(body, "hostTopicId");
-  const topicTitle = str2(body, "topicTitle");
-  const execution = parseExecutionSpec(body.execution);
-  if (body.execution !== undefined && !execution) {
-    return jsonError2("invalid placed-topic execution spec", 400);
-  }
-  const agent = execution?.agent ?? str2(body, "agent");
-  const message = str2(body, "message");
-  if (!requestId || !userId || !hostTopicId || !topicTitle || !agent || !message) {
-    return jsonError2("requestId, userId, hostTopicId, topicTitle, agent, message are required", 400);
-  }
-  if (message.length > MAX_PEER_MESSAGE_LENGTH)
-    return jsonError2("message too long", 400);
-  const hubNode = await resolvePeerNodeByCellId(peer.verified.fromCellId).catch(() => null);
-  if (!hubNode)
-    return jsonError2("calling node is not in this workspace", 403);
-  const payload = {
-    v: PEER_PROTOCOL_VERSION,
-    requestId,
-    userId,
-    hostTopicId,
-    topicTitle,
-    ...execution ? { execution } : {},
-    ...agent ? { agent } : {},
-    ...str2(body, "model") ? { model: str2(body, "model") } : {},
-    ...str2(body, "effort") ? { effort: str2(body, "effort") } : {},
-    ...Array.isArray(body.attachments) && body.attachments.every((entry) => typeof entry === "string") ? { attachments: body.attachments } : {},
-    ...str2(body, "sourceMessageId") ? { sourceMessageId: str2(body, "sourceMessageId") } : {},
-    message
-  };
-  const result = runPeerTurn(hubNode, peer.verified.fromCellId, payload);
-  if (!result.ok)
-    return jsonError2(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)
@@ -45386,20 +44000,12 @@ async function handleAbort(req) {
   const protocolError = checkProtocol(body);
   if (protocolError)
     return protocolError;
-  const userId = str2(body, "userId");
-  const toTopic = str2(body, "toTopic");
+  const userId = str(body, "userId");
+  const toTopic = str(body, "toTopic");
   if (!userId || !toTopic)
     return jsonError2("userId and toTopic are required", 400);
-  const requestId = str2(body, "requestId");
-  if (requestId) {
-    const aborted = abortHostedPeerTurn(peer.verified.fromCellId, requestId, userId, toTopic);
-    if (!aborted)
-      return jsonError2("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)) {
+  if (!topic || !peerAddressable(topic)) {
     return jsonError2(`shared topic "${toTopic}" not found on this node`, 404);
   }
   appendJsonlEntry(sessionInboxPath(userId, topic.id), {
@@ -45423,11 +44029,11 @@ async function handleTell(req) {
   const protocolError = checkProtocol(body);
   if (protocolError)
     return protocolError;
-  const requestId = str2(body, "requestId");
-  const userId = str2(body, "userId");
-  const toTopic = str2(body, "toTopic");
-  const fromLabel = str2(body, "fromLabel");
-  const message = str2(body, "message");
+  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 jsonError2("requestId, userId, toTopic, fromLabel, message are required", 400);
@@ -45441,7 +44047,7 @@ async function handleTell(req) {
     return jsonError2(`tell depth limit exceeded (max ${MAX_TELL_DEPTH})`, 400);
   }
   const topic = getTopicByNameForUser(toTopic, userId);
-  if (!topic || !isTopicShared(topic)) {
+  if (!topic || !peerAddressable(topic)) {
     return jsonError2(`shared topic "${toTopic}" not found on this node`, 404);
   }
   const claim = claimInboundPeerMessage({
@@ -45495,10 +44101,10 @@ async function handleSessions(req) {
   const protocolError = checkProtocol(body);
   if (protocolError)
     return protocolError;
-  const userId = str2(body, "userId");
+  const userId = str(body, "userId");
   if (!userId)
     return jsonError2("userId is required", 400);
-  const topics = listTopics().filter((topic) => topic.kind !== "manager" && !topic.isSubagent && isTopicShared(topic) && topic.participants.some((p) => p.userId === userId));
+  const topics = listTopics().filter((topic) => topic.kind !== "manager" && !topic.isSubagent && peerAddressable(topic) && topic.participants.some((p) => p.userId === userId));
   const titleCounts = new Map;
   for (const topic of topics) {
     const normalized = topic.title.toLowerCase();
@@ -45530,11 +44136,11 @@ async function handleAsk(req) {
   const protocolError = checkProtocol(body);
   if (protocolError)
     return protocolError;
-  const requestId = str2(body, "requestId");
-  const userId = str2(body, "userId");
-  const toTopic = str2(body, "toTopic");
-  const fromLabel = str2(body, "fromLabel");
-  const message = str2(body, "message");
+  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;
@@ -45547,7 +44153,7 @@ async function handleAsk(req) {
     return jsonError2("fromDepth must be a non-negative integer", 400);
   }
   const topic = getTopicByNameForUser(toTopic, userId);
-  if (!topic || !isTopicShared(topic)) {
+  if (!topic || !peerAddressable(topic)) {
     return jsonError2(`shared topic "${toTopic}" not found on this node`, 404);
   }
   if (!topic.agent)
@@ -45600,10 +44206,10 @@ async function handleReply(req) {
   const protocolError = checkProtocol(body);
   if (protocolError)
     return protocolError;
-  const requestId = str2(body, "requestId");
-  const userId = str2(body, "userId");
+  const requestId = str(body, "requestId");
+  const userId = str(body, "userId");
   const replyText = typeof body.replyText === "string" ? body.replyText : null;
-  const fromLabel = str2(body, "fromLabel") ?? "peer";
+  const fromLabel = str(body, "fromLabel") ?? "peer";
   const kind = body.kind === "error" ? "error" : "reply";
   if (!requestId || !userId || replyText === null) {
     return jsonError2("requestId, userId and replyText are required", 400);
@@ -45622,39 +44228,6 @@ async function handleReply(req) {
     return jsonError2("ask callback delivery is retryable", 503);
   return jsonError2("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 jsonError2("file too large", 413);
-  }
-  const form = await req.formData().catch(() => null);
-  if (!form)
-    return jsonError2("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 jsonError2("hostTopicId, userId, and file are required", 400);
-  }
-  if (file.size > MAX_PEER_INPUT_FILE_BYTES)
-    return jsonError2("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 jsonError2("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)
@@ -45668,14 +44241,14 @@ async function handleDeviceVault(req) {
   const protocolError = checkProtocol(body);
   if (protocolError)
     return protocolError;
-  const userId = str2(body, "userId");
-  const operation = str2(body, "operation");
+  const userId = str(body, "userId");
+  const operation = str(body, "operation");
   if (!userId || !operation)
     return jsonError2("userId and operation are required", 400);
   if (operation === "list") {
     return Response.json({ ok: true, entries: vaultList(userId) });
   }
-  const rawKey = str2(body, "key");
+  const rawKey = str(body, "key");
   if (!rawKey || !validateVaultKey(rawKey))
     return jsonError2("invalid vault key", 400);
   const key = normalizeVaultKey(rawKey);
@@ -45740,18 +44313,6 @@ async function handleOtiumPeerRequest(req) {
   if (req.method !== "POST")
     return jsonError2("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/shared-topic/messages":
-      return handleSharedTopicMessages(req);
-    case "/api/v1/peer/shared-topics/private":
-      return handleSharedTopicsPrivate(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":
@@ -45762,8 +44323,6 @@ async function handleOtiumPeerRequest(req) {
       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:
@@ -45773,15 +44332,11 @@ async function handleOtiumPeerRequest(req) {
 var RUNTIME_VERSION;
 var init_peer_server = __esm(async () => {
   await init_src();
-  await init_bindings();
   await init_central();
   await init_gateway_forward();
-  await init_peer_files();
   init_protocol();
   await init_session_bridge();
-  await init_shared_topic_sync();
   await init_store2();
-  await init_turn_bridge();
   RUNTIME_VERSION = NEGOTIUM_VERSION;
 });
 
@@ -45789,16 +44344,6 @@ var init_peer_server = __esm(async () => {
 function startOtiumNodeRuntime(options) {
   const { join: join43 } = options;
   configureOtiumCentral(join43);
-  const failed = failInterruptedPeerTurnRequestsOnStartup();
-  if (failed > 0) {
-    logger.warn({ failed }, "otium: failed interrupted peer turns from previous process");
-  }
-  const staleBindings = sweepStalePeerBindings((localTopicId) => getTopic(localTopicId) !== null);
-  if (staleBindings.topicIds.length > 0) {
-    logger.info({ topicIds: staleBindings.topicIds, ...staleBindings.removed }, "otium: removed peer state for local topics deleted while this node was offline");
-  }
-  const stopBackflow = startEventBackflow();
-  const stopSharedTopicSync = startSharedTopicSync(join43);
   const unregisterRuntimeBridge = registerPeerRuntimeBridge(otiumPeerRuntimeBridge);
   const unregisterSessionBridge = registerPeerSessionBridge(otiumPeerSessionBridge);
   const sessionBridgeIpc = startPeerSessionBridgeIpc(otiumPeerSessionBridge);
@@ -45814,7 +44359,7 @@ function startOtiumNodeRuntime(options) {
     if (event.type !== "topic-deleted")
       return;
     const removed = cleanupPeerStateForLocalTopic(event.topicId);
-    if (removed.sessions + removed.turns + removed.inboxRequests + removed.remoteAsks > 0) {
+    if (removed.inboxRequests + removed.remoteAsks > 0) {
       logger.info({ topicId: event.topicId, ...removed }, "otium: removed peer state for deleted local topic");
     }
   });
@@ -45841,8 +44386,6 @@ function startOtiumNodeRuntime(options) {
       canonicalMcpBridge.stop();
       stopPeerReplyOutbox();
       uninstallFileHooks();
-      stopBackflow();
-      stopSharedTopicSync();
       configureOtiumCentral(null);
     }
   };
@@ -45886,34 +44429,28 @@ var init_src8 = __esm(async () => {
   await init_src();
   await init_canonical_mcp_bridge();
   await init_central();
-  await init_event_backflow();
   await init_join();
   await init_peer_files();
   await init_runtime_bridge();
   await init_session_bridge();
   init_session_bridge_ipc();
-  await init_shared_topic_sync();
   await init_store2();
   init_tunnel_client();
-  await init_bindings();
   await init_central();
   await init_enrollment();
-  await init_event_backflow();
   await init_join();
   await init_peer_server();
   init_protocol();
   init_relay_protocol();
   await init_runtime_bridge();
-  await init_shared_topic_sync();
   await init_store2();
   init_tunnel_client();
-  await init_turn_bridge();
   otiumAdapter = defineNegotiumAdapter({
     name: "otium",
     capabilities: {
       localUserInput: false,
       topicManagement: false,
-      externalPlacedTurn: true
+      externalPlacedTurn: false
     },
     projection: {
       transcript: "full",
@@ -45931,7 +44468,7 @@ __export(exports_node_runtime, {
   handleOtiumAdapterControlRequest: () => handleOtiumAdapterControlRequest,
   OTIUM_ADAPTER_CONTROL_PREFIX: () => OTIUM_ADAPTER_CONTROL_PREFIX,
   OTIUM_ADAPTER_CONTROL_HEADER: () => OTIUM_ADAPTER_CONTROL_HEADER,
-  MAX_PEER_INPUT_REQUEST_BYTES: () => MAX_PEER_INPUT_REQUEST_BYTES
+  MAX_PEER_REQUEST_BODY_BYTES: () => MAX_PEER_REQUEST_BODY_BYTES
 });
 async function handleOtiumAdapterControlRequest(req) {
   const url = new URL(req.url);
@@ -46131,7 +44668,7 @@ async function runOtiumSidecar(options) {
       port: options.port,
       hostname: "127.0.0.1",
       idleTimeout: 240,
-      maxRequestBodySize: MAX_PEER_INPUT_REQUEST_BYTES,
+      maxRequestBodySize: MAX_PEER_REQUEST_BODY_BYTES,
       fetch: (req) => proxyOtiumPeerRequest(req)
     });
   } catch (error2) {
@@ -46223,27 +44760,6 @@ function parseOtiumServeRelayUrl(args) {
   }
   return raw.replace(/\/+$/, "");
 }
-async function resolveHostNodeId(explicit) {
-  if (explicit?.trim())
-    return explicit.trim();
-  const [{ configureOtiumCentral: configureOtiumCentral2, listPeerNodes: listPeerNodes2 }, { loadJoin: loadJoin2 }] = await Promise.all([
-    init_central().then(() => exports_central),
-    init_join().then(() => exports_join)
-  ]);
-  const join43 = loadJoin2();
-  if (!join43)
-    throw new Error("not joined to an Otium workspace; pass --host-node or join first");
-  configureOtiumCentral2(join43);
-  try {
-    const nodes = await listPeerNodes2({ fresh: true });
-    const primary = nodes.find((node) => node.isPrimary && !node.self) ?? nodes.find((node) => node.isPrimary);
-    if (!primary)
-      throw new Error("workspace has no primary Otium node");
-    return primary.cellId;
-  } finally {
-    configureOtiumCentral2(null);
-  }
-}
 async function spawnCanonicalNode2() {
   const entry = process.argv[1];
   if (!entry)
@@ -46275,11 +44791,11 @@ async function runCanonicalNodeChild2() {
   let maxRequestBodySize;
   if (hasConfiguredOtiumJoin2()) {
     const { onShutdown: onShutdown2 } = await init_node_host().then(() => exports_node_host);
-    const { MAX_PEER_INPUT_REQUEST_BYTES: MAX_PEER_INPUT_REQUEST_BYTES2, mountConfiguredOtiumNodeRuntime: mountConfiguredOtiumNodeRuntime2 } = await init_node_runtime().then(() => exports_node_runtime);
+    const { MAX_PEER_REQUEST_BODY_BYTES: MAX_PEER_REQUEST_BODY_BYTES2, mountConfiguredOtiumNodeRuntime: mountConfiguredOtiumNodeRuntime2 } = await init_node_runtime().then(() => exports_node_runtime);
     const runtime2 = mountConfiguredOtiumNodeRuntime2();
     if (runtime2)
       onShutdown2("otium-node-runtime", 125, () => runtime2.stop());
-    maxRequestBodySize = MAX_PEER_INPUT_REQUEST_BYTES2;
+    maxRequestBodySize = MAX_PEER_REQUEST_BODY_BYTES2;
   }
   await runNodeDaemon2({ port: 0, ...maxRequestBodySize ? { maxRequestBodySize } : {} });
 }
@@ -46301,20 +44817,29 @@ async function runOtiumCli(args = process.argv.slice(2)) {
       if (process.env.OTIUM_CENTRAL_URL || process.env.OTIUM_CELL_ID || process.env.OTIUM_CELL_SECRET) {
         throw new Error("Otium join is configured by environment; remove OTIUM_CENTRAL_URL, OTIUM_CELL_ID, and OTIUM_CELL_SECRET to disconnect");
       }
-      const { configureOtiumCentral: configureOtiumCentral2 } = await init_central().then(() => exports_central);
       const { loadJoin: loadJoin2, removeJoin: removeJoin2 } = await init_join().then(() => exports_join);
-      const { disconnectSharedTopics: disconnectSharedTopics2 } = await init_shared_topic_sync().then(() => exports_shared_topic_sync);
-      const join43 = loadJoin2();
-      if (!join43)
+      if (!loadJoin2())
         throw new Error("not joined to an Otium workspace");
-      configureOtiumCentral2(join43);
-      try {
-        await disconnectSharedTopics2(join43);
-        removeJoin2();
-      } finally {
-        configureOtiumCentral2(null);
+      const { getVisibleTopics: getVisibleTopics2, isTopicShared: isTopicShared2, switchTopicAccessMode: switchTopicAccessMode2 } = await init_src().then(() => exports_src);
+      let downgraded = 0;
+      for (const topic of getVisibleTopics2()) {
+        if (!isTopicShared2(topic))
+          continue;
+        const owner = topic.participants.find((participant) => participant.role === "owner");
+        if (!owner)
+          continue;
+        if (topic.isSubagent)
+          continue;
+        const switched = switchTopicAccessMode2({
+          topicId: topic.id,
+          userId: owner.userId,
+          accessMode: "private"
+        });
+        if (switched.ok)
+          downgraded += switched.topicIds.length;
       }
-      console.log("disconnected from Otium; local shared topics are now private");
+      removeJoin2();
+      console.log(`disconnected from Otium; workspace credentials removed` + (downgraded > 0 ? `; ${downgraded} topic(s) are now private` : ""));
       break;
     }
     case "serve": {
@@ -46326,63 +44851,19 @@ async function runOtiumCli(args = process.argv.slice(2)) {
       await runOtiumSidecar2({ port, relayUrl });
       break;
     }
-    case "bindings": {
-      const { listOtiumTopicBindings: listOtiumTopicBindings2 } = await init_bindings().then(() => exports_bindings);
-      const bindings = listOtiumTopicBindings2();
-      if (bindings.length === 0) {
-        console.log("no Otium topic bindings");
-        break;
-      }
-      for (const binding of bindings) {
-        const local = binding.localTopicTitle ? `${binding.localTopicTitle} (${binding.localTopicId})` : `${binding.localTopicId} [missing]`;
-        console.log(`${binding.transport.padEnd(16)} ${binding.hostNodeId}/${binding.hostTopicId} -> ${local}`);
-      }
-      break;
-    }
-    case "share": {
-      const parsed = parseArgs(commandArgs);
-      const [hostTopicId, localTopicId] = parsed.positional;
-      const userId = parsed.options.get("user")?.trim();
-      if (!hostTopicId || !localTopicId || !userId) {
-        throw new Error("usage: negotium otium share <host-topic-id> <local-topic-id> --user <user-id> [--host-node <cell-id>]");
-      }
-      const hostNodeId = await resolveHostNodeId(parsed.options.get("host-node"));
-      const { shareOtiumTopic: shareOtiumTopic2 } = await init_bindings().then(() => exports_bindings);
-      const result = shareOtiumTopic2({ hostNodeId, hostTopicId, localTopicId, userId });
-      if (!result.ok)
-        throw new Error(result.error);
-      console.log(`shared ${hostNodeId}/${hostTopicId} with local topic ${result.localTopicId}` + (result.replaced ? " (replaced previous binding)" : ""));
-      break;
-    }
-    case "private": {
-      const parsed = parseArgs(commandArgs);
-      const [localTopicId] = parsed.positional;
-      const userId = parsed.options.get("user")?.trim();
-      if (!localTopicId || !userId) {
-        throw new Error("usage: negotium otium private <local-topic-id> --user <user-id>");
-      }
-      const { setOtiumTopicPrivate: setOtiumTopicPrivate2 } = await init_bindings().then(() => exports_bindings);
-      const result = setOtiumTopicPrivate2({ localTopicId, userId });
-      if (!result.ok)
-        throw new Error(result.error);
-      console.log(`private mode selected for ${result.localTopicId}; removed ${result.removedBindings} Otium binding(s)`);
-      break;
-    }
     default: {
       console.log([
         "negotium otium \u2014 attach a Negotium node to an Otium workspace",
         "",
-        "usage: negotium otium <join|leave|serve|bindings|share|private> [args]",
+        "usage: negotium otium <join|leave|serve> [args]",
         "",
         "  join <code>   store credentials from an Otium invite code",
-        "  leave         delete Hub copies, make local topics private, and remove credentials",
+        "  leave         remove the stored workspace credentials",
         "  serve [--port <port>] [--relay <url>]",
         "                 run peer routes and an outbound relay tunnel",
-        "  bindings      list internal mirrors and shared topic bindings",
-        "  share <host-topic> <local-topic> --user <id> [--host-node <cell>]",
-        "                 publish one private local topic to Otium as shared",
-        "  private <local-topic> --user <id>",
-        "                 remove all Otium bindings; keep Terminal/Telegram access"
+        "",
+        "Publish a topic to the workspace with /public in that topic; the hub",
+        "discovers it over the Runtime Gateway. /private withdraws it."
       ].join(`
 `));
       if (command && command !== "help" && command !== "--help")
@@ -46898,8 +45379,8 @@ var CLI_COMMANDS = [
   },
   {
     name: "otium",
-    usage: "otium join|bindings|share|private|leave",
-    description: "manage the Otium workspace connection and topic bindings",
+    usage: "otium join|leave|serve",
+    description: "manage the Otium workspace connection",
     group: "Channels"
   }
 ];
@@ -46939,11 +45420,11 @@ async function runCanonicalNode(port) {
   let maxRequestBodySize;
   if (hasConfiguredOtiumJoin2()) {
     const { onShutdown: onShutdown2 } = await init_node_host().then(() => exports_node_host);
-    const { MAX_PEER_INPUT_REQUEST_BYTES: MAX_PEER_INPUT_REQUEST_BYTES2, mountConfiguredOtiumNodeRuntime: mountConfiguredOtiumNodeRuntime2 } = await init_node_runtime().then(() => exports_node_runtime);
+    const { MAX_PEER_REQUEST_BODY_BYTES: MAX_PEER_REQUEST_BODY_BYTES2, mountConfiguredOtiumNodeRuntime: mountConfiguredOtiumNodeRuntime2 } = await init_node_runtime().then(() => exports_node_runtime);
     const otiumRuntime = mountConfiguredOtiumNodeRuntime2();
     if (otiumRuntime)
       onShutdown2("otium-node-runtime", 125, () => otiumRuntime.stop());
-    maxRequestBodySize = MAX_PEER_INPUT_REQUEST_BYTES2;
+    maxRequestBodySize = MAX_PEER_REQUEST_BODY_BYTES2;
   }
   const node = await startDefaultNode2({
     port,
@@ -47084,4 +45565,4 @@ switch (command) {
   }
 }
 
-//# debugId=31C48E669F9A292A64756E2164756E21
+//# debugId=4A37A5D1997871CA64756E2164756E21