@openscout/scout 0.2.55 → 0.2.56

package/dist/scout-control-plane-web.mjs

@@ -122,6 +122,35 @@ function extractPendingApprovalRequests(snapshot) {
 }
 
 // packages/agent-sessions/src/state.ts
+function normalizeTrackedTimestamp(value) {
+  if (value == null) {
+    return null;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      return null;
+    }
+    return value < 1000000000000 ? value * 1000 : value;
+  }
+  if (value instanceof Date) {
+    const ms = value.getTime();
+    return Number.isFinite(ms) ? ms : null;
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed) {
+      return null;
+    }
+    const numeric = Number(trimmed);
+    if (Number.isFinite(numeric)) {
+      return numeric < 1000000000000 ? numeric * 1000 : numeric;
+    }
+    const parsed = Date.parse(trimmed);
+    return Number.isNaN(parsed) ? null : parsed;
+  }
+  return null;
+}
+
 class StateTracker {
   states = new Map;
   createSession(sessionId, session) {
@@ -156,7 +185,7 @@ class StateTracker {
     }
     return summaries;
   }
-  trackEvent(sessionId, event) {
+  trackEvent(sessionId, event, capturedAt) {
     const state = this.states.get(sessionId);
     if (!state)
       return;
@@ -168,13 +197,13 @@ class StateTracker {
         state.session = { ...state.session, status: "closed" };
         break;
       case "turn:start":
-        this.handleTurnStart(state, event);
+        this.handleTurnStart(state, event, capturedAt);
         break;
       case "turn:end":
-        this.handleTurnEnd(state, event);
+        this.handleTurnEnd(state, event, capturedAt);
         break;
       case "turn:error":
-        this.handleTurnError(state, event);
+        this.handleTurnError(state, event, capturedAt);
         break;
       case "block:start":
         this.handleBlockStart(state, event);
@@ -199,17 +228,17 @@ class StateTracker {
         break;
     }
   }
-  handleTurnStart(state, event) {
+  handleTurnStart(state, event, capturedAt) {
     const turn = {
       id: event.turn.id,
       status: "streaming",
       blocks: [],
-      startedAt: Date.now()
+      startedAt: normalizeTrackedTimestamp(event.turn.startedAt) ?? normalizeTrackedTimestamp(capturedAt) ?? Date.now()
     };
     state.turns.push(turn);
     state.currentTurnId = turn.id;
   }
-  handleTurnEnd(state, event) {
+  handleTurnEnd(state, event, capturedAt) {
     const turn = this.findTurn(state, event.turnId);
     if (!turn)
       return;
@@ -227,17 +256,17 @@ class StateTracker {
         turn.status = "completed";
         break;
     }
-    turn.endedAt = Date.now();
+    turn.endedAt = normalizeTrackedTimestamp(capturedAt) ?? Date.now();
     if (state.currentTurnId === event.turnId) {
       state.currentTurnId = undefined;
     }
   }
-  handleTurnError(state, event) {
+  handleTurnError(state, event, capturedAt) {
     const turn = this.findTurn(state, event.turnId);
     if (!turn)
       return;
     turn.status = "error";
-    turn.endedAt = Date.now();
+    turn.endedAt = normalizeTrackedTimestamp(capturedAt) ?? Date.now();
     if (state.currentTurnId === event.turnId) {
       state.currentTurnId = undefined;
     }
@@ -577,6 +606,682 @@ var init_registry = __esm(() => {
   };
 });
 
+// packages/agent-sessions/src/history.ts
+import { basename, dirname } from "path";
+function decodeClaudeProjectsSlug(name) {
+  if (!name || !name.startsWith("-")) {
+    return null;
+  }
+  const tail = name.slice(1);
+  if (!tail) {
+    return null;
+  }
+  return `/${tail.replace(/-/g, "/")}`;
+}
+function inferClaudeHistoryCwd(path) {
+  const parent = basename(dirname(path));
+  return decodeClaudeProjectsSlug(parent);
+}
+function deriveHistoryName(path) {
+  const claudeCwd = inferClaudeHistoryCwd(path);
+  if (claudeCwd) {
+    return basename(claudeCwd) || claudeCwd;
+  }
+  const parent = basename(dirname(path));
+  return parent || basename(path) || "History Session";
+}
+function normalizeTimestamp(value) {
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      return null;
+    }
+    return value < 1000000000000 ? value * 1000 : value;
+  }
+  if (value instanceof Date) {
+    const time = value.getTime();
+    return Number.isFinite(time) ? time : null;
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed) {
+      return null;
+    }
+    const numeric = Number(trimmed);
+    if (Number.isFinite(numeric)) {
+      return numeric < 1000000000000 ? numeric * 1000 : numeric;
+    }
+    const parsed = Date.parse(trimmed);
+    return Number.isNaN(parsed) ? null : parsed;
+  }
+  return null;
+}
+function extractRecordTimestamp(record) {
+  const candidates = [
+    record.timestamp,
+    record.createdAt,
+    record.created_at,
+    record.updatedAt,
+    record.updated_at,
+    record.time,
+    record.ts
+  ];
+  for (const candidate of candidates) {
+    const normalized = normalizeTimestamp(candidate);
+    if (normalized !== null) {
+      return normalized;
+    }
+  }
+  return null;
+}
+function stringifyUnknown(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value == null) {
+    return "";
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function renderToolResultContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (Array.isArray(content)) {
+    const text = content.map((entry) => {
+      if (typeof entry === "string") {
+        return entry;
+      }
+      const item = entry;
+      if (typeof item.text === "string") {
+        return item.text;
+      }
+      if (typeof item.content === "string") {
+        return item.content;
+      }
+      return stringifyUnknown(entry);
+    }).filter(Boolean).join(`
+`);
+    return text || stringifyUnknown(content);
+  }
+  return stringifyUnknown(content);
+}
+function extractQuestionOptions(firstQuestion) {
+  const options = Array.isArray(firstQuestion.options) ? firstQuestion.options : [];
+  return options.map((option) => {
+    if (typeof option === "string") {
+      return { label: option };
+    }
+    const record = option;
+    return {
+      label: typeof record.label === "string" ? record.label : String(option),
+      description: typeof record.description === "string" ? record.description : undefined
+    };
+  });
+}
+function parseQuestionAnswer(content) {
+  const text = renderToolResultContent(content).trim();
+  if (!text) {
+    return [];
+  }
+  return text.split(/\s*,\s*/u).map((part) => part.trim()).filter(Boolean);
+}
+function inferHistoryAdapterType(path, adapterType) {
+  const normalizedAdapter = adapterType?.trim();
+  if (normalizedAdapter === "claude-code") {
+    return "claude-code";
+  }
+  if (normalizedAdapter === "codex") {
+    return "codex";
+  }
+  const normalizedPath = path.toLowerCase();
+  if (normalizedPath.includes("/.claude/projects/")) {
+    return "claude-code";
+  }
+  if (normalizedPath.includes("/.codex/") || normalizedPath.includes("/.openai-codex/")) {
+    return "codex";
+  }
+  return "unknown";
+}
+function buildBaseHistorySession(input, adapterType) {
+  const cwd = input.cwd?.trim() || inferClaudeHistoryCwd(input.path) || undefined;
+  return {
+    id: input.sessionId?.trim() || `history:${input.path}`,
+    name: input.name?.trim() || deriveHistoryName(input.path),
+    adapterType,
+    status: "idle",
+    ...cwd ? { cwd } : {},
+    providerMeta: {
+      historyPath: input.path,
+      historyAdapterType: adapterType,
+      source: "external_history"
+    }
+  };
+}
+
+class ClaudeCodeHistoryParser {
+  session;
+  baseTimestampMs;
+  events = [];
+  currentTurn = null;
+  turnCounter = 0;
+  blockIndex = 0;
+  toolBlockMap = new Map;
+  questionBlockMap = new Map;
+  blockById = new Map;
+  activeStreamBlocks = new Map;
+  sawStreamTextThisTurn = false;
+  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;
+    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 (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+          skippedLineCount += 1;
+          continue;
+        }
+        record = parsed;
+      } catch {
+        skippedLineCount += 1;
+        continue;
+      }
+      const capturedAt = extractRecordTimestamp(record) ?? this.baseTimestampMs + index;
+      if (this.handleRecord(record, capturedAt)) {
+        parsedLineCount += 1;
+      } else {
+        skippedLineCount += 1;
+      }
+    }
+    return {
+      events: this.events,
+      lineCount,
+      parsedLineCount,
+      skippedLineCount
+    };
+  }
+  handleRecord(record, capturedAt) {
+    const type = typeof record.type === "string" ? record.type : null;
+    if (!type) {
+      return false;
+    }
+    switch (type) {
+      case "system":
+        this.handleSystem(record, capturedAt);
+        return true;
+      case "user":
+        this.startTurn(capturedAt);
+        return true;
+      case "assistant":
+        this.handleAssistant(record, capturedAt);
+        return true;
+      case "tool_use":
+        this.handleToolUse(record, capturedAt);
+        return true;
+      case "tool_result":
+        this.handleToolResult(record, capturedAt);
+        return true;
+      case "stream_event":
+        this.handleStreamEvent(record, capturedAt);
+        return true;
+      case "result":
+        this.handleResult(record, capturedAt);
+        return true;
+      case "error":
+        this.handleError(record, capturedAt);
+        return true;
+      default:
+        return false;
+    }
+  }
+  handleSystem(record, capturedAt) {
+    if (record.subtype !== "init") {
+      return;
+    }
+    let changed = false;
+    const externalSessionId = typeof record.session_id === "string" ? record.session_id : typeof record.sessionId === "string" ? record.sessionId : null;
+    if (externalSessionId) {
+      const providerMeta = { ...this.session.providerMeta ?? {} };
+      if (providerMeta.externalSessionId !== externalSessionId) {
+        providerMeta.externalSessionId = externalSessionId;
+        this.session.providerMeta = providerMeta;
+        changed = true;
+      }
+    }
+    if (typeof record.cwd === "string" && record.cwd.trim() && this.session.cwd !== record.cwd) {
+      this.session.cwd = record.cwd;
+      changed = true;
+    }
+    if (typeof record.model === "string" && record.model.trim() && this.session.model !== record.model) {
+      this.session.model = record.model;
+      changed = true;
+    }
+    if (changed) {
+      this.emitEvent(capturedAt, {
+        event: "session:update",
+        session: { ...this.session }
+      });
+    }
+  }
+  handleAssistant(record, capturedAt) {
+    const turn = this.ensureTurn(capturedAt);
+    if (this.sawStreamTextThisTurn) {
+      return;
+    }
+    const content = record.message && typeof record.message === "object" ? record.message.content : record.content;
+    if (!Array.isArray(content)) {
+      return;
+    }
+    for (const part of content) {
+      const contentPart = part;
+      const contentType = typeof contentPart.type === "string" ? contentPart.type : "";
+      if (contentType === "thinking" || contentType === "reasoning") {
+        const block = this.startBlock(turn, capturedAt, {
+          type: "reasoning",
+          text: typeof contentPart.thinking === "string" ? contentPart.thinking : typeof contentPart.text === "string" ? contentPart.text : "",
+          status: "completed"
+        });
+        this.emitBlockEnd(capturedAt, turn, block, "completed");
+      } else if (contentType === "text") {
+        const block = this.startBlock(turn, capturedAt, {
+          type: "text",
+          text: typeof contentPart.text === "string" ? contentPart.text : "",
+          status: "completed"
+        });
+        this.emitBlockEnd(capturedAt, turn, block, "completed");
+      }
+    }
+  }
+  handleStreamEvent(record, capturedAt) {
+    const turn = this.ensureTurn(capturedAt);
+    const streamEvent = record.event;
+    if (!streamEvent || typeof streamEvent !== "object") {
+      return;
+    }
+    const eventRecord = streamEvent;
+    const streamType = typeof eventRecord.type === "string" ? eventRecord.type : "";
+    if (streamType === "message_start") {
+      this.activeStreamBlocks.clear();
+      this.sawStreamTextThisTurn = false;
+      return;
+    }
+    if (streamType === "content_block_start") {
+      const index = typeof eventRecord.index === "number" ? eventRecord.index : 0;
+      const contentBlock = eventRecord.content_block;
+      if (!contentBlock || typeof contentBlock !== "object") {
+        return;
+      }
+      const contentRecord = contentBlock;
+      const contentType = typeof contentRecord.type === "string" ? contentRecord.type : "";
+      if (contentType !== "text" && contentType !== "thinking") {
+        return;
+      }
+      const block = this.startBlock(turn, capturedAt, {
+        type: contentType === "thinking" ? "reasoning" : "text",
+        text: "",
+        status: "streaming"
+      });
+      this.activeStreamBlocks.set(index, block);
+      this.sawStreamTextThisTurn = true;
+      const initialText = contentType === "thinking" ? typeof contentRecord.thinking === "string" ? contentRecord.thinking : "" : typeof contentRecord.text === "string" ? contentRecord.text : "";
+      this.appendTextDelta(capturedAt, turn, block, initialText);
+      return;
+    }
+    if (streamType === "content_block_delta") {
+      const index = typeof eventRecord.index === "number" ? eventRecord.index : 0;
+      const block = this.activeStreamBlocks.get(index);
+      const delta = eventRecord.delta;
+      if (!block || !delta || typeof delta !== "object") {
+        return;
+      }
+      const deltaRecord = delta;
+      const deltaType = typeof deltaRecord.type === "string" ? deltaRecord.type : "";
+      if (deltaType === "text_delta") {
+        this.appendTextDelta(capturedAt, turn, block, typeof deltaRecord.text === "string" ? deltaRecord.text : "");
+        return;
+      }
+      if (deltaType === "thinking_delta") {
+        this.appendTextDelta(capturedAt, turn, block, typeof deltaRecord.thinking === "string" ? deltaRecord.thinking : "");
+      }
+      return;
+    }
+    if (streamType === "content_block_stop") {
+      const index = typeof eventRecord.index === "number" ? eventRecord.index : 0;
+      const block = this.activeStreamBlocks.get(index);
+      if (!block) {
+        return;
+      }
+      this.emitBlockEnd(capturedAt, turn, block, "completed");
+      this.activeStreamBlocks.delete(index);
+    }
+  }
+  handleToolUse(record, capturedAt) {
+    const turn = this.ensureTurn(capturedAt);
+    const toolName = typeof record.tool_name === "string" ? record.tool_name : typeof record.name === "string" ? record.name : "unknown";
+    const toolCallId = typeof record.tool_use_id === "string" ? record.tool_use_id : typeof record.id === "string" ? record.id : `${turn.id}:tool:${this.blockIndex}`;
+    if (toolName === "AskUserQuestion") {
+      const input = record.input && typeof record.input === "object" ? record.input : {};
+      const questions = Array.isArray(input.questions) ? input.questions : [];
+      const firstQuestion = questions[0] ?? {};
+      const block2 = this.startBlock(turn, capturedAt, {
+        id: `${turn.id}:question:${toolCallId}`,
+        type: "question",
+        header: typeof firstQuestion.header === "string" ? firstQuestion.header : undefined,
+        question: typeof firstQuestion.question === "string" ? firstQuestion.question : "",
+        options: extractQuestionOptions(firstQuestion),
+        multiSelect: firstQuestion.multiSelect === true,
+        questionStatus: "awaiting_answer",
+        answer: undefined,
+        status: "streaming"
+      });
+      this.toolBlockMap.set(toolCallId, block2.id);
+      this.questionBlockMap.set(toolCallId, block2.id);
+      return;
+    }
+    let action;
+    if (toolName === "Edit" || toolName === "Write" || toolName === "MultiEdit") {
+      const input = record.input && typeof record.input === "object" ? record.input : {};
+      action = {
+        kind: "file_change",
+        path: typeof input.file_path === "string" ? input.file_path : typeof input.path === "string" ? input.path : "",
+        diff: "",
+        status: "running",
+        output: ""
+      };
+    } else if (toolName === "Bash") {
+      const input = record.input && typeof record.input === "object" ? record.input : {};
+      action = {
+        kind: "command",
+        command: typeof input.command === "string" ? input.command : "",
+        status: "running",
+        output: ""
+      };
+    } else if (toolName === "Agent") {
+      const input = record.input && typeof record.input === "object" ? record.input : {};
+      action = {
+        kind: "subagent",
+        agentId: toolCallId,
+        agentName: typeof input.description === "string" ? input.description : undefined,
+        prompt: typeof input.prompt === "string" ? input.prompt : undefined,
+        status: "running",
+        output: ""
+      };
+    } else {
+      action = {
+        kind: "tool_call",
+        toolName,
+        toolCallId,
+        input: record.input,
+        status: "running",
+        output: ""
+      };
+    }
+    const block = this.startBlock(turn, capturedAt, {
+      id: `${turn.id}:action:${toolCallId}`,
+      type: "action",
+      action,
+      status: "streaming"
+    });
+    this.toolBlockMap.set(toolCallId, block.id);
+  }
+  handleToolResult(record, capturedAt) {
+    const turn = this.ensureTurn(capturedAt);
+    const toolCallId = typeof record.tool_use_id === "string" ? record.tool_use_id : typeof record.id === "string" ? record.id : "";
+    if (!toolCallId) {
+      return;
+    }
+    const questionBlockId = this.questionBlockMap.get(toolCallId);
+    if (questionBlockId) {
+      const answer = parseQuestionAnswer(record.content);
+      this.emitEvent(capturedAt, {
+        event: "block:question:answer",
+        sessionId: this.session.id,
+        turnId: turn.id,
+        blockId: questionBlockId,
+        questionStatus: "answered",
+        ...answer.length > 0 ? { answer } : {}
+      });
+      const block2 = this.blockById.get(questionBlockId);
+      if (block2) {
+        this.emitBlockEnd(capturedAt, turn, block2, "completed");
+      }
+      this.questionBlockMap.delete(toolCallId);
+      this.toolBlockMap.delete(toolCallId);
+      return;
+    }
+    const blockId = this.toolBlockMap.get(toolCallId);
+    if (!blockId) {
+      return;
+    }
+    const output = renderToolResultContent(record.content);
+    if (output) {
+      this.emitEvent(capturedAt, {
+        event: "block:action:output",
+        sessionId: this.session.id,
+        turnId: turn.id,
+        blockId,
+        output
+      });
+    }
+    const status = record.is_error === true ? "failed" : "completed";
+    this.emitEvent(capturedAt, {
+      event: "block:action:status",
+      sessionId: this.session.id,
+      turnId: turn.id,
+      blockId,
+      status
+    });
+    const block = this.blockById.get(blockId);
+    if (block) {
+      this.emitBlockEnd(capturedAt, turn, block, status === "failed" ? "failed" : "completed");
+    }
+    this.toolBlockMap.delete(toolCallId);
+  }
+  handleResult(record, capturedAt) {
+    const turn = this.currentTurn;
+    if (!turn) {
+      return;
+    }
+    this.completeOpenStreamBlocks(capturedAt, turn);
+    const denials = Array.isArray(record.permission_denials) ? record.permission_denials : [];
+    for (const denial of denials) {
+      const denialRecord = denial;
+      if (denialRecord.tool_name !== "AskUserQuestion") {
+        continue;
+      }
+      const input = denialRecord.tool_input && typeof denialRecord.tool_input === "object" ? denialRecord.tool_input : {};
+      const questions = Array.isArray(input.questions) ? input.questions : [];
+      const firstQuestion = questions[0] ?? {};
+      const block = this.startBlock(turn, capturedAt, {
+        type: "question",
+        header: typeof firstQuestion.header === "string" ? firstQuestion.header : undefined,
+        question: typeof firstQuestion.question === "string" ? firstQuestion.question : "",
+        options: extractQuestionOptions(firstQuestion),
+        multiSelect: firstQuestion.multiSelect === true,
+        questionStatus: "denied",
+        status: "completed"
+      });
+      this.emitBlockEnd(capturedAt, turn, block, "completed");
+    }
+    this.endTurn(record.subtype === "error" ? "failed" : "completed", capturedAt);
+  }
+  handleError(record, capturedAt) {
+    const turn = this.ensureTurn(capturedAt);
+    const error = record.error && typeof record.error === "object" ? record.error : {};
+    const message = typeof error.message === "string" ? error.message : typeof record.message === "string" ? record.message : "Unknown error";
+    this.emitError(turn, capturedAt, message);
+    this.endTurn("failed", capturedAt);
+  }
+  startTurn(capturedAt) {
+    if (this.currentTurn) {
+      this.endTurn("stopped", capturedAt);
+    }
+    this.turnCounter += 1;
+    this.blockIndex = 0;
+    this.toolBlockMap.clear();
+    this.questionBlockMap.clear();
+    this.blockById.clear();
+    this.activeStreamBlocks.clear();
+    this.sawStreamTextThisTurn = false;
+    this.session.status = "active";
+    this.emitEvent(capturedAt, {
+      event: "session:update",
+      session: { ...this.session }
+    });
+    const turn = {
+      id: `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.toolBlockMap.clear();
+    this.questionBlockMap.clear();
+    this.blockById.clear();
+    this.activeStreamBlocks.clear();
+    this.sawStreamTextThisTurn = false;
+    this.session.status = "idle";
+    this.emitEvent(capturedAt, {
+      event: "session:update",
+      session: { ...this.session }
+    });
+  }
+  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;
+  }
+  appendTextDelta(capturedAt, turn, block, text) {
+    if (!text) {
+      return;
+    }
+    block.text += text;
+    block.status = "streaming";
+    this.emitEvent(capturedAt, {
+      event: "block:delta",
+      sessionId: this.session.id,
+      turnId: turn.id,
+      blockId: block.id,
+      text
+    });
+  }
+  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
+    });
+  }
+  completeOpenStreamBlocks(capturedAt, turn) {
+    for (const block of this.activeStreamBlocks.values()) {
+      this.emitBlockEnd(capturedAt, turn, block, "completed");
+    }
+    this.activeStreamBlocks.clear();
+  }
+  emitError(turn, capturedAt, message) {
+    const block = this.startBlock(turn, capturedAt, {
+      type: "error",
+      message,
+      status: "completed"
+    });
+    this.emitBlockEnd(capturedAt, turn, block, "completed");
+  }
+  emitEvent(capturedAt, event) {
+    this.events.push({
+      capturedAt,
+      event: structuredClone(event)
+    });
+  }
+}
+function supportsHistorySessionSnapshotForPath(path, adapterType) {
+  return inferHistoryAdapterType(path, adapterType) === "claude-code";
+}
+function createHistorySessionSnapshot(input) {
+  const adapterType = inferHistoryAdapterType(input.path, input.adapterType);
+  if (adapterType !== "claude-code") {
+    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 replay = parser.parse(input.content);
+  const tracker = new StateTracker;
+  tracker.createSession(session.id, session);
+  for (const entry of replay.events) {
+    tracker.trackEvent(session.id, entry.event, entry.capturedAt);
+  }
+  const snapshot = tracker.getSessionState(session.id);
+  if (!snapshot) {
+    throw new Error("Failed to reconstruct session snapshot from history.");
+  }
+  return {
+    adapterType,
+    lineCount: replay.lineCount,
+    parsedLineCount: replay.parsedLineCount,
+    skippedLineCount: replay.skippedLineCount,
+    events: replay.events,
+    snapshot
+  };
+}
+var init_history = () => {};
+
 // packages/agent-sessions/src/adapters/claude-code.ts
 import { existsSync, readdirSync, statSync } from "fs";
 import { homedir } from "os";
@@ -602,7 +1307,7 @@ function resolveClaudeResumeContext(config) {
     if (!existsSync(sessionPath)) {
       continue;
     }
-    const cwd = decodeClaudeProjectsSlug(slug);
+    const cwd = decodeClaudeProjectsSlug2(slug);
     if (!cwd) {
       continue;
     }
@@ -621,7 +1326,7 @@ function resolveClaudeResumeContext(config) {
   }
   return null;
 }
-function decodeClaudeProjectsSlug(slug) {
+function decodeClaudeProjectsSlug2(slug) {
   if (!slug.startsWith("-")) {
     return null;
   }
@@ -1142,7 +1847,7 @@ Referenced files: ${prompt.files.join(", ")}` });
 // packages/agent-sessions/src/codex-launch-config.ts
 import { accessSync, constants, existsSync as existsSync2 } from "fs";
 import { homedir as homedir2 } from "os";
-import { basename, delimiter, dirname, join as join2, resolve } from "path";
+import { basename as basename2, delimiter, dirname as dirname2, join as join2, resolve } from "path";
 import { fileURLToPath } from "url";
 function isExecutable(filePath) {
   if (!filePath) {
@@ -1163,7 +1868,7 @@ function ancestorChain(start) {
   let current = resolve(start);
   while (true) {
     chain.push(current);
-    const parent = dirname(current);
+    const parent = dirname2(current);
     if (parent === current) {
       return chain;
     }
@@ -1199,7 +1904,7 @@ function resolveBunExecutable(env) {
       return candidate;
     }
   }
-  if (basename(process.execPath).startsWith("bun") && isExecutable(process.execPath)) {
+  if (basename2(process.execPath).startsWith("bun") && isExecutable(process.execPath)) {
     return process.execPath;
   }
   return resolveExecutableFromSearchPath(["bun"], env);
@@ -1219,7 +1924,7 @@ function resolveScoutExecutable(env) {
   return resolveExecutableFromSearchPath(["scout"], env);
 }
 function resolveRepoScoutScript(currentDirectory) {
-  const moduleDirectory = dirname(fileURLToPath(import.meta.url));
+  const moduleDirectory = dirname2(fileURLToPath(import.meta.url));
   const starts = uniquePaths([currentDirectory, moduleDirectory]);
   for (const start of starts) {
     for (const candidate of ancestorChain(start)) {
@@ -3394,6 +4099,7 @@ var init_echo = __esm(() => {
 var init_src = __esm(() => {
   init_registry();
   init_registry();
+  init_history();
   init_claude_code();
   init_codex();
   init_openai_compat();
@@ -4795,17 +5501,127 @@ var init_mesh = () => {};
 
 // packages/protocol/dist/conversations.js
 var init_conversations = () => {};
-// packages/protocol/dist/messages.js
-var init_messages = () => {};
 
-// packages/protocol/dist/invocations.js
-var init_invocations = () => {};
-
-// packages/protocol/dist/scout-dispatch.js
-var init_scout_dispatch = () => {};
-
-// packages/protocol/dist/deliveries.js
-var init_deliveries = () => {};
+// packages/protocol/dist/collaboration.js
+function isQuestionTerminalState(state) {
+  return state === "closed" || state === "declined";
+}
+function isWorkItemTerminalState(state) {
+  return state === "done" || state === "cancelled";
+}
+function collaborationRequiresNextMoveOwner(record) {
+  if (record.kind === "question") {
+    return !isQuestionTerminalState(record.state);
+  }
+  return !isWorkItemTerminalState(record.state);
+}
+function collaborationRequiresOwner(record) {
+  return record.kind === "work_item" && !isWorkItemTerminalState(record.state);
+}
+function collaborationRequiresWaitingOn(record) {
+  return record.kind === "work_item" && record.state === "waiting";
+}
+function collaborationRequiresAcceptance(record) {
+  if (record.acceptanceState === "none") {
+    return false;
+  }
+  if (record.kind === "question") {
+    return Boolean(record.askedById && record.askedOfId);
+  }
+  return Boolean(record.requestedById);
+}
+function validateCollaborationRecord(record) {
+  const errors = [];
+  if (!record.id.trim()) {
+    errors.push("collaboration record id is required");
+  }
+  if (!record.title.trim()) {
+    errors.push("collaboration title is required");
+  }
+  if (!record.createdById.trim()) {
+    errors.push("createdById is required");
+  }
+  if (record.parentId && record.parentId === record.id) {
+    errors.push("parentId cannot reference the record itself");
+  }
+  if (record.createdAt > record.updatedAt) {
+    errors.push("updatedAt must be greater than or equal to createdAt");
+  }
+  if (collaborationRequiresOwner(record) && !record.ownerId) {
+    errors.push("non-terminal work items require ownerId");
+  }
+  if (collaborationRequiresNextMoveOwner(record) && !record.nextMoveOwnerId) {
+    errors.push("non-terminal collaboration records require nextMoveOwnerId");
+  }
+  if (record.kind === "work_item" && collaborationRequiresWaitingOn(record) && !record.waitingOn) {
+    errors.push("waiting work items require waitingOn");
+  }
+  if (record.kind === "question") {
+    if (record.spawnedWorkItemId && record.spawnedWorkItemId === record.id) {
+      errors.push("question spawnedWorkItemId cannot reference the question itself");
+    }
+  } else if (record.waitingOn?.targetId && record.waitingOn.targetId === record.id) {
+    errors.push("waitingOn.targetId cannot reference the work item itself");
+  }
+  if (record.acceptanceState !== "none" && !collaborationRequiresAcceptance(record)) {
+    errors.push("acceptanceState requires the corresponding requester and reviewer identities");
+  }
+  return errors;
+}
+function assertValidCollaborationRecord(record) {
+  const errors = validateCollaborationRecord(record);
+  if (errors.length > 0) {
+    throw new Error(errors.join("; "));
+  }
+}
+function validateCollaborationEvent(event, record) {
+  const errors = [];
+  if (!event.id.trim()) {
+    errors.push("collaboration event id is required");
+  }
+  if (!event.recordId.trim()) {
+    errors.push("collaboration event recordId is required");
+  }
+  if (!event.actorId.trim()) {
+    errors.push("collaboration event actorId is required");
+  }
+  if (record) {
+    if (record.id !== event.recordId) {
+      errors.push("collaboration event recordId does not match the target record");
+    }
+    if (record.kind !== event.recordKind) {
+      errors.push("collaboration event recordKind does not match the target record");
+    }
+  }
+  if (event.kind === "answered" && event.recordKind !== "question") {
+    errors.push("answered events only apply to questions");
+  }
+  if (event.kind === "declined" && event.recordKind !== "question") {
+    errors.push("declined events only apply to questions");
+  }
+  if ((event.kind === "waiting" || event.kind === "progressed" || event.kind === "review_requested" || event.kind === "done" || event.kind === "cancelled") && event.recordKind !== "work_item") {
+    errors.push(`${event.kind} events only apply to work items`);
+  }
+  return errors;
+}
+function assertValidCollaborationEvent(event, record) {
+  const errors = validateCollaborationEvent(event, record);
+  if (errors.length > 0) {
+    throw new Error(errors.join("; "));
+  }
+}
+
+// packages/protocol/dist/messages.js
+var init_messages = () => {};
+
+// packages/protocol/dist/invocations.js
+var init_invocations = () => {};
+
+// packages/protocol/dist/scout-dispatch.js
+var init_scout_dispatch = () => {};
+
+// packages/protocol/dist/deliveries.js
+var init_deliveries = () => {};
 
 // packages/protocol/dist/transports.js
 var init_transports = () => {};
@@ -4886,9 +5702,9 @@ var init_support_paths = () => {};
 // packages/runtime/src/harness-catalog.ts
 import { existsSync as existsSync4, statSync as statSync2 } from "fs";
 import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import { dirname as dirname2, join as join5 } from "path";
+import { dirname as dirname3, join as join5 } from "path";
 async function writeHarnessCatalogOverrides(overrides, overridePath = resolveOpenScoutSupportPaths().harnessCatalogPath) {
-  await mkdir2(dirname2(overridePath), { recursive: true });
+  await mkdir2(dirname3(overridePath), { recursive: true });
   const payload = {
     version: HARNESS_CATALOG_VERSION,
     entries: overrides,
@@ -4984,9 +5800,9 @@ var init_harness_catalog = __esm(() => {
 // packages/runtime/src/user-project-hints.ts
 import { readdir, readFile as readFile3, stat } from "fs/promises";
 import { homedir as homedir5 } from "os";
-import { dirname as dirname3, join as join6, resolve as resolve2 } from "path";
+import { dirname as dirname4, join as join6, resolve as resolve2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-function decodeClaudeProjectsSlug2(name) {
+function decodeClaudeProjectsSlug3(name) {
   if (!name || name === "." || name === "..") {
     return null;
   }
@@ -5011,7 +5827,7 @@ async function resolveExistingDirectoryHint(pathLike) {
       return absolutePath;
     }
     if (info.isFile()) {
-      return dirname3(absolutePath);
+      return dirname4(absolutePath);
     }
   } catch {
     return null;
@@ -5038,7 +5854,7 @@ async function findLikelyProjectRoot(absolutePath) {
         }
       }
     }
-    const parent = dirname3(current);
+    const parent = dirname4(current);
     if (parent === current) {
       return lastCandidate ?? absolutePath;
     }
@@ -5179,7 +5995,7 @@ async function appendCursorWorkspacePaths(home, roots) {
         }
         const wsRaw = await readFile3(wsFile, "utf8");
         const wsDoc = JSON.parse(wsRaw);
-        const wsDir = dirname3(wsFile);
+        const wsDir = dirname4(wsFile);
         for (const f of wsDoc.folders ?? []) {
           if (typeof f.path !== "string" || !f.path) {
             continue;
@@ -5200,7 +6016,7 @@ async function appendClaudeProjectSlugs(home, roots) {
     return;
   }
   for (const name of names) {
-    const decoded = decodeClaudeProjectsSlug2(name);
+    const decoded = decodeClaudeProjectsSlug3(name);
     if (!decoded) {
       continue;
     }
@@ -5336,7 +6152,7 @@ import { execFileSync } from "child_process";
 import { existsSync as existsSync5, readFileSync } from "fs";
 import { access as access2, mkdir as mkdir3, readdir as readdir2, readFile as readFile4, realpath, rm as rm2, stat as stat2, writeFile as writeFile3 } from "fs/promises";
 import { homedir as homedir6, hostname, userInfo } from "os";
-import { basename as basename2, dirname as dirname4, isAbsolute, join as join7, relative, resolve as resolve3 } from "path";
+import { basename as basename3, dirname as dirname5, isAbsolute, join as join7, relative, resolve as resolve3 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function titleCaseWords(value) {
   return value.split(/[\s._-]+/).map((part) => part.trim()).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
@@ -5811,7 +6627,7 @@ async function readJsonFile(filePath) {
   }
 }
 async function writeJsonFile(filePath, value) {
-  await mkdir3(dirname4(filePath), { recursive: true });
+  await mkdir3(dirname5(filePath), { recursive: true });
   await writeFile3(filePath, JSON.stringify(value, null, 2) + `
 `, "utf8");
 }
@@ -6056,7 +6872,7 @@ function applyImportedEnvironmentSeeds(config, codexImport, projectRoot) {
       ...(config.environment?.actions?.length ?? 0) === 0 && importedEnvironment.actions ? { actions: importedEnvironment.actions } : {}
     };
   }
-  const defaultProjectName = titleCase(basename2(projectRoot));
+  const defaultProjectName = titleCase(basename3(projectRoot));
   if (codexImport?.name?.trim() && (!config.project.name?.trim() || config.project.name === defaultProjectName)) {
     next.project = {
       ...config.project,
@@ -6224,7 +7040,7 @@ async function seedWorkspaceRoots(options) {
   const roots = new Set;
   const currentProjectRoot = options.currentDirectory ? await findNearestProjectRoot(options.currentDirectory) : null;
   if (currentProjectRoot) {
-    roots.add(dirname4(currentProjectRoot));
+    roots.add(dirname5(currentProjectRoot));
   }
   const legacyRoot = options.legacyRelayConfig?.projectRoot?.trim();
   if (legacyRoot) {
@@ -6232,7 +7048,7 @@ async function seedWorkspaceRoots(options) {
   }
   for (const record of Object.values(options.legacyAgents ?? {})) {
     if (record.cwd?.trim()) {
-      roots.add(dirname4(normalizePath(record.cwd)));
+      roots.add(dirname5(normalizePath(record.cwd)));
     }
   }
   if (roots.size === 0) {
@@ -6323,7 +7139,7 @@ async function installScoutSkillToHarnesses() {
       continue;
     }
     try {
-      await mkdir3(dirname4(target), { recursive: true });
+      await mkdir3(dirname5(target), { recursive: true });
       await writeFile3(target, content, "utf8");
       entries.push({ harness, target, status: "installed" });
     } catch (error) {
@@ -6424,7 +7240,7 @@ async function findNearestProjectRoot(startDirectory) {
     if (await pathExists2(projectConfigPath(current)) || await pathExists2(join7(current, "package.json")) || await pathExists2(join7(current, "AGENTS.md")) || await pathExists2(join7(current, "CLAUDE.md"))) {
       lastCandidate = current;
     }
-    const parent = dirname4(current);
+    const parent = dirname5(current);
     if (parent === current) {
       return lastCandidate;
     }
@@ -6432,7 +7248,7 @@ async function findNearestProjectRoot(startDirectory) {
   }
 }
 function defaultProjectConfig(projectRoot, settings, preferredHarness) {
-  const projectName = basename2(projectRoot);
+  const projectName = basename3(projectRoot);
   const definitionId = normalizeAgentId(projectName);
   const relativeRoot = relative(projectRoot, projectRoot) || ".";
   return {
@@ -6738,8 +7554,8 @@ function selectorFromInput(value) {
 }
 async function resolveManifestBackedAgent(projectRoot, config, settings, override) {
   const resolvedProjectRoot = resolveProjectRootFromConfig(projectRoot, config);
-  const projectName = config.project.name?.trim() || titleCase(config.project.id || basename2(resolvedProjectRoot));
-  const fallbackDefinitionId = normalizeAgentId(config.project.id || basename2(resolvedProjectRoot));
+  const projectName = config.project.name?.trim() || titleCase(config.project.id || basename3(resolvedProjectRoot));
+  const fallbackDefinitionId = normalizeAgentId(config.project.id || basename3(resolvedProjectRoot));
   const definitionId = normalizeAgentId(config.agent?.id || override?.definitionId || fallbackDefinitionId);
   const detectedHarness = await detectPreferredHarness(resolvedProjectRoot, settings.agents.defaultHarness);
   const runtimeDefaults = config.agent?.runtime?.defaults;
@@ -6776,7 +7592,7 @@ async function resolveManifestBackedAgent(projectRoot, config, settings, overrid
   return mergeResolvedAgentConfig(base, override, settings);
 }
 async function resolveInferredAgent(projectRoot, settings, override) {
-  const projectName = basename2(projectRoot);
+  const projectName = basename3(projectRoot);
   const definitionId = normalizeAgentId(override?.definitionId?.trim() || projectName);
   const detectedHarness = await detectPreferredHarness(projectRoot, settings.agents.defaultHarness);
   const defaultHarness = normalizeManagedHarness(override?.defaultHarness ?? override?.runtime?.harness, normalizeManagedHarness(detectedHarness, "claude"));
@@ -6812,7 +7628,7 @@ async function resolveInferredAgent(projectRoot, settings, override) {
   return mergeResolvedAgentConfig(base, override, settings);
 }
 async function buildProjectInventoryEntry(agent, sourceRoot) {
-  const manifestRoot = agent.projectConfigPath ? normalizePath(join7(dirname4(agent.projectConfigPath), "..")) : null;
+  const manifestRoot = agent.projectConfigPath ? normalizePath(join7(dirname5(agent.projectConfigPath), "..")) : null;
   const manifest = manifestRoot ? await readProjectConfig(manifestRoot) : null;
   const markers = await detectHarnessMarkers(agent.projectRoot);
   const harnesses = new Map;
@@ -7205,7 +8021,7 @@ var init_setup = __esm(() => {
   PROJECT_STRONG_MARKERS_FLAT_NESTED = partitionFlatAndNestedMarkers(PROJECT_STRONG_MARKERS);
   PROJECT_WEAK_MARKERS_FLAT_NESTED = partitionFlatAndNestedMarkers(PROJECT_WEAK_MARKERS);
   gitBranchCache = new Map;
-  SETUP_MODULE_DIRECTORY = dirname4(fileURLToPath3(import.meta.url));
+  SETUP_MODULE_DIRECTORY = dirname5(fileURLToPath3(import.meta.url));
   SCOUT_SKILL_REPO_ROOT = resolve3(SETUP_MODULE_DIRECTORY, "..", "..", "..");
   SCOUT_SKILL_INSTALL_PATHS = {
     claude: join7(homedir6(), ".claude", "skills", "scout", SCOUT_SKILL_FILE_NAME),
@@ -7290,7 +8106,7 @@ function updateBlockCompletion(blockState, completed) {
   blockState.status = completed ? "completed" : "streaming";
   blockState.block.status = completed ? "completed" : "streaming";
 }
-function parseQuestionAnswer(value) {
+function parseQuestionAnswer2(value) {
   if (Array.isArray(value)) {
     return value.map((entry) => typeof entry === "string" ? entry.trim() : String(entry).trim()).filter(Boolean);
   }
@@ -7608,7 +8424,7 @@ function buildClaudeStreamJsonSessionSnapshot(raw2, options, targetClaudeSession
         if (blockState.block.type === "question") {
           const questionBlock = blockState.block;
           questionBlock.questionStatus = result.is_error ? "denied" : "answered";
-          const answer = parseQuestionAnswer(result.content);
+          const answer = parseQuestionAnswer2(result.content);
           questionBlock.answer = answer.length > 0 ? answer : undefined;
           updateBlockCompletion(blockState, true);
           continue;
@@ -9621,7 +10437,7 @@ function buildInvocationCollaborationContextPrompt(invocation) {
 import { spawnSync } from "child_process";
 import { existsSync as existsSync9, mkdirSync as mkdirSync5, readFileSync as readFileSync5, rmSync as rmSync2, writeFileSync as writeFileSync5 } from "fs";
 import { homedir as homedir11 } from "os";
-import { basename as basename3, dirname as dirname9, join as join15, resolve as resolve5 } from "path";
+import { basename as basename4, dirname as dirname10, join as join15, resolve as resolve5 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 function isTmpPath(p) {
   return /^\/(?:private\/)?tmp\//.test(p);
@@ -9654,7 +10470,7 @@ function runtimePackageDir() {
   const fromCwd = findWorkspaceRuntimeDir(process.cwd());
   if (fromCwd)
     return fromCwd;
-  const moduleDir = dirname9(fileURLToPath5(import.meta.url));
+  const moduleDir = dirname10(fileURLToPath5(import.meta.url));
   return resolve5(moduleDir, "..");
 }
 function isInstalledRuntimePackageDir(candidate) {
@@ -9692,7 +10508,7 @@ function findWorkspaceRuntimeDir(startDir) {
     if (existsSync9(join15(candidate, "package.json")) && existsSync9(join15(candidate, "src"))) {
       return candidate;
     }
-    const parent = dirname9(current);
+    const parent = dirname10(current);
     if (parent === current)
       return null;
     current = parent;
@@ -9703,7 +10519,7 @@ function resolveBunExecutable2() {
   if (explicit && explicit.trim().length > 0) {
     return explicit;
   }
-  if (basename3(process.execPath).startsWith("bun") && existsSync9(process.execPath)) {
+  if (basename4(process.execPath).startsWith("bun") && existsSync9(process.execPath)) {
     return process.execPath;
   }
   const pathEntries = (process.env.PATH ?? "").split(":").filter(Boolean);
@@ -9856,8 +10672,8 @@ function collectOptionalEnvVars(keys) {
 }
 function resolveLaunchAgentPATH() {
   const entries = [
-    ...(process.env.PATH ?? "").split(":").filter(Boolean),
     join15(homedir11(), ".bun", "bin"),
+    ...(process.env.PATH ?? "").split(":").filter(Boolean),
     "/opt/homebrew/bin",
     "/usr/local/bin",
     "/usr/bin",
@@ -9871,7 +10687,7 @@ function xmlEscape(value) {
   return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
 }
 function ensureParentDirectory(filePath) {
-  mkdirSync5(dirname9(filePath), { recursive: true });
+  mkdirSync5(dirname10(filePath), { recursive: true });
 }
 function ensureServiceDirectories(config) {
   ensureOpenScoutCleanSlateSync();
@@ -10128,7 +10944,7 @@ var DEFAULT_BROKER_HOST = "127.0.0.1", DEFAULT_BROKER_HOST_MESH = "0.0.0.0", DEF
 var init_broker_service = __esm(async () => {
   init_support_paths();
   DEFAULT_BROKER_URL = buildDefaultBrokerUrl();
-  if (process.argv[1] && fileURLToPath5(import.meta.url) === process.argv[1]) {
+  if (process.argv[1] && fileURLToPath5(import.meta.url) === process.argv[1] && !process.argv[1].endsWith("/main.mjs")) {
     await main();
   }
 });
@@ -10184,7 +11000,7 @@ import { randomUUID as randomUUID2 } from "crypto";
 import { execFileSync as execFileSync2, execSync } from "child_process";
 import { existsSync as existsSync10, readFileSync as readFileSync6 } from "fs";
 import { mkdir as mkdir6, rm as rm5, stat as stat4, writeFile as writeFile6 } from "fs/promises";
-import { basename as basename4, dirname as dirname10, join as join16, resolve as resolve6 } from "path";
+import { basename as basename5, dirname as dirname11, join as join16, resolve as resolve6 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 function resolveRelayHub() {
   return resolveOpenScoutSupportPaths().relayHubDirectory;
@@ -10196,13 +11012,13 @@ function resolveProjectsRoot(projectPath) {
   try {
     const supportPaths = resolveOpenScoutSupportPaths();
     if (!existsSync10(supportPaths.settingsPath)) {
-      return dirname10(projectPath);
+      return dirname11(projectPath);
     }
     const raw2 = JSON.parse(readFileSync6(supportPaths.settingsPath, "utf8"));
     const workspaceRoot = raw2.discovery?.workspaceRoots?.find((entry) => typeof entry === "string" && entry.trim().length > 0);
-    return workspaceRoot ? resolve6(workspaceRoot) : dirname10(projectPath);
+    return workspaceRoot ? resolve6(workspaceRoot) : dirname11(projectPath);
   } catch {
-    return dirname10(projectPath);
+    return dirname11(projectPath);
   }
 }
 function resolveBrokerUrl() {
@@ -10629,7 +11445,7 @@ function recordForHarness(record, harnessOverride) {
 function normalizeLocalAgentRecord(agentId, record) {
   const cwd = normalizeProjectPath(record.cwd || process.cwd());
   const projectRoot = normalizeProjectPath(record.projectRoot || cwd);
-  const project = record.project?.trim() || basename4(projectRoot);
+  const project = record.project?.trim() || basename5(projectRoot);
   const definitionId = record.definitionId?.trim() || agentId;
   const defaultHarness = activeLocalHarness(record);
   const harnessProfiles = normalizeLocalHarnessProfiles(agentId, {
@@ -10694,7 +11510,7 @@ function localAgentRecordFromResolvedConfig(config) {
 function localAgentRecordFromRelayAgentOverride(agentId, override) {
   return normalizeLocalAgentRecord(agentId, {
     definitionId: override.definitionId ?? agentId,
-    project: override.projectName ?? basename4(override.projectRoot || override.runtime?.cwd || agentId),
+    project: override.projectName ?? basename5(override.projectRoot || override.runtime?.cwd || agentId),
     projectRoot: override.projectRoot ?? override.runtime?.cwd,
     tmuxSession: override.runtime?.sessionId ?? `relay-${agentId}`,
     cwd: override.runtime?.cwd ?? override.projectRoot,
@@ -11135,7 +11951,7 @@ async function ensureLocalAgentOnline(agentName, record) {
     return normalizedRecord;
   }
   const projectPath = normalizedRecord.cwd;
-  const projectName = normalizedRecord.project || basename4(projectPath);
+  const projectName = normalizedRecord.project || basename5(projectPath);
   const systemPromptTemplate = normalizedRecord.systemPrompt || buildLocalAgentSystemPromptTemplate();
   const systemPrompt = renderLocalAgentSystemPromptTemplate(systemPromptTemplate, buildLocalAgentTemplateContext(agentName, projectName, projectPath), { transport: normalizedRecord.transport });
   const agentRuntimeDir = relayAgentRuntimeDirectory(agentName);
@@ -11357,7 +12173,7 @@ async function resolveLocalAgentIdentity(input) {
       nodeQualifier: instance2.nodeQualifier,
       harness: normalizeManagedHarness2(preferredHarness ?? override.defaultHarness, "claude"),
       projectRoot: normalizeProjectPath(override.projectRoot),
-      projectName: override.projectName ?? basename4(override.projectRoot),
+      projectName: override.projectName ?? basename5(override.projectRoot),
       source: "existing"
     };
   }
@@ -11376,12 +12192,12 @@ async function resolveLocalAgentIdentity(input) {
       nodeQualifier: instance2.nodeQualifier,
       harness: normalizeManagedHarness2(preferredHarness ?? override.defaultHarness, "claude"),
       projectRoot: normalizeProjectPath(override.projectRoot),
-      projectName: override.projectName ?? basename4(override.projectRoot),
+      projectName: override.projectName ?? basename5(override.projectRoot),
       source: "existing"
     };
   }
   const configDefinitionId = config?.agent?.id?.trim() ? normalizeAgentSelectorSegment(config.agent.id.trim()) : "";
-  const definitionId = requestedDefinitionId || configDefinitionId || normalizeAgentSelectorSegment(basename4(projectRoot)) || "agent";
+  const definitionId = requestedDefinitionId || configDefinitionId || normalizeAgentSelectorSegment(basename5(projectRoot)) || "agent";
   const configDisplayName = config?.agent?.displayName?.trim() || "";
   const displayName = input.displayName || configDisplayName || titleCaseLocalAgentName(definitionId);
   const instance = buildRelayAgentInstance(definitionId, projectRoot);
@@ -11395,7 +12211,7 @@ async function resolveLocalAgentIdentity(input) {
     nodeQualifier: instance.nodeQualifier,
     harness: effectiveHarness,
     projectRoot,
-    projectName: basename4(projectRoot),
+    projectName: basename5(projectRoot),
     source: configDefinitionId || configDisplayName ? "config" : "new"
   };
 }
@@ -11451,7 +12267,7 @@ async function startLocalAgent(input) {
   }
   if (!matchingOverride) {
     const configDefinitionId = coldProjectConfig?.agent?.id?.trim() ? normalizeAgentSelectorSegment(coldProjectConfig.agent.id.trim()) : "";
-    const definitionId = requestedDefinitionId || configDefinitionId || normalizeAgentSelectorSegment(basename4(projectRoot)) || "agent";
+    const definitionId = requestedDefinitionId || configDefinitionId || normalizeAgentSelectorSegment(basename5(projectRoot)) || "agent";
     const configDisplayName = coldProjectConfig?.agent?.displayName?.trim() || "";
     const effectiveDisplayName = input.displayName || configDisplayName || titleCaseLocalAgentName(definitionId);
     const instance = buildRelayAgentInstance(definitionId, projectRoot);
@@ -11467,7 +12283,7 @@ async function startLocalAgent(input) {
       agentId: instance.id,
       definitionId,
       displayName: effectiveDisplayName,
-      projectName: basename4(projectRoot),
+      projectName: basename5(projectRoot),
       projectRoot,
       projectConfigPath: coldProjectConfigPath,
       source: "manual",
@@ -11503,7 +12319,7 @@ async function startLocalAgent(input) {
       agentId: instance.id,
       definitionId: requestedDefinitionId,
       displayName: input.displayName || titleCaseLocalAgentName(requestedDefinitionId),
-      projectName: matchingOverride.projectName ?? basename4(matchingProjectRoot),
+      projectName: matchingOverride.projectName ?? basename5(matchingProjectRoot),
       projectRoot: matchingProjectRoot,
       projectConfigPath: matchingOverride.projectConfigPath ?? null,
       source: "manual",
@@ -11808,7 +12624,7 @@ async function invokeLocalAgentEndpoint(endpoint, invocation) {
   const requestedHarness = invocation.execution?.harness;
   const record = existing ?? (projectRoot ? {
     definitionId,
-    project: basename4(projectRoot),
+    project: basename5(projectRoot),
     projectRoot,
     tmuxSession: String(endpoint.metadata?.tmuxSession ?? `relay-${agentRuntimeId}`),
     cwd: projectRoot,
@@ -11888,20 +12704,20 @@ var init_local_agents = __esm(async () => {
   init_support_paths();
   init_local_agent_template();
   await init_broker_service();
-  MODULE_DIRECTORY = dirname10(fileURLToPath6(import.meta.url));
+  MODULE_DIRECTORY = dirname11(fileURLToPath6(import.meta.url));
   OPENSCOUT_REPO_ROOT = resolve6(MODULE_DIRECTORY, "..", "..", "..");
   DEFAULT_LOCAL_AGENT_CAPABILITIES = ["chat", "invoke", "deliver"];
   SUPPORTED_LOCAL_AGENT_HARNESSES = ["claude", "codex"];
 });
 
 // packages/web/server/index.ts
-import { existsSync as existsSync13 } from "fs";
-import { dirname as dirname12, join as join20, resolve as resolve9 } from "path";
+import { existsSync as existsSync14 } from "fs";
+import { dirname as dirname13, join as join21, resolve as resolve10 } from "path";
 import { fileURLToPath as fileURLToPath8 } from "url";
 
 // packages/web/server/create-openscout-web-server.ts
-import { existsSync as existsSync11, rmSync as rmSync3 } from "fs";
-import { dirname as dirname11, resolve as resolve8 } from "path";
+import { existsSync as existsSync12, rmSync as rmSync3 } from "fs";
+import { dirname as dirname12, resolve as resolve9 } from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
 
 // node_modules/.bun/hono@4.12.10/node_modules/hono/dist/compose.js
@@ -13457,7 +14273,7 @@ import {
   writeFileSync as writeFileSync3
 } from "fs";
 import { homedir as homedir8 } from "os";
-import { dirname as dirname6, join as join9, resolve as resolve4 } from "path";
+import { dirname as dirname7, join as join9, resolve as resolve4 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 
 // packages/runtime/src/local-config.ts
@@ -13469,7 +14285,7 @@ import {
   writeFileSync as writeFileSync2
 } from "fs";
 import { homedir as homedir7 } from "os";
-import { dirname as dirname5, join as join8 } from "path";
+import { dirname as dirname6, join as join8 } from "path";
 var LOCAL_CONFIG_VERSION = 1;
 var DEFAULT_LOCAL_CONFIG = {
   version: LOCAL_CONFIG_VERSION,
@@ -13523,7 +14339,7 @@ function isValidPort(value) {
 }
 function writeLocalConfig(config) {
   const configPath = localConfigPath();
-  mkdirSync2(dirname5(configPath), { recursive: true });
+  mkdirSync2(dirname6(configPath), { recursive: true });
   const body = JSON.stringify({ ...config, version: LOCAL_CONFIG_VERSION }, null, 2) + `
 `;
   const tmp = `${configPath}.tmp`;
@@ -13983,7 +14799,7 @@ function resolveScoutPairingRuntimeScriptPath() {
   throw new Error("Unable to locate the Scout pair supervisor entrypoint.");
 }
 function resolveOpenScoutWebServerDirectory(moduleUrl = import.meta.url) {
-  return dirname6(fileURLToPath4(moduleUrl));
+  return dirname7(fileURLToPath4(moduleUrl));
 }
 function resolveOpenScoutWebPackageRoot(moduleUrl = import.meta.url) {
   return resolve4(resolveOpenScoutWebServerDirectory(moduleUrl), "..");
@@ -14141,6 +14957,17 @@ async function getScoutWebPairingState(currentDirectory) {
 async function refreshScoutWebPairingState(currentDirectory) {
   return readScoutPairingState(currentDirectory);
 }
+async function getScoutWebPairingSessionSnapshot(sessionId) {
+  if (!isScoutPairingRuntimeRunning()) {
+    return null;
+  }
+  const resolvedConfig = resolveScoutPairingConfig();
+  try {
+    return await withScoutPairingBridgeClient(resolvedConfig.port, async (client) => client.query("session.snapshot", { sessionId }));
+  } catch {
+    return null;
+  }
+}
 async function controlScoutWebPairingService(action, currentDirectory) {
   return serializePairingMutation(async () => {
     switch (action) {
@@ -14679,7 +15506,7 @@ import { join as join12 } from "path";
 // packages/runtime/src/user-config.ts
 import { existsSync as existsSync8, readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4 } from "fs";
 import { homedir as homedir9 } from "os";
-import { dirname as dirname8, join as join11 } from "path";
+import { dirname as dirname9, join as join11 } from "path";
 function userConfigPath() {
   return join11(process.env.OPENSCOUT_HOME ?? join11(homedir9(), ".openscout"), "user.json");
 }
@@ -14695,7 +15522,7 @@ function loadUserConfig() {
 }
 function saveUserConfig(config) {
   const configPath = userConfigPath();
-  mkdirSync4(dirname8(configPath), { recursive: true });
+  mkdirSync4(dirname9(configPath), { recursive: true });
   writeFileSync4(configPath, JSON.stringify(config, null, 2) + `
 `, "utf8");
 }
@@ -15478,7 +16305,10 @@ function querySessions(limit = 80) {
        a.id AS agent_id,
        ac.display_name,
        ep.harness,
+       ep.transport,
        ep.project_root,
+       ep.session_id,
+       ep.metadata_json AS endpoint_metadata_json,
        a.metadata_json
      FROM conversation_members cm
      JOIN agents a ON a.id = cm.actor_id
@@ -15501,6 +16331,8 @@ function querySessions(limit = 80) {
     const stats = statsStmt.get(r.id);
     let agentName = null;
     let harness = null;
+    let harnessSessionId = null;
+    let harnessLogPath = null;
     let branch = null;
     let workspaceRoot = null;
     if (primaryAgent) {
@@ -15514,6 +16346,14 @@ function querySessions(limit = 80) {
         }
         branch = meta.branch ?? meta.workspaceQualifier ?? null;
       } catch {}
+      try {
+        const endpointMeta = primaryAgent.endpoint_metadata_json ? JSON.parse(primaryAgent.endpoint_metadata_json) : {};
+        harnessSessionId = resolveHarnessSessionId(primaryAgent.transport, primaryAgent.session_id, endpointMeta);
+        harnessLogPath = resolveHarnessLogPath(primaryAgent.agent_id, primaryAgent.transport, primaryAgent.session_id, endpointMeta);
+      } catch {
+        harnessSessionId = resolveHarnessSessionId(primaryAgent.transport, primaryAgent.session_id, undefined);
+        harnessLogPath = resolveHarnessLogPath(primaryAgent.agent_id, primaryAgent.transport, primaryAgent.session_id, undefined);
+      }
     }
     const preview = previewStmt.get(r.id)?.body ?? null;
     return [{
@@ -15524,6 +16364,8 @@ function querySessions(limit = 80) {
       agentId,
       agentName,
       harness,
+      harnessSessionId,
+      harnessLogPath,
       currentBranch: branch,
       preview: preview ? preview.slice(0, 200) : null,
       messageCount: stats?.cnt ?? 0,
@@ -15621,23 +16463,30 @@ function parseDirectConversationId(conversationId) {
 }
 function synthesizeDirectSession(conversationId, agentId, operatorId) {
   const agent = db().prepare(`SELECT
-       a.id AS agent_id,
-       ac.display_name,
-       ep.harness,
-       ep.project_root,
-       a.metadata_json
-     FROM agents a
-     JOIN actors ac ON ac.id = a.id
-     ${LATEST_AGENT_ENDPOINT_JOIN}
-     WHERE a.id = ?`).get(agentId);
+        a.id AS agent_id,
+        ac.display_name,
+        ep.harness,
+        ep.transport,
+        ep.project_root,
+       ep.session_id,
+       ep.metadata_json AS endpoint_metadata_json,
+        a.metadata_json
+      FROM agents a
+      JOIN actors ac ON ac.id = a.id
+      ${LATEST_AGENT_ENDPOINT_JOIN}
+      WHERE a.id = ?`).get(agentId);
   if (!agent) {
     return null;
   }
   let currentBranch = null;
+  let endpointMeta = {};
   try {
     const metadata = agent.metadata_json ? JSON.parse(agent.metadata_json) : {};
     currentBranch = metadata.branch ?? metadata.workspaceQualifier ?? null;
   } catch {}
+  try {
+    endpointMeta = agent.endpoint_metadata_json ? JSON.parse(agent.endpoint_metadata_json) : {};
+  } catch {}
   return {
     id: conversationId,
     kind: "direct",
@@ -15646,6 +16495,8 @@ function synthesizeDirectSession(conversationId, agentId, operatorId) {
     agentId,
     agentName: agent.display_name,
     harness: agent.harness,
+    harnessSessionId: resolveHarnessSessionId(agent.transport, agent.session_id, endpointMeta),
+    harnessLogPath: resolveHarnessLogPath(agentId, agent.transport, agent.session_id, endpointMeta),
     currentBranch,
     preview: null,
     messageCount: 0,
@@ -16026,7 +16877,7 @@ init_dist2();
 init_setup();
 init_support_paths();
 await init_local_agents();
-import { basename as basename5, join as join17, resolve as resolve7 } from "path";
+import { basename as basename6, join as join17, resolve as resolve7 } from "path";
 
 // packages/web/server/core/broker/paths.ts
 var scoutBrokerPaths = {
@@ -16943,135 +17794,2913 @@ function whoEntryState(endpoints, registrationKind) {
   }, "offline");
 }
 
-// packages/web/server/core/mesh/service.ts
-await init_broker_service();
+// packages/web/server/core/observe/service.ts
+init_src();
+import { existsSync as existsSync11, readFileSync as readFileSync7, statSync as statSync4 } from "fs";
+import { homedir as homedir12 } from "os";
+import { join as join18, resolve as resolve8 } from "path";
 
-// packages/runtime/src/tailscale.ts
-import { readFile as readFile7 } from "fs/promises";
-import { execFile } from "child_process";
-import { promisify } from "util";
-var execFileAsync = promisify(execFile);
-function parseStatusJson(raw2) {
-  return JSON.parse(raw2);
+// packages/runtime/src/registry.ts
+function createRuntimeRegistrySnapshot(value = {}) {
+  return {
+    nodes: value.nodes ?? {},
+    actors: value.actors ?? {},
+    agents: value.agents ?? {},
+    endpoints: value.endpoints ?? {},
+    conversations: value.conversations ?? {},
+    bindings: value.bindings ?? {},
+    messages: value.messages ?? {},
+    flights: value.flights ?? {},
+    collaborationRecords: value.collaborationRecords ?? {}
+  };
 }
-function parsePeers(status) {
-  const peers = Object.entries(status.Peer ?? {});
-  return peers.map(([fallbackId, peer]) => ({
-    id: peer.ID ?? fallbackId,
-    name: peer.HostName ?? peer.DNSName ?? fallbackId,
-    dnsName: peer.DNSName,
-    addresses: peer.TailscaleIPs ?? [],
-    online: peer.Online ?? false,
-    hostName: peer.HostName,
-    os: peer.OS,
-    tags: peer.Tags ?? []
-  }));
+
+// packages/runtime/src/index.ts
+init_harness_catalog();
+
+// packages/runtime/src/planner.ts
+function createDeliveryId(messageId, targetId, reason, transport) {
+  return `del-${messageId}-${targetId}-${reason}-${transport}`;
 }
-function parseSelf(status) {
-  const self = status.Self;
-  if (!self) {
-    return null;
+function unique(values) {
+  return [...new Set(values)];
+}
+function resolveVisibilityAudience(message, conversation) {
+  if (message.audience?.visibleTo?.length) {
+    return unique(message.audience.visibleTo);
   }
+  return unique(conversation.participantIds.filter((participantId) => participantId !== message.actorId));
+}
+function resolveNotifyAudience(message) {
+  const fromMentions = (message.mentions ?? []).map((mention) => mention.actorId);
+  const explicit = message.audience?.notify ?? [];
+  return unique([...fromMentions, ...explicit].filter((actorId) => actorId !== message.actorId));
+}
+function resolveInvocationAudience(message) {
+  return unique((message.audience?.invoke ?? []).filter((actorId) => actorId !== message.actorId));
+}
+function planTargetDelivery(message, route, reason, policy) {
   return {
-    id: self.ID ?? self.DNSName ?? self.HostName ?? "self",
-    name: self.HostName ?? self.DNSName ?? "self",
-    dnsName: self.DNSName,
-    addresses: self.TailscaleIPs ?? [],
-    online: self.Online ?? true,
-    hostName: self.HostName,
-    os: self.OS,
-    tailnetName: status.CurrentTailnet?.Name,
-    magicDnsSuffix: status.CurrentTailnet?.MagicDNSSuffix
+    id: createDeliveryId(message.id, route.targetId, reason, route.transport),
+    messageId: message.id,
+    targetId: route.targetId,
+    targetNodeId: route.nodeId,
+    targetKind: route.targetKind,
+    transport: route.transport,
+    reason,
+    policy,
+    status: "pending",
+    bindingId: route.bindingId
   };
 }
-async function readStatusJsonFromFile(filePath) {
-  const raw2 = await readFile7(filePath, "utf8");
-  return parseStatusJson(raw2);
+function planMessageDeliveries(input) {
+  const visibilityIds = new Set(resolveVisibilityAudience(input.message, input.conversation));
+  const notifyIds = new Set(resolveNotifyAudience(input.message));
+  const invokeIds = new Set(resolveInvocationAudience(input.message));
+  const deliveries2 = new Map;
+  for (const route of input.participantRoutes) {
+    if (visibilityIds.has(route.targetId)) {
+      const intent = planTargetDelivery(input.message, {
+        ...route,
+        transport: route.nodeId && input.localNodeId && route.nodeId !== input.localNodeId ? "peer_broker" : route.transport
+      }, input.conversation.kind === "direct" || input.conversation.kind === "group_direct" ? "direct_message" : "conversation_visibility", "durable");
+      deliveries2.set(intent.id, intent);
+    }
+    if (notifyIds.has(route.targetId)) {
+      const intent = planTargetDelivery(input.message, {
+        ...route,
+        transport: route.nodeId && input.localNodeId && route.nodeId !== input.localNodeId ? "peer_broker" : route.transport
+      }, "mention", "must_ack");
+      deliveries2.set(intent.id, intent);
+    }
+    if (invokeIds.has(route.targetId)) {
+      const intent = planTargetDelivery(input.message, {
+        ...route,
+        transport: route.nodeId && input.localNodeId && route.nodeId !== input.localNodeId ? "peer_broker" : route.transport
+      }, "invocation", "must_ack");
+      deliveries2.set(intent.id, intent);
+    }
+    if (input.message.speech?.text && route.speechEnabled) {
+      const speechIntent = planTargetDelivery(input.message, {
+        ...route,
+        transport: route.transport === "local_socket" ? "native_voice" : "tts",
+        targetKind: route.targetKind === "device" ? "voice_session" : route.targetKind
+      }, "speech", "best_effort");
+      deliveries2.set(speechIntent.id, speechIntent);
+    }
+  }
+  for (const route of input.bindingRoutes ?? []) {
+    const intent = planTargetDelivery(input.message, route, "bridge_outbound", "durable");
+    deliveries2.set(intent.id, intent);
+  }
+  return [...deliveries2.values()];
+}
+// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/entity.js
+var entityKind = Symbol.for("drizzle:entityKind");
+var hasOwnEntityKind = Symbol.for("drizzle:hasOwnEntityKind");
+function is(value, type) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  if (value instanceof type) {
+    return true;
+  }
+  if (!Object.prototype.hasOwnProperty.call(type, entityKind)) {
+    throw new Error(`Class "${type.name ?? "<unknown>"}" doesn't look like a Drizzle entity. If this is incorrect and the class is provided by Drizzle, please report this as a bug.`);
+  }
+  let cls = Object.getPrototypeOf(value).constructor;
+  if (cls) {
+    while (cls) {
+      if (entityKind in cls && cls[entityKind] === type[entityKind]) {
+        return true;
+      }
+      cls = Object.getPrototypeOf(cls);
+    }
+  }
+  return false;
 }
-async function readStatusJson() {
-  const fixturePath = process.env.OPENSCOUT_TAILSCALE_STATUS_JSON;
-  if (fixturePath) {
-    return readStatusJsonFromFile(fixturePath);
+
+// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/column.js
+class Column {
+  constructor(table, config) {
+    this.table = table;
+    this.config = config;
+    this.name = config.name;
+    this.keyAsName = config.keyAsName;
+    this.notNull = config.notNull;
+    this.default = config.default;
+    this.defaultFn = config.defaultFn;
+    this.onUpdateFn = config.onUpdateFn;
+    this.hasDefault = config.hasDefault;
+    this.primary = config.primaryKey;
+    this.isUnique = config.isUnique;
+    this.uniqueName = config.uniqueName;
+    this.uniqueType = config.uniqueType;
+    this.dataType = config.dataType;
+    this.columnType = config.columnType;
+    this.generated = config.generated;
+    this.generatedIdentity = config.generatedIdentity;
+  }
+  static [entityKind] = "Column";
+  name;
+  keyAsName;
+  primary;
+  notNull;
+  default;
+  defaultFn;
+  onUpdateFn;
+  hasDefault;
+  isUnique;
+  uniqueName;
+  uniqueType;
+  dataType;
+  columnType;
+  enumValues = undefined;
+  generated = undefined;
+  generatedIdentity = undefined;
+  config;
+  mapFromDriverValue(value) {
+    return value;
   }
-  try {
-    const tailscaleBin = process.env.OPENSCOUT_TAILSCALE_BIN ?? "tailscale";
-    const { stdout } = await execFileAsync(tailscaleBin, ["status", "--json"]);
-    return parseStatusJson(stdout);
-  } catch {
-    return null;
+  mapToDriverValue(value) {
+    return value;
+  }
+  shouldDisableInsert() {
+    return this.config.generated !== undefined && this.config.generated.type !== "byDefault";
   }
 }
-async function readTailscalePeers() {
-  const status = await readStatusJson();
-  if (!status) {
-    return [];
+
+// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/column-builder.js
+class ColumnBuilder {
+  static [entityKind] = "ColumnBuilder";
+  config;
+  constructor(name, dataType, columnType) {
+    this.config = {
+      name,
+      keyAsName: name === "",
+      notNull: false,
+      default: undefined,
+      hasDefault: false,
+      primaryKey: false,
+      isUnique: false,
+      uniqueName: undefined,
+      uniqueType: undefined,
+      dataType,
+      columnType,
+      generated: undefined
+    };
+  }
+  $type() {
+    return this;
+  }
+  notNull() {
+    this.config.notNull = true;
+    return this;
+  }
+  default(value) {
+    this.config.default = value;
+    this.config.hasDefault = true;
+    return this;
+  }
+  $defaultFn(fn) {
+    this.config.defaultFn = fn;
+    this.config.hasDefault = true;
+    return this;
+  }
+  $default = this.$defaultFn;
+  $onUpdateFn(fn) {
+    this.config.onUpdateFn = fn;
+    this.config.hasDefault = true;
+    return this;
+  }
+  $onUpdate = this.$onUpdateFn;
+  primaryKey() {
+    this.config.primaryKey = true;
+    this.config.notNull = true;
+    return this;
+  }
+  setName(name) {
+    if (this.config.name !== "")
+      return;
+    this.config.name = name;
   }
-  return parsePeers(status);
 }
-async function readTailscaleSelf() {
-  const status = await readStatusJson();
-  if (!status) {
-    return null;
+
+// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/table.utils.js
+var TableName = Symbol.for("drizzle:Name");
+
+// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/tracing-utils.js
+function iife(fn, ...args) {
+  return fn(...args);
+}
+
+// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/pg-core/unique-constraint.js
+function uniqueKeyName(table, columns) {
+  return `${table[TableName]}_${columns.join("_")}_unique`;
+}
+
+// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/pg-core/columns/common.js
+class PgColumn extends Column {
+  constructor(table, config) {
+    if (!config.uniqueName) {
+      config.uniqueName = uniqueKeyName(table, [config.name]);
+    }
+    super(table, config);
+    this.table = table;
   }
-  return parseSelf(status);
+  static [entityKind] = "PgColumn";
 }
 
-// packages/web/server/core/mesh/service.ts
-function normalizeHost(host) {
-  return host.trim().replace(/^\[/, "").replace(/\]$/, "").toLowerCase();
+class ExtraConfigColumn extends PgColumn {
+  static [entityKind] = "ExtraConfigColumn";
+  getSQLType() {
+    return this.getSQLType();
+  }
+  indexConfig = {
+    order: this.config.order ?? "asc",
+    nulls: this.config.nulls ?? "last",
+    opClass: this.config.opClass
+  };
+  defaultConfig = {
+    order: "asc",
+    nulls: "last",
+    opClass: undefined
+  };
+  asc() {
+    this.indexConfig.order = "asc";
+    return this;
+  }
+  desc() {
+    this.indexConfig.order = "desc";
+    return this;
+  }
+  nullsFirst() {
+    this.indexConfig.nulls = "first";
+    return this;
+  }
+  nullsLast() {
+    this.indexConfig.nulls = "last";
+    return this;
+  }
+  op(opClass) {
+    this.indexConfig.opClass = opClass;
+    return this;
+  }
 }
-function isLoopbackHost(host) {
-  const normalized = normalizeHost(host);
-  return normalized === "127.0.0.1" || normalized === "::1" || normalized === "localhost";
+
+// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/pg-core/columns/enum.js
+class PgEnumObjectColumn extends PgColumn {
+  static [entityKind] = "PgEnumObjectColumn";
+  enum;
+  enumValues = this.config.enum.enumValues;
+  constructor(table, config) {
+    super(table, config);
+    this.enum = config.enum;
+  }
+  getSQLType() {
+    return this.enum.enumName;
+  }
 }
-function isWildcardHost(host) {
-  const normalized = normalizeHost(host);
-  return normalized === "0.0.0.0" || normalized === "::";
+var isPgEnumSym = Symbol.for("drizzle:isPgEnum");
+function isPgEnum(obj) {
+  return !!obj && typeof obj === "function" && isPgEnumSym in obj && obj[isPgEnumSym] === true;
 }
-function isPeerReachableBrokerUrl(url) {
-  if (!url) {
-    return false;
+class PgEnumColumn extends PgColumn {
+  static [entityKind] = "PgEnumColumn";
+  enum = this.config.enum;
+  enumValues = this.config.enum.enumValues;
+  constructor(table, config) {
+    super(table, config);
+    this.enum = config.enum;
   }
-  try {
-    const hostname2 = new URL(url).hostname;
-    return !isLoopbackHost(hostname2) && !isWildcardHost(hostname2);
-  } catch {
-    return false;
+  getSQLType() {
+    return this.enum.enumName;
   }
 }
-function stripTrailingDot(value) {
-  const trimmed = value?.trim();
-  if (!trimmed) {
-    return null;
+
+// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/subquery.js
+class Subquery {
+  static [entityKind] = "Subquery";
+  constructor(sql, fields, alias, isWith = false, usedTables = []) {
+    this._ = {
+      brand: "Subquery",
+      sql,
+      selectedFields: fields,
+      alias,
+      isWith,
+      usedTables
+    };
   }
-  return trimmed.replace(/\.$/, "");
 }
-async function readTailscaleStatus() {
-  const peers = await readTailscalePeers();
-  return {
-    available: peers.length > 0,
-    peers,
-    onlineCount: peers.filter((p) => p.online).length
+
+// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/version.js
+var version = "0.45.2";
+
+// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/tracing.js
+var otel;
+var rawTracer;
+var tracer = {
+  startActiveSpan(name, fn) {
+    if (!otel) {
+      return fn();
+    }
+    if (!rawTracer) {
+      rawTracer = otel.trace.getTracer("drizzle-orm", version);
+    }
+    return iife((otel2, rawTracer2) => rawTracer2.startActiveSpan(name, (span) => {
+      try {
+        return fn(span);
+      } catch (e) {
+        span.setStatus({
+          code: otel2.SpanStatusCode.ERROR,
+          message: e instanceof Error ? e.message : "Unknown error"
+        });
+        throw e;
+      } finally {
+        span.end();
+      }
+    }), otel, rawTracer);
+  }
+};
+
+// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/view-common.js
+var ViewBaseConfig = Symbol.for("drizzle:ViewBaseConfig");
+
+// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/table.js
+var Schema = Symbol.for("drizzle:Schema");
+var Columns = Symbol.for("drizzle:Columns");
+var ExtraConfigColumns = Symbol.for("drizzle:ExtraConfigColumns");
+var OriginalName = Symbol.for("drizzle:OriginalName");
+var BaseName = Symbol.for("drizzle:BaseName");
+var IsAlias = Symbol.for("drizzle:IsAlias");
+var ExtraConfigBuilder = Symbol.for("drizzle:ExtraConfigBuilder");
+var IsDrizzleTable = Symbol.for("drizzle:IsDrizzleTable");
+
+class Table {
+  static [entityKind] = "Table";
+  static Symbol = {
+    Name: TableName,
+    Schema,
+    OriginalName,
+    Columns,
+    ExtraConfigColumns,
+    BaseName,
+    IsAlias,
+    ExtraConfigBuilder
   };
+  [TableName];
+  [OriginalName];
+  [Schema];
+  [Columns];
+  [ExtraConfigColumns];
+  [BaseName];
+  [IsAlias] = false;
+  [IsDrizzleTable] = true;
+  [ExtraConfigBuilder] = undefined;
+  constructor(name, schema, baseName) {
+    this[TableName] = this[OriginalName] = name;
+    this[Schema] = schema;
+    this[BaseName] = baseName;
+  }
 }
-function formatIssueWarning(issue) {
-  return issue.action ? `${issue.title} \u2014 ${issue.summary} ${issue.action}` : `${issue.title} \u2014 ${issue.summary}`;
+
+// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sql/sql.js
+function isSQLWrapper(value) {
+  return value !== null && value !== undefined && typeof value.getSQL === "function";
 }
-function computeIssues(health, localNode, nodes, tailscale) {
-  const issues = [];
-  if (!health.reachable) {
-    issues.push({
-      code: "broker_unreachable",
-      severity: "error",
-      title: "Broker not reachable",
-      summary: "The mesh page cannot reach the local broker yet, so peer status is incomplete.",
-      action: "Start the broker, then reload this page.",
-      actionCommand: null
-    });
-    return issues;
+function mergeQueries(queries) {
+  const result = { sql: "", params: [] };
+  for (const query of queries) {
+    result.sql += query.sql;
+    result.params.push(...query.params);
+    if (query.typings?.length) {
+      if (!result.typings) {
+        result.typings = [];
+      }
+      result.typings.push(...query.typings);
+    }
   }
-  if (localNode?.advertiseScope === "local") {
-    issues.push({
+  return result;
+}
+
+class StringChunk {
+  static [entityKind] = "StringChunk";
+  value;
+  constructor(value) {
+    this.value = Array.isArray(value) ? value : [value];
+  }
+  getSQL() {
+    return new SQL([this]);
+  }
+}
+
+class SQL {
+  constructor(queryChunks) {
+    this.queryChunks = queryChunks;
+    for (const chunk of queryChunks) {
+      if (is(chunk, Table)) {
+        const schemaName = chunk[Table.Symbol.Schema];
+        this.usedTables.push(schemaName === undefined ? chunk[Table.Symbol.Name] : schemaName + "." + chunk[Table.Symbol.Name]);
+      }
+    }
+  }
+  static [entityKind] = "SQL";
+  decoder = noopDecoder;
+  shouldInlineParams = false;
+  usedTables = [];
+  append(query) {
+    this.queryChunks.push(...query.queryChunks);
+    return this;
+  }
+  toQuery(config) {
+    return tracer.startActiveSpan("drizzle.buildSQL", (span) => {
+      const query = this.buildQueryFromSourceParams(this.queryChunks, config);
+      span?.setAttributes({
+        "drizzle.query.text": query.sql,
+        "drizzle.query.params": JSON.stringify(query.params)
+      });
+      return query;
+    });
+  }
+  buildQueryFromSourceParams(chunks, _config) {
+    const config = Object.assign({}, _config, {
+      inlineParams: _config.inlineParams || this.shouldInlineParams,
+      paramStartIndex: _config.paramStartIndex || { value: 0 }
+    });
+    const {
+      casing,
+      escapeName,
+      escapeParam,
+      prepareTyping,
+      inlineParams,
+      paramStartIndex
+    } = config;
+    return mergeQueries(chunks.map((chunk) => {
+      if (is(chunk, StringChunk)) {
+        return { sql: chunk.value.join(""), params: [] };
+      }
+      if (is(chunk, Name)) {
+        return { sql: escapeName(chunk.value), params: [] };
+      }
+      if (chunk === undefined) {
+        return { sql: "", params: [] };
+      }
+      if (Array.isArray(chunk)) {
+        const result = [new StringChunk("(")];
+        for (const [i, p] of chunk.entries()) {
+          result.push(p);
+          if (i < chunk.length - 1) {
+            result.push(new StringChunk(", "));
+          }
+        }
+        result.push(new StringChunk(")"));
+        return this.buildQueryFromSourceParams(result, config);
+      }
+      if (is(chunk, SQL)) {
+        return this.buildQueryFromSourceParams(chunk.queryChunks, {
+          ...config,
+          inlineParams: inlineParams || chunk.shouldInlineParams
+        });
+      }
+      if (is(chunk, Table)) {
+        const schemaName = chunk[Table.Symbol.Schema];
+        const tableName = chunk[Table.Symbol.Name];
+        return {
+          sql: schemaName === undefined || chunk[IsAlias] ? escapeName(tableName) : escapeName(schemaName) + "." + escapeName(tableName),
+          params: []
+        };
+      }
+      if (is(chunk, Column)) {
+        const columnName = casing.getColumnCasing(chunk);
+        if (_config.invokeSource === "indexes") {
+          return { sql: escapeName(columnName), params: [] };
+        }
+        const schemaName = chunk.table[Table.Symbol.Schema];
+        return {
+          sql: chunk.table[IsAlias] || schemaName === undefined ? escapeName(chunk.table[Table.Symbol.Name]) + "." + escapeName(columnName) : escapeName(schemaName) + "." + escapeName(chunk.table[Table.Symbol.Name]) + "." + escapeName(columnName),
+          params: []
+        };
+      }
+      if (is(chunk, View)) {
+        const schemaName = chunk[ViewBaseConfig].schema;
+        const viewName = chunk[ViewBaseConfig].name;
+        return {
+          sql: schemaName === undefined || chunk[ViewBaseConfig].isAlias ? escapeName(viewName) : escapeName(schemaName) + "." + escapeName(viewName),
+          params: []
+        };
+      }
+      if (is(chunk, Param)) {
+        if (is(chunk.value, Placeholder)) {
+          return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
+        }
+        const mappedValue = chunk.value === null ? null : chunk.encoder.mapToDriverValue(chunk.value);
+        if (is(mappedValue, SQL)) {
+          return this.buildQueryFromSourceParams([mappedValue], config);
+        }
+        if (inlineParams) {
+          return { sql: this.mapInlineParam(mappedValue, config), params: [] };
+        }
+        let typings = ["none"];
+        if (prepareTyping) {
+          typings = [prepareTyping(chunk.encoder)];
+        }
+        return { sql: escapeParam(paramStartIndex.value++, mappedValue), params: [mappedValue], typings };
+      }
+      if (is(chunk, Placeholder)) {
+        return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
+      }
+      if (is(chunk, SQL.Aliased) && chunk.fieldAlias !== undefined) {
+        return { sql: escapeName(chunk.fieldAlias), params: [] };
+      }
+      if (is(chunk, Subquery)) {
+        if (chunk._.isWith) {
+          return { sql: escapeName(chunk._.alias), params: [] };
+        }
+        return this.buildQueryFromSourceParams([
+          new StringChunk("("),
+          chunk._.sql,
+          new StringChunk(") "),
+          new Name(chunk._.alias)
+        ], config);
+      }
+      if (isPgEnum(chunk)) {
+        if (chunk.schema) {
+          return { sql: escapeName(chunk.schema) + "." + escapeName(chunk.enumName), params: [] };
+        }
+        return { sql: escapeName(chunk.enumName), params: [] };
+      }
+      if (isSQLWrapper(chunk)) {
+        if (chunk.shouldOmitSQLParens?.()) {
+          return this.buildQueryFromSourceParams([chunk.getSQL()], config);
+        }
+        return this.buildQueryFromSourceParams([
+          new StringChunk("("),
+          chunk.getSQL(),
+          new StringChunk(")")
+        ], config);
+      }
+      if (inlineParams) {
+        return { sql: this.mapInlineParam(chunk, config), params: [] };
+      }
+      return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
+    }));
+  }
+  mapInlineParam(chunk, { escapeString }) {
+    if (chunk === null) {
+      return "null";
+    }
+    if (typeof chunk === "number" || typeof chunk === "boolean") {
+      return chunk.toString();
+    }
+    if (typeof chunk === "string") {
+      return escapeString(chunk);
+    }
+    if (typeof chunk === "object") {
+      const mappedValueAsString = chunk.toString();
+      if (mappedValueAsString === "[object Object]") {
+        return escapeString(JSON.stringify(chunk));
+      }
+      return escapeString(mappedValueAsString);
+    }
+    throw new Error("Unexpected param value: " + chunk);
+  }
+  getSQL() {
+    return this;
+  }
+  as(alias) {
+    if (alias === undefined) {
+      return this;
+    }
+    return new SQL.Aliased(this, alias);
+  }
+  mapWith(decoder) {
+    this.decoder = typeof decoder === "function" ? { mapFromDriverValue: decoder } : decoder;
+    return this;
+  }
+  inlineParams() {
+    this.shouldInlineParams = true;
+    return this;
+  }
+  if(condition) {
+    return condition ? this : undefined;
+  }
+}
+
+class Name {
+  constructor(value) {
+    this.value = value;
+  }
+  static [entityKind] = "Name";
+  brand;
+  getSQL() {
+    return new SQL([this]);
+  }
+}
+var noopDecoder = {
+  mapFromDriverValue: (value) => value
+};
+var noopEncoder = {
+  mapToDriverValue: (value) => value
+};
+var noopMapper = {
+  ...noopDecoder,
+  ...noopEncoder
+};
+
+class Param {
+  constructor(value, encoder = noopEncoder) {
+    this.value = value;
+    this.encoder = encoder;
+  }
+  static [entityKind] = "Param";
+  brand;
+  getSQL() {
+    return new SQL([this]);
+  }
+}
+function sql(strings, ...params) {
+  const queryChunks = [];
+  if (params.length > 0 || strings.length > 0 && strings[0] !== "") {
+    queryChunks.push(new StringChunk(strings[0]));
+  }
+  for (const [paramIndex, param2] of params.entries()) {
+    queryChunks.push(param2, new StringChunk(strings[paramIndex + 1]));
+  }
+  return new SQL(queryChunks);
+}
+((sql2) => {
+  function empty() {
+    return new SQL([]);
+  }
+  sql2.empty = empty;
+  function fromList(list) {
+    return new SQL(list);
+  }
+  sql2.fromList = fromList;
+  function raw2(str) {
+    return new SQL([new StringChunk(str)]);
+  }
+  sql2.raw = raw2;
+  function join18(chunks, separator) {
+    const result = [];
+    for (const [i, chunk] of chunks.entries()) {
+      if (i > 0 && separator !== undefined) {
+        result.push(separator);
+      }
+      result.push(chunk);
+    }
+    return new SQL(result);
+  }
+  sql2.join = join18;
+  function identifier(value) {
+    return new Name(value);
+  }
+  sql2.identifier = identifier;
+  function placeholder2(name2) {
+    return new Placeholder(name2);
+  }
+  sql2.placeholder = placeholder2;
+  function param2(value, encoder) {
+    return new Param(value, encoder);
+  }
+  sql2.param = param2;
+})(sql || (sql = {}));
+((SQL2) => {
+
+  class Aliased {
+    constructor(sql2, fieldAlias) {
+      this.sql = sql2;
+      this.fieldAlias = fieldAlias;
+    }
+    static [entityKind] = "SQL.Aliased";
+    isSelectionField = false;
+    getSQL() {
+      return this.sql;
+    }
+    clone() {
+      return new Aliased(this.sql, this.fieldAlias);
+    }
+  }
+  SQL2.Aliased = Aliased;
+})(SQL || (SQL = {}));
+
+class Placeholder {
+  constructor(name2) {
+    this.name = name2;
+  }
+  static [entityKind] = "Placeholder";
+  getSQL() {
+    return new SQL([this]);
+  }
+}
+var IsDrizzleView = Symbol.for("drizzle:IsDrizzleView");
+
+class View {
+  static [entityKind] = "View";
+  [ViewBaseConfig];
+  [IsDrizzleView] = true;
+  constructor({ name: name2, schema, selectedFields, query }) {
+    this[ViewBaseConfig] = {
+      name: name2,
+      originalName: name2,
+      schema,
+      selectedFields,
+      query,
+      isExisting: !query,
+      isAlias: false
+    };
+  }
+  getSQL() {
+    return new SQL([this]);
+  }
+}
+Column.prototype.getSQL = function() {
+  return new SQL([this]);
+};
+Table.prototype.getSQL = function() {
+  return new SQL([this]);
+};
+Subquery.prototype.getSQL = function() {
+  return new SQL([this]);
+};
+
+// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/utils.js
+function getColumnNameAndConfig(a, b) {
+  return {
+    name: typeof a === "string" && a.length > 0 ? a : "",
+    config: typeof a === "object" ? a : b
+  };
+}
+var textDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder;
+
+// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/foreign-keys.js
+class ForeignKeyBuilder {
+  static [entityKind] = "SQLiteForeignKeyBuilder";
+  reference;
+  _onUpdate;
+  _onDelete;
+  constructor(config, actions) {
+    this.reference = () => {
+      const { name, columns, foreignColumns } = config();
+      return { name, columns, foreignTable: foreignColumns[0].table, foreignColumns };
+    };
+    if (actions) {
+      this._onUpdate = actions.onUpdate;
+      this._onDelete = actions.onDelete;
+    }
+  }
+  onUpdate(action) {
+    this._onUpdate = action;
+    return this;
+  }
+  onDelete(action) {
+    this._onDelete = action;
+    return this;
+  }
+  build(table) {
+    return new ForeignKey(table, this);
+  }
+}
+
+class ForeignKey {
+  constructor(table, builder) {
+    this.table = table;
+    this.reference = builder.reference;
+    this.onUpdate = builder._onUpdate;
+    this.onDelete = builder._onDelete;
+  }
+  static [entityKind] = "SQLiteForeignKey";
+  reference;
+  onUpdate;
+  onDelete;
+  getName() {
+    const { name, columns, foreignColumns } = this.reference();
+    const columnNames = columns.map((column) => column.name);
+    const foreignColumnNames = foreignColumns.map((column) => column.name);
+    const chunks = [
+      this.table[TableName],
+      ...columnNames,
+      foreignColumns[0].table[TableName],
+      ...foreignColumnNames
+    ];
+    return name ?? `${chunks.join("_")}_fk`;
+  }
+}
+
+// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/unique-constraint.js
+function uniqueKeyName2(table, columns) {
+  return `${table[TableName]}_${columns.join("_")}_unique`;
+}
+
+// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/columns/common.js
+class SQLiteColumnBuilder extends ColumnBuilder {
+  static [entityKind] = "SQLiteColumnBuilder";
+  foreignKeyConfigs = [];
+  references(ref, actions = {}) {
+    this.foreignKeyConfigs.push({ ref, actions });
+    return this;
+  }
+  unique(name) {
+    this.config.isUnique = true;
+    this.config.uniqueName = name;
+    return this;
+  }
+  generatedAlwaysAs(as, config) {
+    this.config.generated = {
+      as,
+      type: "always",
+      mode: config?.mode ?? "virtual"
+    };
+    return this;
+  }
+  buildForeignKeys(column, table) {
+    return this.foreignKeyConfigs.map(({ ref, actions }) => {
+      return ((ref2, actions2) => {
+        const builder = new ForeignKeyBuilder(() => {
+          const foreignColumn = ref2();
+          return { columns: [column], foreignColumns: [foreignColumn] };
+        });
+        if (actions2.onUpdate) {
+          builder.onUpdate(actions2.onUpdate);
+        }
+        if (actions2.onDelete) {
+          builder.onDelete(actions2.onDelete);
+        }
+        return builder.build(table);
+      })(ref, actions);
+    });
+  }
+}
+
+class SQLiteColumn extends Column {
+  constructor(table, config) {
+    if (!config.uniqueName) {
+      config.uniqueName = uniqueKeyName2(table, [config.name]);
+    }
+    super(table, config);
+    this.table = table;
+  }
+  static [entityKind] = "SQLiteColumn";
+}
+
+// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/columns/blob.js
+class SQLiteBigIntBuilder extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteBigIntBuilder";
+  constructor(name) {
+    super(name, "bigint", "SQLiteBigInt");
+  }
+  build(table) {
+    return new SQLiteBigInt(table, this.config);
+  }
+}
+
+class SQLiteBigInt extends SQLiteColumn {
+  static [entityKind] = "SQLiteBigInt";
+  getSQLType() {
+    return "blob";
+  }
+  mapFromDriverValue(value) {
+    if (typeof Buffer !== "undefined" && Buffer.from) {
+      const buf = Buffer.isBuffer(value) ? value : value instanceof ArrayBuffer ? Buffer.from(value) : value.buffer ? Buffer.from(value.buffer, value.byteOffset, value.byteLength) : Buffer.from(value);
+      return BigInt(buf.toString("utf8"));
+    }
+    return BigInt(textDecoder.decode(value));
+  }
+  mapToDriverValue(value) {
+    return Buffer.from(value.toString());
+  }
+}
+
+class SQLiteBlobJsonBuilder extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteBlobJsonBuilder";
+  constructor(name) {
+    super(name, "json", "SQLiteBlobJson");
+  }
+  build(table) {
+    return new SQLiteBlobJson(table, this.config);
+  }
+}
+
+class SQLiteBlobJson extends SQLiteColumn {
+  static [entityKind] = "SQLiteBlobJson";
+  getSQLType() {
+    return "blob";
+  }
+  mapFromDriverValue(value) {
+    if (typeof Buffer !== "undefined" && Buffer.from) {
+      const buf = Buffer.isBuffer(value) ? value : value instanceof ArrayBuffer ? Buffer.from(value) : value.buffer ? Buffer.from(value.buffer, value.byteOffset, value.byteLength) : Buffer.from(value);
+      return JSON.parse(buf.toString("utf8"));
+    }
+    return JSON.parse(textDecoder.decode(value));
+  }
+  mapToDriverValue(value) {
+    return Buffer.from(JSON.stringify(value));
+  }
+}
+
+class SQLiteBlobBufferBuilder extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteBlobBufferBuilder";
+  constructor(name) {
+    super(name, "buffer", "SQLiteBlobBuffer");
+  }
+  build(table) {
+    return new SQLiteBlobBuffer(table, this.config);
+  }
+}
+
+class SQLiteBlobBuffer extends SQLiteColumn {
+  static [entityKind] = "SQLiteBlobBuffer";
+  mapFromDriverValue(value) {
+    if (Buffer.isBuffer(value)) {
+      return value;
+    }
+    return Buffer.from(value);
+  }
+  getSQLType() {
+    return "blob";
+  }
+}
+function blob(a, b) {
+  const { name, config } = getColumnNameAndConfig(a, b);
+  if (config?.mode === "json") {
+    return new SQLiteBlobJsonBuilder(name);
+  }
+  if (config?.mode === "bigint") {
+    return new SQLiteBigIntBuilder(name);
+  }
+  return new SQLiteBlobBufferBuilder(name);
+}
+
+// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/columns/custom.js
+class SQLiteCustomColumnBuilder extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteCustomColumnBuilder";
+  constructor(name, fieldConfig, customTypeParams) {
+    super(name, "custom", "SQLiteCustomColumn");
+    this.config.fieldConfig = fieldConfig;
+    this.config.customTypeParams = customTypeParams;
+  }
+  build(table) {
+    return new SQLiteCustomColumn(table, this.config);
+  }
+}
+
+class SQLiteCustomColumn extends SQLiteColumn {
+  static [entityKind] = "SQLiteCustomColumn";
+  sqlName;
+  mapTo;
+  mapFrom;
+  constructor(table, config) {
+    super(table, config);
+    this.sqlName = config.customTypeParams.dataType(config.fieldConfig);
+    this.mapTo = config.customTypeParams.toDriver;
+    this.mapFrom = config.customTypeParams.fromDriver;
+  }
+  getSQLType() {
+    return this.sqlName;
+  }
+  mapFromDriverValue(value) {
+    return typeof this.mapFrom === "function" ? this.mapFrom(value) : value;
+  }
+  mapToDriverValue(value) {
+    return typeof this.mapTo === "function" ? this.mapTo(value) : value;
+  }
+}
+function customType(customTypeParams) {
+  return (a, b) => {
+    const { name, config } = getColumnNameAndConfig(a, b);
+    return new SQLiteCustomColumnBuilder(name, config, customTypeParams);
+  };
+}
+
+// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/columns/integer.js
+class SQLiteBaseIntegerBuilder extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteBaseIntegerBuilder";
+  constructor(name, dataType, columnType) {
+    super(name, dataType, columnType);
+    this.config.autoIncrement = false;
+  }
+  primaryKey(config) {
+    if (config?.autoIncrement) {
+      this.config.autoIncrement = true;
+    }
+    this.config.hasDefault = true;
+    return super.primaryKey();
+  }
+}
+
+class SQLiteBaseInteger extends SQLiteColumn {
+  static [entityKind] = "SQLiteBaseInteger";
+  autoIncrement = this.config.autoIncrement;
+  getSQLType() {
+    return "integer";
+  }
+}
+
+class SQLiteIntegerBuilder extends SQLiteBaseIntegerBuilder {
+  static [entityKind] = "SQLiteIntegerBuilder";
+  constructor(name) {
+    super(name, "number", "SQLiteInteger");
+  }
+  build(table) {
+    return new SQLiteInteger(table, this.config);
+  }
+}
+
+class SQLiteInteger extends SQLiteBaseInteger {
+  static [entityKind] = "SQLiteInteger";
+}
+
+class SQLiteTimestampBuilder extends SQLiteBaseIntegerBuilder {
+  static [entityKind] = "SQLiteTimestampBuilder";
+  constructor(name, mode) {
+    super(name, "date", "SQLiteTimestamp");
+    this.config.mode = mode;
+  }
+  defaultNow() {
+    return this.default(sql`(cast((julianday('now') - 2440587.5)*86400000 as integer))`);
+  }
+  build(table) {
+    return new SQLiteTimestamp(table, this.config);
+  }
+}
+
+class SQLiteTimestamp extends SQLiteBaseInteger {
+  static [entityKind] = "SQLiteTimestamp";
+  mode = this.config.mode;
+  mapFromDriverValue(value) {
+    if (this.config.mode === "timestamp") {
+      return new Date(value * 1000);
+    }
+    return new Date(value);
+  }
+  mapToDriverValue(value) {
+    const unix = value.getTime();
+    if (this.config.mode === "timestamp") {
+      return Math.floor(unix / 1000);
+    }
+    return unix;
+  }
+}
+
+class SQLiteBooleanBuilder extends SQLiteBaseIntegerBuilder {
+  static [entityKind] = "SQLiteBooleanBuilder";
+  constructor(name, mode) {
+    super(name, "boolean", "SQLiteBoolean");
+    this.config.mode = mode;
+  }
+  build(table) {
+    return new SQLiteBoolean(table, this.config);
+  }
+}
+
+class SQLiteBoolean extends SQLiteBaseInteger {
+  static [entityKind] = "SQLiteBoolean";
+  mode = this.config.mode;
+  mapFromDriverValue(value) {
+    return Number(value) === 1;
+  }
+  mapToDriverValue(value) {
+    return value ? 1 : 0;
+  }
+}
+function integer(a, b) {
+  const { name, config } = getColumnNameAndConfig(a, b);
+  if (config?.mode === "timestamp" || config?.mode === "timestamp_ms") {
+    return new SQLiteTimestampBuilder(name, config.mode);
+  }
+  if (config?.mode === "boolean") {
+    return new SQLiteBooleanBuilder(name, config.mode);
+  }
+  return new SQLiteIntegerBuilder(name);
+}
+
+// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/columns/numeric.js
+class SQLiteNumericBuilder extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteNumericBuilder";
+  constructor(name) {
+    super(name, "string", "SQLiteNumeric");
+  }
+  build(table) {
+    return new SQLiteNumeric(table, this.config);
+  }
+}
+
+class SQLiteNumeric extends SQLiteColumn {
+  static [entityKind] = "SQLiteNumeric";
+  mapFromDriverValue(value) {
+    if (typeof value === "string")
+      return value;
+    return String(value);
+  }
+  getSQLType() {
+    return "numeric";
+  }
+}
+
+class SQLiteNumericNumberBuilder extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteNumericNumberBuilder";
+  constructor(name) {
+    super(name, "number", "SQLiteNumericNumber");
+  }
+  build(table) {
+    return new SQLiteNumericNumber(table, this.config);
+  }
+}
+
+class SQLiteNumericNumber extends SQLiteColumn {
+  static [entityKind] = "SQLiteNumericNumber";
+  mapFromDriverValue(value) {
+    if (typeof value === "number")
+      return value;
+    return Number(value);
+  }
+  mapToDriverValue = String;
+  getSQLType() {
+    return "numeric";
+  }
+}
+
+class SQLiteNumericBigIntBuilder extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteNumericBigIntBuilder";
+  constructor(name) {
+    super(name, "bigint", "SQLiteNumericBigInt");
+  }
+  build(table) {
+    return new SQLiteNumericBigInt(table, this.config);
+  }
+}
+
+class SQLiteNumericBigInt extends SQLiteColumn {
+  static [entityKind] = "SQLiteNumericBigInt";
+  mapFromDriverValue = BigInt;
+  mapToDriverValue = String;
+  getSQLType() {
+    return "numeric";
+  }
+}
+function numeric(a, b) {
+  const { name, config } = getColumnNameAndConfig(a, b);
+  const mode = config?.mode;
+  return mode === "number" ? new SQLiteNumericNumberBuilder(name) : mode === "bigint" ? new SQLiteNumericBigIntBuilder(name) : new SQLiteNumericBuilder(name);
+}
+
+// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/columns/real.js
+class SQLiteRealBuilder extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteRealBuilder";
+  constructor(name) {
+    super(name, "number", "SQLiteReal");
+  }
+  build(table) {
+    return new SQLiteReal(table, this.config);
+  }
+}
+
+class SQLiteReal extends SQLiteColumn {
+  static [entityKind] = "SQLiteReal";
+  getSQLType() {
+    return "real";
+  }
+}
+function real(name) {
+  return new SQLiteRealBuilder(name ?? "");
+}
+
+// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/columns/text.js
+class SQLiteTextBuilder extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteTextBuilder";
+  constructor(name, config) {
+    super(name, "string", "SQLiteText");
+    this.config.enumValues = config.enum;
+    this.config.length = config.length;
+  }
+  build(table) {
+    return new SQLiteText(table, this.config);
+  }
+}
+
+class SQLiteText extends SQLiteColumn {
+  static [entityKind] = "SQLiteText";
+  enumValues = this.config.enumValues;
+  length = this.config.length;
+  constructor(table, config) {
+    super(table, config);
+  }
+  getSQLType() {
+    return `text${this.config.length ? `(${this.config.length})` : ""}`;
+  }
+}
+
+class SQLiteTextJsonBuilder extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteTextJsonBuilder";
+  constructor(name) {
+    super(name, "json", "SQLiteTextJson");
+  }
+  build(table) {
+    return new SQLiteTextJson(table, this.config);
+  }
+}
+
+class SQLiteTextJson extends SQLiteColumn {
+  static [entityKind] = "SQLiteTextJson";
+  getSQLType() {
+    return "text";
+  }
+  mapFromDriverValue(value) {
+    return JSON.parse(value);
+  }
+  mapToDriverValue(value) {
+    return JSON.stringify(value);
+  }
+}
+function text(a, b = {}) {
+  const { name, config } = getColumnNameAndConfig(a, b);
+  if (config.mode === "json") {
+    return new SQLiteTextJsonBuilder(name);
+  }
+  return new SQLiteTextBuilder(name, config);
+}
+
+// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/columns/all.js
+function getSQLiteColumnBuilders() {
+  return {
+    blob,
+    customType,
+    integer,
+    numeric,
+    real,
+    text
+  };
+}
+
+// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/table.js
+var InlineForeignKeys = Symbol.for("drizzle:SQLiteInlineForeignKeys");
+
+class SQLiteTable extends Table {
+  static [entityKind] = "SQLiteTable";
+  static Symbol = Object.assign({}, Table.Symbol, {
+    InlineForeignKeys
+  });
+  [Table.Symbol.Columns];
+  [InlineForeignKeys] = [];
+  [Table.Symbol.ExtraConfigBuilder] = undefined;
+}
+function sqliteTableBase(name, columns, extraConfig, schema, baseName = name) {
+  const rawTable = new SQLiteTable(name, schema, baseName);
+  const parsedColumns = typeof columns === "function" ? columns(getSQLiteColumnBuilders()) : columns;
+  const builtColumns = Object.fromEntries(Object.entries(parsedColumns).map(([name2, colBuilderBase]) => {
+    const colBuilder = colBuilderBase;
+    colBuilder.setName(name2);
+    const column = colBuilder.build(rawTable);
+    rawTable[InlineForeignKeys].push(...colBuilder.buildForeignKeys(column, rawTable));
+    return [name2, column];
+  }));
+  const table = Object.assign(rawTable, builtColumns);
+  table[Table.Symbol.Columns] = builtColumns;
+  table[Table.Symbol.ExtraConfigColumns] = builtColumns;
+  if (extraConfig) {
+    table[SQLiteTable.Symbol.ExtraConfigBuilder] = extraConfig;
+  }
+  return table;
+}
+var sqliteTable = (name, columns, extraConfig) => {
+  return sqliteTableBase(name, columns, extraConfig);
+};
+
+// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/indexes.js
+class IndexBuilderOn {
+  constructor(name, unique2) {
+    this.name = name;
+    this.unique = unique2;
+  }
+  static [entityKind] = "SQLiteIndexBuilderOn";
+  on(...columns) {
+    return new IndexBuilder(this.name, columns, this.unique);
+  }
+}
+
+class IndexBuilder {
+  static [entityKind] = "SQLiteIndexBuilder";
+  config;
+  constructor(name, columns, unique2) {
+    this.config = {
+      name,
+      columns,
+      unique: unique2,
+      where: undefined
+    };
+  }
+  where(condition) {
+    this.config.where = condition;
+    return this;
+  }
+  build(table) {
+    return new Index(this.config, table);
+  }
+}
+
+class Index {
+  static [entityKind] = "SQLiteIndex";
+  config;
+  constructor(config, table) {
+    this.config = { ...config, table };
+  }
+}
+function index(name) {
+  return new IndexBuilderOn(name, false);
+}
+
+// packages/runtime/src/drizzle-schema.ts
+var deliveriesTable = sqliteTable("deliveries", {
+  id: text("id").primaryKey(),
+  messageId: text("message_id"),
+  invocationId: text("invocation_id"),
+  targetId: text("target_id").notNull(),
+  targetNodeId: text("target_node_id"),
+  targetKind: text("target_kind").$type().notNull(),
+  transport: text("transport").$type().notNull(),
+  reason: text("reason").$type().notNull(),
+  policy: text("policy").$type().notNull(),
+  status: text("status").$type().notNull(),
+  bindingId: text("binding_id"),
+  leaseOwner: text("lease_owner"),
+  leaseExpiresAt: integer("lease_expires_at"),
+  metadataJson: text("metadata_json"),
+  createdAt: integer("created_at").notNull().default(sql`(unixepoch())`)
+}, (table) => [
+  index("idx_deliveries_status_transport").on(table.status, table.transport)
+]);
+var deliveryAttemptsTable = sqliteTable("delivery_attempts", {
+  id: text("id").primaryKey(),
+  deliveryId: text("delivery_id").notNull(),
+  attempt: integer("attempt").notNull(),
+  status: text("status").$type().notNull(),
+  error: text("error"),
+  externalRef: text("external_ref"),
+  metadataJson: text("metadata_json"),
+  createdAt: integer("created_at").notNull()
+});
+// packages/runtime/src/broker.ts
+init_dist2();
+function createRuntimeId(prefix) {
+  return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function toTargetKind(actor) {
+  if (!actor)
+    return "participant";
+  if (actor.kind === "agent")
+    return "agent";
+  if (actor.kind === "device")
+    return "device";
+  if (actor.kind === "bridge")
+    return "bridge";
+  return "participant";
+}
+function defaultTransportForActor(actor) {
+  if (!actor)
+    return "local_socket";
+  switch (actor.kind) {
+    case "bridge":
+      return "webhook";
+    case "device":
+      return "local_socket";
+    case "agent":
+      return "local_socket";
+    default:
+      return "local_socket";
+  }
+}
+function endpointTransportRank(transport) {
+  switch (transport) {
+    case "codex_app_server":
+      return 0;
+    case "claude_stream_json":
+      return 1;
+    case "tmux":
+      return 2;
+    case "local_socket":
+      return 3;
+    default:
+      return 4;
+  }
+}
+function shouldBridgeMessageToBinding(binding, message) {
+  if (binding.platform !== "telegram") {
+    return true;
+  }
+  const source = typeof message.metadata?.source === "string" ? String(message.metadata.source) : "";
+  if (source === "telegram") {
+    return false;
+  }
+  const outboundMode = typeof binding.metadata?.outboundMode === "string" ? String(binding.metadata.outboundMode) : "operator_only";
+  const operatorId = typeof binding.metadata?.operatorId === "string" ? String(binding.metadata.operatorId) : "operator";
+  const allowedActorIds = Array.isArray(binding.metadata?.allowedActorIds) ? binding.metadata.allowedActorIds.map((entry) => String(entry).trim()).filter(Boolean) : [];
+  if (outboundMode === "all") {
+    return true;
+  }
+  if (outboundMode === "allowlist") {
+    return allowedActorIds.includes(message.actorId);
+  }
+  return message.actorId === operatorId;
+}
+function resolveBindingRoutes(bindings, message) {
+  return bindings.filter((binding) => shouldBridgeMessageToBinding(binding, message)).map((binding) => ({
+    targetId: binding.id,
+    targetKind: "bridge",
+    transport: binding.platform === "telegram" ? "telegram" : binding.platform === "discord" ? "discord" : "webhook",
+    bindingId: binding.id
+  }));
+}
+function preferredEndpoint(endpoints) {
+  let preferred;
+  let preferredRank = Number.POSITIVE_INFINITY;
+  for (const endpoint of endpoints) {
+    const rank = endpointTransportRank(endpoint.transport);
+    if (!preferred || rank < preferredRank) {
+      preferred = endpoint;
+      preferredRank = rank;
+    }
+  }
+  return preferred;
+}
+
+class InMemoryControlRuntime {
+  registry;
+  listeners = new Set;
+  eventBuffer = [];
+  localNodeId;
+  endpointIdsByAgentId = new Map;
+  bindingIdsByConversationId = new Map;
+  flightIdByInvocationId = new Map;
+  constructor(initial = {}, options = {}) {
+    this.registry = createRuntimeRegistrySnapshot(initial);
+    this.localNodeId = options.localNodeId;
+    this.rebuildIndexes();
+  }
+  snapshot() {
+    return createRuntimeRegistrySnapshot({
+      nodes: { ...this.registry.nodes },
+      actors: { ...this.registry.actors },
+      agents: { ...this.registry.agents },
+      endpoints: { ...this.registry.endpoints },
+      conversations: { ...this.registry.conversations },
+      bindings: { ...this.registry.bindings },
+      messages: { ...this.registry.messages },
+      flights: { ...this.registry.flights },
+      collaborationRecords: { ...this.registry.collaborationRecords }
+    });
+  }
+  peek() {
+    return this.registry;
+  }
+  node(nodeId) {
+    return this.registry.nodes[nodeId];
+  }
+  agent(agentId) {
+    return this.registry.agents[agentId];
+  }
+  conversation(conversationId) {
+    return this.registry.conversations[conversationId];
+  }
+  message(messageId) {
+    return this.registry.messages[messageId];
+  }
+  collaborationRecord(recordId) {
+    return this.registry.collaborationRecords[recordId];
+  }
+  flightForInvocation(invocationId) {
+    const flightId = this.flightIdByInvocationId.get(invocationId);
+    return flightId ? this.registry.flights[flightId] : undefined;
+  }
+  bindingsForConversation(conversationId) {
+    const bindingIds = this.bindingIdsByConversationId.get(conversationId);
+    if (!bindingIds) {
+      return [];
+    }
+    const bindings = [];
+    for (const bindingId of bindingIds) {
+      const binding = this.registry.bindings[bindingId];
+      if (binding) {
+        bindings.push(binding);
+      }
+    }
+    return bindings;
+  }
+  endpointsForAgent(agentId, options = {}) {
+    const endpointIds = this.endpointIdsByAgentId.get(agentId);
+    if (!endpointIds) {
+      return [];
+    }
+    const endpoints = [];
+    for (const endpointId of endpointIds) {
+      const endpoint = this.registry.endpoints[endpointId];
+      if (!endpoint)
+        continue;
+      if (!options.includeOffline && endpoint.state === "offline")
+        continue;
+      if (options.nodeId && endpoint.nodeId !== options.nodeId)
+        continue;
+      if (options.harness && endpoint.harness !== options.harness)
+        continue;
+      endpoints.push(endpoint);
+    }
+    return endpoints;
+  }
+  recentEvents(limit = 100) {
+    return this.eventBuffer.slice(-limit);
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  async dispatch(command) {
+    switch (command.kind) {
+      case "node.upsert":
+        await this.upsertNode(command.node);
+        return;
+      case "actor.upsert":
+        await this.upsertActor(command.actor);
+        return;
+      case "agent.upsert":
+        await this.upsertAgent(command.agent);
+        return;
+      case "agent.endpoint.upsert":
+        await this.upsertEndpoint(command.endpoint);
+        return;
+      case "conversation.upsert":
+        await this.upsertConversation(command.conversation);
+        return;
+      case "binding.upsert":
+        await this.upsertBinding(command.binding);
+        return;
+      case "collaboration.upsert":
+        await this.upsertCollaboration(command.record);
+        return;
+      case "collaboration.event.append":
+        await this.appendCollaborationEvent(command.event);
+        return;
+      case "conversation.post":
+        await this.postMessage(command.message);
+        return;
+      case "agent.invoke":
+        await this.invokeAgent(command.invocation);
+        return;
+      case "agent.ensure_awake":
+        this.emit({
+          id: createRuntimeId("evt"),
+          kind: "flight.updated",
+          ts: Date.now(),
+          actorId: command.requesterId,
+          nodeId: this.localNodeId,
+          payload: {
+            flight: {
+              id: createRuntimeId("flt"),
+              invocationId: command.agentId,
+              requesterId: command.requesterId,
+              targetAgentId: command.agentId,
+              state: "waking",
+              summary: command.reason
+            }
+          }
+        });
+        return;
+      case "stream.subscribe":
+        return;
+      default: {
+        const exhaustive = command;
+        return exhaustive;
+      }
+    }
+  }
+  async upsertNode(node) {
+    this.registry.nodes[node.id] = node;
+    this.emit({
+      id: createRuntimeId("evt"),
+      kind: "node.upserted",
+      ts: Date.now(),
+      actorId: node.id,
+      nodeId: node.id,
+      payload: { node }
+    });
+  }
+  async upsertActor(actor) {
+    this.registry.actors[actor.id] = {
+      id: actor.id,
+      kind: actor.kind,
+      displayName: actor.displayName,
+      handle: actor.handle,
+      labels: actor.labels,
+      metadata: actor.metadata
+    };
+    this.emit({
+      id: createRuntimeId("evt"),
+      kind: "actor.registered",
+      ts: Date.now(),
+      actorId: actor.id,
+      nodeId: this.localNodeId,
+      payload: { actor }
+    });
+  }
+  async upsertAgent(agent) {
+    if (!this.registry.actors[agent.id]) {
+      this.registry.actors[agent.id] = {
+        id: agent.id,
+        kind: agent.kind,
+        displayName: agent.displayName,
+        handle: agent.handle,
+        labels: agent.labels,
+        metadata: agent.metadata
+      };
+    }
+    this.registry.agents[agent.id] = agent;
+    this.emit({
+      id: createRuntimeId("evt"),
+      kind: "agent.registered",
+      ts: Date.now(),
+      actorId: agent.id,
+      nodeId: agent.authorityNodeId,
+      payload: { agent }
+    });
+  }
+  async upsertEndpoint(endpoint) {
+    const previous = this.registry.endpoints[endpoint.id];
+    if (previous) {
+      this.unindexEndpoint(previous);
+    }
+    this.registry.endpoints[endpoint.id] = endpoint;
+    this.indexEndpoint(endpoint);
+    this.emit({
+      id: createRuntimeId("evt"),
+      kind: "agent.endpoint.upserted",
+      ts: Date.now(),
+      actorId: endpoint.agentId,
+      nodeId: endpoint.nodeId,
+      payload: { endpoint }
+    });
+  }
+  async upsertConversation(conversation) {
+    this.registry.conversations[conversation.id] = conversation;
+    this.emit({
+      id: createRuntimeId("evt"),
+      kind: "conversation.upserted",
+      ts: Date.now(),
+      actorId: "system",
+      nodeId: conversation.authorityNodeId,
+      payload: { conversation }
+    });
+  }
+  async upsertBinding(binding) {
+    const previous = this.registry.bindings[binding.id];
+    if (previous) {
+      this.unindexBinding(previous);
+    }
+    this.registry.bindings[binding.id] = binding;
+    this.indexBinding(binding);
+    this.emit({
+      id: createRuntimeId("evt"),
+      kind: "binding.upserted",
+      ts: Date.now(),
+      actorId: "system",
+      nodeId: this.localNodeId,
+      payload: { binding }
+    });
+  }
+  async upsertCollaboration(record) {
+    assertValidCollaborationRecord(record);
+    this.registry.collaborationRecords[record.id] = record;
+    this.emit({
+      id: createRuntimeId("evt"),
+      kind: "collaboration.upserted",
+      ts: Date.now(),
+      actorId: record.createdById,
+      nodeId: this.localNodeId,
+      payload: { record }
+    });
+  }
+  async appendCollaborationEvent(event) {
+    const record = this.registry.collaborationRecords[event.recordId];
+    if (!record) {
+      throw new Error(`unknown collaboration record: ${event.recordId}`);
+    }
+    assertValidCollaborationEvent(event, record);
+    this.emit({
+      id: createRuntimeId("evt"),
+      kind: "collaboration.event.appended",
+      ts: Date.now(),
+      actorId: event.actorId,
+      nodeId: this.localNodeId,
+      payload: { event }
+    });
+  }
+  async upsertFlight(flight) {
+    const previous = this.registry.flights[flight.id];
+    if (previous && this.flightIdByInvocationId.get(previous.invocationId) === previous.id) {
+      this.flightIdByInvocationId.delete(previous.invocationId);
+    }
+    this.registry.flights[flight.id] = flight;
+    this.flightIdByInvocationId.set(flight.invocationId, flight.id);
+    this.emit({
+      id: createRuntimeId("evt"),
+      kind: "flight.updated",
+      ts: Date.now(),
+      actorId: flight.requesterId,
+      nodeId: this.localNodeId,
+      payload: { flight }
+    });
+  }
+  async postMessage(message, options = {}) {
+    const deliveries2 = this.planMessage(message, options);
+    await this.commitMessage(message, deliveries2);
+    return deliveries2;
+  }
+  planMessage(message, options = {}) {
+    const conversation = this.registry.conversations[message.conversationId];
+    if (!conversation) {
+      throw new Error(`unknown conversation: ${message.conversationId}`);
+    }
+    const bindingRoutes = resolveBindingRoutes(this.bindingsForConversation(conversation.id), message);
+    const plannedParticipantRoutes = this.resolveParticipantRoutes(conversation.participantIds);
+    const participantRoutes = options.localOnly ? plannedParticipantRoutes.filter((route) => !route.nodeId || route.nodeId === this.localNodeId) : plannedParticipantRoutes;
+    const deliveries2 = planMessageDeliveries({
+      localNodeId: this.localNodeId,
+      message,
+      conversation,
+      participantRoutes,
+      bindingRoutes: options.localOnly ? [] : bindingRoutes
+    });
+    return deliveries2;
+  }
+  async commitMessage(message, deliveries2) {
+    this.registry.messages[message.id] = message;
+    this.emit({
+      id: createRuntimeId("evt"),
+      kind: "message.posted",
+      ts: Date.now(),
+      actorId: message.actorId,
+      nodeId: message.originNodeId,
+      payload: { message }
+    });
+    for (const delivery of deliveries2) {
+      this.emit({
+        id: createRuntimeId("evt"),
+        kind: "delivery.planned",
+        ts: Date.now(),
+        actorId: message.actorId,
+        nodeId: message.originNodeId,
+        payload: { delivery }
+      });
+    }
+  }
+  async invokeAgent(invocation) {
+    const flight = this.planInvocation(invocation);
+    await this.commitInvocation(invocation, flight);
+    return flight;
+  }
+  planInvocation(invocation) {
+    const targetAgent = this.registry.agents[invocation.targetAgentId];
+    if (!targetAgent) {
+      throw new Error(`unknown agent: ${invocation.targetAgentId}`);
+    }
+    const targetEndpoints = this.endpointsForAgent(invocation.targetAgentId, {
+      nodeId: targetAgent.authorityNodeId,
+      harness: invocation.execution?.harness
+    });
+    const isLocalAuthority = !this.localNodeId || targetAgent.authorityNodeId === this.localNodeId;
+    const startedAt = Date.now();
+    let state = invocation.ensureAwake ? "waking" : "queued";
+    let summary;
+    let error;
+    let completedAt;
+    if (isLocalAuthority) {
+      if (targetEndpoints.length == 0) {
+        state = invocation.ensureAwake ? "waking" : "queued";
+        summary = invocation.ensureAwake ? invocation.execution?.harness ? `${targetAgent.displayName} waking on ${invocation.execution.harness}.` : `${targetAgent.displayName} waking.` : `Message stored for ${targetAgent.displayName}. Will deliver when online.`;
+      } else {
+        state = "queued";
+        summary = `${targetAgent.displayName} queued for local execution.`;
+      }
+    }
+    const flight = {
+      id: createRuntimeId("flt"),
+      invocationId: invocation.id,
+      requesterId: invocation.requesterId,
+      targetAgentId: invocation.targetAgentId,
+      state,
+      summary,
+      error,
+      startedAt,
+      completedAt,
+      metadata: invocation.metadata
+    };
+    return flight;
+  }
+  async commitInvocation(invocation, flight) {
+    const previous = this.registry.flights[flight.id];
+    if (previous && this.flightIdByInvocationId.get(previous.invocationId) === previous.id) {
+      this.flightIdByInvocationId.delete(previous.invocationId);
+    }
+    this.registry.flights[flight.id] = flight;
+    this.flightIdByInvocationId.set(flight.invocationId, flight.id);
+    const targetAgent = this.registry.agents[invocation.targetAgentId];
+    this.emit({
+      id: createRuntimeId("evt"),
+      kind: "invocation.requested",
+      ts: Date.now(),
+      actorId: invocation.requesterId,
+      nodeId: invocation.requesterNodeId,
+      payload: { invocation }
+    });
+    this.emit({
+      id: createRuntimeId("evt"),
+      kind: "flight.updated",
+      ts: Date.now(),
+      actorId: invocation.requesterId,
+      nodeId: targetAgent?.authorityNodeId,
+      payload: { flight }
+    });
+  }
+  rebuildIndexes() {
+    for (const endpoint of Object.values(this.registry.endpoints)) {
+      this.indexEndpoint(endpoint);
+    }
+    for (const binding of Object.values(this.registry.bindings)) {
+      this.indexBinding(binding);
+    }
+    for (const flight of Object.values(this.registry.flights)) {
+      this.flightIdByInvocationId.set(flight.invocationId, flight.id);
+    }
+  }
+  indexEndpoint(endpoint) {
+    this.addIndexedId(this.endpointIdsByAgentId, endpoint.agentId, endpoint.id);
+  }
+  unindexEndpoint(endpoint) {
+    this.removeIndexedId(this.endpointIdsByAgentId, endpoint.agentId, endpoint.id);
+  }
+  indexBinding(binding) {
+    this.addIndexedId(this.bindingIdsByConversationId, binding.conversationId, binding.id);
+  }
+  unindexBinding(binding) {
+    this.removeIndexedId(this.bindingIdsByConversationId, binding.conversationId, binding.id);
+  }
+  addIndexedId(index2, key, value) {
+    const ids = index2.get(key) ?? new Set;
+    ids.add(value);
+    index2.set(key, ids);
+  }
+  removeIndexedId(index2, key, value) {
+    const ids = index2.get(key);
+    if (!ids) {
+      return;
+    }
+    ids.delete(value);
+    if (ids.size === 0) {
+      index2.delete(key);
+    }
+  }
+  resolveParticipantRoutes(participantIds) {
+    const routes = [];
+    for (const participantId of participantIds) {
+      const actor = this.registry.actors[participantId];
+      const agent = this.registry.agents[participantId];
+      const targetIdentity = actor ?? agent;
+      const endpoints = this.endpointsForAgent(participantId);
+      const endpoint = preferredEndpoint(endpoints);
+      if (!endpoint) {
+        if (agent?.authorityNodeId && agent.authorityNodeId !== this.localNodeId) {
+          routes.push({
+            targetId: participantId,
+            nodeId: agent.authorityNodeId,
+            targetKind: toTargetKind(targetIdentity),
+            transport: defaultTransportForActor(targetIdentity),
+            speechEnabled: false
+          });
+        } else if (agent) {
+          routes.push({
+            targetId: participantId,
+            nodeId: agent.authorityNodeId ?? this.localNodeId,
+            targetKind: toTargetKind(targetIdentity),
+            transport: defaultTransportForActor(targetIdentity),
+            speechEnabled: false
+          });
+        }
+        continue;
+      }
+      routes.push({
+        targetId: participantId,
+        nodeId: endpoint.nodeId ?? agent?.authorityNodeId,
+        targetKind: toTargetKind(targetIdentity),
+        transport: endpoint.transport ?? defaultTransportForActor(targetIdentity),
+        speechEnabled: Boolean(actor?.kind === "device" || endpoints.some((candidate) => candidate.transport === "local_socket" || candidate.transport === "websocket"))
+      });
+    }
+    return routes;
+  }
+  emit(event) {
+    this.eventBuffer.push(event);
+    if (this.eventBuffer.length > 500) {
+      this.eventBuffer.shift();
+    }
+    for (const listener of this.listeners) {
+      listener(event);
+    }
+  }
+}
+// packages/runtime/src/tailscale.ts
+import { readFile as readFile7 } from "fs/promises";
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+function parseStatusJson(raw2) {
+  return JSON.parse(raw2);
+}
+function parsePeers(status) {
+  const peers = Object.entries(status.Peer ?? {});
+  return peers.map(([fallbackId, peer]) => ({
+    id: peer.ID ?? fallbackId,
+    name: peer.HostName ?? peer.DNSName ?? fallbackId,
+    dnsName: peer.DNSName,
+    addresses: peer.TailscaleIPs ?? [],
+    online: peer.Online ?? false,
+    hostName: peer.HostName,
+    os: peer.OS,
+    tags: peer.Tags ?? []
+  }));
+}
+function parseSelf(status) {
+  const self = status.Self;
+  if (!self) {
+    return null;
+  }
+  return {
+    id: self.ID ?? self.DNSName ?? self.HostName ?? "self",
+    name: self.HostName ?? self.DNSName ?? "self",
+    dnsName: self.DNSName,
+    addresses: self.TailscaleIPs ?? [],
+    online: self.Online ?? true,
+    hostName: self.HostName,
+    os: self.OS,
+    tailnetName: status.CurrentTailnet?.Name,
+    magicDnsSuffix: status.CurrentTailnet?.MagicDNSSuffix
+  };
+}
+async function readStatusJsonFromFile(filePath) {
+  const raw2 = await readFile7(filePath, "utf8");
+  return parseStatusJson(raw2);
+}
+async function readStatusJson() {
+  const fixturePath = process.env.OPENSCOUT_TAILSCALE_STATUS_JSON;
+  if (fixturePath) {
+    return readStatusJsonFromFile(fixturePath);
+  }
+  try {
+    const tailscaleBin = process.env.OPENSCOUT_TAILSCALE_BIN ?? "tailscale";
+    const { stdout } = await execFileAsync(tailscaleBin, ["status", "--json"]);
+    return parseStatusJson(stdout);
+  } catch {
+    return null;
+  }
+}
+async function readTailscalePeers() {
+  const status = await readStatusJson();
+  if (!status) {
+    return [];
+  }
+  return parsePeers(status);
+}
+async function readTailscaleSelf() {
+  const status = await readStatusJson();
+  if (!status) {
+    return null;
+  }
+  return parseSelf(status);
+}
+
+// packages/runtime/src/index.ts
+init_broker_service();
+init_local_agents();
+
+// packages/runtime/src/scout-broker.ts
+init_dist2();
+init_setup();
+init_support_paths();
+await __promiseAll([
+  init_local_agents(),
+  init_broker_service()
+]);
+
+// packages/runtime/src/index.ts
+init_codex_app_server();
+init_setup();
+init_support_paths();
+
+// packages/runtime/src/scout-agent-cards.ts
+init_dist2();
+// packages/runtime/src/thread-events.ts
+class ThreadWatchProtocolError extends Error {
+  status;
+  body;
+  constructor(status, body) {
+    super(body.message);
+    this.status = status;
+    this.body = body;
+  }
+}
+function watchKey(conversationId, watcherNodeId, watcherId) {
+  return `${conversationId}:${watcherNodeId}:${watcherId}`;
+}
+function writeSse(response, eventName, payload) {
+  response.write(`event: ${eventName}
+data: ${JSON.stringify(payload)}
+
+`);
+}
+
+class ThreadEventPlane {
+  options;
+  watches = new Map;
+  watchIdsByKey = new Map;
+  watchIdsByConversation = new Map;
+  constructor(options) {
+    this.options = options;
+  }
+  async openWatch(request) {
+    const conversation = this.requireConversationAuthority(request.conversationId);
+    this.requireRemoteWatchAllowed(conversation);
+    const afterSeq = Math.max(0, request.afterSeq ?? 0);
+    const oldestSeq = await this.options.projection.oldestThreadSeq(conversation.id);
+    const latestSeq = await this.options.projection.latestThreadSeq(conversation.id);
+    if (latestSeq > 0 && oldestSeq > 0 && afterSeq < oldestSeq - 1) {
+      throw new ThreadWatchProtocolError(409, {
+        code: "cursor_out_of_range",
+        message: `thread cursor ${afterSeq} is older than retained seq ${oldestSeq}`
+      });
+    }
+    const key = watchKey(conversation.id, request.watcherNodeId, request.watcherId);
+    const existingWatchId = this.watchIdsByKey.get(key);
+    if (existingWatchId) {
+      this.closeWatchInternal(existingWatchId);
+    }
+    const watchId = `thread-watch:${conversation.id}:${request.watcherNodeId}:${request.watcherId}`;
+    const leaseExpiresAt = Date.now() + this.normalizeLeaseMs(request.leaseMs);
+    const watch = {
+      watchId,
+      conversationId: conversation.id,
+      watcherNodeId: request.watcherNodeId,
+      watcherId: request.watcherId,
+      acceptedAfterSeq: afterSeq,
+      leaseExpiresAt,
+      mode: conversation.shareMode === "summary" ? "summary" : "shared",
+      clients: new Set
+    };
+    this.watches.set(watchId, watch);
+    this.watchIdsByKey.set(key, watchId);
+    this.indexWatch(watch);
+    return {
+      watchId,
+      conversationId: conversation.id,
+      authorityNodeId: conversation.authorityNodeId,
+      acceptedAfterSeq: afterSeq,
+      latestSeq,
+      leaseExpiresAt,
+      mode: watch.mode
+    };
+  }
+  async renewWatch(request) {
+    const watch = this.requireLiveWatch(request.watchId);
+    watch.leaseExpiresAt = Date.now() + this.normalizeLeaseMs(request.leaseMs);
+    return {
+      watchId: watch.watchId,
+      leaseExpiresAt: watch.leaseExpiresAt
+    };
+  }
+  async closeWatch(request) {
+    this.closeWatchInternal(request.watchId);
+  }
+  async replay(options) {
+    const conversation = this.requireConversationAuthority(options.conversationId);
+    this.requireRemoteWatchAllowed(conversation);
+    const oldestSeq = await this.options.projection.oldestThreadSeq(conversation.id);
+    const latestSeq = await this.options.projection.latestThreadSeq(conversation.id);
+    if (latestSeq > 0 && oldestSeq > 0 && options.afterSeq < oldestSeq - 1) {
+      throw new ThreadWatchProtocolError(409, {
+        code: "cursor_out_of_range",
+        message: `thread cursor ${options.afterSeq} is older than retained seq ${oldestSeq}`
+      });
+    }
+    return this.options.projection.listThreadEvents({
+      conversationId: conversation.id,
+      afterSeq: options.afterSeq,
+      limit: Math.min(options.limit ?? 500, this.options.maxReplayLimit ?? 2000)
+    });
+  }
+  async snapshot(conversationId) {
+    const conversation = this.requireConversationAuthority(conversationId);
+    this.requireRemoteWatchAllowed(conversation);
+    const snapshot = await this.options.projection.getThreadSnapshot(conversation.id);
+    if (!snapshot) {
+      throw new ThreadWatchProtocolError(404, {
+        code: "unknown_conversation",
+        message: `unknown conversation ${conversation.id}`
+      });
+    }
+    return snapshot;
+  }
+  async streamWatch(watchId, request, response) {
+    const watch = this.requireLiveWatch(watchId);
+    const backlog = await this.options.projection.listThreadEvents({
+      conversationId: watch.conversationId,
+      afterSeq: watch.acceptedAfterSeq,
+      limit: this.options.maxReplayLimit ?? 2000
+    });
+    response.writeHead(200, {
+      "content-type": "text/event-stream",
+      "cache-control": "no-cache, no-transform",
+      connection: "keep-alive"
+    });
+    writeSse(response, "hello", {
+      watchId: watch.watchId,
+      conversationId: watch.conversationId,
+      leaseExpiresAt: watch.leaseExpiresAt
+    });
+    for (const event of backlog) {
+      writeSse(response, "thread.event", event);
+    }
+    watch.clients.add(response);
+    request.on("close", () => {
+      watch.clients.delete(response);
+      response.end();
+    });
+  }
+  publish(events2) {
+    for (const event of events2) {
+      const watchIds = this.watchIdsByConversation.get(event.conversationId);
+      if (!watchIds || watchIds.size === 0) {
+        continue;
+      }
+      for (const watchId of [...watchIds]) {
+        const watch = this.watches.get(watchId);
+        if (!watch) {
+          watchIds.delete(watchId);
+          continue;
+        }
+        if (watch.leaseExpiresAt <= Date.now()) {
+          this.closeWatchInternal(watchId);
+          continue;
+        }
+        for (const client of watch.clients) {
+          writeSse(client, "thread.event", event);
+        }
+      }
+    }
+  }
+  normalizeLeaseMs(requestedLeaseMs) {
+    const defaultLeaseMs = this.options.defaultLeaseMs ?? 30000;
+    const maxLeaseMs = this.options.maxLeaseMs ?? 300000;
+    if (!requestedLeaseMs || !Number.isFinite(requestedLeaseMs) || requestedLeaseMs <= 0) {
+      return defaultLeaseMs;
+    }
+    return Math.min(Math.max(requestedLeaseMs, 5000), maxLeaseMs);
+  }
+  requireConversationAuthority(conversationId) {
+    const conversation = this.options.runtime.conversation(conversationId);
+    if (!conversation) {
+      throw new ThreadWatchProtocolError(404, {
+        code: "unknown_conversation",
+        message: `unknown conversation ${conversationId}`
+      });
+    }
+    if (conversation.authorityNodeId !== this.options.nodeId) {
+      throw new ThreadWatchProtocolError(409, {
+        code: "no_responder",
+        message: `conversation ${conversationId} is owned by ${conversation.authorityNodeId}`
+      });
+    }
+    return conversation;
+  }
+  requireRemoteWatchAllowed(conversation) {
+    if (conversation.shareMode === "local") {
+      throw new ThreadWatchProtocolError(403, {
+        code: "forbidden",
+        message: `conversation ${conversation.id} does not allow remote watches`
+      });
+    }
+  }
+  requireLiveWatch(watchId) {
+    const watch = this.watches.get(watchId);
+    if (!watch) {
+      throw new ThreadWatchProtocolError(404, {
+        code: "invalid_request",
+        message: `unknown watch ${watchId}`
+      });
+    }
+    if (watch.leaseExpiresAt <= Date.now()) {
+      this.closeWatchInternal(watchId);
+      throw new ThreadWatchProtocolError(410, {
+        code: "lease_expired",
+        message: `watch ${watchId} lease expired`
+      });
+    }
+    return watch;
+  }
+  indexWatch(watch) {
+    const ids = this.watchIdsByConversation.get(watch.conversationId) ?? new Set;
+    ids.add(watch.watchId);
+    this.watchIdsByConversation.set(watch.conversationId, ids);
+  }
+  closeWatchInternal(watchId) {
+    const watch = this.watches.get(watchId);
+    if (!watch) {
+      return;
+    }
+    this.watches.delete(watchId);
+    this.watchIdsByKey.delete(watchKey(watch.conversationId, watch.watcherNodeId, watch.watcherId));
+    const ids = this.watchIdsByConversation.get(watch.conversationId);
+    if (ids) {
+      ids.delete(watchId);
+      if (ids.size === 0) {
+        this.watchIdsByConversation.delete(watch.conversationId);
+      }
+    }
+    for (const client of watch.clients) {
+      client.end();
+    }
+    watch.clients.clear();
+  }
+}
+// packages/runtime/src/mobile-push.ts
+init_support_paths();
+// packages/web/server/core/observe/service.ts
+function activeEndpoint(snapshot, agentId) {
+  const candidates = Object.values(snapshot.endpoints ?? {}).filter((endpoint) => endpoint.agentId === agentId);
+  const rank = (state) => {
+    switch (state) {
+      case "active":
+        return 0;
+      case "idle":
+        return 1;
+      case "waiting":
+        return 2;
+      case "offline":
+        return 5;
+      default:
+        return 4;
+    }
+  };
+  return [...candidates].sort((left, right) => rank(left.state) - rank(right.state))[0] ?? null;
+}
+function expandHome(value) {
+  if (!value) {
+    return null;
+  }
+  if (value === "~") {
+    return homedir12();
+  }
+  if (value.startsWith("~/")) {
+    return join18(homedir12(), value.slice(2));
+  }
+  return value;
+}
+function encodeClaudeProjectsSlug2(absolutePath) {
+  const normalized = resolve8(absolutePath);
+  return `-${normalized.replace(/^\//u, "").replace(/\//gu, "-")}`;
+}
+function resolveClaudeHistoryPath(cwd, sessionId) {
+  const normalizedCwd = expandHome(cwd)?.trim();
+  const normalizedSessionId = sessionId?.trim().replace(/\.jsonl$/u, "") || "";
+  if (!normalizedCwd || !normalizedSessionId) {
+    return null;
+  }
+  return join18(homedir12(), ".claude", "projects", encodeClaudeProjectsSlug2(normalizedCwd), `${normalizedSessionId}.jsonl`);
+}
+function historyAdapterAlias(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (!normalized) {
+    return null;
+  }
+  if (normalized === "claude" || normalized === "claude-code" || normalized === "claude_stream_json") {
+    return "claude-code";
+  }
+  if (normalized === "codex" || normalized === "codex_app_server") {
+    return "codex";
+  }
+  return null;
+}
+function snapshotProviderMeta(snapshot) {
+  const providerMeta = snapshot.session.providerMeta;
+  return providerMeta && typeof providerMeta === "object" ? providerMeta : {};
+}
+function firstString(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim().length > 0) {
+      return value.trim();
+    }
+  }
+  return null;
+}
+function resolveHistoryCandidate(agent, snapshot) {
+  const snapshotAdapter = historyAdapterAlias(snapshot?.session.adapterType);
+  const agentAdapter = historyAdapterAlias(agent.harness);
+  const providerMeta = snapshot ? snapshotProviderMeta(snapshot) : {};
+  const directPath = firstString(providerMeta.resumeSessionPath, providerMeta.threadPath);
+  if (directPath) {
+    const adapterType = snapshotAdapter ?? agentAdapter;
+    if (adapterType) {
+      return { path: directPath, adapterType };
+    }
+  }
+  const claudeSessionId = firstString(providerMeta.transportSessionId, agent.harnessSessionId);
+  const claudeCwd = firstString(snapshot?.session.cwd, agent.cwd, agent.projectRoot);
+  if ((snapshotAdapter ?? agentAdapter) === "claude-code") {
+    const path = resolveClaudeHistoryPath(claudeCwd, claudeSessionId);
+    if (path) {
+      return { path, adapterType: "claude-code" };
+    }
+  }
+  return null;
+}
+function normalizeTimedEvents(events2) {
+  if (!events2) {
+    return [];
+  }
+  return events2.map((entry) => ({
+    timestamp: entry.capturedAt,
+    event: entry.event
+  }));
+}
+function readHistorySnapshot(candidate) {
+  if (!candidate) {
+    return null;
+  }
+  if (!supportsHistorySessionSnapshotForPath(candidate.path, candidate.adapterType)) {
+    return null;
+  }
+  if (!existsSync11(candidate.path)) {
+    return null;
+  }
+  const stat5 = statSync4(candidate.path);
+  const replay = createHistorySessionSnapshot({
+    path: candidate.path,
+    content: readFileSync7(candidate.path, "utf8"),
+    adapterType: candidate.adapterType,
+    baseTimestampMs: stat5.mtimeMs
+  });
+  return {
+    historyPath: candidate.path,
+    snapshot: replay.snapshot,
+    timedEvents: normalizeTimedEvents(replay.events)
+  };
+}
+async function readLiveSnapshot(endpoint) {
+  if (!endpoint?.sessionId) {
+    return null;
+  }
+  if (endpoint.transport === "pairing_bridge") {
+    return await getScoutWebPairingSessionSnapshot(endpoint.sessionId);
+  }
+  if (endpoint.transport === "codex_app_server" || endpoint.transport === "claude_stream_json") {
+    return await getLocalAgentEndpointSessionSnapshot(endpoint);
+  }
+  return null;
+}
+function summarizeCommandOutput(output) {
+  const lines = output.split(/\r?\n/u).map((line) => line.trimEnd()).filter((line) => line.length > 0);
+  if (lines.length === 0) {
+    return;
+  }
+  return lines.slice(-12);
+}
+function truncatePreview(value, maxLines = 6, maxChars = 400) {
+  const lines = value.split(/\r?\n/u).map((line) => line.trimEnd()).filter((line) => line.length > 0).slice(0, maxLines);
+  const joined = lines.join(`
+`);
+  return joined.length <= maxChars ? joined : `${joined.slice(0, maxChars - 1).trimEnd()}\u2026`;
+}
+function countDiffStats(value) {
+  let add = 0;
+  let del = 0;
+  for (const line of value.split(/\r?\n/u)) {
+    if (line.startsWith("+++ ") || line.startsWith("--- ")) {
+      continue;
+    }
+    if (line.startsWith("+")) {
+      add += 1;
+    } else if (line.startsWith("-")) {
+      del += 1;
+    }
+  }
+  return { add, del };
+}
+function toolArgSummary(input) {
+  if (typeof input === "string") {
+    return input;
+  }
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    return "";
+  }
+  const record = input;
+  const preferred = firstString(record.file_path, record.path, record.command, record.pattern, record.query, record.glob, record.prompt, record.description);
+  if (preferred) {
+    return preferred;
+  }
+  try {
+    return JSON.stringify(record);
+  } catch {
+    return "";
+  }
+}
+function normalizeToolName(toolName) {
+  switch (toolName.trim().toLowerCase()) {
+    case "read":
+    case "view":
+      return "read";
+    case "grep":
+    case "glob":
+    case "search":
+      return "grep";
+    case "edit":
+    case "multiedit":
+      return "edit";
+    case "write":
+      return "write";
+    case "bash":
+      return "bash";
+    case "agent":
+      return "agent";
+    default:
+      return toolName.trim().toLowerCase() || "tool";
+  }
+}
+function fileStatePriority(state) {
+  switch (state) {
+    case "created":
+      return 3;
+    case "modified":
+      return 2;
+    case "read":
+      return 1;
+  }
+}
+function addTouchedFile(files, path, state, lastT) {
+  const normalizedPath = path.trim();
+  if (!normalizedPath) {
+    return;
+  }
+  const existing = files.get(normalizedPath);
+  if (!existing) {
+    files.set(normalizedPath, {
+      path: normalizedPath,
+      state,
+      touches: 1,
+      lastT
+    });
+    return;
+  }
+  existing.touches += 1;
+  existing.lastT = Math.max(existing.lastT, lastT);
+  if (fileStatePriority(state) > fileStatePriority(existing.state)) {
+    existing.state = state;
+  }
+}
+function detectFileTouches(block, t, files) {
+  if (block.type !== "action") {
+    return;
+  }
+  const { action } = block;
+  if (action.kind === "file_change" && action.path.trim()) {
+    addTouchedFile(files, action.path, "modified", t);
+    return;
+  }
+  if (action.kind !== "tool_call") {
+    return;
+  }
+  const toolName = normalizeToolName(action.toolName);
+  const input = action.input;
+  const path = firstString(input?.file_path, input?.path);
+  if (!path) {
+    return;
+  }
+  if (toolName === "read" || toolName === "grep") {
+    addTouchedFile(files, path, "read", t);
+    return;
+  }
+  if (toolName === "write") {
+    addTouchedFile(files, path, "created", t);
+    return;
+  }
+  if (toolName === "edit") {
+    addTouchedFile(files, path, "modified", t);
+  }
+}
+function buildTimingLookup(snapshot, timedEvents) {
+  const turnStartedAtMs = new Map;
+  const turnEndedAtMs = new Map;
+  const blockStartedAtMs = new Map;
+  const questionAnsweredAtMs = new Map;
+  let bootTimestampMs = Number.POSITIVE_INFINITY;
+  for (const entry of timedEvents) {
+    if (entry.event.event === "session:update") {
+      bootTimestampMs = Math.min(bootTimestampMs, entry.timestamp);
+      continue;
+    }
+    if (entry.event.event === "turn:start") {
+      turnStartedAtMs.set(entry.event.turn.id, entry.timestamp);
+      bootTimestampMs = Math.min(bootTimestampMs, entry.timestamp);
+      continue;
+    }
+    if (entry.event.event === "turn:end" || entry.event.event === "turn:error") {
+      turnEndedAtMs.set(entry.event.turnId, entry.timestamp);
+      continue;
+    }
+    if (entry.event.event === "block:start") {
+      blockStartedAtMs.set(entry.event.block.id, entry.timestamp);
+      continue;
+    }
+    if (entry.event.event === "block:question:answer") {
+      questionAnsweredAtMs.set(entry.event.blockId, entry.timestamp);
+    }
+  }
+  for (const turn of snapshot.turns) {
+    if (!turnStartedAtMs.has(turn.id) && Number.isFinite(turn.startedAt)) {
+      turnStartedAtMs.set(turn.id, turn.startedAt);
+    }
+    if (!turnEndedAtMs.has(turn.id) && Number.isFinite(turn.endedAt ?? NaN)) {
+      turnEndedAtMs.set(turn.id, turn.endedAt);
+    }
+    bootTimestampMs = Math.min(bootTimestampMs, turnStartedAtMs.get(turn.id) ?? Number.POSITIVE_INFINITY);
+  }
+  if (!Number.isFinite(bootTimestampMs)) {
+    bootTimestampMs = Date.now();
+  }
+  return {
+    baseTimestampMs: bootTimestampMs,
+    bootTimestampMs,
+    turnStartedAtMs,
+    turnEndedAtMs,
+    blockStartedAtMs,
+    questionAnsweredAtMs
+  };
+}
+function blockTimestampMs(turnId, block, turnBlockCount, timing) {
+  const explicit = timing.blockStartedAtMs.get(block.id);
+  if (typeof explicit === "number" && Number.isFinite(explicit)) {
+    return explicit;
+  }
+  const turnStart = timing.turnStartedAtMs.get(turnId) ?? timing.baseTimestampMs;
+  const turnEnd = timing.turnEndedAtMs.get(turnId) ?? turnStart + Math.max(3000, turnBlockCount * 2000);
+  const duration = Math.max(1000, turnEnd - turnStart);
+  const step = duration / Math.max(1, turnBlockCount + 1);
+  return Math.round(turnStart + step * (block.index + 1));
+}
+function timelineSeconds(values, baseTimestampMs) {
+  let last = 0;
+  return values.map((timestamp) => {
+    const seconds = Math.max(0, Math.round((timestamp - baseTimestampMs) / 1000));
+    last = Math.max(last, seconds);
+    return last;
+  });
+}
+function syntheticContextUsage(eventCount) {
+  if (eventCount <= 0) {
+    return [];
+  }
+  const length = Math.max(2, Math.min(eventCount, 24));
+  return Array.from({ length }, (_, index2) => {
+    const progress = length <= 1 ? 1 : index2 / (length - 1);
+    return Math.min(0.92, 0.08 + progress * 0.66);
+  });
+}
+function buildObserveDataFromSnapshot(snapshot, timedEvents = [], live = false) {
+  const timing = buildTimingLookup(snapshot, timedEvents);
+  const files = new Map;
+  const eventDrafts = [
+    {
+      timestampMs: timing.bootTimestampMs,
+      build: (t) => ({
+        id: `${snapshot.session.id}:boot`,
+        t,
+        kind: "boot",
+        text: `Session started \xB7 ${snapshot.session.model ?? snapshot.session.adapterType}`,
+        detail: [
+          snapshot.session.cwd ? `workspace: ${snapshot.session.cwd}` : null,
+          `turns: ${snapshot.turns.length}`,
+          `status: ${snapshot.session.status}`
+        ].filter(Boolean).join(" \xB7 ")
+      })
+    }
+  ];
+  for (const turn of snapshot.turns) {
+    const turnBlockCount = turn.blocks.length;
+    for (const blockState of turn.blocks) {
+      const { block } = blockState;
+      const timestampMs = blockTimestampMs(turn.id, block, turnBlockCount, timing);
+      eventDrafts.push({
+        timestampMs,
+        block,
+        build: (t) => {
+          switch (block.type) {
+            case "reasoning":
+              return {
+                id: block.id,
+                t,
+                kind: "think",
+                text: block.text.trim(),
+                live: live && snapshot.currentTurnId === turn.id && blockState.status === "streaming"
+              };
+            case "text":
+              return {
+                id: block.id,
+                t,
+                kind: "message",
+                text: block.text.trim(),
+                to: "human"
+              };
+            case "question": {
+              const answeredAt = timing.questionAnsweredAtMs.get(block.id);
+              return {
+                id: block.id,
+                t,
+                kind: "ask",
+                text: block.question.trim(),
+                to: "human",
+                answer: block.answer?.join(", "),
+                answerT: answeredAt ? Math.max(t, Math.round((answeredAt - timing.baseTimestampMs) / 1000)) : undefined
+              };
+            }
+            case "error":
+              return {
+                id: block.id,
+                t,
+                kind: "system",
+                text: block.message,
+                detail: block.code
+              };
+            case "file":
+              return {
+                id: block.id,
+                t,
+                kind: "note",
+                text: block.name ? `Generated file ${block.name}` : "Generated file artifact"
+              };
+            case "action": {
+              if (block.action.kind === "command") {
+                return {
+                  id: block.id,
+                  t,
+                  kind: "tool",
+                  text: "",
+                  tool: "bash",
+                  arg: block.action.command,
+                  stream: summarizeCommandOutput(block.action.output)
+                };
+              }
+              if (block.action.kind === "file_change") {
+                const diffBody = block.action.diff?.trim() || block.action.output.trim();
+                const diff = diffBody ? {
+                  ...countDiffStats(diffBody),
+                  preview: truncatePreview(diffBody)
+                } : undefined;
+                return {
+                  id: block.id,
+                  t,
+                  kind: "tool",
+                  text: "",
+                  tool: block.action.path ? "edit" : "write",
+                  arg: block.action.path,
+                  ...diff ? { diff } : {}
+                };
+              }
+              if (block.action.kind === "subagent") {
+                return {
+                  id: block.id,
+                  t,
+                  kind: "tool",
+                  text: "",
+                  tool: "agent",
+                  arg: block.action.agentName ?? block.action.agentId,
+                  stream: summarizeCommandOutput(block.action.output)
+                };
+              }
+              return {
+                id: block.id,
+                t,
+                kind: "tool",
+                text: "",
+                tool: normalizeToolName(block.action.toolName),
+                arg: toolArgSummary(block.action.input),
+                stream: summarizeCommandOutput(block.action.output)
+              };
+            }
+          }
+        }
+      });
+    }
+  }
+  const seconds = timelineSeconds(eventDrafts.map((draft) => draft.timestampMs), timing.baseTimestampMs);
+  const builtEntries = eventDrafts.map((draft, index2) => ({
+    draft,
+    event: draft.build(seconds[index2] ?? 0)
+  })).filter(({ event }) => event.text.length > 0 || event.kind === "tool" || event.kind === "boot");
+  const events2 = builtEntries.map((entry) => entry.event);
+  for (const { draft, event } of builtEntries) {
+    if (draft.block) {
+      detectFileTouches(draft.block, event.t, files);
+    }
+  }
+  return {
+    events: events2,
+    files: [...files.values()].sort((left, right) => right.lastT - left.lastT || left.path.localeCompare(right.path)),
+    contextUsage: syntheticContextUsage(events2.length),
+    live
+  };
+}
+function unavailableObserveData(agent) {
+  return {
+    events: [
+      {
+        id: `${agent.id}:unavailable`,
+        t: 0,
+        kind: "system",
+        text: "No session trace is available for this agent yet.",
+        detail: agent.harness ? `${agent.harness} \xB7 waiting for a live session or a readable history file` : "waiting for a live session or a readable history file"
+      }
+    ],
+    files: [],
+    contextUsage: [],
+    live: false
+  };
+}
+async function resolveSnapshotSource(agent) {
+  const broker2 = await loadScoutBrokerContext();
+  const endpoint = broker2 ? activeEndpoint(broker2.snapshot, agent.id) : null;
+  const liveSnapshot = await readLiveSnapshot(endpoint);
+  const live = Boolean(liveSnapshot && (liveSnapshot.currentTurnId || liveSnapshot.session.status === "active"));
+  const historyCandidate = resolveHistoryCandidate(agent, liveSnapshot);
+  const historySnapshot = readHistorySnapshot(historyCandidate);
+  if (historySnapshot) {
+    return {
+      source: "history",
+      historyPath: historySnapshot.historyPath,
+      snapshot: historySnapshot.snapshot,
+      timedEvents: historySnapshot.timedEvents,
+      live,
+      sessionId: liveSnapshot?.session.id ?? endpoint?.sessionId ?? null
+    };
+  }
+  if (liveSnapshot) {
+    return {
+      source: "live",
+      historyPath: historyCandidate?.path ?? null,
+      snapshot: liveSnapshot,
+      timedEvents: [],
+      live,
+      sessionId: liveSnapshot.session.id
+    };
+  }
+  const agentHistorySnapshot = readHistorySnapshot(resolveHistoryCandidate(agent, null));
+  if (agentHistorySnapshot) {
+    return {
+      source: "history",
+      historyPath: agentHistorySnapshot.historyPath,
+      snapshot: agentHistorySnapshot.snapshot,
+      timedEvents: agentHistorySnapshot.timedEvents,
+      live: false,
+      sessionId: null
+    };
+  }
+  return {
+    source: "unavailable",
+    historyPath: null,
+    live: false,
+    sessionId: null
+  };
+}
+async function loadAgentObservePayload(agentId) {
+  const agent = queryAgents(200).find((entry) => entry.id === agentId) ?? null;
+  if (!agent) {
+    return null;
+  }
+  const source = await resolveSnapshotSource(agent);
+  if (source.source === "unavailable") {
+    return {
+      agentId,
+      source: "unavailable",
+      fidelity: "synthetic",
+      historyPath: null,
+      sessionId: null,
+      updatedAt: Date.now(),
+      data: unavailableObserveData(agent)
+    };
+  }
+  const fidelity = source.timedEvents.length > 0 ? "timestamped" : "synthetic";
+  return {
+    agentId,
+    source: source.source,
+    fidelity,
+    historyPath: source.historyPath,
+    sessionId: source.sessionId,
+    updatedAt: Date.now(),
+    data: buildObserveDataFromSnapshot(source.snapshot, source.timedEvents, source.live)
+  };
+}
+
+// packages/web/server/core/mesh/service.ts
+await init_broker_service();
+function normalizeHost(host) {
+  return host.trim().replace(/^\[/, "").replace(/\]$/, "").toLowerCase();
+}
+function isLoopbackHost(host) {
+  const normalized = normalizeHost(host);
+  return normalized === "127.0.0.1" || normalized === "::1" || normalized === "localhost";
+}
+function isWildcardHost(host) {
+  const normalized = normalizeHost(host);
+  return normalized === "0.0.0.0" || normalized === "::";
+}
+function isPeerReachableBrokerUrl(url) {
+  if (!url) {
+    return false;
+  }
+  try {
+    const hostname2 = new URL(url).hostname;
+    return !isLoopbackHost(hostname2) && !isWildcardHost(hostname2);
+  } catch {
+    return false;
+  }
+}
+function stripTrailingDot(value) {
+  const trimmed = value?.trim();
+  if (!trimmed) {
+    return null;
+  }
+  return trimmed.replace(/\.$/, "");
+}
+async function readTailscaleStatus() {
+  const peers = await readTailscalePeers();
+  return {
+    available: peers.length > 0,
+    peers,
+    onlineCount: peers.filter((p) => p.online).length
+  };
+}
+function formatIssueWarning(issue) {
+  return issue.action ? `${issue.title} \u2014 ${issue.summary} ${issue.action}` : `${issue.title} \u2014 ${issue.summary}`;
+}
+function computeIssues(health, localNode, nodes, tailscale2) {
+  const issues = [];
+  if (!health.reachable) {
+    issues.push({
+      code: "broker_unreachable",
+      severity: "error",
+      title: "Broker not reachable",
+      summary: "The mesh page cannot reach the local broker yet, so peer status is incomplete.",
+      action: "Start the broker, then reload this page.",
+      actionCommand: null
+    });
+    return issues;
+  }
+  if (localNode?.advertiseScope === "local") {
+    issues.push({
       code: "local_only",
       severity: "warning",
       title: "Not announced to peers",
@@ -17090,7 +20719,7 @@ function computeIssues(health, localNode, nodes, tailscale) {
     });
   }
   const remoteNodes = Object.values(nodes).filter((n) => n.id !== localNode?.id);
-  if (!tailscale.available && remoteNodes.length === 0) {
+  if (!tailscale2.available && remoteNodes.length === 0) {
     issues.push({
       code: "discovery_unconfigured",
       severity: "warning",
@@ -17179,7 +20808,7 @@ function filterCurrentMeshNodes(allNodes, meshId, localNodeId, now) {
 }
 async function loadMeshStatus() {
   const brokerUrl = resolveScoutBrokerUrl();
-  const [health, context, tailscale] = await Promise.all([
+  const [health, context, tailscale2] = await Promise.all([
     readScoutBrokerHealth(brokerUrl),
     loadScoutBrokerContext(brokerUrl),
     readTailscaleStatus()
@@ -17189,9 +20818,9 @@ async function loadMeshStatus() {
   const meshId = health.meshId ?? localNode?.meshId ?? null;
   const identity = computeIdentitySummary(health, localNode, meshId);
   const nodes = filterCurrentMeshNodes(allNodes, meshId, localNode?.id, Date.now());
-  const issues = computeIssues(health, localNode, nodes, tailscale);
+  const issues = computeIssues(health, localNode, nodes, tailscale2);
   const warnings = issues.map(formatIssueWarning);
-  return { brokerUrl, health, localNode, meshId, identity, nodes, tailscale, issues, warnings };
+  return { brokerUrl, health, localNode, meshId, identity, nodes, tailscale: tailscale2, issues, warnings };
 }
 function preferredAnnounceHost(self, currentBrokerUrl) {
   const dnsName = stripTrailingDot(self?.dnsName);
@@ -17316,10 +20945,10 @@ function resolveConversationRouting(conversationId) {
   return { directAgentId, senderId };
 }
 function resolveBundledStaticClientRoot(moduleUrl = import.meta.url) {
-  return resolve8(dirname11(fileURLToPath7(moduleUrl)), "client");
+  return resolve9(dirname12(fileURLToPath7(moduleUrl)), "client");
 }
 function resolveSourceStaticClientRoot(moduleUrl = import.meta.url) {
-  return resolve8(dirname11(fileURLToPath7(moduleUrl)), "../dist/client");
+  return resolve9(dirname12(fileURLToPath7(moduleUrl)), "../dist/client");
 }
 function resolveStaticRoot(staticRoot) {
   const configured = staticRoot?.trim();
@@ -17327,7 +20956,7 @@ function resolveStaticRoot(staticRoot) {
     return configured;
   }
   const bundled = resolveBundledStaticClientRoot(import.meta.url);
-  if (existsSync11(resolve8(bundled, "index.html"))) {
+  if (existsSync12(resolve9(bundled, "index.html"))) {
     return bundled;
   }
   return resolveSourceStaticClientRoot(import.meta.url);
@@ -17365,6 +20994,10 @@ async function createOpenScoutWebServer(options) {
   app.get("/api/shell-state", async (c) => c.json(await shellStateCache.get()));
   app.get("/api/shell-state/refresh", async (c) => c.json(await shellStateCache.refresh()));
   app.get("/api/agents", (c) => c.json(queryAgents()));
+  app.get("/api/agents/:id/observe", async (c) => {
+    const payload = await loadAgentObservePayload(c.req.param("id"));
+    return payload ? c.json(payload) : c.json({ error: "not found" }, 404);
+  });
   app.get("/api/activity", (c) => c.json(queryActivity()));
   app.get("/api/heartrate", (c) => c.json(queryHeartrate()));
   app.get("/api/fleet", (c) => c.json(queryFleet({
@@ -17608,8 +21241,8 @@ async function createOpenScoutWebServer(options) {
 // ../hudson/packages/hudson-relay/src/relay/session.ts
 import { createRequire } from "module";
 import { execSync as execSync2 } from "child_process";
-import { existsSync as existsSync12, mkdirSync as mkdirSync6, writeFileSync as writeFileSync6 } from "fs";
-import { join as join18, dirname as pathDirname } from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync6, writeFileSync as writeFileSync6 } from "fs";
+import { join as join19, dirname as pathDirname } from "path";
 var require2 = createRequire(import.meta.url);
 var pty = require2("node-pty");
 var DEFAULT_ORPHAN_TTL_MS = 30 * 60 * 1000;
@@ -17626,7 +21259,7 @@ function send(ws, data) {
 function resolveCwd(raw2) {
   const home = process.env.HOME || "/tmp";
   const expanded = (raw2 || home).replace(/^~/, home);
-  if (existsSync12(expanded))
+  if (existsSync13(expanded))
     return expanded;
   try {
     mkdirSync6(expanded, { recursive: true });
@@ -17662,11 +21295,11 @@ function tmuxSessionExists2(name) {
 }
 function bootstrapFiles(cwd, files, sessionId) {
   for (const [relPath, content] of Object.entries(files)) {
-    const absPath = join18(cwd, relPath);
-    if (!existsSync12(absPath)) {
+    const absPath = join19(cwd, relPath);
+    if (!existsSync13(absPath)) {
       try {
         const dir = pathDirname(absPath);
-        if (!existsSync12(dir))
+        if (!existsSync13(dir))
           mkdirSync6(dir, { recursive: true });
         writeFileSync6(absPath, content, "utf-8");
         console.log(`[relay] Session ${sessionId}: bootstrapped ${relPath}`);
@@ -17721,7 +21354,7 @@ function createSession(ws, msg) {
       return null;
     }
   }
-  if (!existsSync12(agentBin)) {
+  if (!existsSync13(agentBin)) {
     const reason = `${agent} binary not found at ${agentBin}`;
     console.error(`[relay] Session ${id} failed: ${reason}`);
     send(ws, { type: "session:error", error: reason });
@@ -17881,7 +21514,7 @@ function destroy(sessionId) {
 
 // packages/web/server/relay.ts
 import { mkdir as mkdir7 } from "fs/promises";
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 var UPLOAD_DIR = "/tmp/scout-uploads";
 async function handleRelayUpload(req) {
@@ -17891,7 +21524,7 @@ async function handleRelayUpload(req) {
   }
   await mkdir7(UPLOAD_DIR, { recursive: true });
   const filename = `${randomUUID3()}-${name}`;
-  const filepath = join19(UPLOAD_DIR, filename);
+  const filepath = join20(UPLOAD_DIR, filename);
   await Bun.write(filepath, Buffer.from(data, "base64"));
   return Response.json({ path: filepath });
 }
@@ -17996,13 +21629,13 @@ function resolveStaticRoot2() {
   if (process.env.OPENSCOUT_WEB_STATIC_ROOT?.trim()) {
     return process.env.OPENSCOUT_WEB_STATIC_ROOT.trim();
   }
-  const selfDir = dirname12(fileURLToPath8(import.meta.url));
-  const siblingClientRoot = join20(selfDir, "client");
-  if (existsSync13(join20(siblingClientRoot, "index.html"))) {
+  const selfDir = dirname13(fileURLToPath8(import.meta.url));
+  const siblingClientRoot = join21(selfDir, "client");
+  if (existsSync14(join21(siblingClientRoot, "index.html"))) {
     return siblingClientRoot;
   }
-  const sourceDistClientRoot = resolve9(selfDir, "../dist/client");
-  if (existsSync13(join20(sourceDistClientRoot, "index.html"))) {
+  const sourceDistClientRoot = resolve10(selfDir, "../dist/client");
+  if (existsSync14(join21(sourceDistClientRoot, "index.html"))) {
     return sourceDistClientRoot;
   }
   return;