adhdev 0.8.75 → 0.8.77

package/dist/index.js

@@ -1026,6 +1026,67 @@ var init_host_memory = __esm({
   }
 });
 
+// ../../oss/packages/daemon-core/src/session-host/runtime-surface.ts
+function isSessionHostLiveRuntime(record2) {
+  const lifecycle = String(record2?.lifecycle || "").trim();
+  return LIVE_LIFECYCLES.has(lifecycle);
+}
+function getSessionHostRecoveryLabel(meta3) {
+  const recoveryState = typeof meta3?.runtimeRecoveryState === "string" ? String(meta3.runtimeRecoveryState).trim() : "";
+  if (!recoveryState) return null;
+  if (recoveryState === "auto_resumed") return "restored after restart";
+  if (recoveryState === "resume_failed") return "restore failed";
+  if (recoveryState === "host_restart_interrupted") return "host restart interrupted";
+  if (recoveryState === "orphan_snapshot") return "snapshot recovered";
+  return recoveryState.replace(/_/g, " ");
+}
+function isSessionHostRecoverySnapshot(record2) {
+  if (!record2) return false;
+  if (isSessionHostLiveRuntime(record2)) return false;
+  const lifecycle = String(record2.lifecycle || "").trim();
+  if (lifecycle && lifecycle !== "stopped" && lifecycle !== "failed") {
+    return false;
+  }
+  const meta3 = record2.meta || void 0;
+  if (meta3?.restoredFromStorage === true) return true;
+  return getSessionHostRecoveryLabel(meta3) !== null;
+}
+function getSessionHostSurfaceKind(record2) {
+  if (isSessionHostLiveRuntime(record2)) return "live_runtime";
+  if (isSessionHostRecoverySnapshot(record2)) return "recovery_snapshot";
+  return "inactive_record";
+}
+function partitionSessionHostRecords(records) {
+  const liveRuntimes = [];
+  const recoverySnapshots = [];
+  const inactiveRecords = [];
+  for (const record2 of records) {
+    const kind = getSessionHostSurfaceKind(record2);
+    if (kind === "live_runtime") {
+      liveRuntimes.push(record2);
+    } else if (kind === "recovery_snapshot") {
+      recoverySnapshots.push(record2);
+    } else {
+      inactiveRecords.push(record2);
+    }
+  }
+  return {
+    liveRuntimes,
+    recoverySnapshots,
+    inactiveRecords
+  };
+}
+function partitionSessionHostDiagnosticsSessions(records) {
+  return partitionSessionHostRecords(records || []);
+}
+var LIVE_LIFECYCLES;
+var init_runtime_surface = __esm({
+  "../../oss/packages/daemon-core/src/session-host/runtime-surface.ts"() {
+    "use strict";
+    LIVE_LIFECYCLES = /* @__PURE__ */ new Set(["starting", "running", "stopping", "interrupted"]);
+  }
+});
+
 // ../../oss/packages/daemon-core/src/status/chat-tail-hot-sessions.ts
 function parseMessageTimestamp(value) {
   if (typeof value === "number" && Number.isFinite(value)) return value;
@@ -1035,6 +1096,23 @@ function parseMessageTimestamp(value) {
   }
   return 0;
 }
