@martian-engineering/lossless-claw 0.2.1 → 0.2.3

package/README.md

@@ -1,11 +1,11 @@
 # lossless-claw
 
-> ⚠️ **Current requirement:** This plugin currently requires a custom OpenClaw build with [PR #22201](https://github.com/openclaw/openclaw/pull/22201) applied until that PR is merged upstream.
-
 Lossless Context Management plugin for [OpenClaw](https://github.com/openclaw/openclaw), based on the [LCM paper](https://papers.voltropy.com/LCM). Replaces OpenClaw's built-in sliding-window compaction with a DAG-based summarization system that preserves every message while keeping active context within model token limits.
 
 ## What it does
 
+Two ways to learn: read the below, or [check out this super cool animated visualization](https://losslesscontext.ai).
+
 When a conversation grows beyond the model's context window, OpenClaw (just like all of the other agents) normally truncates older messages. LCM instead:
 
 1. **Persists every message** in a SQLite database, organized by conversation
@@ -68,23 +68,182 @@ 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.
 
 ### Plugin config
 
-Add an `lossless-claw` block under `plugins.config` in your OpenClaw config:
+Add a `lossless-claw` entry under `plugins.entries` in your OpenClaw config:
 
 ```json
 {
   "plugins": {
-    "config": {
+    "entries": {
       "lossless-claw": {
-        "enabled": true,
-        "freshTailCount": 32,
-        "contextThreshold": 0.75,
-        "incrementalMaxDepth": 1
+        "enabled": true
       }
     }
   }
@@ -102,7 +261,7 @@ Add an `lossless-claw` block under `plugins.config` in your OpenClaw config:
 | `LCM_LEAF_MIN_FANOUT` | `8` | Minimum raw messages per leaf summary |
 | `LCM_CONDENSED_MIN_FANOUT` | `4` | Minimum summaries per condensed node |
 | `LCM_CONDENSED_MIN_FANOUT_HARD` | `2` | Relaxed fanout for forced compaction sweeps |
-| `LCM_INCREMENTAL_MAX_DEPTH` | `0` | How deep incremental compaction goes (0 = leaf only) |
+| `LCM_INCREMENTAL_MAX_DEPTH` | `0` | How deep incremental compaction goes (0 = leaf only, -1 = unlimited) |
 | `LCM_LEAF_CHUNK_TOKENS` | `20000` | Max source tokens per leaf compaction chunk |
 | `LCM_LEAF_TARGET_TOKENS` | `1200` | Target token count for leaf summaries |
 | `LCM_CONDENSED_TARGET_TOKENS` | `2000` | Target token count for condensed summaries |
@@ -110,18 +269,18 @@ Add an `lossless-claw` block under `plugins.config` in your OpenClaw config:
 | `LCM_LARGE_FILE_TOKEN_THRESHOLD` | `25000` | File blocks above this size are intercepted and stored separately |
 | `LCM_SUMMARY_MODEL` | *(from OpenClaw)* | Model for summarization (e.g. `anthropic/claude-sonnet-4-20250514`) |
 | `LCM_SUMMARY_PROVIDER` | *(from OpenClaw)* | Provider override for summarization |
-| `LCM_INCREMENTAL_MAX_DEPTH` | `0` | Depth limit for incremental condensation after leaf passes |
+| `LCM_INCREMENTAL_MAX_DEPTH` | `0` | Depth limit for incremental condensation after leaf passes (-1 = unlimited) |
 
 ### Recommended starting configuration
 
 ```
 LCM_FRESH_TAIL_COUNT=32
-LCM_INCREMENTAL_MAX_DEPTH=1
+LCM_INCREMENTAL_MAX_DEPTH=-1
 LCM_CONTEXT_THRESHOLD=0.75
 ```
 
 - **freshTailCount=32** protects the last 32 messages from compaction, giving the model enough recent context for continuity.
-- **incrementalMaxDepth=1** enables automatic condensation of leaf summaries after each compaction pass (without this, only leaf summaries are created and condensation only happens during manual `/compact` or overflow).
+- **incrementalMaxDepth=-1** enables unlimited automatic condensation after each compaction pass — the DAG cascades as deep as needed. Set to `0` (default) for leaf-only, or a positive integer for a specific depth cap.
 - **contextThreshold=0.75** triggers compaction when context reaches 75% of the model's window, leaving headroom for the model's response.
 
 ## How it works
@@ -171,7 +330,7 @@ This gives the model enough information to know what was discussed, when, and ho
 
 Compaction runs in two modes:
 
-- **Proactive (after each turn):** If raw messages outside the fresh tail exceed `leafChunkTokens`, a leaf pass runs. If `incrementalMaxDepth > 0`, condensation follows.
+- **Proactive (after each turn):** If raw messages outside the fresh tail exceed `leafChunkTokens`, a leaf pass runs. If `incrementalMaxDepth != 0`, condensation follows (cascading to the configured depth, or unlimited with `-1`).
 - **Reactive (overflow/manual):** When total context exceeds `contextThreshold × tokenBudget`, a full sweep runs: all eligible leaf chunks are compacted, then condensation proceeds depth-by-depth until stable.
 
 ### Depth-aware prompts

package/docs/architecture.md

@@ -87,7 +87,7 @@ The **condensed pass** merges summaries at the same depth into a higher-level su
 **Incremental (after each turn):**
 - Checks if raw tokens outside the fresh tail exceed `leafChunkTokens`
 - If so, runs one leaf pass
-- If `incrementalMaxDepth > 0`, follows with condensation passes up to that depth
+- If `incrementalMaxDepth != 0`, follows with condensation passes up to that depth (`-1` for unlimited)
 - Best-effort: failures don't break the conversation
 
 **Full sweep (manual `/compact` or overflow):**

package/docs/configuration.md

@@ -26,7 +26,7 @@ Set recommended environment variables:
 
 ```bash
 export LCM_FRESH_TAIL_COUNT=32
-export LCM_INCREMENTAL_MAX_DEPTH=1
+export LCM_INCREMENTAL_MAX_DEPTH=-1
 ```
 
 Restart OpenClaw.
@@ -70,8 +70,9 @@ For coding conversations with tool calls (which generate many messages per logic
 `LCM_INCREMENTAL_MAX_DEPTH` (default `0`) controls whether condensation happens automatically after leaf passes.
 
 - **0** — Only leaf summaries are created incrementally. Condensation only happens during manual `/compact` or overflow.
-- **1** — After each leaf pass, attempt to condense d0 summaries into d1. Good default for active conversations.
-- **2+** — Deeper automatic condensation. Rarely needed; the full sweep handles this during overflow.
+- **1** — After each leaf pass, attempt to condense d0 summaries into d1.
+- **2+** — Deeper automatic condensation up to the specified depth.
+- **-1** — Unlimited depth. Condensation cascades as deep as needed after each leaf pass. Recommended for long-running sessions.
 
 ### Summary target tokens
 

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();
+  const pluginConfig =
+    api.pluginConfig && typeof api.pluginConfig === "object" && !Array.isArray(api.pluginConfig)
+      ? api.pluginConfig
+      : undefined;
+  const config = resolveLcmConfig(process.env, pluginConfig);
 
   return {
     config,
@@ -862,17 +866,11 @@ const lcmPlugin = {
 
   configSchema: {
     parse(value: unknown) {
-      // Merge plugin config with env vars — env vars take precedence for backward compat
       const raw =
         value && typeof value === "object" && !Array.isArray(value)
           ? (value as Record<string, unknown>)
           : {};
-      const enabled = typeof raw.enabled === "boolean" ? raw.enabled : undefined;
-      const config = resolveLcmConfig();
-      if (enabled !== undefined) {
-        config.enabled = enabled;
-      }
-      return config;
+      return resolveLcmConfig(process.env, raw);
     },
   },
 

package/openclaw.plugin.json

@@ -7,7 +7,7 @@
     },
     "incrementalMaxDepth": {
       "label": "Incremental Max Depth",
-      "help": "How deep incremental compaction goes (0 = leaf only)"
+      "help": "How deep incremental compaction goes (0 = leaf only, -1 = unlimited)"
     },
     "freshTailCount": {
       "label": "Fresh Tail Count",
@@ -32,7 +32,7 @@
       },
       "incrementalMaxDepth": {
         "type": "integer",
-        "minimum": 0
+        "minimum": -1
       },
       "freshTailCount": {
         "type": "integer",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@martian-engineering/lossless-claw",
-  "version": "0.2.1",
+  "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

@@ -26,25 +26,102 @@ export type LcmConfig = {
   pruneHeartbeatOk: boolean;
 };
 
-export function resolveLcmConfig(env: NodeJS.ProcessEnv = process.env): LcmConfig {
+/** Safely coerce an unknown value to a finite number, or return undefined. */
+function toNumber(value: unknown): number | undefined {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string") {
+    const n = Number(value);
+    if (Number.isFinite(n)) return n;
+  }
+  return undefined;
+}
+
+/** Safely coerce an unknown value to a boolean, or return undefined. */
+function toBool(value: unknown): boolean | undefined {
+  if (typeof value === "boolean") return value;
+  if (value === "true") return true;
+  if (value === "false") return false;
+  return undefined;
+}
+
+/** Safely coerce an unknown value to a trimmed non-empty string, or return undefined. */
+function toStr(value: unknown): string | undefined {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+  }
+  return undefined;
+}
+
+/**
+ * Resolve LCM configuration with three-tier precedence:
+ *   1. Environment variables (highest — backward compat)
+ *   2. Plugin config object (from plugins.entries.lossless-claw.config)
+ *   3. Hardcoded defaults (lowest)
+ */
+export function resolveLcmConfig(
+  env: NodeJS.ProcessEnv = process.env,
+  pluginConfig?: Record<string, unknown>,
+): LcmConfig {
+  const pc = pluginConfig ?? {};
+
   return {
-    enabled: env.LCM_ENABLED !== "false",
-    databasePath: env.LCM_DATABASE_PATH ?? join(homedir(), ".openclaw", "lcm.db"),
-    contextThreshold: parseFloat(env.LCM_CONTEXT_THRESHOLD ?? "0.75"),
-    freshTailCount: parseInt(env.LCM_FRESH_TAIL_COUNT ?? "32", 10),
-    leafMinFanout: parseInt(env.LCM_LEAF_MIN_FANOUT ?? "8", 10),
-    condensedMinFanout: parseInt(env.LCM_CONDENSED_MIN_FANOUT ?? "4", 10),
-    condensedMinFanoutHard: parseInt(env.LCM_CONDENSED_MIN_FANOUT_HARD ?? "2", 10),
-    incrementalMaxDepth: parseInt(env.LCM_INCREMENTAL_MAX_DEPTH ?? "0", 10),
-    leafChunkTokens: parseInt(env.LCM_LEAF_CHUNK_TOKENS ?? "20000", 10),
-    leafTargetTokens: parseInt(env.LCM_LEAF_TARGET_TOKENS ?? "1200", 10),
-    condensedTargetTokens: parseInt(env.LCM_CONDENSED_TARGET_TOKENS ?? "2000", 10),
-    maxExpandTokens: parseInt(env.LCM_MAX_EXPAND_TOKENS ?? "4000", 10),
-    largeFileTokenThreshold: parseInt(env.LCM_LARGE_FILE_TOKEN_THRESHOLD ?? "25000", 10),
-    largeFileSummaryProvider: env.LCM_LARGE_FILE_SUMMARY_PROVIDER?.trim() ?? "",
-    largeFileSummaryModel: env.LCM_LARGE_FILE_SUMMARY_MODEL?.trim() ?? "",
-    autocompactDisabled: env.LCM_AUTOCOMPACT_DISABLED === "true",
-    timezone: env.TZ ?? Intl.DateTimeFormat().resolvedOptions().timeZone,
-    pruneHeartbeatOk: env.LCM_PRUNE_HEARTBEAT_OK === "true",
+    enabled:
+      env.LCM_ENABLED !== undefined
+        ? env.LCM_ENABLED !== "false"
+        : toBool(pc.enabled) ?? true,
+    databasePath:
+      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,
+    freshTailCount:
+      (env.LCM_FRESH_TAIL_COUNT !== undefined ? parseInt(env.LCM_FRESH_TAIL_COUNT, 10) : undefined)
+        ?? toNumber(pc.freshTailCount) ?? 32,
+    leafMinFanout:
+      (env.LCM_LEAF_MIN_FANOUT !== undefined ? parseInt(env.LCM_LEAF_MIN_FANOUT, 10) : undefined)
+        ?? toNumber(pc.leafMinFanout) ?? 8,
+    condensedMinFanout:
+      (env.LCM_CONDENSED_MIN_FANOUT !== undefined ? parseInt(env.LCM_CONDENSED_MIN_FANOUT, 10) : undefined)
+        ?? toNumber(pc.condensedMinFanout) ?? 4,
+    condensedMinFanoutHard:
+      (env.LCM_CONDENSED_MIN_FANOUT_HARD !== undefined ? parseInt(env.LCM_CONDENSED_MIN_FANOUT_HARD, 10) : undefined)
+        ?? toNumber(pc.condensedMinFanoutHard) ?? 2,
+    incrementalMaxDepth:
+      (env.LCM_INCREMENTAL_MAX_DEPTH !== undefined ? parseInt(env.LCM_INCREMENTAL_MAX_DEPTH, 10) : undefined)
+        ?? toNumber(pc.incrementalMaxDepth) ?? 0,
+    leafChunkTokens:
+      (env.LCM_LEAF_CHUNK_TOKENS !== undefined ? parseInt(env.LCM_LEAF_CHUNK_TOKENS, 10) : undefined)
+        ?? toNumber(pc.leafChunkTokens) ?? 20000,
+    leafTargetTokens:
+      (env.LCM_LEAF_TARGET_TOKENS !== undefined ? parseInt(env.LCM_LEAF_TARGET_TOKENS, 10) : undefined)
+        ?? toNumber(pc.leafTargetTokens) ?? 1200,
+    condensedTargetTokens:
+      (env.LCM_CONDENSED_TARGET_TOKENS !== undefined ? parseInt(env.LCM_CONDENSED_TARGET_TOKENS, 10) : undefined)
+        ?? toNumber(pc.condensedTargetTokens) ?? 2000,
+    maxExpandTokens:
+      (env.LCM_MAX_EXPAND_TOKENS !== undefined ? parseInt(env.LCM_MAX_EXPAND_TOKENS, 10) : undefined)
+        ?? toNumber(pc.maxExpandTokens) ?? 4000,
+    largeFileTokenThreshold:
+      (env.LCM_LARGE_FILE_TOKEN_THRESHOLD !== undefined ? parseInt(env.LCM_LARGE_FILE_TOKEN_THRESHOLD, 10) : undefined)
+        ?? toNumber(pc.largeFileThresholdTokens)
+        ?? toNumber(pc.largeFileTokenThreshold)
+        ?? 25000,
+    largeFileSummaryProvider:
+      env.LCM_LARGE_FILE_SUMMARY_PROVIDER?.trim() ?? toStr(pc.largeFileSummaryProvider) ?? "",
+    largeFileSummaryModel:
+      env.LCM_LARGE_FILE_SUMMARY_MODEL?.trim() ?? toStr(pc.largeFileSummaryModel) ?? "",
+    autocompactDisabled:
+      env.LCM_AUTOCOMPACT_DISABLED !== undefined
+        ? env.LCM_AUTOCOMPACT_DISABLED === "true"
+        : toBool(pc.autocompactDisabled) ?? false,
+    timezone: env.TZ ?? toStr(pc.timezone) ?? Intl.DateTimeFormat().resolvedOptions().timeZone,
+    pruneHeartbeatOk:
+      env.LCM_PRUNE_HEARTBEAT_OK !== undefined
+        ? env.LCM_PRUNE_HEARTBEAT_OK === "true"
+        : toBool(pc.pruneHeartbeatOk) ?? false,
   };
 }

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,

package/src/summarize.ts

@@ -1,4 +1,3 @@
-import { resolveLcmConfig } from "./db/config.js";
 import type { LcmDependencies } from "./types.js";
 
 export type LcmSummarizeOptions = {
@@ -675,11 +674,10 @@ export async function createLcmSummarizeFromLegacyParams(params: {
 
   const apiKey = params.deps.getApiKey(provider, model);
 
-  const runtimeLcmConfig = resolveLcmConfig();
   const condensedTargetTokens =
-    Number.isFinite(runtimeLcmConfig.condensedTargetTokens) &&
-    runtimeLcmConfig.condensedTargetTokens > 0
-      ? runtimeLcmConfig.condensedTargetTokens
+    Number.isFinite(params.deps.config.condensedTargetTokens) &&
+    params.deps.config.condensedTargetTokens > 0
+      ? params.deps.config.condensedTargetTokens
       : DEFAULT_CONDENSED_TARGET_TOKENS;
 
   return async (