@openscout/scout 0.2.69 → 0.2.70

package/dist/runtime/broker-daemon.mjs

@@ -16,12 +16,13 @@ var __export = (target, all) => {
 
 // packages/runtime/src/broker-daemon.ts
 import { spawn as spawn5 } from "child_process";
+import { randomUUID as randomUUID4 } from "crypto";
 import { createServer } from "http";
 import { existsSync as existsSync19, mkdirSync as mkdirSync8, openSync as openSync3 } from "fs";
 import { lstat, mkdir as mkdir8, stat as stat5, unlink } from "fs/promises";
 import { createRequire } from "module";
 import { hostname as hostname4 } from "os";
-import { basename as basename11, dirname as dirname15, join as join25, resolve as resolve8 } from "path";
+import { basename as basename12, dirname as dirname16, join as join25, resolve as resolve8 } from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
 
 // node_modules/.bun/@trpc+server@11.16.0+1fb4c65d43e298b9/node_modules/@trpc/server/dist/codes-DagpWZLc.mjs
@@ -16320,6 +16321,7 @@ var RAW_MAX_STRING_LEN = 1000;
 var RAW_MAX_ARRAY_ITEMS = 25;
 var RAW_MAX_OBJECT_KEYS = 50;
 var RECENT_TRANSCRIPT_READ_BYTES = 512 * 1024;
+var RECENT_TRANSCRIPT_LINES_PER_FILE = 200;
 var RECENT_TRANSCRIPT_MAX_FILES = readPositiveIntEnv3("OPENSCOUT_TAIL_RECENT_TRANSCRIPT_MAX_FILES", 24);
 var sources = [ClaudeSource, CodexSource];
 var watchers = new Map;
@@ -16646,6 +16648,15 @@ function stopLoopIfIdle() {
   }
   watchers.clear();
 }
