@adhdev/daemon-core 0.8.74 → 0.8.76

package/dist/index.js

@@ -3667,6 +3667,7 @@ __export(index_exports, {
   resolveChatMessageKind: () => resolveChatMessageKind,
   resolveDebugRuntimeConfig: () => resolveDebugRuntimeConfig,
   resolveSessionHostAppName: () => resolveSessionHostAppName,
+  runAsyncBatch: () => runAsyncBatch,
   saveConfig: () => saveConfig,
   saveState: () => saveState,
   setDebugRuntimeConfig: () => setDebugRuntimeConfig,
@@ -4451,6 +4452,32 @@ function classifyHotChatSessionsForSubscriptionFlush(sessions, previousHotSessio
 var import_ws = __toESM(require("ws"));
 var http = __toESM(require("http"));
 init_logger();
+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 DaemonCdpManager = class {
   ws = null;
   browserWs = null;
@@ -4611,18 +4638,28 @@ var DaemonCdpManager = class {
               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 || "";
@@ -6062,7 +6099,17 @@ var os5 = __toESM(require("os"));
 init_chat_message_normalization();
 var HISTORY_DIR = path7.join(os5.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();
@@ -6120,6 +6167,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, "_");
 }
@@ -6133,71 +6242,386 @@ function listHistoryFiles(dir, historySessionId) {
     return true;
   }).sort().reverse();
 }
-function buildSavedHistoryCacheSignature(dir, files) {
-  return files.map((file) => {
+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, file) {
+  const match = file.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((file) => {
     try {
       const stat = fs3.statSync(path7.join(dir, file));
-      return `${file}:${stat.size}:${Math.trunc(stat.mtimeMs)}`;
+      return [file, `${file}:${stat.size}:${Math.trunc(stat.mtimeMs)}`];
     } catch {
-      return `${file}: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 file of files) {
-    const match = file.match(filePattern);
-    if (!match?.[1]) continue;
-    const historySessionId = match[1];
-    const grouped = groupedFiles.get(historySessionId) || [];
-    grouped.push(file);
-    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 file of grouped.sort()) {
-      const filePath = path7.join(dir, file);
-      const content = fs3.readFileSync(filePath, "utf-8");
-      const lines = content.split("\n").filter(Boolean);
-      for (const line of lines) {
-        let parsed = null;
+      return [file, `${file}:missing`];
+    }
+  }));
+}
+function buildSavedHistoryCacheSignature(files, fileSignatures) {
+  return files.map((file) => fileSignatures.get(file) || `${file}: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(([file, entry]) => !!file && !!entry && typeof entry.signature === "string").map(([file, entry]) => [file, {
+        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 (error) {
+      if (error?.code !== "EEXIST") return null;
+      try {
+        const stat = fs3.statSync(lockPath);
+        if (Date.now() - stat.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();
+  }
+}
+function loadPersistedSavedHistoryIndex(dir) {
+  return loadPersistedSavedHistoryIndexFromFile(dir);
+}
+function savePersistedSavedHistoryIndex(dir, entries) {
+  withLockedPersistedSavedHistoryIndex(dir, (currentEntries) => {
+    const incomingFiles = new Set(Array.from(entries.keys()));
+    for (const [file, entry] of Array.from(entries.entries())) {
+      const liveSignature = buildSavedHistoryFileSignature(dir, file);
+      const existingEntry = currentEntries.get(file);
+      if (existingEntry && existingEntry.signature !== liveSignature && entry.signature !== liveSignature) {
+        continue;
+      }
+      if (entry.signature !== liveSignature && (!existingEntry || existingEntry.signature !== liveSignature)) {
+        continue;
+      }
+      currentEntries.set(file, entry.signature === liveSignature ? entry : {
+        signature: liveSignature,
+        summary: existingEntry?.summary || entry.summary
+      });
+    }
+    for (const file of Array.from(currentEntries.keys())) {
+      if (incomingFiles.has(file)) continue;
+      if (!fs3.existsSync(path7.join(dir, file))) {
+        currentEntries.delete(file);
+      }
+    }
+  });
+}
+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 stat = fs3.statSync(getSavedHistoryIndexFilePath(dir));
+    return `index:${stat.size}:${Math.trunc(stat.mtimeMs)}`;
+  } catch {
+    return "index:missing";
+  }
+}
+function historyDirectoryHasFilesNewerThanIndex(dir) {
+  try {
+    const indexStat = fs3.statSync(getSavedHistoryIndexFilePath(dir));
+    const files = listHistoryFiles(dir);
+    for (const file of files) {
+      const stat = fs3.statSync(path7.join(dir, file));
+      if (stat.mtimeMs > indexStat.mtimeMs) return true;
+    }
+    return false;
+  } catch {
+    return true;
+  }
+}
+function buildSavedHistoryFileSignature(dir, file) {
+  try {
+    const stat = fs3.statSync(path7.join(dir, file));
+    return `${file}:${stat.size}:${Math.trunc(stat.mtimeMs)}`;
+  } catch {
+    return `${file}:missing`;
+  }
+}
+function persistSavedHistoryFileSummaryEntry(agentType, dir, file, updater) {
+  const filePath = path7.join(dir, file);
+  const result = withLockedPersistedSavedHistoryIndex(dir, (entries) => {
+    const currentEntry = entries.get(file) || null;
+    const nextSummary = updater(currentEntry?.summary || null);
+    const nextEntry = {
+      signature: buildSavedHistoryFileSignature(dir, file),
+      summary: nextSummary
+    };
+    entries.set(file, 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, file, historySessionId, workspace) {
+  const normalizedSessionId = normalizeSavedHistorySessionId(agentType, historySessionId);
+  const normalizedWorkspace = String(workspace || "").trim();
+  if (!normalizedSessionId || !normalizedWorkspace) return;
+  persistSavedHistoryFileSummaryEntry(agentType, dir, file, (currentSummary) => ({
+    file,
+    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, file, historySessionId, messages) {
+  const normalizedSessionId = normalizeSavedHistorySessionId(agentType, historySessionId || "");
+  if (!normalizedSessionId || messages.length === 0) return;
+  persistSavedHistoryFileSummaryEntry(agentType, dir, file, (currentSummary) => {
+    const nextSummary = {
+      file,
+      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, file) {
+  const historySessionId = extractSavedHistorySessionIdFromFile(agentType, file);
+  if (!historySessionId) return null;
+  const filePath = path7.join(dir, file);
+  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,
+    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 [file, 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 file of files.slice().sort()) {
+    const filePath = path7.join(dir, file);
+    const signature = fileSignatures.get(file) || `${file}:missing`;
+    const cached = savedHistoryFileSummaryCache.get(filePath);
+    const persisted = persistedEntries.get(file);
+    const reusableEntry = cached?.signature === signature ? cached : persisted?.signature === signature ? persisted : null;
+    const fileSummary = reusableEntry?.summary || computeSavedHistoryFileSummary(agentType, dir, file);
+    const nextEntry = reusableEntry || {
+      signature,
+      summary: fileSummary
+    };
+    if (!reusableEntry) {
+      nextEntry.signature = signature;
+      nextEntry.summary = fileSummary;
+    }
+    savedHistoryFileSummaryCache.set(filePath, nextEntry);
+    nextPersistedEntries.set(file, 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;
+    }
   }
-  summaries.sort((a, b) => b.lastMessageAt - a.lastMessageAt);
-  return summaries;
+  return {
+    summaries: Array.from(summaryBySessionId.values()).sort((a, b) => b.lastMessageAt - a.lastMessageAt),
+    persistedEntries: nextPersistedEntries
+  };
 }
 var ChatHistoryWriter = class {
   /** Last seen message count per agent (deduplication) */
@@ -6272,9 +6696,11 @@ var ChatHistoryWriter = class {
       fs3.mkdirSync(dir, { recursive: true });
       const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
       const filePrefix = effectiveHistoryKey ? `${this.sanitize(effectiveHistoryKey)}_` : "";
-      const filePath = path7.join(dir, `${filePrefix}${date}.jsonl`);
+      const fileName = `${filePrefix}${date}.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();
@@ -6365,7 +6791,8 @@ var ChatHistoryWriter = class {
       const dir = path7.join(HISTORY_DIR, this.sanitize(agentType));
       fs3.mkdirSync(dir, { recursive: true });
       const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-      const filePath = path7.join(dir, `${this.sanitize(id)}_${date}.jsonl`);
+      const fileName = `${this.sanitize(id)}_${date}.jsonl`;
+      const filePath = path7.join(dir, fileName);
       const record = {
         ts: (/* @__PURE__ */ new Date()).toISOString(),
         receivedAt: Date.now(),
@@ -6378,6 +6805,7 @@ var ChatHistoryWriter = class {
         workspace: ws
       };
       fs3.appendFileSync(filePath, JSON.stringify(record) + "\n", "utf-8");
+      updateSavedHistoryIndexForSessionStart(agentType, dir, fileName, id, ws);
     } catch {
     }
   }
@@ -6443,6 +6871,7 @@ var ChatHistoryWriter = class {
         }
         fs3.unlinkSync(sourcePath);
       }
+      invalidatePersistedSavedHistoryIndex(agentType, dir);
     } catch {
     }
   }
@@ -6492,6 +6921,7 @@ var ChatHistoryWriter = class {
         fs3.writeFileSync(filePath, `${collapsed.map((entry) => JSON.stringify(entry)).join("\n")}
 `, "utf-8");
       }
+      invalidatePersistedSavedHistoryIndex(agentType, dir);
     } catch {
     }
   }
@@ -6511,13 +6941,18 @@ var ChatHistoryWriter = class {
       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 file of files) {
           const filePath = path7.join(dirPath, file);
           const stat = fs3.statSync(filePath);
           if (stat.mtimeMs < cutoff) {
             fs3.unlinkSync(filePath);
+            removedAny = true;
           }
         }
+        if (removedAny) {
+          invalidatePersistedSavedHistoryIndex(dir.name, dirPath);
+        }
       }
     } catch {
     }
@@ -6583,18 +7018,51 @@ function listSavedHistorySessions(agentType, options = {}) {
       savedHistorySessionCache.delete(sanitized);
       return { sessions: [], hasMore: false };
     }
-    const files = listHistoryFiles(dir);
-    const signature = buildSavedHistoryCacheSignature(dir, files);
     const cached = savedHistorySessionCache.get(sanitized);
-    const summaries = cached?.signature === signature ? cached.summaries : computeSavedHistorySessionSummaries(agentType, dir, files);
-    if (!cached || cached.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 (cached) {
+      const cacheLooksPersisted = cached.signature.startsWith("index:");
+      const cacheStillValid = cacheLooksPersisted ? cached.signature === indexSignature : (() => {
+        const files2 = listHistoryFiles(dir);
+        const fileSignatures2 = buildSavedHistoryFileSignatureMap(dir, files2);
+        return cached.signature === buildSavedHistoryCacheSignature(files2, fileSignatures2);
+      })();
+      if (cacheStillValid) {
+        const sliced2 = cached.summaries.slice(offset, offset + limit);
+        return {
+          sessions: sliced2,
+          hasMore: cached.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,
@@ -8347,6 +8815,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));
@@ -8430,6 +8913,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));
     }
   }
@@ -10600,7 +11084,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" };
@@ -10643,16 +11129,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);
@@ -17575,6 +18061,23 @@ function prepareSessionModalUpdate(input) {
   };
 }
 
+// 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);
+}
+
 // src/agent-stream/provider-adapter.ts
 init_read_chat_contract();
 init_chat_message_normalization();
@@ -18043,10 +18546,12 @@ var DaemonAgentStreamManager = class {
     }
   }
   /** 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;
@@ -18059,18 +18564,44 @@ var DaemonAgentStreamManager = class {
     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)}`);
@@ -18366,6 +18897,7 @@ var AgentStreamPoller = class {
       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) {
@@ -25071,6 +25603,7 @@ async function shutdownDaemonComponents(components) {
   resolveChatMessageKind,
   resolveDebugRuntimeConfig,
   resolveSessionHostAppName,
+  runAsyncBatch,
   saveConfig,
   saveState,
   setDebugRuntimeConfig,