@martian-engineering/lossless-claw 0.2.2 → 0.2.3

package/README.md

@@ -68,6 +68,168 @@ If you need to set it manually, ensure the context engine slot points at lossles
 
 Restart OpenClaw after configuration changes.
 
+### Optional: enable FTS5 for fast full-text search
+
+`lossless-claw` works without FTS5 as of the current release. When FTS5 is unavailable in the
+Node runtime that runs the OpenClaw gateway, the plugin:
+
+- keeps persisting messages and summaries
+- falls back from `"full_text"` search to a slower `LIKE`-based search
+- loses FTS ranking/snippet quality
+
+If you want native FTS5 search performance and ranking, the **exact Node runtime that runs the
+gateway** must have SQLite FTS5 compiled in.
+
+#### Probe the gateway runtime
+
+Run this with the same `node` binary your gateway uses:
+
+```bash
+node --input-type=module - <<'NODE'
+import { DatabaseSync } from 'node:sqlite';
+const db = new DatabaseSync(':memory:');
+const options = db.prepare('pragma compile_options').all().map((row) => row.compile_options);
+
+console.log(options.filter((value) => value.includes('FTS')).join('\n') || 'no fts compile options');
+
+try {
+  db.exec("CREATE VIRTUAL TABLE t USING fts5(content)");
+  console.log("fts5: ok");
+} catch (err) {
+  console.log("fts5: fail");
+  console.log(err instanceof Error ? err.message : String(err));
+}
+NODE
+```
+
+Expected output:
+
+```text
+ENABLE_FTS5
+fts5: ok
+```
+
+If you get `fts5: fail`, build or install an FTS5-capable Node and point the gateway at that runtime.
+
+#### Build an FTS5-capable Node on macOS
+
+This workflow was verified with Node `v22.15.0`.
+
+```bash
+cd ~/Projects
+git clone --depth 1 --branch v22.15.0 https://github.com/nodejs/node.git node-fts5
+cd node-fts5
+```
+
+Edit `deps/sqlite/sqlite.gyp` and add `SQLITE_ENABLE_FTS5` to the `defines` list for the `sqlite`
+target:
+
+```diff
+ 'defines': [
+   'SQLITE_DEFAULT_MEMSTATUS=0',
++  'SQLITE_ENABLE_FTS5',
+   'SQLITE_ENABLE_MATH_FUNCTIONS',
+   'SQLITE_ENABLE_SESSION',
+   'SQLITE_ENABLE_PREUPDATE_HOOK'
+ ],
+```
+
+Important:
+
+- patch `deps/sqlite/sqlite.gyp`, not only `node.gyp`
+- `node:sqlite` uses the embedded SQLite built from `deps/sqlite/sqlite.gyp`
+
+Build the runtime:
+
+```bash
+./configure --prefix="$PWD/out-install"
+make -j8 node
+```
+
+Expose the binary under a Node-compatible basename that OpenClaw recognizes:
+
+```bash
+mkdir -p ~/Projects/node-fts5/bin
+ln -sfn ~/Projects/node-fts5/out/Release/node ~/Projects/node-fts5/bin/node-22.15.0
+```
+
+Use a basename like `node-22.15.0`, `node`, or `nodejs`. Names like
+`node-v22.15.0-fts5` may not be recognized correctly by OpenClaw's CLI/runtime parsing.
+
+Verify the new runtime:
+
+```bash
+~/Projects/node-fts5/bin/node-22.15.0 --version
+~/Projects/node-fts5/bin/node-22.15.0 --input-type=module - <<'NODE'
+import { DatabaseSync } from 'node:sqlite';
+const db = new DatabaseSync(':memory:');
+db.exec("CREATE VIRTUAL TABLE t USING fts5(content)");
+console.log("fts5: ok");
+NODE
+```
+
+#### Point the OpenClaw gateway at that runtime on macOS
+
+Back up the existing LaunchAgent plist first:
+
+```bash
+cp ~/Library/LaunchAgents/ai.openclaw.gateway.plist \
+  ~/Library/LaunchAgents/ai.openclaw.gateway.plist.bak-$(date +%Y%m%d-%H%M%S)
+```
+
+Replace the runtime path, then reload the agent:
+
+```bash
+/usr/libexec/PlistBuddy -c 'Set :ProgramArguments:0 /Users/youruser/Projects/node-fts5/bin/node-22.15.0' \
+  ~/Library/LaunchAgents/ai.openclaw.gateway.plist
+
+launchctl bootout gui/$UID ~/Library/LaunchAgents/ai.openclaw.gateway.plist 2>/dev/null || true
+launchctl bootstrap gui/$UID ~/Library/LaunchAgents/ai.openclaw.gateway.plist
+launchctl kickstart -k gui/$UID/ai.openclaw.gateway
+```
+
+Verify the live runtime:
+
+```bash
+launchctl print gui/$UID/ai.openclaw.gateway | sed -n '1,80p'
+```
+
+You should see:
+
+```text
+program = /Users/youruser/Projects/node-fts5/bin/node-22.15.0
+```
+
+#### Verify `lossless-claw`
+
+Check the logs:
+
+```bash
+tail -n 60 ~/.openclaw/logs/gateway.log
+tail -n 60 ~/.openclaw/logs/gateway.err.log
+```
+
+You want:
+
+- `[gateway] [lcm] Plugin loaded ...`
+- no new `no such module: fts5`
+
+Then force one turn through the gateway and verify the DB fills:
+
+```bash
+/Users/youruser/Projects/node-fts5/bin/node-22.15.0 \
+  /path/to/openclaw/dist/index.js \
+  agent --session-id fts5-smoke --message 'Reply with exactly: ok' --timeout 60
+
+sqlite3 ~/.openclaw/lcm.db '
+  select count(*) as conversations from conversations;
+  select count(*) as messages from messages;
+  select count(*) as summaries from summaries;
+'
+```
+
+Those counts should increase after a real turn.
+
 ## Configuration
 
 LCM is configured through a combination of plugin config and environment variables. Environment variables take precedence for backward compatibility.
