@adhdev/daemon-standalone 0.8.75 → 0.8.77

package/dist/index.js

@@ -9244,7 +9244,7 @@ var require_dist = __commonJS({
         }
       }
     };
-    var import_crypto2 = require("crypto");
+    var import_crypto3 = require("crypto");
     var path5 = __toESM2(require("path"));
     function normalizeSlug(input) {
       return input.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48);
@@ -9360,7 +9360,7 @@ var require_dist = __commonJS({
     var SessionHostRegistry = class {
       sessions = /* @__PURE__ */ new Map();
       createSession(payload) {
-        const sessionId = payload.sessionId || (0, import_crypto2.randomUUID)();
+        const sessionId = payload.sessionId || (0, import_crypto3.randomUUID)();
         if (this.sessions.has(sessionId)) {
           throw new Error(`Session already exists: ${sessionId}`);
         }
@@ -26823,9 +26823,9 @@ var init_handler = __esm({
         if (this.fsw.closed) {
           return;
         }
-        const dirname3 = sp.dirname(file2);
+        const dirname4 = sp.dirname(file2);
         const basename3 = sp.basename(file2);
-        const parent = this.fsw._getWatchedDir(dirname3);
+        const parent = this.fsw._getWatchedDir(dirname4);
         let prevStats = stats;
         if (parent.has(basename3))
           return;
@@ -26852,7 +26852,7 @@ var init_handler = __esm({
                 prevStats = newStats2;
               }
             } catch (error48) {
-              this.fsw._remove(dirname3, basename3);
+              this.fsw._remove(dirname4, basename3);
             }
           } else if (parent.has(basename3)) {
             const at2 = newStats.atimeMs;
@@ -27927,7 +27927,7 @@ var require_dist2 = __commonJS({
       };
     }
     function generateMachineId() {
-      return `${MACHINE_ID_PREFIX}${(0, import_crypto2.randomUUID)().replace(/-/g, "")}`;
+      return `${MACHINE_ID_PREFIX}${(0, import_crypto3.randomUUID)().replace(/-/g, "")}`;
     }
     function isStableMachineId(machineId) {
       return typeof machineId === "string" && machineId.startsWith(MACHINE_ID_PREFIX);
@@ -28046,7 +28046,7 @@ var require_dist2 = __commonJS({
     var import_os2;
     var import_path2;
     var import_fs;
-    var import_crypto2;
+    var import_crypto3;
     var DEFAULT_CONFIG;
     var MACHINE_ID_PREFIX;
     var init_config = __esm2({
@@ -28055,7 +28055,7 @@ var require_dist2 = __commonJS({
         import_os2 = require("os");
         import_path2 = require("path");
         import_fs = require("fs");
-        import_crypto2 = require("crypto");
+        import_crypto3 = require("crypto");
         DEFAULT_CONFIG = {
           serverUrl: "https://api.adhf.dev",
           allowServerApiProxy: false,
@@ -31510,6 +31510,7 @@ ${data.message || ""}`.trim();
       resolveChatMessageKind: () => resolveChatMessageKind,
       resolveDebugRuntimeConfig: () => resolveDebugRuntimeConfig,
       resolveSessionHostAppName: () => resolveSessionHostAppName2,
+      runAsyncBatch: () => runAsyncBatch2,
       saveConfig: () => saveConfig,
       saveState: () => saveState,
       setDebugRuntimeConfig: () => setDebugRuntimeConfig,
@@ -32228,12 +32229,66 @@ ${data.message || ""}`.trim();
       const availableMem = darwinAvail != null ? darwinAvail : freeMem;
       return { totalMem, freeMem, availableMem };
     }
+    var LIVE_LIFECYCLES = /* @__PURE__ */ new Set(["starting", "running", "stopping", "interrupted"]);
+    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 DEFAULT_ACTIVE_CHAT_POLL_STATUSES = /* @__PURE__ */ new Set([
       "generating",
       "waiting_approval",
       "starting"
     ]);
     var DEFAULT_CHAT_TAIL_RECENT_MESSAGE_GRACE_MS = 8e3;
+    var LIVE_RUNTIME_LIFECYCLES = /* @__PURE__ */ new Set(["starting", "running", "stopping", "interrupted"]);
     function parseMessageTimestamp(value) {
       if (typeof value === "number" && Number.isFinite(value)) return value;
       if (typeof value === "string") {
@@ -32242,6 +32297,23 @@ ${data.message || ""}`.trim();
       }
       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 classifyHotChatSessionsForSubscriptionFlush2(sessions, previousHotSessionIds, options = {}) {
       const now = options.now ?? Date.now();
       const recentMessageGraceMs = Math.max(
@@ -32250,9 +32322,14 @@ ${data.message || ""}`.trim();
       );
       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;
@@ -32261,13 +32338,39 @@ ${data.message || ""}`.trim();
         }
       }
       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 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 +32531,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 +33980,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 +34048,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 +34123,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);
+        }
+      }
+      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";
       }
-      summaries.sort((a, b2) => b2.lastMessageAt - a.lastMessageAt);
-      return summaries;
+    }
+    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 +34577,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 +34672,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 +34686,7 @@ ${cleanBody}`;
             workspace: ws2
           };
           fs32.appendFileSync(filePath, JSON.stringify(record2) + "\n", "utf-8");
+          updateSavedHistoryIndexForSessionStart(agentType, dir, fileName, id, ws2);
         } catch {
         }
       }
@@ -34248,6 +34752,7 @@ ${cleanBody}`;
             }
             fs32.unlinkSync(sourcePath);
           }
+          invalidatePersistedSavedHistoryIndex(agentType, dir);
         } catch {
         }
       }
@@ -34297,6 +34802,7 @@ ${cleanBody}`;
             fs32.writeFileSync(filePath, `${collapsed.map((entry) => JSON.stringify(entry)).join("\n")}
 `, "utf-8");
           }
+          invalidatePersistedSavedHistoryIndex(agentType, dir);
         } catch {
         }
       }
@@ -34316,13 +34822,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 +34899,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,
@@ -36013,7 +36557,7 @@ ${effect.notification.body || ""}`.trim();
       return profile !== "live";
     }
     function shouldIncludeRuntimeMetadata(profile) {
-      return profile !== "live";
+      return true;
     }
     function findCdpManager(cdpManagers, key) {
       const exact = cdpManagers.get(key);
@@ -36128,6 +36672,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));
@@ -36153,8 +36712,12 @@ ${effect.notification.body || ""}`.trim();
           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,
@@ -36211,6 +36774,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 +38915,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 +38960,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);
@@ -39398,8 +39964,12 @@ ${effect.notification.body || ""}`.trim();
             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,
@@ -43681,59 +44251,6 @@ Run 'adhdev doctor' for detailed diagnostics.`
     }
     cleanOldFiles();
     init_logger();
-    var LIVE_LIFECYCLES = /* @__PURE__ */ new Set(["starting", "running", "stopping", "interrupted"]);
-    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 os16 = __toESM2(require("os"));
     init_config();
     init_terminal_screen();
@@ -45277,6 +45794,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 +46274,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 +46292,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 +46623,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) {
@@ -52017,6 +52578,8 @@ data: ${JSON.stringify(msg.data)}
           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
@@ -52619,6 +53182,7 @@ var import_ws = require("ws");
 var path4 = __toESM(require("path"));
 var fs3 = __toESM(require("fs"));
 var os5 = __toESM(require("os"));
+var import_crypto2 = require("crypto");
 var import_daemon_core2 = __toESM(require_dist2());
 
 // src/session-host.ts
@@ -53124,6 +53688,165 @@ async function getWorkspaceSocketInfo(workspaceName) {
 var import_daemon_core3 = __toESM(require_dist2());
 var DEFAULT_PORT = 3847;
 var STATUS_INTERVAL = 2e3;
+var STANDALONE_AUTH_SESSION_COOKIE = "adhdev_standalone_session";
+var STANDALONE_PASSWORD_CONFIG_FILE = "standalone-auth.json";
+var STANDALONE_BIND_HOST_CONFIG_FILE = "standalone-network.json";
+var STANDALONE_BIND_HOST_DEFAULT = "127.0.0.1";
+var PASSWORD_KEYLEN = 64;
+var DEFAULT_SESSION_TTL_MS = 1e3 * 60 * 60 * 24 * 30;
+function getStandalonePasswordConfigPath() {
+  const dir = path4.join(os5.homedir(), ".adhdev");
+  if (!fs3.existsSync(dir)) {
+    fs3.mkdirSync(dir, { recursive: true, mode: 448 });
+  }
+  return path4.join(dir, STANDALONE_PASSWORD_CONFIG_FILE);
+}
+function getStandaloneConfigJsonPath() {
+  const dir = path4.join(os5.homedir(), ".adhdev");
+  if (!fs3.existsSync(dir)) {
+    fs3.mkdirSync(dir, { recursive: true, mode: 448 });
+  }
+  return path4.join(dir, STANDALONE_BIND_HOST_CONFIG_FILE);
+}
+function loadStandaloneBindHostPreference() {
+  try {
+    const configPath = getStandaloneConfigJsonPath();
+    if (!fs3.existsSync(configPath)) return STANDALONE_BIND_HOST_DEFAULT;
+    const parsed = JSON.parse(fs3.readFileSync(configPath, "utf8"));
+    return parsed?.standaloneBindHost === "0.0.0.0" ? "0.0.0.0" : STANDALONE_BIND_HOST_DEFAULT;
+  } catch {
+    return STANDALONE_BIND_HOST_DEFAULT;
+  }
+}
+function saveStandaloneBindHostPreference(bindHost) {
+  const configPath = getStandaloneConfigJsonPath();
+  let parsed = {};
+  try {
+    if (fs3.existsSync(configPath)) {
+      const raw = fs3.readFileSync(configPath, "utf8");
+      const next = JSON.parse(raw);
+      if (next && typeof next === "object" && !Array.isArray(next)) parsed = next;
+    }
+  } catch {
+    parsed = {};
+  }
+  parsed.standaloneBindHost = bindHost;
+  fs3.writeFileSync(configPath, JSON.stringify(parsed, null, 2), { encoding: "utf8", mode: 384 });
+  try {
+    fs3.chmodSync(configPath, 384);
+  } catch {
+  }
+  return bindHost;
+}
+function createPasswordRecord(password, salt = (0, import_crypto2.randomBytes)(16).toString("hex")) {
+  return {
+    passwordHash: (0, import_crypto2.scryptSync)(`${password || ""}`, salt, PASSWORD_KEYLEN).toString("hex"),
+    passwordSalt: salt,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function verifyPassword(password, config2) {
+  if (!config2?.passwordHash || !config2.passwordSalt) return false;
+  const actual = Buffer.from((0, import_crypto2.scryptSync)(`${password || ""}`, config2.passwordSalt, PASSWORD_KEYLEN).toString("hex"), "utf8");
+  const expected = Buffer.from(config2.passwordHash, "utf8");
+  return actual.length === expected.length && (0, import_crypto2.timingSafeEqual)(actual, expected);
+}
+function loadStandalonePasswordConfig(filePath = getStandalonePasswordConfigPath()) {
+  if (!fs3.existsSync(filePath)) return null;
+  try {
+    const parsed = JSON.parse(fs3.readFileSync(filePath, "utf8"));
+    if (!parsed || typeof parsed !== "object") return null;
+    if (typeof parsed.passwordHash !== "string" || typeof parsed.passwordSalt !== "string") return null;
+    return {
+      passwordHash: parsed.passwordHash,
+      passwordSalt: parsed.passwordSalt,
+      updatedAt: typeof parsed.updatedAt === "string" ? parsed.updatedAt : (/* @__PURE__ */ new Date(0)).toISOString()
+    };
+  } catch {
+    return null;
+  }
+}
+function saveStandalonePasswordConfig(filePath, config2) {
+  const dir = path4.dirname(filePath);
+  if (!fs3.existsSync(dir)) {
+    fs3.mkdirSync(dir, { recursive: true, mode: 448 });
+  }
+  fs3.writeFileSync(filePath, JSON.stringify(config2, null, 2), { encoding: "utf8", mode: 384 });
+  try {
+    fs3.chmodSync(filePath, 384);
+  } catch {
+  }
+}
+function clearStandalonePasswordConfig(filePath = getStandalonePasswordConfigPath()) {
+  if (fs3.existsSync(filePath)) {
+    fs3.rmSync(filePath, { force: true });
+  }
+}
+function shouldWarnForPublicUnauthenticatedHost(input) {
+  return input.host === "0.0.0.0" && !input.hasTokenAuth && !input.hasPasswordAuth;
+}
+function parseCookies(cookieHeader) {
+  if (!cookieHeader) return {};
+  return Object.fromEntries(
+    cookieHeader.split(";").map((part) => part.trim()).filter(Boolean).map((part) => {
+      const eq = part.indexOf("=");
+      if (eq === -1) return [part, ""];
+      return [part.slice(0, eq), decodeURIComponent(part.slice(eq + 1))];
+    })
+  );
+}
+function buildSessionCookie(sessionId, secure, maxAgeMs = DEFAULT_SESSION_TTL_MS) {
+  const parts = [
+    `${STANDALONE_AUTH_SESSION_COOKIE}=${encodeURIComponent(sessionId)}`,
+    "Path=/",
+    "HttpOnly",
+    "SameSite=Lax",
+    `Max-Age=${Math.max(0, Math.floor(maxAgeMs / 1e3))}`
+  ];
+  if (secure) parts.push("Secure");
+  return parts.join("; ");
+}
+function buildClearedSessionCookie(secure) {
+  return buildSessionCookie("", secure, 0);
+}
+var StandaloneSessionStore = class {
+  sessions = /* @__PURE__ */ new Map();
+  create(ttlMs = DEFAULT_SESSION_TTL_MS) {
+    const id = (0, import_crypto2.randomBytes)(24).toString("hex");
+    this.sessions.set(id, Date.now() + ttlMs);
+    return id;
+  }
+  has(sessionId) {
+    if (!sessionId) return false;
+    const expiresAt = this.sessions.get(sessionId);
+    if (!expiresAt) return false;
+    if (expiresAt <= Date.now()) {
+      this.sessions.delete(sessionId);
+      return false;
+    }
+    return true;
+  }
+  revoke(sessionId) {
+    if (!sessionId) return;
+    this.sessions.delete(sessionId);
+  }
+  clear() {
+    this.sessions.clear();
+  }
+};
+function isStandaloneRequestAuthenticated(input) {
+  const hasTokenAuth = !!input.configuredToken;
+  const hasPasswordAuth = !!input.passwordConfig;
+  if (!hasTokenAuth && !hasPasswordAuth) return true;
+  if (hasTokenAuth && (input.bearerToken === input.configuredToken || input.queryToken === input.configuredToken)) {
+    return true;
+  }
+  if (hasPasswordAuth) {
+    const cookies = parseCookies(input.cookieHeader);
+    return input.sessionStore.has(cookies[STANDALONE_AUTH_SESSION_COOKIE]);
+  }
+  return false;
+}
 var pkgVersion = process.env.ADHDEV_PKG_VERSION || "unknown";
 if (pkgVersion === "unknown") {
   try {
@@ -53172,6 +53895,10 @@ var StandaloneServer = class {
   wsSessionModalSubscriptions = /* @__PURE__ */ new Map();
   wsDaemonMetadataSubscriptions = /* @__PURE__ */ new Map();
   authToken = null;
+  passwordConfigPath = getStandalonePasswordConfigPath();
+  passwordConfig = null;
+  authSessions = new StandaloneSessionStore();
+  listenHost = "127.0.0.1";
   statusTimer = null;
   lastStatusBroadcastAt = 0;
   statusBroadcastPending = false;
@@ -53228,10 +53955,88 @@ var StandaloneServer = class {
     const mode = this.getCliPresentationMode(sessionId);
     return mode === "chat" || mode === "terminal";
   }
+  hasPasswordAuth() {
+    return !!this.passwordConfig;
+  }
+  hasAnyAuth() {
+    return !!this.authToken || this.hasPasswordAuth();
+  }
+  getCookieSecureFlag(req) {
+    const forwardedProto = req.headers["x-forwarded-proto"];
+    return !!req.socket.encrypted || typeof forwardedProto === "string" && forwardedProto.toLowerCase().includes("https");
+  }
+  getRequestTokens(req, rawUrl) {
+    const authHeader = req.headers["authorization"];
+    const bearerToken = typeof authHeader === "string" && authHeader.startsWith("Bearer ") ? authHeader.slice(7) : null;
+    const queryToken = new URL(rawUrl, `http://${req.headers.host || "localhost"}`).searchParams.get("token");
+    return { bearerToken, queryToken };
+  }
+  isRequestAuthenticated(req, rawUrl) {
+    const { bearerToken, queryToken } = this.getRequestTokens(req, rawUrl);
+    return isStandaloneRequestAuthenticated({
+      configuredToken: this.authToken,
+      passwordConfig: this.passwordConfig,
+      bearerToken,
+      queryToken,
+      cookieHeader: typeof req.headers.cookie === "string" ? req.headers.cookie : void 0,
+      sessionStore: this.authSessions
+    });
+  }
+  getRequestSessionId(req) {
+    const cookies = parseCookies(typeof req.headers.cookie === "string" ? req.headers.cookie : void 0);
+    return cookies.adhdev_standalone_session || null;
+  }
+  buildAuthStatus(req, rawUrl) {
+    const required2 = this.hasAnyAuth();
+    return {
+      required: required2,
+      authenticated: this.isRequestAuthenticated(req, rawUrl),
+      hasTokenAuth: !!this.authToken,
+      hasPasswordAuth: this.hasPasswordAuth(),
+      publicHostWarning: shouldWarnForPublicUnauthenticatedHost({
+        host: this.listenHost,
+        hasTokenAuth: !!this.authToken,
+        hasPasswordAuth: this.hasPasswordAuth()
+      }),
+      boundHost: this.listenHost
+    };
+  }
+  isTrustedStandaloneMutationRequest(req) {
+    const originHeader = req.headers.origin;
+    if (typeof originHeader !== "string" || !originHeader.trim()) return true;
+    try {
+      const origin = new URL(originHeader);
+      const host = req.headers.host || "";
+      return origin.host === host;
+    } catch {
+      return false;
+    }
+  }
+  async readJsonBody(req) {
+    return await new Promise((resolve4, reject) => {
+      let body = "";
+      req.on("data", (chunk) => {
+        body += chunk;
+      });
+      req.on("end", () => {
+        try {
+          resolve4(body ? JSON.parse(body) : {});
+        } catch (error48) {
+          reject(error48);
+        }
+      });
+      req.on("error", reject);
+    });
+  }
   async start(options = {}) {
-    const port = options.port || DEFAULT_PORT;
-    const host = options.host || "127.0.0.1";
+    const persistedStandaloneBindHost = loadStandaloneBindHostPreference();
     const cfg = (0, import_daemon_core2.loadConfig)();
+    if (!options.host && persistedStandaloneBindHost !== STANDALONE_BIND_HOST_DEFAULT) {
+      saveStandaloneBindHostPreference(persistedStandaloneBindHost);
+    }
+    const port = options.port || DEFAULT_PORT;
+    const host = options.host || persistedStandaloneBindHost;
+    this.listenHost = host;
     const sessionHostEndpoint = await ensureSessionHostReady();
     this.sessionHostEndpoint = sessionHostEndpoint;
     const sessionHostControl = new StandaloneSessionHostControlPlane(
@@ -53239,6 +54044,7 @@ var StandaloneServer = class {
     );
     this.sessionHostControl = sessionHostControl;
     this.authToken = options.token || process.env.ADHDEV_TOKEN || null;
+    this.passwordConfig = loadStandalonePasswordConfig(this.passwordConfigPath);
     const statusInstanceId = `standalone_${cfg.machineId || "mach_unknown"}`;
     this.components = await (0, import_daemon_core2.initDaemonComponents)({
       cliManagerDeps: {
@@ -53256,7 +54062,7 @@ var StandaloneServer = class {
         }),
         onStatusChange: () => {
           this.scheduleBroadcastStatus();
-          void this.flushWsChatSubscriptions(void 0, { onlyActive: false });
+          void this.flushWsChatSubscriptions(void 0, { onlyActive: true });
         },
         removeAgentTracking: () => {
         },
@@ -53285,7 +54091,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) => {
@@ -53312,13 +54118,10 @@ var StandaloneServer = class {
     this.httpServer.on("upgrade", (req, socket, head) => {
       const wsUrl = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
       if (wsUrl.pathname === "/ws") {
-        if (this.authToken) {
-          const urlToken = wsUrl.searchParams.get("token");
-          if (urlToken !== this.authToken) {
-            socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
-            socket.destroy();
-            return;
-          }
+        if (!this.isRequestAuthenticated(req, req.url || "/")) {
+          socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
+          socket.destroy();
+          return;
         }
         this.wss.handleUpgrade(req, socket, head, (ws2) => {
           this.handleWsConnection(ws2);
@@ -53351,7 +54154,14 @@ var StandaloneServer = class {
       }
     }
     if (this.authToken) {
-      console.log(`   \u{1F511} Token: ${this.authToken}`);
+      console.log("   \u{1F511} Token auth: enabled");
+    }
+    if (this.passwordConfig) {
+      console.log("   \u{1F510} Password auth: enabled");
+    }
+    if (shouldWarnForPublicUnauthenticatedHost({ host, hasTokenAuth: !!this.authToken, hasPasswordAuth: !!this.passwordConfig })) {
+      console.warn("   \u26A0\uFE0F  Public host mode is enabled without any auth.");
+      console.warn("      Anyone on your LAN can open and control this dashboard until you set a password or token.");
     }
     console.log("");
     const cdpCount = [...this.components.cdpManagers.values()].filter((m) => m.isConnected).length;
@@ -53391,18 +54201,148 @@ var StandaloneServer = class {
       res.end();
       return;
     }
-    if (this.authToken && url2.startsWith("/api/")) {
-      const authHeader = req.headers["authorization"];
-      const bearerToken = authHeader?.startsWith("Bearer ") ? authHeader.slice(7) : null;
-      const queryToken = new URL(url2, `http://${req.headers.host || "localhost"}`).searchParams.get("token");
-      if (bearerToken !== this.authToken && queryToken !== this.authToken) {
-        res.writeHead(401, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ error: "Unauthorized. Provide token via Authorization header or ?token= query." }));
-        return;
-      }
+    const parsedUrl = new URL(url2, `http://${req.headers.host || "localhost"}`);
+    if (parsedUrl.pathname === "/auth/session" && method === "GET") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(this.buildAuthStatus(req, url2)));
+      return;
+    }
+    if (parsedUrl.pathname === "/auth/login" && method === "POST") {
+      void (async () => {
+        if (!this.passwordConfig) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Password auth is not configured." }));
+          return;
+        }
+        const body = await this.readJsonBody(req);
+        if (!verifyPassword(typeof body.password === "string" ? body.password : "", this.passwordConfig)) {
+          res.writeHead(401, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Incorrect password." }));
+          return;
+        }
+        this.authSessions.clear();
+        const sessionId = this.authSessions.create();
+        res.setHeader("Set-Cookie", buildSessionCookie(sessionId, this.getCookieSecureFlag(req)));
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ...this.buildAuthStatus(req, url2), authenticated: true }));
+      })().catch((error48) => {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: error48?.message || String(error48) }));
+      });
+      return;
+    }
+    if (parsedUrl.pathname === "/auth/logout" && method === "POST") {
+      this.authSessions.revoke(this.getRequestSessionId(req));
+      res.setHeader("Set-Cookie", buildClearedSessionCookie(this.getCookieSecureFlag(req)));
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: true }));
+      return;
+    }
+    if (parsedUrl.pathname === "/auth/password" && method === "POST") {
+      void (async () => {
+        if (!this.hasAnyAuth() && !this.isTrustedStandaloneMutationRequest(req)) {
+          res.writeHead(403, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Cross-origin standalone settings changes are not allowed without existing auth." }));
+          return;
+        }
+        if (this.hasAnyAuth() && !this.isRequestAuthenticated(req, url2)) {
+          res.writeHead(401, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Unauthorized" }));
+          return;
+        }
+        const body = await this.readJsonBody(req);
+        const currentPassword = typeof body.currentPassword === "string" ? body.currentPassword : "";
+        const newPassword = typeof body.newPassword === "string" ? body.newPassword : "";
+        const clearPassword = body.clear === true;
+        if (this.passwordConfig && !verifyPassword(currentPassword, this.passwordConfig)) {
+          res.writeHead(403, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Current password is incorrect." }));
+          return;
+        }
+        if (clearPassword) {
+          clearStandalonePasswordConfig(this.passwordConfigPath);
+          this.passwordConfig = null;
+          this.authSessions.clear();
+          res.setHeader("Set-Cookie", buildClearedSessionCookie(this.getCookieSecureFlag(req)));
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ success: true, ...this.buildAuthStatus(req, url2), authenticated: !this.hasAnyAuth() }));
+          return;
+        }
+        if (newPassword.trim().length < 4) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Password must be at least 4 characters." }));
+          return;
+        }
+        const nextConfig = createPasswordRecord(newPassword.trim());
+        saveStandalonePasswordConfig(this.passwordConfigPath, nextConfig);
+        this.passwordConfig = nextConfig;
+        this.authSessions.clear();
+        const sessionId = this.authSessions.create();
+        res.setHeader("Set-Cookie", buildSessionCookie(sessionId, this.getCookieSecureFlag(req)));
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ success: true, ...this.buildAuthStatus(req, url2), authenticated: true }));
+      })().catch((error48) => {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: error48?.message || String(error48) }));
+      });
+      return;
+    }
+    if (parsedUrl.pathname === "/api/v1/standalone/preferences" && method === "GET") {
+      const configuredBindHost = loadStandaloneBindHostPreference();
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({
+        standaloneBindHost: configuredBindHost,
+        currentBindHost: this.listenHost,
+        hasPasswordAuth: !!this.passwordConfig,
+        hasTokenAuth: !!this.authToken,
+        publicHostWarning: shouldWarnForPublicUnauthenticatedHost({
+          host: configuredBindHost,
+          hasTokenAuth: !!this.authToken,
+          hasPasswordAuth: !!this.passwordConfig
+        })
+      }));
+      return;
+    }
+    if (parsedUrl.pathname === "/api/v1/standalone/preferences" && method === "POST") {
+      void (async () => {
+        if (!this.hasAnyAuth() && !this.isTrustedStandaloneMutationRequest(req)) {
+          res.writeHead(403, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Cross-origin standalone settings changes are not allowed without existing auth." }));
+          return;
+        }
+        if (this.hasAnyAuth() && !this.isRequestAuthenticated(req, url2)) {
+          res.writeHead(401, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Unauthorized" }));
+          return;
+        }
+        const body = await this.readJsonBody(req);
+        const nextHost = body?.standaloneBindHost === "0.0.0.0" ? "0.0.0.0" : "127.0.0.1";
+        const savedHost = saveStandaloneBindHostPreference(nextHost);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({
+          success: true,
+          standaloneBindHost: savedHost,
+          currentBindHost: this.listenHost,
+          hasPasswordAuth: !!this.passwordConfig,
+          hasTokenAuth: !!this.authToken,
+          publicHostWarning: shouldWarnForPublicUnauthenticatedHost({
+            host: savedHost,
+            hasTokenAuth: !!this.authToken,
+            hasPasswordAuth: !!this.passwordConfig
+          })
+        }));
+      })().catch((error48) => {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: error48?.message || String(error48) }));
+      });
+      return;
+    }
+    if (url2.startsWith("/api/") && !this.isRequestAuthenticated(req, url2)) {
+      res.writeHead(401, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Unauthorized. Provide dashboard session cookie or token auth." }));
+      return;
     }
     const apiPath = url2.startsWith("/api/v1/") ? url2.slice(7) : null;
-    const parsedUrl = new URL(url2, `http://${req.headers.host || "localhost"}`);
     if (apiPath === "/status" && method === "GET") {
       const status = this.getStatus(getSharedSnapshot());
       res.writeHead(200, { "Content-Type": "application/json" });
@@ -53885,6 +54825,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 +54835,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) {
@@ -54282,6 +55230,7 @@ async function main() {
     process.exit(exitCode);
   }
   const options = {};
+  let hostExplicit = false;
   for (let i = 0; i < args.length; i++) {
     if ((args[i] === "--port" || args[i] === "-p") && args[i + 1]) {
       options.port = parseInt(args[i + 1]);
@@ -54289,6 +55238,7 @@ async function main() {
     }
     if (args[i] === "--host" || args[i] === "-H") {
       options.host = "0.0.0.0";
+      hostExplicit = true;
     }
     if (args[i] === "--public" && args[i + 1]) {
       options.publicDir = args[i + 1];
@@ -54330,6 +55280,9 @@ Runtime commands:
       process.exit(0);
     }
   }
+  if (!hostExplicit) {
+    options.host = loadStandaloneBindHostPreference();
+  }
   if (!options.publicDir) {
     const candidates = [
       path4.join(__dirname, "../../web-standalone/dist"),
@@ -54345,6 +55298,9 @@ Runtime commands:
   }
   const server = new StandaloneServer();
   await server.start(options);
+  if (!hostExplicit) {
+    saveStandaloneBindHostPreference(options.host === "0.0.0.0" ? "0.0.0.0" : "127.0.0.1");
+  }
   await new Promise(() => {
   });
 }