@adhdev/daemon-standalone 0.8.75 → 0.8.76

package/dist/index.js

@@ -31510,6 +31510,7 @@ ${data.message || ""}`.trim();
       resolveChatMessageKind: () => resolveChatMessageKind,
       resolveDebugRuntimeConfig: () => resolveDebugRuntimeConfig,
       resolveSessionHostAppName: () => resolveSessionHostAppName2,
+      runAsyncBatch: () => runAsyncBatch2,
       saveConfig: () => saveConfig,
       saveState: () => saveState,
       setDebugRuntimeConfig: () => setDebugRuntimeConfig,
@@ -32268,6 +32269,32 @@ ${data.message || ""}`.trim();
     var import_ws2 = __toESM2(require("ws"));
     var http = __toESM2(require("http"));
     init_logger();
+    function normalizeTitle(value) {
+      return String(value || "").trim().replace(/\s+/g, " ").toLowerCase();
+    }
+    function titlesMatch(lhs, rhs) {
+      const a = normalizeTitle(lhs);
+      const b2 = normalizeTitle(rhs);
+      if (!a || !b2) return false;
+      return a === b2 || a.includes(b2) || b2.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 DaemonCdpManager = class {
       ws = null;
       browserWs = null;
@@ -32428,18 +32455,28 @@ ${data.message || ""}`.trim();
                   resolve11(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 || "";
-                    resolve11(specific);
-                  } else {
-                    this.log(`[CDP] Target ${this._targetId} not found in page list`);
-                    resolve11(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 || "";
+                  resolve11(selected.target);
+                  return;
+                }
+                if (previousTargetId) {
+                  this.log(`[CDP] Target ${previousTargetId} not found in page list`);
+                  resolve11(null);
                   return;
                 }
                 this._pageTitle = list[0]?.title || "";
@@ -33867,7 +33904,17 @@ ${cleanBody}`;
     init_chat_message_normalization();
     var HISTORY_DIR = path7.join(os52.homedir(), ".adhdev", "history");
     var RETAIN_DAYS = 30;
+    var SAVED_HISTORY_INDEX_VERSION = 1;
+    var SAVED_HISTORY_INDEX_FILE = ".saved-history-index.json";
+    var SAVED_HISTORY_INDEX_LOCK_SUFFIX = ".lock";
+    var SAVED_HISTORY_INDEX_LOCK_WAIT_MS = 1500;
+    var SAVED_HISTORY_INDEX_LOCK_STALE_MS = 15e3;
+    var SAVED_HISTORY_INDEX_LOCK_POLL_MS = 25;
+    var SAVED_HISTORY_ROLLUP_THRESHOLD_BYTES = 16 * 1024 * 1024;
     var savedHistorySessionCache = /* @__PURE__ */ new Map();
+    var savedHistoryFileSummaryCache = /* @__PURE__ */ new Map();
+    var savedHistoryBackgroundRefresh = /* @__PURE__ */ new Set();
+    var savedHistoryRollupInFlight = /* @__PURE__ */ new Set();
     var 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;
     function normalizeHistoryComparable(text) {
       return String(text || "").replace(/\s+/g, " ").trim();
@@ -33925,6 +33972,68 @@ ${cleanBody}`;
         content
       };
     }
+    function sortSavedHistorySessionSummaries(summaries) {
+      return summaries.slice().sort((a, b2) => b2.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 (!fs32.existsSync(filePath)) return null;
+        const raw = JSON.parse(fs32.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, "_");
     }
@@ -33938,71 +34047,386 @@ ${cleanBody}`;
         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 = fs32.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 = fs32.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(ms2) {
+      if (ms2 <= 0) return;
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms2);
+    }
+    function loadPersistedSavedHistoryIndexFromFile(dir) {
+      try {
+        const filePath = getSavedHistoryIndexFilePath(dir);
+        if (!fs32.existsSync(filePath)) return /* @__PURE__ */ new Map();
+        const raw = JSON.parse(fs32.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)
+      };
+      fs32.writeFileSync(tempPath, JSON.stringify(payload), "utf-8");
+      fs32.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 {
+          fs32.mkdirSync(lockPath);
+          return () => {
             try {
-              parsed = JSON.parse(line);
+              fs32.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 = fs32.statSync(lockPath);
+            if (Date.now() - stat4.mtimeMs > SAVED_HISTORY_INDEX_LOCK_STALE_MS) {
+              fs32.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);
+        }
       }
-      summaries.sort((a, b2) => b2.lastMessageAt - a.lastMessageAt);
-      return summaries;
+      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();
+      }
+    }
+    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 (!fs32.existsSync(path7.join(dir, file2))) {
+            currentEntries.delete(file2);
+          }
+        }
+      });
+    }
+    function invalidatePersistedSavedHistoryIndex(agentType, dir) {
+      try {
+        fs32.rmSync(getSavedHistoryIndexFilePath(dir), { force: true });
+      } catch {
+      }
+      savedHistorySessionCache.delete(agentType.replace(/[^a-zA-Z0-9_-]/g, "_"));
+    }
+    function buildSavedHistoryIndexFileSignature(dir) {
+      try {
+        const stat4 = fs32.statSync(getSavedHistoryIndexFilePath(dir));
+        return `index:${stat4.size}:${Math.trunc(stat4.mtimeMs)}`;
+      } catch {
+        return "index:missing";
+      }
+    }
+    function historyDirectoryHasFilesNewerThanIndex(dir) {
+      try {
+        const indexStat = fs32.statSync(getSavedHistoryIndexFilePath(dir));
+        const files = listHistoryFiles(dir);
+        for (const file2 of files) {
+          const stat4 = fs32.statSync(path7.join(dir, file2));
+          if (stat4.mtimeMs > indexStat.mtimeMs) return true;
+        }
+        return false;
+      } catch {
+        return true;
+      }
+    }
+    function buildSavedHistoryFileSignature(dir, file2) {
+      try {
+        const stat4 = fs32.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 = fs32.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 (!fs32.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, b2) => b2.lastMessageAt - a.lastMessageAt),
+        persistedEntries: nextPersistedEntries
+      };
     }
     var ChatHistoryWriter = class {
       /** Last seen message count per agent (deduplication) */
@@ -34077,9 +34501,11 @@ ${cleanBody}`;
           fs32.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";
           fs32.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();
@@ -34170,7 +34596,8 @@ ${cleanBody}`;
           const dir = path7.join(HISTORY_DIR, this.sanitize(agentType));
           fs32.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(),
@@ -34183,6 +34610,7 @@ ${cleanBody}`;
             workspace: ws2
           };
           fs32.appendFileSync(filePath, JSON.stringify(record2) + "\n", "utf-8");
+          updateSavedHistoryIndexForSessionStart(agentType, dir, fileName, id, ws2);
         } catch {
         }
       }
@@ -34248,6 +34676,7 @@ ${cleanBody}`;
             }
             fs32.unlinkSync(sourcePath);
           }
