@openscout/scout 0.2.60 → 0.2.62

package/dist/pair-supervisor.mjs

@@ -56,6 +56,9 @@ function resolvedPairingConfig() {
   };
 }
 
+// ../../apps/desktop/src/core/pairing/supervisor.ts
+import { spawn as spawn4 } from "child_process";
+
 // ../../node_modules/.bun/uqr@0.1.3/node_modules/uqr/dist/index.mjs
 var QrCodeDataType = /* @__PURE__ */ ((QrCodeDataType2) => {
   QrCodeDataType2[QrCodeDataType2["Border"] = -1] = "Border";
@@ -685,7 +688,7 @@ function renderQRCode(payload) {
 // ../../apps/desktop/src/core/pairing/runtime/relay-runtime.ts
 import { execSync } from "child_process";
 import { existsSync as existsSync2, mkdirSync as mkdirSync3, readdirSync } from "fs";
-import { homedir as homedir2 } from "os";
+import { homedir as homedir2, networkInterfaces } from "os";
 import { join } from "path";
 
 // ../../apps/desktop/src/core/pairing/runtime/log.ts
@@ -716,6 +719,7 @@ function startRelay(port, options = {}) {
   const roomByBridgeKey = new Map;
   const server = Bun.serve({
     port,
+    hostname: "0.0.0.0",
     ...options.tls ? {
       tls: {
         cert: Bun.file(options.tls.cert),
@@ -974,24 +978,42 @@ function readTailscaleStatus() {
     return null;
   }
 }
-function resolveRelayEndpointForTailscaleStatus(port, tailscale) {
+function resolveRelayEndpointForTailscaleStatus(port, tailscale, options = {}) {
   const backendState = tailscale?.backendState?.trim().toLowerCase() ?? "";
   const hostname = tailscale?.dnsName ?? null;
   const tailscaleRunning = backendState === "running" && tailscale?.online !== false && Boolean(hostname);
-  const tls = resolveTls(tailscaleRunning ? hostname : null);
-  if (tailscaleRunning && hostname && tls) {
+  const tls = tailscaleRunning ? options.tls !== undefined ? options.tls : resolveTls(hostname) : null;
+  const scheme = tls ? "wss" : "ws";
+  const connectUrl = `${scheme}://127.0.0.1:${port}`;
+  const localAddress = options.localAddress !== undefined ? normalizedOptionalAddress(options.localAddress) : findLocalNetworkAddress();
+  const localRelayUrl = localAddress ? `${scheme}://${localAddress}:${port}` : null;
+  const tailnetRelayUrl = tailscaleRunning && hostname ? `${scheme}://${hostname}:${port}` : null;
+  const fallbackRelayUrls = tailnetRelayUrl && localRelayUrl ? [tailnetRelayUrl] : [];
+  if (localRelayUrl) {
     return {
-      relayUrl: `wss://${hostname}:${port}`,
+      relayUrl: localRelayUrl,
+      connectUrl,
+      fallbackRelayUrls,
+      options: tls ? { tls } : {}
+    };
+  }
+  if (tailnetRelayUrl && tls) {
+    return {
+      relayUrl: tailnetRelayUrl,
+      connectUrl,
+      fallbackRelayUrls: [],
       options: { tls }
     };
   }
-  if (tailscaleRunning && hostname) {
+  if (tailnetRelayUrl) {
     pairingLog.warn("relay", "tailscale is running without TLS; falling back to insecure websocket relay", {
       hostname,
       port
     });
     return {
-      relayUrl: `ws://${hostname}:${port}`,
+      relayUrl: tailnetRelayUrl,
+      connectUrl,
+      fallbackRelayUrls: [],
       options: {}
     };
   }
@@ -1004,7 +1026,9 @@ function resolveRelayEndpointForTailscaleStatus(port, tailscale) {
     });
   }
   return {
-    relayUrl: `ws://127.0.0.1:${port}`,
+    relayUrl: connectUrl,
+    connectUrl,
+    fallbackRelayUrls: [],
     options: {}
   };
 }
@@ -1057,16 +1081,87 @@ function resolveRelayEndpoint(port) {
 }
 function startManagedRelay(port = 7889) {
   const endpoint = resolveRelayEndpoint(port);
-  pairingLog.info("relay", "starting managed relay", { relay: endpoint.relayUrl, port });
+  pairingLog.info("relay", "starting managed relay", {
+    relay: endpoint.relayUrl,
+    connectUrl: endpoint.connectUrl,
+    fallbackRelayUrls: endpoint.fallbackRelayUrls,
+    port
+  });
   const relay = startRelay(port, endpoint.options);
   return {
     relayUrl: endpoint.relayUrl,
+    connectUrl: endpoint.connectUrl,
+    fallbackRelayUrls: endpoint.fallbackRelayUrls,
     stop() {
       pairingLog.info("relay", "stopping managed relay", { relay: endpoint.relayUrl, port });
       relay.stop();
     }
   };
 }
+function normalizedOptionalAddress(address) {
+  const trimmed = address?.trim();
+  return trimmed ? trimmed : null;
+}
+function findLocalNetworkAddress() {
+  const candidates = [];
+  const interfaces = networkInterfaces();
+  for (const [name, entries] of Object.entries(interfaces)) {
+    for (const entry of entries ?? []) {
+      if (entry.internal || entry.family !== "IPv4") {
+        continue;
+      }
+      if (!isPrivateIPv4(entry.address) || isLinkLocalIPv4(entry.address) || isTailscaleIPv4(entry.address)) {
+        continue;
+      }
+      candidates.push({ name, address: entry.address });
+    }
+  }
+  candidates.sort((left, right) => {
+    const leftScore = localInterfaceScore(left.name);
+    const rightScore = localInterfaceScore(right.name);
+    if (leftScore !== rightScore) {
+      return leftScore - rightScore;
+    }
+    return left.address.localeCompare(right.address);
+  });
+  return candidates[0]?.address ?? null;
+}
+function localInterfaceScore(name) {
+  if (/^en\d+$/i.test(name)) {
+    return 0;
+  }
+  if (/^bridge\d*$/i.test(name)) {
+    return 2;
+  }
+  return 1;
+}
+function isPrivateIPv4(address) {
+  const octets = parseIPv4(address);
+  if (!octets) {
+    return false;
+  }
+  const [first, second] = octets;
+  return first === 10 || first === 172 && second >= 16 && second <= 31 || first === 192 && second === 168;
+}
+function isLinkLocalIPv4(address) {
+  const octets = parseIPv4(address);
+  return Boolean(octets && octets[0] === 169 && octets[1] === 254);
+}
+function isTailscaleIPv4(address) {
+  const octets = parseIPv4(address);
+  return Boolean(octets && octets[0] === 100 && octets[1] >= 64 && octets[1] <= 127);
+}
+function parseIPv4(address) {
+  const octets = address.split(".");
+  if (octets.length !== 4) {
+    return null;
+  }
+  const numbers = octets.map((octet) => Number(octet));
+  if (numbers.some((value) => !Number.isInteger(value) || value < 0 || value > 255)) {
+    return null;
+  }
+  return numbers;
+}
 
 // ../../apps/desktop/src/core/pairing/runtime/runtime-state.ts
 import { existsSync as existsSync4, mkdirSync as mkdirSync5, readFileSync as readFileSync3, renameSync, unlinkSync, writeFileSync as writeFileSync3 } from "fs";
@@ -3152,15 +3247,30 @@ function isTrustedPeer(publicKeyHex) {
 }
 var QR_VERSION = 1;
 var QR_EXPIRY_MS = 5 * 60 * 1000;
-function createQRPayload(bridgePublicKey, relayUrl) {
+function createQRPayload(bridgePublicKey, relayUrl, fallbackRelayUrls = []) {
+  const fallbackRelays = normalizedRelayUrls(fallbackRelayUrls, relayUrl);
   return {
     v: QR_VERSION,
     relay: relayUrl,
+    ...fallbackRelays.length > 0 ? { fallbackRelays } : {},
     room: crypto.randomUUID(),
     publicKey: bytesToHex2(bridgePublicKey),
     expiresAt: Date.now() + QR_EXPIRY_MS
   };
 }
+function normalizedRelayUrls(urls, primaryRelayUrl) {
+  const seen = new Set([primaryRelayUrl.trim()]);
+  const normalized = [];
+  for (const url of urls) {
+    const trimmed = url.trim();
+    if (!trimmed || seen.has(trimmed)) {
+      continue;
+    }
+    seen.add(trimmed);
+    normalized.push(trimmed);
+  }
+  return normalized;
+}
 function bytesToHex2(bytes) {
   return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
 }
@@ -3394,7 +3504,7 @@ function writeJsonAtomically(filePath, value) {
 }
 
 // ../../apps/desktop/src/core/pairing/runtime/runtime.ts
-import { homedir as homedir18 } from "os";
+import { homedir as homedir19 } from "os";
 // ../agent-sessions/src/protocol/adapter.ts
 class BaseAdapter {
   config;
@@ -4026,6 +4136,15 @@ function stringifyUnknown(value) {
     return String(value);
   }
 }
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function maybeString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+function maybeNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
 function renderToolResultContent(content) {
   if (typeof content === "string") {
     return content;
@@ -4081,6 +4200,7 @@ class ClaudeCodeHistoryParser {
   blockById = new Map;
   activeStreamBlocks = new Map;
   sawStreamTextThisTurn = false;
+  assistantUsageByMessageId = new Map;
   constructor(session, baseTimestampMs) {
     this.session = session;
     this.baseTimestampMs = baseTimestampMs;
@@ -4090,6 +4210,7 @@ class ClaudeCodeHistoryParser {
     let parsedLineCount = 0;
     let skippedLineCount = 0;
     let lineCount = 0;
+    let lastCapturedAt = this.baseTimestampMs;
     for (let index = 0;index < lines.length; index += 1) {
       const rawLine = lines[index];
       const trimmed = rawLine.trim();
@@ -4110,12 +4231,19 @@ class ClaudeCodeHistoryParser {
         continue;
       }
       const capturedAt = extractRecordTimestamp(record) ?? this.baseTimestampMs + index;
+      lastCapturedAt = capturedAt;
       if (this.handleRecord(record, capturedAt)) {
         parsedLineCount += 1;
       } else {
         skippedLineCount += 1;
       }
     }
+    if (this.persistObserveUsageMetadata()) {
+      this.emitEvent(lastCapturedAt, {
+        event: "session:update",
+        session: { ...this.session }
+      });
+    }
     return {
       events: this.events,
       lineCount,
@@ -4124,6 +4252,7 @@ class ClaudeCodeHistoryParser {
     };
   }
   handleRecord(record, capturedAt) {
+    this.captureRecordMetadata(record);
     const type = typeof record.type === "string" ? record.type : null;
     if (!type) {
       return false;
@@ -4133,7 +4262,7 @@ class ClaudeCodeHistoryParser {
         this.handleSystem(record, capturedAt);
         return true;
       case "user":
-        this.startTurn(capturedAt);
+        this.handleUser(record, capturedAt);
         return true;
       case "assistant":
         this.handleAssistant(record, capturedAt);
@@ -4157,6 +4286,130 @@ class ClaudeCodeHistoryParser {
         return false;
     }
   }
+  captureRecordMetadata(record) {
+    const runtime = this.ensureObserveMetaRecord("observeRuntime");
+    this.assignObserveString(runtime, "entrypoint", record.entrypoint);
+    this.assignObserveString(runtime, "cliVersion", record.version);
+    this.assignObserveString(runtime, "gitBranch", record.gitBranch);
+    this.assignObserveString(runtime, "permissionMode", record.permissionMode);
+    this.assignObserveString(runtime, "userType", record.userType);
+    const recordCwd = maybeString(record.cwd);
+    if (recordCwd && !this.session.cwd) {
+      this.session.cwd = recordCwd;
+    }
+    const message = isRecord(record.message) ? record.message : null;
+    const model = maybeString(message?.model);
+    if (model && !this.session.model) {
+      this.session.model = model;
+    }
+    const usage = this.readClaudeUsageEntry(record);
+    if (!usage) {
+      return;
+    }
+    const messageId = maybeString(message?.id) ?? maybeString(record.requestId) ?? maybeString(record.uuid);
+    if (!messageId) {
+      return;
+    }
+    this.assistantUsageByMessageId.set(messageId, usage);
+  }
+  readClaudeUsageEntry(record) {
+    const type = maybeString(record.type);
+    const message = isRecord(record.message) ? record.message : null;
+    const role = maybeString(message?.role);
+    if (type !== "assistant" && role !== "assistant") {
+      return null;
+    }
+    const usage = isRecord(message?.usage) ? message.usage : null;
+    const serverToolUse = isRecord(usage?.server_tool_use) ? usage.server_tool_use : null;
+    const entry = {
+      inputTokens: maybeNumber(usage?.input_tokens) ?? 0,
+      outputTokens: maybeNumber(usage?.output_tokens) ?? 0,
+      cacheReadInputTokens: maybeNumber(usage?.cache_read_input_tokens) ?? 0,
+      cacheCreationInputTokens: maybeNumber(usage?.cache_creation_input_tokens) ?? 0,
+      webSearchRequests: maybeNumber(serverToolUse?.web_search_requests) ?? 0,
+      webFetchRequests: maybeNumber(serverToolUse?.web_fetch_requests) ?? 0,
+      ...maybeString(message?.service_tier) ? { serviceTier: maybeString(message?.service_tier) } : {},
+      ...maybeString(message?.speed) ? { speed: maybeString(message?.speed) } : {}
+    };
+    const hasUsage = entry.inputTokens > 0 || entry.outputTokens > 0 || entry.cacheReadInputTokens > 0 || entry.cacheCreationInputTokens > 0 || entry.webSearchRequests > 0 || entry.webFetchRequests > 0 || Boolean(entry.serviceTier) || Boolean(entry.speed);
+    return hasUsage ? entry : null;
+  }
+  persistObserveUsageMetadata() {
+    if (this.assistantUsageByMessageId.size === 0) {
+      return false;
+    }
+    const usage = this.ensureObserveMetaRecord("observeUsage");
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let cacheReadInputTokens = 0;
+    let cacheCreationInputTokens = 0;
+    let webSearchRequests = 0;
+    let webFetchRequests = 0;
+    let serviceTier;
+    let speed;
+    for (const entry of this.assistantUsageByMessageId.values()) {
+      inputTokens += entry.inputTokens;
+      outputTokens += entry.outputTokens;
+      cacheReadInputTokens += entry.cacheReadInputTokens;
+      cacheCreationInputTokens += entry.cacheCreationInputTokens;
+      webSearchRequests += entry.webSearchRequests;
+      webFetchRequests += entry.webFetchRequests;
+      if (entry.serviceTier) {
+        serviceTier = entry.serviceTier;
+      }
+      if (entry.speed) {
+        speed = entry.speed;
+      }
+    }
+    let changed = false;
+    const assignNumber = (key, value) => {
+      if (usage[key] !== value) {
+        usage[key] = value;
+        changed = true;
+      }
+    };
+    const assignString = (key, value) => {
+      if (usage[key] !== value) {
+        usage[key] = value;
+        changed = true;
+      }
+    };
+    assignNumber("assistantMessages", this.assistantUsageByMessageId.size);
+    if (inputTokens > 0)
+      assignNumber("inputTokens", inputTokens);
+    if (outputTokens > 0)
+      assignNumber("outputTokens", outputTokens);
+    if (cacheReadInputTokens > 0)
+      assignNumber("cacheReadInputTokens", cacheReadInputTokens);
+    if (cacheCreationInputTokens > 0)
+      assignNumber("cacheCreationInputTokens", cacheCreationInputTokens);
+    if (webSearchRequests > 0)
+      assignNumber("webSearchRequests", webSearchRequests);
+    if (webFetchRequests > 0)
+      assignNumber("webFetchRequests", webFetchRequests);
+    if (serviceTier)
+      assignString("serviceTier", serviceTier);
+    if (speed)
+      assignString("speed", speed);
+    return changed;
+  }
+  ensureObserveMetaRecord(key) {
+    const providerMeta = isRecord(this.session.providerMeta) ? this.session.providerMeta : {};
+    this.session.providerMeta = providerMeta;
+    const existing = providerMeta[key];
+    if (isRecord(existing)) {
+      return existing;
+    }
+    const next = {};
+    providerMeta[key] = next;
+    return next;
+  }
+  assignObserveString(target, key, value) {
+    const next = maybeString(value);
+    if (next) {
+      target[key] = next;
+    }
+  }
   handleSystem(record, capturedAt) {
     if (record.subtype !== "init") {
       return;
@@ -4186,19 +4439,41 @@ class ClaudeCodeHistoryParser {
       });
     }
   }
+  handleUser(record, capturedAt) {
+    const message = record.message && typeof record.message === "object" ? record.message : null;
+    const content = message?.content;
+    if (Array.isArray(content) && content.length > 0) {
+      const toolResults = content.filter((entry) => {
+        return !!entry && typeof entry === "object" && !Array.isArray(entry) && entry.type === "tool_result";
+      });
+      if (toolResults.length === content.length) {
+        for (const toolResult of toolResults) {
+          this.handleToolResult({
+            ...toolResult,
+            tool_use_id: typeof toolResult.tool_use_id === "string" ? toolResult.tool_use_id : toolResult.id,
+            is_error: toolResult.is_error === true
+          }, capturedAt);
+        }
+        return;
+      }
+    }
+    this.startTurn(capturedAt);
+  }
   handleAssistant(record, capturedAt) {
     const turn = this.ensureTurn(capturedAt);
-    if (this.sawStreamTextThisTurn) {
-      return;
-    }
     const content = record.message && typeof record.message === "object" ? record.message.content : record.content;
     if (!Array.isArray(content)) {
+      this.maybeEndTurnFromAssistant(record, capturedAt);
       return;
     }
+    const skipTextBlocks = this.sawStreamTextThisTurn;
     for (const part of content) {
       const contentPart = part;
       const contentType = typeof contentPart.type === "string" ? contentPart.type : "";
       if (contentType === "thinking" || contentType === "reasoning") {
+        if (skipTextBlocks) {
+          continue;
+        }
         const block = this.startBlock(turn, capturedAt, {
           type: "reasoning",
           text: typeof contentPart.thinking === "string" ? contentPart.thinking : typeof contentPart.text === "string" ? contentPart.text : "",
@@ -4206,14 +4481,20 @@ class ClaudeCodeHistoryParser {
         });
         this.emitBlockEnd(capturedAt, turn, block, "completed");
       } else if (contentType === "text") {
+        if (skipTextBlocks) {
+          continue;
+        }
         const block = this.startBlock(turn, capturedAt, {
           type: "text",
           text: typeof contentPart.text === "string" ? contentPart.text : "",
           status: "completed"
         });
         this.emitBlockEnd(capturedAt, turn, block, "completed");
+      } else if (contentType === "tool_use") {
+        this.handleToolUse(contentPart, capturedAt);
       }
     }
+    this.maybeEndTurnFromAssistant(record, capturedAt);
   }
   handleStreamEvent(record, capturedAt) {
     const turn = this.ensureTurn(capturedAt);
@@ -4435,6 +4716,12 @@ class ClaudeCodeHistoryParser {
     this.emitError(turn, capturedAt, message);
     this.endTurn("failed", capturedAt);
   }
+  maybeEndTurnFromAssistant(record, capturedAt) {
+    const stopReason = record.message && typeof record.message === "object" ? record.message.stop_reason : record.stop_reason;
+    if (stopReason === "end_turn") {
+      this.endTurn("completed", capturedAt);
+    }
+  }
   startTurn(capturedAt) {
     if (this.currentTurn) {
       this.endTurn("stopped", capturedAt);
@@ -8539,11 +8826,11 @@ function formatTimestamp(value) {
 // ../../apps/desktop/src/core/pairing/runtime/bridge/server.ts
 import { readdirSync as readdirSync3, readFileSync as readFileSync9, realpathSync, statSync as statSync3 } from "fs";
 import { execSync as execSync3 } from "child_process";
-import { basename as basename6, isAbsolute as isAbsolute3, join as join17, relative as relative2 } from "path";
-import { homedir as homedir15 } from "os";
+import { basename as basename7, isAbsolute as isAbsolute3, join as join18, relative as relative2 } from "path";
+import { homedir as homedir16 } from "os";
 
 // ../../apps/desktop/src/core/mobile/service.ts
-import { basename as basename5, resolve as resolve6 } from "path";
+import { basename as basename6, resolve as resolve7 } from "path";
 
 // ../runtime/src/harness-catalog.ts
 import { execFileSync } from "child_process";
@@ -10154,149 +10441,6 @@ function diagnoseAgentIdentity(identity, candidates) {
 var parseAgentSelector = parseAgentIdentity;
 var formatAgentSelector = formatAgentIdentity;
 var resolveAgentSelector = resolveAgentIdentity;
-// ../protocol/dist/scout-agent-card.js
-function buildScoutReturnAddress(input) {
-  const next = {
-    actorId: input.actorId,
-    handle: input.handle.trim()
-  };
-  if (input.displayName?.trim()) {
-    next.displayName = input.displayName.trim();
-  }
-  if (input.selector?.trim()) {
-    next.selector = input.selector.trim();
-  }
-  if (input.defaultSelector?.trim()) {
-    next.defaultSelector = input.defaultSelector.trim();
-  }
-  if (input.conversationId?.trim()) {
-    next.conversationId = input.conversationId.trim();
-  }
-  if (input.replyToMessageId?.trim()) {
-    next.replyToMessageId = input.replyToMessageId.trim();
-  }
-  if (input.nodeId?.trim()) {
-    next.nodeId = input.nodeId.trim();
-  }
-  if (input.projectRoot?.trim()) {
-    next.projectRoot = input.projectRoot.trim();
-  }
-  if (input.sessionId?.trim()) {
-    next.sessionId = input.sessionId.trim();
-  }
-  if (input.metadata && Object.keys(input.metadata).length > 0) {
-    next.metadata = input.metadata;
-  }
-  return next;
-}
-// ../protocol/dist/collaboration.js
-function isQuestionTerminalState(state) {
-  return state === "closed" || state === "declined";
-}
-function isWorkItemTerminalState(state) {
-  return state === "done" || state === "cancelled";
-}
-function collaborationRequiresNextMoveOwner(record) {
-  if (record.kind === "question") {
-    return !isQuestionTerminalState(record.state);
-  }
-  return !isWorkItemTerminalState(record.state);
-}
-function collaborationRequiresOwner(record) {
-  return record.kind === "work_item" && !isWorkItemTerminalState(record.state);
-}
-function collaborationRequiresWaitingOn(record) {
-  return record.kind === "work_item" && record.state === "waiting";
-}
-function collaborationRequiresAcceptance(record) {
-  if (record.acceptanceState === "none") {
-    return false;
-  }
-  if (record.kind === "question") {
-    return Boolean(record.askedById && record.askedOfId);
-  }
-  return Boolean(record.requestedById);
-}
-function validateCollaborationRecord(record) {
-  const errors = [];
-  if (!record.id.trim()) {
-    errors.push("collaboration record id is required");
-  }
-  if (!record.title.trim()) {
-    errors.push("collaboration title is required");
-  }
-  if (!record.createdById.trim()) {
-    errors.push("createdById is required");
-  }
-  if (record.parentId && record.parentId === record.id) {
-    errors.push("parentId cannot reference the record itself");
-  }
-  if (record.createdAt > record.updatedAt) {
-    errors.push("updatedAt must be greater than or equal to createdAt");
-  }
-  if (collaborationRequiresOwner(record) && !record.ownerId) {
-    errors.push("non-terminal work items require ownerId");
-  }
-  if (collaborationRequiresNextMoveOwner(record) && !record.nextMoveOwnerId) {
-    errors.push("non-terminal collaboration records require nextMoveOwnerId");
-  }
-  if (record.kind === "work_item" && collaborationRequiresWaitingOn(record) && !record.waitingOn) {
-    errors.push("waiting work items require waitingOn");
-  }
-  if (record.kind === "question") {
-    if (record.spawnedWorkItemId && record.spawnedWorkItemId === record.id) {
-      errors.push("question spawnedWorkItemId cannot reference the question itself");
-    }
-  } else if (record.waitingOn?.targetId && record.waitingOn.targetId === record.id) {
-    errors.push("waitingOn.targetId cannot reference the work item itself");
-  }
-  if (record.acceptanceState !== "none" && !collaborationRequiresAcceptance(record)) {
-    errors.push("acceptanceState requires the corresponding requester and reviewer identities");
-  }
-  return errors;
-}
-function assertValidCollaborationRecord(record) {
-  const errors = validateCollaborationRecord(record);
-  if (errors.length > 0) {
-    throw new Error(errors.join("; "));
-  }
-}
-function validateCollaborationEvent(event, record) {
-  const errors = [];
-  if (!event.id.trim()) {
-    errors.push("collaboration event id is required");
-  }
-  if (!event.recordId.trim()) {
-    errors.push("collaboration event recordId is required");
-  }
-  if (!event.actorId.trim()) {
-    errors.push("collaboration event actorId is required");
-  }
-  if (record) {
-    if (record.id !== event.recordId) {
-      errors.push("collaboration event recordId does not match the target record");
-    }
-    if (record.kind !== event.recordKind) {
-      errors.push("collaboration event recordKind does not match the target record");
-    }
-  }
-  if (event.kind === "answered" && event.recordKind !== "question") {
-    errors.push("answered events only apply to questions");
-  }
-  if (event.kind === "declined" && event.recordKind !== "question") {
-    errors.push("declined events only apply to questions");
-  }
-  if ((event.kind === "waiting" || event.kind === "progressed" || event.kind === "review_requested" || event.kind === "done" || event.kind === "cancelled") && event.recordKind !== "work_item") {
-    errors.push(`${event.kind} events only apply to work items`);
-  }
-  return errors;
-}
-function assertValidCollaborationEvent(event, record) {
-  const errors = validateCollaborationEvent(event, record);
-  if (errors.length > 0) {
-    throw new Error(errors.join("; "));
-  }
-}
 // ../runtime/src/user-project-hints.ts
 import { readdir, readFile as readFile3, stat } from "fs/promises";
 import { homedir as homedir11 } from "os";
@@ -12347,9 +12491,9 @@ async function ensureRelayAgentConfigured(value, options = {}) {
 
 // ../runtime/src/local-agents.ts
 import { execFileSync as execFileSync3, execSync as execSync2 } from "child_process";
-import { existsSync as existsSync13, readFileSync as readFileSync8 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync8 } from "fs";
 import { mkdir as mkdir6, rm as rm5, stat as stat3, writeFile as writeFile6 } from "fs/promises";
-import { basename as basename4, dirname as dirname6, join as join15, resolve as resolve5 } from "path";
+import { basename as basename5, dirname as dirname7, join as join16, resolve as resolve6 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 
 // ../runtime/src/claude-stream-json.ts
@@ -13693,10 +13837,116 @@ function buildCollaborationContractPrompt(agentId) {
 
 // ../runtime/src/broker-service.ts
 import { spawnSync } from "child_process";
-import { existsSync as existsSync12, mkdirSync as mkdirSync8, readFileSync as readFileSync7, rmSync as rmSync2, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync13, mkdirSync as mkdirSync8, readFileSync as readFileSync7, rmSync as rmSync2, writeFileSync as writeFileSync5 } from "fs";
+import { homedir as homedir14 } from "os";
+import { dirname as dirname6, join as join15, resolve as resolve5 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+
+// ../runtime/src/tool-resolution.ts
+import { accessSync as accessSync2, constants as constants4, existsSync as existsSync12 } from "fs";
 import { homedir as homedir13 } from "os";
 import { basename as basename3, dirname as dirname5, join as join14, resolve as resolve4 } from "path";
-import { fileURLToPath as fileURLToPath4 } from "url";
+var DEFAULT_COMMON_EXECUTABLE_DIRECTORIES = [
+  join14(homedir13(), ".bun", "bin"),
+  "/opt/homebrew/bin",
+  "/usr/local/bin"
+];
+function expandHomePath3(value, env = process.env) {
+  const home = env.HOME ?? homedir13();
+  if (value === "~") {
+    return home;
+  }
+  if (value.startsWith("~/")) {
+    return join14(home, value.slice(2));
+  }
+  return value;
+}
+function isExecutablePath(candidate) {
+  if (!candidate) {
+    return false;
+  }
+  try {
+    accessSync2(candidate, constants4.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function splitPathEntries(env = process.env) {
+  const separator = process.platform === "win32" ? ";" : ":";
+  return (env.PATH ?? "").split(separator).filter(Boolean);
+}
+function dedupeDirectories(values, env) {
+  const seen = new Set;
+  const resolvedEntries = [];
+  for (const value of values) {
+    const normalized = resolve4(expandHomePath3(value, env));
+    if (seen.has(normalized)) {
+      continue;
+    }
+    seen.add(normalized);
+    resolvedEntries.push(normalized);
+  }
+  return resolvedEntries;
+}
+function resolveExecutableFromSearch(options) {
+  const env = options.env ?? process.env;
+  const envKeys = options.envKeys ?? [];
+  for (const envKey of envKeys) {
+    const explicit = env[envKey]?.trim();
+    if (!explicit) {
+      continue;
+    }
+    const expanded = expandHomePath3(explicit, env);
+    if (isExecutablePath(expanded)) {
+      return { path: resolve4(expanded), source: "env" };
+    }
+    const foundOnPath = findExecutableOnSearchPath(explicit, env);
+    if (foundOnPath) {
+      return { path: foundOnPath.path, source: "env" };
+    }
+  }
+  const commonDirectories = dedupeDirectories([...options.commonDirectories ?? DEFAULT_COMMON_EXECUTABLE_DIRECTORIES], env);
+  const searchDirectories = dedupeDirectories([
+    ...splitPathEntries(env),
+    ...options.extraDirectories ?? [],
+    ...commonDirectories
+  ], env);
+  for (const directory of searchDirectories) {
+    for (const name of options.names) {
+      const candidate = join14(directory, name);
+      if (isExecutablePath(candidate)) {
+        return {
+          path: candidate,
+          source: commonDirectories.includes(directory) ? "common-path" : "path"
+        };
+      }
+    }
+  }
+  return null;
+}
+function resolveBunExecutable2(env = process.env) {
+  return resolveExecutableFromSearch({
+    env,
+    envKeys: ["OPENSCOUT_BUN_BIN", "SCOUT_BUN_BIN", "BUN_BIN"],
+    names: ["bun"]
+  });
+}
+function findExecutableOnSearchPath(name, env) {
+  const searchDirectories = dedupeDirectories([
+    ...splitPathEntries(env),
+    ...DEFAULT_COMMON_EXECUTABLE_DIRECTORIES
+  ], env);
+  for (const directory of searchDirectories) {
+    const candidate = join14(directory, name);
+    if (isExecutablePath(candidate)) {
+      return { path: candidate, source: "path" };
+    }
+  }
+  return null;
+}
+
+// ../runtime/src/broker-service.ts
 function isTmpPath(p) {
   return /^\/(?:private\/)?tmp\//.test(p);
 }
@@ -13735,17 +13985,17 @@ function runtimePackageDir() {
   const fromCwd = findWorkspaceRuntimeDir(process.cwd());
   if (fromCwd)
     return fromCwd;
-  const moduleDir = dirname5(fileURLToPath4(import.meta.url));
-  return resolve4(moduleDir, "..");
+  const moduleDir = dirname6(fileURLToPath4(import.meta.url));
+  return resolve5(moduleDir, "..");
 }
 function isInstalledRuntimePackageDir(candidate) {
-  return existsSync12(join14(candidate, "package.json")) && existsSync12(join14(candidate, "bin", "openscout-runtime.mjs"));
+  return existsSync13(join15(candidate, "package.json")) && existsSync13(join15(candidate, "bin", "openscout-runtime.mjs"));
 }
 function findGlobalRuntimeDir() {
   const candidates = [
-    join14(homedir13(), ".bun", "node_modules", "@openscout", "runtime"),
-    join14(homedir13(), ".bun", "install", "global", "node_modules", "@openscout", "runtime"),
-    join14(homedir13(), ".bun", "install", "global", "node_modules", "@openscout", "scout", "node_modules", "@openscout", "runtime")
+    join15(homedir14(), ".bun", "node_modules", "@openscout", "runtime"),
+    join15(homedir14(), ".bun", "install", "global", "node_modules", "@openscout", "runtime"),
+    join15(homedir14(), ".bun", "install", "global", "node_modules", "@openscout", "scout", "node_modules", "@openscout", "runtime")
   ];
   for (const c of candidates) {
     if (isInstalledRuntimePackageDir(c))
@@ -13755,11 +14005,11 @@ function findGlobalRuntimeDir() {
     const result = spawnSync("which", ["scout"], { encoding: "utf8", timeout: 3000 });
     const scoutBin = result.stdout?.trim();
     if (scoutBin) {
-      const scoutPkg = resolve4(scoutBin, "..", "..");
-      const nested = join14(scoutPkg, "node_modules", "@openscout", "runtime");
+      const scoutPkg = resolve5(scoutBin, "..", "..");
+      const nested = join15(scoutPkg, "node_modules", "@openscout", "runtime");
       if (isInstalledRuntimePackageDir(nested))
         return nested;
-      const sibling = resolve4(scoutPkg, "..", "runtime");
+      const sibling = resolve5(scoutPkg, "..", "runtime");
       if (isInstalledRuntimePackageDir(sibling))
         return sibling;
     }
@@ -13767,38 +14017,24 @@ function findGlobalRuntimeDir() {
   return null;
 }
 function findWorkspaceRuntimeDir(startDir) {
-  let current = resolve4(startDir);
+  let current = resolve5(startDir);
   while (true) {
-    const candidate = join14(current, "packages", "runtime");
-    if (existsSync12(join14(candidate, "package.json")) && existsSync12(join14(candidate, "src"))) {
+    const candidate = join15(current, "packages", "runtime");
+    if (existsSync13(join15(candidate, "package.json")) && existsSync13(join15(candidate, "src"))) {
       return candidate;
     }
-    const parent = dirname5(current);
+    const parent = dirname6(current);
     if (parent === current)
       return null;
     current = parent;
   }
 }
-function resolveBunExecutable2() {
-  const explicit = process.env.OPENSCOUT_BUN_BIN ?? process.env.BUN_BIN;
-  if (explicit && explicit.trim().length > 0) {
-    return explicit;
-  }
-  if (basename3(process.execPath).startsWith("bun") && existsSync12(process.execPath)) {
-    return process.execPath;
-  }
-  const pathEntries = (process.env.PATH ?? "").split(":").filter(Boolean);
-  for (const entry of pathEntries) {
-    const candidate = join14(entry, "bun");
-    if (existsSync12(candidate)) {
-      return candidate;
-    }
-  }
-  const homeBun = join14(homedir13(), ".bun", "bin", "bun");
-  if (existsSync12(homeBun)) {
-    return homeBun;
+function resolveBunExecutable3() {
+  const bun = resolveBunExecutable2(process.env);
+  if (bun) {
+    return bun.path;
   }
-  return "bun";
+  throw new Error("Unable to locate Bun for broker service management. Install Bun or set OPENSCOUT_BUN_BIN.");
 }
 function resolveBrokerServiceMode() {
   const explicit = (process.env.OPENSCOUT_BROKER_SERVICE_MODE ?? "").trim().toLowerCase();
@@ -13837,15 +14073,15 @@ function resolveBrokerServiceConfig() {
   const label = resolveBrokerServiceLabel(mode);
   const uid = typeof process.getuid === "function" ? process.getuid() : Number.parseInt(process.env.UID ?? "0", 10);
   const supportPaths = resolveOpenScoutSupportPaths();
-  const defaultSupportDir = join14(homedir13(), "Library", "Application Support", "OpenScout");
+  const defaultSupportDir = join15(homedir14(), "Library", "Application Support", "OpenScout");
   const supportDirectory = isTmpPath(supportPaths.supportDirectory) ? defaultSupportDir : supportPaths.supportDirectory;
-  const logsDirectory = join14(supportDirectory, "logs", "broker");
-  const controlHome = isTmpPath(supportPaths.controlHome) ? join14(homedir13(), ".openscout", "control-plane") : supportPaths.controlHome;
+  const logsDirectory = join15(supportDirectory, "logs", "broker");
+  const controlHome = isTmpPath(supportPaths.controlHome) ? join15(homedir14(), ".openscout", "control-plane") : supportPaths.controlHome;
   const advertiseScope = resolveAdvertiseScope();
   const brokerHost = resolveBrokerHost(advertiseScope);
   const brokerPort = Number.parseInt(process.env.OPENSCOUT_BROKER_PORT ?? String(DEFAULT_BROKER_PORT), 10);
   const brokerUrl = process.env.OPENSCOUT_BROKER_URL ?? buildDefaultBrokerUrl(brokerHost, brokerPort);
-  const launchAgentPath = join14(homedir13(), "Library", "LaunchAgents", `${label}.plist`);
+  const launchAgentPath = join15(homedir14(), "Library", "LaunchAgents", `${label}.plist`);
   return {
     label,
     mode,
@@ -13855,11 +14091,11 @@ function resolveBrokerServiceConfig() {
     launchAgentPath,
     supportDirectory,
     logsDirectory,
-    stdoutLogPath: join14(logsDirectory, "stdout.log"),
-    stderrLogPath: join14(logsDirectory, "stderr.log"),
+    stdoutLogPath: join15(logsDirectory, "stdout.log"),
+    stderrLogPath: join15(logsDirectory, "stderr.log"),
     controlHome,
     runtimePackageDir: runtimePackageDir(),
-    bunExecutable: resolveBunExecutable2(),
+    bunExecutable: resolveBunExecutable3(),
     brokerHost,
     brokerPort,
     brokerUrl,
@@ -13876,7 +14112,7 @@ function renderLaunchAgentPlist(config) {
     OPENSCOUT_BROKER_SERVICE_MODE: config.mode,
     OPENSCOUT_BROKER_SERVICE_LABEL: config.label,
     OPENSCOUT_ADVERTISE_SCOPE: config.advertiseScope,
-    HOME: homedir13(),
+    HOME: homedir14(),
     PATH: launchPath,
     ...collectOptionalEnvVars([
       "OPENSCOUT_MESH_ID",
@@ -13902,7 +14138,7 @@ function renderLaunchAgentPlist(config) {
   <key>ProgramArguments</key>
   <array>
     <string>${xmlEscape(config.bunExecutable)}</string>
-    <string>${xmlEscape(join14(config.runtimePackageDir, "bin", "openscout-runtime.mjs"))}</string>
+    <string>${xmlEscape(join15(config.runtimePackageDir, "bin", "openscout-runtime.mjs"))}</string>
     <string>broker</string>
   </array>
   <key>WorkingDirectory</key>
@@ -13937,7 +14173,7 @@ function collectOptionalEnvVars(keys) {
 }
 function resolveLaunchAgentPATH() {
   const entries = [
-    join14(homedir13(), ".bun", "bin"),
+    join15(homedir14(), ".bun", "bin"),
     ...(process.env.PATH ?? "").split(":").filter(Boolean),
     "/opt/homebrew/bin",
     "/usr/local/bin",
@@ -13952,7 +14188,7 @@ function xmlEscape(value) {
   return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
 }
 function ensureParentDirectory(filePath) {
-  mkdirSync8(dirname5(filePath), { recursive: true });
+  mkdirSync8(dirname6(filePath), { recursive: true });
 }
 function ensureServiceDirectories(config) {
   ensureOpenScoutCleanSlateSync();
@@ -13985,7 +14221,7 @@ function launchctlPath() {
   return "/bin/launchctl";
 }
 function readLogLines(path2) {
-  if (!existsSync12(path2)) {
+  if (!existsSync13(path2)) {
     return [];
   }
   return readFileSync7(path2, "utf8").split(`
@@ -14085,7 +14321,7 @@ async function brokerServiceStatus(config = resolveBrokerServiceConfig()) {
   ensureServiceDirectories(config);
   const launchctl = inspectLaunchctl(config);
   const health = await fetchHealthSnapshot(config);
-  const installed = existsSync12(config.launchAgentPath);
+  const installed = existsSync13(config.launchAgentPath);
   const lastLogLine = health.reachable ? readLastLogLine([config.stdoutLogPath, config.stderrLogPath]) : readLastLogLine([config.stderrLogPath, config.stdoutLogPath]);
   return {
     label: config.label,
@@ -14128,7 +14364,7 @@ async function startBrokerService(config = resolveBrokerServiceConfig()) {
   throw new Error(status.lastLogLine ?? status.health.error ?? "Broker service did not become healthy.");
 }
 function sleep(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
 }
 async function stopBrokerService(config = resolveBrokerServiceConfig()) {
   runCommand(launchctlPath(), ["bootout", config.serviceTarget], { allowFailure: true });
@@ -14147,7 +14383,7 @@ async function restartBrokerService(config = resolveBrokerServiceConfig()) {
 }
 async function uninstallBrokerService(config = resolveBrokerServiceConfig()) {
   await stopBrokerService(config);
-  if (existsSync12(config.launchAgentPath)) {
+  if (existsSync13(config.launchAgentPath)) {
     rmSync2(config.launchAgentPath, { force: true });
   }
   return brokerServiceStatus(config);
@@ -14217,8 +14453,8 @@ var LOCAL_AGENT_SYSTEM_PROMPT_TEMPLATE_HINT = [
 ].join("");
 
 // ../runtime/src/local-agents.ts
-var MODULE_DIRECTORY = dirname6(fileURLToPath5(import.meta.url));
-var OPENSCOUT_REPO_ROOT = resolve5(MODULE_DIRECTORY, "..", "..", "..");
+var MODULE_DIRECTORY = dirname7(fileURLToPath5(import.meta.url));
+var OPENSCOUT_REPO_ROOT = resolve6(MODULE_DIRECTORY, "..", "..", "..");
 var DEFAULT_LOCAL_AGENT_CAPABILITIES = ["chat", "invoke", "deliver"];
 var DEFAULT_LOCAL_AGENT_HARNESS = "claude";
 function resolveRelayHub() {
@@ -14226,18 +14462,18 @@ function resolveRelayHub() {
 }
 function resolveProjectsRoot(projectPath) {
   if (process.env.OPENSCOUT_PROJECTS_ROOT?.trim()) {
-    return resolve5(process.env.OPENSCOUT_PROJECTS_ROOT.trim());
+    return resolve6(process.env.OPENSCOUT_PROJECTS_ROOT.trim());
   }
   try {
     const supportPaths = resolveOpenScoutSupportPaths();
-    if (!existsSync13(supportPaths.settingsPath)) {
-      return dirname6(projectPath);
+    if (!existsSync14(supportPaths.settingsPath)) {
+      return dirname7(projectPath);
     }
     const raw = JSON.parse(readFileSync8(supportPaths.settingsPath, "utf8"));
     const workspaceRoot = raw.discovery?.workspaceRoots?.find((entry) => typeof entry === "string" && entry.trim().length > 0);
-    return workspaceRoot ? resolve5(workspaceRoot) : dirname6(projectPath);
+    return workspaceRoot ? resolve6(workspaceRoot) : dirname7(projectPath);
   } catch {
-    return dirname6(projectPath);
+    return dirname7(projectPath);
   }
 }
 function resolveBrokerUrl() {
@@ -14247,7 +14483,7 @@ function nowSeconds2() {
   return Math.floor(Date.now() / 1000);
 }
 function scoutCliPath() {
-  return join15(OPENSCOUT_REPO_ROOT, "packages", "cli", "bin", "scout.mjs");
+  return join16(OPENSCOUT_REPO_ROOT, "packages", "cli", "bin", "scout.mjs");
 }
 function legacyNodeBrokerRelayCommand() {
   return `node ${JSON.stringify(scoutCliPath())}`;
@@ -14260,13 +14496,13 @@ function titleCaseLocalAgentName(value) {
 }
 function resolveScoutSkillPath() {
   const candidatePaths = [
-    join15(OPENSCOUT_REPO_ROOT, ".agents", "skills", "scout", "SKILL.md"),
-    join15(process.env.HOME ?? "", ".agents", "skills", "scout", "SKILL.md"),
-    join15(OPENSCOUT_REPO_ROOT, ".agents", "skills", "relay-agent-comms", "SKILL.md"),
-    join15(process.env.HOME ?? "", ".agents", "skills", "relay-agent-comms", "SKILL.md")
+    join16(OPENSCOUT_REPO_ROOT, ".agents", "skills", "scout", "SKILL.md"),
+    join16(process.env.HOME ?? "", ".agents", "skills", "scout", "SKILL.md"),
+    join16(OPENSCOUT_REPO_ROOT, ".agents", "skills", "relay-agent-comms", "SKILL.md"),
+    join16(process.env.HOME ?? "", ".agents", "skills", "relay-agent-comms", "SKILL.md")
   ];
   for (const path2 of candidatePaths) {
-    if (existsSync13(path2)) {
+    if (existsSync14(path2)) {
       return path2;
     }
   }
@@ -14317,7 +14553,7 @@ function buildLocalAgentCollaborationPrompt(context) {
 function buildLocalAgentTmuxProtocolPrompt(context) {
   return [
     "Relay protocol:",
-    `  - Read recent context with: ${context.relayCommand} read --as ${context.agentId}`,
+    `  - Read recent context when needed with: ${context.relayCommand} latest --agent ${context.agentId} --limit 20`,
     `  - Tell one agent with: ${context.relayCommand} send --as ${context.agentId} "@<agent> your message"`,
     `  - Ask one agent and stay attached with: ${context.relayCommand} ask --to <agent> --as ${context.agentId} "your request"`,
     "",
@@ -14329,9 +14565,10 @@ function buildLocalAgentTmuxProtocolPrompt(context) {
     "  - If you need multiple agents, use separate DMs or an explicit channel; do not guess a venue from multiple mentions",
     "  - Do not use channel.shared for ordinary delegation or follow-up; reserve it for explicit group updates or broadcasts",
     "  - If a short @handle may be ambiguous, resolve the exact target before sending; do not guess and do not fall back to shared",
+    "  - Treat known offline / on-demand agents as wakeable: use send or ask first and let the broker wake them; only surface ambiguity or unknown-target failures to the operator",
     "  - Use send for tells and status; use ask when the meaning is 'do this and get back to me'",
     "  - When replying to an [ask:<id>] request, include the same [ask:<id>] tag in your reply",
-    "  - Use the broker-backed relay read command above to inspect recent context before responding",
+    "  - Use the broker-backed latest command above only when recent context is needed before responding",
     `  - Follow the scout skill at ${context.scoutSkill} for agent-to-agent communication`
   ].join(`
 `);
@@ -14342,7 +14579,7 @@ function buildLocalAgentDirectProtocolPrompt(context) {
     "  - You are invoked directly by the OpenScout broker",
     "  - Return your final answer in the assistant message for the current turn",
     "  - Do not shell out to send the final answer through relay yourself",
-    `  - If you need recent relay context, inspect it with: ${context.relayCommand} read --as ${context.agentId}`,
+    `  - If you need recent broker context, inspect it with: ${context.relayCommand} latest --agent ${context.agentId} --limit 20`,
     `  - If you need to tell one agent something, use: ${context.relayCommand} send --as ${context.agentId} "@<agent> your message"`,
     `  - If you need another agent to do work, use: ${context.relayCommand} ask --to <agent> --as ${context.agentId} "your request"`,
     "  - Default Scout loop: resolve identity, resolve one target, choose DM vs explicit channel, keep follow-up in that same venue",
@@ -14350,6 +14587,7 @@ function buildLocalAgentDirectProtocolPrompt(context) {
     "  - If you need multiple agents, use separate DMs or an explicit channel; do not guess a venue from multiple mentions",
     "  - Do not use channel.shared for ordinary delegation or follow-up; reserve it for explicit group updates or broadcasts",
     "  - If a short @handle may be ambiguous, resolve the exact target before sending; do not guess and do not fall back to shared",
+    "  - Treat known offline / on-demand agents as wakeable: use send or ask first and let the broker wake them; only surface ambiguity or unknown-target failures to the operator",
     "  - Use send for tells and status; use ask when the meaning is 'do this and get back to me'",
     `  - Follow the scout skill at ${context.scoutSkill} for agent-to-agent communication`
   ].join(`
@@ -14412,7 +14650,7 @@ function buildLegacySimpleRelayPrompt(agentId, projectName, projectPath, relayCo
     "A primary agent may call into you for context, execution, follow-through, and handoff.",
     "",
     `You have full access to the codebase at ${projectPath}.`,
-    `There is a structured relay event stream at ${join15(relayHub, "channel.jsonl")} shared by all agents.`,
+    `There is a structured relay event stream at ${join16(relayHub, "channel.jsonl")} shared by all agents.`,
     "",
     "Your job:",
     `  - Respond to @${agentId} mentions from other agents`,
@@ -14516,17 +14754,17 @@ async function writeLocalAgentRegistry(registry) {
   }
   await writeRelayAgentOverrides(nextOverrides);
 }
-function expandHomePath3(value) {
+function expandHomePath4(value) {
   if (value === "~") {
     return process.env.HOME ?? process.cwd();
   }
   if (value.startsWith("~/")) {
-    return join15(process.env.HOME ?? process.cwd(), value.slice(2));
+    return join16(process.env.HOME ?? process.cwd(), value.slice(2));
   }
   return value;
 }
 function normalizeProjectPath(value) {
-  return resolve5(expandHomePath3(value.trim() || "."));
+  return resolve6(expandHomePath4(value.trim() || "."));
 }
 function normalizeTmuxSessionName2(value, agentId) {
   const fallback = `relay-${agentId}`;
@@ -14789,7 +15027,7 @@ function recordForHarness(record, harnessOverride) {
 function normalizeLocalAgentRecord(agentId, record) {
   const cwd = normalizeProjectPath(record.cwd || process.cwd());
   const projectRoot = normalizeProjectPath(record.projectRoot || cwd);
-  const project = record.project?.trim() || basename4(projectRoot);
+  const project = record.project?.trim() || basename5(projectRoot);
   const definitionId = record.definitionId?.trim() || agentId;
   const defaultHarness = activeLocalHarness(record);
   const harnessProfiles = normalizeLocalHarnessProfiles(agentId, {
@@ -14854,7 +15092,7 @@ function localAgentRecordFromResolvedConfig(config) {
 function localAgentRecordFromRelayAgentOverride(agentId, override) {
   return normalizeLocalAgentRecord(agentId, {
     definitionId: override.definitionId ?? agentId,
-    project: override.projectName ?? basename4(override.projectRoot || override.runtime?.cwd || agentId),
+    project: override.projectName ?? basename5(override.projectRoot || override.runtime?.cwd || agentId),
     projectRoot: override.projectRoot ?? override.runtime?.cwd,
     tmuxSession: override.runtime?.sessionId ?? `relay-${agentId}`,
     cwd: override.runtime?.cwd ?? override.projectRoot,
@@ -14950,7 +15188,7 @@ function buildLocalAgentBootstrapPrompt(_harness, _systemPrompt, initialMessage)
 function buildLocalAgentLaunchCommand(agentName, record, projectPath, promptFile, workerScript) {
   const extraArgs = shellQuoteArguments(normalizeLaunchArgsForHarness(normalizeLocalAgentHarness(record.harness), record.launchArgs));
   if (normalizeLocalAgentHarness(record.harness) === "codex") {
-    return `exec bash ${JSON.stringify(workerScript ?? join15(relayAgentRuntimeDirectory(agentName), "codex-worker.sh"))}`;
+    return `exec bash ${JSON.stringify(workerScript ?? join16(relayAgentRuntimeDirectory(agentName), "codex-worker.sh"))}`;
   }
   return [
     "claude",
@@ -14996,7 +15234,7 @@ async function ensureLocalAgentOnline(agentName, record) {
     return normalizedRecord;
   }
   const projectPath = normalizedRecord.cwd;
-  const projectName = normalizedRecord.project || basename4(projectPath);
+  const projectName = normalizedRecord.project || basename5(projectPath);
   const systemPromptTemplate = normalizedRecord.systemPrompt || buildLocalAgentSystemPromptTemplate();
   const systemPrompt = renderLocalAgentSystemPromptTemplate(systemPromptTemplate, buildLocalAgentTemplateContext(agentName, projectName, projectPath), { transport: normalizedRecord.transport });
   const agentRuntimeDir = relayAgentRuntimeDirectory(agentName);
@@ -15004,7 +15242,7 @@ async function ensureLocalAgentOnline(agentName, record) {
   await mkdir6(agentRuntimeDir, { recursive: true });
   await mkdir6(logsDir, { recursive: true });
   if (normalizedRecord.transport === "codex_app_server") {
-    await writeFile6(join15(agentRuntimeDir, "prompt.txt"), systemPrompt);
+    await writeFile6(join16(agentRuntimeDir, "prompt.txt"), systemPrompt);
     await ensureCodexAppServerAgentOnline(buildCodexAgentSessionOptions(agentName, normalizedRecord, systemPrompt));
     const registry2 = await readLocalAgentRegistry();
     registry2[agentName] = {
@@ -15016,7 +15254,7 @@ async function ensureLocalAgentOnline(agentName, record) {
     return registry2[agentName];
   }
   if (normalizedRecord.transport === "claude_stream_json") {
-    await writeFile6(join15(agentRuntimeDir, "prompt.txt"), systemPrompt);
+    await writeFile6(join16(agentRuntimeDir, "prompt.txt"), systemPrompt);
     await ensureClaudeStreamJsonAgentOnline(buildClaudeAgentSessionOptions(agentName, normalizedRecord, systemPrompt));
     const registry2 = await readLocalAgentRegistry();
     registry2[agentName] = {
@@ -15029,17 +15267,17 @@ async function ensureLocalAgentOnline(agentName, record) {
   }
   const initialMessage = buildLocalAgentInitialMessage(projectName, agentName);
   const bootstrapPrompt = buildLocalAgentBootstrapPrompt(normalizeLocalAgentHarness(normalizedRecord.harness), systemPrompt, initialMessage);
-  const queueDirectory = join15(agentRuntimeDir, "queue");
-  const processingDirectory = join15(queueDirectory, "processing");
-  const processedDirectory = join15(queueDirectory, "processed");
-  const promptFile = join15(agentRuntimeDir, "prompt.txt");
-  const initialFile = join15(agentRuntimeDir, "initial.txt");
-  const launchScript = join15(agentRuntimeDir, "launch.sh");
-  const workerScript = join15(agentRuntimeDir, "codex-worker.sh");
-  const codexSessionIdFile = join15(agentRuntimeDir, "codex-session-id.txt");
-  const stateFile = join15(agentRuntimeDir, "state.json");
-  const stdoutLogFile = join15(logsDir, "stdout.log");
-  const stderrLogFile = join15(logsDir, "stderr.log");
+  const queueDirectory = join16(agentRuntimeDir, "queue");
+  const processingDirectory = join16(queueDirectory, "processing");
+  const processedDirectory = join16(queueDirectory, "processed");
+  const promptFile = join16(agentRuntimeDir, "prompt.txt");
+  const initialFile = join16(agentRuntimeDir, "initial.txt");
+  const launchScript = join16(agentRuntimeDir, "launch.sh");
+  const workerScript = join16(agentRuntimeDir, "codex-worker.sh");
+  const codexSessionIdFile = join16(agentRuntimeDir, "codex-session-id.txt");
+  const stateFile = join16(agentRuntimeDir, "state.json");
+  const stdoutLogFile = join16(logsDir, "stdout.log");
+  const stderrLogFile = join16(logsDir, "stderr.log");
   await writeFile6(promptFile, systemPrompt);
   await writeFile6(initialFile, bootstrapPrompt);
   await writeFile6(stderrLogFile, "");
@@ -15101,10 +15339,10 @@ async function ensureLocalAgentOnline(agentName, record) {
     if (isLocalAgentSessionAlive(normalizedRecord.tmuxSession)) {
       break;
     }
-    await new Promise((resolve6) => setTimeout(resolve6, 100));
+    await new Promise((resolve7) => setTimeout(resolve7, 100));
   }
   if (!isLocalAgentSessionAlive(normalizedRecord.tmuxSession)) {
-    const stderrTail = existsSync13(stderrLogFile) ? readFileSync8(stderrLogFile, "utf8").trim().split(/\r?\n/).slice(-10).join(`
+    const stderrTail = existsSync14(stderrLogFile) ? readFileSync8(stderrLogFile, "utf8").trim().split(/\r?\n/).slice(-10).join(`
 `).trim() : "";
     throw new Error(stderrTail ? `Relay agent ${agentName} failed to stay online:
 ${stderrTail}` : `Relay agent ${agentName} failed to stay online.`);
@@ -15159,6 +15397,7 @@ async function startLocalAgent(input) {
   const preferredHarness = input.harness ? normalizeLocalAgentHarness(input.harness) : undefined;
   const currentDirectory = input.currentDirectory ?? projectPath;
   const effectiveCwd = input.cwdOverride ? normalizeProjectPath(input.cwdOverride) : undefined;
+  const shouldEnsureOnline = input.ensureOnline !== false;
   const requestedDefinitionId = input.agentName?.trim() ? normalizeAgentSelectorSegment(input.agentName.trim()) : "";
   if (input.agentName?.trim() && !requestedDefinitionId) {
     throw new Error(`Invalid agent name "${input.agentName}".`);
@@ -15206,7 +15445,7 @@ async function startLocalAgent(input) {
   }
   if (!matchingOverride) {
     const configDefinitionId = coldProjectConfig?.agent?.id?.trim() ? normalizeAgentSelectorSegment(coldProjectConfig.agent.id.trim()) : "";
-    const definitionId = requestedDefinitionId || configDefinitionId || normalizeAgentSelectorSegment(basename4(projectRoot)) || "agent";
+    const definitionId = requestedDefinitionId || configDefinitionId || normalizeAgentSelectorSegment(basename5(projectRoot)) || "agent";
     const configDisplayName = coldProjectConfig?.agent?.displayName?.trim() || "";
     const effectiveDisplayName = input.displayName || configDisplayName || titleCaseLocalAgentName(definitionId);
     const instance = buildRelayAgentInstance(definitionId, projectRoot);
@@ -15223,7 +15462,7 @@ async function startLocalAgent(input) {
       agentId: instance.id,
       definitionId,
       displayName: effectiveDisplayName,
-      projectName: basename4(projectRoot),
+      projectName: basename5(projectRoot),
       projectRoot,
       projectConfigPath: coldProjectConfigPath,
       source: "manual",
@@ -15263,7 +15502,7 @@ async function startLocalAgent(input) {
       agentId: instance.id,
       definitionId: requestedDefinitionId,
       displayName: input.displayName || titleCaseLocalAgentName(requestedDefinitionId),
-      projectName: matchingOverride.projectName ?? basename4(matchingProjectRoot),
+      projectName: matchingOverride.projectName ?? basename5(matchingProjectRoot),
       projectRoot: matchingProjectRoot,
       projectConfigPath: matchingOverride.projectConfigPath ?? null,
       source: "manual",
@@ -15308,12 +15547,14 @@ async function startLocalAgent(input) {
     }
     targetAgentId = matchingAgentId;
   }
-  await ensureLocalAgentBindingOnline(targetAgentId, process.env.OPENSCOUT_NODE_ID ?? "local", {
-    includeDiscovered: false,
-    currentDirectory,
-    ensureCurrentProjectConfig: false,
-    harness: preferredHarness
-  });
+  if (shouldEnsureOnline) {
+    await ensureLocalAgentBindingOnline(targetAgentId, process.env.OPENSCOUT_NODE_ID ?? "local", {
+      includeDiscovered: false,
+      currentDirectory,
+      ensureCurrentProjectConfig: false,
+      harness: preferredHarness
+    });
+  }
   const finalOverrides = await readRelayAgentOverrides();
   const finalOverride = finalOverrides[targetAgentId];
   if (!finalOverride) {
@@ -15379,8 +15620,8 @@ async function interruptLocalAgent(agentId) {
 function readPersistedClaudeSessionId(agentName) {
   try {
     const runtimeDir = relayAgentRuntimeDirectory(agentName);
-    const catalogPath = join15(runtimeDir, "session-catalog.json");
-    if (existsSync13(catalogPath)) {
+    const catalogPath = join16(runtimeDir, "session-catalog.json");
+    if (existsSync14(catalogPath)) {
       const raw = readFileSync8(catalogPath, "utf8").trim();
       if (raw) {
         const catalog = JSON.parse(raw);
@@ -15389,8 +15630,8 @@ function readPersistedClaudeSessionId(agentName) {
         }
       }
     }
-    const legacyPath = join15(runtimeDir, "claude-session-id.txt");
-    if (existsSync13(legacyPath)) {
+    const legacyPath = join16(runtimeDir, "claude-session-id.txt");
+    if (existsSync14(legacyPath)) {
       const value = readFileSync8(legacyPath, "utf8").trim();
       return value || null;
     }
@@ -15584,6 +15825,7 @@ var scoutBrokerPaths = {
     endpoints: "/v1/endpoints",
     conversations: "/v1/conversations",
     invocations: "/v1/invocations",
+    deliver: "/v1/deliver",
     activity: "/v1/activity",
     collaborationRecords: "/v1/collaboration/records",
     collaborationEvents: "/v1/collaboration/events"
@@ -15613,29 +15855,6 @@ function titleCaseName(value) {
 function displayNameForBrokerActor(snapshot, actorId) {
   return snapshot.agents[actorId]?.displayName ?? snapshot.actors[actorId]?.displayName ?? titleCaseName(metadataString2(snapshot.agents[actorId]?.metadata, "definitionId") || actorId);
 }
-function firstEndpointForActor(snapshot, actorId) {
-  return Object.values(snapshot.endpoints).filter((endpoint) => endpoint.agentId === actorId).sort((lhs, rhs) => lhs.id.localeCompare(rhs.id))[0];
-}
-function buildScoutReturnAddress2(snapshot, actorId, options = {}) {
-  const agent = snapshot.agents[actorId];
-  const actor = snapshot.actors[actorId];
-  const endpoint = firstEndpointForActor(snapshot, actorId);
-  const selector = agent?.selector?.trim() || metadataString2(agent?.metadata, "selector") || metadataString2(actor?.metadata, "selector");
-  const defaultSelector = agent?.defaultSelector?.trim() || metadataString2(agent?.metadata, "defaultSelector") || metadataString2(actor?.metadata, "defaultSelector");
-  const projectRoot = endpoint?.projectRoot ?? endpoint?.cwd ?? metadataString2(agent?.metadata, "projectRoot") ?? metadataString2(actor?.metadata, "projectRoot");
-  return buildScoutReturnAddress({
-    actorId,
-    handle: agent?.handle?.trim() || actor?.handle?.trim() || actorId,
-    displayName: agent?.displayName || actor?.displayName,
-    selector,
-    defaultSelector,
-    conversationId: options.conversationId,
-    replyToMessageId: options.replyToMessageId,
-    nodeId: endpoint?.nodeId || agent?.authorityNodeId || agent?.homeNodeId,
-    projectRoot,
-    sessionId: endpoint?.sessionId
-  });
-}
 function metadataString2(metadata, key) {
   const value = metadata?.[key];
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
@@ -15938,74 +16157,42 @@ async function openScoutPeerSession(input) {
   };
 }
 async function sendScoutDirectMessage(input) {
-  const currentDirectory = input.currentDirectory ?? process.cwd();
-  const directSession = await openScoutPeerSession({
-    sourceId: OPERATOR_ID,
-    targetId: input.agentId,
-    currentDirectory
-  });
   const broker = await requireScoutBrokerContext();
   const createdAt = Date.now();
-  const messageId = `msg-${createdAt.toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
   const source = input.source?.trim() || "scout-mobile";
-  const targetAgentId = directSession.targetId;
-  const targetAgent = broker.snapshot.agents[targetAgentId] ?? ("agent" in directSession ? directSession.agent : undefined);
-  const targetLabel = `@${targetAgent?.handle?.trim() || targetAgent?.displayName?.trim() || targetAgentId}`;
-  const returnAddress = buildScoutReturnAddress2(broker.snapshot, OPERATOR_ID, {
-    conversationId: directSession.conversation.id,
-    replyToMessageId: messageId
-  });
-  await brokerPostJson(broker.baseUrl, scoutBrokerPaths.v1.messages, {
-    id: messageId,
-    conversationId: directSession.conversation.id,
-    replyToMessageId: input.replyToMessageId ?? undefined,
-    actorId: OPERATOR_ID,
-    originNodeId: broker.node.id,
-    class: "agent",
+  const delivery = await brokerPostJson(broker.baseUrl, scoutBrokerPaths.v1.deliver, {
+    id: `deliver-${createdAt.toString(36)}-${Math.random().toString(36).slice(2, 8)}`,
+    requesterId: OPERATOR_ID,
+    requesterNodeId: broker.node.id,
+    targetAgentId: input.agentId,
     body: input.body.trim(),
-    mentions: [{ actorId: targetAgentId, label: targetLabel }],
-    audience: {
-      notify: [targetAgentId],
-      reason: "direct_message"
-    },
-    visibility: "private",
-    policy: "durable",
+    intent: "consult",
+    replyToMessageId: input.replyToMessageId ?? undefined,
+    execution: input.executionHarness ? { harness: input.executionHarness } : undefined,
+    ensureAwake: true,
     createdAt,
-    metadata: {
+    messageMetadata: {
       source,
       destinationKind: "direct",
-      destinationId: targetAgentId,
+      destinationId: input.agentId,
       referenceMessageIds: input.referenceMessageIds ?? [],
       clientMessageId: input.clientMessageId ?? null,
-      returnAddress,
       ...input.deviceId ? { deviceId: input.deviceId } : {}
-    }
-  });
-  const invocationResponse = await brokerPostJson(broker.baseUrl, scoutBrokerPaths.v1.invocations, {
-    id: `inv-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`,
-    requesterId: OPERATOR_ID,
-    requesterNodeId: broker.node.id,
-    targetAgentId,
-    action: "consult",
-    task: input.body.trim(),
-    conversationId: directSession.conversation.id,
-    messageId,
-    execution: input.executionHarness ? { harness: input.executionHarness } : undefined,
-    ensureAwake: true,
-    stream: false,
-    createdAt,
-    metadata: {
+    },
+    invocationMetadata: {
       source,
       destinationKind: "direct",
-      destinationId: targetAgentId,
-      returnAddress,
+      destinationId: input.agentId,
       ...input.deviceId ? { deviceId: input.deviceId } : {}
     }
   });
+  if (delivery.kind !== "delivery") {
+    throw new Error(delivery.kind === "question" ? delivery.question.detail : delivery.rejection.detail);
+  }
   return {
-    conversationId: directSession.conversation.id,
-    messageId,
-    flight: invocationResponse.flight
+    conversationId: delivery.conversation.id,
+    messageId: delivery.message.id,
+    flight: delivery.flight
   };
 }
 async function loadScoutActivityItems(options = {}) {
@@ -16032,11 +16219,11 @@ async function upScoutAgent(input) {
 
 // ../../apps/desktop/src/server/db-queries.ts
 import { Database } from "bun:sqlite";
-import { homedir as homedir14 } from "os";
-import { join as join16 } from "path";
+import { homedir as homedir15 } from "os";
+import { join as join17 } from "path";
 function resolveDbPath() {
-  const controlHome = process.env.OPENSCOUT_CONTROL_HOME ?? join16(homedir14(), ".openscout", "control-plane");
-  return join16(controlHome, "control-plane.sqlite");
+  const controlHome = process.env.OPENSCOUT_CONTROL_HOME ?? join17(homedir15(), ".openscout", "control-plane");
+  return join17(controlHome, "control-plane.sqlite");
 }
 var _db = null;
 function db() {
@@ -16047,7 +16234,7 @@ function db() {
   }
   return _db;
 }
-var HOME = homedir14();
+var HOME = homedir15();
 function compact(p) {
   if (!p)
     return null;
@@ -16703,8 +16890,8 @@ async function createScoutSession(input, currentDirectory, deviceId) {
   if (!rawWorkspaceId) {
     throw new Error(`Invalid workspaceId.`);
   }
-  const workspaceRoot = resolve6(rawWorkspaceId);
-  const projectName = basename5(workspaceRoot) || workspaceRoot;
+  const workspaceRoot = resolve7(rawWorkspaceId);
+  const projectName = basename6(workspaceRoot) || workspaceRoot;
   const workspace = {
     id: workspaceRoot,
     title: projectName,
@@ -16813,17 +17000,17 @@ async function deriveNewAgentName(projectName, branch, harness) {
 }
 async function createGitWorktree(projectRoot, agentName) {
   const { execSync: execSync3 } = await import("child_process");
-  const { join: join17 } = await import("path");
-  const { mkdirSync: mkdirSync9, existsSync: existsSync14 } = await import("fs");
+  const { join: join18 } = await import("path");
+  const { mkdirSync: mkdirSync9, existsSync: existsSync15 } = await import("fs");
   try {
     execSync3("git rev-parse --git-dir", { cwd: projectRoot, stdio: "pipe" });
   } catch {
     return null;
   }
   const branchName = `scout/${agentName}`;
-  const worktreeDir = join17(projectRoot, ".scout-worktrees");
-  const worktreePath = join17(worktreeDir, agentName);
-  if (existsSync14(worktreePath)) {
+  const worktreeDir = join18(projectRoot, ".scout-worktrees");
+  const worktreePath = join18(worktreeDir, agentName);
+  if (existsSync15(worktreePath)) {
     return { path: worktreePath, branch: branchName };
   }
   mkdirSync9(worktreeDir, { recursive: true });
@@ -17027,9 +17214,9 @@ async function handleRPCInner(bridge, req, deviceId) {
       }
       case "session/resume": {
         const p = req.params;
-        const sessionFilename = basename6(p.sessionPath, ".jsonl");
+        const sessionFilename = basename7(p.sessionPath, ".jsonl");
         const parentDir = p.sessionPath.substring(0, p.sessionPath.lastIndexOf("/"));
-        const dirName = basename6(parentDir);
+        const dirName = basename7(parentDir);
         let cwd;
         if (dirName.startsWith("-")) {
           const candidate = "/" + dirName.slice(1).replace(/-/g, "/");
@@ -17096,7 +17283,7 @@ async function handleRPCInner(bridge, req, deviceId) {
           return { id: req.id, error: { code: -32000, message: "Workspace target is not a directory" } };
         }
         const adapterType = p.adapter ?? "claude-code";
-        const name = p.name ?? basename6(projectPath);
+        const name = p.name ?? basename7(projectPath);
         const session = await bridge.createSession(adapterType, {
           name,
           cwd: projectPath
@@ -17336,13 +17523,13 @@ function resolveMobileCurrentDirectory() {
   }
 }
 function resolveWorkspaceRoot(root) {
-  const expandedRoot = root.replace(/^~/, homedir15());
+  const expandedRoot = root.replace(/^~/, homedir16());
   return realpathSync(expandedRoot);
 }
 function resolveWorkspacePath(root, requestedPath) {
   const normalizedRoot = resolveWorkspaceRoot(root);
-  const expandedPath = requestedPath?.replace(/^~/, homedir15());
-  const candidate = expandedPath ? isAbsolute3(expandedPath) ? expandedPath : join17(normalizedRoot, expandedPath) : normalizedRoot;
+  const expandedPath = requestedPath?.replace(/^~/, homedir16());
+  const candidate = expandedPath ? isAbsolute3(expandedPath) ? expandedPath : join18(normalizedRoot, expandedPath) : normalizedRoot;
   const resolvedCandidate = realpathSync(candidate);
   const rel = relative2(normalizedRoot, resolvedCandidate);
   if (rel === "" || !rel.startsWith("..") && !isAbsolute3(rel)) {
@@ -17372,7 +17559,7 @@ function listDirectories(dirPath) {
       continue;
     if (name === "node_modules" || name === ".build" || name === "target")
       continue;
-    const fullPath = join17(dirPath, name);
+    const fullPath = join18(dirPath, name);
     try {
       const stat4 = statSync3(fullPath);
       if (!stat4.isDirectory())
@@ -17395,7 +17582,7 @@ function listDirectories(dirPath) {
   return entries.sort((a, b) => a.name.localeCompare(b.name));
 }
 async function discoverSessionFiles(maxAgeDays, limit) {
-  const home = homedir15();
+  const home = homedir16();
   const results = [];
   const searchPaths = [
     { pattern: `${home}/.claude/projects`, agent: "claude-code" },
@@ -31932,2189 +32119,12 @@ function date4(params) {
 
 // ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/external.js
 config(en_default());
-// ../runtime/src/registry.ts
-function createRuntimeRegistrySnapshot(value = {}) {
-  return {
-    nodes: value.nodes ?? {},
-    actors: value.actors ?? {},
-    agents: value.agents ?? {},
-    endpoints: value.endpoints ?? {},
-    conversations: value.conversations ?? {},
-    bindings: value.bindings ?? {},
-    messages: value.messages ?? {},
-    flights: value.flights ?? {},
-    collaborationRecords: value.collaborationRecords ?? {}
-  };
-}
-// ../runtime/src/planner.ts
-function createDeliveryId(messageId, targetId, reason, transport) {
-  return `del-${messageId}-${targetId}-${reason}-${transport}`;
-}
-function unique(values) {
-  return [...new Set(values)];
-}
-function resolveVisibilityAudience(message, conversation) {
-  if (message.audience?.visibleTo?.length) {
-    return unique(message.audience.visibleTo);
-  }
-  return unique(conversation.participantIds.filter((participantId) => participantId !== message.actorId));
-}
-function resolveNotifyAudience(message) {
-  const fromMentions = (message.mentions ?? []).map((mention) => mention.actorId);
-  const explicit = message.audience?.notify ?? [];
-  return unique([...fromMentions, ...explicit].filter((actorId) => actorId !== message.actorId));
-}
-function resolveInvocationAudience(message) {
-  return unique((message.audience?.invoke ?? []).filter((actorId) => actorId !== message.actorId));
-}
-function planTargetDelivery(message, route2, reason, policy) {
-  return {
-    id: createDeliveryId(message.id, route2.targetId, reason, route2.transport),
-    messageId: message.id,
-    targetId: route2.targetId,
-    targetNodeId: route2.nodeId,
-    targetKind: route2.targetKind,
-    transport: route2.transport,
-    reason,
-    policy,
-    status: "pending",
-    bindingId: route2.bindingId
-  };
-}
-function planMessageDeliveries(input) {
-  const visibilityIds = new Set(resolveVisibilityAudience(input.message, input.conversation));
-  const notifyIds = new Set(resolveNotifyAudience(input.message));
-  const invokeIds = new Set(resolveInvocationAudience(input.message));
-  const deliveries2 = new Map;
-  for (const route2 of input.participantRoutes) {
-    if (visibilityIds.has(route2.targetId)) {
-      const intent = planTargetDelivery(input.message, {
-        ...route2,
-        transport: route2.nodeId && input.localNodeId && route2.nodeId !== input.localNodeId ? "peer_broker" : route2.transport
-      }, input.conversation.kind === "direct" || input.conversation.kind === "group_direct" ? "direct_message" : "conversation_visibility", "durable");
-      deliveries2.set(intent.id, intent);
-    }
-    if (notifyIds.has(route2.targetId)) {
-      const intent = planTargetDelivery(input.message, {
-        ...route2,
-        transport: route2.nodeId && input.localNodeId && route2.nodeId !== input.localNodeId ? "peer_broker" : route2.transport
-      }, "mention", "must_ack");
-      deliveries2.set(intent.id, intent);
-    }
-    if (invokeIds.has(route2.targetId)) {
-      const intent = planTargetDelivery(input.message, {
-        ...route2,
-        transport: route2.nodeId && input.localNodeId && route2.nodeId !== input.localNodeId ? "peer_broker" : route2.transport
-      }, "invocation", "must_ack");
-      deliveries2.set(intent.id, intent);
-    }
-    if (input.message.speech?.text && route2.speechEnabled) {
-      const speechIntent = planTargetDelivery(input.message, {
-        ...route2,
-        transport: route2.transport === "local_socket" ? "native_voice" : "tts",
-        targetKind: route2.targetKind === "device" ? "voice_session" : route2.targetKind
-      }, "speech", "best_effort");
-      deliveries2.set(speechIntent.id, speechIntent);
-    }
-  }
-  for (const route2 of input.bindingRoutes ?? []) {
-    const intent = planTargetDelivery(input.message, route2, "bridge_outbound", "durable");
-    deliveries2.set(intent.id, intent);
-  }
-  return [...deliveries2.values()];
-}
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/entity.js
-var entityKind = Symbol.for("drizzle:entityKind");
-var hasOwnEntityKind = Symbol.for("drizzle:hasOwnEntityKind");
-function is(value, type) {
-  if (!value || typeof value !== "object") {
-    return false;
-  }
-  if (value instanceof type) {
-    return true;
-  }
-  if (!Object.prototype.hasOwnProperty.call(type, entityKind)) {
-    throw new Error(`Class "${type.name ?? "<unknown>"}" doesn't look like a Drizzle entity. If this is incorrect and the class is provided by Drizzle, please report this as a bug.`);
-  }
-  let cls = Object.getPrototypeOf(value).constructor;
-  if (cls) {
-    while (cls) {
-      if (entityKind in cls && cls[entityKind] === type[entityKind]) {
-        return true;
-      }
-      cls = Object.getPrototypeOf(cls);
-    }
-  }
-  return false;
-}
-
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/column.js
-class Column {
-  constructor(table, config2) {
-    this.table = table;
-    this.config = config2;
-    this.name = config2.name;
-    this.keyAsName = config2.keyAsName;
-    this.notNull = config2.notNull;
-    this.default = config2.default;
-    this.defaultFn = config2.defaultFn;
-    this.onUpdateFn = config2.onUpdateFn;
-    this.hasDefault = config2.hasDefault;
-    this.primary = config2.primaryKey;
-    this.isUnique = config2.isUnique;
-    this.uniqueName = config2.uniqueName;
-    this.uniqueType = config2.uniqueType;
-    this.dataType = config2.dataType;
-    this.columnType = config2.columnType;
-    this.generated = config2.generated;
-    this.generatedIdentity = config2.generatedIdentity;
-  }
-  static [entityKind] = "Column";
-  name;
-  keyAsName;
-  primary;
-  notNull;
-  default;
-  defaultFn;
-  onUpdateFn;
-  hasDefault;
-  isUnique;
-  uniqueName;
-  uniqueType;
-  dataType;
-  columnType;
-  enumValues = undefined;
-  generated = undefined;
-  generatedIdentity = undefined;
-  config;
-  mapFromDriverValue(value) {
-    return value;
-  }
-  mapToDriverValue(value) {
-    return value;
-  }
-  shouldDisableInsert() {
-    return this.config.generated !== undefined && this.config.generated.type !== "byDefault";
-  }
-}
-
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/column-builder.js
-class ColumnBuilder {
-  static [entityKind] = "ColumnBuilder";
-  config;
-  constructor(name, dataType, columnType) {
-    this.config = {
-      name,
-      keyAsName: name === "",
-      notNull: false,
-      default: undefined,
-      hasDefault: false,
-      primaryKey: false,
-      isUnique: false,
-      uniqueName: undefined,
-      uniqueType: undefined,
-      dataType,
-      columnType,
-      generated: undefined
-    };
-  }
-  $type() {
-    return this;
-  }
-  notNull() {
-    this.config.notNull = true;
-    return this;
-  }
-  default(value) {
-    this.config.default = value;
-    this.config.hasDefault = true;
-    return this;
-  }
-  $defaultFn(fn) {
-    this.config.defaultFn = fn;
-    this.config.hasDefault = true;
-    return this;
-  }
-  $default = this.$defaultFn;
-  $onUpdateFn(fn) {
-    this.config.onUpdateFn = fn;
-    this.config.hasDefault = true;
-    return this;
-  }
-  $onUpdate = this.$onUpdateFn;
-  primaryKey() {
-    this.config.primaryKey = true;
-    this.config.notNull = true;
-    return this;
-  }
-  setName(name) {
-    if (this.config.name !== "")
-      return;
-    this.config.name = name;
-  }
-}
-
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/table.utils.js
-var TableName = Symbol.for("drizzle:Name");
-
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/tracing-utils.js
-function iife(fn, ...args) {
-  return fn(...args);
-}
-
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/pg-core/unique-constraint.js
-function uniqueKeyName(table, columns) {
-  return `${table[TableName]}_${columns.join("_")}_unique`;
-}
-
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/pg-core/columns/common.js
-class PgColumn extends Column {
-  constructor(table, config2) {
-    if (!config2.uniqueName) {
-      config2.uniqueName = uniqueKeyName(table, [config2.name]);
-    }
-    super(table, config2);
-    this.table = table;
-  }
-  static [entityKind] = "PgColumn";
-}
-
-class ExtraConfigColumn extends PgColumn {
-  static [entityKind] = "ExtraConfigColumn";
-  getSQLType() {
-    return this.getSQLType();
-  }
-  indexConfig = {
-    order: this.config.order ?? "asc",
-    nulls: this.config.nulls ?? "last",
-    opClass: this.config.opClass
-  };
-  defaultConfig = {
-    order: "asc",
-    nulls: "last",
-    opClass: undefined
-  };
-  asc() {
-    this.indexConfig.order = "asc";
-    return this;
-  }
-  desc() {
-    this.indexConfig.order = "desc";
-    return this;
-  }
-  nullsFirst() {
-    this.indexConfig.nulls = "first";
-    return this;
-  }
-  nullsLast() {
-    this.indexConfig.nulls = "last";
-    return this;
-  }
-  op(opClass) {
-    this.indexConfig.opClass = opClass;
-    return this;
-  }
-}
-
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/pg-core/columns/enum.js
-class PgEnumObjectColumn extends PgColumn {
-  static [entityKind] = "PgEnumObjectColumn";
-  enum;
-  enumValues = this.config.enum.enumValues;
-  constructor(table, config2) {
-    super(table, config2);
-    this.enum = config2.enum;
-  }
-  getSQLType() {
-    return this.enum.enumName;
-  }
-}
-var isPgEnumSym = Symbol.for("drizzle:isPgEnum");
-function isPgEnum(obj) {
-  return !!obj && typeof obj === "function" && isPgEnumSym in obj && obj[isPgEnumSym] === true;
-}
-class PgEnumColumn extends PgColumn {
-  static [entityKind] = "PgEnumColumn";
-  enum = this.config.enum;
-  enumValues = this.config.enum.enumValues;
-  constructor(table, config2) {
-    super(table, config2);
-    this.enum = config2.enum;
-  }
-  getSQLType() {
-    return this.enum.enumName;
-  }
-}
-
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/subquery.js
-class Subquery {
-  static [entityKind] = "Subquery";
-  constructor(sql, fields, alias, isWith = false, usedTables = []) {
-    this._ = {
-      brand: "Subquery",
-      sql,
-      selectedFields: fields,
-      alias,
-      isWith,
-      usedTables
-    };
-  }
-}
-
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/version.js
-var version2 = "0.45.2";
-
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/tracing.js
-var otel;
-var rawTracer;
-var tracer = {
-  startActiveSpan(name, fn) {
-    if (!otel) {
-      return fn();
-    }
-    if (!rawTracer) {
-      rawTracer = otel.trace.getTracer("drizzle-orm", version2);
-    }
-    return iife((otel2, rawTracer2) => rawTracer2.startActiveSpan(name, (span) => {
-      try {
-        return fn(span);
-      } catch (e) {
-        span.setStatus({
-          code: otel2.SpanStatusCode.ERROR,
-          message: e instanceof Error ? e.message : "Unknown error"
-        });
-        throw e;
-      } finally {
-        span.end();
-      }
-    }), otel, rawTracer);
-  }
-};
-
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/view-common.js
-var ViewBaseConfig = Symbol.for("drizzle:ViewBaseConfig");
-
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/table.js
-var Schema = Symbol.for("drizzle:Schema");
-var Columns = Symbol.for("drizzle:Columns");
-var ExtraConfigColumns = Symbol.for("drizzle:ExtraConfigColumns");
-var OriginalName = Symbol.for("drizzle:OriginalName");
-var BaseName = Symbol.for("drizzle:BaseName");
-var IsAlias = Symbol.for("drizzle:IsAlias");
-var ExtraConfigBuilder = Symbol.for("drizzle:ExtraConfigBuilder");
-var IsDrizzleTable = Symbol.for("drizzle:IsDrizzleTable");
-
-class Table {
-  static [entityKind] = "Table";
-  static Symbol = {
-    Name: TableName,
-    Schema,
-    OriginalName,
-    Columns,
-    ExtraConfigColumns,
-    BaseName,
-    IsAlias,
-    ExtraConfigBuilder
-  };
-  [TableName];
-  [OriginalName];
-  [Schema];
-  [Columns];
-  [ExtraConfigColumns];
-  [BaseName];
-  [IsAlias] = false;
-  [IsDrizzleTable] = true;
-  [ExtraConfigBuilder] = undefined;
-  constructor(name, schema, baseName) {
-    this[TableName] = this[OriginalName] = name;
-    this[Schema] = schema;
-    this[BaseName] = baseName;
-  }
-}
-
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sql/sql.js
-function isSQLWrapper(value) {
-  return value !== null && value !== undefined && typeof value.getSQL === "function";
-}
-function mergeQueries(queries) {
-  const result = { sql: "", params: [] };
-  for (const query of queries) {
-    result.sql += query.sql;
-    result.params.push(...query.params);
-    if (query.typings?.length) {
-      if (!result.typings) {
-        result.typings = [];
-      }
-      result.typings.push(...query.typings);
-    }
-  }
-  return result;
-}
-
-class StringChunk {
-  static [entityKind] = "StringChunk";
-  value;
-  constructor(value) {
-    this.value = Array.isArray(value) ? value : [value];
-  }
-  getSQL() {
-    return new SQL([this]);
-  }
-}
-
-class SQL {
-  constructor(queryChunks) {
-    this.queryChunks = queryChunks;
-    for (const chunk of queryChunks) {
-      if (is(chunk, Table)) {
-        const schemaName = chunk[Table.Symbol.Schema];
-        this.usedTables.push(schemaName === undefined ? chunk[Table.Symbol.Name] : schemaName + "." + chunk[Table.Symbol.Name]);
-      }
-    }
-  }
-  static [entityKind] = "SQL";
-  decoder = noopDecoder;
-  shouldInlineParams = false;
-  usedTables = [];
-  append(query) {
-    this.queryChunks.push(...query.queryChunks);
-    return this;
-  }
-  toQuery(config2) {
-    return tracer.startActiveSpan("drizzle.buildSQL", (span) => {
-      const query = this.buildQueryFromSourceParams(this.queryChunks, config2);
-      span?.setAttributes({
-        "drizzle.query.text": query.sql,
-        "drizzle.query.params": JSON.stringify(query.params)
-      });
-      return query;
-    });
-  }
-  buildQueryFromSourceParams(chunks, _config) {
-    const config2 = Object.assign({}, _config, {
-      inlineParams: _config.inlineParams || this.shouldInlineParams,
-      paramStartIndex: _config.paramStartIndex || { value: 0 }
-    });
-    const {
-      casing,
-      escapeName,
-      escapeParam,
-      prepareTyping,
-      inlineParams,
-      paramStartIndex
-    } = config2;
-    return mergeQueries(chunks.map((chunk) => {
-      if (is(chunk, StringChunk)) {
-        return { sql: chunk.value.join(""), params: [] };
-      }
-      if (is(chunk, Name)) {
-        return { sql: escapeName(chunk.value), params: [] };
-      }
-      if (chunk === undefined) {
-        return { sql: "", params: [] };
-      }
-      if (Array.isArray(chunk)) {
-        const result = [new StringChunk("(")];
-        for (const [i, p] of chunk.entries()) {
-          result.push(p);
-          if (i < chunk.length - 1) {
-            result.push(new StringChunk(", "));
-          }
-        }
-        result.push(new StringChunk(")"));
-        return this.buildQueryFromSourceParams(result, config2);
-      }
-      if (is(chunk, SQL)) {
-        return this.buildQueryFromSourceParams(chunk.queryChunks, {
-          ...config2,
-          inlineParams: inlineParams || chunk.shouldInlineParams
-        });
-      }
-      if (is(chunk, Table)) {
-        const schemaName = chunk[Table.Symbol.Schema];
-        const tableName = chunk[Table.Symbol.Name];
-        return {
-          sql: schemaName === undefined || chunk[IsAlias] ? escapeName(tableName) : escapeName(schemaName) + "." + escapeName(tableName),
-          params: []
-        };
-      }
-      if (is(chunk, Column)) {
-        const columnName = casing.getColumnCasing(chunk);
-        if (_config.invokeSource === "indexes") {
-          return { sql: escapeName(columnName), params: [] };
-        }
-        const schemaName = chunk.table[Table.Symbol.Schema];
-        return {
-          sql: chunk.table[IsAlias] || schemaName === undefined ? escapeName(chunk.table[Table.Symbol.Name]) + "." + escapeName(columnName) : escapeName(schemaName) + "." + escapeName(chunk.table[Table.Symbol.Name]) + "." + escapeName(columnName),
-          params: []
-        };
-      }
-      if (is(chunk, View)) {
-        const schemaName = chunk[ViewBaseConfig].schema;
-        const viewName = chunk[ViewBaseConfig].name;
-        return {
-          sql: schemaName === undefined || chunk[ViewBaseConfig].isAlias ? escapeName(viewName) : escapeName(schemaName) + "." + escapeName(viewName),
-          params: []
-        };
-      }
-      if (is(chunk, Param)) {
-        if (is(chunk.value, Placeholder)) {
-          return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
-        }
-        const mappedValue = chunk.value === null ? null : chunk.encoder.mapToDriverValue(chunk.value);
-        if (is(mappedValue, SQL)) {
-          return this.buildQueryFromSourceParams([mappedValue], config2);
-        }
-        if (inlineParams) {
-          return { sql: this.mapInlineParam(mappedValue, config2), params: [] };
-        }
-        let typings = ["none"];
-        if (prepareTyping) {
-          typings = [prepareTyping(chunk.encoder)];
-        }
-        return { sql: escapeParam(paramStartIndex.value++, mappedValue), params: [mappedValue], typings };
-      }
-      if (is(chunk, Placeholder)) {
-        return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
-      }
-      if (is(chunk, SQL.Aliased) && chunk.fieldAlias !== undefined) {
-        return { sql: escapeName(chunk.fieldAlias), params: [] };
-      }
-      if (is(chunk, Subquery)) {
-        if (chunk._.isWith) {
-          return { sql: escapeName(chunk._.alias), params: [] };
-        }
-        return this.buildQueryFromSourceParams([
-          new StringChunk("("),
-          chunk._.sql,
-          new StringChunk(") "),
-          new Name(chunk._.alias)
-        ], config2);
-      }
-      if (isPgEnum(chunk)) {
-        if (chunk.schema) {
-          return { sql: escapeName(chunk.schema) + "." + escapeName(chunk.enumName), params: [] };
-        }
-        return { sql: escapeName(chunk.enumName), params: [] };
-      }
-      if (isSQLWrapper(chunk)) {
-        if (chunk.shouldOmitSQLParens?.()) {
-          return this.buildQueryFromSourceParams([chunk.getSQL()], config2);
-        }
-        return this.buildQueryFromSourceParams([
-          new StringChunk("("),
-          chunk.getSQL(),
-          new StringChunk(")")
-        ], config2);
-      }
-      if (inlineParams) {
-        return { sql: this.mapInlineParam(chunk, config2), params: [] };
-      }
-      return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
-    }));
-  }
-  mapInlineParam(chunk, { escapeString }) {
-    if (chunk === null) {
-      return "null";
-    }
-    if (typeof chunk === "number" || typeof chunk === "boolean") {
-      return chunk.toString();
-    }
-    if (typeof chunk === "string") {
-      return escapeString(chunk);
-    }
-    if (typeof chunk === "object") {
-      const mappedValueAsString = chunk.toString();
-      if (mappedValueAsString === "[object Object]") {
-        return escapeString(JSON.stringify(chunk));
-      }
-      return escapeString(mappedValueAsString);
-    }
-    throw new Error("Unexpected param value: " + chunk);
-  }
-  getSQL() {
-    return this;
-  }
-  as(alias) {
-    if (alias === undefined) {
-      return this;
-    }
-    return new SQL.Aliased(this, alias);
-  }
-  mapWith(decoder) {
-    this.decoder = typeof decoder === "function" ? { mapFromDriverValue: decoder } : decoder;
-    return this;
-  }
-  inlineParams() {
-    this.shouldInlineParams = true;
-    return this;
-  }
-  if(condition) {
-    return condition ? this : undefined;
-  }
-}
-
-class Name {
-  constructor(value) {
-    this.value = value;
-  }
-  static [entityKind] = "Name";
-  brand;
-  getSQL() {
-    return new SQL([this]);
-  }
-}
-var noopDecoder = {
-  mapFromDriverValue: (value) => value
-};
-var noopEncoder = {
-  mapToDriverValue: (value) => value
-};
-var noopMapper = {
-  ...noopDecoder,
-  ...noopEncoder
-};
-
-class Param {
-  constructor(value, encoder = noopEncoder) {
-    this.value = value;
-    this.encoder = encoder;
-  }
-  static [entityKind] = "Param";
-  brand;
-  getSQL() {
-    return new SQL([this]);
-  }
-}
-function sql(strings, ...params) {
-  const queryChunks = [];
-  if (params.length > 0 || strings.length > 0 && strings[0] !== "") {
-    queryChunks.push(new StringChunk(strings[0]));
-  }
-  for (const [paramIndex, param2] of params.entries()) {
-    queryChunks.push(param2, new StringChunk(strings[paramIndex + 1]));
-  }
-  return new SQL(queryChunks);
-}
-((sql2) => {
-  function empty() {
-    return new SQL([]);
-  }
-  sql2.empty = empty;
-  function fromList(list) {
-    return new SQL(list);
-  }
-  sql2.fromList = fromList;
-  function raw(str) {
-    return new SQL([new StringChunk(str)]);
-  }
-  sql2.raw = raw;
-  function join18(chunks, separator) {
-    const result = [];
-    for (const [i, chunk] of chunks.entries()) {
-      if (i > 0 && separator !== undefined) {
-        result.push(separator);
-      }
-      result.push(chunk);
-    }
-    return new SQL(result);
-  }
-  sql2.join = join18;
-  function identifier(value) {
-    return new Name(value);
-  }
-  sql2.identifier = identifier;
-  function placeholder2(name2) {
-    return new Placeholder(name2);
-  }
-  sql2.placeholder = placeholder2;
-  function param2(value, encoder) {
-    return new Param(value, encoder);
-  }
-  sql2.param = param2;
-})(sql || (sql = {}));
-((SQL2) => {
-
-  class Aliased {
-    constructor(sql2, fieldAlias) {
-      this.sql = sql2;
-      this.fieldAlias = fieldAlias;
-    }
-    static [entityKind] = "SQL.Aliased";
-    isSelectionField = false;
-    getSQL() {
-      return this.sql;
-    }
-    clone() {
-      return new Aliased(this.sql, this.fieldAlias);
-    }
-  }
-  SQL2.Aliased = Aliased;
-})(SQL || (SQL = {}));
-
-class Placeholder {
-  constructor(name2) {
-    this.name = name2;
-  }
-  static [entityKind] = "Placeholder";
-  getSQL() {
-    return new SQL([this]);
-  }
-}
-var IsDrizzleView = Symbol.for("drizzle:IsDrizzleView");
-
-class View {
-  static [entityKind] = "View";
-  [ViewBaseConfig];
-  [IsDrizzleView] = true;
-  constructor({ name: name2, schema, selectedFields, query }) {
-    this[ViewBaseConfig] = {
-      name: name2,
-      originalName: name2,
-      schema,
-      selectedFields,
-      query,
-      isExisting: !query,
-      isAlias: false
-    };
-  }
-  getSQL() {
-    return new SQL([this]);
-  }
-}
-Column.prototype.getSQL = function() {
-  return new SQL([this]);
-};
-Table.prototype.getSQL = function() {
-  return new SQL([this]);
-};
-Subquery.prototype.getSQL = function() {
-  return new SQL([this]);
-};
-
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/utils.js
-function getColumnNameAndConfig(a, b) {
-  return {
-    name: typeof a === "string" && a.length > 0 ? a : "",
-    config: typeof a === "object" ? a : b
-  };
-}
-var textDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder;
-
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/foreign-keys.js
-class ForeignKeyBuilder {
-  static [entityKind] = "SQLiteForeignKeyBuilder";
-  reference;
-  _onUpdate;
-  _onDelete;
-  constructor(config2, actions) {
-    this.reference = () => {
-      const { name, columns, foreignColumns } = config2();
-      return { name, columns, foreignTable: foreignColumns[0].table, foreignColumns };
-    };
-    if (actions) {
-      this._onUpdate = actions.onUpdate;
-      this._onDelete = actions.onDelete;
-    }
-  }
-  onUpdate(action) {
-    this._onUpdate = action;
-    return this;
-  }
-  onDelete(action) {
-    this._onDelete = action;
-    return this;
-  }
-  build(table) {
-    return new ForeignKey(table, this);
-  }
-}
-
-class ForeignKey {
-  constructor(table, builder) {
-    this.table = table;
-    this.reference = builder.reference;
-    this.onUpdate = builder._onUpdate;
-    this.onDelete = builder._onDelete;
-  }
-  static [entityKind] = "SQLiteForeignKey";
-  reference;
-  onUpdate;
-  onDelete;
-  getName() {
-    const { name, columns, foreignColumns } = this.reference();
-    const columnNames = columns.map((column) => column.name);
-    const foreignColumnNames = foreignColumns.map((column) => column.name);
-    const chunks = [
-      this.table[TableName],
-      ...columnNames,
-      foreignColumns[0].table[TableName],
-      ...foreignColumnNames
-    ];
-    return name ?? `${chunks.join("_")}_fk`;
-  }
-}
-
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/unique-constraint.js
-function uniqueKeyName2(table, columns) {
-  return `${table[TableName]}_${columns.join("_")}_unique`;
-}
-
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/columns/common.js
-class SQLiteColumnBuilder extends ColumnBuilder {
-  static [entityKind] = "SQLiteColumnBuilder";
-  foreignKeyConfigs = [];
-  references(ref, actions = {}) {
-    this.foreignKeyConfigs.push({ ref, actions });
-    return this;
-  }
-  unique(name) {
-    this.config.isUnique = true;
-    this.config.uniqueName = name;
-    return this;
-  }
-  generatedAlwaysAs(as, config2) {
-    this.config.generated = {
-      as,
-      type: "always",
-      mode: config2?.mode ?? "virtual"
-    };
-    return this;
-  }
-  buildForeignKeys(column, table) {
-    return this.foreignKeyConfigs.map(({ ref, actions }) => {
-      return ((ref2, actions2) => {
-        const builder = new ForeignKeyBuilder(() => {
-          const foreignColumn = ref2();
-          return { columns: [column], foreignColumns: [foreignColumn] };
-        });
-        if (actions2.onUpdate) {
-          builder.onUpdate(actions2.onUpdate);
-        }
-        if (actions2.onDelete) {
-          builder.onDelete(actions2.onDelete);
-        }
-        return builder.build(table);
-      })(ref, actions);
-    });
-  }
-}
-
-class SQLiteColumn extends Column {
-  constructor(table, config2) {
-    if (!config2.uniqueName) {
-      config2.uniqueName = uniqueKeyName2(table, [config2.name]);
-    }
-    super(table, config2);
-    this.table = table;
-  }
-  static [entityKind] = "SQLiteColumn";
-}
-
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/columns/blob.js
-class SQLiteBigIntBuilder extends SQLiteColumnBuilder {
-  static [entityKind] = "SQLiteBigIntBuilder";
-  constructor(name) {
-    super(name, "bigint", "SQLiteBigInt");
-  }
-  build(table) {
-    return new SQLiteBigInt(table, this.config);
-  }
-}
-
-class SQLiteBigInt extends SQLiteColumn {
-  static [entityKind] = "SQLiteBigInt";
-  getSQLType() {
-    return "blob";
-  }
-  mapFromDriverValue(value) {
-    if (typeof Buffer !== "undefined" && Buffer.from) {
-      const buf = Buffer.isBuffer(value) ? value : value instanceof ArrayBuffer ? Buffer.from(value) : value.buffer ? Buffer.from(value.buffer, value.byteOffset, value.byteLength) : Buffer.from(value);
-      return BigInt(buf.toString("utf8"));
-    }
-    return BigInt(textDecoder.decode(value));
-  }
-  mapToDriverValue(value) {
-    return Buffer.from(value.toString());
-  }
-}
-
-class SQLiteBlobJsonBuilder extends SQLiteColumnBuilder {
-  static [entityKind] = "SQLiteBlobJsonBuilder";
-  constructor(name) {
-    super(name, "json", "SQLiteBlobJson");
-  }
-  build(table) {
-    return new SQLiteBlobJson(table, this.config);
-  }
-}
-
-class SQLiteBlobJson extends SQLiteColumn {
-  static [entityKind] = "SQLiteBlobJson";
-  getSQLType() {
-    return "blob";
-  }
-  mapFromDriverValue(value) {
-    if (typeof Buffer !== "undefined" && Buffer.from) {
-      const buf = Buffer.isBuffer(value) ? value : value instanceof ArrayBuffer ? Buffer.from(value) : value.buffer ? Buffer.from(value.buffer, value.byteOffset, value.byteLength) : Buffer.from(value);
-      return JSON.parse(buf.toString("utf8"));
-    }
-    return JSON.parse(textDecoder.decode(value));
-  }
-  mapToDriverValue(value) {
-    return Buffer.from(JSON.stringify(value));
-  }
-}
-
-class SQLiteBlobBufferBuilder extends SQLiteColumnBuilder {
-  static [entityKind] = "SQLiteBlobBufferBuilder";
-  constructor(name) {
-    super(name, "buffer", "SQLiteBlobBuffer");
-  }
-  build(table) {
-    return new SQLiteBlobBuffer(table, this.config);
-  }
-}
-
-class SQLiteBlobBuffer extends SQLiteColumn {
-  static [entityKind] = "SQLiteBlobBuffer";
-  mapFromDriverValue(value) {
-    if (Buffer.isBuffer(value)) {
-      return value;
-    }
-    return Buffer.from(value);
-  }
-  getSQLType() {
-    return "blob";
-  }
-}
-function blob(a, b) {
-  const { name, config: config2 } = getColumnNameAndConfig(a, b);
-  if (config2?.mode === "json") {
-    return new SQLiteBlobJsonBuilder(name);
-  }
-  if (config2?.mode === "bigint") {
-    return new SQLiteBigIntBuilder(name);
-  }
-  return new SQLiteBlobBufferBuilder(name);
-}
-
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/columns/custom.js
-class SQLiteCustomColumnBuilder extends SQLiteColumnBuilder {
-  static [entityKind] = "SQLiteCustomColumnBuilder";
-  constructor(name, fieldConfig, customTypeParams) {
-    super(name, "custom", "SQLiteCustomColumn");
-    this.config.fieldConfig = fieldConfig;
-    this.config.customTypeParams = customTypeParams;
-  }
-  build(table) {
-    return new SQLiteCustomColumn(table, this.config);
-  }
-}
-
-class SQLiteCustomColumn extends SQLiteColumn {
-  static [entityKind] = "SQLiteCustomColumn";
-  sqlName;
-  mapTo;
-  mapFrom;
-  constructor(table, config2) {
-    super(table, config2);
-    this.sqlName = config2.customTypeParams.dataType(config2.fieldConfig);
-    this.mapTo = config2.customTypeParams.toDriver;
-    this.mapFrom = config2.customTypeParams.fromDriver;
-  }
-  getSQLType() {
-    return this.sqlName;
-  }
-  mapFromDriverValue(value) {
-    return typeof this.mapFrom === "function" ? this.mapFrom(value) : value;
-  }
-  mapToDriverValue(value) {
-    return typeof this.mapTo === "function" ? this.mapTo(value) : value;
-  }
-}
-function customType(customTypeParams) {
-  return (a, b) => {
-    const { name, config: config2 } = getColumnNameAndConfig(a, b);
-    return new SQLiteCustomColumnBuilder(name, config2, customTypeParams);
-  };
-}
-
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/columns/integer.js
-class SQLiteBaseIntegerBuilder extends SQLiteColumnBuilder {
-  static [entityKind] = "SQLiteBaseIntegerBuilder";
-  constructor(name, dataType, columnType) {
-    super(name, dataType, columnType);
-    this.config.autoIncrement = false;
-  }
-  primaryKey(config2) {
-    if (config2?.autoIncrement) {
-      this.config.autoIncrement = true;
-    }
-    this.config.hasDefault = true;
-    return super.primaryKey();
-  }
-}
-
-class SQLiteBaseInteger extends SQLiteColumn {
-  static [entityKind] = "SQLiteBaseInteger";
-  autoIncrement = this.config.autoIncrement;
-  getSQLType() {
-    return "integer";
-  }
-}
-
-class SQLiteIntegerBuilder extends SQLiteBaseIntegerBuilder {
-  static [entityKind] = "SQLiteIntegerBuilder";
-  constructor(name) {
-    super(name, "number", "SQLiteInteger");
-  }
-  build(table) {
-    return new SQLiteInteger(table, this.config);
-  }
-}
-
-class SQLiteInteger extends SQLiteBaseInteger {
-  static [entityKind] = "SQLiteInteger";
-}
-
-class SQLiteTimestampBuilder extends SQLiteBaseIntegerBuilder {
-  static [entityKind] = "SQLiteTimestampBuilder";
-  constructor(name, mode) {
-    super(name, "date", "SQLiteTimestamp");
-    this.config.mode = mode;
-  }
-  defaultNow() {
-    return this.default(sql`(cast((julianday('now') - 2440587.5)*86400000 as integer))`);
-  }
-  build(table) {
-    return new SQLiteTimestamp(table, this.config);
-  }
-}
-
-class SQLiteTimestamp extends SQLiteBaseInteger {
-  static [entityKind] = "SQLiteTimestamp";
-  mode = this.config.mode;
-  mapFromDriverValue(value) {
-    if (this.config.mode === "timestamp") {
-      return new Date(value * 1000);
-    }
-    return new Date(value);
-  }
-  mapToDriverValue(value) {
-    const unix = value.getTime();
-    if (this.config.mode === "timestamp") {
-      return Math.floor(unix / 1000);
-    }
-    return unix;
-  }
-}
-
-class SQLiteBooleanBuilder extends SQLiteBaseIntegerBuilder {
-  static [entityKind] = "SQLiteBooleanBuilder";
-  constructor(name, mode) {
-    super(name, "boolean", "SQLiteBoolean");
-    this.config.mode = mode;
-  }
-  build(table) {
-    return new SQLiteBoolean(table, this.config);
-  }
-}
-
-class SQLiteBoolean extends SQLiteBaseInteger {
-  static [entityKind] = "SQLiteBoolean";
-  mode = this.config.mode;
-  mapFromDriverValue(value) {
-    return Number(value) === 1;
-  }
-  mapToDriverValue(value) {
-    return value ? 1 : 0;
-  }
-}
-function integer2(a, b) {
-  const { name, config: config2 } = getColumnNameAndConfig(a, b);
-  if (config2?.mode === "timestamp" || config2?.mode === "timestamp_ms") {
-    return new SQLiteTimestampBuilder(name, config2.mode);
-  }
-  if (config2?.mode === "boolean") {
-    return new SQLiteBooleanBuilder(name, config2.mode);
-  }
-  return new SQLiteIntegerBuilder(name);
-}
-
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/columns/numeric.js
-class SQLiteNumericBuilder extends SQLiteColumnBuilder {
-  static [entityKind] = "SQLiteNumericBuilder";
-  constructor(name) {
-    super(name, "string", "SQLiteNumeric");
-  }
-  build(table) {
-    return new SQLiteNumeric(table, this.config);
-  }
-}
-
-class SQLiteNumeric extends SQLiteColumn {
-  static [entityKind] = "SQLiteNumeric";
-  mapFromDriverValue(value) {
-    if (typeof value === "string")
-      return value;
-    return String(value);
-  }
-  getSQLType() {
-    return "numeric";
-  }
-}
-
-class SQLiteNumericNumberBuilder extends SQLiteColumnBuilder {
-  static [entityKind] = "SQLiteNumericNumberBuilder";
-  constructor(name) {
-    super(name, "number", "SQLiteNumericNumber");
-  }
-  build(table) {
-    return new SQLiteNumericNumber(table, this.config);
-  }
-}
-
-class SQLiteNumericNumber extends SQLiteColumn {
-  static [entityKind] = "SQLiteNumericNumber";
-  mapFromDriverValue(value) {
-    if (typeof value === "number")
-      return value;
-    return Number(value);
-  }
-  mapToDriverValue = String;
-  getSQLType() {
-    return "numeric";
-  }
-}
-
-class SQLiteNumericBigIntBuilder extends SQLiteColumnBuilder {
-  static [entityKind] = "SQLiteNumericBigIntBuilder";
-  constructor(name) {
-    super(name, "bigint", "SQLiteNumericBigInt");
-  }
-  build(table) {
-    return new SQLiteNumericBigInt(table, this.config);
-  }
-}
-
-class SQLiteNumericBigInt extends SQLiteColumn {
-  static [entityKind] = "SQLiteNumericBigInt";
-  mapFromDriverValue = BigInt;
-  mapToDriverValue = String;
-  getSQLType() {
-    return "numeric";
-  }
-}
-function numeric(a, b) {
-  const { name, config: config2 } = getColumnNameAndConfig(a, b);
-  const mode = config2?.mode;
-  return mode === "number" ? new SQLiteNumericNumberBuilder(name) : mode === "bigint" ? new SQLiteNumericBigIntBuilder(name) : new SQLiteNumericBuilder(name);
-}
-
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/columns/real.js
-class SQLiteRealBuilder extends SQLiteColumnBuilder {
-  static [entityKind] = "SQLiteRealBuilder";
-  constructor(name) {
-    super(name, "number", "SQLiteReal");
-  }
-  build(table) {
-    return new SQLiteReal(table, this.config);
-  }
-}
-
-class SQLiteReal extends SQLiteColumn {
-  static [entityKind] = "SQLiteReal";
-  getSQLType() {
-    return "real";
-  }
-}
-function real(name) {
-  return new SQLiteRealBuilder(name ?? "");
-}
-
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/columns/text.js
-class SQLiteTextBuilder extends SQLiteColumnBuilder {
-  static [entityKind] = "SQLiteTextBuilder";
-  constructor(name, config2) {
-    super(name, "string", "SQLiteText");
-    this.config.enumValues = config2.enum;
-    this.config.length = config2.length;
-  }
-  build(table) {
-    return new SQLiteText(table, this.config);
-  }
-}
-
-class SQLiteText extends SQLiteColumn {
-  static [entityKind] = "SQLiteText";
-  enumValues = this.config.enumValues;
-  length = this.config.length;
-  constructor(table, config2) {
-    super(table, config2);
-  }
-  getSQLType() {
-    return `text${this.config.length ? `(${this.config.length})` : ""}`;
-  }
-}
-
-class SQLiteTextJsonBuilder extends SQLiteColumnBuilder {
-  static [entityKind] = "SQLiteTextJsonBuilder";
-  constructor(name) {
-    super(name, "json", "SQLiteTextJson");
-  }
-  build(table) {
-    return new SQLiteTextJson(table, this.config);
-  }
-}
-
-class SQLiteTextJson extends SQLiteColumn {
-  static [entityKind] = "SQLiteTextJson";
-  getSQLType() {
-    return "text";
-  }
-  mapFromDriverValue(value) {
-    return JSON.parse(value);
-  }
-  mapToDriverValue(value) {
-    return JSON.stringify(value);
-  }
-}
-function text(a, b = {}) {
-  const { name, config: config2 } = getColumnNameAndConfig(a, b);
-  if (config2.mode === "json") {
-    return new SQLiteTextJsonBuilder(name);
-  }
-  return new SQLiteTextBuilder(name, config2);
-}
-
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/columns/all.js
-function getSQLiteColumnBuilders() {
-  return {
-    blob,
-    customType,
-    integer: integer2,
-    numeric,
-    real,
-    text
-  };
-}
-
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/table.js
-var InlineForeignKeys = Symbol.for("drizzle:SQLiteInlineForeignKeys");
-
-class SQLiteTable extends Table {
-  static [entityKind] = "SQLiteTable";
-  static Symbol = Object.assign({}, Table.Symbol, {
-    InlineForeignKeys
-  });
-  [Table.Symbol.Columns];
-  [InlineForeignKeys] = [];
-  [Table.Symbol.ExtraConfigBuilder] = undefined;
-}
-function sqliteTableBase(name, columns, extraConfig, schema, baseName = name) {
-  const rawTable = new SQLiteTable(name, schema, baseName);
-  const parsedColumns = typeof columns === "function" ? columns(getSQLiteColumnBuilders()) : columns;
-  const builtColumns = Object.fromEntries(Object.entries(parsedColumns).map(([name2, colBuilderBase]) => {
-    const colBuilder = colBuilderBase;
-    colBuilder.setName(name2);
-    const column = colBuilder.build(rawTable);
-    rawTable[InlineForeignKeys].push(...colBuilder.buildForeignKeys(column, rawTable));
-    return [name2, column];
-  }));
-  const table = Object.assign(rawTable, builtColumns);
-  table[Table.Symbol.Columns] = builtColumns;
-  table[Table.Symbol.ExtraConfigColumns] = builtColumns;
-  if (extraConfig) {
-    table[SQLiteTable.Symbol.ExtraConfigBuilder] = extraConfig;
-  }
-  return table;
-}
-var sqliteTable = (name, columns, extraConfig) => {
-  return sqliteTableBase(name, columns, extraConfig);
-};
-
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/indexes.js
-class IndexBuilderOn {
-  constructor(name, unique2) {
-    this.name = name;
-    this.unique = unique2;
-  }
-  static [entityKind] = "SQLiteIndexBuilderOn";
-  on(...columns) {
-    return new IndexBuilder(this.name, columns, this.unique);
-  }
-}
-
-class IndexBuilder {
-  static [entityKind] = "SQLiteIndexBuilder";
-  config;
-  constructor(name, columns, unique2) {
-    this.config = {
-      name,
-      columns,
-      unique: unique2,
-      where: undefined
-    };
-  }
-  where(condition) {
-    this.config.where = condition;
-    return this;
-  }
-  build(table) {
-    return new Index(this.config, table);
-  }
-}
-
-class Index {
-  static [entityKind] = "SQLiteIndex";
-  config;
-  constructor(config2, table) {
-    this.config = { ...config2, table };
-  }
-}
-function index(name) {
-  return new IndexBuilderOn(name, false);
-}
-
-// ../runtime/src/drizzle-schema.ts
-var deliveriesTable = sqliteTable("deliveries", {
-  id: text("id").primaryKey(),
-  messageId: text("message_id"),
-  invocationId: text("invocation_id"),
-  targetId: text("target_id").notNull(),
-  targetNodeId: text("target_node_id"),
-  targetKind: text("target_kind").$type().notNull(),
-  transport: text("transport").$type().notNull(),
-  reason: text("reason").$type().notNull(),
-  policy: text("policy").$type().notNull(),
-  status: text("status").$type().notNull(),
-  bindingId: text("binding_id"),
-  leaseOwner: text("lease_owner"),
-  leaseExpiresAt: integer2("lease_expires_at"),
-  metadataJson: text("metadata_json"),
-  createdAt: integer2("created_at").notNull().default(sql`(unixepoch())`)
-}, (table) => [
-  index("idx_deliveries_status_transport").on(table.status, table.transport)
-]);
-var deliveryAttemptsTable = sqliteTable("delivery_attempts", {
-  id: text("id").primaryKey(),
-  deliveryId: text("delivery_id").notNull(),
-  attempt: integer2("attempt").notNull(),
-  status: text("status").$type().notNull(),
-  error: text("error"),
-  externalRef: text("external_ref"),
-  metadataJson: text("metadata_json"),
-  createdAt: integer2("created_at").notNull()
-});
-// ../runtime/src/broker.ts
-function createRuntimeId(prefix) {
-  return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
-}
-function toTargetKind(actor) {
-  if (!actor)
-    return "participant";
-  if (actor.kind === "agent")
-    return "agent";
-  if (actor.kind === "device")
-    return "device";
-  if (actor.kind === "bridge")
-    return "bridge";
-  return "participant";
-}
-function defaultTransportForActor(actor) {
-  if (!actor)
-    return "local_socket";
-  switch (actor.kind) {
-    case "bridge":
-      return "webhook";
-    case "device":
-      return "local_socket";
-    case "agent":
-      return "local_socket";
-    default:
-      return "local_socket";
-  }
-}
-function endpointTransportRank(transport) {
-  switch (transport) {
-    case "codex_app_server":
-      return 0;
-    case "claude_stream_json":
-      return 1;
-    case "tmux":
-      return 2;
-    case "local_socket":
-      return 3;
-    default:
-      return 4;
-  }
-}
-function shouldBridgeMessageToBinding(binding, message) {
-  if (binding.platform !== "telegram") {
-    return true;
-  }
-  const source = typeof message.metadata?.source === "string" ? String(message.metadata.source) : "";
-  if (source === "telegram") {
-    return false;
-  }
-  const outboundMode = typeof binding.metadata?.outboundMode === "string" ? String(binding.metadata.outboundMode) : "operator_only";
-  const operatorId = typeof binding.metadata?.operatorId === "string" ? String(binding.metadata.operatorId) : "operator";
-  const allowedActorIds = Array.isArray(binding.metadata?.allowedActorIds) ? binding.metadata.allowedActorIds.map((entry) => String(entry).trim()).filter(Boolean) : [];
-  if (outboundMode === "all") {
-    return true;
-  }
-  if (outboundMode === "allowlist") {
-    return allowedActorIds.includes(message.actorId);
-  }
-  return message.actorId === operatorId;
-}
-function resolveBindingRoutes(bindings, message) {
-  return bindings.filter((binding) => shouldBridgeMessageToBinding(binding, message)).map((binding) => ({
-    targetId: binding.id,
-    targetKind: "bridge",
-    transport: binding.platform === "telegram" ? "telegram" : binding.platform === "discord" ? "discord" : "webhook",
-    bindingId: binding.id
-  }));
-}
-function preferredEndpoint(endpoints) {
-  let preferred;
-  let preferredRank = Number.POSITIVE_INFINITY;
-  for (const endpoint of endpoints) {
-    const rank = endpointTransportRank(endpoint.transport);
-    if (!preferred || rank < preferredRank) {
-      preferred = endpoint;
-      preferredRank = rank;
-    }
-  }
-  return preferred;
-}
-
-class InMemoryControlRuntime {
-  registry;
-  listeners = new Set;
-  eventBuffer = [];
-  localNodeId;
-  endpointIdsByAgentId = new Map;
-  bindingIdsByConversationId = new Map;
-  flightIdByInvocationId = new Map;
-  constructor(initial = {}, options = {}) {
-    this.registry = createRuntimeRegistrySnapshot(initial);
-    this.localNodeId = options.localNodeId;
-    this.rebuildIndexes();
-  }
-  snapshot() {
-    return createRuntimeRegistrySnapshot({
-      nodes: { ...this.registry.nodes },
-      actors: { ...this.registry.actors },
-      agents: { ...this.registry.agents },
-      endpoints: { ...this.registry.endpoints },
-      conversations: { ...this.registry.conversations },
-      bindings: { ...this.registry.bindings },
-      messages: { ...this.registry.messages },
-      flights: { ...this.registry.flights },
-      collaborationRecords: { ...this.registry.collaborationRecords }
-    });
-  }
-  peek() {
-    return this.registry;
-  }
-  node(nodeId) {
-    return this.registry.nodes[nodeId];
-  }
-  agent(agentId) {
-    return this.registry.agents[agentId];
-  }
-  conversation(conversationId) {
-    return this.registry.conversations[conversationId];
-  }
-  message(messageId) {
-    return this.registry.messages[messageId];
-  }
-  collaborationRecord(recordId) {
-    return this.registry.collaborationRecords[recordId];
-  }
-  flightForInvocation(invocationId) {
-    const flightId = this.flightIdByInvocationId.get(invocationId);
-    return flightId ? this.registry.flights[flightId] : undefined;
-  }
-  bindingsForConversation(conversationId) {
-    const bindingIds = this.bindingIdsByConversationId.get(conversationId);
-    if (!bindingIds) {
-      return [];
-    }
-    const bindings = [];
-    for (const bindingId of bindingIds) {
-      const binding = this.registry.bindings[bindingId];
-      if (binding) {
-        bindings.push(binding);
-      }
-    }
-    return bindings;
-  }
-  endpointsForAgent(agentId, options = {}) {
-    const endpointIds = this.endpointIdsByAgentId.get(agentId);
-    if (!endpointIds) {
-      return [];
-    }
-    const endpoints = [];
-    for (const endpointId of endpointIds) {
-      const endpoint = this.registry.endpoints[endpointId];
-      if (!endpoint)
-        continue;
-      if (!options.includeOffline && endpoint.state === "offline")
-        continue;
-      if (options.nodeId && endpoint.nodeId !== options.nodeId)
-        continue;
-      if (options.harness && endpoint.harness !== options.harness)
-        continue;
-      endpoints.push(endpoint);
-    }
-    return endpoints;
-  }
-  recentEvents(limit = 100) {
-    return this.eventBuffer.slice(-limit);
-  }
-  subscribe(listener) {
-    this.listeners.add(listener);
-    return () => {
-      this.listeners.delete(listener);
-    };
-  }
-  async dispatch(command) {
-    switch (command.kind) {
-      case "node.upsert":
-        await this.upsertNode(command.node);
-        return;
-      case "actor.upsert":
-        await this.upsertActor(command.actor);
-        return;
-      case "agent.upsert":
-        await this.upsertAgent(command.agent);
-        return;
-      case "agent.endpoint.upsert":
-        await this.upsertEndpoint(command.endpoint);
-        return;
-      case "conversation.upsert":
-        await this.upsertConversation(command.conversation);
-        return;
-      case "binding.upsert":
-        await this.upsertBinding(command.binding);
-        return;
-      case "collaboration.upsert":
-        await this.upsertCollaboration(command.record);
-        return;
-      case "collaboration.event.append":
-        await this.appendCollaborationEvent(command.event);
-        return;
-      case "conversation.post":
-        await this.postMessage(command.message);
-        return;
-      case "agent.invoke":
-        await this.invokeAgent(command.invocation);
-        return;
-      case "agent.ensure_awake":
-        this.emit({
-          id: createRuntimeId("evt"),
-          kind: "flight.updated",
-          ts: Date.now(),
-          actorId: command.requesterId,
-          nodeId: this.localNodeId,
-          payload: {
-            flight: {
-              id: createRuntimeId("flt"),
-              invocationId: command.agentId,
-              requesterId: command.requesterId,
-              targetAgentId: command.agentId,
-              state: "waking",
-              summary: command.reason
-            }
-          }
-        });
-        return;
-      case "stream.subscribe":
-        return;
-      default: {
-        const exhaustive = command;
-        return exhaustive;
-      }
-    }
-  }
-  async upsertNode(node) {
-    this.registry.nodes[node.id] = node;
-    this.emit({
-      id: createRuntimeId("evt"),
-      kind: "node.upserted",
-      ts: Date.now(),
-      actorId: node.id,
-      nodeId: node.id,
-      payload: { node }
-    });
-  }
-  async upsertActor(actor) {
-    this.registry.actors[actor.id] = {
-      id: actor.id,
-      kind: actor.kind,
-      displayName: actor.displayName,
-      handle: actor.handle,
-      labels: actor.labels,
-      metadata: actor.metadata
-    };
-    this.emit({
-      id: createRuntimeId("evt"),
-      kind: "actor.registered",
-      ts: Date.now(),
-      actorId: actor.id,
-      nodeId: this.localNodeId,
-      payload: { actor }
-    });
-  }
-  async upsertAgent(agent) {
-    if (!this.registry.actors[agent.id]) {
-      this.registry.actors[agent.id] = {
-        id: agent.id,
-        kind: agent.kind,
-        displayName: agent.displayName,
-        handle: agent.handle,
-        labels: agent.labels,
-        metadata: agent.metadata
-      };
-    }
-    this.registry.agents[agent.id] = agent;
-    this.emit({
-      id: createRuntimeId("evt"),
-      kind: "agent.registered",
-      ts: Date.now(),
-      actorId: agent.id,
-      nodeId: agent.authorityNodeId,
-      payload: { agent }
-    });
-  }
-  async upsertEndpoint(endpoint) {
-    const previous = this.registry.endpoints[endpoint.id];
-    if (previous) {
-      this.unindexEndpoint(previous);
-    }
-    this.registry.endpoints[endpoint.id] = endpoint;
-    this.indexEndpoint(endpoint);
-    this.emit({
-      id: createRuntimeId("evt"),
-      kind: "agent.endpoint.upserted",
-      ts: Date.now(),
-      actorId: endpoint.agentId,
-      nodeId: endpoint.nodeId,
-      payload: { endpoint }
-    });
-  }
-  async upsertConversation(conversation) {
-    this.registry.conversations[conversation.id] = conversation;
-    this.emit({
-      id: createRuntimeId("evt"),
-      kind: "conversation.upserted",
-      ts: Date.now(),
-      actorId: "system",
-      nodeId: conversation.authorityNodeId,
-      payload: { conversation }
-    });
-  }
-  async upsertBinding(binding) {
-    const previous = this.registry.bindings[binding.id];
-    if (previous) {
-      this.unindexBinding(previous);
-    }
-    this.registry.bindings[binding.id] = binding;
-    this.indexBinding(binding);
-    this.emit({
-      id: createRuntimeId("evt"),
-      kind: "binding.upserted",
-      ts: Date.now(),
-      actorId: "system",
-      nodeId: this.localNodeId,
-      payload: { binding }
-    });
-  }
-  async upsertCollaboration(record2) {
-    assertValidCollaborationRecord(record2);
-    this.registry.collaborationRecords[record2.id] = record2;
-    this.emit({
-      id: createRuntimeId("evt"),
-      kind: "collaboration.upserted",
-      ts: Date.now(),
-      actorId: record2.createdById,
-      nodeId: this.localNodeId,
-      payload: { record: record2 }
-    });
-  }
-  async appendCollaborationEvent(event) {
-    const record2 = this.registry.collaborationRecords[event.recordId];
-    if (!record2) {
-      throw new Error(`unknown collaboration record: ${event.recordId}`);
-    }
-    assertValidCollaborationEvent(event, record2);
-    this.emit({
-      id: createRuntimeId("evt"),
-      kind: "collaboration.event.appended",
-      ts: Date.now(),
-      actorId: event.actorId,
-      nodeId: this.localNodeId,
-      payload: { event }
-    });
-  }
-  async upsertFlight(flight) {
-    const previous = this.registry.flights[flight.id];
-    if (previous && this.flightIdByInvocationId.get(previous.invocationId) === previous.id) {
-      this.flightIdByInvocationId.delete(previous.invocationId);
-    }
-    this.registry.flights[flight.id] = flight;
-    this.flightIdByInvocationId.set(flight.invocationId, flight.id);
-    this.emit({
-      id: createRuntimeId("evt"),
-      kind: "flight.updated",
-      ts: Date.now(),
-      actorId: flight.requesterId,
-      nodeId: this.localNodeId,
-      payload: { flight }
-    });
-  }
-  async postMessage(message, options = {}) {
-    const deliveries2 = this.planMessage(message, options);
-    await this.commitMessage(message, deliveries2);
-    return deliveries2;
-  }
-  planMessage(message, options = {}) {
-    const conversation = this.registry.conversations[message.conversationId];
-    if (!conversation) {
-      throw new Error(`unknown conversation: ${message.conversationId}`);
-    }
-    const bindingRoutes = resolveBindingRoutes(this.bindingsForConversation(conversation.id), message);
-    const plannedParticipantRoutes = this.resolveParticipantRoutes(conversation.participantIds);
-    const participantRoutes = options.localOnly ? plannedParticipantRoutes.filter((route2) => !route2.nodeId || route2.nodeId === this.localNodeId) : plannedParticipantRoutes;
-    const deliveries2 = planMessageDeliveries({
-      localNodeId: this.localNodeId,
-      message,
-      conversation,
-      participantRoutes,
-      bindingRoutes: options.localOnly ? [] : bindingRoutes
-    });
-    return deliveries2;
-  }
-  async commitMessage(message, deliveries2) {
-    this.registry.messages[message.id] = message;
-    this.emit({
-      id: createRuntimeId("evt"),
-      kind: "message.posted",
-      ts: Date.now(),
-      actorId: message.actorId,
-      nodeId: message.originNodeId,
-      payload: { message }
-    });
-    for (const delivery of deliveries2) {
-      this.emit({
-        id: createRuntimeId("evt"),
-        kind: "delivery.planned",
-        ts: Date.now(),
-        actorId: message.actorId,
-        nodeId: message.originNodeId,
-        payload: { delivery }
-      });
-    }
-  }
-  async invokeAgent(invocation) {
-    const flight = this.planInvocation(invocation);
-    await this.commitInvocation(invocation, flight);
-    return flight;
-  }
-  planInvocation(invocation) {
-    const targetAgent = this.registry.agents[invocation.targetAgentId];
-    if (!targetAgent) {
-      throw new Error(`unknown agent: ${invocation.targetAgentId}`);
-    }
-    const targetEndpoints = this.endpointsForAgent(invocation.targetAgentId, {
-      nodeId: targetAgent.authorityNodeId,
-      harness: invocation.execution?.harness
-    });
-    const isLocalAuthority = !this.localNodeId || targetAgent.authorityNodeId === this.localNodeId;
-    const startedAt = Date.now();
-    let state = invocation.ensureAwake ? "waking" : "queued";
-    let summary;
-    let error48;
-    let completedAt;
-    if (isLocalAuthority) {
-      if (targetEndpoints.length == 0) {
-        state = invocation.ensureAwake ? "waking" : "queued";
-        summary = invocation.ensureAwake ? invocation.execution?.harness ? `${targetAgent.displayName} waking on ${invocation.execution.harness}.` : `${targetAgent.displayName} waking.` : `Message stored for ${targetAgent.displayName}. Will deliver when online.`;
-      } else {
-        state = "queued";
-        summary = `${targetAgent.displayName} queued for local execution.`;
-      }
-    }
-    const flight = {
-      id: createRuntimeId("flt"),
-      invocationId: invocation.id,
-      requesterId: invocation.requesterId,
-      targetAgentId: invocation.targetAgentId,
-      state,
-      summary,
-      error: error48,
-      startedAt,
-      completedAt,
-      metadata: invocation.metadata
-    };
-    return flight;
-  }
-  async commitInvocation(invocation, flight) {
-    const previous = this.registry.flights[flight.id];
-    if (previous && this.flightIdByInvocationId.get(previous.invocationId) === previous.id) {
-      this.flightIdByInvocationId.delete(previous.invocationId);
-    }
-    this.registry.flights[flight.id] = flight;
-    this.flightIdByInvocationId.set(flight.invocationId, flight.id);
-    const targetAgent = this.registry.agents[invocation.targetAgentId];
-    this.emit({
-      id: createRuntimeId("evt"),
-      kind: "invocation.requested",
-      ts: Date.now(),
-      actorId: invocation.requesterId,
-      nodeId: invocation.requesterNodeId,
-      payload: { invocation }
-    });
-    this.emit({
-      id: createRuntimeId("evt"),
-      kind: "flight.updated",
-      ts: Date.now(),
-      actorId: invocation.requesterId,
-      nodeId: targetAgent?.authorityNodeId,
-      payload: { flight }
-    });
-  }
-  rebuildIndexes() {
-    for (const endpoint of Object.values(this.registry.endpoints)) {
-      this.indexEndpoint(endpoint);
-    }
-    for (const binding of Object.values(this.registry.bindings)) {
-      this.indexBinding(binding);
-    }
-    for (const flight of Object.values(this.registry.flights)) {
-      this.flightIdByInvocationId.set(flight.invocationId, flight.id);
-    }
-  }
-  indexEndpoint(endpoint) {
-    this.addIndexedId(this.endpointIdsByAgentId, endpoint.agentId, endpoint.id);
-  }
-  unindexEndpoint(endpoint) {
-    this.removeIndexedId(this.endpointIdsByAgentId, endpoint.agentId, endpoint.id);
-  }
-  indexBinding(binding) {
-    this.addIndexedId(this.bindingIdsByConversationId, binding.conversationId, binding.id);
-  }
-  unindexBinding(binding) {
-    this.removeIndexedId(this.bindingIdsByConversationId, binding.conversationId, binding.id);
-  }
-  addIndexedId(index2, key, value) {
-    const ids = index2.get(key) ?? new Set;
-    ids.add(value);
-    index2.set(key, ids);
-  }
-  removeIndexedId(index2, key, value) {
-    const ids = index2.get(key);
-    if (!ids) {
-      return;
-    }
-    ids.delete(value);
-    if (ids.size === 0) {
-      index2.delete(key);
-    }
-  }
-  resolveParticipantRoutes(participantIds) {
-    const routes = [];
-    for (const participantId of participantIds) {
-      const actor = this.registry.actors[participantId];
-      const agent = this.registry.agents[participantId];
-      const targetIdentity = actor ?? agent;
-      const endpoints = this.endpointsForAgent(participantId);
-      const endpoint = preferredEndpoint(endpoints);
-      if (!endpoint) {
-        if (agent?.authorityNodeId && agent.authorityNodeId !== this.localNodeId) {
-          routes.push({
-            targetId: participantId,
-            nodeId: agent.authorityNodeId,
-            targetKind: toTargetKind(targetIdentity),
-            transport: defaultTransportForActor(targetIdentity),
-            speechEnabled: false
-          });
-        } else if (agent) {
-          routes.push({
-            targetId: participantId,
-            nodeId: agent.authorityNodeId ?? this.localNodeId,
-            targetKind: toTargetKind(targetIdentity),
-            transport: defaultTransportForActor(targetIdentity),
-            speechEnabled: false
-          });
-        }
-        continue;
-      }
-      routes.push({
-        targetId: participantId,
-        nodeId: endpoint.nodeId ?? agent?.authorityNodeId,
-        targetKind: toTargetKind(targetIdentity),
-        transport: endpoint.transport ?? defaultTransportForActor(targetIdentity),
-        speechEnabled: Boolean(actor?.kind === "device" || endpoints.some((candidate) => candidate.transport === "local_socket" || candidate.transport === "websocket"))
-      });
-    }
-    return routes;
-  }
-  emit(event) {
-    this.eventBuffer.push(event);
-    if (this.eventBuffer.length > 500) {
-      this.eventBuffer.shift();
-    }
-    for (const listener of this.listeners) {
-      listener(event);
-    }
-  }
-}
-// ../runtime/src/tailscale.ts
-import { execFile } from "child_process";
-import { promisify } from "util";
-var execFileAsync = promisify(execFile);
-// ../runtime/src/thread-events.ts
-class ThreadWatchProtocolError extends Error {
-  status;
-  body;
-  constructor(status, body) {
-    super(body.message);
-    this.status = status;
-    this.body = body;
-  }
-}
-function watchKey(conversationId, watcherNodeId, watcherId) {
-  return `${conversationId}:${watcherNodeId}:${watcherId}`;
-}
-function writeSse(response, eventName, payload) {
-  response.write(`event: ${eventName}
-data: ${JSON.stringify(payload)}
-
-`);
-}
-
-class ThreadEventPlane {
-  options;
-  watches = new Map;
-  watchIdsByKey = new Map;
-  watchIdsByConversation = new Map;
-  constructor(options) {
-    this.options = options;
-  }
-  async openWatch(request) {
-    const conversation = this.requireConversationAuthority(request.conversationId);
-    this.requireRemoteWatchAllowed(conversation);
-    const afterSeq = Math.max(0, request.afterSeq ?? 0);
-    const oldestSeq = await this.options.projection.oldestThreadSeq(conversation.id);
-    const latestSeq = await this.options.projection.latestThreadSeq(conversation.id);
-    if (latestSeq > 0 && oldestSeq > 0 && afterSeq < oldestSeq - 1) {
-      throw new ThreadWatchProtocolError(409, {
-        code: "cursor_out_of_range",
-        message: `thread cursor ${afterSeq} is older than retained seq ${oldestSeq}`
-      });
-    }
-    const key = watchKey(conversation.id, request.watcherNodeId, request.watcherId);
-    const existingWatchId = this.watchIdsByKey.get(key);
-    if (existingWatchId) {
-      this.closeWatchInternal(existingWatchId);
-    }
-    const watchId = `thread-watch:${conversation.id}:${request.watcherNodeId}:${request.watcherId}`;
-    const leaseExpiresAt = Date.now() + this.normalizeLeaseMs(request.leaseMs);
-    const watch = {
-      watchId,
-      conversationId: conversation.id,
-      watcherNodeId: request.watcherNodeId,
-      watcherId: request.watcherId,
-      acceptedAfterSeq: afterSeq,
-      leaseExpiresAt,
-      mode: conversation.shareMode === "summary" ? "summary" : "shared",
-      clients: new Set
-    };
-    this.watches.set(watchId, watch);
-    this.watchIdsByKey.set(key, watchId);
-    this.indexWatch(watch);
-    return {
-      watchId,
-      conversationId: conversation.id,
-      authorityNodeId: conversation.authorityNodeId,
-      acceptedAfterSeq: afterSeq,
-      latestSeq,
-      leaseExpiresAt,
-      mode: watch.mode
-    };
-  }
-  async renewWatch(request) {
-    const watch = this.requireLiveWatch(request.watchId);
-    watch.leaseExpiresAt = Date.now() + this.normalizeLeaseMs(request.leaseMs);
-    return {
-      watchId: watch.watchId,
-      leaseExpiresAt: watch.leaseExpiresAt
-    };
-  }
-  async closeWatch(request) {
-    this.closeWatchInternal(request.watchId);
-  }
-  async replay(options) {
-    const conversation = this.requireConversationAuthority(options.conversationId);
-    this.requireRemoteWatchAllowed(conversation);
-    const oldestSeq = await this.options.projection.oldestThreadSeq(conversation.id);
-    const latestSeq = await this.options.projection.latestThreadSeq(conversation.id);
-    if (latestSeq > 0 && oldestSeq > 0 && options.afterSeq < oldestSeq - 1) {
-      throw new ThreadWatchProtocolError(409, {
-        code: "cursor_out_of_range",
-        message: `thread cursor ${options.afterSeq} is older than retained seq ${oldestSeq}`
-      });
-    }
-    return this.options.projection.listThreadEvents({
-      conversationId: conversation.id,
-      afterSeq: options.afterSeq,
-      limit: Math.min(options.limit ?? 500, this.options.maxReplayLimit ?? 2000)
-    });
-  }
-  async snapshot(conversationId) {
-    const conversation = this.requireConversationAuthority(conversationId);
-    this.requireRemoteWatchAllowed(conversation);
-    const snapshot = await this.options.projection.getThreadSnapshot(conversation.id);
-    if (!snapshot) {
-      throw new ThreadWatchProtocolError(404, {
-        code: "unknown_conversation",
-        message: `unknown conversation ${conversation.id}`
-      });
-    }
-    return snapshot;
-  }
-  async streamWatch(watchId, request, response) {
-    const watch = this.requireLiveWatch(watchId);
-    const backlog = await this.options.projection.listThreadEvents({
-      conversationId: watch.conversationId,
-      afterSeq: watch.acceptedAfterSeq,
-      limit: this.options.maxReplayLimit ?? 2000
-    });
-    response.writeHead(200, {
-      "content-type": "text/event-stream",
-      "cache-control": "no-cache, no-transform",
-      connection: "keep-alive"
-    });
-    writeSse(response, "hello", {
-      watchId: watch.watchId,
-      conversationId: watch.conversationId,
-      leaseExpiresAt: watch.leaseExpiresAt
-    });
-    for (const event of backlog) {
-      writeSse(response, "thread.event", event);
-    }
-    watch.clients.add(response);
-    request.on("close", () => {
-      watch.clients.delete(response);
-      response.end();
-    });
-  }
-  publish(events2) {
-    for (const event of events2) {
-      const watchIds = this.watchIdsByConversation.get(event.conversationId);
-      if (!watchIds || watchIds.size === 0) {
-        continue;
-      }
-      for (const watchId of [...watchIds]) {
-        const watch = this.watches.get(watchId);
-        if (!watch) {
-          watchIds.delete(watchId);
-          continue;
-        }
-        if (watch.leaseExpiresAt <= Date.now()) {
-          this.closeWatchInternal(watchId);
-          continue;
-        }
-        for (const client of watch.clients) {
-          writeSse(client, "thread.event", event);
-        }
-      }
-    }
-  }
-  normalizeLeaseMs(requestedLeaseMs) {
-    const defaultLeaseMs = this.options.defaultLeaseMs ?? 30000;
-    const maxLeaseMs = this.options.maxLeaseMs ?? 300000;
-    if (!requestedLeaseMs || !Number.isFinite(requestedLeaseMs) || requestedLeaseMs <= 0) {
-      return defaultLeaseMs;
-    }
-    return Math.min(Math.max(requestedLeaseMs, 5000), maxLeaseMs);
-  }
-  requireConversationAuthority(conversationId) {
-    const conversation = this.options.runtime.conversation(conversationId);
-    if (!conversation) {
-      throw new ThreadWatchProtocolError(404, {
-        code: "unknown_conversation",
-        message: `unknown conversation ${conversationId}`
-      });
-    }
-    if (conversation.authorityNodeId !== this.options.nodeId) {
-      throw new ThreadWatchProtocolError(409, {
-        code: "no_responder",
-        message: `conversation ${conversationId} is owned by ${conversation.authorityNodeId}`
-      });
-    }
-    return conversation;
-  }
-  requireRemoteWatchAllowed(conversation) {
-    if (conversation.shareMode === "local") {
-      throw new ThreadWatchProtocolError(403, {
-        code: "forbidden",
-        message: `conversation ${conversation.id} does not allow remote watches`
-      });
-    }
-  }
-  requireLiveWatch(watchId) {
-    const watch = this.watches.get(watchId);
-    if (!watch) {
-      throw new ThreadWatchProtocolError(404, {
-        code: "invalid_request",
-        message: `unknown watch ${watchId}`
-      });
-    }
-    if (watch.leaseExpiresAt <= Date.now()) {
-      this.closeWatchInternal(watchId);
-      throw new ThreadWatchProtocolError(410, {
-        code: "lease_expired",
-        message: `watch ${watchId} lease expired`
-      });
-    }
-    return watch;
-  }
-  indexWatch(watch) {
-    const ids = this.watchIdsByConversation.get(watch.conversationId) ?? new Set;
-    ids.add(watch.watchId);
-    this.watchIdsByConversation.set(watch.conversationId, ids);
-  }
-  closeWatchInternal(watchId) {
-    const watch = this.watches.get(watchId);
-    if (!watch) {
-      return;
-    }
-    this.watches.delete(watchId);
-    this.watchIdsByKey.delete(watchKey(watch.conversationId, watch.watcherNodeId, watch.watcherId));
-    const ids = this.watchIdsByConversation.get(watch.conversationId);
-    if (ids) {
-      ids.delete(watchId);
-      if (ids.size === 0) {
-        this.watchIdsByConversation.delete(watch.conversationId);
-      }
-    }
-    for (const client of watch.clients) {
-      client.end();
-    }
-    watch.clients.clear();
-  }
-}
 // ../runtime/src/mobile-push.ts
 import { Database as Database2 } from "bun:sqlite";
 import { mkdirSync as mkdirSync9, readFileSync as readFileSync10 } from "fs";
 import { connect as connectHttp2 } from "http2";
 import { createPrivateKey, sign as signWithKey } from "crypto";
-import { dirname as dirname7, join as join18 } from "path";
+import { dirname as dirname8, join as join19 } from "path";
 var MOBILE_PUSH_SCHEMA = `
 CREATE TABLE IF NOT EXISTS mobile_push_registrations (
   id TEXT PRIMARY KEY,
@@ -34142,7 +32152,7 @@ var dbHandle = null;
 var dbPath = null;
 var cachedApnsJwt = null;
 function resolveControlPlaneDbPath() {
-  return join18(resolveOpenScoutSupportPaths().controlHome, "control-plane.sqlite");
+  return join19(resolveOpenScoutSupportPaths().controlHome, "control-plane.sqlite");
 }
 function ensureMobilePushSchema(database) {
   database.exec("PRAGMA busy_timeout = 5000;");
@@ -34156,7 +32166,7 @@ function writeDb() {
     dbHandle = null;
   }
   if (!dbHandle) {
-    mkdirSync9(dirname7(nextPath), { recursive: true });
+    mkdirSync9(dirname8(nextPath), { recursive: true });
     dbHandle = new Database2(nextPath, { create: true });
     dbPath = nextPath;
     ensureMobilePushSchema(dbHandle);
@@ -34372,7 +32382,7 @@ async function sendApnsAlertToRegistration(registration, alert) {
     },
     ...alert.payload ? { scout: alert.payload } : {}
   });
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     const client = connectHttp2(authority);
     client.once("error", reject);
     const request = client.request({
@@ -34410,7 +32420,7 @@ async function sendApnsAlertToRegistration(registration, alert) {
         }
       }
       if (status === 200) {
-        resolve7({
+        resolve8({
           delivered: true,
           skipped: false,
           status,
@@ -34422,7 +32432,7 @@ async function sendApnsAlertToRegistration(registration, alert) {
       if (reason === "BadDeviceToken" || reason === "Unregistered") {
         deleteMobilePushRegistrationByToken(registration.pushToken);
       }
-      resolve7({
+      resolve8({
         delivered: false,
         skipped: false,
         status,
@@ -34481,11 +32491,12 @@ async function broadcastApnsAlertToActiveMobileDevices(alert) {
     failures
   };
 }
+
 // ../../apps/desktop/src/core/pairing/runtime/bridge/router.ts
 import { readFileSync as readFileSync11, readdirSync as readdirSync4, realpathSync as realpathSync2, statSync as statSync4 } from "fs";
 import { execSync as execSync4 } from "child_process";
-import { basename as basename7, isAbsolute as isAbsolute4, join as join19, relative as relative3 } from "path";
-import { homedir as homedir16 } from "os";
+import { basename as basename8, isAbsolute as isAbsolute4, join as join20, relative as relative3 } from "path";
+import { homedir as homedir17 } from "os";
 var t = initTRPC.context().create();
 var logged = t.middleware(async ({ path: path2, type, next }) => {
   const start = Date.now();
@@ -34512,13 +32523,13 @@ function resolveMobileCurrentDirectory2() {
   }
 }
 function resolveWorkspaceRoot2(root) {
-  const expandedRoot = root.replace(/^~/, homedir16());
+  const expandedRoot = root.replace(/^~/, homedir17());
   return realpathSync2(expandedRoot);
 }
 function resolveWorkspacePath2(root, requestedPath) {
   const normalizedRoot = resolveWorkspaceRoot2(root);
-  const expandedPath = requestedPath?.replace(/^~/, homedir16());
-  const candidate = expandedPath ? isAbsolute4(expandedPath) ? expandedPath : join19(normalizedRoot, expandedPath) : normalizedRoot;
+  const expandedPath = requestedPath?.replace(/^~/, homedir17());
+  const candidate = expandedPath ? isAbsolute4(expandedPath) ? expandedPath : join20(normalizedRoot, expandedPath) : normalizedRoot;
   const resolvedCandidate = realpathSync2(candidate);
   const rel = relative3(normalizedRoot, resolvedCandidate);
   if (rel === "" || !rel.startsWith("..") && !isAbsolute4(rel)) {
@@ -34548,7 +32559,7 @@ function listDirectories2(dirPath) {
       continue;
     if (name === "node_modules" || name === ".build" || name === "target")
       continue;
-    const fullPath = join19(dirPath, name);
+    const fullPath = join20(dirPath, name);
     try {
       const stat4 = statSync4(fullPath);
       if (!stat4.isDirectory())
@@ -34587,7 +32598,7 @@ function detectAgent2(filePath) {
   return "unknown";
 }
 async function discoverSessionFiles2(maxAgeDays, limit) {
-  const home = homedir16();
+  const home = homedir17();
   const results = [];
   const searchPaths = [
     { pattern: `${home}/.claude/projects`, agent: "claude-code" },
@@ -34669,23 +32680,23 @@ function bridgeEventIterable(bridge, signal) {
   return {
     [Symbol.asyncIterator]() {
       const buffer = [];
-      let resolve7 = null;
+      let resolve8 = null;
       let done = false;
       const unsub = bridge.onEvent((event) => {
         if (done)
           return;
         buffer.push(event);
-        if (resolve7) {
-          resolve7();
-          resolve7 = null;
+        if (resolve8) {
+          resolve8();
+          resolve8 = null;
         }
       });
       const cleanup = () => {
         done = true;
         unsub();
-        if (resolve7) {
-          resolve7();
-          resolve7 = null;
+        if (resolve8) {
+          resolve8();
+          resolve8 = null;
         }
       };
       signal?.addEventListener("abort", cleanup, { once: true });
@@ -34698,7 +32709,7 @@ function bridgeEventIterable(bridge, signal) {
               return { done: false, value: buffer.shift() };
             }
             await new Promise((r) => {
-              resolve7 = r;
+              resolve8 = r;
             });
           }
         },
@@ -34717,8 +32728,8 @@ function getEventSessionId(event) {
 function trackedSequencedEventId(event) {
   return `${getEventSessionId(event) ?? "unknown"}:${event.seq}`;
 }
-function approvalInboxItemId(sessionId, turnId, blockId, version3) {
-  return `approval:${sessionId}:${turnId}:${blockId}:v${version3}`;
+function approvalInboxItemId(sessionId, turnId, blockId, version2) {
+  return `approval:${sessionId}:${turnId}:${blockId}:v${version2}`;
 }
 function projectApprovalInboxItem(snapshot, turn, block) {
   const normalized = normalizeApprovalRequest(snapshot.session, turn.id, block);
@@ -34827,9 +32838,9 @@ var sessionRouter = t.router({
     adapterType: exports_external.string().optional(),
     name: exports_external.string().optional()
   })).mutation(async ({ input, ctx }) => {
-    const sessionFilename = basename7(input.sessionPath, ".jsonl");
+    const sessionFilename = basename8(input.sessionPath, ".jsonl");
     const parentDir = input.sessionPath.substring(0, input.sessionPath.lastIndexOf("/"));
-    const dirName = basename7(parentDir);
+    const dirName = basename8(parentDir);
     let cwd;
     if (dirName.startsWith("-")) {
       const candidate = "/" + dirName.slice(1).replace(/-/g, "/");
@@ -35129,7 +33140,7 @@ var workspaceRouter = t.router({
       });
     }
     const adapterType = input.adapter ?? "claude-code";
-    const name = input.name ?? basename7(projectPath);
+    const name = input.name ?? basename8(projectPath);
     return ctx.bridge.createSession(adapterType, {
       name,
       cwd: projectPath
@@ -35376,7 +33387,8 @@ var BACKOFF_MULTIPLIER = 2;
 var LEGACY_CLIENT_ID = "__legacy__";
 function connectToRelay(relayUrl, identity2, bridge, options = {}) {
   const { secure = true, events: events2 } = options;
-  const qrPayload = createQRPayload(identity2.publicKey, relayUrl);
+  const publicRelayUrl = options.publicRelayUrl?.trim() || relayUrl;
+  const qrPayload = createQRPayload(identity2.publicKey, publicRelayUrl, options.fallbackRelayUrls);
   let ws = null;
   let eventUnsub = null;
   let stopped = false;
@@ -35390,12 +33402,12 @@ function connectToRelay(relayUrl, identity2, bridge, options = {}) {
     const bridgeKeyHex = bytesToHex2(identity2.publicKey);
     const url2 = buildRelayUrl(relayUrl, qrPayload.room, bridgeKeyHex);
     console.log(`[relay-client] connecting to relay (room: ${qrPayload.room})`);
-    events2?.onConnecting?.({ relayUrl, room: qrPayload.room });
+    events2?.onConnecting?.({ relayUrl: publicRelayUrl, room: qrPayload.room });
     ws = new WebSocket(url2, relayWebSocketOptions(relayUrl));
     ws.addEventListener("open", () => {
       console.log(`[relay-client] connected to relay (room: ${qrPayload.room})`);
       backoff = INITIAL_BACKOFF_MS;
-      events2?.onConnected?.({ relayUrl, room: qrPayload.room });
+      events2?.onConnected?.({ relayUrl: publicRelayUrl, room: qrPayload.room });
     });
     ws.addEventListener("message", (event) => {
       handleRelaySocketMessage(event.data);
@@ -35403,7 +33415,7 @@ function connectToRelay(relayUrl, identity2, bridge, options = {}) {
     ws.addEventListener("close", (event) => {
       console.log(`[relay-client] disconnected (code: ${event.code}, reason: ${event.reason})`);
       events2?.onClosed?.({
-        relayUrl,
+        relayUrl: publicRelayUrl,
         room: qrPayload.room,
         code: event.code,
         reason: event.reason
@@ -35414,7 +33426,7 @@ function connectToRelay(relayUrl, identity2, bridge, options = {}) {
     ws.addEventListener("error", () => {
       const error48 = new Error("Relay websocket error");
       console.error("[relay-client] connection error");
-      events2?.onError?.({ relayUrl, room: qrPayload.room, error: error48 });
+      events2?.onError?.({ relayUrl: publicRelayUrl, room: qrPayload.room, error: error48 });
     });
   }
   function handleRelaySocketMessage(raw) {
@@ -35468,7 +33480,7 @@ function connectToRelay(relayUrl, identity2, bridge, options = {}) {
         replaceOlderPeerForSameDevice(peer);
         ensureBridgeEventSubscription();
         console.log(`[relay-client] secure handshake complete (peer: ${pubHex.slice(0, 12)}..., device: ${peer.deviceId}, client: ${clientId})`);
-        events2?.onPaired?.({ relayUrl, room: qrPayload.room, remotePublicKey });
+        events2?.onPaired?.({ relayUrl: publicRelayUrl, room: qrPayload.room, remotePublicKey });
         sendExistingSessions((json2) => {
           if (peer.transport.isReady()) {
             peer.transport.send(json2);
@@ -35481,7 +33493,7 @@ function connectToRelay(relayUrl, identity2, bridge, options = {}) {
       onError: (err) => {
         console.error("[relay-client] secure transport error:", err.message);
         log.error("trns:cry", `decrypt failed for ${clientId} \u2014 resetting handshake: ${err.message}`);
-        events2?.onError?.({ relayUrl, room: qrPayload.room, error: err });
+        events2?.onError?.({ relayUrl: publicRelayUrl, room: qrPayload.room, error: err });
         sendRelayClose(clientId, 4002, "Transport reset");
         teardownSecurePeer(clientId);
       },
@@ -35680,7 +33692,7 @@ function connectToRelay(relayUrl, identity2, bridge, options = {}) {
     if (stopped)
       return;
     console.log(`[relay-client] reconnecting in ${backoff}ms...`);
-    events2?.onReconnectScheduled?.({ relayUrl, room: qrPayload.room, delayMs: backoff });
+    events2?.onReconnectScheduled?.({ relayUrl: publicRelayUrl, room: qrPayload.room, delayMs: backoff });
     reconnectTimer = setTimeout(() => {
       reconnectTimer = null;
       connect();
@@ -35772,13 +33784,13 @@ function asStringPayload(raw) {
 // ../../node_modules/.bun/hono@4.12.10/node_modules/hono/dist/compose.js
 var compose = (middleware, onError, onNotFound) => {
   return (context, next) => {
-    let index2 = -1;
+    let index = -1;
     return dispatch(0);
     async function dispatch(i) {
-      if (i <= index2) {
+      if (i <= index) {
         throw new Error("next() called multiple times");
       }
-      index2 = i;
+      index = i;
       let res;
       let isError = false;
       let handler;
@@ -35875,8 +33887,8 @@ var handleParsingNestedValues = (form, key, value) => {
   }
   let nestedForm = form;
   const keys = key.split(".");
-  keys.forEach((key2, index2) => {
-    if (index2 === keys.length - 1) {
+  keys.forEach((key2, index) => {
+    if (index === keys.length - 1) {
       nestedForm[key2] = value;
     } else {
       if (!nestedForm[key2] || typeof nestedForm[key2] !== "object" || Array.isArray(nestedForm[key2]) || nestedForm[key2] instanceof File) {
@@ -35902,8 +33914,8 @@ var splitRoutingPath = (routePath) => {
 };
 var extractGroupsFromPath = (path2) => {
   const groups = [];
-  path2 = path2.replace(/\{[^}]+\}/g, (match, index2) => {
-    const mark = `@${index2}`;
+  path2 = path2.replace(/\{[^}]+\}/g, (match, index) => {
+    const mark = `@${index}`;
     groups.push([mark, match]);
     return mark;
   });
@@ -36161,7 +34173,7 @@ var HonoRequest = class {
     return bodyCache[key] = raw[key]();
   };
   json() {
-    return this.#cachedBody("text").then((text2) => JSON.parse(text2));
+    return this.#cachedBody("text").then((text) => JSON.parse(text));
   }
   text() {
     return this.#cachedBody("text");
@@ -36382,8 +34394,8 @@ var Context = class {
   }
   newResponse = (...args) => this.#newResponse(...args);
   body = (data, arg, headers) => this.#newResponse(data, arg, headers);
-  text = (text2, arg, headers) => {
-    return !this.#preparedHeaders && !this.#status && !arg && !headers && !this.finalized ? new Response(text2) : this.#newResponse(text2, arg, setDefaultContentType(TEXT_PLAIN, headers));
+  text = (text, arg, headers) => {
+    return !this.#preparedHeaders && !this.#status && !arg && !headers && !this.finalized ? new Response(text) : this.#newResponse(text, arg, setDefaultContentType(TEXT_PLAIN, headers));
   };
   json = (object2, arg, headers) => {
     return this.#newResponse(JSON.stringify(object2), arg, setDefaultContentType("application/json", headers));
@@ -36647,8 +34659,8 @@ function match(method, path2) {
     if (!match3) {
       return [[], emptyParam];
     }
-    const index2 = match3.indexOf("", 1);
-    return [matcher[1][index2], match3];
+    const index = match3.indexOf("", 1);
+    return [matcher[1][index], match3];
   };
   this.match = match2;
   return match2(method, path2);
@@ -36683,7 +34695,7 @@ var Node = class _Node {
   #index;
   #varIndex;
   #children = /* @__PURE__ */ Object.create(null);
-  insert(tokens, index2, paramMap, context, pathErrorCheckOnly) {
+  insert(tokens, index, paramMap, context, pathErrorCheckOnly) {
     if (tokens.length === 0) {
       if (this.#index !== undefined) {
         throw PATH_ERROR;
@@ -36691,7 +34703,7 @@ var Node = class _Node {
       if (pathErrorCheckOnly) {
         return;
       }
-      this.#index = index2;
+      this.#index = index;
       return;
     }
     const [token, ...restTokens] = tokens;
@@ -36737,7 +34749,7 @@ var Node = class _Node {
         node = this.#children[token] = new _Node;
       }
     }
-    node.insert(restTokens, index2, paramMap, context, pathErrorCheckOnly);
+    node.insert(restTokens, index, paramMap, context, pathErrorCheckOnly);
   }
   buildRegExpStr() {
     const childKeys = Object.keys(this.#children).sort(compareKey);
@@ -36762,7 +34774,7 @@ var Node = class _Node {
 var Trie = class {
   #context = { varIndex: 0 };
   #root = new Node;
-  insert(path2, index2, pathErrorCheckOnly) {
+  insert(path2, index, pathErrorCheckOnly) {
     const paramAssoc = [];
     const groups = [];
     for (let i = 0;; ) {
@@ -36788,7 +34800,7 @@ var Trie = class {
         }
       }
     }
-    this.#root.insert(tokens, index2, paramAssoc, this.#context, pathErrorCheckOnly);
+    this.#root.insert(tokens, index, paramAssoc, this.#context, pathErrorCheckOnly);
     return paramAssoc;
   }
   buildRegExp() {
@@ -36998,11 +35010,11 @@ var PreparedRegExpRouter = class {
     if (!map2) {
       matcher[2][path2][0].push([handler, {}]);
     } else {
-      indexes.forEach((index2) => {
-        if (typeof index2 === "number") {
-          matcher[1][index2].push([handler, map2]);
+      indexes.forEach((index) => {
+        if (typeof index === "number") {
+          matcher[1][index].push([handler, map2]);
         } else {
-          matcher[2][index2 || path2][0].push([handler, map2]);
+          matcher[2][index || path2][0].push([handler, map2]);
         }
       });
     }
@@ -37481,22 +35493,22 @@ var jsonContentTypeHandler = {
           message: '"input" needs to be an object when doing a batch call'
         });
       const acc = emptyObject();
-      for (const index2 of paths.keys()) {
-        const input = inputs[index2];
+      for (const index of paths.keys()) {
+        const input = inputs[index];
         if (input !== undefined)
-          acc[index2] = opts.router._def._config.transformer.input.deserialize(input);
+          acc[index] = opts.router._def._config.transformer.input.deserialize(input);
       }
       return acc;
     });
-    const calls = await Promise.all(paths.map(async (path2, index2) => {
+    const calls = await Promise.all(paths.map(async (path2, index) => {
       const procedure2 = await getProcedureAtPath(opts.router, path2);
       return {
-        batchIndex: index2,
+        batchIndex: index,
         path: path2,
         procedure: procedure2,
         getRawInput: async () => {
           const inputs = await getInputs.read();
-          let input = inputs[index2];
+          let input = inputs[index];
           if ((procedure2 === null || procedure2 === undefined ? undefined : procedure2._def.type) === "subscription") {
             var _ref2, _opts$headers$get;
             const lastEventId = (_ref2 = (_opts$headers$get = opts.headers.get("last-event-id")) !== null && _opts$headers$get !== undefined ? _opts$headers$get : opts.searchParams.get("lastEventId")) !== null && _ref2 !== undefined ? _ref2 : opts.searchParams.get("Last-Event-Id");
@@ -37512,7 +35524,7 @@ var jsonContentTypeHandler = {
         },
         result: () => {
           var _getInputs$result;
-          return (_getInputs$result = getInputs.result()) === null || _getInputs$result === undefined ? undefined : _getInputs$result[index2];
+          return (_getInputs$result = getInputs.result()) === null || _getInputs$result === undefined ? undefined : _getInputs$result[index];
         }
       };
     }));
@@ -37676,8 +35688,8 @@ var Unpromise = class Unpromise2 {
         status: "fulfilled",
         value
       };
-      subscribers === null || subscribers === undefined || subscribers.forEach(({ resolve: resolve7 }) => {
-        resolve7(value);
+      subscribers === null || subscribers === undefined || subscribers.forEach(({ resolve: resolve8 }) => {
+        resolve8(value);
       });
     });
     if ("catch" in thenReturn)
@@ -37785,28 +35797,28 @@ function resolveSelfTuple(promise2) {
   return Unpromise.proxy(promise2).then(() => [promise2]);
 }
 function withResolvers() {
-  let resolve7;
+  let resolve8;
   let reject;
   const promise2 = new Promise((_resolve, _reject) => {
-    resolve7 = _resolve;
+    resolve8 = _resolve;
     reject = _reject;
   });
   return {
     promise: promise2,
-    resolve: resolve7,
+    resolve: resolve8,
     reject
   };
 }
 function listWithMember(arr, member) {
   return [...arr, member];
 }
-function listWithoutIndex(arr, index2) {
-  return [...arr.slice(0, index2), ...arr.slice(index2 + 1)];
+function listWithoutIndex(arr, index) {
+  return [...arr.slice(0, index), ...arr.slice(index + 1)];
 }
 function listWithoutMember(arr, member) {
-  const index2 = arr.indexOf(member);
-  if (index2 !== -1)
-    return listWithoutIndex(arr, index2);
+  const index = arr.indexOf(member);
+  if (index !== -1)
+    return listWithoutIndex(arr, index);
   return arr;
 }
 var _Symbol;
@@ -37839,8 +35851,8 @@ function timerResource(ms) {
   return makeResource({ start() {
     if (timer)
       throw new Error("Timer already started");
-    const promise2 = new Promise((resolve7) => {
-      timer = setTimeout(() => resolve7(disposablePromiseTimerResult), ms);
+    const promise2 = new Promise((resolve8) => {
+      timer = setTimeout(() => resolve8(disposablePromiseTimerResult), ms);
     });
     return promise2;
   } }, () => {
@@ -38043,15 +36055,15 @@ function _takeWithGrace() {
   return _takeWithGrace.apply(this, arguments);
 }
 function createDeferred() {
-  let resolve7;
+  let resolve8;
   let reject;
   const promise2 = new Promise((res, rej) => {
-    resolve7 = res;
+    resolve8 = res;
     reject = rej;
   });
   return {
     promise: promise2,
-    resolve: resolve7,
+    resolve: resolve8,
     reject
   };
 }
@@ -39019,9 +37031,9 @@ async function resolveResponse(opts) {
       });
       const stream = jsonlStreamProducer((0, import_objectSpread24.default)((0, import_objectSpread24.default)({}, config2.jsonl), {}, {
         maxDepth: Infinity,
-        data: rpcCalls.map(async (res, index2) => {
+        data: rpcCalls.map(async (res, index) => {
           const [error48, result] = await res;
-          const call = info.calls[index2];
+          const call = info.calls[index];
           if (error48) {
             var _procedure$_def$type, _procedure;
             return { error: getErrorShape({
@@ -39083,8 +37095,8 @@ async function resolveResponse(opts) {
         }), undefined];
       return res;
     });
-    const resultAsRPCResponse = results.map(([error48, result], index2) => {
-      const call = info.calls[index2];
+    const resultAsRPCResponse = results.map(([error48, result], index) => {
+      const call = info.calls[index];
       if (error48) {
         var _call$procedure$_def$4, _call$procedure5;
         return { error: getErrorShape({
@@ -39189,7 +37201,7 @@ async function fetchRequestHandler(opts) {
 
 // ../../node_modules/.bun/hono@4.12.10/node_modules/hono/dist/helper/route/index.js
 var matchedRoutes = (c) => c.req[GET_MATCH_RESULT][0].map(([[, route2]]) => route2);
-var routePath = (c, index2) => matchedRoutes(c).at(index2 ?? c.req.routeIndex)?.path ?? "";
+var routePath = (c, index) => matchedRoutes(c).at(index ?? c.req.routeIndex)?.path ?? "";
 
 // ../../node_modules/.bun/@hono+trpc-server@0.4.2+2b2485a92adeb0d0/node_modules/@hono/trpc-server/dist/index.js
 var trpcServer = ({ endpoint, createContext, ...rest }) => {
@@ -39282,14 +37294,14 @@ function parseTRPCMessage(obj, transformer) {
 }
 // ../../apps/desktop/src/core/pairing/runtime/bridge/server-trpc.ts
 import { realpathSync as realpathSync3 } from "fs";
-import { homedir as homedir17 } from "os";
+import { homedir as homedir18 } from "os";
 function resolveCurrentDirectory() {
   try {
     const config2 = resolveConfig();
     const configuredRoot = config2.workspace?.root;
     if (!configuredRoot)
       return process.cwd();
-    const expanded = configuredRoot.replace(/^~/, homedir17());
+    const expanded = configuredRoot.replace(/^~/, homedir18());
     return realpathSync3(expanded);
   } catch {
     return process.cwd();
@@ -39352,14 +37364,14 @@ function startBridgeServerTRPC(options) {
       }
     };
   }
-  async function handleTRPCMessage(ws, state, text2) {
+  async function handleTRPCMessage(ws, state, text) {
     const send = createSender(ws, state);
     if (!bridgeRouter) {
-      await handleLegacyFallback(ws, state, text2);
+      await handleLegacyFallback(ws, state, text);
       return;
     }
     try {
-      const msgJSON = JSON.parse(text2);
+      const msgJSON = JSON.parse(text);
       const msgs = Array.isArray(msgJSON) ? msgJSON : [msgJSON];
       for (const raw2 of msgs) {
         log.info("rpc:req", `\u2192 ${raw2.params?.path ?? raw2.method ?? "?"}`);
@@ -39436,8 +37448,8 @@ function startBridgeServerTRPC(options) {
           }
           const iterable = isObservable(result) ? observableToAsyncIterable(result, abortController.signal) : result;
           const iterator = iterable[Symbol.asyncIterator]();
-          const abortPromise = new Promise((resolve7) => {
-            abortController.signal.addEventListener("abort", () => resolve7("abort"), {
+          const abortPromise = new Promise((resolve8) => {
+            abortController.signal.addEventListener("abort", () => resolve8("abort"), {
               once: true
             });
           });
@@ -39548,7 +37560,7 @@ function startBridgeServerTRPC(options) {
       });
     }
   }
-  async function handleLegacyFallback(ws, state, text2) {
+  async function handleLegacyFallback(ws, state, text) {
     const sendRaw = (json2) => {
       if (state.transport) {
         state.transport.send(json2);
@@ -39558,7 +37570,7 @@ function startBridgeServerTRPC(options) {
     };
     let req;
     try {
-      req = JSON.parse(text2);
+      req = JSON.parse(text);
     } catch {
       sendRaw(JSON.stringify({ id: null, error: { code: -32700, message: "Parse error" } }));
       return;
@@ -39672,8 +37684,8 @@ function startBridgeServerTRPC(options) {
           const data = typeof raw2 === "string" ? raw2 : new Uint8Array(raw2);
           state.transport.receive(data);
         } else {
-          const text2 = typeof raw2 === "string" ? raw2 : new TextDecoder().decode(raw2);
-          handleTRPCMessage(ws, state, text2);
+          const text = typeof raw2 === "string" ? raw2 : new TextDecoder().decode(raw2);
+          handleTRPCMessage(ws, state, text);
         }
       },
       close(ws) {
@@ -39782,6 +37794,8 @@ async function startPairingRuntime(options) {
   }
   const relayConnection = connectToRelay(relayUrl, identity2, bridge, {
     secure: true,
+    publicRelayUrl: options?.advertisedRelayUrl ?? undefined,
+    fallbackRelayUrls: options?.fallbackRelayUrls,
     events: options?.relayEvents
   });
   await autoStartConfiguredSessions(bridge, config2.sessions);
@@ -39809,7 +37823,7 @@ async function autoStartConfiguredSessions(bridge, sessions3) {
     try {
       const session = await bridge.createSession(entry.adapter, {
         name: entry.name,
-        cwd: entry.cwd?.replace(/^~/, homedir18()),
+        cwd: entry.cwd?.replace(/^~/, homedir19()),
         options: entry.options
       });
       console.log(`[bridge] session started: ${session.name} (${entry.adapter})`);
@@ -39823,6 +37837,7 @@ async function autoStartConfiguredSessions(bridge, sessions3) {
 // ../../apps/desktop/src/core/pairing/supervisor.ts
 var SCOUT_PAIR_REFRESH_LEEWAY_MS = 30000;
 var SCOUT_PAIR_RESTART_DELAY_MS = 2000;
+var BONJOUR_SERVICE_TYPE = "_scout-pair._tcp";
 async function runScoutPairingSupervisor() {
   clearStalePairingRuntimeFiles();
   const existingPid = readPairingRuntimePid();
@@ -39844,7 +37859,8 @@ async function runScoutPairingSupervisor() {
     refreshTimer: null,
     intentionalStop: false,
     runtime: null,
-    relay: null
+    relay: null,
+    bonjour: null
   };
   const shutdown = async () => {
     state.intentionalStop = true;
@@ -39872,6 +37888,8 @@ async function startSupervisorRuntime(state) {
   const config2 = resolvedPairingConfig();
   const relayPort = config2.port + 1;
   const resolvedRelayUrl = config2.relay?.trim() || null;
+  const identity2 = loadOrCreateIdentity();
+  const publicKeyHex = bytesToHex2(identity2.publicKey);
   writeCurrent(state, {
     status: "starting",
     statusLabel: "Starting",
@@ -39883,12 +37901,24 @@ async function startSupervisorRuntime(state) {
   });
   const emitStatus = createStatusWriter(state);
   try {
-    const activeRelayUrl = resolvedRelayUrl ?? (() => {
+    const managedRelay = resolvedRelayUrl ? null : (() => {
       state.relay = startManagedRelay(relayPort);
-      return state.relay.relayUrl;
+      return state.relay;
     })();
-    state.runtime = await startPairingRuntime({
+    const activeRelayUrl = resolvedRelayUrl ?? managedRelay?.relayUrl;
+    const connectRelayUrl = resolvedRelayUrl ?? managedRelay?.connectUrl ?? managedRelay?.relayUrl;
+    if (!activeRelayUrl || !connectRelayUrl) {
+      throw new Error("Scout pairing relay URL is not configured.");
+    }
+    state.bonjour = managedRelay ? startBonjourRelayAdvertisement({
+      port: relayPort,
       relayUrl: activeRelayUrl,
+      publicKeyHex
+    }) : null;
+    state.runtime = await startPairingRuntime({
+      relayUrl: connectRelayUrl,
+      advertisedRelayUrl: activeRelayUrl,
+      fallbackRelayUrls: managedRelay?.fallbackRelayUrls,
       relayEvents: {
         onConnecting() {
           emitStatus("connecting", `Connecting to ${activeRelayUrl}`);
@@ -39911,7 +37941,6 @@ async function startSupervisorRuntime(state) {
     if (!payload) {
       throw new Error("Scout pairing runtime did not produce a QR payload.");
     }
-    const identity2 = loadOrCreateIdentity();
     writeCurrent(state, {
       status: "connecting",
       statusLabel: "Pairing Ready",
@@ -39928,7 +37957,7 @@ async function startSupervisorRuntime(state) {
       },
       childPid: null
     }, {
-      identityFingerprint: bytesToHex2(identity2.publicKey).slice(0, 16),
+      identityFingerprint: publicKeyHex.slice(0, 16),
       trustedPeerCount: trustedPeerCount()
     });
     schedulePairingRefresh(state, payload);
@@ -40002,6 +38031,9 @@ function clearRefreshTimer(state) {
   }
 }
 async function stopSupervisorRuntime(state) {
+  try {
+    state.bonjour?.stop();
+  } catch {}
   try {
     await state.runtime?.stop();
   } catch {}
@@ -40010,6 +38042,57 @@ async function stopSupervisorRuntime(state) {
   } catch {}
   state.runtime = null;
   state.relay = null;
+  state.bonjour = null;
+}
+function startBonjourRelayAdvertisement(input) {
+  if (process.platform !== "darwin") {
+    return null;
+  }
+  const scheme = relayScheme(input.relayUrl);
+  const fingerprint = input.publicKeyHex.slice(0, 16);
+  const serviceName = `OpenScout ${fingerprint}`;
+  const args = [
+    "-R",
+    serviceName,
+    BONJOUR_SERVICE_TYPE,
+    "local.",
+    String(input.port),
+    "v=1",
+    `pk=${input.publicKeyHex}`,
+    `fp=${fingerprint}`,
+    `scheme=${scheme}`
+  ];
+  let processRef = null;
+  try {
+    processRef = spawn4("/usr/bin/dns-sd", args, { stdio: "ignore" });
+    processRef.on("error", (error48) => {
+      console.warn(`[pairing] bonjour advertisement failed: ${error48.message}`);
+    });
+    processRef.on("exit", (code, signal) => {
+      if (code !== 0 && signal !== "SIGTERM") {
+        console.warn(`[pairing] bonjour advertisement exited (code=${code ?? "null"}, signal=${signal ?? "null"})`);
+      }
+    });
+    console.log(`[pairing] bonjour advertising ${serviceName} on ${BONJOUR_SERVICE_TYPE} port ${input.port}`);
+  } catch (error48) {
+    const detail = error48 instanceof Error ? error48.message : String(error48);
+    console.warn(`[pairing] bonjour advertisement unavailable: ${detail}`);
+    return null;
+  }
+  return {
+    stop() {
+      processRef?.kill("SIGTERM");
+      processRef = null;
+    }
+  };
+}
+function relayScheme(relayUrl) {
+  try {
+    const protocol = new URL(relayUrl).protocol;
+    return protocol === "wss:" ? "wss" : "ws";
+  } catch {
+    return relayUrl.startsWith("wss://") ? "wss" : "ws";
+  }
 }
 function writeCurrent(state, patch, overrides = {}) {
   state.current = writePairingRuntimeSnapshot({