@openscout/scout 0.2.69 → 0.2.70

package/dist/scout-web-server.mjs

@@ -1503,6 +1503,31 @@ function buildScoutReturnAddress(input) {
   }
   return next;
 }
+// packages/protocol/src/channel-identity.ts
+function mintChannelId(randomUuid) {
+  return `${CHANNEL_ID_PREFIX}${randomUuid().toLowerCase()}`;
+}
+function directChannelNaturalKey(participantIds) {
+  return `direct:${stableIdentityParts(participantIds).join(",")}`;
+}
+function namedChannelNaturalKey(channel) {
+  return `channel:${encodeIdentityPart(channel.trim().toLowerCase() || "shared")}`;
+}
+function systemChannelNaturalKey(name) {
+  return `system:${encodeIdentityPart(name.trim().toLowerCase() || "system")}`;
+}
+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";
+
 // packages/protocol/src/collaboration.ts
 function isQuestionTerminalState(state) {
   return state === "closed" || state === "declined";
@@ -5742,6 +5767,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) => {
@@ -6451,17 +6529,517 @@ 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 = basename2(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 match2 = output.match(/(?:exit code|exited with code):\s*(-?\d+)/iu);
+    if (!match2) {
+      return null;
+    }
+    const exitCode = Number(match2[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 supportsHistorySessionSnapshotForPath(path, adapterType) {
-  return inferHistoryAdapterType(path, adapterType) === "claude-code";
+  const inferred = inferHistoryAdapterType(path, 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);
@@ -8181,7 +8759,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) => {
@@ -8657,7 +9235,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);
           }
@@ -8736,7 +9314,7 @@ var init_codex = __esm(() => {
           return;
         }
         case "reasoning": {
-          const finalText = extractReasoningText(item);
+          const finalText = extractReasoningText2(item);
           if (!finalText && !turnState.blocksByItemId.has(itemId)) {
             return;
           }
@@ -12481,7 +13059,7 @@ function isCodexThreadGlobalMessage(message) {
 function sessionKey2(options) {
   return `${options.agentName}:${options.sessionId}`;
 }
-function metadataString2(metadata, key) {
+function metadataString3(metadata, key) {
   const value = metadata?.[key];
   return typeof value === "string" && value.trim().length > 0 ? value : undefined;
 }
@@ -13909,9 +14487,9 @@ class CodexAppServerSession {
         return;
       }
       const errorPayload = metadataRecord(params, "error");
-      const message2 = metadataString2(errorPayload, "message") ?? metadataString2(params, "message") ?? "Codex app-server reported an error.";
-      const codexErrorInfo = metadataString2(errorPayload, "codexErrorInfo") ?? metadataString2(params, "codexErrorInfo");
-      const additionalDetails = metadataString2(errorPayload, "additionalDetails") ?? metadataString2(params, "additionalDetails");
+      const message2 = metadataString3(errorPayload, "message") ?? metadataString3(params, "message") ?? "Codex app-server reported an error.";
+      const codexErrorInfo = metadataString3(errorPayload, "codexErrorInfo") ?? metadataString3(params, "codexErrorInfo");
+      const additionalDetails = metadataString3(errorPayload, "additionalDetails") ?? metadataString3(params, "additionalDetails");
       const detail = [codexErrorInfo, additionalDetails].filter((value) => Boolean(value && value.trim().length > 0)).join("; ");
       const error = detail.length > 0 ? `${message2} (${detail})` : message2;
       if (this.activeTurn) {
@@ -14109,8 +14687,8 @@ async function getCodexAppServerAgentSnapshot(options) {
     readOptionalFile3(threadIdPath),
     readOptionalJsonRecord(statePath)
   ]);
-  const resolvedThreadId = options.threadId ?? persistedThreadId ?? metadataString2(persistedState ?? undefined, "threadId") ?? undefined;
-  const persistedThreadPath = metadataString2(persistedState ?? undefined, "threadPath");
+  const resolvedThreadId = options.threadId ?? persistedThreadId ?? metadataString3(persistedState ?? undefined, "threadId") ?? undefined;
+  const persistedThreadPath = metadataString3(persistedState ?? undefined, "threadPath");
   if (persistedThreadPath) {
     const rawRollout = await readOptionalFile3(persistedThreadPath);
     if (rawRollout) {
@@ -14379,6 +14957,8 @@ __export(exports_local_agents, {
   getLocalAgentConfig: () => getLocalAgentConfig,
   ensureLocalSessionEndpointOnline: () => ensureLocalSessionEndpointOnline,
   ensureLocalAgentBindingOnline: () => ensureLocalAgentBindingOnline,
+  endpointStateAfterSuccessfulSessionWarmup: () => endpointStateAfterSuccessfulSessionWarmup,
+  clearEndpointFailureMetadata: () => clearEndpointFailureMetadata,
   classifyLocalAgentContextState: () => classifyLocalAgentContextState,
   buildTmuxPasteBufferArgs: () => buildTmuxPasteBufferArgs,
   buildTmuxLaunchShellCommand: () => buildTmuxLaunchShellCommand,
@@ -15525,6 +16105,13 @@ async function ensureLocalSessionEndpointOnline(endpoint) {
   }
   return {};
 }
+function clearEndpointFailureMetadata(metadata) {
+  const { lastError: _lastError, lastFailedAt: _lastFailedAt, ...baseMetadata } = metadata ?? {};
+  return baseMetadata;
+}
+function endpointStateAfterSuccessfulSessionWarmup(state) {
+  return state === "active" ? "active" : "idle";
+}
 async function shutdownLocalSessionEndpoint(endpoint) {
   if (endpoint.transport === "codex_app_server") {
     await shutdownCodexAppServerAgent(buildCodexEndpointSessionOptions(endpoint));
@@ -15953,7 +16540,7 @@ function invocationSessionFreshness(invocation) {
     case "existing":
       return "continuing session";
     case "any":
-      return "reuse-or-new session";
+      return invocation.execution?.targetSessionId ? "continuing session" : "fresh session";
     default:
       return "session unspecified";
   }
@@ -17342,6 +17929,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",
@@ -20662,17 +21250,24 @@ function queryActivity(limit = 60) {
          ai.invocation_id,
          ai.session_id,
          ai.message_id,
-         ai.record_id
+         ai.record_id,
+         c.kind AS conversation_kind
        FROM activity_items ai
        LEFT JOIN actors ac ON ac.id = ai.actor_id
        LEFT JOIN actors agent_actor ON agent_actor.id = ai.agent_id
+       LEFT JOIN conversations c ON c.id = ai.conversation_id
        WHERE ai.kind != 'ask_replied'
          AND ${staleFlightActivityPredicate("ai")}
        ORDER BY ${activityTsExpression} DESC
        LIMIT ?`).all(limit);
   const items = rows.map((r) => ({
     id: r.id,
-    kind: r.kind,
+    kind: normalizeActivityKind(r.kind, {
+      conversationKind: r.conversation_kind,
+      messageId: r.message_id,
+      invocationId: r.invocation_id,
+      flightId: r.flight_id
+    }),
     ts: r.ts,
     actorName: r.actor_name,
     title: r.title,
@@ -20689,6 +21284,12 @@ function queryActivity(limit = 60) {
   }));
   return items.filter((item, index) => !isDuplicateActivityFeedItem(items[index - 1] ?? null, item));
 }
+function normalizeActivityKind(kind, input) {
+  if (kind === "ask_opened" && input.messageId && !input.invocationId && !input.flightId && input.conversationKind !== "direct") {
+    return "message_posted";
+  }
+  return kind;
+}
 var HEARTRATE_WINDOW_MS = 7 * 24 * 60 * 60000;
 var DEFAULT_HEARTRATE_BUCKETS = 56;
 function smoothHeartrateCounts(counts) {
@@ -21540,6 +22141,7 @@ function queryWorkItems(opts) {
 }
 
 // packages/web/server/db/sessions.ts
+init_src();
 function pickDirectConversationAgentId(participants, candidateAgentIds) {
   const uniqueAgentIds = Array.from(new Set(candidateAgentIds.filter(Boolean)));
   if (uniqueAgentIds.length === 0) {
@@ -21609,6 +22211,64 @@ function queryConversationDefinitionById(conversationId) {
     participantIds: participants
   };
 }
+function parseMetadataJson(raw2) {
+  if (!raw2)
+    return {};
+  try {
+    const parsed = JSON.parse(raw2);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function metadataString2(metadata, key) {
+  const value = metadata[key];
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function formatChannelAlias(value) {
+  const trimmed = value.trim();
+  if (!trimmed)
+    return "";
+  return trimmed.startsWith("#") ? trimmed : `#${trimmed}`;
+}
+function conversationAliasForRow(row, metadata) {
+  const explicitAlias = metadataString2(metadata, "alias");
+  if (explicitAlias)
+    return explicitAlias;
+  const channel = metadataString2(metadata, "channel");
+  if (channel && channel !== "system") {
+    return formatChannelAlias(channel);
+  }
+  if (row.kind === "channel") {
+    if (row.id.startsWith("channel.")) {
+      return formatChannelAlias(row.id.slice("channel.".length));
+    }
+    return formatChannelAlias(row.title);
+  }
+  return null;
+}
+function conversationIdentityFields(row, metadata) {
+  const alias = conversationAliasForRow(row, metadata);
+  const naturalKey = channelNaturalKeyFromMetadata(metadata);
+  return {
+    ...alias ? { alias } : {},
+    ...naturalKey ? { naturalKey } : {}
+  };
+}
+function resolveConversationAlias(conversationId) {
+  const byMetadata = db().prepare(`SELECT id, metadata_json
+     FROM conversations
+     ORDER BY created_at ASC`).all();
+  const directConversation = parseDirectConversationId(conversationId);
+  const naturalKey = directConversation ? directChannelNaturalKey([directConversation.operatorId, directConversation.agentId]) : conversationId.startsWith("channel.") ? namedChannelNaturalKey(conversationId.slice("channel.".length)) : null;
+  for (const row of byMetadata) {
+    const metadata = parseMetadataJson(row.metadata_json);
+    if (naturalKey && channelNaturalKeyFromMetadata(metadata) === naturalKey) {
+      return row.id;
+    }
+  }
+  return null;
+}
 function projectSessionConversationRows(rows, opts) {
   const dedupeLocalSessionDirects = opts?.dedupeLocalSessionDirects ?? false;
   const messageCreatedAtExpression = sqlTimestampMsExpression("created_at");
@@ -21634,6 +22294,7 @@ function projectSessionConversationRows(rows, opts) {
      ORDER BY ${messageCreatedAtExpression} DESC
      LIMIT 1`);
   const summaries = rows.flatMap((r) => {
+    const conversationMetadata = parseMetadataJson(r.metadata_json);
     const participants = memberStmt.all(r.id).map((m) => m.actor_id);
     const agentParticipants = agentMemberStmt.all(r.id);
     const primaryAgentId = r.kind === "direct" ? pickDirectConversationAgentId(participants, agentParticipants.map((entry) => entry.agent_id)) : agentParticipants.length === 1 ? agentParticipants[0]?.agent_id ?? null : null;
@@ -21666,10 +22327,12 @@ function projectSessionConversationRows(rows, opts) {
       }
     }
     const preview = previewStmt.get(r.id)?.body ?? null;
+    const identityFields = conversationIdentityFields(r, conversationMetadata);
     return [{
       id: r.id,
       kind: r.kind,
       title: agentName ?? r.title,
+      ...identityFields,
       participantIds: participants,
       agentId,
       agentName,
@@ -21739,7 +22402,7 @@ function querySessions(limit = 80) {
 }
 function querySessionById(conversationId) {
   const messageCreatedAtExpression = sqlTimestampMsExpression("created_at");
-  const row = db().prepare(`SELECT
+  const readRow = (id) => db().prepare(`SELECT
        c.id,
        c.kind,
        c.title,
@@ -21754,11 +22417,20 @@ function querySessionById(conversationId) {
        GROUP BY conversation_id
      ) ms ON ms.conversation_id = c.id
      WHERE c.id = ?
-     LIMIT 1`).get(conversationId, conversationId);
+     LIMIT 1`).get(id, id);
+  const row = readRow(conversationId);
   const existing = row ? projectSessionConversationRows([row], { dedupeLocalSessionDirects: false, limit: 1 })[0] ?? null : null;
   if (existing) {
     return existing;
   }
+  const resolvedConversationId = resolveConversationAlias(conversationId);
+  if (resolvedConversationId) {
+    const resolvedRow = readRow(resolvedConversationId);
+    const resolved = resolvedRow ? projectSessionConversationRows([resolvedRow], { dedupeLocalSessionDirects: false, limit: 1 })[0] ?? null : null;
+    if (resolved) {
+      return resolved;
+    }
+  }
   const directConversation = parseDirectConversationId(conversationId);
   if (!directConversation) {
     return null;
@@ -22214,7 +22886,7 @@ init_user_config();
 function projectFleetActivity(row) {
   return {
     id: row.id,
-    kind: row.kind,
+    kind: normalizeFleetActivityKind(row),
     ts: row.ts,
     actorName: row.actor_name,
     title: row.title,
@@ -22231,6 +22903,12 @@ function projectFleetActivity(row) {
     sessionId: row.session_id
   };
 }
+function normalizeFleetActivityKind(row) {
+  if (row.kind === "ask_opened" && row.message_id && !row.invocation_id && !row.flight_id && row.conversation_kind !== "direct") {
+    return "message_posted";
+  }
+  return row.kind;
+}
 function queryFleetActivity(opts) {
   const filters = [];
   const params = [];
@@ -22279,10 +22957,12 @@ function queryFleetActivity(opts) {
     ai.invocation_id,
     ai.flight_id,
     ai.record_id,
-    ai.session_id
+    ai.session_id,
+    c.kind AS conversation_kind
   FROM activity_items ai
   LEFT JOIN actors ac ON ac.id = ai.actor_id
   LEFT JOIN actors agent_actor ON agent_actor.id = ai.agent_id
+  LEFT JOIN conversations c ON c.id = ai.conversation_id
   ${sqlWhereClause([
     staleFlightActivityPredicate("ai"),
     ...andClauses,
@@ -22554,6 +23234,7 @@ init_broker_process_manager();
 init_local_agents();
 init_support_paths();
 init_user_config();
+import { randomUUID as randomUUID3 } from "crypto";
 import { mkdir as mkdir7, readFile as readFile7, unlink, writeFile as writeFile7 } from "fs/promises";
 import { basename as basename9, join as join22, resolve as resolve8 } from "path";
 
@@ -22565,6 +23246,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",
@@ -22583,9 +23266,6 @@ var scoutBrokerPaths = {
 };
 
 // packages/web/server/core/broker/service.ts
-var BROKER_SHARED_CHANNEL_ID = "channel.shared";
-var BROKER_VOICE_CHANNEL_ID = "channel.voice";
-var BROKER_SYSTEM_CHANNEL_ID = "channel.system";
 var OPERATOR_ID = "operator";
 var DEFAULT_BROKER_HOST2 = "127.0.0.1";
 var DEFAULT_BROKER_PORT2 = 65535;
@@ -22619,7 +23299,7 @@ function titleCaseName(value) {
   return value.split(/[-_.\s]+/).filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1)).join(" ");
 }
 function displayNameForBrokerActor(snapshot, actorId) {
-  return snapshot.agents[actorId]?.displayName ?? snapshot.actors[actorId]?.displayName ?? titleCaseName(metadataString3(snapshot.agents[actorId]?.metadata, "definitionId") || actorId);
+  return snapshot.agents[actorId]?.displayName ?? snapshot.actors[actorId]?.displayName ?? titleCaseName(metadataString4(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];
@@ -22628,9 +23308,9 @@ 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() || metadataString3(agent?.metadata, "selector") || metadataString3(actor?.metadata, "selector");
-  const defaultSelector = agent?.defaultSelector?.trim() || metadataString3(agent?.metadata, "defaultSelector") || metadataString3(actor?.metadata, "defaultSelector");
-  const projectRoot = endpoint?.projectRoot ?? endpoint?.cwd ?? metadataString3(agent?.metadata, "projectRoot") ?? metadataString3(actor?.metadata, "projectRoot");
+  const selector = agent?.selector?.trim() || metadataString4(agent?.metadata, "selector") || metadataString4(actor?.metadata, "selector");
+  const defaultSelector = agent?.defaultSelector?.trim() || metadataString4(agent?.metadata, "defaultSelector") || metadataString4(actor?.metadata, "defaultSelector");
+  const projectRoot = endpoint?.projectRoot ?? endpoint?.cwd ?? metadataString4(agent?.metadata, "projectRoot") ?? metadataString4(actor?.metadata, "projectRoot");
   return buildScoutReturnAddress({
     actorId,
     handle: agent?.handle?.trim() || actor?.handle?.trim() || actorId,
@@ -22644,10 +23324,7 @@ function buildScoutReturnAddress2(snapshot, actorId, options = {}) {
     sessionId: endpoint?.sessionId
   });
 }
-function sanitizeConversationSegment(value) {
-  return value.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-") || "shared";
-}
-function metadataString3(metadata, key) {
+function metadataString4(metadata, key) {
   const value = metadata?.[key];
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
 }
@@ -22692,6 +23369,24 @@ function renderScoutTargetLabel(targetLabel) {
   }
   return trimmed.startsWith("@") ? trimmed : `@${trimmed}`;
 }
+function renderedScoutAskTarget(target) {
+  switch (target.kind) {
+    case "agent_id":
+      return target.agentId.trim();
+    case "agent_label":
+      return target.label.trim();
+    case "session_id":
+      return `session:${target.sessionId.trim()}`;
+    case "binding_ref":
+      return `ref:${target.ref.trim()}`;
+    case "project_path":
+      return target.projectPath.trim();
+    case "channel":
+      return `channel:${target.channel.trim()}`;
+    case "broadcast":
+      return "broadcast";
+  }
+}
 function scoutTargetDiagnosticFromDeliveryFailure(delivery) {
   const dispatch = delivery.kind === "question" ? delivery.question : delivery.rejection;
   if (dispatch.kind === "ambiguous") {
@@ -22827,18 +23522,18 @@ async function requireScoutBrokerContext(baseUrl = resolveScoutBrokerUrl()) {
 function buildMentionCandidate(snapshot, agent) {
   const endpoints = Object.values(snapshot.endpoints ?? {}).filter((endpoint) => endpoint.agentId === agent.id);
   const preferred = endpoints.find((endpoint) => endpoint.state === "active") ?? endpoints.find((endpoint) => endpoint.state === "idle" || endpoint.state === "waiting") ?? endpoints[0];
-  const harness = preferred?.harness ?? metadataString3(agent.metadata, "harness") ?? metadataString3(agent.metadata, "defaultHarness");
-  const profile = metadataString3(agent.metadata, "profile");
+  const harness = preferred?.harness ?? metadataString4(agent.metadata, "harness") ?? metadataString4(agent.metadata, "defaultHarness");
+  const profile = metadataString4(agent.metadata, "profile");
   return {
     agentId: agent.id,
-    definitionId: metadataString3(agent.metadata, "definitionId") || agent.id,
-    nodeQualifier: metadataString3(agent.metadata, "nodeQualifier"),
-    workspaceQualifier: metadataString3(agent.metadata, "workspaceQualifier"),
+    definitionId: metadataString4(agent.metadata, "definitionId") || agent.id,
+    nodeQualifier: metadataString4(agent.metadata, "nodeQualifier"),
+    workspaceQualifier: metadataString4(agent.metadata, "workspaceQualifier"),
     ...harness ? { harness } : {},
     ...profile ? { profile } : {},
     aliases: [
-      metadataString3(agent.metadata, "selector"),
-      metadataString3(agent.metadata, "defaultSelector")
+      metadataString4(agent.metadata, "selector"),
+      metadataString4(agent.metadata, "defaultSelector")
     ].filter(Boolean)
   };
 }
@@ -23054,50 +23749,74 @@ function conversationDefinition(snapshot, nodeId, channel, senderId, targetParti
   const sharedParticipants = [...new Set([OPERATOR_ID, senderId, ...Object.keys(snapshot.agents)])].sort();
   const scopedParticipants = [...new Set([OPERATOR_ID, senderId, ...targetParticipantIds])].sort();
   if (normalizedChannel === "voice") {
+    const naturalKey2 = namedChannelNaturalKey("voice");
+    const existing2 = findConversationByIdentity(snapshot, naturalKey2);
     return {
-      id: BROKER_VOICE_CHANNEL_ID,
+      id: existing2?.id ?? mintChannelId(randomUUID3),
       kind: "channel",
       title: "voice",
       visibility: "workspace",
       shareMode: resolveConversationShareMode(snapshot, nodeId, scopedParticipants, "local"),
       authorityNodeId: nodeId,
       participantIds: scopedParticipants,
-      metadata: { surface: "scout-cli", channel: "voice" }
+      metadata: {
+        surface: "scout-cli",
+        channel: "voice",
+        naturalKey: naturalKey2
+      }
     };
   }
   if (normalizedChannel === "system") {
+    const naturalKey2 = systemChannelNaturalKey("system");
+    const existing2 = findConversationByIdentity(snapshot, naturalKey2);
     return {
-      id: BROKER_SYSTEM_CHANNEL_ID,
+      id: existing2?.id ?? mintChannelId(randomUUID3),
       kind: "system",
       title: "system",
       visibility: "system",
       shareMode: "local",
       authorityNodeId: nodeId,
       participantIds: [OPERATOR_ID, senderId].sort(),
-      metadata: { surface: "scout-cli", channel: "system" }
+      metadata: {
+        surface: "scout-cli",
+        channel: "system",
+        naturalKey: naturalKey2
+      }
     };
   }
   if (normalizedChannel === "shared") {
+    const naturalKey2 = namedChannelNaturalKey("shared");
+    const existing2 = findConversationByIdentity(snapshot, naturalKey2);
     return {
-      id: BROKER_SHARED_CHANNEL_ID,
+      id: existing2?.id ?? mintChannelId(randomUUID3),
       kind: "channel",
       title: "shared-channel",
       visibility: "workspace",
       shareMode: "shared",
       authorityNodeId: nodeId,
       participantIds: sharedParticipants,
-      metadata: { surface: "scout-cli", channel: "shared" }
+      metadata: {
+        surface: "scout-cli",
+        channel: "shared",
+        naturalKey: naturalKey2
+      }
     };
   }
+  const naturalKey = namedChannelNaturalKey(normalizedChannel);
+  const existing = findConversationByIdentity(snapshot, naturalKey);
   return {
-    id: `channel.${sanitizeConversationSegment(normalizedChannel)}`,
+    id: existing?.id ?? mintChannelId(randomUUID3),
     kind: "channel",
     title: normalizedChannel,
     visibility: "workspace",
     shareMode: resolveConversationShareMode(snapshot, nodeId, scopedParticipants, "local"),
     authorityNodeId: nodeId,
     participantIds: scopedParticipants,
-    metadata: { surface: "scout-cli", channel: normalizedChannel }
+    metadata: {
+      surface: "scout-cli",
+      channel: normalizedChannel,
+      naturalKey
+    }
   };
 }
 async function ensureBrokerConversation(baseUrl, snapshot, nodeId, channel, senderId, targetParticipantIds = []) {
@@ -23115,21 +23834,15 @@ async function ensureBrokerConversation(baseUrl, snapshot, nodeId, channel, send
   }
   return existing;
 }
-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;
@@ -23151,6 +23864,7 @@ async function ensureBrokerDirectConversationBetween(baseUrl, snapshot, nodeId,
     participantIds,
     metadata: {
       surface: "scout",
+      naturalKey,
       ...targetId === SCOUT_AGENT_ID && sourceId === OPERATOR_ID ? { role: "partner" } : {}
     }
   };
@@ -23411,23 +24125,30 @@ async function sendScoutDirectMessage(input) {
   };
 }
 async function askScoutQuestion(input) {
+  const renderedTarget = input.targetLabel?.trim() || (input.target ? renderedScoutAskTarget(input.target) : "") || input.targetAgentId?.trim() || "";
   const broker = await loadScoutBrokerContext();
   if (!broker) {
-    return { usedBroker: false, unresolvedTarget: input.targetLabel };
+    return { usedBroker: false, unresolvedTarget: renderedTarget };
   }
   const currentDirectory = input.currentDirectory ?? process.cwd();
   const senderId = await resolveConversationActorId(broker.baseUrl, broker.snapshot, broker.node.id, input.senderId, currentDirectory);
-  const normalizedTargetLabel = renderScoutTargetLabel(input.targetLabel);
-  const explicitTargetAgentId = input.targetAgentId?.trim() || broker.snapshot.agents[input.targetLabel.trim()]?.id;
+  if (!renderedTarget) {
+    return { usedBroker: true, unresolvedTarget: renderedTarget };
+  }
+  const normalizedTargetLabel = input.target?.kind === "project_path" ? "" : renderScoutTargetLabel(renderedTarget);
+  const explicitTargetAgentId = input.targetAgentId?.trim() || (input.target ? undefined : broker.snapshot.agents[renderedTarget]?.id);
   if (explicitTargetAgentId) {
     await ensureTargetRelayAgentRegistered(broker.baseUrl, broker.snapshot, broker.node.id, explicitTargetAgentId, currentDirectory);
   }
-  const messageBody = input.body.trim().startsWith(normalizedTargetLabel) ? input.body.trim() : `${normalizedTargetLabel} ${input.body.trim()}`;
+  const messageBody = normalizedTargetLabel && input.body.trim().startsWith(normalizedTargetLabel) ? input.body.trim() : normalizedTargetLabel ? `${normalizedTargetLabel} ${input.body.trim()}` : input.body.trim();
+  const createdAt = input.createdAtMs ?? Date.now();
+  const source = input.source?.trim() || "scout-cli";
   const delivery = await brokerPostDeliver(broker.baseUrl, {
-    id: `deliver-${(input.createdAtMs ?? Date.now()).toString(36)}-${Math.random().toString(36).slice(2, 8)}`,
+    id: `deliver-${createdAt.toString(36)}-${Math.random().toString(36).slice(2, 8)}`,
     requesterId: senderId,
     requesterNodeId: broker.node.id,
-    targetLabel: input.targetLabel,
+    ...input.target ? { target: input.target } : {},
+    targetLabel: renderedTarget,
     targetAgentId: explicitTargetAgentId,
     body: messageBody,
     intent: "consult",
@@ -23435,21 +24156,23 @@ async function askScoutQuestion(input) {
     speechText: input.shouldSpeak ? stripScoutAgentSelectorLabels(messageBody) : undefined,
     execution: {
       ...input.executionHarness ? { harness: input.executionHarness } : {},
-      session: "new"
+      ...input.executionModel?.trim() ? { model: input.executionModel.trim() } : {},
+      session: input.executionSession ?? "new"
     },
+    ...input.projectAgent ? { projectAgent: input.projectAgent } : {},
     ensureAwake: true,
-    createdAt: input.createdAtMs ?? Date.now(),
+    createdAt,
     messageMetadata: {
-      source: "scout-cli"
+      source
     },
     invocationMetadata: {
-      source: "scout-cli"
+      source
     }
   });
   if (delivery.kind !== "delivery") {
     return {
       usedBroker: true,
-      unresolvedTarget: input.targetLabel,
+      unresolvedTarget: renderedTarget,
       targetDiagnostic: scoutTargetDiagnosticFromDeliveryFailure(delivery)
     };
   }
@@ -23470,6 +24193,7 @@ async function loadScoutRelayConfig() {
 }
 
 // packages/web/server/core/conversations/service.ts
+init_src();
 var DEFAULT_CONVERSATION_KINDS = [
   "direct",
   "channel",
@@ -23511,10 +24235,38 @@ function endpointActivity(endpoint) {
 function endpointStartedAt(endpoint) {
   return Math.max(normalizeMetadataTimestamp(endpoint.metadata?.lastStartedAt), normalizeMetadataTimestamp(endpoint.metadata?.startedAt));
 }
-function metadataString4(metadata, key) {
+function metadataString5(metadata, key) {
   const value = metadata?.[key];
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
 }
+function formatChannelAlias2(value) {
+  const trimmed = value.trim();
+  if (!trimmed)
+    return "";
+  return trimmed.startsWith("#") ? trimmed : `#${trimmed}`;
+}
+function conversationAlias(input) {
+  const explicitAlias = metadataString5(input.metadata, "alias");
+  if (explicitAlias)
+    return explicitAlias;
+  const channel = metadataString5(input.metadata, "channel");
+  if (channel && channel !== "system") {
+    return formatChannelAlias2(channel);
+  }
+  if (input.kind === "channel") {
+    if (input.id.startsWith("channel.")) {
+      return formatChannelAlias2(input.id.slice("channel.".length));
+    }
+    return formatChannelAlias2(input.title);
+  }
+  return null;
+}
+function conversationIdentityFields2(input) {
+  return {
+    alias: conversationAlias(input),
+    naturalKey: channelNaturalKeyFromMetadata(input.metadata)
+  };
+}
 function metadataBoolean2(metadata, key) {
   return metadata?.[key] === true;
 }
@@ -23599,17 +24351,19 @@ async function getScoutConversations(filters = {}) {
         return [];
       }
       const title = agentDisplayName(snapshot, agentId);
+      const identityFields2 = conversationIdentityFields2(conversation);
       return [{
         id: conversation.id,
         kind: conversation.kind,
         title,
+        ...identityFields2,
         participantIds: [...conversation.participantIds],
         authorityNodeId: conversation.authorityNodeId ?? null,
         authorityNodeName: snapshot.nodes?.[conversation.authorityNodeId]?.name ?? null,
         agentId,
         agentName: title,
         harness: endpoint?.harness ?? null,
-        currentBranch: metadataString4(endpoint?.metadata, "branch") ?? metadataString4(endpoint?.metadata, "workspaceQualifier") ?? metadataString4(agent.metadata, "branch") ?? metadataString4(agent.metadata, "workspaceQualifier"),
+        currentBranch: metadataString5(endpoint?.metadata, "branch") ?? metadataString5(endpoint?.metadata, "workspaceQualifier") ?? metadataString5(agent.metadata, "branch") ?? metadataString5(agent.metadata, "workspaceQualifier"),
         preview: latestMessage?.body ?? null,
         messageCount,
         lastMessageAt: normalizeTimestampMs2(latestMessage?.createdAt),
@@ -23628,10 +24382,12 @@ async function getScoutConversations(filters = {}) {
     } else if (conversation.kind === "system") {
       return [];
     }
+    const identityFields = conversationIdentityFields2(conversation);
     return [{
       id: conversation.id,
       kind: conversation.kind,
       title: conversation.title,
+      ...identityFields,
       participantIds: [...conversation.participantIds],
       authorityNodeId: conversation.authorityNodeId ?? null,
       authorityNodeName: snapshot.nodes?.[conversation.authorityNodeId]?.name ?? null,
@@ -25109,7 +25865,7 @@ function metadataRecord3(metadata, key) {
   }
   return value;
 }
-function metadataString5(metadata, key) {
+function metadataString6(metadata, key) {
   const value = metadata?.[key];
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
 }
@@ -25133,50 +25889,50 @@ function buildObserveMetadata(snapshot, sessionStart) {
   }
   if (snapshot.turns.length > 0)
     sessionMeta.turnCount = snapshot.turns.length;
-  if (metadataString5(providerMeta, "externalSessionId")) {
-    sessionMeta.externalSessionId = metadataString5(providerMeta, "externalSessionId");
+  if (metadataString6(providerMeta, "externalSessionId")) {
+    sessionMeta.externalSessionId = metadataString6(providerMeta, "externalSessionId");
   }
-  if (metadataString5(providerMeta, "threadId")) {
-    sessionMeta.threadId = metadataString5(providerMeta, "threadId");
+  if (metadataString6(providerMeta, "threadId")) {
+    sessionMeta.threadId = metadataString6(providerMeta, "threadId");
   }
-  if (metadataString5(providerMeta, "threadPath")) {
-    sessionMeta.threadPath = metadataString5(providerMeta, "threadPath");
+  if (metadataString6(providerMeta, "threadPath")) {
+    sessionMeta.threadPath = metadataString6(providerMeta, "threadPath");
   }
-  if (metadataString5(observeRuntime, "gitBranch")) {
-    sessionMeta.gitBranch = metadataString5(observeRuntime, "gitBranch");
+  if (metadataString6(observeRuntime, "gitBranch")) {
+    sessionMeta.gitBranch = metadataString6(observeRuntime, "gitBranch");
   }
-  if (metadataString5(observeRuntime, "cliVersion")) {
-    sessionMeta.cliVersion = metadataString5(observeRuntime, "cliVersion");
+  if (metadataString6(observeRuntime, "cliVersion")) {
+    sessionMeta.cliVersion = metadataString6(observeRuntime, "cliVersion");
   }
-  if (metadataString5(observeRuntime, "entrypoint")) {
-    sessionMeta.entrypoint = metadataString5(observeRuntime, "entrypoint");
+  if (metadataString6(observeRuntime, "entrypoint")) {
+    sessionMeta.entrypoint = metadataString6(observeRuntime, "entrypoint");
   }
-  if (metadataString5(observeRuntime, "originator")) {
-    sessionMeta.originator = metadataString5(observeRuntime, "originator");
+  if (metadataString6(observeRuntime, "originator")) {
+    sessionMeta.originator = metadataString6(observeRuntime, "originator");
   }
-  if (metadataString5(observeRuntime, "source")) {
-    sessionMeta.source = metadataString5(observeRuntime, "source");
+  if (metadataString6(observeRuntime, "source")) {
+    sessionMeta.source = metadataString6(observeRuntime, "source");
   }
-  if (metadataString5(observeRuntime, "permissionMode")) {
-    sessionMeta.permissionMode = metadataString5(observeRuntime, "permissionMode");
+  if (metadataString6(observeRuntime, "permissionMode")) {
+    sessionMeta.permissionMode = metadataString6(observeRuntime, "permissionMode");
   }
-  if (metadataString5(observeRuntime, "approvalPolicy")) {
-    sessionMeta.approvalPolicy = metadataString5(observeRuntime, "approvalPolicy");
+  if (metadataString6(observeRuntime, "approvalPolicy")) {
+    sessionMeta.approvalPolicy = metadataString6(observeRuntime, "approvalPolicy");
   }
-  if (metadataString5(observeRuntime, "sandbox")) {
-    sessionMeta.sandbox = metadataString5(observeRuntime, "sandbox");
+  if (metadataString6(observeRuntime, "sandbox")) {
+    sessionMeta.sandbox = metadataString6(observeRuntime, "sandbox");
   }
-  if (metadataString5(observeRuntime, "userType")) {
-    sessionMeta.userType = metadataString5(observeRuntime, "userType");
+  if (metadataString6(observeRuntime, "userType")) {
+    sessionMeta.userType = metadataString6(observeRuntime, "userType");
   }
-  if (metadataString5(observeRuntime, "effort")) {
-    sessionMeta.effort = metadataString5(observeRuntime, "effort");
+  if (metadataString6(observeRuntime, "effort")) {
+    sessionMeta.effort = metadataString6(observeRuntime, "effort");
   }
-  if (metadataString5(observeRuntime, "modelProvider")) {
-    sessionMeta.modelProvider = metadataString5(observeRuntime, "modelProvider");
+  if (metadataString6(observeRuntime, "modelProvider")) {
+    sessionMeta.modelProvider = metadataString6(observeRuntime, "modelProvider");
   }
-  if (metadataString5(observeRuntime, "timezone")) {
-    sessionMeta.timezone = metadataString5(observeRuntime, "timezone");
+  if (metadataString6(observeRuntime, "timezone")) {
+    sessionMeta.timezone = metadataString6(observeRuntime, "timezone");
   }
   const usageMeta = {};
   if (metadataNumber(observeUsage, "assistantMessages") !== undefined) {
@@ -25209,14 +25965,14 @@ function buildObserveMetadata(snapshot, sessionStart) {
   if (metadataNumber(observeUsage, "webFetchRequests") !== undefined) {
     usageMeta.webFetchRequests = metadataNumber(observeUsage, "webFetchRequests");
   }
-  if (metadataString5(observeUsage, "serviceTier")) {
-    usageMeta.serviceTier = metadataString5(observeUsage, "serviceTier");
+  if (metadataString6(observeUsage, "serviceTier")) {
+    usageMeta.serviceTier = metadataString6(observeUsage, "serviceTier");
   }
-  if (metadataString5(observeUsage, "speed")) {
-    usageMeta.speed = metadataString5(observeUsage, "speed");
+  if (metadataString6(observeUsage, "speed")) {
+    usageMeta.speed = metadataString6(observeUsage, "speed");
   }
-  if (metadataString5(observeUsage, "planType")) {
-    usageMeta.planType = metadataString5(observeUsage, "planType");
+  if (metadataString6(observeUsage, "planType")) {
+    usageMeta.planType = metadataString6(observeUsage, "planType");
   }
   const observedTopology = metadataRecord3(providerMeta, OBSERVED_HARNESS_TOPOLOGY_META_KEY);
   const hasSessionMeta = Object.keys(sessionMeta).length > 0;
@@ -25293,6 +26049,9 @@ function readHistorySnapshot(candidate) {
     adapterType: candidate.adapterType,
     baseTimestampMs: stat6.mtimeMs
   });
+  if (replay.events.length === 0) {
+    return null;
+  }
   const nextEntry = {
     historyPath: candidate.path,
     snapshot: replay.snapshot,
@@ -30642,6 +31401,9 @@ init_src();
 // packages/runtime/src/drizzle-migrate.ts
 init_support_paths();
 if (false) {}
+
+// packages/runtime/src/conversations/api.ts
+init_src();
 // packages/runtime/src/tailscale.ts
 import { readFile as readFile8 } from "fs/promises";
 import { execFile as execFile2 } from "child_process";
@@ -31316,8 +32078,8 @@ function candidateFromValue(key, value, root, now) {
       title: firstMetadataString(root, "title", "attentionTitle"),
       summary: firstMetadataString(root, "summary", "attentionSummary", "blockedReason", "needsInputReason", "reason", "message"),
       detail: firstMetadataString(root, "detail", "statusDetail"),
-      turnId: metadataString6(root, "turnId"),
-      blockId: metadataString6(root, "blockId"),
+      turnId: metadataString7(root, "turnId"),
+      blockId: metadataString7(root, "blockId"),
       version: metadataNumber2(root, "version"),
       updatedAt: metadataTimestamp(root, now),
       severity: nativeSeverity(root)
@@ -31336,8 +32098,8 @@ function candidateFromValue(key, value, root, now) {
       title: firstMetadataString(root, "title", "attentionTitle"),
       summary: firstMetadataString(root, "summary", "attentionSummary", "blockedReason", "needsInputReason", "reason", "message"),
       detail: firstMetadataString(root, "detail", "statusDetail"),
-      turnId: metadataString6(root, "turnId"),
-      blockId: metadataString6(root, "blockId"),
+      turnId: metadataString7(root, "turnId"),
+      blockId: metadataString7(root, "blockId"),
       version: metadataNumber2(root, "version"),
       updatedAt: metadataTimestamp(root, now),
       severity: nativeSeverity(root)
@@ -31366,8 +32128,8 @@ function candidateFromRecord(key, record, now, keyImpliesAttention) {
     title: firstMetadataString(record, "title", "label"),
     summary: firstMetadataString(record, "summary", "message", "reason", "description"),
     detail: firstMetadataString(record, "detail", "statusDetail", "hint"),
-    turnId: metadataString6(record, "turnId"),
-    blockId: metadataString6(record, "blockId"),
+    turnId: metadataString7(record, "turnId"),
+    blockId: metadataString7(record, "blockId"),
     version: metadataNumber2(record, "version"),
     updatedAt: metadataTimestamp(record, now),
     severity: nativeSeverity(record)
@@ -31387,7 +32149,7 @@ function stableNativeIdPart(value) {
   return stable || "blocked";
 }
 function nativeSeverity(record) {
-  const severity = metadataString6(record, "severity")?.toLowerCase();
+  const severity = metadataString7(record, "severity")?.toLowerCase();
   if (severity === "critical" || severity === "warning" || severity === "info") {
     return severity;
   }
@@ -31396,7 +32158,7 @@ function nativeSeverity(record) {
 function metadataRecord4(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
-function metadataString6(record, key) {
+function metadataString7(record, key) {
   const value = record?.[key];
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
 }
@@ -31417,7 +32179,7 @@ function metadataTimestamp(record, fallback) {
 }
 function firstMetadataString(record, ...keys) {
   for (const key of keys) {
-    const value = metadataString6(record, key);
+    const value = metadataString7(record, key);
     if (value) {
       return value;
     }
@@ -31695,7 +32457,7 @@ function endpointTmuxTarget(endpoint) {
   if (endpoint.transport !== "tmux") {
     return null;
   }
-  const sessionName = endpoint.sessionId ?? metadataString7(endpoint, "tmuxSession");
+  const sessionName = endpoint.sessionId ?? metadataString8(endpoint, "tmuxSession");
   if (!sessionName) {
     return null;
   }
@@ -31813,7 +32575,7 @@ function buildStandaloneTmuxNode(tmuxSession) {
   };
 }
 function endpointTitle(endpoint, sessionName) {
-  const agentName = metadataString7(endpoint, "agentName") ?? metadataString7(endpoint, "definitionId") ?? endpoint.agentId;
+  const agentName = metadataString8(endpoint, "agentName") ?? metadataString8(endpoint, "definitionId") ?? endpoint.agentId;
   return `${agentName} (${sessionName})`;
 }
 function layoutForIndex(index2) {
@@ -31861,7 +32623,7 @@ function fnv1a(value) {
   }
   return (hash >>> 0).toString(36);
 }
-function metadataString7(endpoint, key) {
+function metadataString8(endpoint, key) {
   const value = endpoint.metadata?.[key];
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
 }
@@ -32521,7 +33283,7 @@ async function loadOpenScoutWebShellState() {
 }
 
 // packages/web/server/scoutbot-assistant.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 var DEFAULT_MODEL = "gpt-4.1-mini";
 var DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
 var PRESENTER_MODEL = "gpt-4o-mini";
@@ -32706,13 +33468,13 @@ function createScoutbotAssistantService(input) {
       }
       const now = Date.now();
       const userMessage = {
-        id: `msg_${randomUUID3()}`,
+        id: `msg_${randomUUID4()}`,
         role: "user",
         body: trimmed,
         createdAt: now
       };
       const assistantMessage = {
-        id: `msg_${randomUUID3()}`,
+        id: `msg_${randomUUID4()}`,
         role: "assistant",
         body: replyBody,
         createdAt: Date.now()
@@ -33175,7 +33937,7 @@ function parseBriefResponse(raw2, timing, mode = "tour") {
   const steps = normalizeBriefSteps(record.steps, timing.preparedAt, expiresAt);
   const fallbackSummary = raw2.replace(/\s+/g, " ").trim();
   return {
-    id: `brf_${randomUUID3()}`,
+    id: `brf_${randomUUID4()}`,
     title: stringField(record.title, "One-minute brief"),
     summary: stringField(record.summary, fallbackSummary || "Scoutbot prepared a current control-plane brief."),
     preparedAt: timing.preparedAt,
@@ -33232,7 +33994,7 @@ function briefFromMarkdown(markdown, timing, mode) {
     observations
   };
   return {
-    id: `brf_${randomUUID3()}`,
+    id: `brf_${randomUUID4()}`,
     title,
     summary: headline || fallbackSummary || "Scoutbot prepared a current control-plane brief.",
     preparedAt: timing.preparedAt,
@@ -33542,7 +34304,7 @@ function clampNumber(value, min, max) {
 function createSession(model) {
   const now = Date.now();
   return {
-    id: `rgr_${randomUUID3()}`,
+    id: `rgr_${randomUUID4()}`,
     title: "New Scout Session",
     createdAt: now,
     updatedAt: now,
@@ -33738,7 +34500,7 @@ function pruneBriefings(maxRows) {
 
 // packages/web/server/scoutbot-reminders.ts
 init_support_paths();
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 import { existsSync as existsSync18, mkdirSync as mkdirSync6, readFileSync as readFileSync11, renameSync as renameSync2, writeFileSync as writeFileSync6 } from "fs";
 import { dirname as dirname14, join as join27 } from "path";
 
@@ -33802,7 +34564,7 @@ function createScoutbotReminderStore(input = {}) {
       const title = firstNonEmptyString2(stringValue3(input2.title), titleFromBody(body)) ?? "Reminder";
       const context = recordValue(input2.context);
       const stored = {
-        id: `rem_${randomUUID4()}`,
+        id: `rem_${randomUUID5()}`,
         title,
         body,
         status: "scheduled",
@@ -34309,9 +35071,9 @@ function renderHelp() {
     "- `/recent @agent` \u2014 latest messages from an agent",
     "- `/doing @agent` \u2014 active work for an agent",
     "- `/flight <id>` \u2014 flight status by id",
-    "- `/steer sid:<session>` \u2014 target this ScoutBot thread at a session",
+    "- `/steer session:<session>` \u2014 target this ScoutBot thread at a session",
     "",
-    "Directives can appear anywhere: `eff:low`, `eff:high`, `sid:<session>`."
+    "Directives can appear anywhere: `eff:low`, `eff:high`, `session:<session>`."
   ].join(`
 `);
 }
@@ -34352,7 +35114,7 @@ function renderStatus(snapshot, rawArg = "") {
 function renderSteer(parsed, rawArg) {
   const targetSessionId = parsed.directives.targetSessionId ?? firstSessionishToken(rawArg);
   if (!targetSessionId) {
-    return "Usage: `/steer sid:<session>`.";
+    return "Usage: `/steer session:<session>`.";
   }
   return `Steering this ScoutBot thread to session ${targetSessionId}.`;
 }
@@ -34450,7 +35212,7 @@ function firstAgentishToken(value) {
 }
 function firstSessionishToken(value) {
   const token = value.trim().split(/\s+/).find(Boolean);
-  const normalized = token?.replace(/^sid:/i, "").replace(/[.,!?;]+$/g, "").trim();
+  const normalized = token?.replace(/^(?:sid|session):/i, "").replace(/[.,!?;]+$/g, "").trim();
   return normalized || null;
 }
 function compact2(value, max = 220) {
@@ -34866,7 +35628,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);
@@ -34966,12 +35728,12 @@ function isInvalidScoutbotSessionEndpoint(endpoint) {
   return lastError.includes("no rollout found for thread id") || lastError.includes("codex_app_server session unavailable") || lastError.includes("session unavailable");
 }
 function hasCurrentScoutbotRuntimeConfig(endpoint) {
-  return metadataString8(endpoint.metadata, "systemPrompt") === SCOUTBOT_ROLE_CONFIG.systemPrompt && metadataString8(endpoint.metadata, "reasoningEffort") === SCOUTBOT_ROLE_CONFIG.defaults.reasoningEffort;
+  return metadataString9(endpoint.metadata, "systemPrompt") === SCOUTBOT_ROLE_CONFIG.systemPrompt && metadataString9(endpoint.metadata, "reasoningEffort") === SCOUTBOT_ROLE_CONFIG.defaults.reasoningEffort;
 }
 function scoutbotEndpointTransportSessionId(endpoint) {
   if (isInvalidScoutbotSessionEndpoint(endpoint))
     return null;
-  return metadataString8(endpoint.metadata, "threadId") ?? metadataString8(endpoint.metadata, "externalSessionId") ?? endpoint.sessionId?.trim() ?? null;
+  return metadataString9(endpoint.metadata, "threadId") ?? metadataString9(endpoint.metadata, "externalSessionId") ?? endpoint.sessionId?.trim() ?? null;
 }
 async function ensureScoutbotEndpointSession(baseUrl, endpoint, log) {
   try {
@@ -35122,7 +35884,7 @@ async function handleBlock(block, options) {
   }
   options.log.info(`handling thread=${thread.threadId} source=${shortId(message.id)} promptChars=${prompt.length}`);
   if (prefilter) {
-    const steerTargetSessionId = prefilter.metadata.matched_rule === "slash.steer" ? metadataString8(prefilter.metadata, "targetSessionId") : undefined;
+    const steerTargetSessionId = prefilter.metadata.matched_rule === "slash.steer" ? metadataString9(prefilter.metadata, "targetSessionId") : undefined;
     if (steerTargetSessionId) {
       await options.threadMap.setThreadTransportSessionId(thread.threadId, steerTargetSessionId);
       options.log.info(`thread=${thread.threadId} steered transportSession=${shortId(steerTargetSessionId)}`);
@@ -35183,7 +35945,7 @@ async function postScoutbotInvocation(input) {
   const prompt = stripMentions(input.message.body);
   const parsed = parseScoutbotDirectives(prompt);
   const requestedReasoningEffort = parsed.directives.reasoningEffort ?? metadataReasoningEffort(input.message.metadata);
-  const transportSessionId = parsed.directives.targetSessionId ?? metadataString8(input.message.metadata, "targetSessionId") ?? input.thread.transportSessionId?.trim() ?? null;
+  const transportSessionId = parsed.directives.targetSessionId ?? metadataString9(input.message.metadata, "targetSessionId") ?? input.thread.transportSessionId?.trim() ?? null;
   const task = parsed.body || parsed.messageBody || prompt;
   const context = scoutbotInvocationDirectiveContext({
     parsed,
@@ -35201,7 +35963,7 @@ async function postScoutbotInvocation(input) {
     messageId: input.message.id,
     ...Object.keys(context).length > 0 ? { context } : {},
     execution: {
-      session: "existing",
+      session: transportSessionId ? "existing" : "new",
       ...transportSessionId ? { targetSessionId: transportSessionId } : {}
     },
     ensureAwake: true,
@@ -35277,16 +36039,16 @@ function extractMessage(event) {
   return typeof record.id === "string" && typeof record.conversationId === "string" ? record : null;
 }
 function scoutbotReplyTransportSessionId(message) {
-  return metadataString8(message.metadata, "targetSessionId") ?? metadataString8(message.metadata, "responderSessionId") ?? metadataString8(metadataObject2(message.metadata, "returnAddress"), "sessionId") ?? null;
+  return metadataString9(message.metadata, "targetSessionId") ?? metadataString9(message.metadata, "responderSessionId") ?? metadataString9(metadataObject2(message.metadata, "returnAddress"), "sessionId") ?? null;
 }
 function isScoutbotAddressedMessage(message) {
   if (message.mentions?.some((mention) => mention.actorId === SCOUTBOT_AGENT_ID))
     return true;
   if (message.audience?.notify?.includes(SCOUTBOT_AGENT_ID))
     return true;
-  if (metadataString8(message.metadata, "destinationId") === SCOUTBOT_AGENT_ID)
+  if (metadataString9(message.metadata, "destinationId") === SCOUTBOT_AGENT_ID)
     return true;
-  if (metadataString8(message.metadata, "relayTarget") === SCOUTBOT_AGENT_ID)
+  if (metadataString9(message.metadata, "relayTarget") === SCOUTBOT_AGENT_ID)
     return true;
   if (metadataStringArrayIncludes(message.metadata, "relayTargetIds", SCOUTBOT_AGENT_ID))
     return true;
@@ -35310,18 +36072,18 @@ function findScoutbotFlightForMessage(snapshot, messageId, options = {}) {
     if (invocation?.messageId === messageId)
       return true;
     const returnAddress = metadataObject2(flight.metadata, "returnAddress");
-    return metadataString8(returnAddress, "replyToMessageId") === messageId;
+    return metadataString9(returnAddress, "replyToMessageId") === messageId;
   });
   return candidates.sort((left, right) => (right.startedAt ?? 0) - (left.startedAt ?? 0))[0] ?? null;
 }
 function isScoutbotDirectDeliveryFlight(flight) {
   if (flight.targetAgentId !== SCOUTBOT_AGENT_ID)
     return false;
-  if (metadataString8(flight.metadata, "source") === "scoutbot")
+  if (metadataString9(flight.metadata, "source") === "scoutbot")
     return false;
-  if (metadataString8(flight.metadata, "destinationId") === SCOUTBOT_AGENT_ID)
+  if (metadataString9(flight.metadata, "destinationId") === SCOUTBOT_AGENT_ID)
     return true;
-  if (metadataString8(flight.metadata, "relayTarget") === SCOUTBOT_AGENT_ID)
+  if (metadataString9(flight.metadata, "relayTarget") === SCOUTBOT_AGENT_ID)
     return true;
   return false;
 }
@@ -35349,15 +36111,18 @@ 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 = metadataObject2(agent.metadata, "roleConfig");
-  return metadataString8(roleConfig, "systemPrompt") === SCOUTBOT_ROLE_CONFIG.systemPrompt;
+  return metadataString9(roleConfig, "systemPrompt") === SCOUTBOT_ROLE_CONFIG.systemPrompt;
 }
 function metadataObject2(metadata, key) {
   const value = metadata?.[key];
   return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
 }
-function metadataString8(metadata, key) {
+function metadataString9(metadata, key) {
   const value = metadata?.[key];
   return typeof value === "string" && value.trim() ? value.trim() : undefined;
 }
@@ -35370,7 +36135,7 @@ var SCOUTBOT_REASONING_EFFORTS = new Set([
   "xhigh"
 ]);
 function metadataReasoningEffort(metadata) {
-  const value = metadataString8(metadata, "reasoningEffort");
+  const value = metadataString9(metadata, "reasoningEffort");
   return SCOUTBOT_REASONING_EFFORTS.has(value) ? value : undefined;
 }
 function metadataStringArrayIncludes(metadata, key, value) {
@@ -37162,7 +37927,7 @@ function listDirectoryEntries(input) {
 import { existsSync as existsSync23, mkdirSync as mkdirSync9, readFileSync as readFileSync15, writeFileSync as writeFileSync9 } from "fs";
 import { homedir as homedir25 } from "os";
 import { dirname as dirname19, join as join32 } from "path";
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 var VOX_CLIENT_ID = "openscout-web";
 var DEFAULT_VOX_RPC_PORT = 42137;
 var DEFAULT_VOX_RPC_HOST = "127.0.0.1";
@@ -37279,7 +38044,7 @@ async function callVoxRpc(method, params, options = {}) {
   const timeoutMs = options.timeoutMs ?? VOX_RPC_TIMEOUT_MS;
   const port = resolveVoxRpcPort();
   const socket = new WebSocket(`ws://${DEFAULT_VOX_RPC_HOST}:${port}`);
-  const id = randomUUID5();
+  const id = randomUUID6();
   return await new Promise((resolve13, reject) => {
     let timeout;
     const cleanup = () => {
@@ -37422,7 +38187,7 @@ function defaultVoiceForModel(providers, modelId) {
 
 // packages/web/server/vantage-handoff.ts
 import { execFile as execFile5, execFileSync as execFileSync6, spawn as spawn6 } from "child_process";
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 import { appendFileSync, existsSync as existsSync24, mkdirSync as mkdirSync10, writeFileSync as writeFileSync10 } from "fs";
 import { dirname as dirname20, join as join33, resolve as resolve13 } from "path";
 import { promisify as promisify5 } from "util";
@@ -37451,7 +38216,7 @@ async function createOpenScoutVantageHandoff(input) {
     selectedNativeSessionIds,
     now: input.now
   });
-  const handoffId = `handoff-${Date.now()}-${randomUUID6().slice(0, 8)}`;
+  const handoffId = `handoff-${Date.now()}-${randomUUID7().slice(0, 8)}`;
   const { handoffPath, setupPath } = writeVantageHandoffFiles({
     handoffId,
     plan,
@@ -38065,8 +38830,9 @@ function inferDirectTargetAgentId(conversationId, session, senderId) {
     const operatorCandidates = new Set([
       senderId.trim(),
       "operator",
+      process.env.OPENSCOUT_OPERATOR_NAME?.trim(),
       ...configuredOperatorActorIds()
-    ]);
+    ].filter((candidate) => Boolean(candidate)));
     if (session.agentId) {
       const participants2 = session.participantIds.filter((participantId) => participantId.trim().length > 0);
       if (participants2.length === 0 || participants2.some((participantId) => operatorCandidates.has(participantId))) {
@@ -38090,7 +38856,7 @@ function inferDirectTargetAgentId(conversationId, session, senderId) {
       return participants[0] ?? null;
     }
   }
-  const parsedDirectConversation = conversationId ? parseDirectConversationId(conversationId) : null;
+  const parsedDirectConversation = !session && conversationId ? parseDirectConversationId(conversationId) : null;
   if (parsedDirectConversation) {
     return parsedDirectConversation.agentId || null;
   }
@@ -38121,6 +38887,15 @@ function resolveConversationRouting(conversationId) {
   const existingConversationId = session && !directAgentId && !channel ? conversationId ?? null : null;
   return { directAgentId, channel, conversationId: existingConversationId, senderId };
 }
+function conversationKindAfterMemberMutation(kind, participantIds) {
+  if (kind === "direct" && participantIds.length > 2) {
+    return "group_direct";
+  }
+  if (kind === "group_direct" && participantIds.length <= 2) {
+    return "direct";
+  }
+  return kind;
+}
 function buildAgentSessionCatalogPayload(input) {
   const runtimeDir = relayAgentRuntimeDirectory(input.agentId);
   const catalog = readSessionCatalogSync(runtimeDir);
@@ -39025,7 +39800,7 @@ async function buildAgentConfigurationSnapshot(currentDirectory) {
       workspaceRoots: settings?.discovery.workspaceRoots ?? [],
       hiddenProjectCount: settings?.discovery.hiddenProjectRoots.length ?? 0,
       defaultHarness: settings?.agents.defaultHarness ?? "claude",
-      defaultTransport: settings?.agents.defaultTransport ?? "claude_stream_json",
+      defaultTransport: settings?.agents.defaultTransport ?? "tmux",
       defaultCapabilities: settings?.agents.defaultCapabilities ?? [],
       sessionPrefix: settings?.agents.sessionPrefix ?? "relay"
     },
@@ -39590,6 +40365,7 @@ async function createOpenScoutWebServer(options) {
       systemPrompt: optionalString(body.systemPrompt) ?? existing.systemPrompt,
       launchArgs: stringList(body.launchArgs, existing.launchArgs),
       model,
+      channelEnabled: hasOwn(body, "channelEnabled") ? body.channelEnabled === true : existing.channelEnabled,
       capabilities: stringList(body.capabilities, existing.capabilities)
     });
     if (!nextConfig) {
@@ -39663,7 +40439,14 @@ async function createOpenScoutWebServer(options) {
     activityLimit: parseOptionalPositiveInt(c.req.query("activityLimit")),
     activityLookbackMs: parseOptionalPositiveInt(c.req.query("activityLookbackMs"))
   })));
-  app.get("/api/messages", (c) => c.json(queryRecentMessages(parseOptionalPositiveInt(c.req.query("limit"), 80) ?? 80, { conversationId: c.req.query("conversationId") || undefined })));
+  app.get("/api/messages", (c) => {
+    const cId = c.req.query("cId") || c.req.query("conversationId") || undefined;
+    const messages2 = queryRecentMessages(parseOptionalPositiveInt(c.req.query("limit"), 80) ?? 80, { conversationId: cId });
+    return c.json(messages2.map((message) => ({
+      ...message,
+      cId: message.conversationId
+    })));
+  });
   const rawHeuristicsFromRequest = async (c) => {
     const body = await c.req.json().catch(() => null);
     if (body && typeof body === "object" && !Array.isArray(body) && typeof body.raw === "string") {
@@ -39823,14 +40606,24 @@ async function createOpenScoutWebServer(options) {
     sessionId: c.req.query("sessionId") || undefined,
     targetAgentId: c.req.query("targetAgentId") || undefined
   })));
-  app.get("/api/conversations", async (c) => {
+  const readCommsList = async (c) => {
     const rawLimit = Number(c.req.query("limit"));
     const rawKinds = c.req.query("kinds")?.trim();
-    return c.json(await getScoutConversations({
+    return getScoutConversations({
       query: c.req.query("query") || undefined,
       limit: Number.isFinite(rawLimit) ? Math.min(250, Math.max(1, Math.floor(rawLimit))) : undefined,
       kinds: parseConversationKinds(rawKinds)
-    }));
+    });
+  };
+  app.get("/api/comms", async (c) => {
+    const items = await readCommsList(c);
+    return c.json(items.map((item) => ({
+      ...item,
+      cId: item.id
+    })));
+  });
+  app.get("/api/conversations", async (c) => {
+    return c.json(await readCommsList(c));
   });
   app.get("/api/conversations/:id/read-cursors", async (c) => {
     try {
@@ -39860,13 +40653,16 @@ async function createOpenScoutWebServer(options) {
     }
   });
   const writeConversationMembers = async (conversationId, mutate) => {
-    const existing = queryConversationDefinitionById(conversationId);
+    const currentSession = querySessionById(conversationId);
+    const canonicalConversationId = currentSession?.id ?? conversationId;
+    const existing = queryConversationDefinitionById(canonicalConversationId);
     if (!existing)
       return null;
     const nextParticipants = mutate(existing.participantIds);
+    const nextKind = conversationKindAfterMemberMutation(existing.kind, nextParticipants);
     await upsertScoutConversation({
       id: existing.id,
-      kind: existing.kind,
+      kind: nextKind,
       title: existing.title,
       visibility: existing.visibility,
       shareMode: existing.shareMode,
@@ -39877,7 +40673,11 @@ async function createOpenScoutWebServer(options) {
       ...existing.messageId ? { messageId: existing.messageId } : {},
       ...existing.metadata ? { metadata: existing.metadata } : {}
     });
-    return nextParticipants;
+    return {
+      kind: nextKind,
+      participantIds: nextParticipants,
+      session: querySessionById(existing.id)
+    };
   };
   app.post("/api/conversations/:id/members", async (c) => {
     const conversationId = c.req.param("id");
@@ -39888,7 +40688,7 @@ async function createOpenScoutWebServer(options) {
     const next = await writeConversationMembers(conversationId, (current) => Array.from(new Set([...current, actorId])).sort());
     if (!next)
       return c.json({ error: "conversation not found" }, 404);
-    return c.json({ ok: true, participantIds: next });
+    return c.json({ ok: true, ...next });
   });
   app.delete("/api/conversations/:id/members/:actorId", async (c) => {
     const conversationId = c.req.param("id");
@@ -39896,7 +40696,7 @@ async function createOpenScoutWebServer(options) {
     const next = await writeConversationMembers(conversationId, (current) => current.filter((id) => id !== actorId));
     if (!next)
       return c.json({ error: "conversation not found" }, 404);
-    return c.json({ ok: true, participantIds: next });
+    return c.json({ ok: true, ...next });
   });
   app.get("/api/sessions", (c) => c.json(querySessions()));
   app.get("/api/session-ref/:id", async (c) => {
@@ -40221,11 +41021,12 @@ async function createOpenScoutWebServer(options) {
     }
   });
   app.post("/api/send", async (c) => {
-    const { body, conversationId, threadId } = await c.req.json();
+    const { body, cId, conversationId, threadId } = await c.req.json();
     if (!body?.trim()) {
       return c.json({ error: "body is required" }, 400);
     }
-    if (!conversationId && scoutbotRunner) {
+    const routeCId = cId ?? conversationId;
+    if (!routeCId && scoutbotRunner) {
       try {
         const result2 = await scoutbotRunner.postOperatorMessage({
           body: body.trim(),
@@ -40240,7 +41041,7 @@ async function createOpenScoutWebServer(options) {
         return c.json({ error: message }, /unknown scoutbot thread/i.test(message) ? 404 : 500);
       }
     }
-    const { directAgentId, channel, conversationId: routedConversationId, senderId } = resolveConversationRouting(conversationId);
+    const { directAgentId, channel, conversationId: routedConversationId, senderId } = resolveConversationRouting(routeCId);
     if (directAgentId) {
       if (directAgentId === SCOUTBOT_AGENT_ID && scoutbotRunner) {
         try {
@@ -40290,11 +41091,11 @@ async function createOpenScoutWebServer(options) {
     return c.json(result);
   });
   app.post("/api/ask", async (c) => {
-    const { body, conversationId } = await c.req.json();
+    const { body, cId, conversationId } = await c.req.json();
     if (!body?.trim()) {
       return c.json({ error: "body is required" }, 400);
     }
-    const { directAgentId, senderId } = resolveConversationRouting(conversationId);
+    const { directAgentId, senderId } = resolveConversationRouting(cId ?? conversationId);
     if (!directAgentId) {
       return c.json({
         error: "ask is only available in a direct conversation with one agent"
@@ -40341,7 +41142,7 @@ async function createOpenScoutWebServer(options) {
         signal: c.req.raw.signal
       }));
     } catch (error) {
-      const message = error instanceof Error ? error.message : "Vox speech failed";
+      const message = error instanceof Error ? error.message : "Voice speech failed";
       return c.json({ error: message }, 503);
     }
   });
@@ -40406,28 +41207,28 @@ async function createOpenScoutWebServer(options) {
     }
   });
   app.get("/api/tail/discover", async (c) => {
-    const force = c.req.query("force") === "true";
-    const snapshot = await getTailDiscovery(force);
-    return c.json(snapshot);
+    const url = new URL(scoutBrokerPaths.v1.tailDiscover, resolveScoutBrokerUrl());
+    if (c.req.query("force") === "true" || c.req.query("force") === "1") {
+      url.searchParams.set("force", "1");
+    }
+    const res = await fetch(url);
+    if (!res.ok) {
+      return c.json({ error: `broker tail discovery unavailable (${res.status})` }, 502);
+    }
+    return c.json(await res.json());
   });
   app.get("/api/tail/recent", async (c) => {
     const limitParam = parseOptionalPositiveInt(c.req.query("limit"), 500) ?? 500;
-    const bufferedEvents = snapshotRecentEvents(limitParam);
-    if (c.req.query("transcripts") !== "true") {
-      return c.json({ events: bufferedEvents });
-    }
-    const transcriptEvents = await readRecentTranscriptEvents(limitParam, {
-      perTranscriptLineLimit: Math.min(200, Math.max(50, limitParam))
-    });
-    const eventsById = new Map;
-    for (const event of transcriptEvents) {
-      eventsById.set(event.id, event);
+    const url = new URL(scoutBrokerPaths.v1.tailRecent, resolveScoutBrokerUrl());
+    url.searchParams.set("limit", String(limitParam));
+    if (c.req.query("transcripts") === "true" || c.req.query("transcripts") === "1") {
+      url.searchParams.set("transcripts", "true");
     }
-    for (const event of bufferedEvents) {
-      eventsById.set(event.id, event);
+    const res = await fetch(url);
+    if (!res.ok) {
+      return c.json({ error: `broker tail unavailable (${res.status})` }, 502);
     }
-    const events2 = [...eventsById.values()].sort((left, right) => right.ts - left.ts).slice(0, limitParam);
-    return c.json({ events: events2 });
+    return c.json(await res.json());
   });
   app.get("/api/broadcast/recent", (c) => {
     const limitParam = parseOptionalPositiveInt(c.req.query("limit"), 50) ?? 50;
@@ -40571,7 +41372,7 @@ function resolveOpenScoutWebApplicationServerIdentity(env = process.env, _machin
 // packages/web/server/relay.ts
 import { mkdir as mkdir9 } from "fs/promises";
 import { join as join35 } from "path";
-import { randomUUID as randomUUID7 } from "crypto";
+import { randomUUID as randomUUID8 } from "crypto";
 var UPLOAD_DIR = "/tmp/scout-uploads";
 async function handleRelayUpload(req) {
   const { name, data } = await req.json();
@@ -40579,7 +41380,7 @@ async function handleRelayUpload(req) {
     return Response.json({ error: "Missing name or data" }, { status: 400 });
   }
   await mkdir9(UPLOAD_DIR, { recursive: true });
-  const filename = `${randomUUID7()}-${name}`;
+  const filename = `${randomUUID8()}-${name}`;
   const filepath = join35(UPLOAD_DIR, filename);
   await Bun.write(filepath, Buffer.from(data, "base64"));
   return Response.json({ path: filepath });