@@ -81,12 +243,7 @@ Add a `lossless-claw` entry under `plugins.entries` in your OpenClaw config:
   "plugins": {
     "entries": {
       "lossless-claw": {
-        "enabled": true,
-        "config": {
-          "freshTailCount": 32,
-          "contextThreshold": 0.75,
-          "incrementalMaxDepth": -1
-        }
+        "enabled": true
       }
     }
   }

package/index.ts

@@ -597,7 +597,11 @@ function readLatestAssistantReply(messages: unknown[]): string | undefined {
 function createLcmDependencies(api: OpenClawPluginApi): LcmDependencies {
   const envSnapshot = snapshotPluginEnv();
   const readEnv: ReadEnvFn = (key) => process.env[key];
-  const config = resolveLcmConfig(process.env, _parsedPluginConfig);
+  const pluginConfig =
+    api.pluginConfig && typeof api.pluginConfig === "object" && !Array.isArray(api.pluginConfig)
+      ? api.pluginConfig
+      : undefined;
+  const config = resolveLcmConfig(process.env, pluginConfig);
 
   return {
     config,
@@ -854,9 +858,6 @@ function createLcmDependencies(api: OpenClawPluginApi): LcmDependencies {
   };
 }
 
-/** Cached config from configSchema.parse — available by the time register() runs. */
-let _parsedPluginConfig: Record<string, unknown> | undefined;
-
 const lcmPlugin = {
   id: "lossless-claw",
   name: "Lossless Context Management",
@@ -869,7 +870,6 @@ const lcmPlugin = {
         value && typeof value === "object" && !Array.isArray(value)
           ? (value as Record<string, unknown>)
           : {};
-      _parsedPluginConfig = raw;
       return resolveLcmConfig(process.env, raw);
     },
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@martian-engineering/lossless-claw",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Lossless Context Management plugin for OpenClaw — DAG-based conversation summarization with incremental compaction",
   "type": "module",
   "main": "index.ts",
@@ -24,6 +24,8 @@
     "LICENSE"
   ],
   "dependencies": {
+    "@mariozechner/pi-agent-core": "*",
+    "@mariozechner/pi-ai": "*",
     "@sinclair/typebox": "0.34.48"
   },
   "devDependencies": {
@@ -31,9 +33,7 @@
     "vitest": "^3.0.0"
   },
   "peerDependencies": {
-    "openclaw": "*",
-    "@mariozechner/pi-agent-core": "*",
-    "@mariozechner/pi-ai": "*"
+    "openclaw": "*"
   },
   "openclaw": {
     "extensions": [

package/src/db/config.ts

@@ -71,7 +71,10 @@ export function resolveLcmConfig(
         ? env.LCM_ENABLED !== "false"
         : toBool(pc.enabled) ?? true,
     databasePath:
-      env.LCM_DATABASE_PATH ?? toStr(pc.databasePath) ?? join(homedir(), ".openclaw", "lcm.db"),
+      env.LCM_DATABASE_PATH
+      ?? toStr(pc.dbPath)
+      ?? toStr(pc.databasePath)
+      ?? join(homedir(), ".openclaw", "lcm.db"),
     contextThreshold:
       (env.LCM_CONTEXT_THRESHOLD !== undefined ? parseFloat(env.LCM_CONTEXT_THRESHOLD) : undefined)
         ?? toNumber(pc.contextThreshold) ?? 0.75,
@@ -104,7 +107,9 @@ export function resolveLcmConfig(
         ?? toNumber(pc.maxExpandTokens) ?? 4000,
     largeFileTokenThreshold:
       (env.LCM_LARGE_FILE_TOKEN_THRESHOLD !== undefined ? parseInt(env.LCM_LARGE_FILE_TOKEN_THRESHOLD, 10) : undefined)
-        ?? toNumber(pc.largeFileTokenThreshold) ?? 25000,
+        ?? toNumber(pc.largeFileThresholdTokens)
+        ?? toNumber(pc.largeFileTokenThreshold)
+        ?? 25000,
     largeFileSummaryProvider:
       env.LCM_LARGE_FILE_SUMMARY_PROVIDER?.trim() ?? toStr(pc.largeFileSummaryProvider) ?? "",
     largeFileSummaryModel:

package/src/db/features.ts

@@ -0,0 +1,42 @@
+import type { DatabaseSync } from "node:sqlite";
+
+export type LcmDbFeatures = {
+  fts5Available: boolean;
+};
+
+const featureCache = new WeakMap<DatabaseSync, LcmDbFeatures>();
+
+function probeFts5(db: DatabaseSync): boolean {
+  try {
+    db.exec("DROP TABLE IF EXISTS temp.__lcm_fts5_probe");
+    db.exec("CREATE VIRTUAL TABLE temp.__lcm_fts5_probe USING fts5(content)");
+    db.exec("DROP TABLE temp.__lcm_fts5_probe");
+    return true;
+  } catch {
+    try {
+      db.exec("DROP TABLE IF EXISTS temp.__lcm_fts5_probe");
+    } catch {
+      // Ignore cleanup failures after a failed probe.
+    }
+    return false;
+  }
+}
+
+/**
+ * Detect SQLite features exposed by the current Node runtime.
+ *
+ * The result is cached per DatabaseSync handle because the probe is runtime-
+ * specific, not database-file-specific.
+ */
+export function getLcmDbFeatures(db: DatabaseSync): LcmDbFeatures {
+  const cached = featureCache.get(db);
+  if (cached) {
+    return cached;
+  }
+
+  const detected: LcmDbFeatures = {
+    fts5Available: probeFts5(db),
+  };
+  featureCache.set(db, detected);
+  return detected;
+}

package/src/db/migration.ts

@@ -1,4 +1,5 @@
 import type { DatabaseSync } from "node:sqlite";
+import { getLcmDbFeatures } from "./features.js";
 
 type SummaryColumnInfo = {
   name?: string;
@@ -354,7 +355,10 @@ function backfillSummaryMetadata(db: DatabaseSync): void {
   }
 }
 
-export function runLcmMigrations(db: DatabaseSync): void {
+export function runLcmMigrations(
+  db: DatabaseSync,
+  options?: { fts5Available?: boolean },
+): void {
   db.exec(`
     CREATE TABLE IF NOT EXISTS conversations (
       conversation_id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -492,6 +496,11 @@ export function runLcmMigrations(db: DatabaseSync): void {
   backfillSummaryDepths(db);
   backfillSummaryMetadata(db);
 
+  const fts5Available = options?.fts5Available ?? getLcmDbFeatures(db).fts5Available;
+  if (!fts5Available) {
+    return;
+  }
+
   // FTS5 virtual tables for full-text search (cannot use IF NOT EXISTS, so check manually)
   const hasFts = db
     .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='messages_fts'")

package/src/engine.ts

@@ -18,6 +18,7 @@ import { ContextAssembler } from "./assembler.js";
 import { CompactionEngine, type CompactionConfig } from "./compaction.js";
 import type { LcmConfig } from "./db/config.js";
 import { getLcmConnection, closeLcmConnection } from "./db/connection.js";
+import { getLcmDbFeatures } from "./db/features.js";
 import { runLcmMigrations } from "./db/migration.js";
 import {
   createDelegatedExpansionGrant,
@@ -513,6 +514,7 @@ export class LcmContextEngine implements ContextEngine {
   private compaction: CompactionEngine;
   private retrieval: RetrievalEngine;
   private migrated = false;
+  private readonly fts5Available: boolean;
   private sessionOperationQueues = new Map<string, Promise<void>>();
   private largeFileTextSummarizerResolved = false;
   private largeFileTextSummarizer?: (prompt: string) => Promise<string | null>;
@@ -523,9 +525,16 @@ export class LcmContextEngine implements ContextEngine {
     this.config = deps.config;
 
     const db = getLcmConnection(this.config.databasePath);
+    this.fts5Available = getLcmDbFeatures(db).fts5Available;
 
-    this.conversationStore = new ConversationStore(db);
-    this.summaryStore = new SummaryStore(db);
+    this.conversationStore = new ConversationStore(db, { fts5Available: this.fts5Available });
+    this.summaryStore = new SummaryStore(db, { fts5Available: this.fts5Available });
+
+    if (!this.fts5Available) {
+      this.deps.log.warn(
+        "[lcm] FTS5 unavailable in the current Node runtime; full_text search will fall back to LIKE and indexing is disabled",
+      );
+    }
 
     this.assembler = new ContextAssembler(
       this.conversationStore,
@@ -561,7 +570,7 @@ export class LcmContextEngine implements ContextEngine {
       return;
     }
     const db = getLcmConnection(this.config.databasePath);
-    runLcmMigrations(db);
+    runLcmMigrations(db, { fts5Available: this.fts5Available });
     this.migrated = true;
   }
 

package/src/store/conversation-store.ts

@@ -1,6 +1,7 @@
 import type { DatabaseSync } from "node:sqlite";
 import { randomUUID } from "node:crypto";
 import { sanitizeFts5Query } from "./fts5-sanitize.js";
+import { buildLikeSearchPlan, createFallbackSnippet } from "./full-text-fallback.js";
 
 export type ConversationId = number;
 export type MessageId = number;
@@ -203,7 +204,14 @@ function toMessagePartRecord(row: MessagePartRow): MessagePartRecord {
 // ── ConversationStore ─────────────────────────────────────────────────────────
 
 export class ConversationStore {
-  constructor(private db: DatabaseSync) {}
+  private readonly fts5Available: boolean;
+
+  constructor(
+    private db: DatabaseSync,
+    options?: { fts5Available?: boolean },
+  ) {
+    this.fts5Available = options?.fts5Available ?? true;
+  }
 
   // ── Transaction helpers ──────────────────────────────────────────────────
 
@@ -292,10 +300,7 @@ export class ConversationStore {
 
     const messageId = Number(result.lastInsertRowid);
 
-    // Index in FTS5
-    this.db
-      .prepare(`INSERT INTO messages_fts(rowid, content) VALUES (?, ?)`)
-      .run(messageId, input.content);
+    this.indexMessageForFullText(messageId, input.content);
 
     const row = this.db
       .prepare(
@@ -315,7 +320,6 @@ export class ConversationStore {
       `INSERT INTO messages (conversation_id, seq, role, content, token_count)
        VALUES (?, ?, ?, ?, ?)`,
     );
-    const insertFtsStmt = this.db.prepare(`INSERT INTO messages_fts(rowid, content) VALUES (?, ?)`);
     const selectStmt = this.db.prepare(
       `SELECT message_id, conversation_id, seq, role, content, token_count, created_at
        FROM messages WHERE message_id = ?`,
@@ -332,7 +336,7 @@ export class ConversationStore {
       );
 
       const messageId = Number(result.lastInsertRowid);
-      insertFtsStmt.run(messageId, input.content);
+      this.indexMessageForFullText(messageId, input.content);
       const row = selectStmt.get(messageId) as unknown as MessageRow;
       records.push(toMessageRecord(row));
     }
@@ -535,8 +539,7 @@ export class ConversationStore {
         .prepare(`DELETE FROM context_items WHERE item_type = 'message' AND message_id = ?`)
         .run(messageId);
 
-      // Remove from FTS index
-      this.db.prepare(`DELETE FROM messages_fts WHERE rowid = ?`).run(messageId);
+      this.deleteMessageFromFullText(messageId);
 
       // Delete the message (message_parts cascade via ON DELETE CASCADE)
       this.db.prepare(`DELETE FROM messages WHERE message_id = ?`).run(messageId);
@@ -553,17 +556,54 @@ export class ConversationStore {
     const limit = input.limit ?? 50;
 
     if (input.mode === "full_text") {
-      return this.searchFullText(
-        input.query,
-        limit,
-        input.conversationId,
-        input.since,
-        input.before,
-      );
+      if (this.fts5Available) {
+        try {
+          return this.searchFullText(
+            input.query,
+            limit,
+            input.conversationId,
+            input.since,
+            input.before,
+          );
+        } catch {
+          return this.searchLike(
+            input.query,
+            limit,
+            input.conversationId,
+            input.since,
+            input.before,
+          );
+        }
+      }
+      return this.searchLike(input.query, limit, input.conversationId, input.since, input.before);
     }
     return this.searchRegex(input.query, limit, input.conversationId, input.since, input.before);
   }
 
+  private indexMessageForFullText(messageId: MessageId, content: string): void {
+    if (!this.fts5Available) {
+      return;
+    }
+    try {
+      this.db
+        .prepare(`INSERT INTO messages_fts(rowid, content) VALUES (?, ?)`)
+        .run(messageId, content);
+    } catch {
+      // Full-text indexing is optional. Message persistence must still succeed.
+    }
+  }
+
+  private deleteMessageFromFullText(messageId: MessageId): void {
+    if (!this.fts5Available) {
+      return;
+    }
+    try {
+      this.db.prepare(`DELETE FROM messages_fts WHERE rowid = ?`).run(messageId);
+    } catch {
+      // Ignore FTS cleanup failures; the source row deletion is authoritative.
+    }
+  }
+
   private searchFullText(
     query: string,
     limit: number,
@@ -603,6 +643,55 @@ export class ConversationStore {
     return rows.map(toSearchResult);
   }
 
+  private searchLike(
+    query: string,
+    limit: number,
+    conversationId?: ConversationId,
+    since?: Date,
+    before?: Date,
+  ): MessageSearchResult[] {
+    const plan = buildLikeSearchPlan("content", query);
+    if (plan.terms.length === 0) {
+      return [];
+    }
+
+    const where: string[] = [...plan.where];
+    const args: Array<string | number> = [...plan.args];
+    if (conversationId != null) {
+      where.push("conversation_id = ?");
+      args.push(conversationId);
+    }
+    if (since) {
+      where.push("julianday(created_at) >= julianday(?)");
+      args.push(since.toISOString());
+    }
+    if (before) {
+      where.push("julianday(created_at) < julianday(?)");
+      args.push(before.toISOString());
+    }
+    args.push(limit);
+
+    const whereClause = where.length > 0 ? `WHERE ${where.join(" AND ")}` : "";
+    const rows = this.db
+      .prepare(
+        `SELECT message_id, conversation_id, seq, role, content, token_count, created_at
+         FROM messages
+         ${whereClause}
+         ORDER BY created_at DESC
+         LIMIT ?`,
+      )
+      .all(...args) as unknown as MessageRow[];
+
+    return rows.map((row) => ({
+      messageId: row.message_id,
+      conversationId: row.conversation_id,
+      role: row.role,
+      snippet: createFallbackSnippet(row.content, plan.terms),
+      createdAt: new Date(row.created_at),
+      rank: 0,
+    }));
+  }
+
   private searchRegex(
     pattern: string,
     limit: number,

package/src/store/full-text-fallback.ts

@@ -0,0 +1,74 @@
+const RAW_TERM_RE = /"([^"]+)"|(\S+)/g;
+const EDGE_PUNCTUATION_RE = /^[`'"()[\]{}<>.,:;!?*_+=|\\/-]+|[`'"()[\]{}<>.,:;!?*_+=|\\/-]+$/g;
+
+export type LikeSearchPlan = {
+  terms: string[];
+  where: string[];
+  args: string[];
+};
+
+function normalizeFallbackTerm(raw: string): string {
+  return raw.trim().replace(EDGE_PUNCTUATION_RE, "").toLowerCase();
+}
+
+function escapeLike(term: string): string {
+  return term.replace(/([\\%_])/g, "\\$1");
+}
+
+/**
+ * Convert a free-text query into a conservative LIKE search plan.
+ *
+ * The fallback keeps phrase tokens when the query uses double quotes, and
+ * otherwise searches for all normalized tokens as case-insensitive substrings.
+ */
+export function buildLikeSearchPlan(column: string, query: string): LikeSearchPlan {
+  const terms: string[] = [];
+  for (const match of query.matchAll(RAW_TERM_RE)) {
+    const raw = match[1] ?? match[2] ?? "";
+    const normalized = normalizeFallbackTerm(raw);
+    if (normalized.length > 0 && !terms.includes(normalized)) {
+      terms.push(normalized);
+    }
+  }
+
+  if (terms.length === 0) {
+    const fallback = normalizeFallbackTerm(query);
+    if (fallback.length > 0) {
+      terms.push(fallback);
+    }
+  }
+
+  return {
+    terms,
+    where: terms.map(() => `LOWER(${column}) LIKE ? ESCAPE '\\'`),
+    args: terms.map((term) => `%${escapeLike(term)}%`),
+  };
+}
+
+/**
+ * Build a compact snippet centered around the earliest matching term.
+ */
+export function createFallbackSnippet(content: string, terms: string[]): string {
+  const haystack = content.toLowerCase();
+  let matchIndex = -1;
+  let matchLength = 0;
+
+  for (const term of terms) {
+    const idx = haystack.indexOf(term);
+    if (idx !== -1 && (matchIndex === -1 || idx < matchIndex)) {
+      matchIndex = idx;
+      matchLength = term.length;
+    }
+  }
+
+  if (matchIndex === -1) {
+    const head = content.trim();
+    return head.length <= 80 ? head : `${head.slice(0, 77).trimEnd()}...`;
+  }
+
+  const start = Math.max(0, matchIndex - 24);
+  const end = Math.min(content.length, matchIndex + Math.max(matchLength, 1) + 40);
+  const prefix = start > 0 ? "..." : "";
+  const suffix = end < content.length ? "..." : "";
+  return `${prefix}${content.slice(start, end).trim()}${suffix}`;
+}

package/src/store/summary-store.ts

@@ -1,5 +1,6 @@
 import type { DatabaseSync } from "node:sqlite";
 import { sanitizeFts5Query } from "./fts5-sanitize.js";
+import { buildLikeSearchPlan, createFallbackSnippet } from "./full-text-fallback.js";
 
 export type SummaryKind = "leaf" | "condensed";
 export type ContextItemType = "message" | "summary";
@@ -239,7 +240,14 @@ function toLargeFileRecord(row: LargeFileRow): LargeFileRecord {
 // ── SummaryStore ──────────────────────────────────────────────────────────────
 
 export class SummaryStore {
-  constructor(private db: DatabaseSync) {}
+  private readonly fts5Available: boolean;
+
+  constructor(
+    private db: DatabaseSync,
+    options?: { fts5Available?: boolean },
+  ) {
+    this.fts5Available = options?.fts5Available ?? true;
+  }
 
   // ── Summary CRUD ──────────────────────────────────────────────────────────
 
@@ -305,8 +313,21 @@ export class SummaryStore {
         sourceMessageTokenCount,
       );
 
+    const row = this.db
+      .prepare(
+        `SELECT summary_id, conversation_id, kind, depth, content, token_count, file_ids,
+                earliest_at, latest_at, descendant_count, created_at
+                , descendant_token_count, source_message_token_count
+       FROM summaries WHERE summary_id = ?`,
+      )
+      .get(input.summaryId) as unknown as SummaryRow;
+
     // Index in FTS5 as best-effort; compaction flow must continue even if
     // FTS indexing fails for any reason.
+    if (!this.fts5Available) {
+      return toSummaryRecord(row);
+    }
+
     try {
       this.db
         .prepare(`INSERT INTO summaries_fts(summary_id, content) VALUES (?, ?)`)
@@ -316,15 +337,6 @@ export class SummaryStore {
       // compaction and assembly will still work correctly.
     }
 
-    const row = this.db
-      .prepare(
-        `SELECT summary_id, conversation_id, kind, depth, content, token_count, file_ids,
-                earliest_at, latest_at, descendant_count, created_at
-                , descendant_token_count, source_message_token_count
-       FROM summaries WHERE summary_id = ?`,
-      )
-      .get(input.summaryId) as unknown as SummaryRow;
-
     return toSummaryRecord(row);
   }
 
@@ -685,13 +697,26 @@ export class SummaryStore {
     const limit = input.limit ?? 50;
 
     if (input.mode === "full_text") {
-      return this.searchFullText(
-        input.query,
-        limit,
-        input.conversationId,
-        input.since,
-        input.before,
-      );
+      if (this.fts5Available) {
+        try {
+          return this.searchFullText(
+            input.query,
+            limit,
+            input.conversationId,
+            input.since,
+            input.before,
+          );
+        } catch {
+          return this.searchLike(
+            input.query,
+            limit,
+            input.conversationId,
+            input.since,
+            input.before,
+          );
+        }
+      }
+      return this.searchLike(input.query, limit, input.conversationId, input.since, input.before);
     }
     return this.searchRegex(input.query, limit, input.conversationId, input.since, input.before);
   }
@@ -735,6 +760,57 @@ export class SummaryStore {
     return rows.map(toSearchResult);
   }
 
+  private searchLike(
+    query: string,
+    limit: number,
+    conversationId?: number,
+    since?: Date,
+    before?: Date,
+  ): SummarySearchResult[] {
+    const plan = buildLikeSearchPlan("content", query);
+    if (plan.terms.length === 0) {
+      return [];
+    }
+
+    const where: string[] = [...plan.where];
+    const args: Array<string | number> = [...plan.args];
+    if (conversationId != null) {
+      where.push("conversation_id = ?");
+      args.push(conversationId);
+    }
+    if (since) {
+      where.push("julianday(created_at) >= julianday(?)");
+      args.push(since.toISOString());
+    }
+    if (before) {
+      where.push("julianday(created_at) < julianday(?)");
+      args.push(before.toISOString());
+    }
+    args.push(limit);
+
+    const whereClause = where.length > 0 ? `WHERE ${where.join(" AND ")}` : "";
+    const rows = this.db
+      .prepare(
+        `SELECT summary_id, conversation_id, kind, depth, content, token_count, file_ids,
+                earliest_at, latest_at, descendant_count, descendant_token_count,
+                source_message_token_count, created_at
+         FROM summaries
+         ${whereClause}
+         ORDER BY created_at DESC
+         LIMIT ?`,
+      )
+      .all(...args) as unknown as SummaryRow[];
+
+    return rows.map((row) => ({
+      summaryId: row.summary_id,
+      conversationId: row.conversation_id,
+      kind: row.kind,
+      snippet: createFallbackSnippet(row.content, plan.terms),
+      createdAt: new Date(row.created_at),
+      rank: 0,
+    }));
+  }
+
   private searchRegex(
     pattern: string,
     limit: number,