feat(search): add FTS5 full-text search, sqlite-vec embeddings, and maintenance daemon

- Replace LIKE queries with FTS5 MATCH + BM25 ranking in SQLiteAdapter
- Add FTS5 virtual table with content-sync triggers and schema migration
- Add sqlite-vec integration for vector search (gated behind embeddingProvider)
- Implement searchByVector, searchHybrid, storeEmbedding, rebuildFtsIndex
- Add EmbeddingProvider abstraction with NoOp default
- Add DaemonMaintenanceService for stale frame cleanup, FTS rebuild,
  embedding backfill, VACUUM, and digest generation
- Register maintenance service in UnifiedDaemon lifecycle and CLI status
- Consolidate tests to reduce count from 513 to 488

Author: StackMemory Bot (CLI)

src/cli/commands/daemon.ts

@@ -138,6 +138,8 @@ The daemon provides:
           const services = [];
           if (newStatus.services.context.enabled) services.push('context');
           if (newStatus.services.linear.enabled) services.push('linear');
+          if (newStatus.services.maintenance?.enabled)
+            services.push('maintenance');
           if (newStatus.services.fileWatch.enabled) services.push('file-watch');
           if (services.length > 0) {
             console.log(chalk.gray(`Services: ${services.join(', ')}`));
@@ -298,6 +300,33 @@ The daemon provides:
         }
       }
 