+async function getTailDiscovery(force = false) {
+  if (force) {
+    return runDiscovery("deep", { pruneMissing: true });
+  }
+  if (lastDiscovery && Date.now() - lastDiscovery.generatedAt <= DISCOVERY_CACHE_MAX_AGE_MS) {
+    return lastDiscovery;
+  }
+  return runDiscovery("shallow", { pruneMissing: true });
+}
 function subscribeTail(handler) {
   subscribers2.add(handler);
   ensureLoopRunning();
@@ -16664,6 +16675,78 @@ function subscribeTail(handler) {
 function snapshotRecentEvents(limit = 500) {
   return aggregateBuffer.slice(-limit);
 }
+async function readRecentLiveEvents(limit = 500) {
+  if (watchers.size === 0) {
+    await runDiscovery("shallow", { pruneMissing: true });
+  } else if (!lastDiscovery || Date.now() - lastDiscovery.generatedAt > DISCOVERY_CACHE_MAX_AGE_MS) {
+    await runDiscovery("hot", { pruneMissing: false });
+  }
+  await pumpAllWatchers();
+  return snapshotRecentEvents(limit);
+}
+async function readRecentTranscriptLines(path, maxLines = RECENT_TRANSCRIPT_LINES_PER_FILE) {
+  let handle = null;
+  try {
+    const stats = await stat(path);
+    if (stats.size <= 0)
+      return [];
+    const start = Math.max(0, stats.size - RECENT_TRANSCRIPT_READ_BYTES);
+    const length = stats.size - start;
+    const buffer = Buffer.alloc(length);
+    handle = await open(path, "r");
+    await handle.read(buffer, 0, length, start);
+    const lines = buffer.toString("utf8").split(`
+`);
+    if (start > 0) {
+      lines.shift();
+    }
+    return lines.filter(Boolean).slice(-maxLines);
+  } catch {
+    return [];
+  } finally {
+    await handle?.close().catch(() => {});
+  }
+}
+async function readRecentTranscriptEvents(limit = 50, options) {
+  const discovery = options?.discovery ?? await getTailDiscovery();
+  const events = [];
+  const seenTranscripts = new Set;
+  const seenEvents = new Set;
+  const transcriptReadLimit = Math.min(RECENT_TRANSCRIPT_MAX_FILES, Math.max(12, limit));
+  for (const transcript of discovery.transcripts.slice(0, transcriptReadLimit)) {
+    const key = transcriptKey(transcript);
+    if (seenTranscripts.has(key))
+      continue;
+    seenTranscripts.add(key);
+    const source = sources.find((candidate) => candidate.name === transcript.source);
+    if (!source)
+      continue;
+    const process3 = processForTranscript(transcript, discovery.processes);
+    const lines = await readRecentTranscriptLines(transcript.transcriptPath, options?.perTranscriptLineLimit);
+    lines.forEach((line, index) => {
+      const event = source.parseLine(line, {
+        process: process3,
+        transcript,
+        transcriptPath: transcript.transcriptPath,
+        lineOffset: index
+      });
+      if (event) {
+        const compacted = compactEvent(event);
+        const eventKey = [
+          compacted.source,
+          compacted.sessionId,
+          compacted.kind,
+          compacted.summary
+        ].join("\x00");
+        if (!seenEvents.has(eventKey)) {
+          seenEvents.add(eventKey);
+          events.push(compacted);
+        }
+      }
+    });
+  }
+  return events.sort((left, right) => right.ts - left.ts).slice(0, limit);
+}
 // packages/runtime/src/harness-topology/service.ts
 import { createHash } from "crypto";
 import { homedir as homedir5 } from "os";
@@ -17798,6 +17881,16 @@ var tailEventsInput = exports_external.object({
   since: exports_external.string().optional(),
   sources: exports_external.array(exports_external.string()).optional()
 }).optional();
+var tailRecentInput = exports_external.object({
+  limit: exports_external.number().int().min(1).max(1000).optional(),
+  sources: exports_external.array(exports_external.string()).optional(),
+  kinds: exports_external.array(exports_external.string()).optional(),
+  sessionId: exports_external.string().optional(),
+  project: exports_external.string().optional(),
+  cwd: exports_external.string().optional(),
+  query: exports_external.string().optional(),
+  transcripts: exports_external.boolean().optional()
+}).optional();
 var topologyEventsInput = exports_external.object({
   since: exports_external.string().optional(),
   sources: exports_external.array(exports_external.string()).optional()
@@ -17946,6 +18039,48 @@ function topologyEventIterable(sources2, signal) {
     }
   };
 }
+function normalizedFilterSet(values) {
+  const normalized = values?.map((value) => value.trim().toLowerCase()).filter(Boolean);
+  return normalized && normalized.length > 0 ? new Set(normalized) : null;
+}
+function textMatches(value, query) {
+  if (!query)
+    return true;
+  return (value ?? "").toLowerCase().includes(query);
+}
+function tailEventMatches(event, input) {
+  const sources2 = normalizedFilterSet(input?.sources);
+  if (sources2 && !sources2.has(event.source.toLowerCase()))
+    return false;
+  const kinds = normalizedFilterSet(input?.kinds);
+  if (kinds && !kinds.has(event.kind.toLowerCase()))
+    return false;
+  const sessionId = input?.sessionId?.trim();
+  if (sessionId && event.sessionId !== sessionId)
+    return false;
+  const project = input?.project?.trim().toLowerCase();
+  if (project && !textMatches(event.project, project))
+    return false;
+  const cwd = input?.cwd?.trim().toLowerCase();
+  if (cwd && !textMatches(event.cwd, cwd))
+    return false;
+  const query = input?.query?.trim().toLowerCase();
+  if (query) {
+    const haystack = [
+      event.source,
+      event.kind,
+      event.sessionId,
+      event.project,
+      event.cwd,
+      event.harness,
+      event.summary
+    ].join(`
+`).toLowerCase();
+    if (!haystack.includes(query))
+      return false;
+  }
+  return true;
+}
 var controlRouter = t.router({
   events: t.procedure.input(controlEventsInput).subscription(async function* ({ input, signal }) {
     const kinds = input?.kinds;
@@ -17971,6 +18106,33 @@ var controlRouter = t.router({
   })
 });
 var tailRouter = t.router({
+  recent: t.procedure.input(tailRecentInput).query(async ({ input }) => {
+    const limit = input?.limit ?? TAIL_BACKLOG_LIMIT;
+    const bufferedEvents = await readRecentLiveEvents(limit);
+    const eventsById = new Map;
+    if (input?.transcripts) {
+      const transcriptEvents = await readRecentTranscriptEvents(limit, {
+        perTranscriptLineLimit: Math.min(200, Math.max(50, limit))
+      });
+      for (const event of transcriptEvents) {
+        eventsById.set(event.id, event);
+      }
+    }
+    for (const event of bufferedEvents) {
+      eventsById.set(event.id, event);
+    }
+    const events = [...eventsById.values()].filter((event) => tailEventMatches(event, input)).sort((left, right) => {
+      if (left.ts === right.ts)
+        return left.id.localeCompare(right.id);
+      return left.ts - right.ts;
+    }).slice(-limit);
+    return {
+      generatedAt: Date.now(),
+      limit,
+      cursor: events.at(-1)?.id ?? null,
+      events
+    };
+  }),
   events: t.procedure.input(tailEventsInput).subscription(async function* ({ input, signal }) {
     const sources2 = input?.sources;
     const filter = sources2 && sources2.length > 0 ? new Set(sources2) : null;
@@ -18512,6 +18674,31 @@ function buildUnsignedMeshPresence(input) {
     ...input.metadata ? { metadata: input.metadata } : {}
   };
 }
+// packages/protocol/src/channel-identity.ts
+var CHANNEL_ID_PREFIX = "c.";
+var CHANNEL_NATURAL_KEY_METADATA = "naturalKey";
+function mintChannelId(randomUuid) {
+  return `${CHANNEL_ID_PREFIX}${randomUuid().toLowerCase()}`;
+}
+function directChannelNaturalKey(participantIds) {
+  return `direct:${stableIdentityParts(participantIds).join(",")}`;
+}
+function namedChannelNaturalKey(channel) {
+  return `channel:${encodeIdentityPart(channel.trim().toLowerCase() || "shared")}`;
+}
+function systemChannelNaturalKey(name) {
+  return `system:${encodeIdentityPart(name.trim().toLowerCase() || "system")}`;
+}
+function channelNaturalKeyFromMetadata(metadata) {
+  const value = metadata?.[CHANNEL_NATURAL_KEY_METADATA];
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function stableIdentityParts(values) {
+  return Array.from(new Set(values.map((value) => value.trim()).filter(Boolean))).sort().map(encodeIdentityPart);
+}
+function encodeIdentityPart(value) {
+  return encodeURIComponent(value).replace(/[!'()*]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`);
+}
 // packages/protocol/src/collaboration.ts
 function isQuestionTerminalState(state) {
   return state === "closed" || state === "declined";
@@ -20273,29 +20460,6 @@ function resolveAgentLabel(snapshot, label, options) {
         return agnosticResolution;
       }
     }
-    const fallbackCandidates = buildAgentLabelCandidates(snapshot, options.helpers, {
-      includeStale: true
-    });
-    const fallbackDiagnosis = diagnoseAgentIdentity(identity2, fallbackCandidates);
-    if (fallbackDiagnosis.kind === "resolved") {
-      return {
-        kind: "resolved",
-        agent: fallbackDiagnosis.match.agent
-      };
-    }
-    if (fallbackDiagnosis.kind === "ambiguous") {
-      return {
-        kind: "ambiguous",
-        label: identity2.label,
-        candidates: fallbackDiagnosis.candidates.map((candidate) => candidate.agent)
-      };
-    }
-    if (harnessAgnosticIdentity) {
-      const agnosticFallbackResolution = resolutionFromDiagnosis(diagnoseAgentIdentity(harnessAgnosticIdentity, fallbackCandidates), identity2.label);
-      if (agnosticFallbackResolution) {
-        return agnosticFallbackResolution;
-      }
-    }
     return { kind: "unknown", label: identity2.label };
   }
   const preferLocal = options.preferLocalNodeId?.trim();
@@ -21734,7 +21898,7 @@ import { randomUUID as randomUUID2 } from "crypto";
 import { execFileSync as execFileSync3, execSync } from "child_process";
 import { existsSync as existsSync14, readFileSync as readFileSync7 } from "fs";
 import { mkdir as mkdir7, rm as rm5, stat as stat4, writeFile as writeFile7 } from "fs/promises";
-import { basename as basename9, dirname as dirname10, join as join19, resolve as resolve7 } from "path";
+import { basename as basename10, dirname as dirname11, join as join19, resolve as resolve7 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 
 // packages/runtime/src/dispatch-stalled.ts
@@ -22945,6 +23109,7 @@ class SessionRegistry {
   }
 }
 // packages/agent-sessions/src/history.ts
+import { basename as basename6, dirname as dirname4 } from "path";
 function normalizeTimestamp(value) {
   if (typeof value === "number") {
     if (!Number.isFinite(value)) {
@@ -23033,6 +23198,59 @@ function renderToolResultContent(content) {
   }
   return stringifyUnknown(content);
 }
+function renderContentPartsText(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  return content.map((entry) => {
+    if (typeof entry === "string") {
+      return entry;
+    }
+    if (!isRecord(entry)) {
+      return "";
+    }
+    if (typeof entry.text === "string") {
+      return entry.text;
+    }
+    if (typeof entry.content === "string") {
+      return entry.content;
+    }
+    return "";
+  }).filter(Boolean).join(`
+`);
+}
+function extractReasoningText(item) {
+  const summary = Array.isArray(item.summary) ? item.summary : [];
+  const content = Array.isArray(item.content) ? item.content : [];
+  const summaryText = summary.map((entry) => {
+    if (typeof entry === "string") {
+      return entry;
+    }
+    const record2 = entry;
+    if (typeof record2.text === "string") {
+      return record2.text;
+    }
+    if (typeof record2.summary === "string") {
+      return record2.summary;
+    }
+    return "";
+  }).filter(Boolean).join(`
+`);
+  const contentText = content.map((entry) => {
+    if (typeof entry === "string") {
+      return entry;
+    }
+    const record2 = entry;
+    return typeof record2.text === "string" ? record2.text : "";
+  }).filter(Boolean).join(`
+`);
+  return [summaryText, contentText].filter(Boolean).join(`
+
+`).trim();
+}
 function extractQuestionOptions(firstQuestion) {
   const options = Array.isArray(firstQuestion.options) ? firstQuestion.options : [];
   return options.map((option) => {
@@ -23709,6 +23927,505 @@ class ClaudeCodeHistoryParser {
     });
   }
 }
+
+class CodexHistoryParser {
+  session;
+  baseTimestampMs;
+  events = [];
+  currentTurn = null;
+  turnCounter = 0;
+  blockIndex = 0;
+  blockById = new Map;
+  toolBlockMap = new Map;
+  assistantMessageTextThisTurn = new Set;
+  inputTokens = 0;
+  outputTokens = 0;
+  reasoningOutputTokens = 0;
+  cachedInputTokens = 0;
+  tokenEventCount = 0;
+  constructor(session, baseTimestampMs) {
+    this.session = session;
+    this.baseTimestampMs = baseTimestampMs;
+  }
+  parse(content) {
+    const lines = content.split(/\r?\n/u);
+    let parsedLineCount = 0;
+    let skippedLineCount = 0;
+    let lineCount = 0;
+    let lastCapturedAt = this.baseTimestampMs;
+    for (let index = 0;index < lines.length; index += 1) {
+      const rawLine = lines[index];
+      const trimmed = rawLine.trim();
+      if (!trimmed) {
+        continue;
+      }
+      lineCount += 1;
+      let record2;
+      try {
+        const parsed = JSON.parse(trimmed);
+        if (!isRecord(parsed)) {
+          skippedLineCount += 1;
+          continue;
+        }
+        record2 = parsed;
+      } catch {
+        skippedLineCount += 1;
+        continue;
+      }
+      const capturedAt = extractRecordTimestamp(record2) ?? this.baseTimestampMs + index;
+      lastCapturedAt = capturedAt;
+      if (this.handleRecord(record2, capturedAt)) {
+        parsedLineCount += 1;
+      } else {
+        skippedLineCount += 1;
+      }
+    }
+    if (this.persistUsageMetadata()) {
+      this.emitSessionUpdate(lastCapturedAt);
+    }
+    return {
+      events: this.events,
+      lineCount,
+      parsedLineCount,
+      skippedLineCount
+    };
+  }
+  handleRecord(record2, capturedAt) {
+    const type = maybeString(record2.type);
+    if (!type) {
+      return false;
+    }
+    switch (type) {
+      case "session_meta":
+        this.handleSessionMeta(record2, capturedAt);
+        return true;
+      case "turn_context":
+        this.handleTurnContext(record2, capturedAt);
+        return true;
+      case "event_msg":
+        this.handleEventMessage(record2, capturedAt);
+        return true;
+      case "response_item":
+        this.handleResponseItem(record2, capturedAt);
+        return true;
+      case "compacted":
+        return true;
+      default:
+        return false;
+    }
+  }
+  handleSessionMeta(record2, capturedAt) {
+    const payload = isRecord(record2.payload) ? record2.payload : {};
+    let changed = false;
+    const providerMeta = this.ensureProviderMeta();
+    const externalSessionId = maybeString(payload.id);
+    if (externalSessionId && providerMeta.externalSessionId !== externalSessionId) {
+      providerMeta.externalSessionId = externalSessionId;
+      changed = true;
+    }
+    const cwd = maybeString(payload.cwd);
+    if (cwd && this.session.cwd !== cwd) {
+      this.session.cwd = cwd;
+      if (!this.session.name || /^\d+$/u.test(this.session.name)) {
+        this.session.name = basename6(cwd) || "Codex Session";
+      }
+      changed = true;
+    }
+    const git = isRecord(payload.git) ? payload.git : null;
+    const runtime = this.ensureObserveMetaRecord("observeRuntime");
+    changed = this.assignObserveString(runtime, "originator", payload.originator) || changed;
+    changed = this.assignObserveString(runtime, "cliVersion", payload.cli_version) || changed;
+    changed = this.assignObserveString(runtime, "source", payload.source) || changed;
+    changed = this.assignObserveString(runtime, "threadSource", payload.thread_source) || changed;
+    changed = this.assignObserveString(runtime, "modelProvider", payload.model_provider) || changed;
+    changed = this.assignObserveString(runtime, "gitBranch", git?.branch) || changed;
+    changed = this.assignObserveString(runtime, "gitCommitHash", git?.commit_hash) || changed;
+    changed = this.assignObserveString(runtime, "repositoryUrl", git?.repository_url) || changed;
+    if (changed) {
+      this.emitSessionUpdate(capturedAt);
+    }
+  }
+  handleTurnContext(record2, capturedAt) {
+    const payload = isRecord(record2.payload) ? record2.payload : {};
+    let changed = false;
+    const cwd = maybeString(payload.cwd);
+    if (cwd && this.session.cwd !== cwd) {
+      this.session.cwd = cwd;
+      changed = true;
+    }
+    const model = maybeString(payload.model);
+    if (model && this.session.model !== model) {
+      this.session.model = model;
+      changed = true;
+    }
+    const runtime = this.ensureObserveMetaRecord("observeRuntime");
+    changed = this.assignObserveString(runtime, "approvalPolicy", payload.approval_policy) || changed;
+    changed = this.assignObserveString(runtime, "currentDate", payload.current_date) || changed;
+    changed = this.assignObserveString(runtime, "timezone", payload.timezone) || changed;
+    changed = this.assignObserveString(runtime, "effort", payload.effort) || changed;
+    changed = this.assignObserveString(runtime, "personality", payload.personality) || changed;
+    if (isRecord(payload.sandbox_policy) && runtime.sandboxPolicy !== payload.sandbox_policy) {
+      runtime.sandboxPolicy = payload.sandbox_policy;
+      changed = true;
+    }
+    if (changed) {
+      this.emitSessionUpdate(capturedAt);
+    }
+  }
+  handleEventMessage(record2, capturedAt) {
+    const payload = isRecord(record2.payload) ? record2.payload : {};
+    const eventType = maybeString(payload.type);
+    if (!eventType) {
+      return;
+    }
+    switch (eventType) {
+      case "task_started": {
+        const startedAt = normalizeTimestamp(payload.started_at) ?? capturedAt;
+        this.startTurn(startedAt, maybeString(payload.turn_id));
+        break;
+      }
+      case "user_message":
+        this.ensureTurn(capturedAt);
+        break;
+      case "agent_message": {
+        const message = maybeString(payload.message);
+        if (message) {
+          this.appendCompletedText(capturedAt, message);
+          this.assistantMessageTextThisTurn.add(message);
+        }
+        break;
+      }
+      case "patch_apply_end":
+        this.handleToolOutput(capturedAt, maybeString(payload.call_id), [maybeString(payload.stdout), maybeString(payload.stderr)].filter(Boolean).join(`
+`), payload.success === false);
+        break;
+      case "token_count":
+        this.captureTokenUsage(payload.info);
+        break;
+      case "task_complete":
+        this.endTurn("completed", normalizeTimestamp(payload.completed_at) ?? capturedAt);
+        break;
+      case "context_compacted":
+      case "web_search_end":
+        break;
+      default:
+        break;
+    }
+  }
+  handleResponseItem(record2, capturedAt) {
+    const payload = isRecord(record2.payload) ? record2.payload : {};
+    const itemType = maybeString(payload.type);
+    if (!itemType) {
+      return;
+    }
+    switch (itemType) {
+      case "message":
+        this.handleResponseMessage(payload, capturedAt);
+        break;
+      case "reasoning":
+        this.handleReasoning(payload, capturedAt);
+        break;
+      case "function_call":
+      case "custom_tool_call":
+        this.handleToolCall(payload, capturedAt);
+        break;
+      case "function_call_output":
+      case "custom_tool_call_output":
+        this.handleToolOutput(capturedAt, maybeString(payload.call_id), renderToolResultContent(payload.output), false);
+        break;
+      case "web_search_call":
+        this.handleWebSearchCall(payload, capturedAt);
+        break;
+      default:
+        break;
+    }
+  }
+  handleResponseMessage(payload, capturedAt) {
+    const role = maybeString(payload.role);
+    if (role !== "assistant") {
+      return;
+    }
+    const text = renderContentPartsText(payload.content).trim();
+    if (!text || this.assistantMessageTextThisTurn.has(text)) {
+      return;
+    }
+    this.appendCompletedText(capturedAt, text);
+    this.assistantMessageTextThisTurn.add(text);
+  }
+  handleReasoning(payload, capturedAt) {
+    const text = extractReasoningText(payload);
+    if (!text) {
+      return;
+    }
+    const turn = this.ensureTurn(capturedAt);
+    const block = this.startBlock(turn, capturedAt, {
+      type: "reasoning",
+      text,
+      status: "completed"
+    });
+    this.emitBlockEnd(capturedAt, turn, block, "completed");
+  }
+  handleToolCall(payload, capturedAt) {
+    const turn = this.ensureTurn(capturedAt);
+    const toolName = maybeString(payload.name) ?? "unknown";
+    const toolCallId = maybeString(payload.call_id) ?? `${turn.id}:tool:${this.blockIndex}`;
+    const input = this.parseToolInput(payload.arguments ?? payload.input);
+    const action = this.buildAction(toolName, toolCallId, input);
+    const block = this.startBlock(turn, capturedAt, {
+      id: `${turn.id}:action:${toolCallId}`,
+      type: "action",
+      action,
+      status: "streaming"
+    });
+    this.toolBlockMap.set(toolCallId, block.id);
+  }
+  handleWebSearchCall(payload, capturedAt) {
+    const turn = this.ensureTurn(capturedAt);
+    const toolCallId = `${turn.id}:web-search:${this.blockIndex}`;
+    const action = {
+      kind: "tool_call",
+      toolName: "web_search",
+      toolCallId,
+      input: payload.action,
+      result: payload.status,
+      status: maybeString(payload.status) === "failed" ? "failed" : "completed",
+      output: ""
+    };
+    const block = this.startBlock(turn, capturedAt, {
+      id: `${turn.id}:action:${toolCallId}`,
+      type: "action",
+      action,
+      status: "completed"
+    });
+    this.emitBlockEnd(capturedAt, turn, block, "completed");
+  }
+  parseToolInput(value) {
+    if (typeof value !== "string") {
+      return value;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+      return "";
+    }
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      return value;
+    }
+  }
+  buildAction(toolName, toolCallId, input) {
+    const inputRecord = isRecord(input) ? input : {};
+    if (toolName === "exec_command") {
+      return {
+        kind: "command",
+        command: maybeString(inputRecord.cmd) ?? "",
+        status: "running",
+        output: ""
+      };
+    }
+    return {
+      kind: "tool_call",
+      toolName,
+      toolCallId,
+      input,
+      status: "running",
+      output: ""
+    };
+  }
+  handleToolOutput(capturedAt, toolCallId, output, isError) {
+    if (!toolCallId) {
+      return;
+    }
+    const blockId = this.toolBlockMap.get(toolCallId);
+    const turn = this.currentTurn;
+    if (!blockId || !turn) {
+      return;
+    }
+    if (output) {
+      this.emitEvent(capturedAt, {
+        event: "block:action:output",
+        sessionId: this.session.id,
+        turnId: turn.id,
+        blockId,
+        output
+      });
+    }
+    const exitCode = this.extractExitCode(output);
+    const status = isError || exitCode != null && exitCode !== 0 ? "failed" : "completed";
+    this.emitEvent(capturedAt, {
+      event: "block:action:status",
+      sessionId: this.session.id,
+      turnId: turn.id,
+      blockId,
+      status,
+      ...exitCode != null ? { meta: { exitCode } } : {}
+    });
+    const block = this.blockById.get(blockId);
+    if (block) {
+      this.emitBlockEnd(capturedAt, turn, block, status === "failed" ? "failed" : "completed");
+    }
+    this.toolBlockMap.delete(toolCallId);
+  }
+  extractExitCode(output) {
+    const match = output.match(/(?:exit code|exited with code):\s*(-?\d+)/iu);
+    if (!match) {
+      return null;
+    }
+    const exitCode = Number(match[1]);
+    return Number.isFinite(exitCode) ? exitCode : null;
+  }
+  captureTokenUsage(info) {
+    if (!isRecord(info)) {
+      return;
+    }
+    const total = isRecord(info.total_token_usage) ? info.total_token_usage : {};
+    this.inputTokens = maybeNumber(total.input_tokens) ?? this.inputTokens;
+    this.outputTokens = maybeNumber(total.output_tokens) ?? this.outputTokens;
+    this.reasoningOutputTokens = maybeNumber(total.reasoning_output_tokens) ?? this.reasoningOutputTokens;
+    this.cachedInputTokens = maybeNumber(total.cached_input_tokens) ?? this.cachedInputTokens;
+    this.tokenEventCount += 1;
+  }
+  persistUsageMetadata() {
+    if (this.tokenEventCount === 0) {
+      return false;
+    }
+    const usage = this.ensureObserveMetaRecord("observeUsage");
+    let changed = false;
+    const assignNumber = (key, value) => {
+      if (value > 0 && usage[key] !== value) {
+        usage[key] = value;
+        changed = true;
+      }
+    };
+    assignNumber("inputTokens", this.inputTokens);
+    assignNumber("outputTokens", this.outputTokens);
+    assignNumber("reasoningOutputTokens", this.reasoningOutputTokens);
+    assignNumber("cacheReadInputTokens", this.cachedInputTokens);
+    assignNumber("tokenEvents", this.tokenEventCount);
+    return changed;
+  }
+  startTurn(capturedAt, turnId) {
+    if (this.currentTurn) {
+      this.endTurn("stopped", capturedAt);
+    }
+    this.turnCounter += 1;
+    this.blockIndex = 0;
+    this.blockById.clear();
+    this.toolBlockMap.clear();
+    this.assistantMessageTextThisTurn.clear();
+    this.session.status = "active";
+    this.emitSessionUpdate(capturedAt);
+    const turn = {
+      id: turnId || `history-turn-${this.turnCounter}`,
+      sessionId: this.session.id,
+      status: "started",
+      startedAt: new Date(capturedAt).toISOString(),
+      blocks: []
+    };
+    this.currentTurn = turn;
+    this.emitEvent(capturedAt, {
+      event: "turn:start",
+      sessionId: this.session.id,
+      turn
+    });
+    return turn;
+  }
+  ensureTurn(capturedAt) {
+    return this.currentTurn ?? this.startTurn(capturedAt);
+  }
+  endTurn(status, capturedAt) {
+    const turn = this.currentTurn;
+    if (!turn) {
+      return;
+    }
+    turn.status = status;
+    turn.endedAt = new Date(capturedAt).toISOString();
+    this.emitEvent(capturedAt, {
+      event: "turn:end",
+      sessionId: this.session.id,
+      turnId: turn.id,
+      status
+    });
+    this.currentTurn = null;
+    this.blockById.clear();
+    this.toolBlockMap.clear();
+    this.assistantMessageTextThisTurn.clear();
+    this.session.status = "idle";
+    this.emitSessionUpdate(capturedAt);
+  }
+  appendCompletedText(capturedAt, text) {
+    const turn = this.ensureTurn(capturedAt);
+    const block = this.startBlock(turn, capturedAt, {
+      type: "text",
+      text,
+      status: "completed"
+    });
+    this.emitBlockEnd(capturedAt, turn, block, "completed");
+  }
+  startBlock(turn, capturedAt, partial2) {
+    const block = {
+      ...partial2,
+      id: partial2.id || `${turn.id}:block:${this.blockIndex}`,
+      turnId: turn.id,
+      index: this.blockIndex
+    };
+    this.blockIndex += 1;
+    turn.blocks.push(block);
+    this.blockById.set(block.id, block);
+    this.emitEvent(capturedAt, {
+      event: "block:start",
+      sessionId: this.session.id,
+      turnId: turn.id,
+      block
+    });
+    return block;
+  }
+  emitBlockEnd(capturedAt, turn, block, status) {
+    block.status = status;
+    this.emitEvent(capturedAt, {
+      event: "block:end",
+      sessionId: this.session.id,
+      turnId: turn.id,
+      blockId: block.id,
+      status
+    });
+  }
+  ensureProviderMeta() {
+    const providerMeta = isRecord(this.session.providerMeta) ? this.session.providerMeta : {};
+    this.session.providerMeta = providerMeta;
+    return providerMeta;
+  }
+  ensureObserveMetaRecord(key) {
+    const providerMeta = this.ensureProviderMeta();
+    const existing = providerMeta[key];
+    if (isRecord(existing)) {
+      return existing;
+    }
+    const next = {};
+    providerMeta[key] = next;
+    return next;
+  }
+  assignObserveString(target, key, value) {
+    const next = maybeString(value);
+    if (!next || target[key] === next) {
+      return false;
+    }
+    target[key] = next;
+    return true;
+  }
+  emitSessionUpdate(capturedAt) {
+    this.emitEvent(capturedAt, {
+      event: "session:update",
+      session: { ...this.session }
+    });
+  }
+  emitEvent(capturedAt, event) {
+    this.events.push({
+      capturedAt,
+      event: structuredClone(event)
+    });
+  }
+}
 // packages/agent-sessions/src/adapters/claude-code.ts
 import { existsSync as existsSync8, readdirSync as readdirSync5, statSync as statSync5 } from "fs";
 import { homedir as homedir8 } from "os";
@@ -24316,7 +25033,7 @@ import { homedir as homedir10 } from "os";
 // packages/agent-sessions/src/codex-launch-config.ts
 import { accessSync as accessSync2, constants as constants2, existsSync as existsSync9 } from "fs";
 import { homedir as homedir9 } from "os";
-import { basename as basename6, delimiter as delimiter2, dirname as dirname4, join as join10, resolve as resolve3 } from "path";
+import { basename as basename7, delimiter as delimiter2, dirname as dirname5, join as join10, resolve as resolve3 } from "path";
 import { fileURLToPath } from "url";
 function isExecutable(filePath) {
   if (!filePath) {
@@ -24337,7 +25054,7 @@ function ancestorChain(start) {
   let current = resolve3(start);
   while (true) {
     chain.push(current);
-    const parent = dirname4(current);
+    const parent = dirname5(current);
     if (parent === current) {
       return chain;
     }
@@ -24373,7 +25090,7 @@ function resolveBunExecutable2(env) {
       return candidate;
     }
   }
-  if (basename6(process.execPath).startsWith("bun") && isExecutable(process.execPath)) {
+  if (basename7(process.execPath).startsWith("bun") && isExecutable(process.execPath)) {
     return process.execPath;
   }
   return resolveExecutableFromSearchPath(["bun"], env);
@@ -24393,7 +25110,7 @@ function resolveScoutExecutable(env) {
   return resolveExecutableFromSearchPath(["scout"], env);
 }
 function resolveRepoScoutScript(currentDirectory) {
-  const moduleDirectory = dirname4(fileURLToPath(import.meta.url));
+  const moduleDirectory = dirname5(fileURLToPath(import.meta.url));
   const starts = uniquePaths([currentDirectory, moduleDirectory]);
   for (const start of starts) {
     for (const candidate of ancestorChain(start)) {
@@ -24681,7 +25398,7 @@ function stringifyValue2(value) {
     return String(value);
   }
 }
-function extractReasoningText(item) {
+function extractReasoningText2(item) {
   const summary = Array.isArray(item.summary) ? item.summary : [];
   const content = Array.isArray(item.content) ? item.content : [];
   const summaryText = summary.map((entry) => {
@@ -25153,7 +25870,7 @@ class CodexAdapter extends BaseAdapter {
         this.ensureTextBlock(turnState, itemId, typeof item.text === "string" ? item.text : "");
         return;
       case "reasoning": {
-        const text = extractReasoningText(item);
+        const text = extractReasoningText2(item);
         if (text) {
           this.ensureReasoningBlock(turnState, itemId, text);
         }
@@ -25232,7 +25949,7 @@ class CodexAdapter extends BaseAdapter {
         return;
       }
       case "reasoning": {
-        const finalText = extractReasoningText(item);
+        const finalText = extractReasoningText2(item);
         if (!finalText && !turnState.blocksByItemId.has(itemId)) {
           return;
         }
@@ -28038,7 +28755,7 @@ import { execFileSync as execFileSync2 } from "child_process";
 import { existsSync as existsSync11, readFileSync as readFileSync4 } from "fs";
 import { access, mkdir as mkdir6, readdir as readdir2, readFile as readFile8, realpath, rm as rm4, stat as stat3, writeFile as writeFile6 } from "fs/promises";
 import { homedir as homedir12, hostname as hostname3, userInfo } from "os";
-import { basename as basename7, dirname as dirname7, isAbsolute, join as join16, relative as relative3, resolve as resolve5 } from "path";
+import { basename as basename8, dirname as dirname8, isAbsolute, join as join16, relative as relative3, resolve as resolve5 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // node_modules/.bun/smol-toml@1.6.1/node_modules/smol-toml/dist/error.js
@@ -28990,7 +29707,7 @@ function parse5(toml, { maxDepth = 1000, integersAsBigInt } = {}) {
 // packages/runtime/src/harness-catalog.ts
 import { existsSync as existsSync10, statSync as statSync6 } from "fs";
 import { mkdir as mkdir5, readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
-import { dirname as dirname5, join as join14 } from "path";
+import { dirname as dirname6, join as join14 } from "path";
 var HARNESS_CATALOG_VERSION = 1;
 var DEFAULT_SUPPORT = {
   install: true,
@@ -29183,7 +29900,7 @@ var BUILT_IN_HARNESS_CATALOG = [
   }
 ];
 async function writeHarnessCatalogOverrides(overrides, overridePath = resolveOpenScoutSupportPaths().harnessCatalogPath) {
-  await mkdir5(dirname5(overridePath), { recursive: true });
+  await mkdir5(dirname6(overridePath), { recursive: true });
   const payload = {
     version: HARNESS_CATALOG_VERSION,
     entries: overrides,
@@ -29201,7 +29918,7 @@ async function ensureHarnessCatalogOverrideFile(overridePath = resolveOpenScoutS
 // packages/runtime/src/user-project-hints.ts
 import { readdir, readFile as readFile7, stat as stat2 } from "fs/promises";
 import { homedir as homedir11 } from "os";
-import { dirname as dirname6, join as join15, resolve as resolve4 } from "path";
+import { dirname as dirname7, join as join15, resolve as resolve4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var PROJECT_HINT_MARKERS = [
   ".git",
@@ -29238,7 +29955,7 @@ async function resolveExistingDirectoryHint(pathLike) {
       return absolutePath;
     }
     if (info.isFile()) {
-      return dirname6(absolutePath);
+      return dirname7(absolutePath);
     }
   } catch {
     return null;
@@ -29265,7 +29982,7 @@ async function findLikelyProjectRoot(absolutePath) {
         }
       }
     }
-    const parent = dirname6(current);
+    const parent = dirname7(current);
     if (parent === current) {
       return lastCandidate ?? absolutePath;
     }
@@ -29406,7 +30123,7 @@ async function appendCursorWorkspacePaths(home, roots) {
         }
         const wsRaw = await readFile7(wsFile, "utf8");
         const wsDoc = JSON.parse(wsRaw);
-        const wsDir = dirname6(wsFile);
+        const wsDir = dirname7(wsFile);
         for (const f of wsDoc.folders ?? []) {
           if (typeof f.path !== "string" || !f.path) {
             continue;
@@ -30115,7 +30832,7 @@ async function readJsonFile(filePath) {
   }
 }
 async function writeJsonFile(filePath, value) {
-  await mkdir6(dirname7(filePath), { recursive: true });
+  await mkdir6(dirname8(filePath), { recursive: true });
   await writeFile6(filePath, JSON.stringify(value, null, 2) + `
 `, "utf8");
 }
@@ -30360,7 +31077,7 @@ function applyImportedEnvironmentSeeds(config2, codexImport, projectRoot) {
       ...(config2.environment?.actions?.length ?? 0) === 0 && importedEnvironment.actions ? { actions: importedEnvironment.actions } : {}
     };
   }
-  const defaultProjectName = titleCase2(basename7(projectRoot));
+  const defaultProjectName = titleCase2(basename8(projectRoot));
   if (codexImport?.name?.trim() && (!config2.project.name?.trim() || config2.project.name === defaultProjectName)) {
     next.project = {
       ...config2.project,
@@ -30570,7 +31287,7 @@ async function seedWorkspaceRoots(options) {
   const roots = new Set;
   const currentProjectRoot = options.currentDirectory ? await findNearestProjectRoot(options.currentDirectory) : null;
   if (currentProjectRoot) {
-    roots.add(dirname7(currentProjectRoot));
+    roots.add(dirname8(currentProjectRoot));
   }
   const legacyRoot = options.legacyRelayConfig?.projectRoot?.trim();
   if (legacyRoot) {
@@ -30578,7 +31295,7 @@ async function seedWorkspaceRoots(options) {
   }
   for (const record2 of Object.values(options.legacyAgents ?? {})) {
     if (record2.cwd?.trim()) {
-      roots.add(dirname7(normalizePath(record2.cwd)));
+      roots.add(dirname8(normalizePath(record2.cwd)));
     }
   }
   if (roots.size === 0) {
@@ -30599,7 +31316,7 @@ async function readOpenScoutSettings(options = {}) {
   });
 }
 var SCOUT_SKILL_FILE_NAME = "SKILL.md";
-var SETUP_MODULE_DIRECTORY = dirname7(fileURLToPath3(import.meta.url));
+var SETUP_MODULE_DIRECTORY = dirname8(fileURLToPath3(import.meta.url));
 var SCOUT_SKILL_REPO_ROOT = resolve5(SETUP_MODULE_DIRECTORY, "..", "..", "..");
 var SCOUT_SKILL_INSTALL_PATHS = {
   claude: join16(homedir12(), ".claude", "skills", "scout", SCOUT_SKILL_FILE_NAME),
@@ -30693,7 +31410,7 @@ async function findNearestProjectRoot(startDirectory) {
     if (await pathExists2(projectConfigPath(current)) || await pathExists2(join16(current, "package.json")) || await pathExists2(join16(current, "AGENTS.md")) || await pathExists2(join16(current, "CLAUDE.md"))) {
       lastCandidate = current;
     }
-    const parent = dirname7(current);
+    const parent = dirname8(current);
     if (parent === current) {
       return lastCandidate;
     }
@@ -30701,7 +31418,7 @@ async function findNearestProjectRoot(startDirectory) {
   }
 }
 function defaultProjectConfig(projectRoot, settings, preferredHarness) {
-  const projectName = basename7(projectRoot);
+  const projectName = basename8(projectRoot);
   const definitionId = normalizeAgentId(projectName);
   const relativeRoot = relative3(projectRoot, projectRoot) || ".";
   return {
@@ -30992,7 +31709,7 @@ function relayAgentOverrideFromResolvedConfig(config2) {
 }
 function projectDefaultDefinitionIds(config2) {
   return new Set([
-    basename7(config2.projectRoot),
+    basename8(config2.projectRoot),
     config2.projectName
   ].map((value) => normalizeAgentId(value)).filter(Boolean));
 }
@@ -31033,8 +31750,8 @@ function selectorFromInput(value) {
 }
 async function resolveManifestBackedAgent(projectRoot, config2, settings, override) {
   const resolvedProjectRoot = resolveProjectRootFromConfig(projectRoot, config2);
-  const projectName = config2.project.name?.trim() || titleCase2(config2.project.id || basename7(resolvedProjectRoot));
-  const fallbackDefinitionId = normalizeAgentId(config2.project.id || basename7(resolvedProjectRoot));
+  const projectName = config2.project.name?.trim() || titleCase2(config2.project.id || basename8(resolvedProjectRoot));
+  const fallbackDefinitionId = normalizeAgentId(config2.project.id || basename8(resolvedProjectRoot));
   const definitionId = normalizeAgentId(config2.agent?.id || override?.definitionId || fallbackDefinitionId);
   const detectedHarness = await detectPreferredHarness(resolvedProjectRoot, settings.agents.defaultHarness);
   const runtimeDefaults = config2.agent?.runtime?.defaults;
@@ -31072,7 +31789,7 @@ async function resolveManifestBackedAgent(projectRoot, config2, settings, overri
   return mergeResolvedAgentConfig(base, override, settings);
 }
 async function resolveInferredAgent(projectRoot, settings, override) {
-  const projectName = basename7(projectRoot);
+  const projectName = basename8(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"));
@@ -31108,7 +31825,7 @@ async function resolveInferredAgent(projectRoot, settings, override) {
   return mergeResolvedAgentConfig(base, override, settings);
 }
 async function buildProjectInventoryEntry(agent, sourceRoot) {
-  const manifestRoot = agent.projectConfigPath ? normalizePath(join16(dirname7(agent.projectConfigPath), "..")) : null;
+  const manifestRoot = agent.projectConfigPath ? normalizePath(join16(dirname8(agent.projectConfigPath), "..")) : null;
   const manifest = manifestRoot ? await readProjectConfig(manifestRoot) : null;
   const markers = await detectHarnessMarkers(agent.projectRoot);
   const harnesses = new Map;
@@ -31373,7 +32090,7 @@ async function ensureRelayAgentConfigured(value, options = {}) {
 import { spawnSync } from "child_process";
 import { chmodSync, existsSync as existsSync12, mkdirSync as mkdirSync2, readFileSync as readFileSync5, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
 import { homedir as homedir13 } from "os";
-import { dirname as dirname8, join as join17, resolve as resolve6 } from "path";
+import { dirname as dirname9, join as join17, resolve as resolve6 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 
 // packages/runtime/src/broker-api.ts
@@ -31624,7 +32341,7 @@ function runtimePackageDir() {
   const fromGlobal = findGlobalRuntimeDir();
   if (fromGlobal)
     return fromGlobal;
-  const moduleDir = dirname8(fileURLToPath4(import.meta.url));
+  const moduleDir = dirname9(fileURLToPath4(import.meta.url));
   return resolve6(moduleDir, "..");
 }
 function isInstalledRuntimePackageDir(candidate) {
@@ -31658,7 +32375,7 @@ function findGlobalRuntimeDir() {
   return null;
 }
 function findBundledRuntimeDir() {
-  const moduleDir = dirname8(fileURLToPath4(import.meta.url));
+  const moduleDir = dirname9(fileURLToPath4(import.meta.url));
   const candidate = resolve6(moduleDir, "..");
   return isInstalledRuntimePackageDir(candidate) ? candidate : null;
 }
@@ -31669,7 +32386,7 @@ function findWorkspaceRuntimeDir(startDir) {
     if (existsSync12(join17(candidate, "package.json")) && existsSync12(join17(candidate, "src"))) {
       return candidate;
     }
-    const parent = dirname8(current);
+    const parent = dirname9(current);
     if (parent === current)
       return null;
     current = parent;
@@ -31868,7 +32585,7 @@ function xmlEscape(value) {
   return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
 }
 function ensureParentDirectory(filePath) {
-  mkdirSync2(dirname8(filePath), { recursive: true });
+  mkdirSync2(dirname9(filePath), { recursive: true });
 }
 function ensureServiceDirectories(config2) {
   ensureOpenScoutCleanSlateSync();
@@ -32242,7 +32959,7 @@ function compileCodexPermissionProfile(profileInput) {
 // packages/runtime/src/user-config.ts
 import { existsSync as existsSync13, readFileSync as readFileSync6, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "fs";
 import { homedir as homedir14 } from "os";
-import { dirname as dirname9, join as join18 } from "path";
+import { dirname as dirname10, join as join18 } from "path";
 function userConfigPath() {
   return join18(process.env.OPENSCOUT_HOME ?? join18(homedir14(), ".openscout"), "user.json");
 }
@@ -32269,7 +32986,7 @@ function resolveOperatorHandle() {
 }
 
 // packages/runtime/src/local-agents.ts
-var MODULE_DIRECTORY = dirname10(fileURLToPath5(import.meta.url));
+var MODULE_DIRECTORY = dirname11(fileURLToPath5(import.meta.url));
 var OPENSCOUT_REPO_ROOT = resolve7(MODULE_DIRECTORY, "..", "..", "..");
 var DEFAULT_LOCAL_AGENT_CAPABILITIES = ["chat", "invoke", "deliver"];
 var DEFAULT_LOCAL_AGENT_HARNESS = "claude";
@@ -32285,13 +33002,13 @@ function resolveProjectsRoot(projectPath) {
   try {
     const supportPaths = resolveOpenScoutSupportPaths();
     if (!existsSync14(supportPaths.settingsPath)) {
-      return dirname10(projectPath);
+      return dirname11(projectPath);
     }
     const raw = JSON.parse(readFileSync7(supportPaths.settingsPath, "utf8"));
     const workspaceRoot = raw.discovery?.workspaceRoots?.find((entry) => typeof entry === "string" && entry.trim().length > 0);
-    return workspaceRoot ? resolve7(workspaceRoot) : dirname10(projectPath);
+    return workspaceRoot ? resolve7(workspaceRoot) : dirname11(projectPath);
   } catch {
-    return dirname10(projectPath);
+    return dirname11(projectPath);
   }
 }
 function resolveBrokerUrl() {
@@ -32729,6 +33446,7 @@ var DEFAULT_CLAUDE_SCOUT_ALLOWED_TOOLS = [
   "mcp__scout__messages_inbox",
   "mcp__scout__messages_channel",
   "mcp__scout__broker_feed",
+  "mcp__scout__tail_events",
   "mcp__scout__agents_search",
   "mcp__scout__agents_resolve",
   "mcp__scout__messages_reply",
@@ -33091,7 +33809,7 @@ function normalizeLocalAgentCardLifecycle(value, now = Date.now()) {
 function normalizeLocalAgentRecord(agentId, record2) {
   const cwd = normalizeProjectPath2(record2.cwd || process.cwd());
   const projectRoot = normalizeProjectPath2(record2.projectRoot || cwd);
-  const project = record2.project?.trim() || basename9(projectRoot);
+  const project = record2.project?.trim() || basename10(projectRoot);
   const definitionId = record2.definitionId?.trim() || agentId;
   const defaultHarness = activeLocalHarness(record2);
   const harnessProfiles = normalizeLocalHarnessProfiles(agentId, {
@@ -33161,7 +33879,7 @@ function localAgentRecordFromRelayAgentOverride(agentId, override) {
   return normalizeLocalAgentRecord(agentId, {
     definitionId: override.definitionId ?? agentId,
     registrationSource: override.source,
-    project: override.projectName ?? basename9(override.projectRoot || override.runtime?.cwd || agentId),
+    project: override.projectName ?? basename10(override.projectRoot || override.runtime?.cwd || agentId),
     projectRoot: override.projectRoot ?? override.runtime?.cwd,
     tmuxSession: override.runtime?.sessionId ?? `relay-${agentId}`,
     cwd: override.runtime?.cwd ?? override.projectRoot,
@@ -33215,6 +33933,13 @@ async function ensureLocalSessionEndpointOnline(endpoint) {
   }
   return {};
 }
+function clearEndpointFailureMetadata(metadata) {
+  const { lastError: _lastError, lastFailedAt: _lastFailedAt, ...baseMetadata } = metadata ?? {};
+  return baseMetadata;
+}
+function endpointStateAfterSuccessfulSessionWarmup(state) {
+  return state === "active" ? "active" : "idle";
+}
 async function shutdownLocalSessionEndpoint(endpoint) {
   if (endpoint.transport === "codex_app_server") {
     await shutdownCodexAppServerAgent(buildCodexEndpointSessionOptions(endpoint));
@@ -33547,7 +34272,7 @@ function invocationSessionFreshness(invocation) {
     case "existing":
       return "continuing session";
     case "any":
-      return "reuse-or-new session";
+      return invocation.execution?.targetSessionId ? "continuing session" : "fresh session";
     default:
       return "session unspecified";
   }
@@ -34016,7 +34741,7 @@ async function ensureLocalAgentOnline(agentName, record2) {
     return normalizedRecord;
   }
   const projectPath = normalizedRecord.cwd;
-  const projectName = normalizedRecord.project || basename9(projectPath);
+  const projectName = normalizedRecord.project || basename10(projectPath);
   const systemPromptTemplate = normalizedRecord.systemPrompt || buildLocalAgentSystemPromptTemplate();
   const systemPrompt = renderLocalAgentSystemPromptTemplate(systemPromptTemplate, buildLocalAgentTemplateContext(agentName, projectName, projectPath), { transport: normalizedRecord.transport });
   const agentRuntimeDir = relayAgentRuntimeDirectory(agentName);
@@ -34199,7 +34924,7 @@ async function startLocalAgent(input) {
   }
   if (!matchingOverride) {
     const configDefinitionId = coldProjectConfig?.agent?.id?.trim() ? normalizeAgentSelectorSegment(coldProjectConfig.agent.id.trim()) : "";
-    const definitionId = requestedDefinitionId || configDefinitionId || normalizeAgentSelectorSegment(basename9(projectRoot)) || "agent";
+    const definitionId = requestedDefinitionId || configDefinitionId || normalizeAgentSelectorSegment(basename10(projectRoot)) || "agent";
     const configDisplayName = coldProjectConfig?.agent?.displayName?.trim() || "";
     const operatorAugmentDefaults = operatorAugmentDefaultsForDefinitionId(definitionId);
     const effectiveDisplayName = input.displayName || operatorAugmentDefaults?.displayName || configDisplayName || titleCaseLocalAgentName(definitionId);
@@ -34220,7 +34945,7 @@ async function startLocalAgent(input) {
       agentId: instance.id,
       definitionId,
       displayName: effectiveDisplayName,
-      projectName: basename9(projectRoot),
+      projectName: basename10(projectRoot),
       projectRoot,
       projectConfigPath: coldProjectConfigPath,
       source: "manual",
@@ -34269,7 +34994,7 @@ async function startLocalAgent(input) {
       agentId: instance.id,
       definitionId: requestedDefinitionId,
       displayName: input.displayName || operatorAugmentDefaults?.displayName || titleCaseLocalAgentName(requestedDefinitionId),
-      projectName: matchingOverride.projectName ?? basename9(matchingProjectRoot),
+      projectName: matchingOverride.projectName ?? basename10(matchingProjectRoot),
       projectRoot: matchingProjectRoot,
       projectConfigPath: null,
       source: "manual",
@@ -34625,7 +35350,7 @@ async function invokeLocalAgentEndpoint(endpoint, invocation) {
   const requestedHarness = invocation.execution?.harness;
   const record2 = existing ?? (projectRoot ? {
     definitionId,
-    project: basename9(projectRoot),
+    project: basename10(projectRoot),
     projectRoot,
     tmuxSession: String(endpoint.metadata?.tmuxSession ?? `relay-${agentRuntimeId}`),
     cwd: projectRoot,
@@ -34872,7 +35597,7 @@ function upsertScoutAgentCardFromInput(runtime, input) {
 
 // packages/runtime/src/pairing-session-agents.ts
 import { existsSync as existsSync15, readFileSync as readFileSync8 } from "fs";
-import { basename as basename10, join as join20 } from "path";
+import { basename as basename11, join as join20 } from "path";
 import { homedir as homedir15 } from "os";
 var DEFAULT_PAIRING_PORT = 7888;
 var PAIRING_CONNECT_TIMEOUT_MS = 1500;
@@ -35059,7 +35784,7 @@ function shortPairingSessionId(sessionId) {
 }
 function pairingProjectLabel(session) {
   const cwd = session.cwd?.trim();
-  return cwd ? basename10(cwd) : null;
+  return cwd ? basename11(cwd) : null;
 }
 function pairingDisplayName(session, shortId) {
   const explicit = session.name?.trim();
@@ -35440,7 +36165,7 @@ async function invokePairingSessionEndpoint(endpoint, invocation, options = {})
 
 // packages/runtime/src/sqlite-store.ts
 import { mkdirSync as mkdirSync5 } from "fs";
-import { dirname as dirname12 } from "path";
+import { dirname as dirname13 } from "path";
 import { Database as Database2 } from "bun:sqlite";
 
 // node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/entity.js
@@ -40042,6 +40767,9 @@ function stampControlPlaneSchemaVersion(database) {
 }
 if (false) {}
 
+// packages/runtime/src/conversations/api.ts
+import { randomUUID as randomUUID3 } from "crypto";
+
 // packages/runtime/src/conversations/legacy-ids.ts
 function conversationIdForAgent(agentId) {
   return buildDirectConversationId("operator", agentId);
@@ -40107,11 +40835,22 @@ class Conversations {
   findById(id) {
     return this.store.getConversation(id);
   }
-  findByNaturalKey(_key) {
+  findByNaturalKey(key) {
+    const normalizedKey = key.trim();
+    if (!normalizedKey) {
+      return null;
+    }
+    const rows = this.readDb.query("SELECT id FROM conversations ORDER BY created_at ASC").all();
+    for (const row of rows) {
+      const conversation = this.findById(row.id);
+      if (conversation && channelNaturalKeyFromMetadata(conversation.metadata) === normalizedKey) {
+        return conversation;
+      }
+    }
     return null;
   }
   findByAgent(agentId) {
-    return this.findById(conversationIdForAgent(agentId));
+    return this.findById(conversationIdForAgent(agentId)) ?? this.findByNaturalKey(directChannelNaturalKey(["operator", agentId]));
   }
   findByParent(parentId) {
     const rows = this.readDb.query("SELECT id FROM conversations WHERE parent_conversation_id = ?1 ORDER BY created_at ASC").all(parentId);
@@ -40155,7 +40894,7 @@ class Conversations {
       return existing;
     }
     const conversation = {
-      id: input.naturalKey,
+      id: mintChannelId(randomUUID3),
       kind: input.kind,
       title: input.title,
       visibility: input.visibility,
@@ -40164,7 +40903,10 @@ class Conversations {
       participantIds: input.participantIds,
       parentConversationId: input.parentConversationId,
       topic: input.topic,
-      metadata: input.metadata
+      metadata: {
+        ...input.metadata ?? {},
+        naturalKey: input.naturalKey
+      }
     };
     this.upsert(conversation);
     return conversation;
@@ -40182,6 +40924,10 @@ class Conversations {
     }
     const parsedDirect = parseDirectConversationId(rawId);
     if (parsedDirect) {
+      const byNaturalKey = this.findByNaturalKey(directChannelNaturalKey([parsedDirect.operatorId, parsedDirect.agentId]));
+      if (byNaturalKey) {
+        return byNaturalKey;
+      }
       for (const candidate of directConversationIdCandidates(parsedDirect.agentId)) {
         const hit = this.findById(candidate);
         if (hit) {
@@ -40191,6 +40937,10 @@ class Conversations {
     }
     const legacyScoutAgentId = parseLegacyScoutSessionConversationId(rawId);
     if (legacyScoutAgentId) {
+      const byNaturalKey = this.findByNaturalKey(directChannelNaturalKey(["operator", legacyScoutAgentId]));
+      if (byNaturalKey) {
+        return byNaturalKey;
+      }
       for (const candidate of directConversationIdCandidates(legacyScoutAgentId)) {
         const hit = this.findById(candidate);
         if (hit) {
@@ -40415,7 +41165,7 @@ class SQLiteControlPlaneStore {
   flushPendingEventsTimer = null;
   conversationsApi = null;
   constructor(dbPath) {
-    mkdirSync5(dirname12(dbPath), { recursive: true });
+    mkdirSync5(dirname13(dbPath), { recursive: true });
     this.db = new SQLiteDatabase(dbPath, { create: true });
     this.db.exec("PRAGMA busy_timeout = 5000;");
     this.db.exec("PRAGMA journal_mode = WAL;");
@@ -41658,7 +42408,7 @@ class SQLiteControlPlaneStore {
     if (message.replyToMessageId && this.isKnownAgentId(message.actorId)) {
       return "ask_replied";
     }
-    if (agentId && message.actorId !== agentId) {
+    if (agentId && message.actorId !== agentId && this.isDirectConversation(message.conversationId)) {
       return "ask_opened";
     }
     if (this.isKnownAgentId(message.actorId)) {
@@ -41666,6 +42416,13 @@ class SQLiteControlPlaneStore {
     }
     return "message_posted";
   }
+  isDirectConversation(conversationId, db = this.readDb) {
+    if (!conversationId) {
+      return false;
+    }
+    const row = queryGet(db, "SELECT kind FROM conversations WHERE id = ?1 LIMIT 1", conversationId);
+    return row?.kind === "direct";
+  }
   resolveActivityAgentIdForMessage(message) {
     if (message.class === "status" && typeof message.metadata?.targetAgentId === "string" && this.isKnownAgentId(message.metadata.targetAgentId)) {
       return message.metadata.targetAgentId;
@@ -43516,7 +44273,7 @@ import {
   writeFileSync as writeFileSync4
 } from "fs";
 import { homedir as homedir16, hostname as osHostname } from "os";
-import { dirname as dirname13, join as join22 } from "path";
+import { dirname as dirname14, join as join22 } from "path";
 var LOCAL_CONFIG_VERSION = 1;
 var DEFAULT_LOCAL_CONFIG = {
   version: LOCAL_CONFIG_VERSION,
@@ -43771,7 +44528,7 @@ import { Database as Database3 } from "bun:sqlite";
 import { mkdirSync as mkdirSync7, readFileSync as readFileSync11 } from "fs";
 import { connect as connectHttp2 } from "http2";
 import { createPrivateKey, sign as signWithKey } from "crypto";
-import { dirname as dirname14, join as join24 } from "path";
+import { dirname as dirname15, join as join24 } from "path";
 var MOBILE_PUSH_SCHEMA = `
 CREATE TABLE IF NOT EXISTS mobile_push_registrations (
   id TEXT PRIMARY KEY,
@@ -43813,7 +44570,7 @@ function writeDb() {
     dbHandle = null;
   }
   if (!dbHandle) {
-    mkdirSync7(dirname14(nextPath), { recursive: true });
+    mkdirSync7(dirname15(nextPath), { recursive: true });
     dbHandle = new Database3(nextPath, { create: true });
     dbPath = nextPath;
     ensureMobilePushSchema(dbHandle);
@@ -44254,6 +45011,11 @@ var tailnetName = process.env.TAILSCALE_TAILNET ?? undefined;
 var brokerUrl = process.env.OPENSCOUT_BROKER_URL ?? buildDefaultBrokerUrl(host, port);
 var brokerSocketPath = process.env.OPENSCOUT_BROKER_SOCKET_PATH ?? resolveBrokerServiceConfig().brokerSocketPath;
 var nodeId = process.env.OPENSCOUT_NODE_ID ?? `${nodeName}-${meshId}`.toLowerCase().replace(/[^a-z0-9-]+/g, "-");
+var nodeLocalProductAgentIds = new Set([
+  SCOUT_DISPATCHER_AGENT_ID,
+  OPENSCOUT_COORDINATOR_AGENT_ID,
+  "scoutbot"
+]);
 var seedUrls = (process.env.OPENSCOUT_MESH_SEEDS ?? "").split(",").map((value) => value.trim()).filter(Boolean);
 var configuredCoreAgentIds = (process.env.OPENSCOUT_CORE_AGENTS ?? "").split(",").map((value) => value.trim().toLowerCase()).filter(Boolean);
 var discoveryIntervalMs = Number.parseInt(process.env.OPENSCOUT_MESH_DISCOVERY_INTERVAL_MS ?? "60000", 10);
@@ -44288,8 +45050,6 @@ var shuttingDown = false;
 var sseKeepAliveIntervalMs = Number.parseInt(process.env.OPENSCOUT_SSE_KEEPALIVE_MS ?? "15000", 10);
 var operatorActorId = "operator";
 var BROKER_SHARED_CHANNEL_ID = "channel.shared";
-var BROKER_VOICE_CHANNEL_ID = "channel.voice";
-var BROKER_SYSTEM_CHANNEL_ID = "channel.system";
 var WEB_START_POLL_TIMEOUT_MS = 15000;
 var WEB_START_POLL_INTERVAL_MS = 250;
 var webServerProcess = null;
@@ -44551,6 +45311,11 @@ async function discoverPeers(seeds = []) {
           continue;
         if (agent.homeNodeId === nodeId)
           continue;
+        if (isNodeLocalProductAgentId(agent.id))
+          continue;
+        const existingAgent = runtime.agent(agent.id);
+        if (existingAgent && isLocalAgentAuthority(existingAgent))
+          continue;
         const agentHome = agent.homeNodeId || node.id;
         if (agentHome !== node.id)
           continue;
@@ -44572,6 +45337,12 @@ async function discoverPeers(seeds = []) {
     probes: result.probes
   };
 }
+function isNodeLocalProductAgentId(agentId) {
+  return nodeLocalProductAgentIds.has(agentId.trim().toLowerCase());
+}
+function isLocalAgentAuthority(agent) {
+  return agent.homeNodeId === nodeId || agent.authorityNodeId === nodeId;
+}
 function currentLocalNode() {
   return runtime.node(nodeId) ?? localNode;
 }
@@ -44671,7 +45442,7 @@ function resolveWebServerEntry() {
   if (repoEntry) {
     return repoEntry;
   }
-  const moduleDir = dirname15(fileURLToPath7(import.meta.url));
+  const moduleDir = dirname16(fileURLToPath7(import.meta.url));
   const candidates = [
     resolve8(moduleDir, "..", "scout-control-plane-web.mjs"),
     resolve8(moduleDir, "..", "scout-web-server.mjs"),
@@ -44681,7 +45452,7 @@ function resolveWebServerEntry() {
   return candidates.find((candidate) => existsSync19(candidate)) ?? null;
 }
 function resolveWebServerRepoRoot() {
-  const moduleDir = dirname15(fileURLToPath7(import.meta.url));
+  const moduleDir = dirname16(fileURLToPath7(import.meta.url));
   return resolveOpenScoutRepoRoot({
     startDirectories: [
       process.env.OPENSCOUT_SETUP_CWD,
@@ -45545,6 +46316,23 @@ function staleLocalEndpointReason(endpoint) {
   const replacement = typeof replacementAgentId === "string" && replacementAgentId.trim().length > 0 ? `; replacement agent is ${replacementAgentId.trim()}` : "";
   return `endpoint ${endpoint.id} is a stale local registration superseded by current setup${replacement}`;
 }
+function staleLocalAgentReason(snapshot, agent) {
+  const endpoints = Object.values(snapshot.endpoints).filter((endpoint) => endpoint.agentId === agent.id);
+  const staleEndpointReasons = endpoints.map((endpoint) => staleLocalEndpointReason(endpoint)).filter((reason) => Boolean(reason));
+  if (endpoints.length > 0 && staleEndpointReasons.length === endpoints.length) {
+    return staleLocalEndpointReason(latestEndpointForAgent(snapshot, agent.id)) ?? staleEndpointReasons[0] ?? null;
+  }
+  if (agent.metadata?.staleLocalRegistration !== true) {
+    return null;
+  }
+  const endpointReason = staleLocalEndpointReason(latestEndpointForAgent(snapshot, agent.id));
+  if (endpointReason) {
+    return endpointReason;
+  }
+  const replacementAgentId = metadataStringValue2(agent.metadata, "replacedByAgentId");
+  const replacement = replacementAgentId ? `; replacement agent is ${replacementAgentId}` : "";
+  return `agent ${agent.id} is a stale local registration superseded by current setup${replacement}`;
+}
 function flightDispatchEndpointId(flight) {
   const dispatchAck = flight.metadata?.dispatchAck;
   if (!dispatchAck || typeof dispatchAck !== "object" || Array.isArray(dispatchAck)) {
@@ -45633,14 +46421,14 @@ function brokerConversationChannel(snapshot, conversationId) {
   if (!conversation) {
     return null;
   }
+  if (typeof conversation.metadata?.channel === "string") {
+    return conversation.metadata.channel;
+  }
   return conversation.id.startsWith("channel.") ? conversation.id.replace(/^channel\./, "") : null;
 }
 function titleCaseName(value) {
   return value.split(/[-_.\s]+/).filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1)).join(" ");
 }
-function sanitizeConversationSegment(value) {
-  return value.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-") || "shared";
-}
 function metadataStringValue2(metadata, key) {
   const value = metadata?.[key];
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
@@ -45674,7 +46462,7 @@ function brokerRouteKind(conversation) {
   if (conversation.kind === "direct") {
     return "dm";
   }
-  return conversation.id === BROKER_SHARED_CHANNEL_ID ? "broadcast" : "channel";
+  return conversation.id === BROKER_SHARED_CHANNEL_ID || conversation.metadata?.channel === "shared" ? "broadcast" : "channel";
 }
 function normalizeBrokerProductTarget(value) {
   return value.trim().toLowerCase().replace(/^@+/, "");
@@ -45733,15 +46521,8 @@ function resolveConversationShareMode(snapshot, participantIds, fallback) {
   });
   return hasRemoteParticipant ? "shared" : fallback;
 }
-function directConversationIdForActors(sourceId, targetId) {
-  if (sourceId === targetId) {
-    return `dm.${sourceId}.${targetId}`;
-  }
-  if (sourceId === operatorActorId || targetId === operatorActorId) {
-    const peerId = sourceId === operatorActorId ? targetId : sourceId;
-    return `dm.${operatorActorId}.${peerId}`;
-  }
-  return `dm.${[sourceId, targetId].sort().join(".")}`;
+function findConversationByIdentity(snapshot, naturalKey) {
+  return Object.values(snapshot.conversations).find((conversation) => channelNaturalKeyFromMetadata(conversation.metadata) === naturalKey);
 }
 async function ensureBrokerActorForDelivery(actorId) {
   const snapshot = runtime.snapshot();
@@ -45762,10 +46543,11 @@ async function ensureBrokerDeliveryConversation(input) {
   const normalizedChannel = input.channel?.trim();
   const targetAgentId = input.targetAgentId?.trim();
   if (!normalizedChannel && targetAgentId) {
-    const conversationId = targetAgentId === SCOUT_DISPATCHER_AGENT_ID && input.requesterId === operatorActorId ? BROKER_SHARED_CHANNEL_ID : directConversationIdForActors(input.requesterId, targetAgentId);
     const participantIds = [...new Set([input.requesterId, targetAgentId])].sort();
     const shareMode = resolveConversationShareMode(snapshot, participantIds, "local");
-    const existing2 = snapshot.conversations[conversationId];
+    const naturalKey = directChannelNaturalKey(participantIds);
+    const existing2 = findConversationByIdentity(snapshot, naturalKey);
+    const conversationId = existing2?.id ?? mintChannelId(randomUUID4);
     const alreadyMatches = existing2 && existing2.kind === "direct" && existing2.visibility === "private" && existing2.shareMode === shareMode && existing2.participantIds.join("\x00") === participantIds.join("\x00");
     if (alreadyMatches) {
       return existing2;
@@ -45782,6 +46564,7 @@ async function ensureBrokerDeliveryConversation(input) {
       participantIds,
       metadata: {
         surface: "broker",
+        naturalKey,
         ...targetAgentId === SCOUT_DISPATCHER_AGENT_ID && input.requesterId === operatorActorId ? { role: "partner" } : {}
       }
     };
@@ -45797,48 +46580,72 @@ async function ensureBrokerDeliveryConversation(input) {
   ])].sort();
   let definition;
   if (channel === "voice") {
+    const naturalKey = namedChannelNaturalKey("voice");
+    const existing2 = findConversationByIdentity(snapshot, naturalKey);
     definition = {
-      id: BROKER_VOICE_CHANNEL_ID,
+      id: existing2?.id ?? mintChannelId(randomUUID4),
       kind: "channel",
       title: "voice",
       visibility: "workspace",
       shareMode: resolveConversationShareMode(snapshot, scopedParticipants, "local"),
       authorityNodeId: nodeId,
       participantIds: scopedParticipants,
-      metadata: { surface: "broker", channel: "voice" }
+      metadata: {
+        surface: "broker",
+        channel: "voice",
+        naturalKey
+      }
     };
   } else if (channel === "system") {
+    const naturalKey = systemChannelNaturalKey("system");
+    const existing2 = findConversationByIdentity(snapshot, naturalKey);
     definition = {
-      id: BROKER_SYSTEM_CHANNEL_ID,
+      id: existing2?.id ?? mintChannelId(randomUUID4),
       kind: "system",
       title: "system",
       visibility: "system",
       shareMode: "local",
       authorityNodeId: nodeId,
       participantIds: [operatorActorId, input.requesterId].sort(),
-      metadata: { surface: "broker", channel: "system" }
+      metadata: {
+        surface: "broker",
+        channel: "system",
+        naturalKey
+      }
     };
   } else if (channel === "shared") {
+    const naturalKey = namedChannelNaturalKey("shared");
+    const existing2 = findConversationByIdentity(snapshot, naturalKey);
     definition = {
-      id: BROKER_SHARED_CHANNEL_ID,
+      id: existing2?.id ?? mintChannelId(randomUUID4),
       kind: "channel",
       title: "shared-channel",
       visibility: "workspace",
       shareMode: "shared",
       authorityNodeId: nodeId,
       participantIds: sharedParticipants,
-      metadata: { surface: "broker", channel: "shared" }
+      metadata: {
+        surface: "broker",
+        channel: "shared",
+        naturalKey
+      }
     };
   } else {
+    const naturalKey = namedChannelNaturalKey(channel);
+    const existing2 = findConversationByIdentity(snapshot, naturalKey);
     definition = {
-      id: `channel.${sanitizeConversationSegment(channel)}`,
+      id: existing2?.id ?? mintChannelId(randomUUID4),
       kind: "channel",
       title: channel,
       visibility: "workspace",
       shareMode: resolveConversationShareMode(snapshot, scopedParticipants, "local"),
       authorityNodeId: nodeId,
       participantIds: scopedParticipants,
-      metadata: { surface: "broker", channel }
+      metadata: {
+        surface: "broker",
+        channel,
+        naturalKey
+      }
     };
   }
   const existing = snapshot.conversations[definition.id];
@@ -45870,7 +46677,22 @@ function buildBrokerReturnAddressForActor(snapshot, actorId, options = {}) {
     sessionId: options.sessionId ?? endpoint?.sessionId
   });
 }
-function describeUnavailableDeliveryTarget(snapshot, agent) {
+function describeUnavailableDeliveryTarget(snapshot, agent, targetSessionId) {
+  const staleReason = targetSessionId ? staleLocalAgentReason(snapshot, agent) : agent.metadata?.staleLocalRegistration === true ? staleLocalAgentReason(snapshot, agent) : null;
+  if (staleReason) {
+    const endpoint2 = latestEndpointForAgent(snapshot, agent.id);
+    const projectRoot2 = brokerTargetProjectRoot(agent, endpoint2);
+    return {
+      agentId: agent.id,
+      displayName: agent.displayName ?? agent.id,
+      reason: "stale_registration",
+      detail: staleReason,
+      wakePolicy: agent.wakePolicy,
+      endpointState: endpoint2?.state === "active" || endpoint2?.state === "idle" || endpoint2?.state === "waiting" ? "online" : endpoint2?.state === "offline" ? "offline" : "unknown",
+      transport: endpoint2?.transport ?? null,
+      projectRoot: projectRoot2
+    };
+  }
   const endpoint = homeEndpointForAgent(snapshot, agent.id);
   const projectRoot = brokerTargetProjectRoot(agent, endpoint);
   if (agent.metadata?.retiredFromFleet === true) {
@@ -46204,11 +47026,11 @@ function updateManagedSessionAgent(agent, input) {
   };
 }
 function managedLocalSessionDefaultDisplayName(input) {
-  const projectName = basename11(input.projectRoot ?? input.cwd) || input.cwd;
+  const projectName = basename12(input.projectRoot ?? input.cwd) || input.cwd;
   return input.transport === "codex_app_server" ? `Codex (${projectName})` : `Claude (${projectName})`;
 }
 function suggestedManagedLocalSessionSelector(input) {
-  const projectName = normalizeAgentSelectorSegment(basename11(input.projectRoot ?? input.cwd) || "session") || "session";
+  const projectName = normalizeAgentSelectorSegment(basename12(input.projectRoot ?? input.cwd) || "session") || "session";
   const prefix = input.transport === "codex_app_server" ? "codex" : "claude";
   return `@${prefix}-${projectName}`;
 }
@@ -46246,7 +47068,7 @@ function buildManagedLocalSessionAgent(input) {
 function buildManagedLocalSessionPairingEndpointBinding(input) {
   const projectRoot = resolve8(input.projectRoot ?? input.cwd);
   const cwd = resolve8(input.cwd);
-  const projectName = basename11(projectRoot) || projectRoot;
+  const projectName = basename12(projectRoot) || projectRoot;
   const definitionId = input.definitionId?.trim() || selectorHandle(input.selector ?? input.agentId);
   const base = buildManagedPairingEndpointBinding({
     agentId: input.agentId,
@@ -47126,7 +47948,7 @@ async function reviveManagedLocalSessionEndpoint(endpoint) {
   }
   const sessionResult = await ensureLocalSessionEndpointOnline(endpoint);
   const externalSessionId = sessionResult.externalSessionId?.trim();
-  const { lastError: _lastError, lastFailedAt: _lastFailedAt, ...baseMetadata } = endpoint.metadata ?? {};
+  const baseMetadata = clearEndpointFailureMetadata(endpoint.metadata);
   const revivedEndpoint = {
     ...endpoint,
     state: "idle",
@@ -47147,19 +47969,23 @@ async function resolveLocalEndpointForInvocation(invocation) {
   const requestedHarness = invocation.execution?.harness;
   const targetSessionId = invocationTargetSessionId(invocation);
   const sessionPreference = invocation.execution?.session ?? "new";
+  const shouldUseExistingSession = Boolean(targetSessionId);
   const existing = activeLocalEndpointForAgent(invocation.targetAgentId, requestedHarness, targetSessionId);
-  if (existing && (sessionPreference !== "new" || existing.transport === "pairing_bridge")) {
+  if (existing && (shouldUseExistingSession || existing.transport === "pairing_bridge")) {
     return existing;
   }
-  const staleEndpoints = runtime.endpointsForAgent(invocation.targetAgentId, {
+  if (!shouldUseExistingSession && sessionPreference === "existing") {
+    return;
+  }
+  const staleEndpoints = shouldUseExistingSession ? runtime.endpointsForAgent(invocation.targetAgentId, {
     nodeId,
     harness: requestedHarness
-  }).filter((endpoint) => endpoint.id !== existing?.id && (targetSessionId ? endpointMatchesTargetSession(endpoint, targetSessionId) : true));
+  }).filter((endpoint) => endpoint.id !== existing?.id && endpointMatchesTargetSession(endpoint, targetSessionId)) : [];
   const staleLocalReason = staleEndpoints.map((endpoint) => staleLocalEndpointReason(endpoint)).find((reason) => Boolean(reason));
   if (staleLocalReason) {
     throw new Error(staleLocalReason);
   }
-  if (invocation.ensureAwake) {
+  if (invocation.ensureAwake && shouldUseExistingSession) {
     for (const endpoint of staleEndpoints) {
       try {
         const revived = await reviveManagedLocalSessionEndpoint(endpoint);
@@ -47192,9 +48018,6 @@ async function resolveLocalEndpointForInvocation(invocation) {
   if (!invocation.ensureAwake) {
     return;
   }
-  if (sessionPreference === "existing") {
-    return;
-  }
   if (targetSessionId) {
     return;
   }
@@ -47236,7 +48059,8 @@ async function executeLocalInvocation(invocation, initialFlight) {
     return;
   }
   if (!agent || !endpoint) {
-    const staleEndpointReason = staleLocalEndpointReason(latestEndpointForAgent(runtime.snapshot(), invocation.targetAgentId));
+    const targetSessionId = invocationTargetSessionId(invocation);
+    const staleEndpointReason = targetSessionId ? staleLocalEndpointReason(latestEndpointForAgent(runtime.snapshot(), invocation.targetAgentId)) : null;
     if (staleEndpointReason) {
       const failedFlight = {
         ...initialFlight,
@@ -47257,7 +48081,15 @@ async function executeLocalInvocation(invocation, initialFlight) {
     const queuedFlight = {
       ...initialFlight,
       state: "queued",
-      summary: `Message stored for ${agent?.displayName ?? invocation.targetAgentId}. Will deliver when online.`
+      summary: `Message stored for ${agent?.displayName ?? invocation.targetAgentId}. Will deliver when online.`,
+      metadata: {
+        ...initialFlight.metadata ?? {},
+        dispatchOutcome: {
+          status: "queued_until_online",
+          reason: "no_runnable_endpoint",
+          checkedAt: Date.now()
+        }
+      }
     };
     await persistFlight(queuedFlight);
     return;
@@ -47654,6 +48486,39 @@ function parseLimit(url2) {
     return 100;
   return Math.min(limit, 500);
 }
+function parseTailLimit(url2) {
+  const limit = Number.parseInt(url2.searchParams.get("limit") ?? "500", 10);
+  if (!Number.isFinite(limit) || limit <= 0)
+    return 500;
+  return Math.min(limit, 1000);
+}
+async function readTailRecentPayload(url2) {
+  const limit = parseTailLimit(url2);
+  const bufferedEvents = await readRecentLiveEvents(limit);
+  const eventsById = new Map;
+  if (url2.searchParams.get("transcripts") === "true" || url2.searchParams.get("transcripts") === "1") {
+    const transcriptEvents = await readRecentTranscriptEvents(limit, {
+      perTranscriptLineLimit: Math.min(200, Math.max(50, limit))
+    });
+    for (const event of transcriptEvents) {
+      eventsById.set(event.id, event);
+    }
+  }
+  for (const event of bufferedEvents) {
+    eventsById.set(event.id, event);
+  }
+  const events2 = [...eventsById.values()].sort((left, right) => {
+    if (left.ts === right.ts)
+      return left.id.localeCompare(right.id);
+    return left.ts - right.ts;
+  }).slice(-limit);
+  return {
+    generatedAt: Date.now(),
+    limit,
+    cursor: events2.at(-1)?.id ?? null,
+    events: events2
+  };
+}
 function parseSince(url2) {
   const since = Number.parseInt(url2.searchParams.get("since") ?? "", 10);
   if (!Number.isFinite(since) || since <= 0) {
@@ -47683,7 +48548,7 @@ async function probeExistingBroker() {
   }
 }
 async function prepareBrokerSocketPath(socketPath) {
-  await mkdir8(dirname15(socketPath), { recursive: true, mode: 448 });
+  await mkdir8(dirname16(socketPath), { recursive: true, mode: 448 });
   try {
     const existing = await lstat(socketPath);
     if (!existing.isSocket()) {
@@ -48025,6 +48890,15 @@ async function routeRequest(request, response) {
     json2(response, 200, await getHarnessTopologySnapshot(url2.searchParams.get("force") === "1"));
     return;
   }
+  if (method === "GET" && url2.pathname === "/v1/tail/discover") {
+    const force = url2.searchParams.get("force") === "1" || url2.searchParams.get("force") === "true";
+    json2(response, 200, await getTailDiscovery(force));
+    return;
+  }
+  if (method === "GET" && url2.pathname === "/v1/tail/recent") {
+    json2(response, 200, await readTailRecentPayload(url2));
+    return;
+  }
   if (method === "POST" && url2.pathname === "/v1/topology/nudge") {
     json2(response, 200, await nudgeHarnessTopologyScan());
     return;
@@ -48703,10 +49577,10 @@ data: ${JSON.stringify({ nodeId, meshId })}
       const externalSessionId = sessionResult.externalSessionId?.trim();
       const nextEndpoint = {
         ...endpoint,
-        state: endpoint.state === "offline" ? "waiting" : endpoint.state,
+        state: endpointStateAfterSuccessfulSessionWarmup(endpoint.state),
         ...externalSessionId ? { sessionId: externalSessionId } : {},
         metadata: {
-          ...endpoint.metadata ?? {},
+          ...clearEndpointFailureMetadata(endpoint.metadata),
           ...externalSessionId ? {
             externalSessionId,
             threadId: endpoint.transport === "codex_app_server" ? externalSessionId : endpoint.metadata?.threadId
@@ -49066,16 +49940,22 @@ function supportedRouteHarness(value) {
   }
   return;
 }
+function supportedRouteModel(value) {
+  const normalized = value?.trim();
+  return normalized || undefined;
+}
 function executionWithRouteParams(payload) {
   const label = agentLabelForRouteParams(payload);
   const identity2 = label ? parseAgentIdentity(label.startsWith("@") ? label : `@${label}`) : null;
-  const harness = supportedRouteHarness(identity2?.harness);
-  if (!harness || payload.execution?.harness) {
+  const harness = payload.execution?.harness ? undefined : supportedRouteHarness(identity2?.harness);
+  const model = payload.execution?.model ? undefined : supportedRouteModel(identity2?.model);
+  if (!harness && !model) {
     return payload.execution;
   }
   return {
     ...payload.execution ?? {},
-    harness
+    ...harness ? { harness } : {},
+    ...model ? { model } : {}
   };
 }
 function resolveBrokerDeliveryTarget(input) {
@@ -49088,43 +49968,82 @@ function projectPathRouteTarget(input) {
   return input.target?.kind === "project_path" ? input.target.projectPath.trim() || undefined : undefined;
 }
 function implicitProjectAgentName(projectPath) {
-  const base = normalizeAgentSelectorSegment(basename11(projectPath)) || "agent";
+  const base = normalizeAgentSelectorSegment(basename12(projectPath)) || "agent";
   return `${base}-card-${createRuntimeId2("one").slice(-8)}`;
 }
-async function resolveBrokerDeliveryTargetWithImplicitProjectCard(input, options) {
+function projectAgentPersistence(spec) {
+  return spec?.persistence === "sticky" ? "sticky" : "one_time";
+}
+function compactProjectAgentName(value) {
+  const normalized = value?.trim();
+  return normalized || undefined;
+}
+function shouldMaterializeProjectAgent(input) {
+  if (!input.projectPath) {
+    return false;
+  }
+  if (input.projectAgent?.persistence === "one_time") {
+    return true;
+  }
+  if (input.projectAgent?.persistence === "sticky") {
+    return input.resolved.kind !== "resolved" || Boolean(input.projectAgent.agentName?.trim()) || Boolean(input.projectAgent.displayName?.trim()) || Boolean(input.execution?.harness) || Boolean(input.execution?.model?.trim()) || Boolean(input.execution?.permissionProfile);
+  }
+  return input.resolved.kind === "unknown" || input.resolved.kind === "ambiguous" && (input.execution?.session ?? "new") === "new";
+}
+async function resolveBrokerDeliveryTargetWithImplicitProjectAgent(input, options) {
   const resolved = resolveBrokerDeliveryTarget(input);
   const projectPath = projectPathRouteTarget(input);
-  const shouldCreateImplicitProjectCard = projectPath && (resolved.kind === "unknown" || resolved.kind === "ambiguous" && (input.execution?.session ?? "new") === "new");
-  if (!shouldCreateImplicitProjectCard) {
+  const persistence = projectAgentPersistence(input.projectAgent);
+  if (!shouldMaterializeProjectAgent({
+    projectPath,
+    resolved,
+    persistence,
+    projectAgent: input.projectAgent,
+    execution: input.execution
+  })) {
+    return resolved;
+  }
+  if (!projectPath) {
     return resolved;
   }
   const createdAt = Date.now();
   const requesterId = options.requesterId?.trim();
+  const agentName = persistence === "sticky" ? compactProjectAgentName(input.projectAgent?.agentName) : implicitProjectAgentName(projectPath);
+  const displayName = compactProjectAgentName(input.projectAgent?.displayName);
   const status = await startLocalAgent({
     projectPath,
-    agentName: implicitProjectAgentName(projectPath),
+    ...agentName ? { agentName } : {},
+    ...displayName ? { displayName } : {},
     currentDirectory: options.currentDirectory ?? projectPath,
     harness: input.execution?.harness,
+    model: input.execution?.model,
+    permissionProfile: input.execution?.permissionProfile,
     ensureOnline: false,
     card: {
-      kind: "one_time",
+      kind: persistence === "sticky" ? "persistent" : "one_time",
       createdAt,
       ...requesterId ? { createdById: requesterId } : {},
-      expiresAt: createdAt + DEFAULT_IMPLICIT_PROJECT_CARD_TTL_MS,
-      maxUses: 1
+      ...persistence === "one_time" ? {
+        expiresAt: createdAt + DEFAULT_IMPLICIT_PROJECT_CARD_TTL_MS,
+        maxUses: 1
+      } : {}
     }
   }).catch((error48) => {
     const detail = error48 instanceof Error ? error48.message : String(error48);
-    throw new Error(`could not create an agent card for project ${projectPath}: ${detail}`);
-  });
-  await pruneOneTimeLocalAgentCards({
-    ...requesterId ? { createdById: requesterId } : {},
-    projectRoot: status.projectRoot,
-    excludeAgentIds: [status.agentId]
-  }).catch((error48) => {
-    console.warn(`[openscout-runtime] implicit project card cleanup failed: ${error48 instanceof Error ? error48.message : String(error48)}`);
+    throw new Error(`could not create a ${persistence} agent for project ${projectPath}: ${detail}`);
   });
-  await syncRegisteredLocalAgentsIfChanged(options.reason);
+  if (persistence === "one_time") {
+    await pruneOneTimeLocalAgentCards({
+      ...requesterId ? { createdById: requesterId } : {},
+      projectRoot: status.projectRoot,
+      excludeAgentIds: [status.agentId]
+    }).catch((error48) => {
+      console.warn(`[openscout-runtime] implicit project card cleanup failed: ${error48 instanceof Error ? error48.message : String(error48)}`);
+    });
+  }
+  clearGitBranchCache();
+  console.log(`[openscout-runtime] local agent registry changed (${options.reason}); refreshing registered agents`);
+  await syncRegisteredLocalAgents();
   const agent = runtime.snapshot().agents[status.agentId];
   if (agent && !isInactiveLocalAgent(agent)) {
     return { kind: "resolved", agent };
@@ -49132,13 +50051,14 @@ async function resolveBrokerDeliveryTargetWithImplicitProjectCard(input, options
   return resolveBrokerDeliveryTarget(input);
 }
 async function resolveInvocationTarget(payload) {
-  return resolveBrokerDeliveryTargetWithImplicitProjectCard({
+  return resolveBrokerDeliveryTargetWithImplicitProjectAgent({
     target: payload.target,
     targetAgentId: payload.targetAgentId,
     targetSessionId: payload.targetSessionId,
     targetLabel: payload.targetLabel,
     routePolicy: payload.routePolicy,
-    execution: payload.execution
+    execution: payload.execution,
+    projectAgent: undefined
   }, {
     requesterId: payload.requesterId,
     currentDirectory: projectPathRouteTarget(payload),
@@ -49156,7 +50076,7 @@ function remediationForDispatch(dispatch) {
   }
   if (dispatch.kind === "unavailable") {
     return {
-      kind: dispatch.target?.reason === "manual_wake_required" ? "wake_target" : "retry_later",
+      kind: dispatch.target?.reason === "manual_wake_required" ? "wake_target" : dispatch.target?.reason === "stale_registration" ? "stale_reference" : "retry_later",
       detail: dispatch.target?.detail ?? dispatch.detail,
       targetAgentId: dispatch.target?.agentId,
       targetLabel: dispatch.askedLabel,
@@ -49494,7 +50414,7 @@ async function acceptBrokerDelivery(payload) {
   const askedLabel = askedLabelForRouteTarget(payload);
   const execution = executionWithRouteParams(payload);
   const deliveryChannel = routeChannelForTarget(payload) ?? payload.channel?.trim();
-  const targetSessionId = payload.target?.kind === "session_id" ? payload.target.sessionId.trim() : payload.targetSessionId?.trim() || metadataStringValue2(payload.invocationMetadata, "targetSessionId") || metadataStringValue2(payload.messageMetadata, "targetSessionId") || undefined;
+  const targetSessionId = payload.target?.kind === "session_id" ? payload.target.sessionId.trim() : payload.targetSessionId?.trim() || payload.execution?.targetSessionId?.trim() || metadataStringValue2(payload.invocationMetadata, "targetSessionId") || metadataStringValue2(payload.messageMetadata, "targetSessionId") || undefined;
   const replyToSessionId = payload.replyToSessionId?.trim() || metadataStringValue2(payload.invocationMetadata, "replyToSessionId") || metadataStringValue2(payload.messageMetadata, "replyToSessionId") || undefined;
   const labels = normalizeScoutLabels(payload.labels);
   const typedChannelTarget = payload.target?.kind === "channel" || payload.target?.kind === "broadcast";
@@ -49748,7 +50668,7 @@ async function acceptBrokerDelivery(payload) {
       message: message2
     };
   }
-  const resolved = await resolveBrokerDeliveryTargetWithImplicitProjectCard({
+  const resolved = await resolveBrokerDeliveryTargetWithImplicitProjectAgent({
     ...payload,
     execution
   }, {
@@ -49776,7 +50696,7 @@ async function acceptBrokerDelivery(payload) {
       remediation: remediationForDispatch(record2)
     };
   }
-  const unavailable = describeUnavailableDeliveryTarget(runtime.snapshot(), resolved.agent);
+  const unavailable = describeUnavailableDeliveryTarget(runtime.snapshot(), resolved.agent, targetSessionId);
   if (unavailable) {
     const { record: record2 } = await recordScoutDispatchDurably(buildUnavailableDispatchEnvelope(askedLabel || brokerTargetLabel(resolved.agent), unavailable), {
       requesterId
@@ -49881,9 +50801,11 @@ async function acceptBrokerDelivery(payload) {
     ...targetSessionId ? { targetSessionId } : {},
     ...payload.intent === "tell" && payload.invocationMetadata?.sourceIntent === undefined ? { sourceIntent: "direct_message" } : {}
   };
+  const baseInvocationExecution = execution ?? {};
   const invocationExecution = {
-    ...execution ?? (payload.intent === "tell" ? { session: "any" } : {}),
-    ...targetSessionId ? { session: "existing", targetSessionId } : {}
+    ...baseInvocationExecution,
+    session: targetSessionId ? "existing" : "new",
+    ...targetSessionId ? { targetSessionId } : {}
   };
   const invocation = {
     id: createRuntimeId2("inv"),