@threadbase-sh/streamer 1.61.0 → 1.61.2

package/dist/cli.cjs

@@ -6146,8 +6146,15 @@ var init_logger = __esm({
 });
 
 // src/feature-flags.ts
+function isFeatureFlagId(id) {
+  return Object.hasOwn(FEATURE_FLAGS, id);
+}
+function getFeatureFlag(id) {
+  return { id, ...FEATURE_FLAGS[id] };
+}
 function findFeatureFlag(id) {
-  return FEATURE_FLAGS.find((f2) => f2.id === id);
+  if (!isFeatureFlagId(id)) return void 0;
+  return getFeatureFlag(id);
 }
 function parseBooleanEnv(raw2) {
   if (raw2 === void 0) return void 0;
@@ -6169,10 +6176,11 @@ function validateFeatureFlagValues(raw2) {
   }
   if (dropped.length > 0) {
     getLogger("feature-flags").warn(
-      `Ignoring unknown or non-boolean feature flags: ${dropped.join(", ")}`,
+      `Ignoring unknown or non-boolean feature flags: ${dropped.join(", ")}. Known ids (FEATURE_FLAGS keys, not env names): ${FEATURE_FLAG_IDS.join(", ")}`,
       {
         event: "config.feature_flags_dropped",
-        dropped
+        dropped,
+        known: FEATURE_FLAG_IDS
       }
     );
   }
@@ -6188,7 +6196,7 @@ function parseFeatureFlagArgs(entries) {
     const def = findFeatureFlag(id);
     if (!def) {
       errors.push(
-        `Unknown feature flag "${id}". Known flags: ${FEATURE_FLAGS.map((f2) => f2.id).join(", ")}`
+        `Unknown feature flag "${id}". Known flags (FEATURE_FLAGS keys, not env names): ${FEATURE_FLAG_IDS.join(", ")}`
       );
       continue;
     }
@@ -6204,7 +6212,7 @@ function resolveFeatureFlags(opts) {
   const env = opts?.env ?? process.env;
   const values = {};
   const sources = {};
-  for (const def of FEATURE_FLAGS) {
+  for (const def of FEATURE_FLAG_LIST) {
     const rungs = [
       ["override", opts?.override?.[def.id]],
       ["env", parseBooleanEnv(env[def.env])],
@@ -6218,50 +6226,50 @@ function resolveFeatureFlags(opts) {
   return { values, sources };
 }
 function nonDefaultFeatureFlags(values) {
-  return FEATURE_FLAGS.filter((f2) => values[f2.id] !== f2.default).map((f2) => f2.id);
+  return FEATURE_FLAG_LIST.filter((f2) => values[f2.id] !== f2.default).map((f2) => f2.id);
 }
 function describeFeatureFlags(resolution) {
-  return FEATURE_FLAGS.map(
+  return FEATURE_FLAG_LIST.map(
     (f2) => `${f2.id}=${resolution.values[f2.id]}(${resolution.sources[f2.id]})`
   ).join(" ");
 }
-var FEATURE_FLAGS;
+var FEATURE_FLAGS, FEATURE_FLAG_IDS, FEATURE_FLAG_LIST;
 var init_feature_flags = __esm({
   "src/feature-flags.ts"() {
     "use strict";
     init_logger();
-    FEATURE_FLAGS = [
-      {
-        id: "codexSystemPrompt",
+    FEATURE_FLAGS = {
+      codexSystemPrompt: {
         description: "Send the built system prompt to fresh Codex sessions. Off by default: Codex has no --system-prompt flag, so the prompt goes in the positional [PROMPT] argument, which Codex treats as the user's opening turn rather than a system-level instruction.",
         default: false,
         env: "THREADBASE_FEATURE_CODEX_SYSTEM_PROMPT"
       },
-      {
-        id: "sessionRehydration",
+      sessionRehydration: {
         description: "Seed the session list at boot with sessions a previous streamer run left behind, so a restart leaves them one tap from resuming instead of silently gone. On by default, with a kill switch: it changes what GET /api/sessions contains.",
         default: true,
         env: "THREADBASE_FEATURE_SESSION_REHYDRATION"
       },
-      {
-        id: "liveActivityPush",
+      liveActivityPush: {
         description: "Drive iOS Live Activity surfaces for running sessions. Off by default: the streamer half needs an APNs p8 and a registered push-to-start token, and without both, mobile falls back to starting the activity locally \u2014 which freezes the moment the app backgrounds and expires silently after ~8h. Mobile reads this flag and skips its local path too, so one switch turns the whole surface off.",
         default: false,
         env: "THREADBASE_FEATURE_LIVE_ACTIVITY_PUSH"
       },
-      {
-        id: "e2ee",
+      e2ee: {
         description: "Application-layer encryption between a paired device and this server, independent of TLS, so a tunnel or a LAN observer on the path carries ciphertext. Off by default: it is negotiated per device, never forced, because released mobile builds cannot be force-updated and a server that demanded it would break every one of them.",
         default: false,
         env: "THREADBASE_FEATURE_E2EE"
       },
-      {
-        id: "ptyHost",
+      ptyHost: {
         description: "Keep live PTYs in a separate host process so a streamer restart can reconnect without restarting the agents. Off by default until cross-platform behavior is qualified.",
         default: false,
         env: "THREADBASE_FEATURE_PTY_HOST"
       }
-    ];
+    };
+    FEATURE_FLAG_IDS = Object.keys(FEATURE_FLAGS);
+    FEATURE_FLAG_LIST = FEATURE_FLAG_IDS.map((id) => ({
+      id,
+      ...FEATURE_FLAGS[id]
+    }));
   }
 });
 
@@ -140828,18 +140836,43 @@ function readGitBranch(projectPath) {
   log15.trace({ projectPath }, "git: no .git found within depth");
   return null;
 }
+var FTS_HIT_OPEN = "";
+var FTS_HIT_CLOSE = "";
+var FTS_SNIPPET_TOKENS = 16;
+var FTS_ELLIPSIS = "\u2026";
+var CONTENT_FIELD = "content";
+function parseFtsSnippet(raw2) {
+  if (!raw2?.includes(FTS_HIT_OPEN)) return null;
+  const highlights = [];
+  let snippet = "";
+  let openAt = -1;
+  for (const ch of raw2) {
+    if (ch === FTS_HIT_OPEN) {
+      openAt = snippet.length;
+      continue;
+    }
+    if (ch === FTS_HIT_CLOSE) {
+      if (openAt >= 0 && snippet.length > openAt) {
+        highlights.push({ start: openAt, end: snippet.length });
+      }
+      openAt = -1;
+      continue;
+    }
+    snippet += ch;
+  }
+  return highlights.length > 0 ? { snippet, highlights } : null;
+}
 function generateMatches(meta3, query) {
   const matches = [];
   const lowerQuery = query.toLowerCase();
   const fields = [
-    ["contentSnippet", meta3.contentSnippet],
-    ["projectName", meta3.projectName],
-    ["sessionId", meta3.sessionId],
     ["sessionName", meta3.sessionName],
-    ["account", meta3.account],
-    ["model", meta3.model || ""],
+    ["projectName", meta3.projectName],
     ["gitBranch", meta3.gitBranch || ""],
-    ["toolNames", meta3.toolNames.join(" ")]
+    ["toolNames", meta3.toolNames.join(" ")],
+    ["model", meta3.model || ""],
+    ["account", meta3.account],
+    ["sessionId", meta3.sessionId]
   ];
   for (const [field, value] of fields) {
     const idx = value.toLowerCase().indexOf(lowerQuery);
@@ -140854,11 +140887,29 @@ function generateMatches(meta3, query) {
   }
   return matches.length > 0 ? matches : [{ field: "preview", snippet: meta3.preview }];
 }
+function buildContentMatch(searchContent, query) {
+  if (!searchContent || !query.trim()) return null;
+  const idx = searchContent.toLowerCase().indexOf(query.toLowerCase());
+  if (idx === -1) return null;
+  const start = Math.max(0, idx - 80);
+  const end = Math.min(searchContent.length, idx + query.length + 120);
+  const body = searchContent.slice(start, end).replace(/\s+/g, " ").trim();
+  const hitAt = body.toLowerCase().indexOf(query.toLowerCase());
+  const prefix = start > 0 ? FTS_ELLIPSIS : "";
+  const suffix = end < searchContent.length ? FTS_ELLIPSIS : "";
+  const snippet = `${prefix}${body}${suffix}`;
+  const highlights = hitAt === -1 ? [] : [{ start: hitAt + prefix.length, end: hitAt + prefix.length + query.length }];
+  return { field: CONTENT_FIELD, snippet, highlights };
+}
 var FlexSearch = flexsearch_bundle_module_min_default.default ?? flexsearch_bundle_module_min_default;
 var SearchIndexer = class {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   index;
   documents = /* @__PURE__ */ new Map();
+  // The indexed body per conversation, kept so a hit can produce a real excerpt
+  // instead of falling back to an unrelated preview. Sized by the caller (the
+  // scanner tail-caps it to the content tier) — see the note on addDocument.
+  searchContents = /* @__PURE__ */ new Map();
   constructor() {
     this.index = this.createIndex();
   }
@@ -140884,25 +140935,25 @@ var SearchIndexer = class {
       cache: 100
     });
   }
-  addDocument(meta3) {
+  // `searchContent` is the combined search document (text + thinking + tools),
+  // NOT meta.contentSnippet.
+  //
+  // It arrives pre-capped. This index is `tokenize: "forward"` at resolution 9,
+  // which stores every prefix of every token, so it is a resident-memory
+  // structure whose cost is very different from the on-disk FTS index. Feeding
+  // it the full ~128 KB budget across a few hundred conversations would be a
+  // multi-hundred-MB-to-GB index. The scanner therefore caps this to the active
+  // tier's snippetMax and accepts that `persistent: false` has lower recall than
+  // SQLite — an honest, documented divergence rather than a silent one.
+  addDocument(meta3, searchContent = "") {
     this.documents.set(meta3.id, meta3);
-    this.index.add({
-      id: meta3.id,
-      content: meta3.contentSnippet,
-      projectName: meta3.projectName,
-      projectPath: meta3.projectPath,
-      sessionId: meta3.sessionId,
-      sessionName: meta3.sessionName,
-      account: meta3.account,
-      model: meta3.model || "",
-      gitBranch: meta3.gitBranch || "",
-      toolNames: meta3.toolNames.join(" ")
-    });
+    this.searchContents.set(meta3.id, searchContent);
+    this.index.add(toIndexDoc(meta3, searchContent));
   }
-  buildIndex(metas) {
+  buildIndex(metas, searchContents) {
     this.clear();
     for (const meta3 of metas) {
-      this.addDocument(meta3);
+      this.addDocument(meta3, searchContents?.get(meta3.id) ?? "");
     }
     getLogger2().debug({ docCount: metas.length }, "indexer: built");
   }
@@ -140922,14 +140973,26 @@ var SearchIndexer = class {
         seen.add(id);
         const meta3 = this.documents.get(id);
         if (!meta3) continue;
-        const matches = generateMatches(meta3, query);
-        searchResults.push({ meta: meta3, score: 1, matches });
+        searchResults.push({
+          meta: meta3,
+          score: 1,
+          matches: this.matchesFor(meta3, query)
+        });
         if (searchResults.length >= limit) break;
       }
       if (searchResults.length >= limit) break;
     }
     return searchResults;
   }
+  // Body context first (that is what explains why the result appeared), then any
+  // metadata matches. Only when neither hits does generateMatches' preview
+  // fallback stand in.
+  matchesFor(meta3, query) {
+    const contentMatch = buildContentMatch(this.searchContents.get(meta3.id) ?? "", query);
+    const metaMatches = generateMatches(meta3, query);
+    if (!contentMatch) return metaMatches;
+    return [contentMatch, ...metaMatches.filter((m2) => m2.field !== "preview")];
+  }
   getRecent(limit) {
     return Array.from(this.documents.values()).sort((a, b2) => b2.timestamp.localeCompare(a.timestamp)).slice(0, limit).map((meta3) => ({
       meta: meta3,
@@ -140943,31 +141006,37 @@ var SearchIndexer = class {
   // Replace an already-indexed document in place. FlexSearch's `add` does not
   // overwrite an existing id, so a single-file refresh must go through
   // `update` to avoid stale matches lingering in the index.
-  updateDocument(meta3) {
+  updateDocument(meta3, searchContent = "") {
     this.documents.set(meta3.id, meta3);
-    this.index.update({
-      id: meta3.id,
-      content: meta3.contentSnippet,
-      projectName: meta3.projectName,
-      projectPath: meta3.projectPath,
-      sessionId: meta3.sessionId,
-      sessionName: meta3.sessionName,
-      account: meta3.account,
-      model: meta3.model || "",
-      gitBranch: meta3.gitBranch || "",
-      toolNames: meta3.toolNames.join(" ")
-    });
+    this.searchContents.set(meta3.id, searchContent);
+    this.index.update(toIndexDoc(meta3, searchContent));
   }
   removeDocument(id) {
     this.documents.delete(id);
+    this.searchContents.delete(id);
     this.index.remove(id);
   }
   clear() {
     this.documents.clear();
+    this.searchContents.clear();
     this.index = this.createIndex();
     getLogger2().trace("indexer: cleared");
   }
 };
+function toIndexDoc(meta3, searchContent) {
+  return {
+    id: meta3.id,
+    content: searchContent,
+    projectName: meta3.projectName,
+    projectPath: meta3.projectPath,
+    sessionId: meta3.sessionId,
+    sessionName: meta3.sessionName,
+    account: meta3.account,
+    model: meta3.model || "",
+    gitBranch: meta3.gitBranch || "",
+    toolNames: meta3.toolNames.join(" ")
+  };
+}
 var CLAUDE_CODE_PROVIDER2 = "claude-code";
 var CODEX_CLI_PROVIDER2 = "codex-cli";
 function initialReducerState() {
@@ -141117,7 +141186,7 @@ var SYSTEM_TAG_RE = new RegExp(`<(${SYSTEM_TAGS.join("|")})[^>]*>[\\s\\S]*?<\\/\
 function cleanSystemTags(text) {
   return text.replace(SYSTEM_TAG_RE, "").replace(/[^\S\n]+/g, " ").replace(/\n{3,}/g, "\n\n").trim();
 }
-async function parseMeta(filePath, account, tier) {
+async function parseMeta(filePath, account, tier, onEntry) {
   const log15 = getLogger2();
   log15.trace({ filePath, account, tier: tier.name }, "parseMeta: start");
   const state = initialReducerState();
@@ -141134,6 +141203,7 @@ async function parseMeta(filePath, account, tier) {
         continue;
       }
       reduceLine(state, entry, tier);
+      onEntry?.(entry);
     }
   } catch (err) {
     log15.warn({ filePath, err }, "parseMeta: read failed");
@@ -141828,7 +141898,7 @@ var LRUCache = class {
   }
 };
 var YIELD_EVERY_LINES = 500;
-async function tailReduce(filePath, startOffset, startLine, state, tier) {
+async function tailReduce(filePath, startOffset, startLine, state, tier, onEntry) {
   const stream = (0, import_fs11.createReadStream)(filePath, { start: startOffset, encoding: "utf8" });
   let buffer = "";
   let offset = startOffset;
@@ -141844,7 +141914,9 @@ async function tailReduce(filePath, startOffset, startLine, state, tier) {
       buffer = buffer.slice(nl + 1);
       if (text.length > 0) {
         try {
-          reduceLine(state, JSON.parse(text), tier);
+          const entry = JSON.parse(text);
+          reduceLine(state, entry, tier);
+          onEntry?.(entry);
         } catch {
           state.badJsonLines++;
         }
@@ -142065,7 +142137,7 @@ function classify(filePath, existing) {
   }
   return { change: "reindex", stat: stat42 };
 }
-async function parseMetaWithProvider(provider, filePath, account, tier) {
+async function parseMetaWithProvider(provider, filePath, account, tier, onEntry) {
   const log15 = getLogger2();
   const acc = provider.createEmptyAccumulator();
   const rl = (0, import_readline3.createInterface)({
@@ -142083,6 +142155,7 @@ async function parseMetaWithProvider(provider, filePath, account, tier) {
       }
       try {
         provider.reduceEntry(acc, entry, tier);
+        onEntry?.(entry);
       } catch (err) {
         log15.warn({ filePath, provider: provider.name, err }, "provider reduce threw; line skipped");
       }
@@ -142093,6 +142166,149 @@ async function parseMetaWithProvider(provider, filePath, account, tier) {
   }
   return provider.finalize(acc, filePath, account, tier);
 }
+var SEARCH_BUDGET = {
+  textMax: 64 * 1024,
+  thinkingMax: 32 * 1024,
+  toolsMax: 32 * 1024,
+  toolPayloadMax: 4 * 1024
+};
+var SEP = "\n\n";
+function emptySearchDocument() {
+  return { text: "", thinking: "", tools: "" };
+}
+function appendSearchDelta(doc, delta) {
+  return {
+    text: tailAppend(doc.text, delta.text, SEARCH_BUDGET.textMax),
+    thinking: tailAppend(doc.thinking, delta.thinking, SEARCH_BUDGET.thinkingMax),
+    tools: tailAppend(doc.tools, delta.tools, SEARCH_BUDGET.toolsMax)
+  };
+}
+function tailAppend(current, incoming, max) {
+  if (!incoming) return current;
+  const joined = current ? current + SEP + incoming : incoming;
+  return joined.length <= max ? joined : joined.slice(-max);
+}
+function combineSearchContent(doc) {
+  return [doc.text, doc.thinking, doc.tools].filter(Boolean).join(SEP);
+}
+function capToolPayload(value) {
+  const raw2 = stringifyPayload(value);
+  if (!raw2) return "";
+  return raw2.length > SEARCH_BUDGET.toolPayloadMax ? raw2.slice(0, SEARCH_BUDGET.toolPayloadMax) : raw2;
+}
+function stringifyPayload(value) {
+  if (value === null || value === void 0) return "";
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value) ?? "";
+  } catch {
+    return "";
+  }
+}
+function extractSearchDelta(entry) {
+  if (entry.type === "response_item" || entry.type === "session_meta") {
+    return extractCodexDelta(entry);
+  }
+  return extractClaudeDelta(entry);
+}
+function extractClaudeDelta(entry) {
+  const type = entry.type;
+  if (type !== "user" && type !== "assistant") return emptySearchDocument();
+  if (entry.isMeta) return emptySearchDocument();
+  const msg = entry.message;
+  const content = msg?.content;
+  const tools = [
+    extractClaudeToolContent(content),
+    // Claude stores the rich/structured tool result at the JSONL entry's top
+    // level, not inside message.content — indexing only message.content would
+    // miss most real tool output (file reads, command stdout).
+    capToolPayload(entry.toolUseResult)
+  ].filter(Boolean).join(SEP);
+  return {
+    text: extractClaudeText(content),
+    thinking: type === "assistant" ? extractThinking(content).content : "",
+    tools
+  };
+}
+function extractClaudeText(content) {
+  if (typeof content === "string") return cleanSystemTags(content);
+  if (!Array.isArray(content)) return "";
+  const parts = [];
+  for (const item of content) {
+    if (typeof item === "string") {
+      const cleaned = cleanSystemTags(item);
+      if (cleaned) parts.push(cleaned);
+    } else if (item?.type === "text" && typeof item.text === "string") {
+      const cleaned = cleanSystemTags(item.text);
+      if (cleaned) parts.push(cleaned);
+    }
+  }
+  return parts.join(SEP);
+}
+function extractClaudeToolContent(content) {
+  if (!Array.isArray(content)) return "";
+  const parts = [];
+  for (const item of content) {
+    if (item?.type === "tool_use") {
+      const capped = capToolPayload(item.input);
+      if (capped) parts.push(capped);
+    } else if (item?.type === "tool_result") {
+      const capped = capToolPayload(item.content);
+      if (capped) parts.push(capped);
+    }
+  }
+  return parts.join(SEP);
+}
+function extractCodexDelta(entry) {
+  const payload = entry.payload;
+  if (!payload || typeof payload !== "object") return emptySearchDocument();
+  const ptype = payload.type;
+  if (ptype === "function_call" || ptype === "custom_tool_call") {
+    return { text: "", thinking: "", tools: capToolPayload(payload.arguments) };
+  }
+  if (ptype === "function_call_output" || ptype === "custom_tool_call_output") {
+    return { text: "", thinking: "", tools: capToolPayload(payload.output) };
+  }
+  if (ptype === "reasoning") {
+    return { text: "", thinking: extractCodexReasoning(payload), tools: "" };
+  }
+  if (ptype === "message") {
+    const role = payload.role;
+    if (role !== "user" && role !== "assistant") return emptySearchDocument();
+    return { text: extractCodexText2(payload.content), thinking: "", tools: "" };
+  }
+  return emptySearchDocument();
+}
+function extractCodexReasoning(payload) {
+  const parts = [];
+  for (const key of ["summary", "content"]) {
+    const blocks = payload[key];
+    if (!Array.isArray(blocks)) continue;
+    for (const block of blocks) {
+      if (typeof block === "string") parts.push(block);
+      else if (typeof block?.text === "string") parts.push(block.text);
+    }
+  }
+  return parts.filter(Boolean).join(SEP);
+}
+function extractCodexText2(content) {
+  if (typeof content === "string") return cleanSystemTags(content);
+  if (!Array.isArray(content)) return "";
+  const parts = [];
+  for (const item of content) {
+    if (typeof item === "string") {
+      const cleaned = cleanSystemTags(item);
+      if (cleaned) parts.push(cleaned);
+      continue;
+    }
+    const t = item?.type;
+    if ((t === "input_text" || t === "output_text" || t === "text") && typeof item.text === "string") {
+      const cleaned = cleanSystemTags(item.text);
+      if (cleaned) parts.push(cleaned);
+    }
+  }
+  return parts.join(SEP);
+}
 var DEFAULT_TIERS = {
   standard: { name: "standard", previewMax: 200, snippetMax: 5e3 },
   full: { name: "full", previewMax: 1200, snippetMax: 5e4 }
@@ -142106,7 +142322,7 @@ function resolveTier(tierName, customTiers) {
   }
   return tier;
 }
-var SCHEMA_VERSION = 4;
+var SCHEMA_VERSION = 5;
 var SCHEMA_SQL = `
 CREATE TABLE IF NOT EXISTS conversation_files (
   id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -142206,13 +142422,27 @@ CREATE INDEX IF NOT EXISTS idx_conversations_account_recent ON conversations(acc
 CREATE INDEX IF NOT EXISTS idx_conversations_subagent_recent ON conversations(is_subagent, timestamp DESC);
 CREATE INDEX IF NOT EXISTS idx_conversations_team_recent ON conversations(team_name, timestamp DESC);
 
--- Full-text search index over conversation content + metadata. Kept separate
--- from the metadata tables so list-screen queries stay small and fast.
--- source_path is UNINDEXED (stored, not tokenized) and links back to a
--- conversations row. One FTS row per conversation, replaced on each upsert.
+-- Full-text search index over conversation body + metadata. Kept separate from
+-- the metadata tables so list-screen queries stay small and fast. One FTS row
+-- per conversation, replaced on each upsert.
+--
+-- The row's rowid IS conversation_files.id. That is load-bearing, not cosmetic:
+-- FTS5's query planner only handles MATCH, rowid and rank, so any other
+-- constraint (including a source_path equality on an UNINDEXED column) has no
+-- index and linear-scans the whole table. At ~128 KB of body per row that would
+-- mean scanning the entire corpus on every append. Look rows up by rowid.
+-- source_path stays stored-but-UNINDEXED so a search hit can resolve back to a
+-- conversations row.
+--
+-- Body is three columns, not one: text > thinking > tools priority has to
+-- survive an append (a new user message belongs in the text column, not after
+-- the tool output already written). They are deliberately NOT concatenated into
+-- a fourth column - that would double-weight body hits and inflate bm25 length.
 CREATE VIRTUAL TABLE IF NOT EXISTS conversation_messages_fts USING fts5(
   source_path UNINDEXED,
-  content,
+  text,
+  thinking,
+  tools,
   project_name,
   session_id,
   session_name,
@@ -142280,6 +142510,24 @@ function runMigrations(db) {
   if (current >= 1 && current < 3 && tableExists(db, "conversations")) {
     db.exec("UPDATE conversations SET provider = 'claude-code' WHERE provider = 'threadbase'");
   }
+  if (current >= 1 && current < 5) {
+    db.exec("DROP TABLE IF EXISTS conversation_messages_fts");
+    if (tableExists(db, "conversation_files")) {
+      const assignments = [];
+      if (hasColumn(db, "conversation_files", "last_indexed_offset")) {
+        assignments.push("last_indexed_offset = 0");
+      }
+      if (hasColumn(db, "conversation_files", "last_indexed_line")) {
+        assignments.push("last_indexed_line = 0");
+      }
+      if (hasColumn(db, "conversation_files", "reducer_state")) {
+        assignments.push("reducer_state = NULL");
+      }
+      if (assignments.length > 0) {
+        db.exec(`UPDATE conversation_files SET ${assignments.join(", ")}`);
+      }
+    }
+  }
   db.exec(SCHEMA_SQL);
   db.pragma(`user_version = ${SCHEMA_VERSION}`);
 }
@@ -142294,15 +142542,46 @@ function openDatabase(dbPath) {
   if (dbPath !== ":memory:") {
     (0, import_fs15.mkdirSync)((0, import_path12.dirname)(dbPath), { recursive: true });
   }
-  const db = new import_better_sqlite3.default(dbPath);
+  let db;
+  try {
+    db = new import_better_sqlite3.default(dbPath);
+  } catch (err) {
+    if (isNativeBindingFailure(err)) throw nativeBindingError(err, dbPath);
+    throw err;
+  }
   db.pragma("journal_mode = WAL");
   db.pragma("synchronous = NORMAL");
   db.pragma("temp_store = MEMORY");
   db.pragma("foreign_keys = ON");
+  db.pragma("busy_timeout = 5000");
   runMigrations(db);
   getLogger2().debug({ dbPath }, "db: opened");
   return db;
 }
+function isNativeBindingFailure(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  return /could not locate the bindings file|NODE_MODULE_VERSION|was compiled against|\.node['"\s]/i.test(
+    message
+  );
+}
+function nativeBindingError(err, dbPath) {
+  const detail = err instanceof Error ? err.message : String(err);
+  return new Error(
+    [
+      `Could not load better-sqlite3's native binary, so the persistent index at ${dbPath} cannot be opened.`,
+      "This usually means the binary was never built or downloaded \u2014 not that your Node version is wrong.",
+      "",
+      "Try, in order:",
+      "  1. npm rebuild better-sqlite3",
+      "  2. rm -rf node_modules && npm install",
+      "     (npm 12 blocks package install scripts by default; approve better-sqlite3 if asked)",
+      "  3. Run without SQLite entirely: new ConversationScanner({ persistent: false })",
+      "     or pass --no-persist on the CLI. Search falls back to the in-memory index.",
+      "",
+      `Original error: ${detail}`
+    ].join("\n")
+  );
+}
 var FULL_RECONCILE_EVERY_N_SCANS = 20;
 async function discoverJsonlFilesGated(dirs, files, scannedDirs, options = {}) {
   const log15 = getLogger2();
@@ -142733,22 +143012,31 @@ var ConversationsRepo = class {
     return this.db.prepare("SELECT COUNT(*) AS n FROM conversations WHERE status = 'active'").get().n;
   }
 };
+var BODY_COLUMNS = [
+  { name: "text", index: 1 },
+  { name: "thinking", index: 2 },
+  { name: "tools", index: 3 }
+];
 var FtsRepo = class {
   constructor(db) {
     this.db = db;
   }
   db;
-  upsert(meta3) {
+  upsert(rowId, meta3, doc) {
     const sourcePath = canonicalPath(meta3.id);
     const tx = this.db.transaction(() => {
-      this.db.prepare("DELETE FROM conversation_messages_fts WHERE source_path = ?").run(sourcePath);
+      this.db.prepare("DELETE FROM conversation_messages_fts WHERE rowid = ?").run(rowId);
       this.db.prepare(
         `INSERT INTO conversation_messages_fts
-             (source_path, content, project_name, session_id, session_name, account, model, branch, tool_names)
-           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+             (rowid, source_path, text, thinking, tools,
+              project_name, session_id, session_name, account, model, branch, tool_names)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
       ).run(
+        rowId,
         sourcePath,
-        meta3.contentSnippet ?? "",
+        doc.text,
+        doc.thinking,
+        doc.tools,
         meta3.projectName ?? "",
         meta3.sessionId ?? "",
         meta3.sessionName ?? "",
@@ -142760,26 +143048,94 @@ var FtsRepo = class {
     });
     tx();
   }
-  remove(sourcePath) {
-    this.db.prepare("DELETE FROM conversation_messages_fts WHERE source_path = ?").run(canonicalPath(sourcePath));
+  // Current durable buckets for a conversation, so an append can tail-extend
+  // them without reparsing the file. Returns null when no row exists yet.
+  readDocument(rowId) {
+    const row = this.db.prepare("SELECT text, thinking, tools FROM conversation_messages_fts WHERE rowid = ?").get(rowId);
+    if (!row) return null;
+    return { text: row.text ?? "", thinking: row.thinking ?? "", tools: row.tools ?? "" };
+  }
+  // True when the stored row already equals what we would write, so an append
+  // can skip re-tokenizing ~128 KB of body for nothing.
+  //
+  // The check covers the metadata columns too, not just the buckets: a
+  // newly-seen tool name or a late-resolved session_name changes metadata while
+  // the body is byte-identical, and nothing else ever rewrites this row — so
+  // skipping on "body unchanged" alone would strand that stale value forever.
+  isCurrent(rowId, meta3, doc) {
+    const row = this.db.prepare(
+      `SELECT text, thinking, tools,
+                project_name, session_id, session_name, account, model, branch, tool_names
+         FROM conversation_messages_fts WHERE rowid = ?`
+    ).get(rowId);
+    if (!row) return false;
+    return row.text === doc.text && row.thinking === doc.thinking && row.tools === doc.tools && row.project_name === (meta3.projectName ?? "") && row.session_id === (meta3.sessionId ?? "") && row.session_name === (meta3.sessionName ?? "") && row.account === (meta3.account ?? "") && row.model === (meta3.model ?? "") && row.branch === (meta3.gitBranch ?? "") && row.tool_names === meta3.toolNames.join(" ");
+  }
+  remove(rowId) {
+    this.db.prepare("DELETE FROM conversation_messages_fts WHERE rowid = ?").run(rowId);
   }
-  // Ranked source_paths matching the query, best first. Returns [] on an empty
-  // query (callers fall back to a recency listing).
-  search(query, limit) {
+  // Ranked hits matching the query, best first. Filters run in SQL BEFORE LIMIT:
+  // with a wide corpus a popular term matches far more conversations than one
+  // page, so post-filtering an already-truncated list would report "no results"
+  // for queries that do have them.
+  search(query, limit, filters = {}) {
     const match2 = toMatchQuery(query);
     if (!match2) return [];
+    const snippetSelects = BODY_COLUMNS.map(
+      (c) => `snippet(conversation_messages_fts, ${c.index}, ?, ?, ?, ?) AS snippet_${c.name}`
+    ).join(", ");
+    const params = [];
+    for (const _col of BODY_COLUMNS) {
+      params.push(FTS_HIT_OPEN, FTS_HIT_CLOSE, FTS_ELLIPSIS, FTS_SNIPPET_TOKENS);
+    }
+    params.push(match2);
+    const where = ["conversation_messages_fts MATCH ?", "c.status = 'active'"];
+    if (filters.account) {
+      where.push("c.account = ?");
+      params.push(filters.account);
+    }
+    if (filters.provider) {
+      where.push("c.provider = ?");
+      params.push(filters.provider);
+    }
+    if (filters.project) {
+      where.push("(lower(c.project_path) LIKE ? OR lower(c.project_name) LIKE ?)");
+      const like = `%${filters.project.toLowerCase()}%`;
+      params.push(like, like);
+    }
+    if (filters.since) {
+      where.push("c.timestamp >= ?");
+      params.push(filters.since.toISOString());
+    }
+    if (filters.include === "conversations") {
+      where.push("c.is_subagent = 0 AND c.is_teammate = 0");
+    } else if (filters.include === "subagents") {
+      where.push("c.is_subagent = 1");
+    } else if (filters.include === "teammates") {
+      where.push("c.is_teammate = 1");
+    }
+    params.push(limit);
     const rows = this.db.prepare(
-      `SELECT source_path FROM conversation_messages_fts
-         WHERE conversation_messages_fts MATCH ?
+      `SELECT conversation_messages_fts.source_path AS source_path, ${snippetSelects}
+         FROM conversation_messages_fts
+         JOIN conversations c ON c.source_path = conversation_messages_fts.source_path
+         WHERE ${where.join(" AND ")}
          ORDER BY rank
          LIMIT ?`
-    ).all(match2, limit);
-    return rows.map((r) => r.source_path);
+    ).all(...params);
+    return rows.map((row) => ({ sourcePath: row.source_path, body: pickBodySnippet(row) }));
   }
   count() {
     return this.db.prepare("SELECT COUNT(*) AS n FROM conversation_messages_fts").get().n;
   }
 };
+function pickBodySnippet(row) {
+  for (const col of BODY_COLUMNS) {
+    const parsed = parseFtsSnippet(row[`snippet_${col.name}`]);
+    if (parsed) return parsed;
+  }
+  return null;
+}
 function toMatchQuery(query) {
   const terms = query.trim().split(/\s+/).map((t) => t.replace(/"/g, "").trim()).filter(Boolean);
   if (terms.length === 0) return "";
@@ -142955,9 +143311,13 @@ var PersistentEngine = class {
     const state = resume ? JSON.parse(existing.reducer_state) : initialReducerState();
     const startOffset = resume ? existing.last_indexed_offset : 0;
     const startLine = resume ? existing.last_indexed_line : 0;
+    let searchDelta = emptySearchDocument();
+    const collectSearch = (entry) => {
+      searchDelta = appendSearchDelta(searchDelta, extractSearchDelta(entry));
+    };
     let result;
     try {
-      result = await tailReduce(filePath, startOffset, startLine, state, tier);
+      result = await tailReduce(filePath, startOffset, startLine, state, tier, collectSearch);
     } catch (err) {
       log15.warn({ filePath, err }, "persistent: tail read failed");
       return { meta: null, change };
@@ -142970,9 +143330,13 @@ var PersistentEngine = class {
     meta3.gitBranch = resolveGitBranch(meta3.projectPath);
     const fp = stat42.size > 0 ? fingerprint(filePath, stat42.size) : null;
     const fileId = this.files.ensure(filePath, account);
+    const base = resume ? this.fts.readDocument(fileId) ?? emptySearchDocument() : emptySearchDocument();
+    const searchDoc = appendSearchDelta(base, searchDelta);
     const upsert = this.db.transaction(() => {
       this.conversations.upsert(fileId, meta3, state.pageMessageCount);
-      this.fts.upsert(meta3);
+      if (!this.fts.isCurrent(fileId, meta3, searchDoc)) {
+        this.fts.upsert(fileId, meta3, searchDoc);
+      }
       if (!resume) this.checkpoints.remove(filePath);
       this.files.updateCursor(fileId, {
         sizeBytes: stat42.size,
@@ -143015,7 +143379,10 @@ var PersistentEngine = class {
   // any change reparses from 0 again. No reducer_state is persisted.
   async indexFileWithProvider(provider, filePath, account, tier, stat42, resolveGitBranch) {
     const log15 = getLogger2();
-    const meta3 = await parseMetaWithProvider(provider, filePath, account, tier);
+    let searchDoc = emptySearchDocument();
+    const meta3 = await parseMetaWithProvider(provider, filePath, account, tier, (entry) => {
+      searchDoc = appendSearchDelta(searchDoc, extractSearchDelta(entry));
+    });
     if (!meta3) {
       this.markDeleted(filePath);
       return null;
@@ -143027,7 +143394,9 @@ var PersistentEngine = class {
     const fileId = this.files.ensure(filePath, account);
     const upsert = this.db.transaction(() => {
       this.conversations.upsert(fileId, meta3, meta3.messageCount);
-      this.fts.upsert(meta3);
+      if (!this.fts.isCurrent(fileId, meta3, searchDoc)) {
+        this.fts.upsert(fileId, meta3, searchDoc);
+      }
       this.checkpoints.remove(filePath);
       this.files.updateCursor(fileId, {
         sizeBytes: stat42.size,
@@ -143053,7 +143422,7 @@ var PersistentEngine = class {
     if (!existing) return;
     const tx = this.db.transaction(() => {
       this.conversations.deleteByFileId(existing.id);
-      this.fts.remove(filePath);
+      this.fts.remove(existing.id);
       this.checkpoints.remove(filePath);
       this.files.setStatus(existing.id, "deleted");
     });
@@ -143069,20 +143438,24 @@ var PersistentEngine = class {
   getAllBySessionId(sessionId) {
     return this.conversations.getAllBySessionId(sessionId);
   }
-  // Ranked metas matching the FTS query, best first. Empty query returns the
-  // most recent conversations (mirroring the in-memory indexer's empty-query
-  // behavior). Resolves each FTS hit to its active conversation row.
-  searchMetas(query, limit) {
-    if (!query.trim()) {
-      return this.conversations.recent(limit);
-    }
-    const paths = this.fts.search(query, limit);
-    const metas = [];
-    for (const path2 of paths) {
-      const meta3 = this.conversations.getBySourcePath(path2);
-      if (meta3) metas.push(meta3);
+  // Ranked hits matching the FTS query, best first, each already resolved to its
+  // active conversation row and carrying the body excerpt when the match was in
+  // the conversation body.
+  //
+  // Filters are passed down into SQL rather than applied to the result: with a
+  // wide corpus, filtering an already-LIMITed list drops conversations that
+  // would have matched.
+  searchHits(query, limit, filters = {}) {
+    const hits = [];
+    for (const hit of this.fts.search(query, limit, filters)) {
+      const meta3 = this.conversations.getBySourcePath(hit.sourcePath);
+      if (meta3) hits.push({ meta: meta3, body: hit.body });
     }
-    return metas;
+    return hits;
+  }
+  // Empty-query listing, mirroring the in-memory indexer's behavior.
+  recentMetas(limit) {
+    return this.conversations.recent(limit);
   }
   getProjects() {
     return this.conversations.distinctProjects();
@@ -143236,6 +143609,10 @@ var DEFAULT_CONFIG_PATH2 = "~/.config/threadbase-scanner";
 function defaultDbPath() {
   return process.env.TB_SCANNER_DB ?? (0, import_path10.join)((0, import_os8.homedir)(), ".config", "threadbase-scanner", "index.db");
 }
+function capForMemory(doc, max) {
+  const combined = combineSearchContent(doc);
+  return combined.length > max ? combined.slice(-max) : combined;
+}
 var ConversationScanner = class {
   metadataCache = /* @__PURE__ */ new Map();
   // Parsed conversations plus (persistent claude-code entries only) the resume
@@ -143247,6 +143624,10 @@ var ConversationScanner = class {
   sessionIdIndex = /* @__PURE__ */ new Map();
   projects = /* @__PURE__ */ new Set();
   indexer = new SearchIndexer();
+  // Search body per conversation for the in-memory path, already tail-capped to
+  // the content tier. Survives scan() so a statCache hit — which skips the parse
+  // entirely — can still index a body rather than an empty string.
+  searchContents = /* @__PURE__ */ new Map();
   // Tier the most recent scan() ran with, so refreshFile() re-parses a single
   // file at the same content depth. Defaults to the standard tier.
   lastTier = resolveTier("standard");
@@ -143407,34 +143788,42 @@ var ConversationScanner = class {
               try {
                 const s3 = (0, import_fs9.statSync)(filePath);
                 if (s3.mtimeMs === cached4.stat.mtimeMs && s3.size === cached4.stat.size) {
-                  return cached4.meta;
+                  return {
+                    meta: cached4.meta,
+                    searchContent: this.searchContents.get(cached4.meta.id)
+                  };
                 }
               } catch {
               }
             }
           }
           try {
-            const meta3 = await parseMetaWithProvider(provider, filePath, account, tier);
+            let doc = emptySearchDocument();
+            const meta3 = await parseMetaWithProvider(provider, filePath, account, tier, (entry) => {
+              doc = appendSearchDelta(doc, extractSearchDelta(entry));
+            });
             if (meta3 && meta3.gitBranch === null && meta3.projectPath) {
               meta3.gitBranch = resolveGitBranch(meta3.projectPath);
             }
-            return meta3;
+            return { meta: meta3, searchContent: capForMemory(doc, tier.snippetMax) };
           } catch (err) {
             parseFailures++;
             log15.warn({ filePath, account, provider: provider.name, err }, "scan: parse threw");
-            return null;
+            return { meta: null, searchContent: void 0 };
           }
         })
       );
       const batchMetas = [];
-      for (const meta3 of results) {
+      for (const { meta: meta3, searchContent } of results) {
         if (meta3 && meta3.messageCount > 0) {
           this.metadataCache.set(meta3.id, meta3);
           this.addToSessionIndex(meta3);
           this.projects.add(meta3.projectPath);
           allMetas.push(meta3);
           batchMetas.push(meta3);
-          this.indexer.addDocument(meta3);
+          const content = searchContent ?? this.searchContents.get(meta3.id) ?? "";
+          this.searchContents.set(meta3.id, content);
+          this.indexer.addDocument(meta3, content);
         }
       }
       if (batchMetas.length > 0) {
@@ -143471,12 +143860,29 @@ var ConversationScanner = class {
         const activeProfiles = profiles.filter((p2) => p2.enabled && p2.scanHistory !== false);
         await engine.indexAll(activeProfiles, { ...options, limit: void 0, offset: void 0 });
       }
-      const metas = engine.searchMetas(query, (options.limit ?? 50) * 2);
-      results = query.trim() ? metas.map((meta3) => ({ meta: meta3, score: 1, matches: generateMatches(meta3, query) })) : metas.map((meta3) => ({
-        meta: meta3,
-        score: 1,
-        matches: [{ field: "timestamp", snippet: meta3.preview }]
-      }));
+      if (query.trim()) {
+        const want = (options.limit ?? 50) + (options.offset ?? 0);
+        results = engine.searchHits(query, want, {
+          account: options.account,
+          provider: options.provider,
+          project: options.project,
+          since: options.since ? parseSinceCutoff(options.since) : void 0,
+          include: options.include
+        }).map(({ meta: meta3, body }) => ({
+          meta: meta3,
+          score: 1,
+          matches: body ? [
+            { field: CONTENT_FIELD, snippet: body.snippet, highlights: body.highlights },
+            ...generateMatches(meta3, query).filter((m2) => m2.field !== "preview")
+          ] : generateMatches(meta3, query)
+        }));
+      } else {
+        results = engine.recentMetas((options.limit ?? 50) + (options.offset ?? 0)).map((meta3) => ({
+          meta: meta3,
+          score: 1,
+          matches: [{ field: "timestamp", snippet: meta3.preview }]
+        }));
+      }
     } else {
       if (this.indexer.getDocumentCount() === 0) {
         log15.debug("search: index empty, triggering scan");
@@ -143670,8 +144076,11 @@ var ConversationScanner = class {
     const previous = this.metadataCache.get(filePath);
     const resolvedAccount = account ?? previous?.account ?? "default";
     let meta3 = null;
+    let searchDoc = emptySearchDocument();
     try {
-      meta3 = await parseMeta(filePath, resolvedAccount, this.lastTier);
+      meta3 = await parseMeta(filePath, resolvedAccount, this.lastTier, (entry) => {
+        searchDoc = appendSearchDelta(searchDoc, extractSearchDelta(entry));
+      });
     } catch (err) {
       log15.warn({ filePath, err }, "refreshFile: parseMeta threw");
       meta3 = null;
@@ -143688,6 +144097,7 @@ var ConversationScanner = class {
         this.metadataCache.delete(previous.id);
         this.removeFromSessionIndex(previous);
         this.indexer.removeDocument(previous.id);
+        this.searchContents.delete(previous.id);
       }
       log15.debug({ filePath }, "refreshFile: dropped (no parseable messages)");
       return null;
@@ -143697,10 +144107,12 @@ var ConversationScanner = class {
     this.metadataCache.set(meta3.id, meta3);
     this.addToSessionIndex(meta3);
     this.projects.add(meta3.projectPath);
+    const searchContent = capForMemory(searchDoc, this.lastTier.snippetMax);
+    this.searchContents.set(meta3.id, searchContent);
     if (previous) {
-      this.indexer.updateDocument(meta3);
+      this.indexer.updateDocument(meta3, searchContent);
     } else {
-      this.indexer.addDocument(meta3);
+      this.indexer.addDocument(meta3, searchContent);
     }
     log15.debug(
       { filePath, messageCount: meta3.messageCount },
@@ -145550,7 +145962,7 @@ function paginate(results, offset, limit) {
 }
 
 // src/utils/codexConversationLine.ts
-function extractCodexText2(content) {
+function extractCodexText3(content) {
   if (typeof content === "string") return content.trim();
   if (!Array.isArray(content)) return "";
   return content.map((item) => {
@@ -145589,7 +146001,7 @@ function classifyCodexLine(line) {
   if (role !== "user" && role !== "assistant") {
     return { kind: "ignored", reason: `role ${String(role)} is not rendered` };
   }
-  const text = extractCodexText2(payload.content);
+  const text = extractCodexText3(payload.content);
   if (!text) {
     return { kind: "ignored", reason: "message has no extractable text" };
   }
@@ -148242,7 +148654,9 @@ var SessionHandlers = class {
       res.end(JSON.stringify({ error: "Session not found" }));
       return;
     }
+    const shouldForget = this.shouldForgetEmptySession(session);
     if (session.status === "idle") {
+      if (shouldForget) this.forgetEmptyStoppedSession(sessionId);
       res.writeHead(200, { "Content-Type": "application/json" });
       res.end(JSON.stringify({ status: "already_idle", sessionId }));
       return;
@@ -148270,6 +148684,7 @@ var SessionHandlers = class {
     this.ptyManager.putOnHold(sessionId);
     this.discoveryCache = null;
     const outcome = await Promise.race([idlePromise, timeoutPromise]);
+    if (shouldForget) this.forgetEmptyStoppedSession(sessionId);
     if (outcome === "idle") {
       res.write(`${JSON.stringify({ event: "stopped", sessionId })}
 `);
@@ -148282,6 +148697,42 @@ var SessionHandlers = class {
     }
     res.end();
   }
+  /**
+   * An unused start: the user never submitted a prompt, and the conversation
+   * cache has no row for this id (empty Codex/Claude often never write a JSONL).
+   * `conversationId === sessionId` is not evidence of history — only the cache
+   * is. promptCount > 0 or a cache hit keeps today's hold path.
+   */
+  shouldForgetEmptySession(session) {
+    const stored = this.sessionStore.getManaged(session.id);
+    const promptCount = Math.max(session.promptCount, stored?.promptCount ?? 0);
+    if (promptCount > 0) return false;
+    return !this.hasCachedConversationFor(session, stored);
+  }
+  hasCachedConversationFor(session, stored) {
+    const cache = this.cache;
+    if (!cache) return false;
+    const ids = /* @__PURE__ */ new Set([session.id]);
+    if (session.boundConversationId) ids.add(session.boundConversationId);
+    if (session.resumedFromConversationId) ids.add(session.resumedFromConversationId);
+    if (stored?.boundConversationId) ids.add(stored.boundConversationId);
+    if (stored?.resumedFromConversationId) ids.add(stored.resumedFromConversationId);
+    for (const id of ids) {
+      if (cache.hasConversation(id)) return true;
+    }
+    return false;
+  }
+  forgetEmptyStoppedSession(sessionId) {
+    this.log.info(`[stop] forgetting empty session ${sessionId.slice(0, 8)}`, {
+      event: "session.forget_empty",
+      sessionId
+    });
+    this.deps.forgetSession(sessionId);
+    this.wsHub.broadcast({
+      type: "session_list",
+      sessions: this.sessionStore.list(this.deps.ptyAttachedIds())
+    });
+  }
   async handleAdopt(sessionId, res) {
     const discovered = await discoverClaudeProcesses();
     this.sessionStore.setDiscovered(discovered);
@@ -153707,6 +154158,7 @@ var StreamerServer = class {
       spawnFlagOverrides: () => this.spawnFlagOverrides(),
       resolveConversationTarget: (sessionId) => this.resolveConversationTarget(sessionId),
       waitForStartupOutcome: (sessionId, timeoutMs) => this.waitForStartupOutcome(sessionId, timeoutMs),
+      forgetSession: (sessionId) => this.forgetSession(sessionId),
       abandonFailedStart: (sessionId) => this.abandonFailedStart(sessionId),
       enrichResumedSessionAsync: (sessionId, projectPath, conv) => this.enrichResumedSessionAsync(sessionId, projectPath, conv),
       findJsonlPath: (uuid3) => this.conversationHandlers.findJsonlPath(uuid3),
@@ -154529,13 +154981,16 @@ var StreamerServer = class {
       json2(res, 400, { error: "Missing token or clientPublicKey" });
       return;
     }
-    let e2eeRequest;
-    try {
-      e2eeRequest = parseE2eeRequest(body?.e2ee);
-    } catch (err) {
-      const e = err;
-      json2(res, 400, { error: e.message, code: e.code });
-      return;
+    const e2eeEnabled = describeE2eeCapability(this.featureFlags.e2ee).enabled;
+    let e2eeRequest = null;
+    if (e2eeEnabled) {
+      try {
+        e2eeRequest = parseE2eeRequest(body?.e2ee);
+      } catch (err) {
+        const e = err;
+        json2(res, 400, { error: e.message, code: e.code });
+        return;
+      }
     }
     const precheck = this.pairTokens.wouldConsume(token);
     if (!precheck.ok) {
@@ -154695,7 +155150,7 @@ var StreamerServer = class {
    */
   getFeatureFlagsConfig() {
     return {
-      registry: FEATURE_FLAGS,
+      registry: FEATURE_FLAG_LIST,
       values: this.featureFlags,
       sources: this.featureFlagSources
     };
@@ -154929,29 +155384,44 @@ var StreamerServer = class {
     });
   }
   /**
-   * Drop every trace of a session that never became usable, and hand back what
-   * it failed with.
+   * Drop every trace of a managed session: in-memory store, durable registry
+   * row, and the collision-probe markers that would otherwise outlive it.
    *
-   * The runner has already torn itself down (failStartup / handleExit); what
-   * remains is server-side bookkeeping that would otherwise leave a dead
-   * session in the list, a registry row claiming a spawn, and a `selfPtyEndedAt`
-   * marker that would suppress the mtime collision signal on the NEXT resume —
-   * i.e. it would help hide the very owner we just collided with.
+   * Used when a start never became usable (`abandonFailedStart`) and when stop
+   * is asked to discard an empty session that has no cached conversation. The
+   * registry delete is load-bearing — `rehydrateSessions` will bring the row
+   * back on the next boot if it remains.
+   *
+   * Callers that kill the PTY (`putOnHold`) must do that *first*: onStatusChange
+   * on idle writes `selfPtyEndedAt` and a registry status, and those have to
+   * be cleared here afterwards.
    */
-  abandonFailedStart(sessionId) {
+  forgetSession(sessionId) {
     this.sessionStore.removeManaged(sessionId);
     this.selfPtyEndedAt.delete(sessionId);
     this.contendedSessions.delete(sessionId);
     try {
       this.managedSessionsRepo?.delete(sessionId);
     } catch (err) {
-      this.log.warn("[registry] failed to drop a failed start", {
+      this.log.warn("[registry] failed to drop a session", {
         event: "registry.forget_failed",
         sessionId,
         err
       });
     }
   }
+  /**
+   * Drop every trace of a session that never became usable.
+   *
+   * The runner has already torn itself down (failStartup / handleExit); what
+   * remains is server-side bookkeeping that would otherwise leave a dead
+   * session in the list, a registry row claiming a spawn, and a `selfPtyEndedAt`
+   * marker that would suppress the mtime collision signal on the NEXT resume —
+   * i.e. it would help hide the very owner we just collided with.
+   */
+  abandonFailedStart(sessionId) {
+    this.forgetSession(sessionId);
+  }
   enrichResumedSessionAsync(sessionId, projectPath, conv) {
     try {
       if (!this.sessionStore.getManaged(sessionId)) return;
@@ -159147,7 +159617,7 @@ program2.command("serve").description("Start the streamer server").option("-p, -
   (value, previous = []) => [...previous, value]
 ).option(
   "--feature <id=bool>",
-  "Enable or disable a server feature flag, e.g. --feature codexSystemPrompt=true. Repeatable. Overridden by the flag's THREADBASE_FEATURE_* env var; overrides feature_flags: in ~/.threadbase/server.yaml.",
+  `Enable or disable a server feature flag. Ids are the FEATURE_FLAGS keys (${FEATURE_FLAG_IDS.join(", ")}), e.g. --feature ptyHost=true \u2014 not the THREADBASE_FEATURE_* env names. Repeatable. Overridden by the flag's env var; overrides feature_flags: in ~/.threadbase/server.yaml.`,
   (value, previous = []) => [...previous, value]
 ).option(
   "--claude-extra-args <args>",