fix: resolve critical FTS indexing and search bugs

This commit fixes multiple critical bugs that prevented full-text search
from working properly:

1. **Wrong IndexAsync signature** (ContentStorageService.cs)
   - Was calling legacy 2-param IndexAsync(contentId, content)
   - Now properly calls 4-param IndexAsync(contentId, title, desc, content)
   - This ensures title and description fields are indexed for search

2. **Incorrect phrase search syntax** (NodeSearchService.cs)
   - Phrase searches now use "phrase" instead of field:"phrase"
   - Single-word searches use field:term syntax
   - Fixes FTS5 compatibility issues with multi-word queries

3. **SQLite connections not disposed** (ContentService.cs + Commands)
   - Made ContentService IDisposable to properly close FTS connections
   - Updated all CLI commands to use 'using' statements
   - Ensures writes are flushed before process exits

4. **Force synchronous writes** (SqliteFtsIndex.cs)
   - Added PRAGMA synchronous=FULL for immediate persistence
   - Added WAL checkpoint on disposal to flush pending writes
   - Prevents data loss in short-lived CLI processes

All search functionality now working correctly with proper FTS indexing
of title, description, and content fields.

🤖 Generated with [Amplifier](https://github.com/microsoft/amplifier)

Co-Authored-By: Amplifier <[email protected]>

Author: dluc

src/Core/Search/NodeSearchService.cs

@@ -146,18 +146,29 @@ private string ExtractTerms(QueryNode node)
 
         private string ExtractTextSearch(TextSearchNode node)
         {
-            // Escape FTS5 special characters and quote the term
-            var escapedText = this.EscapeFtsText(node.SearchText);
+            // Check if this is a phrase search (contains spaces)
+            var isPhrase = node.SearchText.Contains(' ', StringComparison.Ordinal);
+
+            if (isPhrase)
+            {
+                // Phrase searches: use quotes and no field prefix
+                // FTS5 doesn't support field:phrase syntax well, so just search all fields
+                var escapedPhrase = node.SearchText.Replace("\"", "\"\"", StringComparison.Ordinal);
+                return $"\"{escapedPhrase}\"";
+            }
+
+            // Single word searches: use field prefix WITHOUT quotes
+            var escapedTerm = this.EscapeFtsSingleTerm(node.SearchText);
 
             // If specific field, prefix with field name (SQLite FTS5 syntax)
             if (node.Field != null && this.IsFtsField(node.Field.FieldPath))
             {
-                return $"{node.Field.FieldPath}:{escapedText}";
+                return $"{node.Field.FieldPath}:{escapedTerm}";
             }
 
             // Default field: search all FTS fields (title, description, content)
             // FTS5 syntax: {title description content}:term
-            return $"{{title description content}}:{escapedText}";
+            return $"{{title description content}}:{escapedTerm}";
         }
 
         private string ExtractLogical(LogicalNode node)
@@ -191,8 +202,18 @@ private string ExtractComparison(ComparisonNode node)
                 node.Value != null)
             {
                 var searchText = node.Value.AsString();
-                var escapedText = this.EscapeFtsText(searchText);
-                return $"{node.Field.FieldPath}:{escapedText}";
+                var isPhrase = searchText.Contains(' ', StringComparison.Ordinal);
+
+                if (isPhrase)
+                {
+                    // Phrase search: use quotes without field prefix
+                    var escapedPhrase = searchText.Replace("\"", "\"\"", StringComparison.Ordinal);
+                    return $"\"{escapedPhrase}\"";
+                }
+
+                // Single word: use field prefix without quotes
+                var escapedTerm = this.EscapeFtsSingleTerm(searchText);
+                return $"{node.Field.FieldPath}:{escapedTerm}";
             }
 
             // Other comparison operators (==, !=, >=, etc.) are handled by LINQ filtering
@@ -211,12 +232,16 @@ private bool IsFtsField(string? fieldPath)
             return normalized == "title" || normalized == "description" || normalized == "content";
         }
 
