@martian-engineering/lossless-claw 0.2.2 → 0.2.4

package/README.md

@@ -22,7 +22,7 @@ Nothing is lost. Raw messages stay in the database. Summaries link back to their
 
 ### Prerequisites
 
-- OpenClaw with context engine support (josh/context-engine branch or equivalent)
+- OpenClaw with plugin context engine support
 - Node.js 22+
 - An LLM provider configured in OpenClaw (used for summarization)
 
@@ -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.
@@ -110,9 +272,12 @@ Add a `lossless-claw` entry under `plugins.entries` in your OpenClaw config:
 | `LCM_CONDENSED_TARGET_TOKENS` | `2000` | Target token count for condensed summaries |
 | `LCM_MAX_EXPAND_TOKENS` | `4000` | Token cap for sub-agent expansion queries |
 | `LCM_LARGE_FILE_TOKEN_THRESHOLD` | `25000` | File blocks above this size are intercepted and stored separately |
+| `LCM_LARGE_FILE_SUMMARY_PROVIDER` | `""` | Provider override for large-file summarization |
+| `LCM_LARGE_FILE_SUMMARY_MODEL` | `""` | Model override for large-file summarization |
 | `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 (-1 = unlimited) |
+| `LCM_AUTOCOMPACT_DISABLED` | `false` | Disable automatic compaction after turns |
+| `LCM_PRUNE_HEARTBEAT_OK` | `false` | Retroactively delete `HEARTBEAT_OK` turn cycles from LCM storage |
 
 ### Recommended starting configuration
 
@@ -126,6 +291,47 @@ LCM_CONTEXT_THRESHOLD=0.75
 - **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.
 
+### OpenClaw session reset settings
+
+LCM preserves history through compaction, but it does **not** change OpenClaw's core session reset policy. If sessions are resetting sooner than you want, increase OpenClaw's `session.reset.idleMinutes` or use a channel/type-specific override.
+
+```json
+{
+  "session": {
+    "reset": {
+      "mode": "idle",
+      "idleMinutes": 10080
+    }
+  }
+}
+```
+
+- `session.reset.mode: "idle"` keeps a session alive until the idle window expires.
+- `session.reset.idleMinutes` is the actual reset interval in minutes.
+- OpenClaw does **not** currently enforce a maximum `idleMinutes`; in source it is validated only as a positive integer.
+- If you also use daily reset mode, `idleMinutes` acts as a secondary guard and the session resets when **either** the daily boundary or the idle window is reached first.
+- Legacy `session.idleMinutes` still works, but OpenClaw prefers `session.reset.idleMinutes`.
+
+Useful values:
+
+- `1440` = 1 day
+- `10080` = 7 days
+- `43200` = 30 days
+- `525600` = 365 days
+
+For most long-lived LCM setups, a good starting point is:
+
+```json
+{
+  "session": {
+    "reset": {
+      "mode": "idle",
+      "idleMinutes": 10080
+    }
+  }
+}
+```
+
 ## How it works
 
 See [docs/architecture.md](docs/architecture.md) for the full technical deep-dive. Here's the summary:

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.4",
   "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/assembler.ts

@@ -144,6 +144,137 @@ function getOriginalRole(parts: MessagePartRecord[]): string | null {
   return null;
 }
 
+function getPartMetadata(part: MessagePartRecord): {
+  originalRole?: string;
+  rawType?: string;
+  raw?: unknown;
+} {
+  const decoded = parseJson(part.metadata);
+  if (!decoded || typeof decoded !== "object") {
+    return {};
+  }
+
+  const record = decoded as {
+    originalRole?: unknown;
+    rawType?: unknown;
+    raw?: unknown;
+  };
+  return {
+    originalRole:
+      typeof record.originalRole === "string" && record.originalRole.length > 0
+        ? record.originalRole
+        : undefined,
+    rawType:
+      typeof record.rawType === "string" && record.rawType.length > 0
+        ? record.rawType
+        : undefined,
+    raw: record.raw,
+  };
+}
+
+function parseStoredValue(value: string | null): unknown {
+  if (typeof value !== "string" || value.length === 0) {
+    return undefined;
+  }
+  const parsed = parseJson(value);
+  return parsed !== undefined ? parsed : value;
+}
+
+function reasoningBlockFromPart(part: MessagePartRecord, rawType?: string): unknown {
+  const type = rawType === "thinking" ? "thinking" : "reasoning";
+  if (typeof part.textContent === "string" && part.textContent.length > 0) {
+    return type === "thinking"
+      ? { type, thinking: part.textContent }
+      : { type, text: part.textContent };
+  }
+  return { type };
+}
+
+/**
+ * Detect if a raw block is an OpenClaw-normalised OpenAI reasoning item.
+ * OpenClaw converts OpenAI `{type:"reasoning", id:"rs_…", encrypted_content:"…"}`
+ * into `{type:"thinking", thinking:"", thinkingSignature:"{…}"}`.
+ * When we reassemble for the OpenAI provider we need the original back.
+ */
+function tryRestoreOpenAIReasoning(raw: Record<string, unknown>): Record<string, unknown> | null {
+  if (raw.type !== "thinking") return null;
+  const sig = raw.thinkingSignature;
+  if (typeof sig !== "string" || !sig.startsWith("{")) return null;
+  try {
+    const parsed = JSON.parse(sig) as Record<string, unknown>;
+    if (parsed.type === "reasoning" && typeof parsed.id === "string") {
+      return parsed;
+    }
+  } catch {
+    // not valid JSON — leave as-is
+  }
+  return null;
+}
+
+function toolCallBlockFromPart(part: MessagePartRecord, rawType?: string): unknown {
+  const type =
+    rawType === "function_call" ||
+    rawType === "functionCall" ||
+    rawType === "tool_use" ||
+    rawType === "tool-use" ||
+    rawType === "toolUse" ||
+    rawType === "toolCall"
+      ? rawType
+      : "toolCall";
+  const input = parseStoredValue(part.toolInput);
+  const block: Record<string, unknown> = { type };
+
+  if (type === "function_call") {
+    if (typeof part.toolCallId === "string" && part.toolCallId.length > 0) {
+      block.call_id = part.toolCallId;
+    }
+    if (typeof part.toolName === "string" && part.toolName.length > 0) {
+      block.name = part.toolName;
+    }
+    if (input !== undefined) {
+      block.arguments = input;
+    }
+    return block;
+  }
+
+  if (typeof part.toolCallId === "string" && part.toolCallId.length > 0) {
+    block.id = part.toolCallId;
+  }
+  if (typeof part.toolName === "string" && part.toolName.length > 0) {
+    block.name = part.toolName;
+  }
+
+  if (input !== undefined) {
+    if (type === "functionCall") {
+      block.arguments = input;
+    } else {
+      block.input = input;
+    }
+  }
+  return block;
+}
+
+function toolResultBlockFromPart(part: MessagePartRecord, rawType?: string): unknown {
+  const type =
+    rawType === "function_call_output" || rawType === "toolResult" || rawType === "tool_result"
+      ? rawType
+      : "tool_result";
+  const output = parseStoredValue(part.toolOutput) ?? part.textContent ?? "";
+  const block: Record<string, unknown> = { type, output };
+
+  if (type === "function_call_output") {
+    if (typeof part.toolCallId === "string" && part.toolCallId.length > 0) {
+      block.call_id = part.toolCallId;
+    }
+    return block;
+  }
+
+  if (typeof part.toolCallId === "string" && part.toolCallId.length > 0) {
+    block.tool_use_id = part.toolCallId;
+  }
+  return block;
+}
+
 function toRuntimeRole(
   dbRole: MessageRole,
   parts: MessagePartRecord[],
@@ -173,26 +304,43 @@ function toRuntimeRole(
 }
 
 function blockFromPart(part: MessagePartRecord): unknown {
-  const decoded = parseJson(part.metadata);
-  if (decoded && typeof decoded === "object") {
-    const raw = (decoded as { raw?: unknown }).raw;
-    if (raw && typeof raw === "object") {
-      return raw;
-    }
+  const metadata = getPartMetadata(part);
+  if (metadata.raw && typeof metadata.raw === "object") {
+    // If this is an OpenClaw-normalised OpenAI reasoning block, restore the original
+    // OpenAI format so the Responses API gets the {type:"reasoning", id:"rs_…"} it expects.
+    const restored = tryRestoreOpenAIReasoning(metadata.raw as Record<string, unknown>);
+    if (restored) return restored;
+    return metadata.raw;
   }
 
-  if (part.partType === "text" || part.partType === "reasoning") {
-    return { type: "text", text: part.textContent ?? "" };
+  if (part.partType === "reasoning") {
+    return reasoningBlockFromPart(part, metadata.rawType);
   }
   if (part.partType === "tool") {
-    const toolOutput = parseJson(part.toolOutput);
-    if (toolOutput !== undefined) {
-      return toolOutput;
-    }
-    if (typeof part.textContent === "string") {
-      return { type: "text", text: part.textContent };
+    if (metadata.originalRole === "toolResult" || metadata.rawType === "function_call_output") {
+      return toolResultBlockFromPart(part, metadata.rawType);
     }
-    return { type: "text", text: part.toolOutput ?? part.toolInput ?? "" };
+    return toolCallBlockFromPart(part, metadata.rawType);
+  }
+  if (
+    metadata.rawType === "function_call" ||
+    metadata.rawType === "functionCall" ||
+    metadata.rawType === "tool_use" ||
+    metadata.rawType === "tool-use" ||
+    metadata.rawType === "toolUse" ||
+    metadata.rawType === "toolCall"
+  ) {
+    return toolCallBlockFromPart(part, metadata.rawType);
+  }
+  if (
+    metadata.rawType === "function_call_output" ||
+    metadata.rawType === "tool_result" ||
+    metadata.rawType === "toolResult"
+  ) {
+    return toolResultBlockFromPart(part, metadata.rawType);
+  }
+  if (part.partType === "text") {
+    return { type: "text", text: part.textContent ?? "" };
   }
 
   if (typeof part.textContent === "string" && part.textContent.length > 0) {

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,
@@ -59,6 +60,39 @@ function safeString(value: unknown): string | undefined {
   return typeof value === "string" ? value : undefined;
 }
 
+function appendTextValue(value: unknown, out: string[]): void {
+  if (typeof value === "string") {
+    out.push(value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      appendTextValue(entry, out);
+    }
+    return;
+  }
+  if (!value || typeof value !== "object") {
+    return;
+  }
+
+  const record = value as Record<string, unknown>;
+  appendTextValue(record.text, out);
+  appendTextValue(record.value, out);
+}
+
+function extractReasoningText(record: Record<string, unknown>): string | undefined {
+  const chunks: string[] = [];
+  appendTextValue(record.summary, chunks);
+  if (chunks.length === 0) {
+    return undefined;
+  }
+
+  const normalized = chunks
+    .map((chunk) => chunk.trim())
+    .filter((chunk, idx, arr) => chunk.length > 0 && arr.indexOf(chunk) === idx);
+  return normalized.length > 0 ? normalized.join("\n") : undefined;
+}
+
 function normalizeUnknownBlock(value: unknown): {
   type: string;
   text?: string;
@@ -75,7 +109,12 @@ function normalizeUnknownBlock(value: unknown): {
   const rawType = safeString(record.type);
   return {
     type: rawType ?? "agent",
-    text: safeString(record.text) ?? safeString(record.thinking),
+    text:
+      safeString(record.text) ??
+      safeString(record.thinking) ??
+      ((rawType === "reasoning" || rawType === "thinking")
+        ? extractReasoningText(record)
+        : undefined),
     metadata: { raw: record },
   };
 }
@@ -88,7 +127,12 @@ function toPartType(type: string): MessagePartType {
     case "reasoning":
       return "reasoning";
     case "tool_use":
+    case "toolUse":
     case "tool-use":
+    case "toolCall":
+    case "functionCall":
+    case "function_call":
+    case "function_call_output":
     case "tool_result":
     case "toolResult":
     case "tool":
@@ -214,7 +258,12 @@ function buildMessageParts(params: {
   const role = typeof message.role === "string" ? message.role : "unknown";
   const topLevel = message as unknown as Record<string, unknown>;
   const topLevelToolCallId =
-    safeString(topLevel.toolCallId) ?? safeString(topLevel.tool_call_id) ?? safeString(topLevel.id);
+    safeString(topLevel.toolCallId) ??
+    safeString(topLevel.tool_call_id) ??
+    safeString(topLevel.toolUseId) ??
+    safeString(topLevel.tool_use_id) ??
+    safeString(topLevel.call_id) ??
+    safeString(topLevel.id);
 
   // BashExecutionMessage: preserve a synthetic text part so output is round-trippable.
   if (!("content" in message) && "command" in message && "output" in message) {
@@ -283,14 +332,19 @@ function buildMessageParts(params: {
   for (let ordinal = 0; ordinal < message.content.length; ordinal++) {
     const block = normalizeUnknownBlock(message.content[ordinal]);
     const metadataRecord = block.metadata.raw as Record<string, unknown> | undefined;
+    const partType = toPartType(block.type);
     const toolCallId =
       safeString(metadataRecord?.toolCallId) ??
       safeString(metadataRecord?.tool_call_id) ??
+      safeString(metadataRecord?.toolUseId) ??
+      safeString(metadataRecord?.tool_use_id) ??
+      safeString(metadataRecord?.call_id) ??
+      (partType === "tool" ? safeString(metadataRecord?.id) : undefined) ??
       topLevelToolCallId;
 
     parts.push({
       sessionId,
-      partType: toPartType(block.type),
+      partType,
       ordinal,
       textContent: block.text ?? null,
       toolCallId,
@@ -301,6 +355,8 @@ function buildMessageParts(params: {
       toolInput:
         metadataRecord?.input !== undefined
           ? toJson(metadataRecord.input)
+          : metadataRecord?.arguments !== undefined
+            ? toJson(metadataRecord.arguments)
           : metadataRecord?.toolInput !== undefined
             ? toJson(metadataRecord.toolInput)
             : (safeString(metadataRecord?.tool_input) ?? null),
@@ -513,6 +569,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 +580,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, { fts5Available: this.fts5Available });
+    this.summaryStore = new SummaryStore(db, { fts5Available: this.fts5Available });
 
-    this.conversationStore = new ConversationStore(db);
-    this.summaryStore = new SummaryStore(db);
+    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 +625,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/transcript-repair.ts

@@ -27,7 +27,80 @@ type ToolCallLike = {
 
 // -- Extraction helpers (from tool-call-id.ts) --
 
-const TOOL_CALL_TYPES = new Set(["toolCall", "toolUse", "functionCall"]);
+const TOOL_CALL_TYPES = new Set([
+  "toolCall",
+  "toolUse",
+  "tool_use",
+  "tool-use",
+  "functionCall",
+  "function_call",
+]);
+const OPENAI_FUNCTION_CALL_TYPES = new Set(["functionCall", "function_call"]);
+
+function extractToolCallId(block: { id?: unknown; call_id?: unknown }): string | null {
+  if (typeof block.id === "string" && block.id) {
+    return block.id;
+  }
+  if (typeof block.call_id === "string" && block.call_id) {
+    return block.call_id;
+  }
+  return null;
+}
+
+function normalizeAssistantReasoningBlocks<T extends AgentMessageLike>(message: T): T {
+  if (!Array.isArray(message.content)) {
+    return message;
+  }
+
+  let sawToolCall = false;
+  let reasoningAfterToolCall = false;
+  let functionCallCount = 0;
+
+  for (const block of message.content) {
+    if (!block || typeof block !== "object") {
+      return message;
+    }
+
+    const type = (block as { type?: unknown }).type;
+    if (type === "reasoning" || type === "thinking") {
+      if (sawToolCall) {
+        reasoningAfterToolCall = true;
+      }
+      continue;
+    }
+
+    if (typeof type === "string" && TOOL_CALL_TYPES.has(type)) {
+      sawToolCall = true;
+      if (OPENAI_FUNCTION_CALL_TYPES.has(type)) {
+        functionCallCount += 1;
+      }
+      continue;
+    }
+
+    return message;
+  }
+
+  // Only repair the specific OpenAI shape we need: a single function call that
+  // has one or more reasoning blocks after it. Multi-call turns may use
+  // interleaved reasoning intentionally, so leave them untouched.
+  if (!reasoningAfterToolCall || functionCallCount !== 1) {
+    return message;
+  }
+
+  const reasoning = message.content.filter((block) => {
+    const type = (block as { type?: unknown }).type;
+    return type === "reasoning" || type === "thinking";
+  });
+  const toolCalls = message.content.filter((block) => {
+    const type = (block as { type?: unknown }).type;
+    return typeof type === "string" && TOOL_CALL_TYPES.has(type);
+  });
+
+  return {
+    ...message,
+    content: [...reasoning, ...toolCalls],
+  };
+}
 
 function extractToolCallsFromAssistant(msg: AgentMessageLike): ToolCallLike[] {
   const content = msg.content;
@@ -40,13 +113,14 @@ function extractToolCallsFromAssistant(msg: AgentMessageLike): ToolCallLike[] {
     if (!block || typeof block !== "object") {
       continue;
     }
-    const rec = block as { type?: unknown; id?: unknown; name?: unknown };
-    if (typeof rec.id !== "string" || !rec.id) {
+    const rec = block as { type?: unknown; id?: unknown; call_id?: unknown; name?: unknown };
+    const id = extractToolCallId(rec);
+    if (!id) {
       continue;
     }
     if (typeof rec.type === "string" && TOOL_CALL_TYPES.has(rec.type)) {
       toolCalls.push({
-        id: rec.id,
+        id,
         name: typeof rec.name === "string" ? rec.name : undefined,
       });
     }
@@ -134,18 +208,23 @@ export function sanitizeToolUseResultPairing<T extends AgentMessageLike>(message
       continue;
     }
 
+    const normalizedAssistant = normalizeAssistantReasoningBlocks(msg);
+    if (normalizedAssistant !== msg) {
+      changed = true;
+    }
+
     // Skip tool call extraction for aborted or errored assistant messages.
     // When stopReason is "error" or "aborted", the tool_use blocks may be incomplete
     // and should not have synthetic tool_results created.
-    const stopReason = msg.stopReason;
+    const stopReason = normalizedAssistant.stopReason;
     if (stopReason === "error" || stopReason === "aborted") {
-      out.push(msg);
+      out.push(normalizedAssistant as T);
       continue;
     }
 
-    const toolCalls = extractToolCallsFromAssistant(msg);
+    const toolCalls = extractToolCallsFromAssistant(normalizedAssistant);
     if (toolCalls.length === 0) {
-      out.push(msg);
+      out.push(normalizedAssistant as T);
       continue;
     }
 
@@ -190,7 +269,7 @@ export function sanitizeToolUseResultPairing<T extends AgentMessageLike>(message
       }
     }
 
-    out.push(msg);
+    out.push(normalizedAssistant as T);
 
     if (spanResultsById.size > 0 && remainder.length > 0) {
       moved = true;