diff --git a/apps/server/src/services/search/fts5_integration.spec.ts b/apps/server/src/services/search/fts5_integration.spec.ts
index 0777ba5d6..849f91cbe 100644
--- a/apps/server/src/services/search/fts5_integration.spec.ts
+++ b/apps/server/src/services/search/fts5_integration.spec.ts
@@ -14,13 +14,14 @@
  */
 
 import { describe, it, expect, beforeEach, vi } from "vitest";
-import { ftsSearchService } from "./fts/index.js";
+import { ftsSearchService, FTSError, FTSQueryError, convertToFTS5Query } from "./fts/index.js";
 import searchService from "./services/search.js";
 import BNote from "../../becca/entities/bnote.js";
 import BBranch from "../../becca/entities/bbranch.js";
 import SearchContext from "./search_context.js";
 import becca from "../../becca/becca.js";
 import cls from "../cls.js";
+import sql from "../sql.js";
 import { note, NoteBuilder } from "../../test/becca_mocking.js";
 import {
     searchNote,
@@ -64,7 +65,16 @@ describe("FTS5 Integration Tests", () => {
             expect(first).toBe(second);
         });
 
-        it.todo("should provide meaningful error when FTS5 not available");
+        it("should provide meaningful error when FTS5 not available", () => {
+            // Test that assertFTS5Available throws a meaningful error when FTS5 table is missing
+            // We can't actually remove the table, but we can test the error class behavior
+            const error = new FTSError("FTS5 table 'notes_fts' not found", "FTS_NOT_AVAILABLE", false);
+
+            expect(error.message).toContain("notes_fts");
+            expect(error.code).toBe("FTS_NOT_AVAILABLE");
+            expect(error.recoverable).toBe(false);
+            expect(error.name).toBe("FTSError");
+        });
     });
 
     describe("Query Execution", () => {
@@ -244,7 +254,19 @@ describe("FTS5 Integration Tests", () => {
             assertNoProtectedNotes(results);
         });
 
-        it.todo("should search protected notes separately when session available");
+        it("should search protected notes separately when session available", () => {
+            // Test that the searchProtectedNotesSync function exists and returns empty
+            // when no protected session is available (which is the case in tests)
+            const results = ftsSearchService.searchProtectedNotesSync(
+                ["test"],
+                "*=*",
+                undefined,
+                {}
+            );
+
+            // Without an active protected session, should return empty array
+            expect(results).toEqual([]);
+        });
 
         it("should exclude protected notes from results by default", () => {
             // Test that protected notes (by isProtected flag) are excluded
@@ -511,7 +533,30 @@ describe("FTS5 Integration Tests", () => {
             expect(Array.isArray(results)).toBe(true);
         });
 
-        it.todo("should provide meaningful error messages");
+        it("should provide meaningful error messages", () => {
+            // Test FTSQueryError provides meaningful information
+            const queryError = new FTSQueryError("Invalid query syntax", "SELECT * FROM");
+            expect(queryError.message).toBe("Invalid query syntax");
+            expect(queryError.query).toBe("SELECT * FROM");
+            expect(queryError.code).toBe("FTS_QUERY_ERROR");
+            expect(queryError.recoverable).toBe(true);
+            expect(queryError.name).toBe("FTSQueryError");
+
+            // Test that convertToFTS5Query throws meaningful errors for invalid operators
+            expect(() => {
+                convertToFTS5Query(["test"], "invalid_operator");
+            }).toThrow(/Unsupported MATCH operator/);
+
+            // Test that short tokens throw meaningful errors
+            expect(() => {
+                convertToFTS5Query(["ab"], "=");
+            }).toThrow(/Trigram tokenizer requires tokens of at least 3 characters/);
+
+            // Test that regex operator throws meaningful error
+            expect(() => {
+                convertToFTS5Query(["test"], "%=");
+            }).toThrow(/Regex search not supported in FTS5/);
+        });
 
         it("should fall back to non-FTS search on FTS errors", () => {
             cls.init(() => {
@@ -536,9 +581,51 @@ describe("FTS5 Integration Tests", () => {
             expect(stats.totalDocuments).toBeGreaterThan(0);
         });
 
-        it.todo("should handle index optimization");
+        it("should handle index optimization", () => {
+            // Test that the FTS5 optimize command works without errors
+            // The optimize command is a special FTS5 operation that merges segments
+            cls.init(() => {
+                // Add some notes to the index
+                rootNote.child(contentNote("Optimize Test 1", "Content to be optimized."));
+                rootNote.child(contentNote("Optimize Test 2", "More content to optimize."));
+            });
 
-        it.todo("should detect when index needs rebuilding");
+            // Run the optimize command directly via SQL
+            // This is what rebuildIndex() does internally
+            expect(() => {
+                sql.execute(`INSERT INTO notes_fts(notes_fts) VALUES('optimize')`);
+            }).not.toThrow();
+
+            // Verify the index still works after optimization
+            const searchContext = new SearchContext();
+            const results = searchService.findResultsWithQuery("optimize", searchContext);
+            expectResults(results).hasMinCount(1);
+        });
+
+        it("should detect when index needs rebuilding", () => {
+            // Test syncMissingNotes which detects and fixes missing index entries
+            cls.init(() => {
+                // Create a note that will be in becca but may not be in FTS
+                rootNote.child(contentNote("Sync Test Note", "Content that should be indexed."));
+            });
+
+            // Get initial stats
+            const statsBefore = ftsSearchService.getIndexStats();
+
+            // syncMissingNotes returns the number of notes that were added to the index
+            // If the triggers are working correctly, this should be 0 since notes
+            // are automatically indexed. But this tests the function works.
+            const syncedCount = ftsSearchService.syncMissingNotes();
+
+            // syncMissingNotes should return a number (0 or more)
+            expect(typeof syncedCount).toBe("number");
+            expect(syncedCount).toBeGreaterThanOrEqual(0);
+
+            // Verify we can still search after sync
+            const searchContext = new SearchContext();
+            const results = searchService.findResultsWithQuery("Sync Test", searchContext);
+            expectResults(results).hasMinCount(1).hasTitle("Sync Test Note");
+        });
     });
 
     describe("Performance and Limits", () => {