+      // Maintenance service
+      const maint = status.services.maintenance;
+      if (maint) {
+        console.log(
+          `  Maintenance: ${maint.enabled ? chalk.green('Enabled') : chalk.gray('Disabled')}`
+        );
+        if (maint.enabled) {
+          console.log(
+            chalk.gray(`    Interval: ${config.maintenance.interval} min`)
+          );
+          if (maint.staleFramesCleaned) {
+            console.log(
+              chalk.gray(
+                `    Stale frames cleaned: ${maint.staleFramesCleaned}`
+              )
+            );
+          }
+          if (maint.ftsRebuilds) {
+            console.log(chalk.gray(`    FTS rebuilds: ${maint.ftsRebuilds}`));
+          }
+          if (maint.lastRun) {
+            const ago = Math.round((Date.now() - maint.lastRun) / 1000 / 60);
+            console.log(chalk.gray(`    Last run: ${ago} min ago`));
+          }
+        }
+      }
+
       // File watch
       const fw = status.services.fileWatch;
       console.log(

src/core/database/__tests__/fts-search.test.ts

@@ -0,0 +1,168 @@
+/**
+ * Tests for FTS5 Full-Text Search in SQLiteAdapter
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { SQLiteAdapter } from '../sqlite-adapter.js';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+describe('FTS5 Search', () => {
+  let adapter: SQLiteAdapter;
+  let dbPath: string;
+
+  beforeEach(async () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'stackmemory-fts-'));
+    dbPath = path.join(tmpDir, 'test.db');
+    adapter = new SQLiteAdapter('test-project', { dbPath });
+    await adapter.connect();
+    await adapter.initializeSchema();
+  });
+
+  afterEach(async () => {
+    await adapter.disconnect();
+    try {
+      fs.rmSync(path.dirname(dbPath), { recursive: true });
+    } catch {
+      // cleanup best-effort
+    }
+  });
+
+  it('should enable FTS5 and return BM25-ranked results with custom boost', async () => {
+    expect(adapter.getFeatures().supportsFullTextSearch).toBe(true);
+
+    await adapter.createFrame({
+      run_id: 'run-1',
+      project_id: 'test-project',
+      type: 'task',
+      name: 'authentication login flow',
+      digest_text: 'handles user auth',
+    });
+    await adapter.createFrame({
+      run_id: 'run-1',
+      project_id: 'test-project',
+      type: 'task',
+      name: 'database migration',
+      digest_text: 'authentication schema migration for login',
+    });
+    await adapter.createFrame({
+      run_id: 'run-1',
+      project_id: 'test-project',
+      type: 'task',
+      name: 'plain name',
+      inputs: JSON.stringify({ query: 'boosted content here' }),
+    });
+    await adapter.createFrame({
+      run_id: 'run-1',
+      project_id: 'test-project',
+      type: 'task',
+      name: 'boosted content here',
+      inputs: JSON.stringify({}),
+    });
+
+    // BM25 ranking: name match scores higher than digest-only match
+    const results = await adapter.search({ query: 'authentication' });
+    expect(results.length).toBeGreaterThanOrEqual(2);
+    const nameMatch = results.find(
+      (r) => r.name === 'authentication login flow'
+    );
+    const digestMatch = results.find((r) => r.name === 'database migration');
+    expect(nameMatch).toBeDefined();
+    expect(digestMatch).toBeDefined();
+    expect(nameMatch!.score).toBeGreaterThan(digestMatch!.score);
+
+    // Custom boost: inputs weighted 20x, name 1x → inputs match wins
+    const customResults = await adapter.search({
+      query: 'boosted',
+      boost: { name: 1, inputs: 20 },
+    });
+    expect(customResults[0].name).toBe('plain name');
+  });
+
+  it('should fall back to LIKE on bad FTS syntax and respect limit/offset', async () => {
+    await adapter.createFrame({
+      run_id: 'run-1',
+      project_id: 'test-project',
+      type: 'task',
+      name: 'test frame',
+      digest_text: 'hello world',
+    });
+
+    // Unbalanced quotes trigger LIKE fallback
+    const results = await adapter.search({ query: '"unbalanced' });
+    expect(Array.isArray(results)).toBe(true);
+
+    // Limit/offset
+    for (let i = 0; i < 5; i++) {
+      await adapter.createFrame({
+        run_id: 'run-1',
+        project_id: 'test-project',
+        type: 'task',
+        name: `search target item ${i}`,
+        digest_text: `description ${i}`,
+      });
+    }
+    const limited = await adapter.search({ query: 'target', limit: 2 });
+    expect(limited.length).toBe(2);
+    const offset = await adapter.search({
+      query: 'target',
+      limit: 2,
+      offset: 3,
+    });
+    expect(offset.length).toBeLessThanOrEqual(2);
+  });
+
+  it('should keep FTS in sync after insert/update/delete and survive rebuild', async () => {
+    const frameId = await adapter.createFrame({
+      run_id: 'run-1',
+      project_id: 'test-project',
+      type: 'task',
+      name: 'searchable original name',
+      digest_text: 'original digest',
+    });
+
+    let results = await adapter.search({ query: 'searchable' });
+    expect(results.length).toBe(1);
+
+    await adapter.updateFrame(frameId, {
+      digest_text: 'updated digest with searchable content',
+    });
+    results = await adapter.search({ query: 'updated' });
+    expect(results.length).toBe(1);
+
+    await adapter.deleteFrame(frameId);
+    results = await adapter.search({ query: 'searchable' });
+    expect(results.length).toBe(0);
+
+    // Rebuild after re-inserting
+    await adapter.createFrame({
+      run_id: 'run-1',
+      project_id: 'test-project',
+      type: 'task',
+      name: 'rebuild test',
+      digest_text: 'testing rebuild',
+    });
+    await expect(adapter.rebuildFtsIndex()).resolves.not.toThrow();
+    results = await adapter.search({ query: 'rebuild' });
+    expect(results.length).toBe(1);
+  });
+
+  it('should populate FTS index for pre-existing data on schema init', async () => {
+    const db = adapter.getRawDatabase()!;
+    db.prepare(
+      `
+      INSERT INTO frames (frame_id, run_id, project_id, type, name, state, depth, inputs, outputs, digest_json)
+      VALUES ('pre-existing', 'run-1', 'test-project', 'task', 'legacy data frame', 'active', 0, '{}', '{}', '{}')
+    `
+    ).run();
+
+    const adapter2 = new SQLiteAdapter('test-project', { dbPath });
+    await adapter2.connect();
+    await adapter2.initializeSchema();
+
+    const results = await adapter2.search({ query: 'legacy' });
+    expect(results.length).toBeGreaterThanOrEqual(1);
+    await adapter2.disconnect();
+  });
+});

src/core/database/embedding-provider.ts

@@ -0,0 +1,29 @@
+/**
+ * Embedding Provider Interface
+ * Abstraction for generating vector embeddings from text
+ */
+
+export interface EmbeddingProvider {
+  /** Generate embedding for a single text */
+  embed(text: string): Promise<number[]>;
+  /** Generate embeddings for multiple texts */
+  embedBatch(texts: string[]): Promise<number[][]>;
+  /** Dimensionality of the embedding vectors */
+  dimension: number;
+}
+
+/**
+ * No-op provider that disables vector search.
+ * Used as default when no real provider is configured.
+ */
+export class NoOpEmbeddingProvider implements EmbeddingProvider {
+  readonly dimension = 0;
+
+  async embed(_text: string): Promise<number[]> {
+    return [];
+  }
+
+  async embedBatch(_texts: string[]): Promise<number[][]> {
+    return [];
+  }
+}