+function isDefinitelyNonLiveRuntimeSession(session) {
+  const surfaceKind = String(session?.runtimeSurfaceKind || "").trim();
+  if (surfaceKind === "live_runtime") return false;
+  if (surfaceKind === "recovery_snapshot") return true;
+  if (surfaceKind === "inactive_record") return false;
+  const lifecycle = String(session?.runtimeLifecycle || "").trim();
+  if (lifecycle && LIVE_RUNTIME_LIFECYCLES.has(lifecycle)) return false;
+  const inferredSurfaceKind = getSessionHostSurfaceKind({
+    lifecycle: lifecycle || null,
+    meta: {
+      restoredFromStorage: session?.runtimeRestoredFromStorage === true,
+      ...session?.runtimeRecoveryState ? { runtimeRecoveryState: session.runtimeRecoveryState } : {}
+    }
+  });
+  if (inferredSurfaceKind === "recovery_snapshot") return true;
+  return false;
+}
 function classifyHotChatSessionsForSubscriptionFlush(sessions, previousHotSessionIds, options = {}) {
   const now = options.now ?? Date.now();
   const recentMessageGraceMs = Math.max(
@@ -1043,9 +1121,14 @@ function classifyHotChatSessionsForSubscriptionFlush(sessions, previousHotSessio
   );
   const activeStatuses = options.activeStatuses ?? DEFAULT_ACTIVE_CHAT_POLL_STATUSES;
   const active = /* @__PURE__ */ new Set();
+  const excluded = /* @__PURE__ */ new Set();
   for (const session of sessions) {
     const sessionId = typeof session?.id === "string" ? session.id : "";
     if (!sessionId) continue;
+    if (isDefinitelyNonLiveRuntimeSession(session)) {
+      excluded.add(sessionId);
+      continue;
+    }
     const status = String(session?.status || "").toLowerCase();
     const lastMessageAt = parseMessageTimestamp(session?.lastMessageAt);
     const recentlyUpdated = lastMessageAt > 0 && now - lastMessageAt <= recentMessageGraceMs;
@@ -1054,20 +1137,22 @@ function classifyHotChatSessionsForSubscriptionFlush(sessions, previousHotSessio
     }
   }
   const finalizing = new Set(
-    Array.from(previousHotSessionIds).filter((sessionId) => !active.has(sessionId))
+    Array.from(previousHotSessionIds).filter((sessionId) => !active.has(sessionId) && !excluded.has(sessionId))
   );
   return { active, finalizing };
 }
-var DEFAULT_ACTIVE_CHAT_POLL_STATUSES, DEFAULT_CHAT_TAIL_RECENT_MESSAGE_GRACE_MS;
+var DEFAULT_ACTIVE_CHAT_POLL_STATUSES, DEFAULT_CHAT_TAIL_RECENT_MESSAGE_GRACE_MS, LIVE_RUNTIME_LIFECYCLES;
 var init_chat_tail_hot_sessions = __esm({
   "../../oss/packages/daemon-core/src/status/chat-tail-hot-sessions.ts"() {
     "use strict";
+    init_runtime_surface();
     DEFAULT_ACTIVE_CHAT_POLL_STATUSES = /* @__PURE__ */ new Set([
       "generating",
       "waiting_approval",
       "starting"
     ]);
     DEFAULT_CHAT_TAIL_RECENT_MESSAGE_GRACE_MS = 8e3;
+    LIVE_RUNTIME_LIFECYCLES = /* @__PURE__ */ new Set(["starting", "running", "stopping", "interrupted"]);
   }
 });
 
@@ -1287,6 +1372,32 @@ var init_logger = __esm({
 });
 
 // ../../oss/packages/daemon-core/src/cdp/manager.ts
+function normalizeTitle(value) {
+  return String(value || "").trim().replace(/\s+/g, " ").toLowerCase();
+}
+function titlesMatch(lhs, rhs) {
+  const a = normalizeTitle(lhs);
+  const b = normalizeTitle(rhs);
+  if (!a || !b) return false;
+  return a === b || a.includes(b) || b.includes(a);
+}
+function resolveCdpPageTarget(params) {
+  const { pages, pinnedTargetId, previousPageTitle } = params;
+  if (pages.length === 0) return { target: null, retargeted: false };
+  if (!pinnedTargetId) {
+    return { target: pages[0] || null, retargeted: false };
+  }
+  const exact = pages.find((page) => page.id === pinnedTargetId);
+  if (exact) return { target: exact, retargeted: false };
+  const titleMatchesList = pages.filter((page) => titlesMatch(page.title, previousPageTitle));
+  if (titleMatchesList.length === 1) {
+    return { target: titleMatchesList[0], retargeted: true };
+  }
+  if (pages.length === 1) {
+    return { target: pages[0], retargeted: true };
+  }
+  return { target: null, retargeted: false };
+}
 var import_ws, http, DaemonCdpManager;
 var init_manager = __esm({
   "../../oss/packages/daemon-core/src/cdp/manager.ts"() {
@@ -1454,18 +1565,28 @@ var init_manager = __esm({
                   resolve15(targets.find((t) => t.webSocketDebuggerUrl) || null);
                   return;
                 }
-                const mainPages = pages.filter((t) => !this.isNonMainTitle(t.title || ""));
-                const list = mainPages.length > 0 ? mainPages : pages;
+                const titleFilteredPages = pages.filter((t) => !this.isNonMainTitle(t.title || ""));
+                const mainPages = titleFilteredPages.filter((t) => this.isMainPageUrl(t.url));
+                const list = mainPages.length > 0 ? mainPages : titleFilteredPages.length > 0 ? titleFilteredPages : pages;
                 this.log(`[CDP] pages(${list.length}): ${list.map((t) => `"${t.title}"`).join(", ")}`);
-                if (this._targetId) {
-                  const specific = list.find((t) => t.id === this._targetId);
-                  if (specific) {
-                    this._pageTitle = specific.title || "";
-                    resolve15(specific);
-                  } else {
-                    this.log(`[CDP] Target ${this._targetId} not found in page list`);
-                    resolve15(null);
+                const previousTargetId = this._targetId;
+                const selected = resolveCdpPageTarget({
+                  pages: list,
+                  pinnedTargetId: previousTargetId,
+                  previousPageTitle: this._pageTitle
+                });
+                if (selected.target) {
+                  if (selected.retargeted && previousTargetId && previousTargetId !== selected.target.id) {
+                    this.log(`[CDP] Target ${previousTargetId} rekeyed to ${selected.target.id}`);
+                    this._targetId = selected.target.id;
                   }
+                  this._pageTitle = selected.target.title || "";
+                  resolve15(selected.target);
+                  return;
+                }
+                if (previousTargetId) {
+                  this.log(`[CDP] Target ${previousTargetId} not found in page list`);
+                  resolve15(null);
                   return;
                 }
                 this._pageTitle = list[0]?.title || "";
@@ -3342,6 +3463,68 @@ function sanitizeHistoryMessage(agentType, message) {
     content
   };
 }
+function sortSavedHistorySessionSummaries(summaries) {
+  return summaries.slice().sort((a, b) => b.lastMessageAt - a.lastMessageAt);
+}
+function buildSavedHistorySessionSummaryMapFromEntries(entries) {
+  const summaries = /* @__PURE__ */ new Map();
+  for (const entry of Array.from(entries.values())) {
+    const fileSummary = entry.summary;
+    if (!fileSummary || fileSummary.messageCount <= 0 || !fileSummary.lastMessageAt) continue;
+    const existing = summaries.get(fileSummary.historySessionId);
+    if (!existing) {
+      summaries.set(fileSummary.historySessionId, {
+        historySessionId: fileSummary.historySessionId,
+        sessionTitle: fileSummary.sessionTitle,
+        messageCount: fileSummary.messageCount,
+        firstMessageAt: fileSummary.firstMessageAt,
+        lastMessageAt: fileSummary.lastMessageAt,
+        preview: fileSummary.preview,
+        workspace: fileSummary.workspace
+      });
+      continue;
+    }
+    existing.messageCount += fileSummary.messageCount;
+    if (!existing.firstMessageAt || fileSummary.firstMessageAt < existing.firstMessageAt) {
+      existing.firstMessageAt = fileSummary.firstMessageAt;
+    }
+    if (fileSummary.lastMessageAt >= existing.lastMessageAt) {
+      existing.lastMessageAt = fileSummary.lastMessageAt;
+      if (fileSummary.sessionTitle) existing.sessionTitle = fileSummary.sessionTitle;
+      if (fileSummary.preview) existing.preview = fileSummary.preview;
+    }
+    if (!existing.workspace && fileSummary.workspace) {
+      existing.workspace = fileSummary.workspace;
+    }
+  }
+  return Object.fromEntries(sortSavedHistorySessionSummaries(Array.from(summaries.values())).map((summary) => [summary.historySessionId, summary]));
+}
+function readPersistedSavedHistorySessionSummaries(dir) {
+  try {
+    const filePath = getSavedHistoryIndexFilePath(dir);
+    if (!fs3.existsSync(filePath)) return null;
+    const raw = JSON.parse(fs3.readFileSync(filePath, "utf-8"));
+    if (!raw || raw.version !== SAVED_HISTORY_INDEX_VERSION || !raw.sessions || typeof raw.sessions !== "object") {
+      return null;
+    }
+    return sortSavedHistorySessionSummaries(
+      Object.values(raw.sessions).filter((summary) => !!summary && typeof summary.historySessionId === "string" && summary.messageCount > 0 && summary.lastMessageAt > 0).map((summary) => ({
+        historySessionId: summary.historySessionId,
+        sessionTitle: summary.sessionTitle,
+        messageCount: summary.messageCount,
+        firstMessageAt: summary.firstMessageAt,
+        lastMessageAt: summary.lastMessageAt,
+        preview: summary.preview,
+        workspace: summary.workspace
+      }))
+    );
+  } catch {
+    return null;
+  }
+}
+function shouldScheduleSavedHistoryRollup(totalBytes) {
+  return Number.isFinite(totalBytes) && totalBytes >= SAVED_HISTORY_ROLLUP_THRESHOLD_BYTES;
+}
 function sanitizeHistoryFileSegment(value) {
   return String(value || "").replace(/[^a-zA-Z0-9_-]/g, "_");
 }
@@ -3355,71 +3538,386 @@ function listHistoryFiles(dir, historySessionId) {
     return true;
   }).sort().reverse();
 }
-function buildSavedHistoryCacheSignature(dir, files) {
-  return files.map((file2) => {
+function normalizeSavedHistorySessionId(agentType, historySessionId) {
+  const normalizedId = String(historySessionId || "").trim();
+  if (!normalizedId) return "";
+  const strictProviderId = normalizeProviderSessionId(agentType, normalizedId);
+  if (strictProviderId) return strictProviderId;
+  return agentType === "hermes-cli" ? "" : normalizedId;
+}
+function extractSavedHistorySessionIdFromFile(agentType, file2) {
+  const match = file2.match(/^([A-Za-z0-9_-]+)_\d{4}-\d{2}-\d{2}\.jsonl$/);
+  return normalizeSavedHistorySessionId(agentType, match?.[1] || "");
+}
+function buildSavedHistoryFileSignatureMap(dir, files) {
+  return new Map(files.map((file2) => {
     try {
       const stat4 = fs3.statSync(path7.join(dir, file2));
-      return `${file2}:${stat4.size}:${Math.trunc(stat4.mtimeMs)}`;
+      return [file2, `${file2}:${stat4.size}:${Math.trunc(stat4.mtimeMs)}`];
     } catch {
-      return `${file2}:missing`;
-    }
-  }).join("|");
-}
-function computeSavedHistorySessionSummaries(agentType, dir, files) {
-  const groupedFiles = /* @__PURE__ */ new Map();
-  const filePattern = /^([A-Za-z0-9_-]+)_\d{4}-\d{2}-\d{2}\.jsonl$/;
-  for (const file2 of files) {
-    const match = file2.match(filePattern);
-    if (!match?.[1]) continue;
-    const historySessionId = match[1];
-    const grouped = groupedFiles.get(historySessionId) || [];
-    grouped.push(file2);
-    groupedFiles.set(historySessionId, grouped);
-  }
-  const summaries = [];
-  for (const [historySessionId, grouped] of groupedFiles.entries()) {
-    let messageCount = 0;
-    let firstMessageAt = 0;
-    let lastMessageAt = 0;
-    let sessionTitle = "";
-    let preview = "";
-    let workspace = "";
-    for (const file2 of grouped.sort()) {
-      const filePath = path7.join(dir, file2);
-      const content = fs3.readFileSync(filePath, "utf-8");
-      const lines = content.split("\n").filter(Boolean);
-      for (const line of lines) {
-        let parsed = null;
+      return [file2, `${file2}:missing`];
+    }
+  }));
+}
+function buildSavedHistoryCacheSignature(files, fileSignatures) {
+  return files.map((file2) => fileSignatures.get(file2) || `${file2}:missing`).join("|");
+}
+function getSavedHistoryIndexFilePath(dir) {
+  return path7.join(dir, SAVED_HISTORY_INDEX_FILE);
+}
+function getSavedHistoryIndexLockPath(dir) {
+  return `${getSavedHistoryIndexFilePath(dir)}${SAVED_HISTORY_INDEX_LOCK_SUFFIX}`;
+}
+function sleepBlocking(ms) {
+  if (ms <= 0) return;
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function loadPersistedSavedHistoryIndexFromFile(dir) {
+  try {
+    const filePath = getSavedHistoryIndexFilePath(dir);
+    if (!fs3.existsSync(filePath)) return /* @__PURE__ */ new Map();
+    const raw = JSON.parse(fs3.readFileSync(filePath, "utf-8"));
+    if (!raw || raw.version !== SAVED_HISTORY_INDEX_VERSION || !raw.files || typeof raw.files !== "object") {
+      return /* @__PURE__ */ new Map();
+    }
+    return new Map(
+      Object.entries(raw.files).filter(([file2, entry]) => !!file2 && !!entry && typeof entry.signature === "string").map(([file2, entry]) => [file2, {
+        signature: entry.signature,
+        summary: entry.summary || null
+      }])
+    );
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
+function writePersistedSavedHistoryIndexFile(dir, entries) {
+  const filePath = getSavedHistoryIndexFilePath(dir);
+  const tempPath = `${filePath}.tmp`;
+  const payload = {
+    version: SAVED_HISTORY_INDEX_VERSION,
+    files: Object.fromEntries(entries.entries()),
+    sessions: buildSavedHistorySessionSummaryMapFromEntries(entries)
+  };
+  fs3.writeFileSync(tempPath, JSON.stringify(payload), "utf-8");
+  fs3.renameSync(tempPath, filePath);
+}
+function acquireSavedHistoryIndexLock(dir) {
+  const lockPath = getSavedHistoryIndexLockPath(dir);
+  const deadline = Date.now() + SAVED_HISTORY_INDEX_LOCK_WAIT_MS;
+  while (Date.now() <= deadline) {
+    try {
+      fs3.mkdirSync(lockPath);
+      return () => {
         try {
-          parsed = JSON.parse(line);
+          fs3.rmSync(lockPath, { recursive: true, force: true });
         } catch {
-          parsed = null;
         }
-        if (!parsed || parsed.historySessionId !== historySessionId) continue;
-        if (parsed.kind === "session_start") {
-          if (!workspace && parsed.workspace) workspace = parsed.workspace;
+      };
+    } catch (error48) {
+      if (error48?.code !== "EEXIST") return null;
+      try {
+        const stat4 = fs3.statSync(lockPath);
+        if (Date.now() - stat4.mtimeMs > SAVED_HISTORY_INDEX_LOCK_STALE_MS) {
+          fs3.rmSync(lockPath, { recursive: true, force: true });
           continue;
         }
-        messageCount += 1;
-        if (!firstMessageAt || parsed.receivedAt < firstMessageAt) firstMessageAt = parsed.receivedAt;
-        if (!lastMessageAt || parsed.receivedAt > lastMessageAt) lastMessageAt = parsed.receivedAt;
-        if (parsed.sessionTitle) sessionTitle = parsed.sessionTitle;
-        if (parsed.role !== "system" && parsed.content.trim()) preview = parsed.content.trim();
-      }
-    }
-    if (messageCount === 0 || !lastMessageAt) continue;
-    summaries.push({
-      historySessionId,
-      sessionTitle: sessionTitle || void 0,
-      messageCount,
-      firstMessageAt,
-      lastMessageAt,
-      preview: preview || void 0,
-      workspace: workspace || void 0
-    });
+      } catch {
+        continue;
+      }
+      sleepBlocking(SAVED_HISTORY_INDEX_LOCK_POLL_MS);
+    }
+  }
+  return null;
+}
+function withLockedPersistedSavedHistoryIndex(dir, callback) {
+  const release2 = acquireSavedHistoryIndexLock(dir);
+  if (!release2) return null;
+  try {
+    const entries = loadPersistedSavedHistoryIndexFromFile(dir);
+    const result = callback(entries);
+    writePersistedSavedHistoryIndexFile(dir, entries);
+    return result;
+  } catch {
+    return null;
+  } finally {
+    release2();
   }
-  summaries.sort((a, b) => b.lastMessageAt - a.lastMessageAt);
-  return summaries;
+}
+function loadPersistedSavedHistoryIndex(dir) {
+  return loadPersistedSavedHistoryIndexFromFile(dir);
+}
+function savePersistedSavedHistoryIndex(dir, entries) {
+  withLockedPersistedSavedHistoryIndex(dir, (currentEntries) => {
+    const incomingFiles = new Set(Array.from(entries.keys()));
+    for (const [file2, entry] of Array.from(entries.entries())) {
+      const liveSignature = buildSavedHistoryFileSignature(dir, file2);
+      const existingEntry = currentEntries.get(file2);
+      if (existingEntry && existingEntry.signature !== liveSignature && entry.signature !== liveSignature) {
+        continue;
+      }
+      if (entry.signature !== liveSignature && (!existingEntry || existingEntry.signature !== liveSignature)) {
+        continue;
+      }
+      currentEntries.set(file2, entry.signature === liveSignature ? entry : {
+        signature: liveSignature,
+        summary: existingEntry?.summary || entry.summary
+      });
+    }
+    for (const file2 of Array.from(currentEntries.keys())) {
+      if (incomingFiles.has(file2)) continue;
+      if (!fs3.existsSync(path7.join(dir, file2))) {
+        currentEntries.delete(file2);
+      }
+    }
+  });
+}
+function invalidatePersistedSavedHistoryIndex(agentType, dir) {
+  try {
+    fs3.rmSync(getSavedHistoryIndexFilePath(dir), { force: true });
+  } catch {
+  }
+  savedHistorySessionCache.delete(agentType.replace(/[^a-zA-Z0-9_-]/g, "_"));
+}
+function buildSavedHistoryIndexFileSignature(dir) {
+  try {
+    const stat4 = fs3.statSync(getSavedHistoryIndexFilePath(dir));
+    return `index:${stat4.size}:${Math.trunc(stat4.mtimeMs)}`;
+  } catch {
+    return "index:missing";
+  }
+}
+function historyDirectoryHasFilesNewerThanIndex(dir) {
+  try {
+    const indexStat = fs3.statSync(getSavedHistoryIndexFilePath(dir));
+    const files = listHistoryFiles(dir);
+    for (const file2 of files) {
+      const stat4 = fs3.statSync(path7.join(dir, file2));
+      if (stat4.mtimeMs > indexStat.mtimeMs) return true;
+    }
+    return false;
+  } catch {
+    return true;
+  }
+}
+function buildSavedHistoryFileSignature(dir, file2) {
+  try {
+    const stat4 = fs3.statSync(path7.join(dir, file2));
+    return `${file2}:${stat4.size}:${Math.trunc(stat4.mtimeMs)}`;
+  } catch {
+    return `${file2}:missing`;
+  }
+}
+function persistSavedHistoryFileSummaryEntry(agentType, dir, file2, updater) {
+  const filePath = path7.join(dir, file2);
+  const result = withLockedPersistedSavedHistoryIndex(dir, (entries) => {
+    const currentEntry = entries.get(file2) || null;
+    const nextSummary = updater(currentEntry?.summary || null);
+    const nextEntry = {
+      signature: buildSavedHistoryFileSignature(dir, file2),
+      summary: nextSummary
+    };
+    entries.set(file2, nextEntry);
+    savedHistoryFileSummaryCache.set(filePath, nextEntry);
+    return nextEntry;
+  });
+  if (!result) return;
+  if (result.summary?.historySessionId && shouldScheduleSavedHistoryRollupForSignature(result.signature)) {
+    scheduleSavedHistoryRollup(agentType, result.summary.historySessionId);
+  }
+}
+function updateSavedHistoryIndexForSessionStart(agentType, dir, file2, historySessionId, workspace) {
+  const normalizedSessionId = normalizeSavedHistorySessionId(agentType, historySessionId);
+  const normalizedWorkspace = String(workspace || "").trim();
+  if (!normalizedSessionId || !normalizedWorkspace) return;
+  persistSavedHistoryFileSummaryEntry(agentType, dir, file2, (currentSummary) => ({
+    file: file2,
+    historySessionId: normalizedSessionId,
+    messageCount: currentSummary?.messageCount || 0,
+    firstMessageAt: currentSummary?.firstMessageAt || 0,
+    lastMessageAt: currentSummary?.lastMessageAt || 0,
+    sessionTitle: currentSummary?.sessionTitle,
+    preview: currentSummary?.preview,
+    workspace: normalizedWorkspace
+  }));
+}
+function updateSavedHistoryIndexForAppendedMessages(agentType, dir, file2, historySessionId, messages) {
+  const normalizedSessionId = normalizeSavedHistorySessionId(agentType, historySessionId || "");
+  if (!normalizedSessionId || messages.length === 0) return;
+  persistSavedHistoryFileSummaryEntry(agentType, dir, file2, (currentSummary) => {
+    const nextSummary = {
+      file: file2,
+      historySessionId: normalizedSessionId,
+      messageCount: currentSummary?.messageCount || 0,
+      firstMessageAt: currentSummary?.firstMessageAt || 0,
+      lastMessageAt: currentSummary?.lastMessageAt || 0,
+      sessionTitle: currentSummary?.sessionTitle,
+      preview: currentSummary?.preview,
+      workspace: currentSummary?.workspace
+    };
+    for (const message of messages) {
+      if (!message || message.historySessionId !== historySessionId) continue;
+      if (message.kind === "session_start") {
+        if (message.workspace) nextSummary.workspace = message.workspace;
+        continue;
+      }
+      nextSummary.messageCount += 1;
+      if (!nextSummary.firstMessageAt || message.receivedAt < nextSummary.firstMessageAt) {
+        nextSummary.firstMessageAt = message.receivedAt;
+      }
+      if (!nextSummary.lastMessageAt || message.receivedAt >= nextSummary.lastMessageAt) {
+        nextSummary.lastMessageAt = message.receivedAt;
+        if (message.sessionTitle) nextSummary.sessionTitle = message.sessionTitle;
+        if (message.role !== "system" && message.content.trim()) nextSummary.preview = message.content.trim();
+      } else if (message.sessionTitle) {
+        nextSummary.sessionTitle = message.sessionTitle;
+      }
+      if (!nextSummary.preview && message.role !== "system" && message.content.trim()) {
+        nextSummary.preview = message.content.trim();
+      }
+    }
+    return nextSummary;
+  });
+}
+function computeSavedHistoryFileSummary(agentType, dir, file2) {
+  const historySessionId = extractSavedHistorySessionIdFromFile(agentType, file2);
+  if (!historySessionId) return null;
+  const filePath = path7.join(dir, file2);
+  const content = fs3.readFileSync(filePath, "utf-8");
+  const lines = content.split("\n").filter(Boolean);
+  let messageCount = 0;
+  let firstMessageAt = 0;
+  let lastMessageAt = 0;
+  let sessionTitle = "";
+  let preview = "";
+  let workspace = "";
+  for (const line of lines) {
+    let parsed = null;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      parsed = null;
+    }
+    if (!parsed || parsed.historySessionId !== historySessionId) continue;
+    if (parsed.kind === "session_start") {
+      if (!workspace && parsed.workspace) workspace = parsed.workspace;
+      continue;
+    }
+    messageCount += 1;
+    if (!firstMessageAt || parsed.receivedAt < firstMessageAt) firstMessageAt = parsed.receivedAt;
+    if (!lastMessageAt || parsed.receivedAt > lastMessageAt) lastMessageAt = parsed.receivedAt;
+    if (parsed.sessionTitle) sessionTitle = parsed.sessionTitle;
+    if (parsed.role !== "system" && parsed.content.trim()) preview = parsed.content.trim();
+  }
+  if (messageCount === 0 || !lastMessageAt) return null;
+  return {
+    file: file2,
+    historySessionId,
+    messageCount,
+    firstMessageAt,
+    lastMessageAt,
+    sessionTitle: sessionTitle || void 0,
+    preview: preview || void 0,
+    workspace: workspace || void 0
+  };
+}
+function shouldScheduleSavedHistoryRollupForSignature(signature) {
+  const parts = String(signature || "").split(":");
+  const size = Number(parts[1] || 0);
+  return shouldScheduleSavedHistoryRollup(size);
+}
+function scheduleSavedHistoryRollup(agentType, historySessionId) {
+  const key = `${agentType}:${historySessionId}`;
+  if (!historySessionId || savedHistoryRollupInFlight.has(key)) return;
+  savedHistoryRollupInFlight.add(key);
+  setTimeout(() => {
+    try {
+      new ChatHistoryWriter().compactHistorySession(agentType, historySessionId);
+    } finally {
+      savedHistoryRollupInFlight.delete(key);
+    }
+  }, 0);
+}
+function scheduleSavedHistoryBackgroundRefresh(agentType, dir) {
+  const key = `${agentType}:${dir}`;
+  if (savedHistoryBackgroundRefresh.has(key)) return;
+  savedHistoryBackgroundRefresh.add(key);
+  setTimeout(() => {
+    try {
+      if (!fs3.existsSync(dir)) return;
+      const files = listHistoryFiles(dir);
+      const fileSignatures = buildSavedHistoryFileSignatureMap(dir, files);
+      const persistedEntries = loadPersistedSavedHistoryIndex(dir);
+      const computed = computeSavedHistorySessionSummaries(agentType, dir, files, fileSignatures, persistedEntries);
+      savePersistedSavedHistoryIndex(dir, computed.persistedEntries || /* @__PURE__ */ new Map());
+      const refreshedIndexSignature = buildSavedHistoryIndexFileSignature(dir);
+      savedHistorySessionCache.set(agentType.replace(/[^a-zA-Z0-9_-]/g, "_"), {
+        signature: refreshedIndexSignature,
+        summaries: computed.summaries || []
+      });
+      for (const [file2, entry] of Array.from(computed.persistedEntries.entries())) {
+        if (!entry?.summary || !shouldScheduleSavedHistoryRollupForSignature(entry.signature)) continue;
+        scheduleSavedHistoryRollup(agentType, entry.summary.historySessionId);
+      }
+    } catch {
+    } finally {
+      savedHistoryBackgroundRefresh.delete(key);
+    }
+  }, 0);
+}
+function computeSavedHistorySessionSummaries(agentType, dir, files, fileSignatures, persistedEntries) {
+  const summaryBySessionId = /* @__PURE__ */ new Map();
+  const nextPersistedEntries = /* @__PURE__ */ new Map();
+  for (const file2 of files.slice().sort()) {
+    const filePath = path7.join(dir, file2);
+    const signature = fileSignatures.get(file2) || `${file2}:missing`;
+    const cached2 = savedHistoryFileSummaryCache.get(filePath);
+    const persisted = persistedEntries.get(file2);
+    const reusableEntry = cached2?.signature === signature ? cached2 : persisted?.signature === signature ? persisted : null;
+    const fileSummary = reusableEntry?.summary || computeSavedHistoryFileSummary(agentType, dir, file2);
+    const nextEntry = reusableEntry || {
+      signature,
+      summary: fileSummary
+    };
+    if (!reusableEntry) {
+      nextEntry.signature = signature;
+      nextEntry.summary = fileSummary;
+    }
+    savedHistoryFileSummaryCache.set(filePath, nextEntry);
+    nextPersistedEntries.set(file2, nextEntry);
+    if (!fileSummary) continue;
+    const existing = summaryBySessionId.get(fileSummary.historySessionId);
+    if (fileSummary.messageCount <= 0 || !fileSummary.lastMessageAt) {
+      continue;
+    }
+    if (!existing) {
+      summaryBySessionId.set(fileSummary.historySessionId, {
+        historySessionId: fileSummary.historySessionId,
+        sessionTitle: fileSummary.sessionTitle,
+        messageCount: fileSummary.messageCount,
+        firstMessageAt: fileSummary.firstMessageAt,
+        lastMessageAt: fileSummary.lastMessageAt,
+        preview: fileSummary.preview,
+        workspace: fileSummary.workspace
+      });
+      continue;
+    }
+    existing.messageCount += fileSummary.messageCount;
+    if (!existing.firstMessageAt || fileSummary.firstMessageAt < existing.firstMessageAt) {
+      existing.firstMessageAt = fileSummary.firstMessageAt;
+    }
+    if (fileSummary.lastMessageAt >= existing.lastMessageAt) {
+      existing.lastMessageAt = fileSummary.lastMessageAt;
+      if (fileSummary.sessionTitle) existing.sessionTitle = fileSummary.sessionTitle;
+      if (fileSummary.preview) existing.preview = fileSummary.preview;
+    }
+    if (!existing.workspace && fileSummary.workspace) {
+      existing.workspace = fileSummary.workspace;
+    }
+  }
+  return {
+    summaries: Array.from(summaryBySessionId.values()).sort((a, b) => b.lastMessageAt - a.lastMessageAt),
+    persistedEntries: nextPersistedEntries
+  };
 }
 function readChatHistory(agentType, offset = 0, limit = 30, historySessionId, excludeRecentCount = 0) {
   try {
@@ -3477,18 +3975,51 @@ function listSavedHistorySessions(agentType, options = {}) {
       savedHistorySessionCache.delete(sanitized);
       return { sessions: [], hasMore: false };
     }
-    const files = listHistoryFiles(dir);
-    const signature = buildSavedHistoryCacheSignature(dir, files);
     const cached2 = savedHistorySessionCache.get(sanitized);
-    const summaries = cached2?.signature === signature ? cached2.summaries : computeSavedHistorySessionSummaries(agentType, dir, files);
-    if (!cached2 || cached2.signature !== signature) {
+    const offset = Math.max(0, options.offset || 0);
+    const limit = Math.max(1, options.limit || 30);
+    const indexSignature = buildSavedHistoryIndexFileSignature(dir);
+    let cacheWasInvalidated = false;
+    if (cached2) {
+      const cacheLooksPersisted = cached2.signature.startsWith("index:");
+      const cacheStillValid = cacheLooksPersisted ? cached2.signature === indexSignature : (() => {
+        const files2 = listHistoryFiles(dir);
+        const fileSignatures2 = buildSavedHistoryFileSignatureMap(dir, files2);
+        return cached2.signature === buildSavedHistoryCacheSignature(files2, fileSignatures2);
+      })();
+      if (cacheStillValid) {
+        const sliced2 = cached2.summaries.slice(offset, offset + limit);
+        return {
+          sessions: sliced2,
+          hasMore: cached2.summaries.length > offset + limit
+        };
+      }
+      cacheWasInvalidated = true;
+    }
+    const persistedSessions = readPersistedSavedHistorySessionSummaries(dir);
+    if (!cacheWasInvalidated && persistedSessions?.length && !historyDirectoryHasFilesNewerThanIndex(dir)) {
       savedHistorySessionCache.set(sanitized, {
-        signature,
-        summaries
+        signature: indexSignature,
+        summaries: persistedSessions
       });
+      scheduleSavedHistoryBackgroundRefresh(agentType, dir);
+      const sliced2 = persistedSessions.slice(offset, offset + limit);
+      return {
+        sessions: sliced2,
+        hasMore: persistedSessions.length > offset + limit
+      };
     }
-    const offset = Math.max(0, options.offset || 0);
-    const limit = Math.max(1, options.limit || 30);
+    const files = listHistoryFiles(dir);
+    const fileSignatures = buildSavedHistoryFileSignatureMap(dir, files);
+    const signature = buildSavedHistoryCacheSignature(files, fileSignatures);
+    const persistedEntries = loadPersistedSavedHistoryIndex(dir);
+    const computed = computeSavedHistorySessionSummaries(agentType, dir, files, fileSignatures, persistedEntries);
+    const summaries = computed.summaries || [];
+    savePersistedSavedHistoryIndex(dir, computed.persistedEntries || /* @__PURE__ */ new Map());
+    savedHistorySessionCache.set(sanitized, {
+      signature,
+      summaries
+    });
     const sliced = summaries.slice(offset, offset + limit);
     return {
       sessions: sliced,
@@ -3498,7 +4029,7 @@ function listSavedHistorySessions(agentType, options = {}) {
     return { sessions: [], hasMore: false };
   }
 }
-var fs3, path7, os5, HISTORY_DIR, RETAIN_DAYS, savedHistorySessionCache, CODEX_STARTER_PROMPT_RE, ChatHistoryWriter;
+var fs3, path7, os5, HISTORY_DIR, RETAIN_DAYS, SAVED_HISTORY_INDEX_VERSION, SAVED_HISTORY_INDEX_FILE, SAVED_HISTORY_INDEX_LOCK_SUFFIX, SAVED_HISTORY_INDEX_LOCK_WAIT_MS, SAVED_HISTORY_INDEX_LOCK_STALE_MS, SAVED_HISTORY_INDEX_LOCK_POLL_MS, SAVED_HISTORY_ROLLUP_THRESHOLD_BYTES, savedHistorySessionCache, savedHistoryFileSummaryCache, savedHistoryBackgroundRefresh, savedHistoryRollupInFlight, CODEX_STARTER_PROMPT_RE, ChatHistoryWriter;
 var init_chat_history = __esm({
   "../../oss/packages/daemon-core/src/config/chat-history.ts"() {
     "use strict";
@@ -3506,9 +4037,20 @@ var init_chat_history = __esm({
     path7 = __toESM(require("path"));
     os5 = __toESM(require("os"));
     init_chat_message_normalization();
+    init_provider_session_id();
     HISTORY_DIR = path7.join(os5.homedir(), ".adhdev", "history");
     RETAIN_DAYS = 30;
+    SAVED_HISTORY_INDEX_VERSION = 1;
+    SAVED_HISTORY_INDEX_FILE = ".saved-history-index.json";
+    SAVED_HISTORY_INDEX_LOCK_SUFFIX = ".lock";
+    SAVED_HISTORY_INDEX_LOCK_WAIT_MS = 1500;
+    SAVED_HISTORY_INDEX_LOCK_STALE_MS = 15e3;
+    SAVED_HISTORY_INDEX_LOCK_POLL_MS = 25;
+    SAVED_HISTORY_ROLLUP_THRESHOLD_BYTES = 16 * 1024 * 1024;
     savedHistorySessionCache = /* @__PURE__ */ new Map();
+    savedHistoryFileSummaryCache = /* @__PURE__ */ new Map();
+    savedHistoryBackgroundRefresh = /* @__PURE__ */ new Set();
+    savedHistoryRollupInFlight = /* @__PURE__ */ new Set();
     CODEX_STARTER_PROMPT_RE = /^(?:[›❯]\s*)?(?:Find and fix a bug in @filename|Improve documentation in @filename|Write tests for @filename|Explain this codebase|Summarize recent commits|Implement \{feature\}|Use \/skills(?: to list available skills)?|Run \/review on my current changes)$/i;
     ChatHistoryWriter = class {
       /** Last seen message count per agent (deduplication) */
@@ -3583,9 +4125,11 @@ var init_chat_history = __esm({
           fs3.mkdirSync(dir, { recursive: true });
           const date5 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
           const filePrefix = effectiveHistoryKey ? `${this.sanitize(effectiveHistoryKey)}_` : "";
-          const filePath = path7.join(dir, `${filePrefix}${date5}.jsonl`);
+          const fileName = `${filePrefix}${date5}.jsonl`;
+          const filePath = path7.join(dir, fileName);
           const lines = newMessages.map((m) => JSON.stringify(m)).join("\n") + "\n";
           fs3.appendFileSync(filePath, lines, "utf-8");
+          updateSavedHistoryIndexForAppendedMessages(agentType, dir, fileName, effectiveHistoryKey, newMessages);
           const prevCount = this.lastSeenCounts.get(dedupKey) || 0;
           if (!historySessionId && messages.length < prevCount * 0.5 && prevCount > 3) {
             seenHashes.clear();
@@ -3676,7 +4220,8 @@ var init_chat_history = __esm({
           const dir = path7.join(HISTORY_DIR, this.sanitize(agentType));
           fs3.mkdirSync(dir, { recursive: true });
           const date5 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-          const filePath = path7.join(dir, `${this.sanitize(id)}_${date5}.jsonl`);
+          const fileName = `${this.sanitize(id)}_${date5}.jsonl`;
+          const filePath = path7.join(dir, fileName);
           const record2 = {
             ts: (/* @__PURE__ */ new Date()).toISOString(),
             receivedAt: Date.now(),
@@ -3689,6 +4234,7 @@ var init_chat_history = __esm({
             workspace: ws
           };
           fs3.appendFileSync(filePath, JSON.stringify(record2) + "\n", "utf-8");
+          updateSavedHistoryIndexForSessionStart(agentType, dir, fileName, id, ws);
         } catch {
         }
       }
@@ -3754,6 +4300,7 @@ var init_chat_history = __esm({
             }
             fs3.unlinkSync(sourcePath);
           }
+          invalidatePersistedSavedHistoryIndex(agentType, dir);
         } catch {
         }
       }
@@ -3803,6 +4350,7 @@ var init_chat_history = __esm({
             fs3.writeFileSync(filePath, `${collapsed.map((entry) => JSON.stringify(entry)).join("\n")}
 `, "utf-8");
           }
+          invalidatePersistedSavedHistoryIndex(agentType, dir);
         } catch {
         }
       }
@@ -3822,13 +4370,18 @@ var init_chat_history = __esm({
           for (const dir of agentDirs) {
             const dirPath = path7.join(HISTORY_DIR, dir.name);
             const files = fs3.readdirSync(dirPath).filter((f) => f.endsWith(".jsonl") || f.endsWith(".terminal.log"));
+            let removedAny = false;
             for (const file2 of files) {
               const filePath = path7.join(dirPath, file2);
               const stat4 = fs3.statSync(filePath);
               if (stat4.mtimeMs < cutoff) {
                 fs3.unlinkSync(filePath);
+                removedAny = true;
               }
             }
+            if (removedAny) {
+              invalidatePersistedSavedHistoryIndex(dir.name, dirPath);
+            }
           }
         } catch {
         }
@@ -5663,7 +6216,7 @@ function shouldIncludeSessionMetadata(profile) {
   return profile !== "live";
 }
 function shouldIncludeRuntimeMetadata(profile) {
-  return profile !== "live";
+  return true;
 }
 function findCdpManager(cdpManagers, key) {
   const exact = cdpManagers.get(key);
@@ -5755,6 +6308,21 @@ function buildExtensionAgentSession(parent, ext, options) {
     lastUpdated: ext.lastUpdated
   };
 }
+function shouldIncludeExtensionSession(ext) {
+  const status = String(ext.status || "").trim().toLowerCase();
+  const hasActiveChat = !!ext.activeChat;
+  const hasMessages = Array.isArray(ext.activeChat?.messages) && ext.activeChat.messages.length > 0;
+  const hasModal = !!ext.activeChat?.activeModal;
+  const hasStreams = Array.isArray(ext.agentStreams) && ext.agentStreams.length > 0;
+  const hasProviderSessionId = typeof ext.providerSessionId === "string" && ext.providerSessionId.trim().length > 0;
+  const hasControlValues = !!(ext.controlValues && Object.keys(ext.controlValues).length > 0);
+  const hasProviderControls = Array.isArray(ext.providerControls) && ext.providerControls.length > 0;
+  const hasOpenPanelCapability = Array.isArray(ext.sessionCapabilities) && ext.sessionCapabilities.includes("open_panel");
+  const hasSummaryMetadata = !!ext.summaryMetadata;
+  const hasError = typeof ext.errorMessage === "string" && ext.errorMessage.trim().length > 0;
+  const hasInterestingStatus = !!status && !["idle", "panel_hidden", "disconnected", "not_monitored"].includes(status);
+  return hasActiveChat || hasMessages || hasModal || hasStreams || hasProviderSessionId || hasControlValues || hasProviderControls || hasOpenPanelCapability || hasSummaryMetadata || hasError || hasInterestingStatus;
+}
 function buildCliSession(state, options) {
   const profile = options.profile || "full";
   const activeChat = normalizeActiveChatData(state.activeChat, getActiveChatOptions(profile));
@@ -5780,8 +6348,12 @@ function buildCliSession(state, options) {
       runtimeKey: state.runtime?.runtimeKey,
       runtimeDisplayName: state.runtime?.displayName,
       runtimeWorkspaceLabel: state.runtime?.workspaceLabel,
+      runtimeLifecycle: state.runtime?.lifecycle ?? null,
+      runtimeSurfaceKind: state.runtime?.surfaceKind,
       runtimeWriteOwner: state.runtime?.writeOwner || null,
-      runtimeAttachedClients: state.runtime?.attachedClients || []
+      runtimeAttachedClients: state.runtime?.attachedClients || [],
+      runtimeRestoredFromStorage: state.runtime?.restoredFromStorage === true,
+      runtimeRecoveryState: state.runtime?.recoveryState ?? null
     },
     mode: state.mode,
     resume: state.resume,
@@ -5838,6 +6410,7 @@ function buildSessionEntries(allStates, cdpManagers, options = {}) {
   for (const state of ideStates) {
     sessions.push(buildIdeWorkspaceSession(state, cdpManagers, options));
     for (const ext of state.extensions) {
+      if (!shouldIncludeExtensionSession(ext)) continue;
       sessions.push(buildExtensionAgentSession(state, ext, options));
     }
   }
@@ -8090,7 +8663,9 @@ function applyProviderPatch(h, args, payload) {
   });
 }
 async function executeProviderScript(h, args, scriptName) {
-  const resolvedProviderType = h.currentSession?.providerType || h.currentProviderType || args?.agentType || args?.providerType;
+  const explicitTargetSessionId = typeof args?.targetSessionId === "string" ? args.targetSessionId.trim() : "";
+  const targetSession = explicitTargetSessionId ? h.ctx.sessionRegistry?.get(explicitTargetSessionId) : void 0;
+  const resolvedProviderType = targetSession?.providerType || h.currentSession?.providerType || h.currentProviderType || args?.agentType || args?.providerType;
   if (!resolvedProviderType) return { success: false, error: "targetSessionId or providerType is required" };
   const loader = h.ctx.providerLoader;
   if (!loader) return { success: false, error: "ProviderLoader not initialized" };
@@ -8133,16 +8708,16 @@ async function executeProviderScript(h, args, scriptName) {
   const scriptFn = provider.scripts[actualScriptName];
   const scriptCode = scriptFn(normalizedArgs);
   if (!scriptCode) return { success: false, error: `Script '${actualScriptName}' returned null` };
-  const cdpKey = provider.category === "ide" ? h.currentSession?.cdpManagerKey || h.currentManagerKey || resolvedProviderType : h.currentSession?.cdpManagerKey || h.currentManagerKey;
+  const cdpKey = provider.category === "ide" ? targetSession?.cdpManagerKey || h.currentSession?.cdpManagerKey || h.currentManagerKey || resolvedProviderType : targetSession?.cdpManagerKey || h.currentSession?.cdpManagerKey || h.currentManagerKey;
   LOG.info("Command", `[ExtScript] provider=${provider.type} category=${provider.category} cdpKey=${cdpKey}`);
   const cdp = h.getCdp(cdpKey);
   if (!cdp?.isConnected) return { success: false, error: `No CDP connection for ${cdpKey || "any"}` };
   try {
     let result;
     if (provider.category === "extension") {
-      const runtimeSessionId = h.currentSession?.sessionId || args?.targetSessionId;
+      const runtimeSessionId = explicitTargetSessionId || h.currentSession?.sessionId;
       if (!runtimeSessionId) return { success: false, error: `No target session found for ${resolvedProviderType}` };
-      const parentSessionId = h.currentSession?.parentSessionId;
+      const parentSessionId = targetSession?.parentSessionId || h.currentSession?.parentSessionId;
       if (parentSessionId) {
         await h.agentStream?.setActiveSession(cdp, parentSessionId, runtimeSessionId);
         await h.agentStream?.syncActiveSession(cdp, parentSessionId);
@@ -12492,8 +13067,12 @@ var init_cli_provider_instance = __esm({
             runtimeKey: runtime.runtimeKey,
             displayName: runtime.displayName,
             workspaceLabel: runtime.workspaceLabel,
+            lifecycle: runtime.lifecycle ?? null,
+            surfaceKind: runtime.surfaceKind,
             writeOwner: runtime.writeOwner || null,
-            attachedClients: runtime.attachedClients || []
+            attachedClients: runtime.attachedClients || [],
+            restoredFromStorage: runtime.restoredFromStorage === true,
+            recoveryState: runtime.recoveryState ?? null
           } : void 0,
           resume: this.provider.resume,
           controlValues: surface.controlValues,
@@ -34904,67 +35483,6 @@ var init_command_log = __esm({
   }
 });
 
-// ../../oss/packages/daemon-core/src/session-host/runtime-surface.ts
-function isSessionHostLiveRuntime(record2) {
-  const lifecycle = String(record2?.lifecycle || "").trim();
-  return LIVE_LIFECYCLES.has(lifecycle);
-}
-function getSessionHostRecoveryLabel(meta3) {
-  const recoveryState = typeof meta3?.runtimeRecoveryState === "string" ? String(meta3.runtimeRecoveryState).trim() : "";
-  if (!recoveryState) return null;
-  if (recoveryState === "auto_resumed") return "restored after restart";
-  if (recoveryState === "resume_failed") return "restore failed";
-  if (recoveryState === "host_restart_interrupted") return "host restart interrupted";
-  if (recoveryState === "orphan_snapshot") return "snapshot recovered";
-  return recoveryState.replace(/_/g, " ");
-}
-function isSessionHostRecoverySnapshot(record2) {
-  if (!record2) return false;
-  if (isSessionHostLiveRuntime(record2)) return false;
-  const lifecycle = String(record2.lifecycle || "").trim();
-  if (lifecycle && lifecycle !== "stopped" && lifecycle !== "failed") {
-    return false;
-  }
-  const meta3 = record2.meta || void 0;
-  if (meta3?.restoredFromStorage === true) return true;
-  return getSessionHostRecoveryLabel(meta3) !== null;
-}
-function getSessionHostSurfaceKind(record2) {
-  if (isSessionHostLiveRuntime(record2)) return "live_runtime";
-  if (isSessionHostRecoverySnapshot(record2)) return "recovery_snapshot";
-  return "inactive_record";
-}
-function partitionSessionHostRecords(records) {
-  const liveRuntimes = [];
-  const recoverySnapshots = [];
-  const inactiveRecords = [];
-  for (const record2 of records) {
-    const kind = getSessionHostSurfaceKind(record2);
-    if (kind === "live_runtime") {
-      liveRuntimes.push(record2);
-    } else if (kind === "recovery_snapshot") {
-      recoverySnapshots.push(record2);
-    } else {
-      inactiveRecords.push(record2);
-    }
-  }
-  return {
-    liveRuntimes,
-    recoverySnapshots,
-    inactiveRecords
-  };
-}
-function partitionSessionHostDiagnosticsSessions(records) {
-  return partitionSessionHostRecords(records || []);
-}
-var LIVE_LIFECYCLES;
-var init_runtime_surface = __esm({
-  "../../oss/packages/daemon-core/src/session-host/runtime-surface.ts"() {
-    "use strict";
-    LIVE_LIFECYCLES = /* @__PURE__ */ new Set(["starting", "running", "stopping", "interrupted"]);
-  }
-});
-
 // ../../oss/packages/daemon-core/src/status/snapshot.ts
 function buildRecentReadDebugSignature(snapshot) {
   return [
@@ -36582,6 +37100,28 @@ var init_subscription_updates = __esm({
   }
 });
 
+// ../../oss/packages/daemon-core/src/chat/async-batch.ts
+async function runAsyncBatch(items, worker, options = {}) {
+  const list = Array.from(items);
+  if (list.length === 0) return;
+  const concurrency = Math.max(1, Math.min(list.length, Math.floor(options.concurrency || 1)));
+  let nextIndex = 0;
+  const runners = Array.from({ length: concurrency }, async () => {
+    while (true) {
+      const currentIndex = nextIndex;
+      nextIndex += 1;
+      if (currentIndex >= list.length) return;
+      await worker(list[currentIndex], currentIndex);
+    }
+  });
+  await Promise.all(runners);
+}
+var init_async_batch = __esm({
+  "../../oss/packages/daemon-core/src/chat/async-batch.ts"() {
+    "use strict";
+  }
+});
+
 // ../../oss/packages/daemon-core/src/agent-stream/provider-adapter.ts
 var ProviderStreamAdapter;
 var init_provider_adapter = __esm({
@@ -37063,10 +37603,12 @@ var init_manager2 = __esm({
         }
       }
       /** Collect active extension session state */
-      async collectActiveSession(cdp, parentSessionId) {
+      async collectActiveSession(cdp, parentSessionId, attemptedSessionIds = /* @__PURE__ */ new Set(), originSessionId) {
         if (!this.enabled) return null;
         const activeSessionId = this.getActiveSessionId(parentSessionId);
         if (!activeSessionId) return null;
+        const resolvedOriginSessionId = originSessionId || activeSessionId;
+        attemptedSessionIds.add(activeSessionId);
         let agent = this.managedBySessionId.get(activeSessionId);
         if (!agent) {
           agent = await this.connectManagedSession(cdp, parentSessionId, activeSessionId) || void 0;
@@ -37079,18 +37621,44 @@ var init_manager2 = __esm({
         try {
           const evaluate = (expr, timeout) => cdp.evaluateInSessionFrame(agent.cdpSessionId, expr, timeout);
           const state = await agent.adapter.readChat(evaluate);
-          const stateError = this.getStateError(state);
-          const selectedModelValue = typeof state.controlValues?.model === "string" ? state.controlValues.model : "";
-          LOG.debug("AgentStream", `[AgentStream] readChat(${type}) result: status=${state.status} msgs=${state.messages?.length || 0} model=${selectedModelValue}${state.status === "error" ? " error=" + JSON.stringify(stateError) : ""}`);
-          if (state.status === "error" && this.isRecoverableSessionError(stateError)) {
+          const resolvedProviderSessionId = typeof state.providerSessionId === "string" && state.providerSessionId.trim() ? state.providerSessionId.trim() : typeof state.sessionId === "string" && state.sessionId.trim() && state.sessionId !== agent.runtimeSessionId ? state.sessionId.trim() : void 0;
+          const normalizedState = {
+            ...state,
+            sessionId: agent.runtimeSessionId,
+            ...resolvedProviderSessionId ? { providerSessionId: resolvedProviderSessionId } : {}
+          };
+          const stateError = this.getStateError(normalizedState);
+          const selectedModelValue = typeof normalizedState.controlValues?.model === "string" ? normalizedState.controlValues.model : "";
+          LOG.debug("AgentStream", `[AgentStream] readChat(${type}) result: status=${normalizedState.status} msgs=${normalizedState.messages?.length || 0} model=${selectedModelValue}${normalizedState.status === "error" ? " error=" + JSON.stringify(stateError) : ""}`);
+          if (normalizedState.status === "error" && this.isRecoverableSessionError(stateError)) {
             throw new Error(stateError);
           }
-          agent.lastState = state;
+          agent.lastState = normalizedState;
           agent.lastError = null;
-          if (state.status === "panel_hidden") {
+          if (normalizedState.status === "panel_hidden") {
+            const discovered = await cdp.discoverAgentWebviews().catch(() => []);
+            const fallbackTarget = discovered.find((entry) => {
+              if (entry.agentType === type) return false;
+              const fallbackSessionId = this.resolveSessionIdForTarget(parentSessionId, entry.agentType);
+              return !!fallbackSessionId && fallbackSessionId !== activeSessionId && !attemptedSessionIds.has(fallbackSessionId);
+            });
+            if (fallbackTarget) {
+              const fallbackSessionId = this.resolveSessionIdForTarget(parentSessionId, fallbackTarget.agentType);
+              if (fallbackSessionId && fallbackSessionId !== activeSessionId && !attemptedSessionIds.has(fallbackSessionId)) {
+                this.logFn(`[AgentStream] Active session ${type} is hidden; switching to visible agent ${fallbackTarget.agentType} (${parentSessionId})`);
+                await this.setActiveSession(cdp, parentSessionId, fallbackSessionId);
+                await this.syncActiveSession(cdp, parentSessionId);
+                const fallbackState = await this.collectActiveSession(cdp, parentSessionId, attemptedSessionIds, resolvedOriginSessionId);
+                if (fallbackState?.status === "panel_hidden" && resolvedOriginSessionId !== fallbackSessionId) {
+                  await this.setActiveSession(cdp, parentSessionId, resolvedOriginSessionId);
+                  await this.syncActiveSession(cdp, parentSessionId);
+                }
+                return fallbackState;
+              }
+            }
             agent.lastHiddenCheckTime = Date.now();
           }
-          return state;
+          return normalizedState;
         } catch (e) {
           const errorMsg = e?.message || String(e);
           this.logFn(`[AgentStream] readChat(${type}) error: ${errorMsg.slice(0, 200)}`);
@@ -37402,6 +37970,7 @@ var init_poller = __esm({
           try {
             await agentStreamManager.syncActiveSession(cdp, parentSessionId);
             let stream = await agentStreamManager.collectActiveSession(cdp, parentSessionId);
+            resolvedActiveSessionId = stream?.sessionId || agentStreamManager.getActiveSessionId(parentSessionId) || resolvedActiveSessionId;
             if (stream?.status === "waiting_approval") {
               const autoApprove = providerLoader.getSettings(stream.agentType).autoApprove !== false;
               if (autoApprove && resolvedActiveSessionId) {
@@ -43444,6 +44013,8 @@ var init_session_host_transport = __esm({
           runtimeKey: record2.runtimeKey,
           displayName: record2.displayName,
           workspaceLabel: record2.workspaceLabel,
+          lifecycle: typeof record2.lifecycle === "string" ? record2.lifecycle : null,
+          surfaceKind: record2.surfaceKind,
           writeOwner: record2.writeOwner ? {
             clientId: record2.writeOwner.clientId,
             ownerType: record2.writeOwner.ownerType
@@ -44221,6 +44792,7 @@ __export(src_exports, {
   resolveChatMessageKind: () => resolveChatMessageKind,
   resolveDebugRuntimeConfig: () => resolveDebugRuntimeConfig,
   resolveSessionHostAppName: () => resolveSessionHostAppName,
+  runAsyncBatch: () => runAsyncBatch,
   saveConfig: () => saveConfig,
   saveState: () => saveState,
   setDebugRuntimeConfig: () => setDebugRuntimeConfig,
@@ -44268,6 +44840,7 @@ var init_src = __esm({
     init_chat_history();
     init_chat_signatures();
     init_subscription_updates();
+    init_async_batch();
     init_agent_stream();
     init_agent_stream();
     init_forward();
@@ -45356,6 +45929,7 @@ var init_daemon_p2p = __esm({
     fs15 = __toESM(require("fs"));
     path23 = __toESM(require("path"));
     import_node_module2 = require("module");
+    init_src();
     init_data_channel_router();
     init_screenshot_sender();
     init_peer_connection_manager();
@@ -45605,14 +46179,22 @@ ${e?.stack || ""}`);
         return false;
       }
       async flushChatSubscriptions(builder) {
+        const tasks = [];
         for (const peer of this.peers.values()) {
           if (peer.state !== "connected" || !peer.chatSubscriptions || peer.chatSubscriptions.size === 0) continue;
           for (const subscription of peer.chatSubscriptions.values()) {
+            tasks.push({ peer, subscription });
+          }
+        }
+        await runAsyncBatch(tasks, async ({ peer, subscription }) => {
+          try {
             const update = await builder(subscription);
-            if (!update) continue;
+            if (!update) return;
             this.screenshotSender.sendTopicUpdateToPeer(peer, update);
+          } catch (error48) {
+            log(`chat_tail flush skipped: peer=${peer.peerId} session=${subscription.params.targetSessionId} error=${error48?.message || error48}`);
           }
-        }
+        }, { concurrency: 4 });
       }
       async flushMachineRuntimeSubscriptions(builder) {
         for (const peer of this.peers.values()) {
@@ -53563,7 +54145,7 @@ var init_adhdev_daemon = __esm({
     init_source2();
     init_version();
     init_src();
-    pkgVersion = resolvePackageVersion({ injectedVersion: "0.8.75" });
+    pkgVersion = resolvePackageVersion({ injectedVersion: "0.8.77" });
     AdhdevDaemon = class _AdhdevDaemon {
       localHttpServer = null;
       localWss = null;
@@ -53977,7 +54559,7 @@ ${err?.stack || ""}`);
               }),
               onStatusChange: () => {
                 this.statusReporter?.onStatusChange();
-                void this.flushP2PChatSubscriptions({ onlyActive: false });
+                void this.flushP2PChatSubscriptions({ onlyActive: true });
               },
               removeAgentTracking: (key) => this.statusReporter?.removeAgentTracking(key),
               hostedRuntimeManagerTag: "adhdev-cloud",
@@ -54006,7 +54588,7 @@ ${err?.stack || ""}`);
             statusVersion: pkgVersion,
             onStatusChange: () => {
               this.statusReporter?.onStatusChange();
-              void this.flushP2PChatSubscriptions({ onlyActive: false });
+              void this.flushP2PChatSubscriptions({ onlyActive: true });
             },
             onPostChatCommand: () => {
               setTimeout(() => this.statusReporter?.throttledReport(), 1e3);