@openscout/scout 0.2.92 → 0.2.94

package/dist/runtime/broker-daemon.mjs

@@ -3182,12 +3182,12 @@ function checkDaemonBinaryStale() {
       debug22(`daemon binary path changed: ${info.binaryPath} \u2192 ${currentBinaryPath}`);
     } else {
       try {
-        const stat7 = fs2.statSync(currentBinaryPath);
-        if (stat7.mtimeMs === info.binaryMtimeMs) {
+        const stat8 = fs2.statSync(currentBinaryPath);
+        if (stat8.mtimeMs === info.binaryMtimeMs) {
           debug22("daemon binary is current \u2014 no restart needed");
           return;
         }
-        debug22(`daemon binary mtime changed: ${info.binaryMtimeMs} \u2192 ${stat7.mtimeMs}`);
+        debug22(`daemon binary mtime changed: ${info.binaryMtimeMs} \u2192 ${stat8.mtimeMs}`);
       } catch {
         return;
       }
@@ -3207,10 +3207,10 @@ function checkDaemonBinaryStale() {
 }
 function writeDaemonInfo(binaryPath) {
   try {
-    const stat7 = fs2.statSync(binaryPath);
+    const stat8 = fs2.statSync(binaryPath);
     fs2.writeFileSync(getDaemonInfoPath(), JSON.stringify({
       binaryPath,
-      binaryMtimeMs: stat7.mtimeMs
+      binaryMtimeMs: stat8.mtimeMs
     }));
   } catch {}
 }
@@ -3448,8 +3448,8 @@ function getParentSessionId() {
     const chain = [process.pid];
     let current = process.pid;
     for (let i = 0;i < 64; i++) {
-      const stat7 = fs2.readFileSync(`/proc/${current}/stat`, "utf-8");
-      const fields = stat7.split(") ");
+      const stat8 = fs2.readFileSync(`/proc/${current}/stat`, "utf-8");
+      const fields = stat8.split(") ");
       if (fields.length < 2)
         break;
       const ppid = parseInt(fields[1].split(" ")[1], 10);
@@ -4594,8 +4594,8 @@ async function withDirLock(lockPath, opts, fn) {
       }
       try {
         const owner = readLockOwner(lockPath);
-        const stat7 = fs.statSync(lockPath);
-        const ageMs = Date.now() - stat7.mtimeMs;
+        const stat8 = fs.statSync(lockPath);
+        const ageMs = Date.now() - stat8.mtimeMs;
         if (owner ? !isLockOwnerAlive(owner) : ageMs > OWNER_GRACE_MS) {
           debug4("stealing abandoned lock %s (owner pid %s)", lockPath, owner?.pid ?? "unknown");
           stealLock(lockPath);
@@ -23960,8 +23960,8 @@ function writeBackValue(itemKey, newValueStr, sourceFilePath) {
 }
 function getParentPidViaProc(pid) {
   try {
-    const stat7 = readFileSync19(`/proc/${pid}/stat`, "utf8");
-    const after = stat7.slice(stat7.lastIndexOf(")") + 2);
+    const stat8 = readFileSync19(`/proc/${pid}/stat`, "utf8");
+    const after = stat8.slice(stat8.lastIndexOf(")") + 2);
     const fields = after.split(" ");
     const ppid = Number(fields[1]);
     return Number.isFinite(ppid) ? ppid : undefined;
@@ -26972,7 +26972,7 @@ var require_tslib2 = __commonJS((exports, module) => {
 // packages/runtime/src/broker-daemon.ts
 import { createHash as createHash16, randomUUID as randomUUID9 } from "crypto";
 import { createServer } from "http";
-import { mkdir as mkdir14, readFile as readFile15, rename as rename3, stat as stat7, unlink as unlink3, writeFile as writeFile11 } from "fs/promises";
+import { mkdir as mkdir14, readFile as readFile15, rename as rename3, stat as stat8, unlink as unlink3, writeFile as writeFile11 } from "fs/promises";
 import { createRequire as createRequire4 } from "module";
 import { hostname as hostname4 } from "os";
 import { basename as basename24, dirname as dirname33, join as join56, resolve as resolve22 } from "path";
@@ -43866,7 +43866,6 @@ function formatScoutPermissionProfiles() {
 
 // packages/protocol/src/presence.ts
 var PRESENCE_STALE_AFTER_MS = 45000;
-var PRESENCE_REFRESH_INTERVAL_MS = 30000;
 var PRESENCE_GONE_AFTER_STALE_MS = 60000;
 function presenceLifecycle(beat, now, options = {}) {
   if (now < beat.staleAt)
@@ -44660,7 +44659,7 @@ function isScoutLaunchableHarness(value) {
   if (!value)
     return false;
   const normalized = value.trim().toLowerCase();
-  return SCOUT_LAUNCHABLE_HARNESSES.includes(normalized);
+  return normalized === "oc" || SCOUT_LAUNCHABLE_HARNESSES.includes(normalized);
 }
 function normalizeScoutReasoningEffort(value) {
   const normalized = value?.trim().toLowerCase();
@@ -45353,12 +45352,12 @@ function patchConsoleForSecrets() {
 }
 
 // packages/runtime/src/tail/claude-source.ts
-import { closeSync, existsSync as existsSync4, openSync, readdirSync, readSync, statSync } from "fs";
+import { closeSync, existsSync as existsSync4, openSync, readdirSync, readSync, statSync as statSync2 } from "fs";
 import { homedir as homedir4 } from "os";
 import { basename, join as join4, relative } from "path";
 
 // packages/runtime/src/user-config.ts
-import { existsSync as existsSync2, readFileSync, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { existsSync as existsSync2, readFileSync, statSync, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
 import { homedir as homedir2 } from "os";
 import { dirname, join as join2 } from "path";
 
@@ -45441,15 +45440,41 @@ function ensureOpenScoutCleanSlateSync() {
 function userConfigPath() {
   return join2(process.env.OPENSCOUT_HOME ?? join2(homedir2(), ".openscout"), "user.json");
 }
-function loadUserConfig() {
-  const configPath = userConfigPath();
-  if (!existsSync2(configPath))
-    return {};
+var userConfigCache = null;
+var USER_CONFIG_STAT_INTERVAL_MS = 100;
+function userConfigFileKey(configPath) {
   try {
-    return JSON.parse(readFileSync(configPath, "utf8"));
+    const stats = statSync(configPath);
+    return `${stats.ino}:${stats.mtimeMs}:${stats.size}`;
   } catch {
-    return {};
+    return "missing";
+  }
+}
+function readUserConfigFromDisk(configPath, now) {
+  const fileKey = userConfigFileKey(configPath);
+  let value = {};
+  if (existsSync2(configPath)) {
+    try {
+      value = JSON.parse(readFileSync(configPath, "utf8"));
+    } catch {
+      value = {};
+    }
+  }
+  userConfigCache = { path: configPath, value, fileKey, statCheckedAt: now };
+  return { ...value };
+}
+function loadUserConfig(now = Date.now()) {
+  const configPath = userConfigPath();
+  if (userConfigCache && userConfigCache.path === configPath) {
+    if (now - userConfigCache.statCheckedAt < USER_CONFIG_STAT_INTERVAL_MS) {
+      return { ...userConfigCache.value };
+    }
+    if (userConfigFileKey(configPath) === userConfigCache.fileKey) {
+      userConfigCache.statCheckedAt = now;
+      return { ...userConfigCache.value };
+    }
   }
+  return readUserConfigFromDisk(configPath, now);
 }
 function readSettingsOperatorName() {
   const settingsPath = resolveOpenScoutSupportPaths().settingsPath;
@@ -47558,7 +47583,7 @@ function listRecentClaudeProjectTranscripts(root, scope) {
   for (const entry of projectDirs) {
     const projectDir = join4(root, entry);
     try {
-      if (!statSync(projectDir).isDirectory())
+      if (!statSync2(projectDir).isDirectory())
         continue;
     } catch {
       continue;
@@ -47566,13 +47591,13 @@ function listRecentClaudeProjectTranscripts(root, scope) {
     for (const file2 of listJsonlFiles(projectDir)) {
       const path = join4(projectDir, file2);
       try {
-        const stats = statSync(path);
+        const stats = statSync2(path);
         const subagentsDir = join4(projectDir, basename(path, ".jsonl"), "subagents");
         const activeSubagents = [];
         for (const subagentFile of listClaudeSubagentFiles(subagentsDir)) {
           const subagentPath = join4(subagentsDir, subagentFile);
           try {
-            const subagentStats = statSync(subagentPath);
+            const subagentStats = statSync2(subagentPath);
             if (subagentStats.mtimeMs < cutoff)
               continue;
             activeSubagents.push({
@@ -47809,7 +47834,7 @@ var ClaudeSource = {
 };
 
 // packages/runtime/src/tail/codex-source.ts
-import { closeSync as closeSync2, existsSync as existsSync5, openSync as openSync2, readdirSync as readdirSync2, readSync as readSync2, statSync as statSync2 } from "fs";
+import { closeSync as closeSync2, existsSync as existsSync5, openSync as openSync2, readdirSync as readdirSync2, readSync as readSync2, statSync as statSync3 } from "fs";
 import { homedir as homedir5 } from "os";
 import { basename as basename2, join as join5 } from "path";
 var SOURCE_NAME2 = "codex";
@@ -47962,7 +47987,7 @@ function walkRecentJsonlFiles(root, scope) {
       const path = join5(dir, entry);
       let stats;
       try {
-        stats = statSync2(path);
+        stats = statSync3(path);
       } catch {
         continue;
       }
@@ -48230,7 +48255,7 @@ var CodexSource = {
 };
 
 // packages/runtime/src/tail/cursor-source.ts
-import { closeSync as closeSync3, existsSync as existsSync6, openSync as openSync3, readdirSync as readdirSync3, readSync as readSync3, statSync as statSync3 } from "fs";
+import { closeSync as closeSync3, existsSync as existsSync6, openSync as openSync3, readdirSync as readdirSync3, readSync as readSync3, statSync as statSync4 } from "fs";
 import { homedir as homedir6 } from "os";
 import { basename as basename3, join as join6 } from "path";
 var SOURCE_NAME3 = "cursor";
@@ -48357,7 +48382,7 @@ function walkRecentMonitorLogs(root, scope) {
       continue;
     const path = join6(root, entry);
     try {
-      const stats = statSync3(path);
+      const stats = statSync4(path);
       if (!stats.isFile() || stats.mtimeMs < cutoff)
         continue;
       found.push({ path, mtimeMs: stats.mtimeMs, size: stats.size });
@@ -48430,7 +48455,7 @@ var CursorSource = {
 };
 
 // packages/runtime/src/tail/grok-source.ts
-import { closeSync as closeSync4, existsSync as existsSync7, openSync as openSync4, readdirSync as readdirSync4, readFileSync as readFileSync2, readSync as readSync4, statSync as statSync4 } from "fs";
+import { closeSync as closeSync4, existsSync as existsSync7, openSync as openSync4, readdirSync as readdirSync4, readFileSync as readFileSync2, readSync as readSync4, statSync as statSync5 } from "fs";
 import { homedir as homedir7 } from "os";
 import { basename as basename4, dirname as dirname2, join as join7 } from "path";
 var SOURCE_NAME4 = "grok";
@@ -48600,7 +48625,7 @@ function walkRecentGrokEventFiles(root, scope) {
       const path = join7(dir, entry);
       let stats;
       try {
-        stats = statSync4(path);
+        stats = statSync5(path);
       } catch {
         continue;
       }
@@ -48722,7 +48747,7 @@ function grokMatcherForTranscript(transcriptPath) {
     return null;
   let updatesMtimeMs = 0;
   try {
-    updatesMtimeMs = statSync4(updatesPath).mtimeMs;
+    updatesMtimeMs = statSync5(updatesPath).mtimeMs;
   } catch {
     return null;
   }
@@ -48912,7 +48937,7 @@ var GrokSource = {
 };
 
 // packages/runtime/src/tail/kimi-source.ts
-import { existsSync as existsSync8, readdirSync as readdirSync5, readFileSync as readFileSync3, statSync as statSync5 } from "fs";
+import { existsSync as existsSync8, readdirSync as readdirSync5, readFileSync as readFileSync3, statSync as statSync6 } from "fs";
 import { homedir as homedir8 } from "os";
 import { basename as basename5, dirname as dirname3, join as join8 } from "path";
 var SOURCE_NAME5 = "kimi";
@@ -49014,7 +49039,7 @@ function walkRecentKimiWireFiles(root, scope) {
       const path = join8(directory, entry);
       let stats;
       try {
-        stats = statSync5(path);
+        stats = statSync6(path);
       } catch {
         continue;
       }
@@ -49034,7 +49059,7 @@ function readKimiTranscriptMetadata(file2) {
   let stateMtimeMs = null;
   let stateSize = null;
   try {
-    const stateStat = statSync5(statePath);
+    const stateStat = statSync6(statePath);
     stateMtimeMs = stateStat.mtimeMs;
     stateSize = stateStat.size;
   } catch {}
@@ -49253,7 +49278,7 @@ var KimiSource = {
 };
 
 // packages/runtime/src/tail/opencode-source.ts
-import { closeSync as closeSync5, existsSync as existsSync9, openSync as openSync5, readdirSync as readdirSync6, readFileSync as readFileSync4, readSync as readSync5, statSync as statSync6 } from "fs";
+import { closeSync as closeSync5, existsSync as existsSync9, openSync as openSync5, readdirSync as readdirSync6, readFileSync as readFileSync4, readSync as readSync5, statSync as statSync7 } from "fs";
 import { homedir as homedir9 } from "os";
 import { basename as basename6, join as join9, sep } from "path";
 var SOURCE_NAME6 = "opencode";
@@ -49390,7 +49415,7 @@ function walkRecentSessionFiles(root, scope) {
       const path = join9(dir, entry);
       let stats;
       try {
-        stats = statSync6(path);
+        stats = statSync7(path);
       } catch {
         continue;
       }
@@ -49418,38 +49443,63 @@ function walkRecentMessageSessionFiles(root, scope) {
   for (const sessionId of sessionDirs) {
     const dir = join9(messageRoot, sessionId);
     let entries = [];
+    let messageDirectoryMtime = 0;
     try {
-      const stats = statSync6(dir);
+      const stats = statSync7(dir);
       if (!stats.isDirectory())
         continue;
+      messageDirectoryMtime = stats.mtimeMs;
       entries = readdirSync6(dir);
     } catch {
       continue;
     }
-    let latestMessageMtime = 0;
+    let latestDependencyMtime = messageDirectoryMtime;
+    let dependencySize = entries.length;
     for (const entry of entries) {
       if (!entry.endsWith(".json"))
         continue;
       try {
-        const stats = statSync6(join9(dir, entry));
-        if (stats.isFile() && stats.mtimeMs >= cutoff && stats.mtimeMs > latestMessageMtime) {
-          latestMessageMtime = stats.mtimeMs;
+        const stats = statSync7(join9(dir, entry));
+        if (!stats.isFile())
+          continue;
+        latestDependencyMtime = Math.max(latestDependencyMtime, stats.mtimeMs);
+        dependencySize += stats.size;
+        const messageId = entry.replace(/\.json$/u, "");
+        const partDir = join9(root, "part", messageId);
+        const partDirStats = statSync7(partDir);
+        if (!partDirStats.isDirectory())
+          continue;
+        latestDependencyMtime = Math.max(latestDependencyMtime, partDirStats.mtimeMs);
+        const partEntries = readdirSync6(partDir);
+        dependencySize += partEntries.length;
+        for (const partEntry of partEntries) {
+          if (!partEntry.endsWith(".json"))
+            continue;
+          try {
+            const partStats = statSync7(join9(partDir, partEntry));
+            if (!partStats.isFile())
+              continue;
+            latestDependencyMtime = Math.max(latestDependencyMtime, partStats.mtimeMs);
+            dependencySize += partStats.size;
+          } catch {
+            continue;
+          }
         }
       } catch {
         continue;
       }
     }
-    if (latestMessageMtime <= 0)
+    if (latestDependencyMtime < cutoff)
       continue;
     const sessionPath = join9(root, "session", "global", `${sessionId}.json`);
     try {
-      const sessionStats = statSync6(sessionPath);
+      const sessionStats = statSync7(sessionPath);
       if (!sessionStats.isFile())
         continue;
       found.set(sessionPath, {
         path: sessionPath,
-        mtimeMs: Math.max(sessionStats.mtimeMs, latestMessageMtime),
-        size: sessionStats.size
+        mtimeMs: Math.max(sessionStats.mtimeMs, latestDependencyMtime),
+        size: sessionStats.size + dependencySize
       });
     } catch {
       continue;
@@ -49475,8 +49525,15 @@ function discoverOpenCodeTranscripts(scope) {
       ...walkRecentMessageSessionFiles(root, scope)
     ]) {
       const existing = byPath.get(file2.path);
-      if (!existing || file2.mtimeMs > existing.mtimeMs)
+      if (!existing) {
         byPath.set(file2.path, file2);
+      } else {
+        byPath.set(file2.path, {
+          path: file2.path,
+          mtimeMs: Math.max(existing.mtimeMs, file2.mtimeMs),
+          size: Math.max(existing.size, file2.size)
+        });
+      }
     }
   }
   return [...byPath.values()].sort((a, b) => b.mtimeMs - a.mtimeMs).slice(0, discoveryLimit6(scope)).map((file2) => {
@@ -49511,7 +49568,7 @@ function readOpenCodeMessages(root, sessionId) {
     const path = join9(dir, entry);
     let stats;
     try {
-      stats = statSync6(path);
+      stats = statSync7(path);
     } catch {
       continue;
     }
@@ -49539,7 +49596,7 @@ function readOpenCodeParts(root, messageId) {
     const path = join9(dir, entry);
     let stats;
     try {
-      stats = statSync6(path);
+      stats = statSync7(path);
     } catch {
       continue;
     }
@@ -49666,7 +49723,7 @@ var OpenCodeSource = {
 };
 
 // packages/runtime/src/tail/pi-source.ts
-import { closeSync as closeSync6, existsSync as existsSync10, openSync as openSync6, readdirSync as readdirSync7, readSync as readSync6, statSync as statSync7 } from "fs";
+import { closeSync as closeSync6, existsSync as existsSync10, openSync as openSync6, readdirSync as readdirSync7, readSync as readSync6, statSync as statSync8 } from "fs";
 import { homedir as homedir10 } from "os";
 import { basename as basename7, join as join10, relative as relative2 } from "path";
 var SOURCE_NAME7 = "pi";
@@ -49821,7 +49878,7 @@ function listRecentPiProjectTranscripts(root, scope) {
   for (const entry of projectDirs) {
     const projectDir = join10(root, entry);
     try {
-      if (!statSync7(projectDir).isDirectory())
+      if (!statSync8(projectDir).isDirectory())
         continue;
     } catch {
       continue;
@@ -49829,7 +49886,7 @@ function listRecentPiProjectTranscripts(root, scope) {
     for (const file2 of listJsonlFiles2(projectDir)) {
       const path = join10(projectDir, file2);
       try {
-        const stats = statSync7(path);
+        const stats = statSync8(path);
         if (stats.mtimeMs < cutoff)
           continue;
         found.push({ path, mtimeMs: stats.mtimeMs, size: stats.size });
@@ -50011,6 +50068,7 @@ var SHALLOW_DISCOVERY_INTERVAL_MS = readPositiveIntEnv8("OPENSCOUT_TAIL_SHALLOW_
 var DEEP_DISCOVERY_INTERVAL_MS = readPositiveIntEnv8("OPENSCOUT_TAIL_DEEP_DISCOVERY_INTERVAL_MS", 60 * 60000);
 var PER_SESSION_BUFFER_LIMIT = 2000;
 var AGGREGATE_BUFFER_LIMIT = 1e4;
+var ASSISTANT_BUFFER_LIMIT = 1e4;
 var QUIET_EVENT_COALESCE_WINDOW_MS = readPositiveIntEnv8("OPENSCOUT_TAIL_QUIET_EVENT_COALESCE_WINDOW_MS", 5000);
 var QUIET_EVENT_COALESCE_MAX_KEYS = readPositiveIntEnv8("OPENSCOUT_TAIL_QUIET_EVENT_COALESCE_MAX_KEYS", 2000);
 var RAW_MAX_DEPTH = 5;
@@ -50019,12 +50077,19 @@ var RAW_MAX_ARRAY_ITEMS = 25;
 var RAW_MAX_OBJECT_KEYS = 50;
 var RECENT_TRANSCRIPT_READ_BYTES = 512 * 1024;
 var SESSION_TRANSCRIPT_READ_BYTES = 8 * 1024 * 1024;
+var RECENT_TRANSCRIPT_KIND_SCAN_READ_BYTES = 32 * 1024 * 1024;
 var RECENT_TRANSCRIPT_LINES_PER_FILE = 200;
+var RECENT_TRANSCRIPT_KIND_SCAN_MAX_LINES = 65536;
 var RECENT_TRANSCRIPT_MAX_FILES = readPositiveIntEnv8("OPENSCOUT_TAIL_RECENT_TRANSCRIPT_MAX_FILES", 24);
 var NATIVE_TAIL_SOURCES = new Set(["grok", "kimi", "opencode", "cursor"]);
+var TRANSCRIPT_REPLAY_MEMO_MAX_ENTRIES = readPositiveIntEnv8("OPENSCOUT_TAIL_REPLAY_MEMO_MAX_ENTRIES", 256);
+var TRANSCRIPT_REPLAY_ACTIVE_GRACE_MS = readPositiveIntEnv8("OPENSCOUT_TAIL_REPLAY_MEMO_ACTIVE_GRACE_MS", 2000);
+var transcriptReplayMemo = new Map;
+var transcriptReplayInFlight = new Map;
 var sources = [GrokSource, KimiSource, ClaudeSource, CodexSource, CursorSource, OpenCodeSource, PiSource];
 var watchers = new Map;
 var aggregateBuffer = [];
+var assistantBuffer = [];
 var perSessionBuffer = new Map;
 var subscribers2 = new Set;
 var knownTranscripts = new Map;
@@ -50232,6 +50297,12 @@ function pushEvent(rawEvent) {
   if (aggregateBuffer.length > AGGREGATE_BUFFER_LIMIT) {
     aggregateBuffer.splice(0, aggregateBuffer.length - AGGREGATE_BUFFER_LIMIT);
   }
+  if (event.kind === "assistant") {
+    assistantBuffer.push(event);
+    if (assistantBuffer.length > ASSISTANT_BUFFER_LIMIT) {
+      assistantBuffer.splice(0, assistantBuffer.length - ASSISTANT_BUFFER_LIMIT);
+    }
+  }
   let bucket = perSessionBuffer.get(event.sessionId);
   if (!bucket) {
     bucket = [];
@@ -50562,14 +50633,16 @@ function subscribeTail(handler) {
 function snapshotRecentEvents(limit = 500) {
   return aggregateBuffer.slice(-limit);
 }
-async function readRecentLiveEvents(limit = 500) {
+async function readRecentLiveEvents(limit = 500, options) {
   if (watchers.size === 0) {
     scheduleDiscovery("shallow", { pruneMissing: true });
   } else if (!lastDiscovery || Date.now() - lastDiscovery.generatedAt > DISCOVERY_CACHE_MAX_AGE_MS) {
     scheduleDiscovery("hot", { pruneMissing: false });
   }
   pumpAllWatchers();
-  return snapshotRecentEvents(limit);
+  const kinds = options?.kinds?.length ? new Set(options.kinds) : null;
+  const source = kinds?.size === 1 && kinds.has("assistant") ? assistantBuffer : aggregateBuffer;
+  return kinds ? source.filter((event) => kinds.has(event.kind)).slice(-limit) : snapshotRecentEvents(limit);
 }
 async function readRecentTranscriptLines(path, maxLines = RECENT_TRANSCRIPT_LINES_PER_FILE, maxBytes = RECENT_TRANSCRIPT_READ_BYTES) {
   let handle = null;
@@ -50594,6 +50667,44 @@ async function readRecentTranscriptLines(path, maxLines = RECENT_TRANSCRIPT_LINE
     await handle?.close().catch(() => {});
   }
 }
+async function parseRecentTranscriptLineEvents(input) {
+  let fileSize = 0;
+  try {
+    fileSize = (await stat(input.transcriptPath)).size;
+  } catch {
+    return [];
+  }
+  let lineLimit = Math.max(1, input.lineLimit);
+  let readBytes = Math.max(1, Math.min(input.initialReadBytes, input.maxReadBytes));
+  const kindQuota = input.kinds?.size ? Math.max(1, input.kindQuota ?? 1) : null;
+  const maxLines = kindQuota ? Math.max(lineLimit, RECENT_TRANSCRIPT_KIND_SCAN_MAX_LINES) : lineLimit;
+  while (true) {
+    const lines = await readRecentTranscriptLines(input.transcriptPath, lineLimit, readBytes);
+    const parseState = {};
+    const parsed = [];
+    let index = 0;
+    for (const line of lines) {
+      const event = input.source.parseLine(line, {
+        ...input.context,
+        lineOffset: index,
+        state: parseState
+      });
+      index++;
+      if (event)
+        parsed.push(compactEvent(event));
+    }
+    const matchingCount = kindQuota ? parsed.reduce((count, event) => count + (input.kinds.has(event.kind) ? 1 : 0), 0) : 0;
+    const exhaustedFile = readBytes >= fileSize && lines.length < lineLimit;
+    if (!kindQuota || matchingCount >= kindQuota || exhaustedFile)
+      return parsed;
+    const nextLineLimit = Math.min(maxLines, lineLimit * 2);
+    const nextReadBytes = Math.min(input.maxReadBytes, readBytes * 2);
+    if (nextLineLimit === lineLimit && nextReadBytes === readBytes)
+      return parsed;
+    lineLimit = nextLineLimit;
+    readBytes = nextReadBytes;
+  }
+}
 function rememberTranscriptEvent(events, seenEvents, event, dedupeKey) {
   const compacted = compactEvent(event);
   const key = dedupeKey ?? compacted.id;
@@ -50602,45 +50713,108 @@ function rememberTranscriptEvent(events, seenEvents, event, dedupeKey) {
   seenEvents.add(key);
   events.push(compacted);
 }
-async function appendWatcherTranscriptEvents(events, seenEvents, watcher, perTranscriptLineLimit) {
+async function memoizedTranscriptReplay(transcriptPath, variant, load, dependency) {
+  const cacheKey = `${transcriptPath}\x00${variant}`;
+  const inFlight = transcriptReplayInFlight.get(cacheKey);
+  if (inFlight)
+    return [...await inFlight];
+  let stats;
+  try {
+    stats = await stat(transcriptPath);
+  } catch {
+    transcriptReplayMemo.delete(cacheKey);
+    return [];
+  }
+  const fingerprint = [
+    stats.size,
+    stats.mtimeMs,
+    dependency?.size ?? "",
+    dependency?.mtimeMs ?? ""
+  ].join(":");
+  const effectiveMtimeMs = Math.max(stats.mtimeMs, dependency?.mtimeMs ?? 0);
+  const cached2 = transcriptReplayMemo.get(cacheKey);
+  const unchanged = cached2 && cached2.fingerprint === fingerprint;
+  if (unchanged) {
+    cached2.staleSinceMs = undefined;
+    return [...cached2.events];
+  }
+  const now = Date.now();
+  if (cached2 && now - effectiveMtimeMs < TRANSCRIPT_REPLAY_ACTIVE_GRACE_MS) {
+    cached2.staleSinceMs ??= now;
+    if (now - cached2.staleSinceMs < TRANSCRIPT_REPLAY_ACTIVE_GRACE_MS) {
+      return [...cached2.events];
+    }
+  }
+  const promise2 = (async () => {
+    const events = await load();
+    transcriptReplayMemo.delete(cacheKey);
+    transcriptReplayMemo.set(cacheKey, {
+      events: [...events],
+      fingerprint
+    });
+    while (transcriptReplayMemo.size > TRANSCRIPT_REPLAY_MEMO_MAX_ENTRIES) {
+      const oldest = transcriptReplayMemo.keys().next().value;
+      if (typeof oldest !== "string")
+        break;
+      transcriptReplayMemo.delete(oldest);
+    }
+    return events;
+  })().finally(() => transcriptReplayInFlight.delete(cacheKey));
+  transcriptReplayInFlight.set(cacheKey, promise2);
+  return [...await promise2];
+}
+async function appendWatcherTranscriptEvents(events, seenEvents, watcher, options) {
   const { source, transcript, process: process3, transcriptPath } = watcher;
   if (source.parseFile) {
-    const text2 = await readTranscriptText(transcriptPath);
-    if (!text2)
-      return;
-    const parsed = parsedEventsToArray(source.parseFile(text2, {
-      process: process3,
-      transcript,
-      transcriptPath,
-      lineOffset: 0,
-      state: {}
-    }));
-    for (const event of parsed) {
+    const readBytes = options?.kinds?.size ? RECENT_TRANSCRIPT_KIND_SCAN_READ_BYTES : RECENT_TRANSCRIPT_READ_BYTES;
+    const parsed2 = await memoizedTranscriptReplay(transcriptPath, `recent:file:${source.name}:${sessionRegistryKey(transcript)}:${readBytes}:${[...options?.kinds ?? []].sort().join(",")}`, async () => {
+      const text2 = await readTranscriptText(transcriptPath, readBytes);
+      if (!text2)
+        return [];
+      return parsedEventsToArray(source.parseFile(text2, {
+        process: process3,
+        transcript,
+        transcriptPath,
+        lineOffset: 0,
+        state: {}
+      }));
+    }, { size: transcript.size, mtimeMs: transcript.mtimeMs });
+    for (const event of parsed2) {
+      if (options?.kinds?.size && !options.kinds.has(event.kind))
+        continue;
       rememberTranscriptEvent(events, seenEvents, event);
     }
     return;
   }
-  const lines = await readRecentTranscriptLines(transcriptPath, perTranscriptLineLimit);
-  const parseState = {};
-  lines.forEach((line, index) => {
-    const event = source.parseLine(line, {
+  const lineLimit = options?.perTranscriptLineLimit ?? RECENT_TRANSCRIPT_LINES_PER_FILE;
+  const kindKey = [...options?.kinds ?? []].sort().join(",");
+  const parsed = await memoizedTranscriptReplay(transcriptPath, `recent:lines:${source.name}:${sessionRegistryKey(transcript)}:${lineLimit}:${RECENT_TRANSCRIPT_READ_BYTES}:${kindKey}:${options?.kindQuota ?? ""}`, () => parseRecentTranscriptLineEvents({
+    source,
+    transcriptPath,
+    context: {
       process: process3,
       transcript,
       transcriptPath,
-      lineOffset: index,
-      state: parseState
-    });
-    if (!event)
-      return;
-    const compacted = compactEvent(event);
+      lineOffset: 0,
+      state: {}
+    },
+    lineLimit,
+    initialReadBytes: RECENT_TRANSCRIPT_READ_BYTES,
+    maxReadBytes: options?.kinds?.size ? RECENT_TRANSCRIPT_KIND_SCAN_READ_BYTES : RECENT_TRANSCRIPT_READ_BYTES,
+    kinds: options?.kinds,
+    kindQuota: options?.kindQuota
+  }));
+  for (const event of parsed) {
+    if (options?.kinds?.size && !options.kinds.has(event.kind))
+      continue;
     const eventKey = [
-      compacted.source,
-      compacted.sessionId,
-      compacted.kind,
-      compacted.summary
+      event.source,
+      event.sessionId,
+      event.kind,
+      event.summary
     ].join("\x00");
     rememberTranscriptEvent(events, seenEvents, event, eventKey);
-  });
+  }
 }
 async function readRecentTranscriptEvents(limit = 50, options) {
   if (watchers.size === 0) {
@@ -50657,24 +50831,34 @@ async function readRecentTranscriptEvents(limit = 50, options) {
   const seenTranscriptPaths = new Set;
   const transcriptReadLimit = Math.min(RECENT_TRANSCRIPT_MAX_FILES, Math.max(12, limit));
   const lineLimit = options?.perTranscriptLineLimit ?? RECENT_TRANSCRIPT_LINES_PER_FILE;
+  const kinds = options?.kinds?.length ? new Set(options.kinds) : null;
+  const kindQuota = kinds ? Math.max(1, options?.perTranscriptKindLimit ?? limit) : undefined;
   const activeWatchers = [...watchers.values()].sort((left, right) => right.transcript.mtimeMs - left.transcript.mtimeMs).slice(0, transcriptReadLimit);
   for (const watcher of activeWatchers) {
     seenTranscriptPaths.add(watcher.transcriptPath);
-    await appendWatcherTranscriptEvents(events, seenEvents, watcher, lineLimit);
+    await appendWatcherTranscriptEvents(events, seenEvents, watcher, {
+      perTranscriptLineLimit: lineLimit,
+      kinds,
+      kindQuota
+    });
   }
   if (options?.discovery?.transcripts?.length) {
     const discoveryTranscripts = [...options.discovery.transcripts].filter((transcript) => !seenTranscriptPaths.has(transcript.transcriptPath)).sort((left, right) => right.mtimeMs - left.mtimeMs).slice(0, transcriptReadLimit);
     for (const transcript of discoveryTranscripts) {
-      const parsed = await parseTranscriptSessionEvents(transcript, options.discovery.processes, lineLimit);
+      const parsed = await parseTranscriptSessionEvents(transcript, options.discovery.processes, lineLimit, {
+        kinds,
+        kindQuota,
+        initialReadBytes: RECENT_TRANSCRIPT_READ_BYTES
+      });
       for (const event of parsed) {
         rememberTranscriptEvent(events, seenEvents, event);
       }
       seenTranscriptPaths.add(transcript.transcriptPath);
     }
   }
-  return events.sort((left, right) => right.ts - left.ts).slice(0, limit);
+  return events.filter((event) => !kinds || kinds.has(event.kind)).sort((left, right) => right.ts - left.ts).slice(0, limit);
 }
-async function parseTranscriptSessionEvents(transcript, processes, limit) {
+async function parseTranscriptSessionEvents(transcript, processes, limit, options) {
   const source = sources.find((candidate) => candidate.name === transcript.source);
   if (!source)
     return [];
@@ -50686,25 +50870,29 @@ async function parseTranscriptSessionEvents(transcript, processes, limit) {
     lineOffset: 0,
     state: {}
   };
-  if (source.parseFile) {
-    const text2 = await readTranscriptText(transcript.transcriptPath, SESSION_TRANSCRIPT_READ_BYTES);
-    if (!text2)
-      return [];
-    return parsedEventsToArray(source.parseFile(text2, ctxBase)).map(redactTailEvent).sort((left, right) => left.ts - right.ts).slice(-limit);
-  }
   const lineBudget = Math.max(limit, RECENT_TRANSCRIPT_LINES_PER_FILE);
-  const lines = await readRecentTranscriptLines(transcript.transcriptPath, lineBudget, SESSION_TRANSCRIPT_READ_BYTES);
-  const events = [];
-  lines.forEach((line, index) => {
-    const event = source.parseLine(line, {
-      ...ctxBase,
-      lineOffset: index
-    });
-    if (event) {
-      events.push(compactEvent(event));
+  const kindKey = [...options?.kinds ?? []].sort().join(",");
+  const maxReadBytes = options?.kinds?.size ? RECENT_TRANSCRIPT_KIND_SCAN_READ_BYTES : SESSION_TRANSCRIPT_READ_BYTES;
+  const replayVariant = source.parseFile ? `session:file:${source.name}:${sessionRegistryKey(transcript)}:${maxReadBytes}:${kindKey}` : `session:lines:${source.name}:${sessionRegistryKey(transcript)}:${lineBudget}:${maxReadBytes}:${kindKey}:${options?.kindQuota ?? ""}`;
+  const parsed = await memoizedTranscriptReplay(transcript.transcriptPath, replayVariant, async () => {
+    if (source.parseFile) {
+      const text2 = await readTranscriptText(transcript.transcriptPath, maxReadBytes);
+      if (!text2)
+        return [];
+      return parsedEventsToArray(source.parseFile(text2, ctxBase)).map(redactTailEvent);
     }
-  });
-  return events.sort((left, right) => left.ts - right.ts).slice(-limit);
+    return parseRecentTranscriptLineEvents({
+      source,
+      transcriptPath: transcript.transcriptPath,
+      context: ctxBase,
+      lineLimit: lineBudget,
+      initialReadBytes: options?.initialReadBytes ?? SESSION_TRANSCRIPT_READ_BYTES,
+      maxReadBytes,
+      kinds: options?.kinds,
+      kindQuota: options?.kindQuota
+    });
+  }, source.parseFile ? { size: transcript.size, mtimeMs: transcript.mtimeMs } : undefined);
+  return parsed.filter((event) => !options?.kinds?.size || options.kinds.has(event.kind)).sort((left, right) => left.ts - right.ts).slice(-limit);
 }
 // packages/runtime/src/tail/display.ts
 var GROK_STREAMING_PHASES = new Set([
@@ -50771,7 +50959,7 @@ import { createHash } from "crypto";
 import { homedir as homedir15 } from "os";
 
 // packages/agent-sessions/src/adapters/claude-code/team-topology.ts
-import { existsSync as existsSync11, readdirSync as readdirSync8, readFileSync as readFileSync5, statSync as statSync8 } from "fs";
+import { existsSync as existsSync11, readdirSync as readdirSync8, readFileSync as readFileSync5, statSync as statSync9 } from "fs";
 import { homedir as homedir11 } from "os";
 import { basename as basename8, dirname as dirname4, join as join11, relative as relative3 } from "path";
 var TOPOLOGY_SCHEMA_VERSION = "openscout.observed-harness-topology.v1";
@@ -50824,14 +51012,14 @@ function readJsonObject(path) {
 }
 function statIsDirectory(path) {
   try {
-    return statSync8(path).isDirectory();
+    return statSync9(path).isDirectory();
   } catch {
     return false;
   }
 }
 function statIsFile(path) {
   try {
-    return statSync8(path).isFile();
+    return statSync9(path).isFile();
   } catch {
     return false;
   }
@@ -51224,7 +51412,7 @@ function readClaudeAgentTeamTopology(options = {}) {
 }
 
 // packages/agent-sessions/src/adapters/claude-code/subagent-topology.ts
-import { existsSync as existsSync12, readdirSync as readdirSync9, readFileSync as readFileSync6, statSync as statSync9 } from "fs";
+import { existsSync as existsSync12, readdirSync as readdirSync9, readFileSync as readFileSync6, statSync as statSync10 } from "fs";
 import { homedir as homedir12 } from "os";
 import { join as join12, normalize, sep as sep2 } from "path";
 var TOPOLOGY_SCHEMA_VERSION2 = "openscout.observed-harness-topology.v1";
@@ -51248,21 +51436,21 @@ function sourceRefId2(kind, value) {
 }
 function statIsDirectory2(path) {
   try {
-    return statSync9(path).isDirectory();
+    return statSync10(path).isDirectory();
   } catch {
     return false;
   }
 }
 function statIsFile2(path) {
   try {
-    return statSync9(path).isFile();
+    return statSync10(path).isFile();
   } catch {
     return false;
   }
 }
 function statMtimeMs(path) {
   try {
-    return statSync9(path).mtimeMs;
+    return statSync10(path).mtimeMs;
   } catch {
     return 0;
   }
@@ -51744,7 +51932,7 @@ function readClaudeSubagentTopology(options = {}) {
 }
 
 // packages/agent-sessions/src/adapters/claude-code/workflow-topology.ts
-import { existsSync as existsSync13, readdirSync as readdirSync10, readFileSync as readFileSync7, statSync as statSync10 } from "fs";
+import { existsSync as existsSync13, readdirSync as readdirSync10, readFileSync as readFileSync7, statSync as statSync11 } from "fs";
 import { homedir as homedir13 } from "os";
 import { basename as basename10, join as join13, normalize as normalize2, relative as relative4, sep as sep3 } from "path";
 var TOPOLOGY_SCHEMA_VERSION3 = "openscout.observed-harness-topology.v1";
@@ -51767,21 +51955,21 @@ function sourceRefId3(kind, value) {
 }
 function statIsDirectory3(path) {
   try {
-    return statSync10(path).isDirectory();
+    return statSync11(path).isDirectory();
   } catch {
     return false;
   }
 }
 function statIsFile3(path) {
   try {
-    return statSync10(path).isFile();
+    return statSync11(path).isFile();
   } catch {
     return false;
   }
 }
 function statMtimeMs2(path) {
   try {
-    return statSync10(path).mtimeMs;
+    return statSync11(path).mtimeMs;
   } catch {
     return 0;
   }
@@ -52469,7 +52657,7 @@ function readClaudeWorkflowTopology(options = {}) {
 }
 
 // packages/agent-sessions/src/adapters/codex/topology.ts
-import { existsSync as existsSync14, readdirSync as readdirSync11, readFileSync as readFileSync8, statSync as statSync11 } from "fs";
+import { existsSync as existsSync14, readdirSync as readdirSync11, readFileSync as readFileSync8, statSync as statSync12 } from "fs";
 import { homedir as homedir14 } from "os";
 import { basename as basename11, join as join14 } from "path";
 var TOPOLOGY_SCHEMA_VERSION4 = "openscout.observed-harness-topology.v1";
@@ -52496,14 +52684,14 @@ function sourceRefId4(kind, value) {
 }
 function statIsDirectory4(path) {
   try {
-    return statSync11(path).isDirectory();
+    return statSync12(path).isDirectory();
   } catch {
     return false;
   }
 }
 function statIsFile4(path) {
   try {
-    return statSync11(path).isFile();
+    return statSync12(path).isFile();
   } catch {
     return false;
   }
@@ -52914,7 +53102,12 @@ class CodexObservedTopologyTracker {
 
 // packages/runtime/src/harness-topology/service.ts
 var DEFAULT_POLL_INTERVAL_MS = readPositiveIntEnv9("OPENSCOUT_TOPOLOGY_POLL_INTERVAL_MS", 1e4);
+var DEFAULT_MIN_SCAN_INTERVAL_MS = 15000;
 var EVENT_BUFFER_LIMIT = 500;
+function minScanIntervalMs() {
+  const raw = Number.parseInt(process.env.SCOUT_TOPOLOGY_MIN_SCAN_INTERVAL_MS ?? "", 10);
+  return Number.isFinite(raw) && raw >= 0 ? raw : DEFAULT_MIN_SCAN_INTERVAL_MS;
+}
 function readPositiveIntEnv9(name, fallback) {
   const raw = Number.parseInt(process.env[name] ?? "", 10);
   return Number.isFinite(raw) && raw > 0 ? raw : fallback;
@@ -53016,6 +53209,7 @@ class HarnessTopologyObserver {
   scanInFlight = null;
   eventCounter = 0;
   lastSnapshot = null;
+  lastScanCompletedAt = 0;
   constructor(options = {}) {
     this.options = options;
   }
@@ -53027,16 +53221,28 @@ class HarnessTopologyObserver {
     });
     return this.scanInFlight;
   }
+  scanThrottled() {
+    if (this.scanInFlight)
+      return this.scanInFlight;
+    const interval = minScanIntervalMs();
+    if (this.lastSnapshot && interval > 0 && Date.now() - this.lastScanCompletedAt < interval) {
+      return Promise.resolve(this.lastSnapshot);
+    }
+    return this.scan();
+  }
   async getSnapshot(force = false) {
-    if (force || !this.lastSnapshot) {
+    if (force) {
       return this.scan();
     }
+    if (!this.lastSnapshot) {
+      return this.scanThrottled();
+    }
     return this.lastSnapshot;
   }
   subscribe(handler) {
     this.subscribers.add(handler);
     this.ensureLoopRunning();
-    this.scan();
+    this.scanThrottled();
     return () => {
       this.subscribers.delete(handler);
       if (this.subscribers.size === 0) {
@@ -53084,6 +53290,7 @@ class HarnessTopologyObserver {
       });
     }
     this.lastSnapshot = this.buildSnapshot(nowMs2);
+    this.lastScanCompletedAt = Date.now();
     return this.lastSnapshot;
   }
   buildSnapshot(generatedAt) {
@@ -53127,7 +53334,7 @@ class HarnessTopologyObserver {
     if (this.timer)
       return;
     this.timer = setInterval(() => {
-      this.scan();
+      this.scanThrottled();
     }, this.options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS);
   }
   stopLoop() {
@@ -53148,7 +53355,7 @@ function snapshotRecentHarnessTopologyEvents(limit = EVENT_BUFFER_LIMIT) {
   return defaultObserver.snapshotRecentEvents(limit);
 }
 function nudgeHarnessTopologyScan() {
-  return defaultObserver.scan();
+  return defaultObserver.getSnapshot(true);
 }
 // packages/runtime/src/broker-trpc-router.ts
 var t = initTRPC.create();
@@ -53367,41 +53574,28 @@ var controlRouter = t.router({
   events: t.procedure.input(controlEventsInput).subscription(async function* ({ input, signal }) {
     const kinds = input?.kinds;
     const filter = kinds && kinds.length > 0 ? new Set(kinds) : null;
-    const liveIterator = controlEventIterable(kinds, signal)[Symbol.asyncIterator]();
-    const replayedIds = new Set;
-    try {
-      const backlog = snapshotRecentControlEvents(CONTROL_BACKLOG_LIMIT);
-      let startIdx = 0;
-      if (input?.since) {
-        const idx = backlog.findIndex((event) => event.id === input.since);
-        if (idx >= 0)
-          startIdx = idx + 1;
-      }
-      for (let i = startIdx;i < backlog.length; i++) {
-        const event = backlog[i];
-        if (!event)
-          continue;
-        if (filter && !filter.has(event.kind))
-          continue;
-        replayedIds.add(event.id);
-        yield tracked(event.id, event);
-      }
-      for (const event of snapshotPresenceControlEvents()) {
-        if (filter && !filter.has(event.kind))
-          continue;
-        replayedIds.add(event.id);
-        yield tracked(event.id, event);
-      }
-      while (true) {
-        const next = await liveIterator.next();
-        if (next.done)
-          return;
-        if (replayedIds.delete(next.value.id))
-          continue;
-        yield tracked(next.value.id, next.value);
-      }
-    } finally {
-      await liveIterator.return?.();
+    const backlog = snapshotRecentControlEvents(CONTROL_BACKLOG_LIMIT);
+    let startIdx = 0;
+    if (input?.since) {
+      const idx = backlog.findIndex((event) => event.id === input.since);
+      if (idx >= 0)
+        startIdx = idx + 1;
+    }
+    for (let i = startIdx;i < backlog.length; i++) {
+      const event = backlog[i];
+      if (!event)
+        continue;
+      if (filter && !filter.has(event.kind))
+        continue;
+      yield tracked(event.id, event);
+    }
+    for (const event of snapshotPresenceControlEvents()) {
+      if (filter && !filter.has(event.kind))
+        continue;
+      yield tracked(event.id, event);
+    }
+    for await (const event of controlEventIterable(kinds, signal)) {
+      yield tracked(event.id, event);
     }
   })
 });
@@ -53636,18 +53830,20 @@ function activeCollaboration(record3) {
 }
 function queryRuntimeRegistrySnapshot(snapshot, query = {}) {
   const since = finiteTimestamp(query.since);
-  if (since === null) {
+  const conversationScoped = query.scope === "conversations";
+  if (since === null && !conversationScoped) {
     return snapshot;
   }
-  const messages = Object.values(snapshot.messages).filter((message) => message.createdAt >= since);
-  const recentInvocationIds = new Set(Object.values(snapshot.invocations).filter((invocation) => invocation.createdAt >= since).map((invocation) => invocation.id));
-  const flights = Object.values(snapshot.flights).filter((flight) => ACTIVE_FLIGHT_STATES.has(flight.state) || recordTimestamp(flight) >= since || recentInvocationIds.has(flight.invocationId));
+  const cutoff = since ?? 0;
+  const messages = Object.values(snapshot.messages).filter((message) => message.createdAt >= cutoff);
+  const recentInvocationIds = new Set(Object.values(snapshot.invocations).filter((invocation) => invocation.createdAt >= cutoff).map((invocation) => invocation.id));
+  const flights = Object.values(snapshot.flights).filter((flight) => ACTIVE_FLIGHT_STATES.has(flight.state) || recordTimestamp(flight) >= cutoff || recentInvocationIds.has(flight.invocationId));
   const retainedInvocationIds = new Set([
     ...recentInvocationIds,
     ...flights.map((flight) => flight.invocationId)
   ]);
   const invocations = Object.values(snapshot.invocations).filter((invocation) => retainedInvocationIds.has(invocation.id));
-  const collaborationRecords = Object.values(snapshot.collaborationRecords).filter((record3) => activeCollaboration(record3) || record3.updatedAt >= since);
+  const collaborationRecords = Object.values(snapshot.collaborationRecords).filter((record3) => activeCollaboration(record3) || record3.updatedAt >= cutoff);
   const conversationIds = new Set;
   for (const message of messages)
     conversationIds.add(message.conversationId);
@@ -53661,7 +53857,7 @@ function queryRuntimeRegistrySnapshot(snapshot, query = {}) {
   }
   for (const conversation of Object.values(snapshot.conversations)) {
     const timestamp = recordTimestamp(conversation);
-    if (timestamp === 0 || timestamp >= since)
+    if (timestamp === 0 || timestamp >= cutoff)
       conversationIds.add(conversation.id);
   }
   const conversations = [];
@@ -53677,22 +53873,52 @@ function queryRuntimeRegistrySnapshot(snapshot, query = {}) {
       pendingConversationIds.push(conversation.parentConversationId);
     }
   }
+  let scopedInvocations = invocations;
+  let scopedFlights = flights;
+  if (conversationScoped) {
+    const activeFlightInvocationIds = new Set(flights.filter((flight) => ACTIVE_FLIGHT_STATES.has(flight.state)).map((flight) => flight.invocationId));
+    const newestByConversation = new Map;
+    for (const invocation of invocations) {
+      const conversationId = invocation.conversationId;
+      if (!conversationId || !conversationIds.has(conversationId))
+        continue;
+      const bucket = newestByConversation.get(conversationId) ?? [];
+      bucket.push(invocation);
+      newestByConversation.set(conversationId, bucket);
+    }
+    scopedInvocations = [...newestByConversation.values()].flatMap((bucket) => {
+      const sorted = bucket.sort((left, right) => right.createdAt - left.createdAt);
+      const selected = sorted.slice(0, 12);
+      const selectedIds = new Set(selected.map((invocation) => invocation.id));
+      for (const invocation of sorted) {
+        if (activeFlightInvocationIds.has(invocation.id) && !selectedIds.has(invocation.id)) {
+          selected.push(invocation);
+          selectedIds.add(invocation.id);
+        }
+      }
+      return selected;
+    });
+    const scopedInvocationIds = new Set(scopedInvocations.map((invocation) => invocation.id));
+    scopedFlights = flights.filter((flight) => scopedInvocationIds.has(flight.invocationId));
+  }
   const actorIds = new Set;
   const agentIds = new Set;
-  for (const agent of Object.values(snapshot.agents)) {
-    if (currentAgent(agent))
-      agentIds.add(agent.id);
+  const currentEndpointAgentIds = new Set(Object.values(snapshot.endpoints).filter((endpoint) => currentOrRecentEndpoint(endpoint, cutoff)).map((endpoint) => endpoint.agentId));
+  for (const conversation of conversations) {
+    const keepWholeRoster = !conversationScoped || conversation.kind === "direct" || conversation.kind === "group_direct";
+    for (const [index, participantId] of conversation.participantIds.entries()) {
+      if (keepWholeRoster || index < 32 || snapshot.actors[participantId]?.kind === "person" || currentEndpointAgentIds.has(participantId)) {
+        actorIds.add(participantId);
+      }
+    }
   }
-  const endpoints = Object.values(snapshot.endpoints).filter((endpoint) => currentOrRecentEndpoint(endpoint, since));
-  for (const endpoint of endpoints)
-    agentIds.add(endpoint.agentId);
   for (const message of messages)
     actorIds.add(message.actorId);
-  for (const invocation of invocations) {
+  for (const invocation of scopedInvocations) {
     actorIds.add(invocation.requesterId);
     agentIds.add(invocation.targetAgentId);
   }
-  for (const flight of flights) {
+  for (const flight of scopedFlights) {
     actorIds.add(flight.requesterId);
     agentIds.add(flight.targetAgentId);
   }
@@ -53703,10 +53929,19 @@ function queryRuntimeRegistrySnapshot(snapshot, query = {}) {
     if (record3.nextMoveOwnerId)
       actorIds.add(record3.nextMoveOwnerId);
   }
-  for (const conversation of conversations) {
-    for (const participantId of conversation.participantIds)
-      actorIds.add(participantId);
+  if (!conversationScoped) {
+    for (const agent of Object.values(snapshot.agents)) {
+      if (currentAgent(agent))
+        agentIds.add(agent.id);
+    }
   }
+  for (const actorId of actorIds) {
+    if (snapshot.agents[actorId])
+      agentIds.add(actorId);
+  }
+  const endpoints = Object.values(snapshot.endpoints).filter((endpoint) => currentOrRecentEndpoint(endpoint, cutoff) && (!conversationScoped || agentIds.has(endpoint.agentId) || actorIds.has(endpoint.agentId)));
+  for (const endpoint of endpoints)
+    agentIds.add(endpoint.agentId);
   for (const agentId of agentIds)
     actorIds.add(agentId);
   const agents = Object.values(snapshot.agents).filter((agent) => agentIds.has(agent.id) || actorIds.has(agent.id));
@@ -53725,8 +53960,8 @@ function queryRuntimeRegistrySnapshot(snapshot, query = {}) {
     bindings: recordById(Object.values(snapshot.bindings).filter((binding) => conversationIds.has(binding.conversationId))),
     messages: recordById(messages),
     readCursors: Object.fromEntries(Object.entries(snapshot.readCursors).filter(([, cursor]) => conversationIds.has(cursor.conversationId))),
-    invocations: recordById(invocations),
-    flights: recordById(flights),
+    invocations: recordById(scopedInvocations),
+    flights: recordById(scopedFlights),
     collaborationRecords: recordById(collaborationRecords)
   });
 }
@@ -54844,12 +55079,9 @@ function isTransportInferredStall(status) {
 class BrokerPresenceService {
   deps;
   presence;
-  lastPublished = new Map;
-  refreshIntervalMs;
   constructor(deps) {
     this.deps = deps;
     this.presence = new BrokerPresenceMap(deps.map);
-    this.refreshIntervalMs = Math.max(1, deps.refreshIntervalMs ?? PRESENCE_REFRESH_INTERVAL_MS);
   }
   snapshot(now = this.now()) {
     return this.presence.snapshot(now);
@@ -54873,23 +55105,16 @@ class BrokerPresenceService {
         needRef: needRefForStatus(status),
         boundConversationId: boundConversationIdForStatus(status, snapshot)
       }, now);
-      if (!result)
+      if (!result?.transitioned)
         continue;
-      const lastPublished = this.lastPublished.get(agentId);
-      const refreshDue = !result.transitioned && lastPublished !== undefined && result.beat.updatedAt > lastPublished.updatedAt && now - lastPublished.at >= this.refreshIntervalMs;
-      if (!result.transitioned && !refreshDue)
-        continue;
-      this.deps.publish(this.presenceEvent(result.beat, result.transitioned ? result.previousActivity : undefined, now));
-      this.lastPublished.set(agentId, { at: now, updatedAt: result.beat.updatedAt });
+      this.deps.publish(this.presenceEvent(result.beat, result.previousActivity, now));
       published += 1;
     }
-    this.forgetPublished(this.presence.prune(now));
+    this.presence.prune(now);
     return published;
   }
   sweep(now = this.now()) {
-    const dropped = this.presence.prune(now);
-    this.forgetPublished(dropped);
-    return dropped;
+    return this.presence.prune(now);
   }
   presenceEvent(beat, previousActivity, now) {
     return {
@@ -54904,10 +55129,6 @@ class BrokerPresenceService {
   now() {
     return this.deps.now?.() ?? Date.now();
   }
-  forgetPublished(agentIds) {
-    for (const agentId of agentIds)
-      this.lastPublished.delete(agentId);
-  }
 }
 function needRefForStatus(status) {
   if (status.subjectKind !== "question")
@@ -55058,7 +55279,7 @@ class BrokerDeliveryStore {
 // packages/runtime/src/broker-journal.ts
 import { once as once2 } from "events";
 import { createReadStream, createWriteStream } from "fs";
-import { appendFile, mkdir, rename, unlink } from "fs/promises";
+import { appendFile, mkdir, rename, stat as stat2, unlink } from "fs/promises";
 import { dirname as dirname6 } from "path";
 import { createInterface } from "readline";
 function cloneSnapshot(snapshot) {
@@ -55146,19 +55367,30 @@ class FileBackedBrokerJournal {
     scoutDispatches: []
   };
   loaded = false;
+  latestLoadReport = null;
   writeQueue = Promise.resolve();
   constructor(filePath) {
     this.filePath = filePath;
   }
   async load() {
     if (this.loaded) {
-      return;
+      return this.latestLoadReport;
     }
+    const startedAt = Date.now();
+    const sourceBytes = await stat2(this.filePath).then((value) => value.size).catch((error48) => {
+      const code = error48 && typeof error48 === "object" && "code" in error48 ? error48.code : undefined;
+      if (code === "ENOENT")
+        return 0;
+      throw error48;
+    });
     const latestIndexByKey = new Map;
     const lastFlightById = new Map;
+    const countsByKind = {};
     let compactionRequired = false;
-    await this.visitEntries((entry, index) => {
+    const scanStartedAt = Date.now();
+    const scan = await this.visitEntries((entry, index) => {
       this.apply(entry);
+      countsByKind[entry.kind] = (countsByKind[entry.kind] ?? 0) + 1;
       const key = dedupeKey(entry);
       if (key) {
         if (latestIndexByKey.has(key)) {
@@ -55174,10 +55406,37 @@ class FileBackedBrokerJournal {
         lastFlightById.set(entry.flight.id, entry.flight);
       }
     });
+    const scanMs = Date.now() - scanStartedAt;
+    let compactionMs = 0;
     if (compactionRequired) {
+      const compactionStartedAt = Date.now();
       await this.rewriteCompactedEntries(latestIndexByKey);
+      compactionMs = Date.now() - compactionStartedAt;
     }
     this.loaded = true;
+    const completedAt = Date.now();
+    const compactedBytes = await stat2(this.filePath).then((value) => value.size).catch(() => 0);
+    this.latestLoadReport = {
+      startedAt,
+      completedAt,
+      totalMs: completedAt - startedAt,
+      scanMs,
+      compactionMs,
+      sourceBytes,
+      compactedBytes,
+      validEntries: scan.validEntries,
+      invalidLines: scan.invalidLines,
+      blankLines: scan.blankLines,
+      compactionRequired,
+      countsByKind
+    };
+    return this.latestLoadReport;
+  }
+  loadReport() {
+    return this.latestLoadReport ? {
+      ...this.latestLoadReport,
+      countsByKind: { ...this.latestLoadReport.countsByKind }
+    } : null;
   }
   async readEntries() {
     const entries = [];
@@ -55186,8 +55445,27 @@ class FileBackedBrokerJournal {
     });
     return entries;
   }
-  async replay(visitor) {
-    await this.visitEntries((entry) => visitor(entry));
+  captureReplayBoundary() {
+    let boundary = { endByteExclusive: 0 };
+    const capture = this.writeQueue.then(async () => {
+      boundary = {
+        endByteExclusive: await stat2(this.filePath).then((value) => value.size).catch((error48) => {
+          const code = error48 && typeof error48 === "object" && "code" in error48 ? error48.code : undefined;
+          if (code === "ENOENT")
+            return 0;
+          throw error48;
+        })
+      };
+    });
+    this.writeQueue = capture.then(() => {
+      return;
+    }, () => {
+      return;
+    });
+    return capture.then(() => boundary);
+  }
+  async replay(visitor, boundary) {
+    await this.visitEntries((entry) => visitor(entry), boundary ? { endByteExclusive: boundary.endByteExclusive } : {});
   }
   snapshot() {
     return cloneSnapshot(this.state.snapshot);
@@ -55255,17 +55533,43 @@ class FileBackedBrokerJournal {
     const limit = options.limit ?? 1000;
     return [...this.state.invocationDispatchJobs.values()].filter((job) => !options.state || job.state === options.state).sort((left, right) => left.createdAt - right.createdAt).slice(0, limit);
   }
-  async visitEntries(visitor) {
-    const input = createReadStream(this.filePath, { encoding: "utf8" });
+  async visitEntries(visitor, options = {}) {
+    const endByteExclusive = options.endByteExclusive;
+    if (endByteExclusive !== undefined && endByteExclusive <= 0) {
+      return {
+        rawLines: 0,
+        validEntries: 0,
+        invalidLines: 0,
+        blankLines: 0
+      };
+    }
+    const input = createReadStream(this.filePath, {
+      encoding: "utf8",
+      ...endByteExclusive === undefined ? {} : { end: endByteExclusive - 1 }
+    });
     const lines = createInterface({ input, crlfDelay: Infinity });
     let index = 0;
+    const report = {
+      rawLines: 0,
+      validEntries: 0,
+      invalidLines: 0,
+      blankLines: 0
+    };
     try {
       for await (const rawLine of lines) {
+        report.rawLines += 1;
+        if (!rawLine.trim()) {
+          report.blankLines += 1;
+          continue;
+        }
         const entry = parseEntry(rawLine);
-        if (!entry)
+        if (!entry) {
+          report.invalidLines += 1;
           continue;
+        }
         await visitor(entry, index);
         index += 1;
+        report.validEntries += 1;
       }
     } catch (error48) {
       const code = error48 && typeof error48 === "object" && "code" in error48 ? error48.code : undefined;
@@ -55276,6 +55580,7 @@ class FileBackedBrokerJournal {
       lines.close();
       input.destroy();
     }
+    return report;
   }
   async rewriteCompactedEntries(latestIndexByKey) {
     await mkdir(dirname6(this.filePath), { recursive: true });
@@ -55538,18 +55843,18 @@ class BrokerDurableRecordStore {
   constructor(options) {
     this.options = options;
   }
-  upsertNode = async (node) => {
+  upsertNode = async (node, options = {}) => {
     await this.options.durableStore.runWrite(async () => {
       await this.options.durableStore.commitEntries({ kind: "node.upsert", node }, async () => {
         await this.options.runtime.upsertNode(node);
-      });
+      }, options);
     });
   };
-  upsertActor = async (actor) => {
+  upsertActor = async (actor, options = {}) => {
     await this.options.durableStore.runWrite(async () => {
       await this.options.durableStore.commitEntries({ kind: "actor.upsert", actor }, async () => {
         await this.options.runtime.upsertActor(actor);
-      });
+      }, options);
     });
   };
   upsertAgent = async (agent) => {
@@ -55700,6 +56005,41 @@ class BrokerDurableStore {
   };
 }
 
+// packages/runtime/src/broker-startup-traffic-gate.ts
+var RESTORING_READ_PATHS = new Set([
+  "/health",
+  "/v1/home",
+  "/v1/node",
+  "/v1/snapshot"
+]);
+
+class BrokerStartupTrafficGate {
+  mutationsAdmitted = false;
+  admits(method, requestTarget = "/") {
+    if (this.mutationsAdmitted) {
+      return true;
+    }
+    const normalizedMethod = (method ?? "GET").toUpperCase();
+    if (normalizedMethod === "OPTIONS") {
+      return true;
+    }
+    if (normalizedMethod !== "GET" && normalizedMethod !== "HEAD") {
+      return false;
+    }
+    const path = requestTarget.split("?", 1)[0] || "/";
+    return RESTORING_READ_PATHS.has(path);
+  }
+  admitMutations() {
+    this.mutationsAdmitted = true;
+  }
+  snapshot() {
+    return {
+      state: this.mutationsAdmitted ? "ready" : "restoring",
+      mutationsAdmitted: this.mutationsAdmitted
+    };
+  }
+}
+
 // packages/runtime/src/broker-read-cursor-store.ts
 function finitePositiveNumber(value) {
   if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
@@ -56125,7 +56465,7 @@ class BrokerWorkItemStore {
 // packages/runtime/src/local-agents.ts
 import { randomUUID as randomUUID3 } from "crypto";
 import { existsSync as existsSync34, readFileSync as readFileSync18 } from "fs";
-import { mkdir as mkdir9, readFile as readFile9, rm as rm4, stat as stat6, writeFile as writeFile7 } from "fs/promises";
+import { mkdir as mkdir9, readFile as readFile9, rm as rm4, stat as stat7, writeFile as writeFile7 } from "fs/promises";
 import { basename as basename16, dirname as dirname20, join as join37, resolve as resolve11 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 
@@ -56766,7 +57106,7 @@ async function requestJsonWithBun2(connect, socketPath, payload, timeoutMs) {
 }
 
 // packages/runtime/src/system-probes/git-build-info.ts
-import { existsSync as existsSync16, realpathSync, statSync as statSync12 } from "fs";
+import { existsSync as existsSync16, realpathSync, statSync as statSync13 } from "fs";
 import { dirname as dirname8, resolve as resolve2 } from "path";
 var staticMetadataByRepo = new Map;
 function realpathOrResolved(path) {
@@ -56779,8 +57119,8 @@ function realpathOrResolved(path) {
 function directoryOrParent(path) {
   const resolved = resolve2(path);
   try {
-    const stat2 = statSync12(resolved);
-    return stat2.isDirectory() ? resolved : dirname8(resolved);
+    const stat3 = statSync13(resolved);
+    return stat3.isDirectory() ? resolved : dirname8(resolved);
   } catch {
     return resolved;
   }
@@ -57776,7 +58116,7 @@ var herdrSessionsProbe = defineProbeFamily({
 var herdrTopologyCache = new Map;
 // packages/runtime/src/system-probes/sessions.ts
 import { createReadStream as createReadStream2 } from "fs";
-import { readdir, stat as stat2 } from "fs/promises";
+import { readdir, stat as stat3 } from "fs/promises";
 import { homedir as homedir18 } from "os";
 import { basename as basename12, dirname as dirname9, join as join17, resolve as resolve3 } from "path";
 import { createInterface as createInterface2 } from "readline";
@@ -57822,7 +58162,7 @@ function detectAgent(filePath, fallback = "unknown") {
 }
 async function directoryExists(path) {
   try {
-    return (await stat2(path)).isDirectory();
+    return (await stat3(path)).isDirectory();
   } catch {
     return false;
   }
@@ -57851,7 +58191,7 @@ async function scanJsonlFiles(input) {
       if (!entry.isFile() || !entry.name.endsWith(".jsonl"))
         continue;
       try {
-        const info = await stat2(filePath);
+        const info = await stat3(filePath);
         if (!info.isFile() || info.mtimeMs < input.cutoffMs)
           continue;
         out.push({
@@ -61346,7 +61686,7 @@ class SessionRegistry {
 
 // packages/agent-sessions/src/local/transports/codex-app-server.ts
 import { spawn as spawn4 } from "child_process";
-import { appendFile as appendFile2, mkdir as mkdir3, readFile as readFile3, rm, stat as stat3, writeFile as writeFile2 } from "fs/promises";
+import { appendFile as appendFile2, mkdir as mkdir3, readFile as readFile3, rm, stat as stat4, writeFile as writeFile2 } from "fs/promises";
 import { join as join23 } from "path";
 
 // packages/agent-sessions/src/codex-launch-config.ts
@@ -61521,6 +61861,21 @@ class CodexAppServerRequesterTimeoutError extends Error {
     this.timeoutMs = input.timeoutMs;
   }
 }
+
+class CodexThreadHeldExternallyError extends Error {
+  code = "CODEX_THREAD_HELD_EXTERNALLY";
+  threadId;
+  agentName;
+  constructor(input) {
+    super(`Codex thread ${input.threadId} is open in another application` + (input.detail ? ` (${input.detail})` : "") + "; it will accept turns once that application releases it.");
+    this.name = "CodexThreadHeldExternallyError";
+    this.threadId = input.threadId;
+    this.agentName = input.agentName;
+  }
+}
+function isCodexThreadHeldExternallyError(error48) {
+  return error48 instanceof CodexThreadHeldExternallyError || Boolean(error48 && typeof error48 === "object" && error48.code === "CODEX_THREAD_HELD_EXTERNALLY");
+}
 function codexAppServerExitMessage(input) {
   if (input.exitKind === "proactive_shutdown") {
     return `Codex app-server session for ${input.agentName} was stopped by OpenScout` + (input.reason ? `: ${input.reason}` : "") + ".";
@@ -61786,7 +62141,7 @@ async function readOptionalFile(filePath) {
 }
 async function assertCodexWorkingDirectory(cwd, agentName) {
   try {
-    const stats = await stat3(cwd);
+    const stats = await stat4(cwd);
     if (!stats.isDirectory()) {
       throw new Error(`Codex app-server cwd is not a directory for ${agentName}: ${cwd}`);
     }
@@ -61899,6 +62254,10 @@ function isMissingCodexRolloutError(error48) {
   const message = errorMessage2(error48).toLowerCase();
   return message.includes("no rollout found for thread id");
 }
+function isCodexThreadWriterConflictError(error48) {
+  const message = errorMessage2(error48).toLowerCase();
+  return message.includes("already has an active writer") || message.includes("thread-store conflict");
+}
 
 class CodexAppServerTransport {
   options;
@@ -61933,6 +62292,9 @@ class CodexAppServerTransport {
   get currentThreadPath() {
     return this.threadPath;
   }
+  get currentDurableThreadId() {
+    return this.durableThreadId;
+  }
   get stdoutLogFile() {
     return this.stdoutLogPath;
   }
@@ -61969,7 +62331,8 @@ class CodexAppServerTransport {
       throw new Error(`Codex app-server session for ${this.options.agentName} has no active thread.`);
     }
     return {
-      threadId: this.threadId
+      threadId: this.threadId,
+      durableThreadId: this.durableThreadId
     };
   }
   async startTurn(prompt) {
@@ -62187,6 +62550,13 @@ class CodexAppServerTransport {
           await this.persistState();
         }
         if (requestedThreadId || this.options.requireExistingThread) {
+          if (isCodexThreadWriterConflictError(error48)) {
+            throw new CodexThreadHeldExternallyError({
+              agentName: this.options.agentName,
+              threadId: storedThreadId,
+              detail: errorMessage2(error48)
+            });
+          }
           throw new Error(`Failed to resume ${threadOrigin} Codex thread ${storedThreadId}: ${errorMessage2(error48)}`);
         }
       }
@@ -62359,7 +62729,7 @@ class CodexAppServerTransport {
     let rolloutExists = false;
     if (this.threadPath) {
       try {
-        rolloutExists = (await stat3(this.threadPath)).isFile();
+        rolloutExists = (await stat4(this.threadPath)).isFile();
       } catch {
         rolloutExists = false;
       }
@@ -66449,7 +66819,7 @@ function buildInvocationCollaborationContextPrompt(invocation) {
 }
 
 // packages/runtime/src/pi-rpc.ts
-import { existsSync as existsSync26, readFileSync as readFileSync10, statSync as statSync13 } from "fs";
+import { existsSync as existsSync26, readFileSync as readFileSync10, statSync as statSync14 } from "fs";
 import { mkdir as mkdir6, writeFile as writeFile4 } from "fs/promises";
 import { execFileSync as execFileSync2 } from "child_process";
 import { homedir as homedir26 } from "os";
@@ -66556,13 +66926,13 @@ function readPiRpcCredentialFile(name, options = {}) {
     return;
   }
   try {
-    const directoryStat = statSync13(directory);
+    const directoryStat = statSync14(directory);
     if (!directoryStat.isDirectory() || (directoryStat.mode & 63) !== 0) {
       return;
     }
     const path = join28(directory, name);
-    const stat4 = statSync13(path);
-    if (!stat4.isFile() || (stat4.mode & 63) !== 0 || stat4.size > 16 * 1024) {
+    const stat5 = statSync14(path);
+    if (!stat5.isFile() || (stat5.mode & 63) !== 0 || stat5.size > 16 * 1024) {
       return;
     }
     const value = readFileSync10(path, "utf8").trim();
@@ -66913,7 +67283,7 @@ async function shutdownPiRpcAgent(options) {
 // packages/runtime/src/setup.ts
 import { execFileSync as execFileSync4 } from "child_process";
 import { existsSync as existsSync29, readFileSync as readFileSync13 } from "fs";
-import { access, chmod, mkdir as mkdir8, readdir as readdir3, readFile as readFile8, realpath, rm as rm3, stat as stat5, writeFile as writeFile6 } from "fs/promises";
+import { access, chmod, mkdir as mkdir8, readdir as readdir3, readFile as readFile8, realpath, rm as rm3, stat as stat6, writeFile as writeFile6 } from "fs/promises";
 import { homedir as homedir29, hostname as hostname3, userInfo } from "os";
 import { basename as basename15, dirname as dirname16, isAbsolute as isAbsolute2, join as join32, relative as relative6, resolve as resolve9 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
@@ -67866,7 +68236,7 @@ function parse5(toml, { maxDepth = 1000, integersAsBigInt } = {}) {
 
 // packages/runtime/src/harness-catalog.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import { existsSync as existsSync27, statSync as statSync14 } from "fs";
+import { existsSync as existsSync27, statSync as statSync15 } from "fs";
 import { mkdir as mkdir7, readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
 import { homedir as homedir27 } from "os";
 import { dirname as dirname13, join as join29 } from "path";
@@ -68452,7 +68822,7 @@ function defaultRequirementExists(requirement) {
   if (requirement.fileType === "any" || !requirement.fileType)
     return true;
   try {
-    const fileStat = statSync14(expanded);
+    const fileStat = statSync15(expanded);
     return requirement.fileType === "directory" ? fileStat.isDirectory() : fileStat.isFile();
   } catch {
     return false;
@@ -68754,6 +69124,38 @@ var NODE_IDENTITY_FILE = "node-identity.json";
 var NODE_FINGERPRINT_PREFIX = "osc1";
 var NODE_CARD_TTL_MS = 24 * 60 * 60 * 1000;
 var stableNodeQualifierCache = new Map;
+function stripBonjourCollisionSuffix(value) {
+  if (!value || typeof value !== "string")
+    return "";
+  let trimmed = value.trim();
+  const isDotLocal = /\.local\.?$/i.test(trimmed);
+  if (isDotLocal) {
+    trimmed = trimmed.replace(/\.local\.?$/i, "");
+  }
+  const isHyphenLocalOpenscout = /-local-openscout$/i.test(trimmed);
+  const isHyphenLocal = !isHyphenLocalOpenscout && /-local$/i.test(trimmed);
+  if (isHyphenLocalOpenscout) {
+    trimmed = trimmed.replace(/-local-openscout$/i, "");
+  } else if (isHyphenLocal) {
+    trimmed = trimmed.replace(/-local$/i, "");
+  }
+  if (!isDotLocal && !isHyphenLocalOpenscout && !isHyphenLocal) {
+    return trimmed;
+  }
+  trimmed = trimmed.replace(/(?<=[a-zA-Z].*?)(?:-\d+)+$/, "");
+  if (isDotLocal)
+    return `${trimmed}.local`;
+  if (isHyphenLocalOpenscout)
+    return `${trimmed}-local-openscout`;
+  if (isHyphenLocal)
+    return `${trimmed}-local`;
+  return trimmed;
+}
+function canonicalMeshNodeId(nodeId) {
+  if (!nodeId || typeof nodeId !== "string")
+    return "";
+  return stripBonjourCollisionSuffix(nodeId);
+}
 function nodeIdentityPath(supportDirectory) {
   const dir = supportDirectory ?? resolveOpenScoutSupportPaths().supportDirectory;
   return join30(dir, NODE_IDENTITY_FILE);
@@ -68774,6 +69176,12 @@ function loadOrCreateStableNodeQualifier(fallbackName, supportDirectory) {
   const identity2 = loadOrCreateNodeIdentity(supportDirectory);
   const existing = normalizeNodeQualifier(identity2.nodeQualifier);
   if (existing) {
+    if (identity2.nodeQualifier !== existing) {
+      persistNodeIdentity(path, {
+        ...identity2,
+        nodeQualifier: existing
+      });
+    }
     stableNodeQualifierCache.set(path, existing);
     return existing;
   }
@@ -68819,7 +69227,7 @@ function readAndValidateNodeIdentity(path) {
   if (parsed.version !== 1 || !parsed.publicKey || !parsed.privateKey) {
     throw new Error(`Corrupt node identity at ${path}; remove it to generate a fresh one.`);
   }
-  if (parsed.nodeQualifier !== undefined && normalizeNodeQualifier(parsed.nodeQualifier) !== parsed.nodeQualifier) {
+  if (parsed.nodeQualifier !== undefined && normalizePersistedNodeQualifier(parsed.nodeQualifier) !== parsed.nodeQualifier) {
     throw new Error(`Corrupt node identity at ${path}; remove it to generate a fresh one.`);
   }
   try {
@@ -68832,9 +69240,12 @@ function readAndValidateNodeIdentity(path) {
   }
   return parsed;
 }
-function normalizeNodeQualifier(value) {
+function normalizePersistedNodeQualifier(value) {
   return typeof value === "string" ? value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "") : "";
 }
+function normalizeNodeQualifier(value) {
+  return stripBonjourCollisionSuffix(normalizePersistedNodeQualifier(value));
+}
 function persistNodeIdentity(path, identity2) {
   const tempPath = `${path}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
   mkdirSync3(dirname14(path), { recursive: true });
@@ -69033,7 +69444,7 @@ function isRecord9(value) {
 }
 
 // packages/runtime/src/user-project-hints.ts
-import { readdir as readdir2, readFile as readFile7, stat as stat4 } from "fs/promises";
+import { readdir as readdir2, readFile as readFile7, stat as stat5 } from "fs/promises";
 import { homedir as homedir28 } from "os";
 import { dirname as dirname15, join as join31, resolve as resolve8 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
@@ -69067,7 +69478,7 @@ function encodeClaudeProjectsSlug(absolutePath) {
 async function resolveExistingDirectoryHint(pathLike) {
   const absolutePath = resolve8(pathLike);
   try {
-    const info = await stat4(absolutePath);
+    const info = await stat5(absolutePath);
     if (info.isDirectory()) {
       return absolutePath;
     }
@@ -69081,7 +69492,7 @@ async function resolveExistingDirectoryHint(pathLike) {
 }
 async function pathExists(pathLike) {
   try {
-    await stat4(pathLike);
+    await stat5(pathLike);
     return true;
   } catch {
     return false;
@@ -69159,7 +69570,7 @@ async function appendCodexHistoryPaths(home, roots) {
   for (const filePath of candidates) {
     let st;
     try {
-      st = await stat4(filePath);
+      st = await stat5(filePath);
     } catch {
       continue;
     }
@@ -69231,7 +69642,7 @@ async function appendCursorWorkspacePaths(home, roots) {
         }
         let wsStat;
         try {
-          wsStat = await stat4(wsFile);
+          wsStat = await stat5(wsFile);
         } catch {
           continue;
         }
@@ -69298,7 +69709,7 @@ async function appendClaudeSessionPaths(home, roots) {
       const sessionPath = join31(projectsDir, projectName, entry);
       let info;
       try {
-        info = await stat4(sessionPath);
+        info = await stat5(sessionPath);
       } catch {
         continue;
       }
@@ -69986,6 +70397,9 @@ function defaultSettings() {
       quickHits: [],
       preparedAt: null
     },
+    voice: {
+      realtimeEnabled: false
+    },
     ui: {
       scenes: [],
       activeSceneIdBySurface: {}
@@ -70011,7 +70425,7 @@ async function pathExists2(filePath) {
 }
 async function isDirectory(filePath) {
   try {
-    const fileStat = await stat5(filePath);
+    const fileStat = await stat6(filePath);
     return fileStat.isDirectory();
   } catch {
     return false;
@@ -70373,6 +70787,7 @@ async function normalizeSettingsRecord(value, options = {}) {
   const telegram = typeof bridges.telegram === "object" && bridges.telegram ? bridges.telegram : {};
   const network = typeof candidate.network === "object" && candidate.network ? candidate.network : {};
   const phone = typeof candidate.phone === "object" && candidate.phone ? candidate.phone : {};
+  const voice = typeof candidate.voice === "object" && candidate.voice ? candidate.voice : {};
   const ui = typeof candidate.ui === "object" && candidate.ui ? candidate.ui : {};
   const oldOperatorName = typeof candidate.operatorName === "string" ? candidate.operatorName : undefined;
   const seededWorkspaceRoots = await seedWorkspaceRoots({
@@ -70445,6 +70860,9 @@ async function normalizeSettingsRecord(value, options = {}) {
       quickHits: normalizeStringList(phone.quickHits),
       preparedAt: normalizeOptionalTimestamp(phone.preparedAt)
     },
+    voice: {
+      realtimeEnabled: typeof voice.realtimeEnabled === "boolean" ? voice.realtimeEnabled : base.voice.realtimeEnabled
+    },
     ui: normalizeUi(ui)
   };
 }
@@ -73416,6 +73834,14 @@ async function readLocalAgentRegistry() {
     localAgentRecordFromRelayAgentOverride(agentId, override)
   ]));
 }
+var archivedLocalAgentIdsCache = null;
+function invalidateArchivedLocalAgentIdsCache() {
+  archivedLocalAgentIdsCache = null;
+}
+async function writeRelayAgentOverrides2(overrides) {
+  await writeRelayAgentOverrides(overrides);
+  invalidateArchivedLocalAgentIdsCache();
+}
 async function writeLocalAgentRegistry(registry3) {
   const overrides = await readRelayAgentOverrides();
   const nextOverrides = {
@@ -73424,7 +73850,7 @@ async function writeLocalAgentRegistry(registry3) {
   for (const [agentId, record3] of Object.entries(registry3)) {
     nextOverrides[agentId] = relayAgentOverrideFromLocalAgentRecord(agentId, record3, overrides[agentId]);
   }
-  await writeRelayAgentOverrides(nextOverrides);
+  await writeRelayAgentOverrides2(nextOverrides);
 }
 function expandHomePath4(value) {
   if (value === "~") {
@@ -74063,7 +74489,7 @@ function providerSessionIdFromMetadata(metadata) {
 async function ensureLocalSessionEndpointOnline(endpoint) {
   if (endpoint.transport === "codex_app_server") {
     const result = await ensureCodexAppServerAgentOnline(buildCodexEndpointSessionOptions(endpoint));
-    return { externalSessionId: result.threadId };
+    return { externalSessionId: result.durableThreadId };
   }
   if (endpoint.transport === "claude_stream_json") {
     const result = await ensureClaudeStreamJsonAgentOnline(buildClaudeEndpointSessionOptions(endpoint));
@@ -74240,7 +74666,7 @@ function buildCodexEndpointSessionOptions(endpoint) {
     logsDirectory: relayAgentLogsDirectory(agentName),
     env: {
       CODEX_HOME: codexHomeForEndpoint(endpoint),
-      ...endpoint.metadata?.placement === "background" ? {
+      ...endpoint.metadata?.placement === "background" && codexHomeForEndpoint(endpoint) !== operatorCodexHome() ? {
         OPENSCOUT_CODEX_AUTH_SOURCE: join37(operatorCodexHome(), "auth.json")
       } : {}
     },
@@ -74252,6 +74678,12 @@ function buildCodexEndpointSessionOptions(endpoint) {
   });
 }
 function codexHomeForEndpoint(endpoint) {
+  const source = endpointMetadataString(endpoint, "source");
+  const scoutOwnsThread = source === "scoutbot" || source?.startsWith("scout-") === true;
+  const externalThreadId = scoutOwnsThread ? undefined : endpointMetadataString(endpoint, "threadId") ?? endpointMetadataString(endpoint, "externalSessionId");
+  if (externalThreadId) {
+    return operatorCodexHome();
+  }
   const placement = endpoint.metadata?.placement === "background" ? "background" : "foreground";
   if (placement === "background") {
     return join37(resolveOpenScoutSupportPaths().runtimeDirectory, "codex-background-home");
@@ -78683,7 +79115,7 @@ class BrokerDeliveryAcceptanceService {
     };
     const aliasResolution = resolved.aliasResolution;
     const receiptSessionId = requestedTargetSessionId ?? (aliasResolution?.target.kind === "session" ? aliasResolution.target.sessionId : undefined) ?? (resolved.kind === "resolved_session" ? resolved.session.sessionId : undefined);
-    const unavailable = resolved.kind === "resolved" ? this.options.describeUnavailableDeliveryTarget(this.options.runtimeSnapshot(), resolved.agent, requestedTargetSessionId) : describeUnavailableSessionEndpoint(resolved.session.endpoint);
+    const unavailable = resolved.kind === "resolved" ? this.options.describeUnavailableDeliveryTarget(this.options.runtimeSnapshot(), resolved.agent, requestedTargetSessionId) : null;
     if (unavailable) {
       const targetLabel2 = askedLabel || target.label;
       const { record: record3 } = await this.options.recordScoutDispatch(this.options.buildUnavailableDispatchEnvelope(targetLabel2, unavailable), {
@@ -80131,6 +80563,62 @@ function parsePositiveIntParam(url2, key, cap) {
     return;
   return Math.min(value, cap);
 }
+var TAIL_RECENT_ASSISTANT_REPLIES_MODE = "assistant-replies";
+function isAssistantRepliesMode(url2) {
+  return url2.searchParams.get("mode") === TAIL_RECENT_ASSISTANT_REPLIES_MODE;
+}
+function tailEventMessageRole(event) {
+  if (!event.raw || typeof event.raw !== "object" || Array.isArray(event.raw))
+    return null;
+  const payload = event.raw.payload;
+  if (!payload || typeof payload !== "object" || Array.isArray(payload))
+    return null;
+  const role = payload.role;
+  return typeof role === "string" ? role.trim().toLowerCase() : null;
+}
+function isApprovalReviewerDecision(summary) {
+  const trimmed = summary.trim();
+  if (!trimmed.startsWith("{"))
+    return false;
+  if (trimmed.startsWith('{"risk_level":') && trimmed.includes('"user_authorization":') && trimmed.includes('"outcome":') && trimmed.includes('"rationale":')) {
+    return true;
+  }
+  try {
+    const parsed = JSON.parse(trimmed);
+    return typeof parsed.risk_level === "string" && typeof parsed.user_authorization === "string" && typeof parsed.outcome === "string" && typeof parsed.rationale === "string";
+  } catch {
+    return false;
+  }
+}
+function isAssistantReply(event) {
+  if (event.kind !== "assistant")
+    return false;
+  const summary = event.summary.trim();
+  if (!summary || /^\[(?:assistant|message)\]$/iu.test(summary))
+    return false;
+  const role = tailEventMessageRole(event);
+  if (role && role !== "assistant")
+    return false;
+  return !isApprovalReviewerDecision(summary);
+}
+function assistantReplySessionKey(event) {
+  const source = event.source.trim().toLowerCase();
+  const sessionId = event.sessionId.trim();
+  return source && sessionId ? `${source}\x00${sessionId}` : `event\x00${event.id}`;
+}
+function latestAssistantReplies(events) {
+  const latestBySession = new Map;
+  for (const event of events) {
+    if (!isAssistantReply(event))
+      continue;
+    const key = assistantReplySessionKey(event);
+    const current = latestBySession.get(key);
+    if (!current || event.ts > current.ts || event.ts === current.ts && event.id.localeCompare(current.id) > 0) {
+      latestBySession.set(key, event);
+    }
+  }
+  return [...latestBySession.values()];
+}
 function booleanQuery(url2, key) {
   return url2.searchParams.get(key) === "1" || url2.searchParams.get(key) === "true";
 }
@@ -80138,6 +80626,8 @@ function booleanQuery(url2, key) {
 class BrokerRepoTailService {
   options;
   repoWatchWarmInFlight = null;
+  tailRecentCache = null;
+  tailRecentInFlight = null;
   constructor(options) {
     this.options = options;
   }
@@ -80215,6 +80705,48 @@ class BrokerRepoTailService {
     return snapshot;
   }
   async readTailRecentPayloadWithTiming(url2) {
+    const cacheTtlMs = this.options.tailRecentServeCacheTtlMs ?? 0;
+    const cacheKey = `${parseTailLimit(url2)}:${url2.searchParams.get("transcripts") === "true" || url2.searchParams.get("transcripts") === "1"}:${isAssistantRepliesMode(url2) ? TAIL_RECENT_ASSISTANT_REPLIES_MODE : "all"}`;
+    const now = this.now();
+    if (cacheTtlMs > 0 && this.tailRecentCache?.key === cacheKey && this.tailRecentCache.expiresAtMs > now) {
+      const cached2 = this.tailRecentCache;
+      return {
+        payload: {
+          ...cached2.result.payload,
+          events: [...cached2.result.payload.events]
+        },
+        timings: [
+          ...cached2.result.timings,
+          { name: "tail-serve-cache", dur: Math.max(0, now - (cached2.expiresAtMs - cacheTtlMs)) }
+        ]
+      };
+    }
+    const inFlight = this.tailRecentInFlight;
+    if (cacheTtlMs > 0 && inFlight && inFlight.key === cacheKey)
+      return inFlight.promise;
+    const request = (async () => {
+      const result = await this.computeTailRecentPayloadWithTiming(url2);
+      if (cacheTtlMs > 0) {
+        this.tailRecentCache = {
+          key: cacheKey,
+          result,
+          expiresAtMs: this.now() + cacheTtlMs
+        };
+      }
+      return result;
+    })();
+    if (cacheTtlMs > 0) {
+      this.tailRecentInFlight = { key: cacheKey, promise: request };
+      try {
+        return await request;
+      } finally {
+        if (this.tailRecentInFlight?.promise === request)
+          this.tailRecentInFlight = null;
+      }
+    }
+    return request;
+  }
+  async computeTailRecentPayloadWithTiming(url2) {
     const timings = [];
     const measure = async (name, fn) => {
       const start = performance2.now();
@@ -80225,24 +80757,29 @@ class BrokerRepoTailService {
       }
     };
     const limit = parseTailLimit(url2);
+    const assistantRepliesOnly = isAssistantRepliesMode(url2);
+    const kinds = assistantRepliesOnly ? ["assistant"] : undefined;
     const includeTranscripts = url2.searchParams.get("transcripts") === "true" || url2.searchParams.get("transcripts") === "1";
     const eventsById = new Map;
     if (includeTranscripts) {
       const discovery = await measure("tail-discover", () => this.options.getTailDiscovery(false));
       const transcriptEvents = filterTailEventsForDisplay(await measure("tail-transcripts", () => this.options.readRecentTranscriptEvents(Math.max(limit, 800), {
         discovery,
-        perTranscriptLineLimit: Math.min(200, Math.max(50, limit))
+        perTranscriptLineLimit: Math.min(200, Math.max(50, limit)),
+        kinds,
+        ...assistantRepliesOnly ? { perTranscriptKindLimit: 1 } : {}
       })));
       for (const event of transcriptEvents) {
         eventsById.set(event.id, event);
       }
     }
     const mergeStart = performance2.now();
-    const bufferedEvents = filterTailEventsForDisplay(await measure("tail-live", () => this.options.readRecentLiveEvents(limit)));
+    const bufferedEvents = filterTailEventsForDisplay(await measure("tail-live", () => this.options.readRecentLiveEvents(limit, { kinds })));
     for (const event of bufferedEvents) {
       eventsById.set(event.id, event);
     }
-    const events = [...eventsById.values()].sort((left, right) => {
+    const candidates = assistantRepliesOnly ? latestAssistantReplies(eventsById.values()) : [...eventsById.values()];
+    const events = candidates.sort((left, right) => {
       if (left.ts === right.ts)
         return left.id.localeCompare(right.id);
       return left.ts - right.ts;
@@ -80258,12 +80795,12 @@ class BrokerRepoTailService {
       timings
     };
   }
-  async readTailRecentPayload(url2) {
-    return (await this.readTailRecentPayloadWithTiming(url2)).payload;
-  }
   now() {
     return (this.options.now ?? Date.now)();
   }
+  async readTailRecentPayload(url2) {
+    return (await this.readTailRecentPayloadWithTiming(url2)).payload;
+  }
 }
 
 // packages/runtime/src/broker-rendezvous-service.ts
@@ -101776,6 +102313,10 @@ function hasColumn(database, tableName, columnName) {
   const rows = database.query(`SELECT name FROM pragma_table_info('${escapedTableName}')`).all();
   return rows.some((row) => row.name === columnName);
 }
+function hasTable(database, tableName) {
+  const row = database.query("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?1").get(tableName);
+  return Boolean(row);
+}
 var CONTROL_PLANE_SCHEMA_MIGRATIONS = [
   {
     id: "runtime-session-mapping-read-model",
@@ -101954,6 +102495,46 @@ WHERE latest.invocation_id = inv.id
         database.exec("ALTER TABLE trusted_peers ADD COLUMN tls_spki_fingerprint TEXT");
       }
     }
+  },
+  {
+    id: "canonicalize-mesh-nodes-and-rehome",
+    description: "Re-homes foreign key references on Bonjour collision-suffixed ghost nodes to canonical stable node IDs and prunes ghost nodes.",
+    apply(database) {
+      if (!hasTable(database, "nodes"))
+        return;
+      const nodeRows = database.query("SELECT * FROM nodes").all();
+      for (const row of nodeRows) {
+        const canonicalId = canonicalMeshNodeId(row.id);
+        if (canonicalId && canonicalId !== row.id) {
+          const existing = nodeRows.find((r) => r.id === canonicalId);
+          if (!existing) {
+            database.query(`INSERT INTO nodes (
+                id, mesh_id, name, host_name, advertise_scope, broker_url, tailnet_name,
+                capabilities_json, labels_json, metadata_json, last_seen_at, registered_at
+              ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12)
+              ON CONFLICT(id) DO UPDATE SET
+                last_seen_at = MAX(COALESCE(nodes.last_seen_at, 0), COALESCE(excluded.last_seen_at, 0)),
+                broker_url = COALESCE(excluded.broker_url, nodes.broker_url),
+                tailnet_name = COALESCE(excluded.tailnet_name, nodes.tailnet_name)`).run(canonicalId, row.mesh_id, stripBonjourCollisionSuffix(row.name) || row.name, stripBonjourCollisionSuffix(row.host_name ?? "") || (row.host_name ?? null), row.advertise_scope, row.broker_url ?? null, row.tailnet_name ?? null, row.capabilities_json ?? null, row.labels_json ?? null, row.metadata_json ?? null, row.last_seen_at ?? null, row.registered_at);
+          }
+          database.query("UPDATE agents SET home_node_id = ?1 WHERE home_node_id = ?2").run(canonicalId, row.id);
+          database.query("UPDATE agents SET authority_node_id = ?1 WHERE authority_node_id = ?2").run(canonicalId, row.id);
+          database.query("UPDATE agent_endpoints SET node_id = ?1 WHERE node_id = ?2").run(canonicalId, row.id);
+          database.query("UPDATE runtime_sessions SET node_id = ?1 WHERE node_id = ?2").run(canonicalId, row.id);
+          database.query("UPDATE runtime_session_aliases SET node_id = ?1 WHERE node_id = ?2").run(canonicalId, row.id);
+          database.query("UPDATE conversations SET authority_node_id = ?1 WHERE authority_node_id = ?2").run(canonicalId, row.id);
+          database.query("UPDATE conversation_read_cursors SET reader_node_id = ?1 WHERE reader_node_id = ?2").run(canonicalId, row.id);
+          database.query("UPDATE messages SET origin_node_id = ?1 WHERE origin_node_id = ?2").run(canonicalId, row.id);
+          database.query("UPDATE deliveries SET target_node_id = ?1 WHERE target_node_id = ?2").run(canonicalId, row.id);
+          database.query("UPDATE invocations SET requester_node_id = ?1 WHERE requester_node_id = ?2").run(canonicalId, row.id);
+          database.query("UPDATE invocations SET target_node_id = ?1 WHERE target_node_id = ?2").run(canonicalId, row.id);
+          database.query("UPDATE thread_events SET authority_node_id = ?1 WHERE authority_node_id = ?2").run(canonicalId, row.id);
+          database.query("UPDATE thread_cursors SET authority_node_id = ?1 WHERE authority_node_id = ?2").run(canonicalId, row.id);
+          database.query("UPDATE trusted_peers SET node_id = ?1 WHERE node_id = ?2").run(canonicalId, row.id);
+          database.query("DELETE FROM nodes WHERE id = ?1").run(row.id);
+        }
+      }
+    }
   }
 ];
 function configureControlPlaneDatabase(database) {
@@ -102980,11 +103561,65 @@ class SQLiteControlPlaneStore {
     const now = options.now ?? currentTimestampMs();
     const maxStaleAgeMs = options.maxStaleAgeMs ?? 7 * 24 * 60 * 60 * 1000;
     const staleCutoff = now - maxStaleAgeMs;
+    const nodeRows = this.db.query("SELECT * FROM nodes").all();
     const peerRows = this.db.query("SELECT * FROM trusted_peers").all();
     const rehomedMappings = [];
-    const rehomedNodeCount = 0;
+    const rehomeMap = new Map;
+    for (const row of nodeRows) {
+      const canonicalId = canonicalMeshNodeId(row.id);
+      if (canonicalId && canonicalId !== row.id) {
+        rehomeMap.set(row.id, { to: canonicalId, candidateRow: row });
+      }
+    }
+    let rehomedNodeCount = 0;
     let prunedNodeCount = 0;
     this.db.transaction(() => {
+      for (const [staleId, { to: canonicalId, candidateRow }] of rehomeMap.entries()) {
+        const existingCanonical = nodeRows.find((r) => r.id === canonicalId);
+        if (!existingCanonical) {
+          this.db.query(`INSERT INTO nodes (
+              id, mesh_id, name, host_name, advertise_scope, broker_url, tailnet_name,
+              capabilities_json, labels_json, metadata_json, last_seen_at, registered_at
+            ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12)
+            ON CONFLICT(id) DO UPDATE SET
+              last_seen_at = MAX(COALESCE(nodes.last_seen_at, 0), COALESCE(excluded.last_seen_at, 0)),
+              broker_url = COALESCE(excluded.broker_url, nodes.broker_url),
+              tailnet_name = COALESCE(excluded.tailnet_name, nodes.tailnet_name)`).run(canonicalId, candidateRow.mesh_id, stripBonjourCollisionSuffix(candidateRow.name) || candidateRow.name, stripBonjourCollisionSuffix(candidateRow.host_name ?? "") || (candidateRow.host_name ?? null), candidateRow.advertise_scope, candidateRow.broker_url ?? null, candidateRow.tailnet_name ?? null, candidateRow.capabilities_json ?? null, candidateRow.labels_json ?? null, candidateRow.metadata_json ?? null, candidateRow.last_seen_at ?? null, candidateRow.registered_at);
+        } else {
+          this.db.query(`UPDATE nodes SET
+              last_seen_at = MAX(COALESCE(last_seen_at, 0), COALESCE(?1, 0)),
+              broker_url = COALESCE(?2, broker_url)
+             WHERE id = ?3`).run(candidateRow.last_seen_at ?? null, candidateRow.broker_url ?? null, canonicalId);
+        }
+        this.db.query("UPDATE agents SET home_node_id = ?1 WHERE home_node_id = ?2").run(canonicalId, staleId);
+        this.db.query("UPDATE agents SET authority_node_id = ?1 WHERE authority_node_id = ?2").run(canonicalId, staleId);
+        this.db.query("UPDATE agent_endpoints SET node_id = ?1 WHERE node_id = ?2").run(canonicalId, staleId);
+        this.db.query("UPDATE runtime_sessions SET node_id = ?1 WHERE node_id = ?2").run(canonicalId, staleId);
+        this.db.query("UPDATE runtime_session_aliases SET node_id = ?1 WHERE node_id = ?2").run(canonicalId, staleId);
+        this.db.query("UPDATE conversations SET authority_node_id = ?1 WHERE authority_node_id = ?2").run(canonicalId, staleId);
+        this.db.query("UPDATE conversation_read_cursors SET reader_node_id = ?1 WHERE reader_node_id = ?2").run(canonicalId, staleId);
+        this.db.query("UPDATE messages SET origin_node_id = ?1 WHERE origin_node_id = ?2").run(canonicalId, staleId);
+        this.db.query("UPDATE deliveries SET target_node_id = ?1 WHERE target_node_id = ?2").run(canonicalId, staleId);
+        this.db.query("UPDATE invocations SET requester_node_id = ?1 WHERE requester_node_id = ?2").run(canonicalId, staleId);
+        this.db.query("UPDATE invocations SET target_node_id = ?1 WHERE target_node_id = ?2").run(canonicalId, staleId);
+        this.db.query("UPDATE thread_events SET authority_node_id = ?1 WHERE authority_node_id = ?2").run(canonicalId, staleId);
+        this.db.query("UPDATE thread_cursors SET authority_node_id = ?1 WHERE authority_node_id = ?2").run(canonicalId, staleId);
+        this.db.query("UPDATE trusted_peers SET node_id = ?1 WHERE node_id = ?2").run(canonicalId, staleId);
+        const delRes = this.db.query("DELETE FROM nodes WHERE id = ?1").run(staleId);
+        if ((delRes.changes ?? 0) > 0) {
+          prunedNodeCount++;
+          rehomedNodeCount++;
+          rehomedMappings.push({ from: staleId, to: canonicalId });
+        }
+      }
+      for (const peer of peerRows) {
+        if (peer.node_id) {
+          const canonical2 = canonicalMeshNodeId(peer.node_id);
+          if (canonical2 && canonical2 !== peer.node_id) {
+            this.db.query("UPDATE trusted_peers SET node_id = ?1 WHERE key_id = ?2").run(canonical2, peer.key_id);
+          }
+        }
+      }
       const remainingNodes = this.db.query("SELECT * FROM nodes").all();
       for (const row of remainingNodes) {
         if (row.id === options.localNodeId)
@@ -105139,6 +105774,10 @@ class RecoverableSQLiteProjection {
   queue = Promise.resolve();
   closed = false;
   lastUnavailableReason = null;
+  warming = false;
+  warmBoundaryReady = null;
+  startupRecoveryInitiated = false;
+  deferredStartupEvents = [];
   constructor(dbPath, journal, options = {}) {
     this.dbPath = dbPath;
     this.journal = journal;
@@ -105154,21 +105793,57 @@ class RecoverableSQLiteProjection {
     if (this.store) {
       return { state: "ready", detail: null };
     }
+    if (this.warming) {
+      return {
+        state: "warming",
+        detail: "SQLite activity projection is rebuilding from the broker journal."
+      };
+    }
     return {
       state: "degraded",
       detail: this.lastUnavailableReason ?? (this.closed ? "SQLite projection is closed." : "SQLite projection is not ready.")
     };
   }
   warm() {
+    if (this.options.disabled || this.closed || this.store || this.warming) {
+      return this.warmBoundaryReady ?? Promise.resolve();
+    }
+    this.startupRecoveryInitiated = true;
+    const deferredStartupEvents = this.deferredStartupEvents.splice(0);
+    this.warming = true;
+    let resolveBoundary = () => {};
+    let rejectBoundary = () => {};
+    let boundaryCaptured = false;
+    this.warmBoundaryReady = new Promise((resolve16, reject) => {
+      resolveBoundary = resolve16;
+      rejectBoundary = reject;
+    });
     this.enqueue(async () => {
-      await this.ensureStore();
+      try {
+        await this.ensureStore(() => {
+          boundaryCaptured = true;
+          resolveBoundary();
+        });
+      } finally {
+        this.warming = false;
+        if (!boundaryCaptured) {
+          rejectBoundary(new Error(this.lastUnavailableReason ?? "SQLite projection replay boundary could not be established."));
+        }
+      }
     });
+    for (const event of deferredStartupEvents) {
+      this.enqueueEvent(event);
+    }
+    return this.warmBoundaryReady;
   }
   enqueueEntries(entriesInput) {
     const entries = normalizeEntries(entriesInput);
     if (entries.length === 0 || this.options.disabled || this.closed) {
       return;
     }
+    if (!this.startupRecoveryInitiated) {
+      return;
+    }
     this.enqueue(async () => {
       const store = await this.ensureStore();
       if (!store) {
@@ -105192,6 +105867,10 @@ class RecoverableSQLiteProjection {
     if (this.options.disabled || this.closed) {
       return;
     }
+    if (!this.startupRecoveryInitiated) {
+      this.deferredStartupEvents.push(event);
+      return;
+    }
     this.enqueue(async () => {
       const store = await this.ensureStore();
       if (!store) {
@@ -105369,7 +106048,7 @@ class RecoverableSQLiteProjection {
     this.queue = next.then(() => {}, () => {});
     return next;
   }
-  async replayJournal(visitor) {
+  async replayJournal(visitor, boundary) {
     const configuredBatchSize = this.options.replayYieldEvery ?? DEFAULT_REPLAY_YIELD_EVERY;
     const batchSize = Math.max(1, Math.floor(configuredBatchSize));
     let visited = 0;
@@ -105379,22 +106058,27 @@ class RecoverableSQLiteProjection {
       if (visited % batchSize === 0) {
         await new Promise((resolve16) => setImmediate(resolve16));
       }
-    });
+    }, boundary);
   }
-  async ensureStore() {
+  async ensureStore(onReplayBoundaryCaptured) {
     if (this.options.disabled || this.closed) {
       return null;
     }
+    if (!this.startupRecoveryInitiated) {
+      return null;
+    }
     if (this.store) {
       return this.store;
     }
     try {
+      const replayBoundary = await this.journal.captureReplayBoundary();
+      onReplayBoundaryCaptured?.();
       const createStore = this.options.createStore ?? ((dbPath) => new SQLiteControlPlaneStore(dbPath));
       const store = createStore(this.dbPath);
       const parents = createReplayParentScan();
       await this.replayJournal((entry) => {
         collectReplayParents(parents, entry);
-      });
+      }, replayBoundary);
       prepareReplayParents(store, parents);
       await this.replayJournal((entry) => {
         try {
@@ -105408,7 +106092,7 @@ class RecoverableSQLiteProjection {
           }
           reportSkippedEntry(entry, error48);
         }
-      });
+      }, replayBoundary);
       this.store = store;
       this.lastUnavailableReason = null;
       return store;
@@ -106300,6 +106984,7 @@ function createBrokerCoreService(deps) {
         build: deps.build ?? loadOpenScoutRuntimeBuildIdentity(),
         services: deps.readChildServices?.(),
         ...deps.readProjectionStatus ? { projection: deps.readProjectionStatus() } : {},
+        ...deps.readStartupStatus ? { startup: deps.readStartupStatus() } : {},
         counts: {
           nodes: Object.keys(snapshot.nodes).length,
           actors: Object.keys(snapshot.actors).length,
@@ -110713,6 +111398,9 @@ class BrokerLocalEndpointResolver {
           if (revived)
             return revived;
         } catch (error48) {
+          if (isCodexThreadHeldExternallyError(error48)) {
+            throw error48;
+          }
           await this.options.persistEndpoint({
             ...endpoint,
             state: "offline",
@@ -110920,6 +111608,7 @@ function isWakeableSessionBackedEndpoint(endpoint) {
 }
 
 // packages/runtime/src/broker-local-invocation-service.ts
+var HELD_THREAD_RETRY_DELAY_MS = 30000;
 function executionResolutionWithObservedEndpoint(resolution, endpoint, fallbackObservedAt) {
   if (!resolution) {
     return null;
@@ -111008,6 +111697,23 @@ class BrokerLocalInvocationService {
         endpoint = await this.options.endpointResolver.prepareLocalEndpointForInvocation(endpoint);
       }
     } catch (error48) {
+      if (isCodexThreadHeldExternallyError(error48)) {
+        const checkedAt = this.now();
+        await this.options.transitionInvocation(invocation.id, {
+          state: "queued",
+          summary: `${target2.displayName}'s Codex thread is open in another app. Message stored; will deliver when the thread is released.`,
+          metadata: {
+            dispatchOutcome: {
+              status: "queued_until_online",
+              reason: "thread_held_externally",
+              checkedAt
+            },
+            heldThreadId: error48.threadId
+          }
+        });
+        this.options.deferInvocationRetry?.(invocation.id, checkedAt + HELD_THREAD_RETRY_DELAY_MS);
+        return;
+      }
       const message = error48 instanceof Error ? error48.message : String(error48);
       const failedFlight = await this.options.transitionInvocation(invocation.id, {
         state: "failed",
@@ -111345,6 +112051,36 @@ class BrokerLocalInvocationService {
       }
       return;
     }
+    if (isCodexThreadHeldExternallyError(error48)) {
+      const checkedAt = this.now();
+      if (!this.currentFlightIsTerminal(invocation.id)) {
+        await this.options.transitionInvocation(invocation.id, {
+          state: "queued",
+          summary: `${target2.displayName}'s Codex thread is open in another app. Message stored; will deliver when the thread is released.`,
+          error: undefined,
+          completedAt: undefined,
+          metadata: {
+            dispatchOutcome: {
+              status: "queued_until_online",
+              reason: "thread_held_externally",
+              checkedAt
+            },
+            heldThreadId: error48.threadId
+          }
+        });
+      }
+      this.options.deferInvocationRetry?.(invocation.id, checkedAt + HELD_THREAD_RETRY_DELAY_MS);
+      await this.options.persistEndpoint({
+        ...runningEndpoint,
+        state: priorEndpointState,
+        metadata: {
+          ...runningEndpoint.metadata ?? {},
+          lastNotice: message,
+          threadHeldExternallyAt: checkedAt
+        }
+      });
+      return;
+    }
     const failedFlight = this.currentFlightIsTerminal(invocation.id) ? null : await this.options.transitionInvocation(invocation.id, {
       state: "failed",
       summary: `${target2.displayName} failed to respond.`,
@@ -111578,7 +112314,7 @@ function resolveProjectProvisionalAgentName(input) {
 }
 
 // packages/runtime/src/session-locator.ts
-import { existsSync as existsSync45, readdirSync as readdirSync14, readFileSync as readFileSync26, statSync as statSync15 } from "fs";
+import { existsSync as existsSync45, readdirSync as readdirSync14, readFileSync as readFileSync26, statSync as statSync16 } from "fs";
 import { homedir as homedir38 } from "os";
 import { basename as basename23, join as join55, resolve as resolve21 } from "path";
 var CODEX_HARNESS = "codex";
@@ -111595,7 +112331,7 @@ function pathExists4(path7) {
 }
 function safeStatMtimeMs(path7) {
   try {
-    return statSync15(path7).mtimeMs;
+    return statSync16(path7).mtimeMs;
   } catch {
     return 0;
   }
@@ -111615,7 +112351,7 @@ function walkFiles(root, predicate, into = [], depth = 0) {
     const full = join55(root, name2);
     let isDir = false;
     try {
-      isDir = statSync15(full).isDirectory();
+      isDir = statSync16(full).isDirectory();
     } catch {
       continue;
     }
@@ -112168,7 +112904,7 @@ function throwIfAborted2(signal) {
 }
 function json2(response, status, payload) {
   response.writeHead(status, { "content-type": "application/json; charset=utf-8" });
-  response.end(JSON.stringify(payload, null, 2));
+  response.end(JSON.stringify(payload));
 }
 function a2aJson(response, status, payload, headers = {}) {
   response.writeHead(status, {
@@ -112176,14 +112912,14 @@ function a2aJson(response, status, payload, headers = {}) {
     ...headers,
     "content-type": `${A2A_JSON_RPC_CONTENT_TYPE}; charset=utf-8`
   });
-  response.end(JSON.stringify(payload, null, 2));
+  response.end(JSON.stringify(payload));
 }
 function jsonWithHeaders(response, status, payload, headers) {
   response.writeHead(status, {
     ...headers,
     "content-type": "application/json; charset=utf-8"
   });
-  response.end(JSON.stringify(payload, null, 2));
+  response.end(JSON.stringify(payload));
 }
 var MAX_SERVER_TIMING_HEADER_LENGTH = 2048;
 var TRUNCATED_SERVER_TIMING_HEADER = 'server-timing-truncated;desc="oversize"';
@@ -114710,7 +115446,10 @@ function createBrokerHttpRouter(deps) {
       return;
     }
     if (method === "GET" && (url2.pathname === "/v1/snapshot" || url2.pathname === "/v1/mesh/snapshot")) {
-      json2(response, 200, await brokerService.readSnapshot({ since: parseSince(url2) }));
+      json2(response, 200, await brokerService.readSnapshot({
+        since: parseSince(url2),
+        scope: url2.searchParams.get("scope") === "conversations" ? "conversations" : undefined
+      }));
       return;
     }
     if (method === "GET" && url2.pathname === "/v1/capabilities/availability") {
@@ -116016,6 +116755,28 @@ async function discoverMeshNodes(options) {
   };
 }
 
+// packages/runtime/src/mesh-peer-filter.ts
+var MESH_PEER_STALE_MS = 24 * 60 * 60 * 1000;
+function isCurrentMeshPeerNode(node, options) {
+  if (!node.brokerUrl?.trim())
+    return false;
+  if (node.id === options.localNodeId)
+    return false;
+  if (node.advertiseScope !== "mesh")
+    return false;
+  const meshId = options.meshId;
+  if (meshId && node.meshId !== meshId)
+    return false;
+  const now = options.now ?? Date.now();
+  const lastSeen = node.lastSeenAt ?? node.registeredAt ?? 0;
+  if (lastSeen > 0 && now - lastSeen > MESH_PEER_STALE_MS)
+    return false;
+  return true;
+}
+function collectCurrentMeshPeerNodes(input) {
+  return Object.values(input.nodes).filter((node) => isCurrentMeshPeerNode(node, input));
+}
+
 // packages/runtime/src/broker-mesh-discovery-service.ts
 function isNodeLocalProductAgentId(agentId, productAgentIds) {
   return productAgentIds.has(agentId.trim().toLowerCase());
@@ -116074,9 +116835,11 @@ class BrokerMeshDiscoveryService {
     const peersToSync = new Map;
     for (const node of discovered)
       peersToSync.set(node.id, node);
-    for (const node of Object.values(this.deps.runtime.snapshot().nodes)) {
-      if (node.id === this.deps.nodeId || !node.brokerUrl)
-        continue;
+    for (const node of collectCurrentMeshPeerNodes({
+      nodes: this.deps.runtime.snapshot().nodes,
+      localNodeId: this.deps.nodeId,
+      meshId: this.deps.meshId
+    })) {
       peersToSync.set(node.id, node);
     }
     for (const node of peersToSync.values()) {
@@ -117185,14 +117948,28 @@ class BrokerCommandService {
 class BrokerDispatchRecoveryService {
   deps;
   #recoveringInvocationIds = new Set;
+  #deferredInvocations = new Map;
   constructor(deps) {
     this.deps = deps;
   }
+  deferInvocation(invocationId, notBeforeTs) {
+    this.#deferredInvocations.set(invocationId, notBeforeTs);
+  }
+  #isDeferred(invocationId, now) {
+    const notBefore = this.#deferredInvocations.get(invocationId);
+    if (notBefore === undefined)
+      return false;
+    if (now >= notBefore) {
+      this.#deferredInvocations.delete(invocationId);
+      return false;
+    }
+    return true;
+  }
   async recoverQueuedFlights(input) {
     const now = this.deps.now?.() ?? Date.now();
-    const jobs = this.deps.dispatchJobs().filter((job) => isInvocationDispatchJobDue(job, now, { includeRunning: true })).filter((job) => !input.agentId || job.targetAgentId === input.agentId).sort((left, right) => left.createdAt - right.createdAt);
+    const jobs = this.deps.dispatchJobs().filter((job) => isInvocationDispatchJobDue(job, now, { includeRunning: true })).filter((job) => !input.agentId || job.targetAgentId === input.agentId).filter((job) => !this.#isDeferred(job.invocationId, now)).sort((left, right) => left.createdAt - right.createdAt);
     const jobInvocationIds = new Set(jobs.map((job) => job.invocationId));
-    const queued = Object.values(this.deps.runtimeSnapshot().flights).filter((flight) => flight.state === "queued" || flight.state === "waking").filter((flight) => !input.agentId || flight.targetAgentId === input.agentId).filter((flight) => !jobInvocationIds.has(flight.invocationId)).sort((left, right) => flightSortTime(left) - flightSortTime(right));
+    const queued = Object.values(this.deps.runtimeSnapshot().flights).filter((flight) => flight.state === "queued" || flight.state === "waking").filter((flight) => !input.agentId || flight.targetAgentId === input.agentId).filter((flight) => !jobInvocationIds.has(flight.invocationId)).filter((flight) => !this.#isDeferred(flight.invocationId, now)).sort((left, right) => flightSortTime(left) - flightSortTime(right));
     const result = {
       considered: jobs.length + queued.length,
       dispatched: 0,
@@ -117259,10 +118036,14 @@ class BrokerHomeService {
   }
   async read() {
     const snapshot = this.#deps.runtimeSnapshot();
+    const projectionStatus = this.#deps.projectionStatus?.() ?? { state: "ready" };
+    const projectionReady = projectionStatus.state === "ready";
     return {
       updatedAt: this.#now(),
       agents: this.#agents(snapshot),
-      activity: this.#activity(snapshot, await this.#deps.listActivityItems({ limit: 96 }))
+      activity: projectionReady ? this.#activity(snapshot, await this.#deps.listActivityItems({ limit: 96 })) : this.#runtimeActivity(snapshot),
+      activitySource: projectionReady ? "sqlite_projection" : "runtime_snapshot",
+      activityState: projectionStatus.state
     };
   }
   #agents(snapshot) {
@@ -117302,6 +118083,22 @@ class BrokerHomeService {
       };
     });
   }
+  #runtimeActivity(snapshot) {
+    return Object.values(snapshot.messages).sort((left, right) => right.createdAt - left.createdAt || right.id.localeCompare(left.id)).slice(0, 24).map((message) => {
+      const actorName = this.#deps.actorDisplayName(snapshot, message.actorId);
+      return {
+        id: message.id,
+        kind: message.class === "system" || message.class === "status" || message.class === "log" ? "system" : "message",
+        actorId: message.actorId,
+        actorName,
+        title: actorName,
+        detail: message.body || null,
+        conversationId: message.conversationId,
+        channel: brokerConversationChannel(snapshot, message.conversationId),
+        timestamp: message.createdAt
+      };
+    });
+  }
   #now() {
     return this.#deps.now?.() ?? Date.now();
   }
@@ -118488,7 +119285,9 @@ var relayAgentSweepIntervalMs = Number.parseInt(process.env.OPENSCOUT_RELAY_AGEN
 var relayAgentIdleTtlMs = Number.parseInt(process.env.OPENSCOUT_RELAY_AGENT_IDLE_TTL_MS ?? String(DEFAULT_RELAY_AGENT_SESSION_IDLE_TTL_MS), 10);
 var runtimeHeartbeatIntervalMs = 30000;
 var repoWatchServeCacheTtlMs = Number.parseInt(process.env.OPENSCOUT_REPO_WATCH_CACHE_TTL_MS ?? "1200000", 10);
+var tailRecentServeCacheTtlMs = Number.parseInt(process.env.OPENSCOUT_TAIL_RECENT_SERVE_CACHE_TTL_MS ?? "4000", 10);
 var repoWatchRehydrateAfterMs = Number.parseInt(process.env.OPENSCOUT_REPO_WATCH_REHYDRATE_AFTER_MS ?? "30000", 10);
+var startupBoundaryTestDelayMs = Number.parseInt(process.env.OPENSCOUT_TEST_STARTUP_BOUNDARY_DELAY_MS ?? "0", 10);
 var meshGateMode = resolveMeshGateMode(process.env);
 ensureOpenScoutCleanSlateSync();
 var existingBroker = await probeExistingBroker();
@@ -118504,7 +119303,7 @@ nodeId = resolveStableLocalNodeId({
   supportDirectory
 });
 var journal = new FileBackedBrokerJournal(journalPath);
-await journal.load();
+var journalLoadReport = await journal.load();
 var initialSnapshot = journal.snapshot();
 assertNoReservedStoredAgentNames(initialSnapshot.agents, { localNodeId: nodeId });
 var sqliteDisabled = process.env.OPENSCOUT_DISABLE_SQLITE === "1";
@@ -118514,6 +119313,8 @@ if (!sqliteDisabled) {
   await mkdir14(dirname33(dbPath2), { recursive: true });
 }
 var projection = new RecoverableSQLiteProjection(dbPath2, journal, { disabled: sqliteDisabled });
+var projectionWarmStarted = false;
+var bootstrapProjectionOptions = () => projectionWarmStarted ? undefined : { enqueueProjection: false };
 var routeAliasDatabase = sqliteDisabled ? null : openControlPlaneSqliteDatabase(dbPath2, { create: true });
 if (routeAliasDatabase) {
   configureControlPlaneDatabase(routeAliasDatabase);
@@ -119050,7 +119851,7 @@ async function migrateUnqualifiedRelayAgentKeys() {
 async function readRelayAgentRegistrySignature() {
   try {
     const registryPath = resolveOpenScoutSupportPaths().relayAgentsRegistryPath;
-    const info = await stat7(registryPath);
+    const info = await stat8(registryPath);
     const contents = await readFile15(registryPath);
     const hash2 = createHash16("sha256").update(contents).digest("base64url");
     return `${info.mtimeMs}:${info.size}:${hash2}`;
@@ -119330,6 +120131,7 @@ var localInvocationService = new BrokerLocalInvocationService({
   createId: createRuntimeId2,
   transitionInvocation,
   persistEndpoint,
+  deferInvocationRetry: (invocationId, notBeforeTs) => dispatchRecoveryService.deferInvocation(invocationId, notBeforeTs),
   postInvocationStatusMessage,
   postConversationMessage,
   existingBrokerReplyForInvocation,
@@ -119696,9 +120498,11 @@ var deliveryAcceptanceService = new BrokerDeliveryAcceptanceService({
   queueOperatorSignal: (input) => operatorAttentionService.queueOperatorSignal(input),
   warn: (message, detail) => console.warn(message, detail)
 });
+var startupTrafficGate = new BrokerStartupTrafficGate;
 var homeService = new BrokerHomeService({
   runtimeSnapshot: () => runtime.snapshot(),
   listActivityItems: (options) => projection.listActivityItems(options),
+  projectionStatus: () => projection.statusSnapshot(),
   actorDisplayName: brokerActorDisplayName2,
   operatorActorId
 });
@@ -119714,6 +120518,7 @@ var brokerService = createBrokerCoreService({
   isReconciledStaleFlightActivityItem,
   readChildServices: () => webControl.readChildServiceSnapshots(),
   readProjectionStatus: () => projection.statusSnapshot(),
+  readStartupStatus: () => startupTrafficGate.snapshot(),
   readHome: () => homeService.read(),
   readCapabilities: readBrokerCapabilityMatrixSnapshot,
   readRuntimeCatalog: readBrokerRuntimeCatalogSnapshot,
@@ -119732,9 +120537,9 @@ var brokerRepoTailService = new BrokerRepoTailService({
   readRecentTranscriptEvents,
   repoWatchServeCacheTtlMs,
   repoWatchRehydrateAfterMs,
+  tailRecentServeCacheTtlMs,
   warn: (message) => console.warn(message)
 });
-registerActiveScoutBrokerService(brokerService);
 var rendezvousService = new BrokerRendezvousService;
 var routeRequest = createBrokerHttpRouter({
   host,
@@ -119878,12 +120683,7 @@ function openRolesControlPlaneDb() {
 }
 function createBrokerHttpServer() {
   return createServer((request, response) => {
-    meshIngressGate.gateHttpRequest(request, response, (gatedRequest) => routeRequest(gatedRequest, response).catch((error48) => {
-      json2(response, 500, {
-        error: "internal_error",
-        detail: error48 instanceof Error ? error48.message : String(error48)
-      });
-    })).catch((error48) => {
+    meshIngressGate.gateHttpRequest(request, response, (gatedRequest) => routeBrokerHttpRequest(gatedRequest, response)).catch((error48) => {
       json2(response, 500, {
         error: "internal_error",
         detail: error48 instanceof Error ? error48.message : String(error48)
@@ -119891,6 +120691,22 @@ function createBrokerHttpServer() {
     });
   });
 }
+async function routeBrokerHttpRequest(request, response) {
+  if (!startupTrafficGate.admits(request.method, request.url ?? "/")) {
+    json2(response, 503, {
+      error: "broker_restoring",
+      detail: "Recovery reads are available; this route will resume after the startup projection boundary is established.",
+      retryable: true
+    });
+    return;
+  }
+  await routeRequest(request, response).catch((error48) => {
+    json2(response, 500, {
+      error: "internal_error",
+      detail: error48 instanceof Error ? error48.message : String(error48)
+    });
+  });
+}
 var server = createBrokerHttpServer();
 var socketServer = createBrokerHttpServer();
 server.on("close", () => {
@@ -119923,12 +120739,7 @@ var secretRedaction = await bootstrapSecretRedaction({ patchConsole: true });
 console.log(`[openscout-runtime] secret redaction armed (${secretRedaction.registered} value(s)${secretRedaction.schemaPath ? `, schema ${secretRedaction.schemaPath}` : ", no .env.schema found"})`);
 try {
   let handleBrokerHttp = function(request, response) {
-    meshIngressGate.gateHttpRequest(request, response, (gatedRequest) => routeRequest(gatedRequest, response).catch((error48) => {
-      json2(response, 500, {
-        error: "internal_error",
-        detail: error48 instanceof Error ? error48.message : String(error48)
-      });
-    })).catch((error48) => {
+    meshIngressGate.gateHttpRequest(request, response, (gatedRequest) => routeBrokerHttpRequest(gatedRequest, response)).catch((error48) => {
       json2(response, 500, {
         error: "internal_error",
         detail: error48 instanceof Error ? error48.message : String(error48)
@@ -119939,8 +120750,7 @@ try {
   console.log(`[openscout-runtime] secret redaction armed (${secretRedaction2.registered} value(s)${secretRedaction2.schemaPath ? `, schema ${secretRedaction2.schemaPath}` : ", no .env.schema found"})`);
   await listenTcp(server, { host: isLoopbackHost(host) || host === "0.0.0.0" || host === "::" ? "127.0.0.1" : host, port });
   await listenUnixSocket(socketServer, brokerSocketPath);
-  projection.warm();
-  upsertNodeDurably(localNode).then(() => upsertActorDurably(systemActor)).catch((error48) => {
+  const bootstrapIdentityWrite = upsertNodeDurably(localNode, bootstrapProjectionOptions()).then(() => upsertActorDurably(systemActor, bootstrapProjectionOptions())).catch((error48) => {
     console.error("[openscout-runtime] bootstrap identity persistence failed:", error48);
   });
   meshBindController = createMeshBindController({
@@ -119956,7 +120766,7 @@ try {
       brokerUrl = state.brokerUrl;
       const nextNode = localNodeWithBindState(currentLocalNode(), state);
       Object.assign(localNode, nextNode);
-      await upsertNodeDurably(nextNode).catch((error48) => {
+      await upsertNodeDurably(nextNode, bootstrapProjectionOptions()).catch((error48) => {
         console.warn("[openscout-runtime] mesh bind: failed to update node registry:", error48);
       });
       await writeHostInfo().catch((error48) => {
@@ -119970,14 +120780,13 @@ try {
     advertiseScope = state.scope;
     brokerUrl = state.brokerUrl;
     Object.assign(localNode, localNodeWithBindState(localNode, state));
-    await upsertNodeDurably(localNode).catch(() => {
+    await upsertNodeDurably(localNode, bootstrapProjectionOptions()).catch(() => {
       return;
     });
   }
   await writeHostInfo().catch((error48) => {
     console.warn("[openscout-runtime] failed to write .host-info:", error48);
   });
-  peerDelivery.start();
   const meshRendezvousConfig = resolveMeshRendezvousPublishConfig();
   if (meshRendezvousConfig) {
     meshRendezvousPublisher = startMeshRendezvousPublisher(currentRendezvousNode, {
@@ -119985,6 +120794,15 @@ try {
       logger: console
     });
   }
+  if (Number.isFinite(startupBoundaryTestDelayMs) && startupBoundaryTestDelayMs > 0) {
+    await sleep3(startupBoundaryTestDelayMs);
+  }
+  await bootstrapIdentityWrite;
+  projectionWarmStarted = true;
+  await projection.warm();
+  startupTrafficGate.admitMutations();
+  registerActiveScoutBrokerService(brokerService);
+  peerDelivery.start();
   console.log(`[openscout-runtime] broker listening on 127.0.0.1:${port} (scope: ${advertiseScope}, url: ${brokerUrl})`);
   console.log(`[openscout-runtime] broker local socket ${brokerSocketPath}`);
   const bindState = meshBindController.getState();
@@ -119996,6 +120814,7 @@ try {
   console.log(`[openscout-runtime] node ${nodeId} in mesh ${meshId}`);
   console.log(`[openscout-runtime] mesh trust: keyId ${nodeIdentityKeyId} fingerprint ${nodeIdentityFingerprint} (gate: ${effectiveGateMode()})`);
   console.log(`[openscout-runtime] journal ${journalPath}`);
+  console.log(`[openscout-runtime] journal load ${journalLoadReport.totalMs}ms (scan ${journalLoadReport.scanMs}ms, compaction ${journalLoadReport.compactionMs}ms, ${journalLoadReport.validEntries} entries, ${journalLoadReport.sourceBytes} -> ${journalLoadReport.compactedBytes} bytes)`);
   console.log(`[openscout-runtime] sqlite ${sqliteDisabled ? "disabled" : dbPath2}`);
 } catch (error48) {
   unregisterActiveScoutBrokerService(brokerService);
@@ -120091,6 +120910,11 @@ if (Number.isFinite(relayAgentSweepIntervalMs) && relayAgentSweepIntervalMs > 0)
 setInterval(() => {
   sweepAndCompactMeshNodes();
 }, 900000).unref();
+setInterval(() => {
+  dispatchRecoveryService.recoverQueuedFlights({ reason: "queued_retry_sweep" }).catch((error48) => {
+    console.error("[openscout-runtime] queued dispatch retry sweep failed:", error48);
+  });
+}, 60000).unref();
 if (routeAliasService) {
   setInterval(() => {
     routeAliasService.sweepExpired();