-        private string EscapeFtsText(string text)
+        private string EscapeFtsSingleTerm(string term)
         {
-            // FTS5 special characters that need escaping: " * ( ) 
-            // Wrap in quotes to handle spaces and special characters
-            var escaped = text.Replace("\"", "\"\"", StringComparison.Ordinal); // Escape quotes by doubling
-            return $"\"{escaped}\"";
+            // For single-word searches with field prefix (e.g., content:call)
+            // FTS5 does NOT support quotes after the colon: content:"call" is INVALID
+            // We must use: content:call
+            // 
+            // Escape FTS5 special characters: " * 
+            // For now, keep it simple: just remove quotes and wildcards that could break syntax
+            return term.Replace("\"", string.Empty, StringComparison.Ordinal)
+                      .Replace("*", string.Empty, StringComparison.Ordinal);
         }
     }
 }

src/Core/Search/SqliteFtsIndex.cs

@@ -44,6 +44,14 @@ public async Task InitializeAsync(CancellationToken cancellationToken = default)
         this._connection = new SqliteConnection(this._connectionString);
         await this._connection.OpenAsync(cancellationToken).ConfigureAwait(false);
 
+        // Set synchronous=FULL to ensure writes are immediately persisted to disk
+        // This prevents data loss when connections are disposed quickly (CLI scenario)
+        using (var pragmaCmd = this._connection.CreateCommand())
+        {
+            pragmaCmd.CommandText = "PRAGMA synchronous=FULL;";
+            await pragmaCmd.ExecuteNonQueryAsync(cancellationToken).ConfigureAwait(false);
+        }
+
         // Create FTS5 virtual table if it doesn't exist
         // BREAKING CHANGE: New schema indexes title, description, content separately
         // This enables field-specific search (e.g., title:kubernetes vs content:kubernetes)
@@ -201,6 +209,7 @@ public async Task ClearAsync(CancellationToken cancellationToken = default)
 
     /// <summary>
     /// Disposes the database connection.
+    /// Ensures all pending writes are flushed to disk before closing.
     /// </summary>
     public void Dispose()
     {
@@ -209,8 +218,27 @@ public void Dispose()
             return;
         }
 
-        this._connection?.Dispose();
-        this._connection = null;
+        // Flush any pending writes before closing the connection
+        // SQLite needs explicit close to ensure writes are persisted
+        if (this._connection != null)
+        {
+            try
+            {
+                // Execute a checkpoint to flush WAL to disk (if WAL mode is enabled)
+                using var cmd = this._connection.CreateCommand();
+                cmd.CommandText = "PRAGMA wal_checkpoint(TRUNCATE);";
+                cmd.ExecuteNonQuery();
+            }
+            catch (Exception ex)
+            {
+                this._logger.LogWarning(ex, "Failed to checkpoint WAL during FTS index disposal");
+            }
+
+            this._connection.Close();
+            this._connection.Dispose();
+            this._connection = null;
+        }
+
         this._disposed = true;
     }
 }

src/Core/Storage/ContentStorageService.cs

@@ -656,8 +656,18 @@ private async Task ExecuteIndexStepAsync(OperationRecord operation, string index
             return;
         }
 
-        // Update the search index
-        await searchIndex.IndexAsync(operation.ContentId, content.Content, cancellationToken).ConfigureAwait(false);
+        // Update the search index with title, description, and content
+        // Use the 4-parameter signature to properly index all fields
+        if (searchIndex is IFtsIndex ftsIndex)
+        {
+            await ftsIndex.IndexAsync(operation.ContentId, content.Title, content.Description, content.Content, cancellationToken).ConfigureAwait(false);
+        }
+        else
+        {
+            // Fallback for non-FTS indexes (vector, graph, etc.) - use legacy 2-parameter signature
+            await searchIndex.IndexAsync(operation.ContentId, content.Content, cancellationToken).ConfigureAwait(false);
+        }
+
         this._logger.LogDebug("Indexed content {ContentId} in search index {IndexId}", operation.ContentId, indexId);
     }
 

src/Main/CLI/Commands/BaseCommand.cs

@@ -133,8 +133,8 @@ protected ContentService CreateContentService(NodeConfig node, bool readonlyMode
         // Create storage service with search indexes
         var storage = new ContentStorageService(context, cuidGenerator, logger, searchIndexes);
 
-        // Create and return content service
-        return new ContentService(storage, node.Id);
+        // Create and return content service, passing search indexes for proper disposal
+        return new ContentService(storage, node.Id, searchIndexes);
     }
 
     /// <summary>

src/Main/CLI/Commands/DeleteCommand.cs

