@openscout/scout 0.2.69 → 0.2.70

package/dist/pair-supervisor.mjs

@@ -715,6 +715,59 @@ function renderToolResultContent(content) {
   }
   return stringifyUnknown(content);
 }
+function renderContentPartsText(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  return content.map((entry) => {
+    if (typeof entry === "string") {
+      return entry;
+    }
+    if (!isRecord(entry)) {
+      return "";
+    }
+    if (typeof entry.text === "string") {
+      return entry.text;
+    }
+    if (typeof entry.content === "string") {
+      return entry.content;
+    }
+    return "";
+  }).filter(Boolean).join(`
+`);
+}
+function extractReasoningText(item) {
+  const summary = Array.isArray(item.summary) ? item.summary : [];
+  const content = Array.isArray(item.content) ? item.content : [];
+  const summaryText = summary.map((entry) => {
+    if (typeof entry === "string") {
+      return entry;
+    }
+    const record = entry;
+    if (typeof record.text === "string") {
+      return record.text;
+    }
+    if (typeof record.summary === "string") {
+      return record.summary;
+    }
+    return "";
+  }).filter(Boolean).join(`
+`);
+  const contentText = content.map((entry) => {
+    if (typeof entry === "string") {
+      return entry;
+    }
+    const record = entry;
+    return typeof record.text === "string" ? record.text : "";
+  }).filter(Boolean).join(`
+`);
+  return [summaryText, contentText].filter(Boolean).join(`
+
+`).trim();
+}
 function extractQuestionOptions(firstQuestion) {
   const options = Array.isArray(firstQuestion.options) ? firstQuestion.options : [];
   return options.map((option) => {
@@ -1424,20 +1477,520 @@ class ClaudeCodeHistoryParser {
     });
   }
 }