+          invalidatePersistedSavedHistoryIndex(agentType, dir);
         } catch {
         }
       }
@@ -34297,6 +34726,7 @@ ${cleanBody}`;
             fs32.writeFileSync(filePath, `${collapsed.map((entry) => JSON.stringify(entry)).join("\n")}
 `, "utf-8");
           }
+          invalidatePersistedSavedHistoryIndex(agentType, dir);
         } catch {
         }
       }
@@ -34316,13 +34746,18 @@ ${cleanBody}`;
           for (const dir of agentDirs) {
             const dirPath = path7.join(HISTORY_DIR, dir.name);
             const files = fs32.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 = fs32.statSync(filePath);
               if (stat4.mtimeMs < cutoff) {
                 fs32.unlinkSync(filePath);
+                removedAny = true;
               }
             }
+            if (removedAny) {
+              invalidatePersistedSavedHistoryIndex(dir.name, dirPath);
+            }
           }
         } catch {
         }
@@ -34388,18 +34823,51 @@ ${cleanBody}`;
           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,
@@ -36128,6 +36596,21 @@ ${effect.notification.body || ""}`.trim();
         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));
@@ -36211,6 +36694,7 @@ ${effect.notification.body || ""}`.trim();
       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));
         }
       }
@@ -38351,7 +38835,9 @@ ${effect.notification.body || ""}`.trim();
       });
     }
     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" };
@@ -38394,16 +38880,16 @@ ${effect.notification.body || ""}`.trim();
       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;
       LOG2.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);
@@ -45277,6 +45763,21 @@ Run 'adhdev doctor' for detailed diagnostics.`
         }
       };
     }
+    async function runAsyncBatch2(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);
+    }
     init_read_chat_contract();
     init_chat_message_normalization();
     var ProviderStreamAdapter = class {
@@ -45742,10 +46243,12 @@ Run 'adhdev doctor' for detailed diagnostics.`
         }
       }
       /** 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;
@@ -45758,18 +46261,44 @@ Run 'adhdev doctor' for detailed diagnostics.`
         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 : "";
-          LOG2.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 : "";
+          LOG2.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)}`);
@@ -46063,6 +46592,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
           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) {
@@ -53256,7 +53786,7 @@ var StandaloneServer = class {
         }),
         onStatusChange: () => {
           this.scheduleBroadcastStatus();
-          void this.flushWsChatSubscriptions(void 0, { onlyActive: false });
+          void this.flushWsChatSubscriptions(void 0, { onlyActive: true });
         },
         removeAgentTracking: () => {
         },
@@ -53285,7 +53815,7 @@ var StandaloneServer = class {
       statusDaemonMode: false,
       onStatusChange: () => {
         this.scheduleBroadcastStatus();
-        void this.flushWsChatSubscriptions(void 0, { onlyActive: false });
+        void this.flushWsChatSubscriptions(void 0, { onlyActive: true });
       },
       sessionHostControl,
       onStreamsUpdated: (ideType, streams) => {
@@ -53885,6 +54415,7 @@ var StandaloneServer = class {
     try {
       const targets = targetWs ? [targetWs] : Array.from(this.clients);
       const hotSessionIds = options.onlyActive ? this.getHotChatSessionIdsForWsFlush() : null;
+      const tasks = [];
       for (const ws2 of targets) {
         if (ws2.readyState !== import_ws.WebSocket.OPEN) continue;
         const subs = this.wsSubscriptions.get(ws2);
@@ -53894,11 +54425,18 @@ var StandaloneServer = class {
           if (hotSessionIds && !hotSessionIds.active.has(targetSessionId) && !hotSessionIds.finalizing.has(targetSessionId)) {
             continue;
           }
+          tasks.push({ ws: ws2, key, sub });
+        }
+      }
+      await (0, import_daemon_core2.runAsyncBatch)(tasks, async ({ ws: ws2, key, sub }) => {
+        try {
           const update = await this.buildChatTailUpdate(sub.request.params, sub, key);
-          if (!update || ws2.readyState !== import_ws.WebSocket.OPEN) continue;
+          if (!update || ws2.readyState !== import_ws.WebSocket.OPEN) return;
           ws2.send(JSON.stringify({ type: "topic_update", update }));
+        } catch (error48) {
+          import_daemon_core2.LOG.warn("Standalone", `[chat_tail] skipped session=${sub.request.params.targetSessionId} key=${key} error=${error48?.message || error48}`);
         }
-      }
+      }, { concurrency: 4 });
     } finally {
       this.wsChatFlushInFlight = false;
       if (this.pendingWsChatFlush) {