@@ -54,7 +54,7 @@ public override async Task<int> ExecuteAsync(
         try
         {
             var (config, node, formatter) = this.Initialize(settings);
-            var service = this.CreateContentService(node);
+            using var service = this.CreateContentService(node);
 
             // Delete is idempotent - no error if not found
             var result = await service.DeleteAsync(settings.Id, CancellationToken.None).ConfigureAwait(false);

src/Main/CLI/Commands/GetCommand.cs

@@ -59,7 +59,7 @@ public override async Task<int> ExecuteAsync(
         try
         {
             var (config, node, formatter) = this.Initialize(settings);
-            var service = this.CreateContentService(node, readonlyMode: true);
+            using var service = this.CreateContentService(node, readonlyMode: true);
 
             var result = await service.GetAsync(settings.Id, CancellationToken.None).ConfigureAwait(false);
 

src/Main/CLI/Commands/ListCommand.cs

@@ -66,7 +66,7 @@ public override async Task<int> ExecuteAsync(
         try
         {
             var (config, node, formatter) = this.Initialize(settings);
-            var service = this.CreateContentService(node, readonlyMode: true);
+            using var service = this.CreateContentService(node, readonlyMode: true);
 
             // Get total count
             var totalCount = await service.CountAsync(CancellationToken.None).ConfigureAwait(false);

src/Main/CLI/Commands/SearchCommand.cs

@@ -454,7 +454,7 @@ private SearchService CreateSearchService()
         foreach (var (nodeId, nodeConfig) in this.Config.Nodes)
         {
             // Create ContentService for this node
-            var contentService = this.CreateContentService(nodeConfig, readonlyMode: true);
+            using var contentService = this.CreateContentService(nodeConfig, readonlyMode: true);
 
             // Get FTS index from search indexes
             var ftsIndex = Services.SearchIndexFactory.CreateFtsIndex(nodeConfig.SearchIndexes);

src/Main/CLI/Commands/UpsertCommand.cs

@@ -76,7 +76,7 @@ public override async Task<int> ExecuteAsync(
         try
         {
             var (config, node, formatter) = this.Initialize(settings);
-            var service = this.CreateContentService(node);
+            using var service = this.CreateContentService(node);
 
             // Parse tags if provided
             var tags = string.IsNullOrWhiteSpace(settings.Tags)

src/Main/Services/ContentService.cs

@@ -1,4 +1,5 @@
 // Copyright (c) Microsoft. All rights reserved.
+using KernelMemory.Core.Search;
 using KernelMemory.Core.Storage;
 using KernelMemory.Core.Storage.Models;
 
@@ -7,21 +8,26 @@ namespace KernelMemory.Main.Services;
 /// <summary>
 /// Business logic layer for content operations.
 /// Wraps IContentStorage and provides CLI-friendly interface.
+/// Implements IDisposable to ensure search indexes are properly disposed.
 /// </summary>
-public class ContentService
+public sealed class ContentService : IDisposable
 {
     private readonly IContentStorage _storage;
     private readonly string _nodeId;
+    private readonly IReadOnlyDictionary<string, ISearchIndex>? _searchIndexes;
+    private bool _disposed;
 
     /// <summary>
     /// Initializes a new instance of ContentService.
     /// </summary>
     /// <param name="storage">The content storage implementation.</param>
     /// <param name="nodeId">The node ID this service operates on.</param>
-    public ContentService(IContentStorage storage, string nodeId)
+    /// <param name="searchIndexes">Optional search indexes to dispose when done.</param>
+    public ContentService(IContentStorage storage, string nodeId, IReadOnlyDictionary<string, ISearchIndex>? searchIndexes = null)
     {
         this._storage = storage;
         this._nodeId = nodeId;
+        this._searchIndexes = searchIndexes;
     }
 
     /// <summary>
@@ -88,4 +94,30 @@ public async Task<long> CountAsync(CancellationToken cancellationToken = default
     {
         return await this._storage.CountAsync(cancellationToken).ConfigureAwait(false);
     }
+
+    /// <summary>
+    /// Disposes the service and underlying search indexes.
+    /// </summary>
+    public void Dispose()
+    {
+        if (this._disposed)
+        {
+            return;
+        }
+
+        // Dispose all search indexes (e.g., SqliteFtsIndex connections)
+        if (this._searchIndexes != null)
+        {
+            foreach (var index in this._searchIndexes.Values)
+            {
+                if (index is IDisposable disposable)
+                {
+                    disposable.Dispose();
+                }
+            }
+        }
+
+        this._disposed = true;
+        GC.SuppressFinalize(this);
+    }
 }