+
+class CodexHistoryParser {
+  session;
+  baseTimestampMs;
+  events = [];
+  currentTurn = null;
+  turnCounter = 0;
+  blockIndex = 0;
+  blockById = new Map;
+  toolBlockMap = new Map;
+  assistantMessageTextThisTurn = new Set;
+  inputTokens = 0;
+  outputTokens = 0;
+  reasoningOutputTokens = 0;
+  cachedInputTokens = 0;
+  tokenEventCount = 0;
+  constructor(session, baseTimestampMs) {
+    this.session = session;
+    this.baseTimestampMs = baseTimestampMs;
+  }
+  parse(content) {
+    const lines = content.split(/\r?\n/u);
+    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();
+      if (!trimmed) {
+        continue;
+      }
+      lineCount += 1;
+      let record;
+      try {
+        const parsed = JSON.parse(trimmed);
+        if (!isRecord(parsed)) {
+          skippedLineCount += 1;
+          continue;
+        }
+        record = parsed;
+      } catch {
+        skippedLineCount += 1;
+        continue;
+      }
+      const capturedAt = extractRecordTimestamp(record) ?? this.baseTimestampMs + index;
+      lastCapturedAt = capturedAt;
+      if (this.handleRecord(record, capturedAt)) {
+        parsedLineCount += 1;
+      } else {
+        skippedLineCount += 1;
+      }
+    }
+    if (this.persistUsageMetadata()) {
+      this.emitSessionUpdate(lastCapturedAt);
+    }
+    return {
+      events: this.events,
+      lineCount,
+      parsedLineCount,
+      skippedLineCount
+    };
+  }
+  handleRecord(record, capturedAt) {
+    const type = maybeString(record.type);
+    if (!type) {
+      return false;
+    }
+    switch (type) {
+      case "session_meta":
+        this.handleSessionMeta(record, capturedAt);
+        return true;
+      case "turn_context":
+        this.handleTurnContext(record, capturedAt);
+        return true;
+      case "event_msg":
+        this.handleEventMessage(record, capturedAt);
+        return true;
+      case "response_item":
+        this.handleResponseItem(record, capturedAt);
+        return true;
+      case "compacted":
+        return true;
+      default:
+        return false;
+    }
+  }
+  handleSessionMeta(record, capturedAt) {
+    const payload = isRecord(record.payload) ? record.payload : {};
+    let changed = false;
+    const providerMeta = this.ensureProviderMeta();
+    const externalSessionId = maybeString(payload.id);
+    if (externalSessionId && providerMeta.externalSessionId !== externalSessionId) {
+      providerMeta.externalSessionId = externalSessionId;
+      changed = true;
+    }
+    const cwd = maybeString(payload.cwd);
+    if (cwd && this.session.cwd !== cwd) {
+      this.session.cwd = cwd;
+      if (!this.session.name || /^\d+$/u.test(this.session.name)) {
+        this.session.name = basename(cwd) || "Codex Session";
+      }
+      changed = true;
+    }
+    const git = isRecord(payload.git) ? payload.git : null;
+    const runtime = this.ensureObserveMetaRecord("observeRuntime");
+    changed = this.assignObserveString(runtime, "originator", payload.originator) || changed;
+    changed = this.assignObserveString(runtime, "cliVersion", payload.cli_version) || changed;
+    changed = this.assignObserveString(runtime, "source", payload.source) || changed;
+    changed = this.assignObserveString(runtime, "threadSource", payload.thread_source) || changed;
+    changed = this.assignObserveString(runtime, "modelProvider", payload.model_provider) || changed;
+    changed = this.assignObserveString(runtime, "gitBranch", git?.branch) || changed;
+    changed = this.assignObserveString(runtime, "gitCommitHash", git?.commit_hash) || changed;
+    changed = this.assignObserveString(runtime, "repositoryUrl", git?.repository_url) || changed;
+    if (changed) {
+      this.emitSessionUpdate(capturedAt);
+    }
+  }
+  handleTurnContext(record, capturedAt) {
+    const payload = isRecord(record.payload) ? record.payload : {};
+    let changed = false;
+    const cwd = maybeString(payload.cwd);
+    if (cwd && this.session.cwd !== cwd) {
+      this.session.cwd = cwd;
+      changed = true;
+    }
+    const model = maybeString(payload.model);
+    if (model && this.session.model !== model) {
+      this.session.model = model;
+      changed = true;
+    }
+    const runtime = this.ensureObserveMetaRecord("observeRuntime");
+    changed = this.assignObserveString(runtime, "approvalPolicy", payload.approval_policy) || changed;
+    changed = this.assignObserveString(runtime, "currentDate", payload.current_date) || changed;
+    changed = this.assignObserveString(runtime, "timezone", payload.timezone) || changed;
+    changed = this.assignObserveString(runtime, "effort", payload.effort) || changed;
+    changed = this.assignObserveString(runtime, "personality", payload.personality) || changed;
+    if (isRecord(payload.sandbox_policy) && runtime.sandboxPolicy !== payload.sandbox_policy) {
+      runtime.sandboxPolicy = payload.sandbox_policy;
+      changed = true;
+    }
+    if (changed) {
+      this.emitSessionUpdate(capturedAt);
+    }
+  }
+  handleEventMessage(record, capturedAt) {
+    const payload = isRecord(record.payload) ? record.payload : {};
+    const eventType = maybeString(payload.type);
+    if (!eventType) {
+      return;
+    }
+    switch (eventType) {
+      case "task_started": {
+        const startedAt = normalizeTimestamp(payload.started_at) ?? capturedAt;
+        this.startTurn(startedAt, maybeString(payload.turn_id));
+        break;
+      }
+      case "user_message":
+        this.ensureTurn(capturedAt);
+        break;
+      case "agent_message": {
+        const message = maybeString(payload.message);
+        if (message) {
+          this.appendCompletedText(capturedAt, message);
+          this.assistantMessageTextThisTurn.add(message);
+        }
+        break;
+      }
+      case "patch_apply_end":
+        this.handleToolOutput(capturedAt, maybeString(payload.call_id), [maybeString(payload.stdout), maybeString(payload.stderr)].filter(Boolean).join(`
+`), payload.success === false);
+        break;
+      case "token_count":
+        this.captureTokenUsage(payload.info);
+        break;
+      case "task_complete":
+        this.endTurn("completed", normalizeTimestamp(payload.completed_at) ?? capturedAt);
+        break;
+      case "context_compacted":
+      case "web_search_end":
+        break;
+      default:
+        break;
+    }
+  }
+  handleResponseItem(record, capturedAt) {
+    const payload = isRecord(record.payload) ? record.payload : {};
+    const itemType = maybeString(payload.type);
+    if (!itemType) {
+      return;
+    }
+    switch (itemType) {
+      case "message":
+        this.handleResponseMessage(payload, capturedAt);
+        break;
+      case "reasoning":
+        this.handleReasoning(payload, capturedAt);
+        break;
+      case "function_call":
+      case "custom_tool_call":
+        this.handleToolCall(payload, capturedAt);
+        break;
+      case "function_call_output":
+      case "custom_tool_call_output":
+        this.handleToolOutput(capturedAt, maybeString(payload.call_id), renderToolResultContent(payload.output), false);
+        break;
+      case "web_search_call":
+        this.handleWebSearchCall(payload, capturedAt);
+        break;
+      default:
+        break;
+    }
+  }
+  handleResponseMessage(payload, capturedAt) {
+    const role = maybeString(payload.role);
+    if (role !== "assistant") {
+      return;
+    }
+    const text = renderContentPartsText(payload.content).trim();
+    if (!text || this.assistantMessageTextThisTurn.has(text)) {
+      return;
+    }
+    this.appendCompletedText(capturedAt, text);
+    this.assistantMessageTextThisTurn.add(text);
+  }
+  handleReasoning(payload, capturedAt) {
+    const text = extractReasoningText(payload);
+    if (!text) {
+      return;
+    }
+    const turn = this.ensureTurn(capturedAt);
+    const block = this.startBlock(turn, capturedAt, {
+      type: "reasoning",
+      text,
+      status: "completed"
+    });
+    this.emitBlockEnd(capturedAt, turn, block, "completed");
+  }
+  handleToolCall(payload, capturedAt) {
+    const turn = this.ensureTurn(capturedAt);
+    const toolName = maybeString(payload.name) ?? "unknown";
+    const toolCallId = maybeString(payload.call_id) ?? `${turn.id}:tool:${this.blockIndex}`;
+    const input = this.parseToolInput(payload.arguments ?? payload.input);
+    const action = this.buildAction(toolName, toolCallId, input);
+    const block = this.startBlock(turn, capturedAt, {
+      id: `${turn.id}:action:${toolCallId}`,
+      type: "action",
+      action,
+      status: "streaming"
+    });
+    this.toolBlockMap.set(toolCallId, block.id);
+  }
+  handleWebSearchCall(payload, capturedAt) {
+    const turn = this.ensureTurn(capturedAt);
+    const toolCallId = `${turn.id}:web-search:${this.blockIndex}`;
+    const action = {
+      kind: "tool_call",
+      toolName: "web_search",
+      toolCallId,
+      input: payload.action,
+      result: payload.status,
+      status: maybeString(payload.status) === "failed" ? "failed" : "completed",
+      output: ""
+    };
+    const block = this.startBlock(turn, capturedAt, {
+      id: `${turn.id}:action:${toolCallId}`,
+      type: "action",
+      action,
+      status: "completed"
+    });
+    this.emitBlockEnd(capturedAt, turn, block, "completed");
+  }
+  parseToolInput(value) {
+    if (typeof value !== "string") {
+      return value;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+      return "";
+    }
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      return value;
+    }
+  }
+  buildAction(toolName, toolCallId, input) {
+    const inputRecord = isRecord(input) ? input : {};
+    if (toolName === "exec_command") {
+      return {
+        kind: "command",
+        command: maybeString(inputRecord.cmd) ?? "",
+        status: "running",
+        output: ""
+      };
+    }
+    return {
+      kind: "tool_call",
+      toolName,
+      toolCallId,
+      input,
+      status: "running",
+      output: ""
+    };
+  }
+  handleToolOutput(capturedAt, toolCallId, output, isError) {
+    if (!toolCallId) {
+      return;
+    }
+    const blockId = this.toolBlockMap.get(toolCallId);
+    const turn = this.currentTurn;
+    if (!blockId || !turn) {
+      return;
+    }
+    if (output) {
+      this.emitEvent(capturedAt, {
+        event: "block:action:output",
+        sessionId: this.session.id,
+        turnId: turn.id,
+        blockId,
+        output
+      });
+    }
+    const exitCode = this.extractExitCode(output);
+    const status = isError || exitCode != null && exitCode !== 0 ? "failed" : "completed";
+    this.emitEvent(capturedAt, {
+      event: "block:action:status",
+      sessionId: this.session.id,
+      turnId: turn.id,
+      blockId,
+      status,
+      ...exitCode != null ? { meta: { exitCode } } : {}
+    });
+    const block = this.blockById.get(blockId);
+    if (block) {
+      this.emitBlockEnd(capturedAt, turn, block, status === "failed" ? "failed" : "completed");
+    }
+    this.toolBlockMap.delete(toolCallId);
+  }
+  extractExitCode(output) {
+    const match = output.match(/(?:exit code|exited with code):\s*(-?\d+)/iu);
+    if (!match) {
+      return null;
+    }
+    const exitCode = Number(match[1]);
+    return Number.isFinite(exitCode) ? exitCode : null;
+  }
+  captureTokenUsage(info) {
+    if (!isRecord(info)) {
+      return;
+    }
+    const total = isRecord(info.total_token_usage) ? info.total_token_usage : {};
+    this.inputTokens = maybeNumber(total.input_tokens) ?? this.inputTokens;
+    this.outputTokens = maybeNumber(total.output_tokens) ?? this.outputTokens;
+    this.reasoningOutputTokens = maybeNumber(total.reasoning_output_tokens) ?? this.reasoningOutputTokens;
+    this.cachedInputTokens = maybeNumber(total.cached_input_tokens) ?? this.cachedInputTokens;
+    this.tokenEventCount += 1;
+  }
+  persistUsageMetadata() {
+    if (this.tokenEventCount === 0) {
+      return false;
+    }
+    const usage = this.ensureObserveMetaRecord("observeUsage");
+    let changed = false;
+    const assignNumber = (key, value) => {
+      if (value > 0 && usage[key] !== value) {
+        usage[key] = value;
+        changed = true;
+      }
+    };
+    assignNumber("inputTokens", this.inputTokens);
+    assignNumber("outputTokens", this.outputTokens);
+    assignNumber("reasoningOutputTokens", this.reasoningOutputTokens);
+    assignNumber("cacheReadInputTokens", this.cachedInputTokens);
+    assignNumber("tokenEvents", this.tokenEventCount);
+    return changed;
+  }
+  startTurn(capturedAt, turnId) {
+    if (this.currentTurn) {
+      this.endTurn("stopped", capturedAt);
+    }
+    this.turnCounter += 1;
+    this.blockIndex = 0;
+    this.blockById.clear();
+    this.toolBlockMap.clear();
+    this.assistantMessageTextThisTurn.clear();
+    this.session.status = "active";
+    this.emitSessionUpdate(capturedAt);
+    const turn = {
+      id: turnId || `history-turn-${this.turnCounter}`,
+      sessionId: this.session.id,
+      status: "started",
+      startedAt: new Date(capturedAt).toISOString(),
+      blocks: []
+    };
+    this.currentTurn = turn;
+    this.emitEvent(capturedAt, {
+      event: "turn:start",
+      sessionId: this.session.id,
+      turn
+    });
+    return turn;
+  }
+  ensureTurn(capturedAt) {
+    return this.currentTurn ?? this.startTurn(capturedAt);
+  }
+  endTurn(status, capturedAt) {
+    const turn = this.currentTurn;
+    if (!turn) {
+      return;
+    }
+    turn.status = status;
+    turn.endedAt = new Date(capturedAt).toISOString();
+    this.emitEvent(capturedAt, {
+      event: "turn:end",
+      sessionId: this.session.id,
+      turnId: turn.id,
+      status
+    });
+    this.currentTurn = null;
+    this.blockById.clear();
+    this.toolBlockMap.clear();
+    this.assistantMessageTextThisTurn.clear();
+    this.session.status = "idle";
+    this.emitSessionUpdate(capturedAt);
+  }
+  appendCompletedText(capturedAt, text) {
+    const turn = this.ensureTurn(capturedAt);
+    const block = this.startBlock(turn, capturedAt, {
+      type: "text",
+      text,
+      status: "completed"
+    });
+    this.emitBlockEnd(capturedAt, turn, block, "completed");
+  }
+  startBlock(turn, capturedAt, partial) {
+    const block = {
+      ...partial,
+      id: partial.id || `${turn.id}:block:${this.blockIndex}`,
+      turnId: turn.id,
+      index: this.blockIndex
+    };
+    this.blockIndex += 1;
+    turn.blocks.push(block);
+    this.blockById.set(block.id, block);
+    this.emitEvent(capturedAt, {
+      event: "block:start",
+      sessionId: this.session.id,
+      turnId: turn.id,
+      block
+    });
+    return block;
+  }
+  emitBlockEnd(capturedAt, turn, block, status) {
+    block.status = status;
+    this.emitEvent(capturedAt, {
+      event: "block:end",
+      sessionId: this.session.id,
+      turnId: turn.id,
+      blockId: block.id,
+      status
+    });
+  }
+  ensureProviderMeta() {
+    const providerMeta = isRecord(this.session.providerMeta) ? this.session.providerMeta : {};
+    this.session.providerMeta = providerMeta;
+    return providerMeta;
+  }
+  ensureObserveMetaRecord(key) {
+    const providerMeta = this.ensureProviderMeta();
+    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) {
+      return false;
+    }
+    target[key] = next;
+    return true;
+  }
+  emitSessionUpdate(capturedAt) {
+    this.emitEvent(capturedAt, {
+      event: "session:update",
+      session: { ...this.session }
+    });
+  }
+  emitEvent(capturedAt, event) {
+    this.events.push({
+      capturedAt,
+      event: structuredClone(event)
+    });
+  }
+}
 function inferHistorySessionAdapterType(path2, adapterType) {
   return inferHistoryAdapterType(path2, adapterType);
 }
 function supportsHistorySessionSnapshotForPath(path2, adapterType) {
-  return inferHistoryAdapterType(path2, adapterType) === "claude-code";
+  const inferred = inferHistoryAdapterType(path2, adapterType);
+  return inferred === "claude-code" || inferred === "codex";
 }
 function createHistorySessionSnapshot(input) {
   const adapterType = inferHistoryAdapterType(input.path, input.adapterType);
-  if (adapterType !== "claude-code") {
+  if (adapterType !== "claude-code" && adapterType !== "codex") {
     throw new Error(`History snapshot is not supported for adapter type "${adapterType}".`);
   }
   const session = buildBaseHistorySession(input, adapterType);
   const baseTimestampMs = normalizeTimestamp(input.baseTimestampMs) ?? Date.now();
-  const parser = new ClaudeCodeHistoryParser(session, baseTimestampMs);
+  const parser = adapterType === "codex" ? new CodexHistoryParser(session, baseTimestampMs) : new ClaudeCodeHistoryParser(session, baseTimestampMs);
   const replay = parser.parse(input.content);
   const tracker = new StateTracker;
   tracker.createSession(session.id, session);
@@ -3334,7 +3887,7 @@ function stringifyValue(value) {
     return String(value);
   }
 }
-function extractReasoningText(item) {
+function extractReasoningText2(item) {
   const summary = Array.isArray(item.summary) ? item.summary : [];
   const content = Array.isArray(item.content) ? item.content : [];
   const summaryText = summary.map((entry) => {
@@ -3810,7 +4363,7 @@ var init_codex = __esm(() => {
           this.ensureTextBlock(turnState, itemId, typeof item.text === "string" ? item.text : "");
           return;
         case "reasoning": {
-          const text = extractReasoningText(item);
+          const text = extractReasoningText2(item);
           if (text) {
             this.ensureReasoningBlock(turnState, itemId, text);
           }
@@ -3889,7 +4442,7 @@ var init_codex = __esm(() => {
           return;
         }
         case "reasoning": {
-          const finalText = extractReasoningText(item);
+          const finalText = extractReasoningText2(item);
           if (!finalText && !turnState.blocksByItemId.has(itemId)) {
             return;
           }
@@ -7813,6 +8366,25 @@ function buildScoutReturnAddress(input) {
   }
   return next;
 }
+// ../protocol/src/channel-identity.ts
+function mintChannelId(randomUuid) {
+  return `${CHANNEL_ID_PREFIX}${randomUuid().toLowerCase()}`;
+}
+function directChannelNaturalKey(participantIds) {
+  return `direct:${stableIdentityParts(participantIds).join(",")}`;
+}
+function channelNaturalKeyFromMetadata(metadata) {
+  const value = metadata?.[CHANNEL_NATURAL_KEY_METADATA];
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function stableIdentityParts(values) {
+  return Array.from(new Set(values.map((value) => value.trim()).filter(Boolean))).sort().map(encodeIdentityPart);
+}
+function encodeIdentityPart(value) {
+  return encodeURIComponent(value).replace(/[!'()*]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`);
+}
+var CHANNEL_ID_PREFIX = "c.", CHANNEL_NATURAL_KEY_METADATA = "naturalKey";
+
 // ../protocol/src/collaboration.ts
 function isQuestionTerminalState(state) {
   return state === "closed" || state === "declined";
@@ -14922,6 +15494,7 @@ var init_local_agents = __esm(() => {
     "mcp__scout__messages_inbox",
     "mcp__scout__messages_channel",
     "mcp__scout__broker_feed",
+    "mcp__scout__tail_events",
     "mcp__scout__agents_search",
     "mcp__scout__agents_resolve",
     "mcp__scout__messages_reply",
@@ -19499,6 +20072,7 @@ function createScoutAgentService(deps) {
 }
 
 // ../web/server/core/broker/service.ts
+import { randomUUID as randomUUID3 } from "crypto";
 init_src2();
 init_setup();
 init_broker_api();
@@ -19571,6 +20145,8 @@ var scoutBrokerPaths = {
     node: "/v1/node",
     snapshot: "/v1/snapshot",
     topologySnapshot: "/v1/topology/snapshot",
+    tailDiscover: "/v1/tail/discover",
+    tailRecent: "/v1/tail/recent",
     messages: "/v1/messages",
     eventsStream: "/v1/events/stream",
     actors: "/v1/actors",
@@ -19589,7 +20165,6 @@ var scoutBrokerPaths = {
 };
 
 // ../web/server/core/broker/service.ts
-var BROKER_SHARED_CHANNEL_ID = "channel.shared";
 var OPERATOR_ID = "operator";
 var DEFAULT_BROKER_HOST2 = "127.0.0.1";
 var DEFAULT_BROKER_PORT2 = 65535;
@@ -19916,21 +20491,15 @@ async function ensureTargetRelayAgentRegistered(baseUrl, snapshot, nodeId, agent
   });
   return Boolean(binding);
 }
-function directConversationIdForActors(sourceId, targetId) {
-  if (sourceId === targetId) {
-    return `dm.${sourceId}.${targetId}`;
-  }
-  if (sourceId === OPERATOR_ID || targetId === OPERATOR_ID) {
-    const peerId = sourceId === OPERATOR_ID ? targetId : sourceId;
-    return `dm.${OPERATOR_ID}.${peerId}`;
-  }
-  return `dm.${[sourceId, targetId].sort().join(".")}`;
+function findConversationByIdentity(snapshot, naturalKey) {
+  return Object.values(snapshot.conversations).find((conversation) => channelNaturalKeyFromMetadata(conversation.metadata) === naturalKey);
 }
 async function ensureBrokerDirectConversationBetween(baseUrl, snapshot, nodeId, sourceId, targetId) {
-  const conversationId = targetId === SCOUT_AGENT_ID && sourceId === OPERATOR_ID ? BROKER_SHARED_CHANNEL_ID : directConversationIdForActors(sourceId, targetId);
   const participantIds = [...new Set([sourceId, targetId])].sort();
+  const naturalKey = directChannelNaturalKey(participantIds);
+  const existing = findConversationByIdentity(snapshot, naturalKey);
+  const conversationId = existing?.id ?? mintChannelId(randomUUID3);
   const nextShareMode = resolveConversationShareMode(snapshot, nodeId, participantIds, "local");
-  const existing = snapshot.conversations[conversationId];
   const alreadyMatches = existing && existing.kind === "direct" && existing.shareMode === nextShareMode && existing.visibility === "private" && existing.participantIds.join("\x00") === participantIds.join("\x00");
   if (alreadyMatches) {
     const preferredTargetId = targetId === OPERATOR_ID ? sourceId : targetId;
@@ -19952,6 +20521,7 @@ async function ensureBrokerDirectConversationBetween(baseUrl, snapshot, nodeId,
     participantIds,
     metadata: {
       surface: "scout",
+      naturalKey,
       ...targetId === SCOUT_AGENT_ID && sourceId === OPERATOR_ID ? { role: "partner" } : {}
     }
   };
@@ -20222,6 +20792,11 @@ function transientBrokerWorkingStatusPredicate(alias) {
 var HEARTRATE_WINDOW_MS = 7 * 24 * 60 * 60000;
 // ../web/server/db/runs.ts
 init_src2();
+
+// ../web/server/db/sessions.ts
+init_src2();
+
+// ../web/server/db/runs.ts
 var ACTIVE_RUN_STATES = new Set([
   "queued",
   "waking",
@@ -20992,7 +21567,7 @@ async function ensureScoutbotRegistered(baseUrl, snapshot, nodeId, currentDirect
     await postJson(baseUrl, "/v1/actors", actor);
   }
   const existingAgent = snapshot.agents?.[SCOUTBOT_AGENT_ID];
-  if (!existingAgent || !hasScoutbotLabels(existingAgent) || !hasCurrentScoutbotAgentConfig(existingAgent)) {
+  if (!existingAgent || !hasCurrentScoutbotAgentRegistration(existingAgent, nodeId)) {
     await postJson(baseUrl, "/v1/agents", agent);
   }
   const existingEndpoint = findScoutbotEndpoint(snapshot, nodeId);
@@ -21187,6 +21762,9 @@ function hasScoutbotLabels(agent) {
   const labels = new Set(agent.labels ?? []);
   return labels.has("assistant") && labels.has("scout") && labels.has("scoutbot");
 }
+function hasCurrentScoutbotAgentRegistration(agent, nodeId) {
+  return hasScoutbotLabels(agent) && hasCurrentScoutbotAgentConfig(agent) && agent.homeNodeId === nodeId && agent.authorityNodeId === nodeId && agent.advertiseScope === "local" && agent.wakePolicy === "keep_warm" && agent.metadata?.source === "scoutbot";
+}
 function hasCurrentScoutbotAgentConfig(agent) {
   const roleConfig = metadataObject(agent.metadata, "roleConfig");
   return metadataString5(roleConfig, "systemPrompt") === SCOUTBOT_ROLE_CONFIG.systemPrompt;
@@ -38949,6 +39527,9 @@ init_src2();
 // ../runtime/src/drizzle-migrate.ts
 init_support_paths();
 if (false) {}
+
+// ../runtime/src/conversations/api.ts
+init_src2();
 // ../runtime/src/tailscale.ts
 import { execFile } from "child_process";
 import { promisify } from "util";