@selesai/code 0.13.15 → 0.13.18

package/dist/extensions/pi-hermes-memory/tests/store/fts-query.test.ts

@@ -0,0 +1,116 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  normalizeFts5Query,
+  buildFallbackFts5Query,
+  hasExplicitFts5Operator,
+  normalizeNaturalLanguageFts5Query,
+  buildNaturalLanguageFallbackQuery,
+  isFts5QueryError,
+} from '../../src/store/fts-query.js';
+
+describe('fts-query', () => {
+  describe('stop word filtering', () => {
+    it('filters filler words but keeps meaningful terms', () => {
+      const q = normalizeFts5Query('how to fix the authentication bug');
+      assert.ok(q.includes('"authentication"'), 'keeps meaningful term');
+      assert.ok(q.includes('"bug"'), 'keeps meaningful term');
+      assert.ok(!q.includes('"how"'), 'filters "how"');
+      assert.ok(!q.includes('"to"'), 'filters "to"');
+      assert.ok(!q.includes('"the"'), 'filters "the"');
+    });
+
+    it('returns empty string when every term is a stop word', () => {
+      assert.strictEqual(normalizeFts5Query('the a is was were'), '');
+      assert.strictEqual(normalizeFts5Query('for in on'), '');
+    });
+
+    it('keeps quoted phrases intact even when they contain stop words', () => {
+      const q = normalizeNaturalLanguageFts5Query('"the quick brown fox" jumps');
+      assert.ok(q.includes('"the quick brown fox"'));
+      assert.ok(q.includes('"jumps"'));
+    });
+
+    it('normalizes case-insensitively against the stop word list', () => {
+      const q = normalizeFts5Query('The QUICK brown Fox');
+      assert.ok(q.includes('"QUICK"'));
+      assert.ok(q.includes('"Fox"'));
+      assert.ok(!q.includes('"The"'));
+    });
+  });
+
+  describe('fallback queries', () => {
+    it('builds an OR fallback for multi-term natural language queries', () => {
+      const fb = buildFallbackFts5Query('authentication bug fix');
+      assert.ok(fb);
+      assert.ok(fb.includes('OR'));
+      assert.ok(fb.includes('"authentication"'));
+      assert.ok(fb.includes('"bug"'));
+    });
+
+    it('returns null when there are not enough meaningful terms', () => {
+      assert.strictEqual(buildFallbackFts5Query('auth'), null);
+      assert.strictEqual(buildFallbackFts5Query('the a'), null);
+    });
+
+    it('returns null for explicit operator queries', () => {
+      assert.strictEqual(buildFallbackFts5Query('auth OR database'), null);
+    });
+  });
+
+  describe('operator handling', () => {
+    it('detects explicit FTS5 operators', () => {
+      assert.ok(hasExplicitFts5Operator('auth OR database'));
+      assert.ok(hasExplicitFts5Operator('"auth bug" AND database'));
+      assert.ok(!hasExplicitFts5Operator('auth database'));
+    });
+
+    it('preserves explicit operator queries verbatim in normalizeFts5Query', () => {
+      assert.strictEqual(normalizeFts5Query('auth OR database'), 'auth OR database');
+    });
+  });
+
+  describe('natural language recovery', () => {
+    it('normalizes uppercase operator words as natural language', () => {
+      // 'DO' is a stop word and 'NOT' a natural-language connector, so only
+      // the two meaningful terms survive, quoted for implicit AND matching.
+      assert.strictEqual(normalizeNaturalLanguageFts5Query('DO NOT USE FIND'), '"USE" "FIND"');
+    });
+
+    it('keeps intent-bearing words out of the stop list (can/need/off/like/get)', () => {
+      // These words frequently carry the actual search intent ("can the app
+      // start", "need to restart", "like this", "get the build passing"), so
+      // they must survive normalization rather than be silently dropped.
+      assert.strictEqual(
+        normalizeFts5Query('can need off like get'),
+        '"can" "need" "off" "like" "get"',
+      );
+    });
+
+    it('builds a natural language OR fallback ignoring operator detection', () => {
+      const fb = buildNaturalLanguageFallbackQuery('DO NOT USE FIND');
+      assert.ok(fb && fb.includes('OR'));
+    });
+  });
+
+  describe('isFts5QueryError', () => {
+    it('detects genuine FTS5 query/index failure messages', () => {
+      assert.ok(isFts5QueryError(new Error('fts5: syntax error near "AND"')), 'fts5');
+      assert.ok(isFts5QueryError(new Error('fts5: unterminated string')), 'unterminated string');
+      assert.ok(isFts5QueryError(new Error('unterminated string constant in FTS5 query')), 'unterminated string constant');
+    });
+
+    it('rejects corruption signals so DatabaseManager recovery still runs (#186)', () => {
+      // These are corruption/recovery signals, NOT recoverable FTS query errors.
+      // Swallowing them would suppress quarantine/rebuild of a corrupt database.
+      assert.ok(!isFts5QueryError(new Error('database disk image is malformed')), 'malformed is corruption, not FTS');
+      assert.ok(!isFts5QueryError(new Error('SQL logic error')), 'sql logic error is too broad to swallow');
+      assert.ok(!isFts5QueryError(new Error('file is not a database')), 'notadb is corruption, not FTS');
+    });
+
+    it('rejects unrelated errors', () => {
+      assert.ok(!isFts5QueryError(new Error('disk full')));
+      assert.ok(!isFts5QueryError('string, not an Error'));
+    });
+  });
+});

package/dist/extensions/pi-hermes-memory/tests/store/memory-store.test.ts

@@ -117,6 +117,9 @@ describe("MemoryStore", { concurrency: 1 }, () => {
     await removeFile(memoryPath);
     await removeFile(userPath);
     await removeFile(failurePath);
+    const artifactNames = (await fs.readdir(MEMORY_DIR))
+      .filter((name) => name.includes(".recovery-") || name.includes(".retired-") || name.includes(".conflict-"));
+    await Promise.all(artifactNames.map((name) => removeFile(path.join(MEMORY_DIR, name))));
     await new Promise((r) => setTimeout(r, 50));
   }
 
@@ -184,6 +187,48 @@ describe("MemoryStore", { concurrency: 1 }, () => {
       assert.ok(result.error!.includes("chars"));
     });
 
+    it("bypasses the Markdown cap for memory, user, failure, and project stores in policy-only mode", async () => {
+      const config = makeConfig({
+        memoryMode: "policy-only",
+        memoryCharLimit: 1,
+        userCharLimit: 1,
+        projectCharLimit: 1,
+        memoryOverflowStrategy: "auto-consolidate",
+        autoConsolidate: true,
+      });
+      const store = new MemoryStore(config);
+      const projectStore = new MemoryStore({
+        ...config,
+        memoryDir: path.join(MEMORY_DIR, "project"),
+      });
+      let consolidatorCalls = 0;
+      const consolidator = async () => {
+        consolidatorCalls++;
+        return { consolidated: true };
+      };
+      store.setConsolidator(consolidator);
+      projectStore.setConsolidator(consolidator);
+      await store.loadFromDisk();
+      await projectStore.loadFromDisk();
+
+      const results = await Promise.all([
+        store.add("memory", `${TEST_MARKER} policy-only memory ${"x".repeat(100)}`),
+        store.add("user", `${TEST_MARKER} policy-only user ${"x".repeat(100)}`),
+        store.addFailure(`${TEST_MARKER} policy-only failure ${"x".repeat(100)}`, { category: "failure" }),
+        projectStore.add("memory", `${TEST_MARKER} policy-only project ${"x".repeat(100)}`),
+      ]);
+
+      for (const result of results) {
+        assert.equal(result.success, true, result.error);
+      }
+      assert.equal(consolidatorCalls, 0);
+      assert.equal(store.getRawEntriesForSync("memory").length, 1);
+      assert.equal(store.getRawEntriesForSync("user").length, 1);
+      assert.equal(store.getRawEntriesForSync("failure").length, 1);
+      assert.equal(projectStore.getRawEntriesForSync("memory").length, 1);
+    });
+
+
     it("rejects without consolidation when memoryOverflowStrategy is reject", async () => {
       let consolidatorCalled = false;
       const store = new MemoryStore(makeConfig({
@@ -603,6 +648,45 @@ describe("MemoryStore", { concurrency: 1 }, () => {
   // ─── replace() tests ───
 
   describe("replace()", () => {
+    it("bypasses the Markdown cap for replacements in policy-only mode", async () => {
+      const config = makeConfig({
+        memoryMode: "policy-only",
+        memoryCharLimit: 1,
+        userCharLimit: 1,
+        projectCharLimit: 1,
+      });
+      const store = new MemoryStore(config);
+      const projectStore = new MemoryStore({
+        ...config,
+        memoryDir: path.join(MEMORY_DIR, "project-replace"),
+      });
+      let consolidatorCalls = 0;
+      const consolidator = async () => {
+        consolidatorCalls++;
+        return { consolidated: true };
+      };
+      store.setConsolidator(consolidator);
+      projectStore.setConsolidator(consolidator);
+      await store.loadFromDisk();
+      await projectStore.loadFromDisk();
+      await store.add("memory", `${TEST_MARKER} replace memory seed`);
+      await store.add("user", `${TEST_MARKER} replace user seed`);
+      await store.addFailure(`${TEST_MARKER} replace failure seed`, { category: "failure" });
+      await projectStore.add("memory", `${TEST_MARKER} replace project seed`);
+
+      const replacement = `${TEST_MARKER} ${"x".repeat(100)}`;
+      const results = await Promise.all([
+        store.replace("memory", "replace memory seed", replacement),
+        store.replace("user", "replace user seed", replacement),
+        store.replace("failure", "replace failure seed", replacement),
+        projectStore.replace("memory", "replace project seed", replacement),
+      ]);
+
+      for (const result of results) {
+        assert.equal(result.success, true, result.error);
+      }
+      assert.equal(consolidatorCalls, 0);
+    });
     it("updates entry in file", async () => {
       const store = new MemoryStore(makeConfig());
       await store.loadFromDisk();
@@ -1318,6 +1402,52 @@ describe("MemoryStore", { concurrency: 1 }, () => {
         assert.equal(await readRaw(memoryPath), beforeDisk);
       }
     });
+    it("bypasses the Markdown cap for batch mutations in policy-only mode", async () => {
+      const config = makeConfig({
+        memoryMode: "policy-only",
+        memoryCharLimit: 1,
+        userCharLimit: 1,
+        projectCharLimit: 1,
+      });
+      const store = new MemoryStore(config);
+      const projectStore = new MemoryStore({
+        ...config,
+        memoryDir: path.join(MEMORY_DIR, "project-batch"),
+      });
+      let consolidatorCalls = 0;
+      const consolidator = async () => {
+        consolidatorCalls++;
+        return { consolidated: true };
+      };
+      store.setConsolidator(consolidator);
+      projectStore.setConsolidator(consolidator);
+      await store.loadFromDisk();
+      await projectStore.loadFromDisk();
+
+      const results = await Promise.all([
+        store.applyMutationPlan("memory", [
+          { action: "add", content: `${TEST_MARKER} batch memory ${"x".repeat(100)}` },
+          { action: "add", content: `${TEST_MARKER} batch memory second ${"x".repeat(100)}` },
+        ]),
+        store.applyMutationPlan("user", [
+          { action: "add", content: `${TEST_MARKER} batch user ${"x".repeat(100)}` },
+          { action: "add", content: `${TEST_MARKER} batch user second ${"x".repeat(100)}` },
+        ]),
+        store.applyMutationPlan("failure", [
+          { action: "add", content: `${TEST_MARKER} batch failure ${"x".repeat(100)}`, category: "failure" },
+          { action: "add", content: `${TEST_MARKER} batch failure second ${"x".repeat(100)}`, category: "failure" },
+        ]),
+        projectStore.applyMutationPlan("memory", [
+          { action: "add", content: `${TEST_MARKER} batch project ${"x".repeat(100)}` },
+          { action: "add", content: `${TEST_MARKER} batch project second ${"x".repeat(100)}` },
+        ]),
+      ]);
+
+      for (const result of results) {
+        assert.equal(result.success, true, result.error);
+      }
+      assert.equal(consolidatorCalls, 0);
+    });
   });
 
   describe("external file changes", () => {
@@ -1710,6 +1840,39 @@ describe("MemoryStore", { concurrency: 1 }, () => {
       assert.match(raw, /later add/);
     });
 
+    it("reuses one recent recovery snapshot during rapid successive writes", async () => {
+      const store = new MemoryStore(makeConfig());
+      await store.loadFromDisk();
+      await store.add("memory", `${TEST_MARKER} recovery seed`);
+
+      for (let index = 0; index < 10; index++) {
+        await store.add("memory", `${TEST_MARKER} rapid overwrite ${index}`);
+      }
+
+      const recoveryFiles = (await fs.readdir(MEMORY_DIR))
+        .filter((name) => name.startsWith(`.${MEMORY_FILE}.recovery-`));
+      assert.ok(recoveryFiles.length <= 2);
+    });
+
+    it("takes a new recovery snapshot after the reuse interval", async () => {
+      const store = new MemoryStore(makeConfig());
+      await store.loadFromDisk();
+      await store.add("memory", `${TEST_MARKER} recovery seed`);
+      await store.add("memory", `${TEST_MARKER} first overwrite`);
+
+      const initialRecoveryFiles = (await fs.readdir(MEMORY_DIR))
+        .filter((name) => name.startsWith(`.${MEMORY_FILE}.recovery-`));
+      assert.equal(initialRecoveryFiles.length, 1);
+      const old = new Date(Date.now() - 60 * 60 * 1000 - 1_000);
+      await fs.utimes(path.join(MEMORY_DIR, initialRecoveryFiles[0]), old, old);
+
+      await store.add("memory", `${TEST_MARKER} overwrite after interval`);
+
+      const recoveryFiles = (await fs.readdir(MEMORY_DIR))
+        .filter((name) => name.startsWith(`.${MEMORY_FILE}.recovery-`));
+      assert.equal(recoveryFiles.length, 2);
+    });
+
     it("prunes expired recovery files but retains recently active ones", async () => {
       const pathStore = new MemoryStore(makeConfig());
       const expiredPath = (pathStore as any).recoveryPathFor(memoryPath) as string;

package/dist/extensions/pi-hermes-memory/tests/store/session-indexer.test.ts

@@ -19,6 +19,7 @@ import {
   truncateMessageContent,
   upsertSessionFileMetadata,
   pruneEphemeralReviewSessions,
+  pruneOldSessions,
 } from '../../src/store/session-indexer.js';
 import { DEFAULT_MAX_MESSAGE_CONTENT_LENGTH } from '../../src/constants.js';
 import { parseSessionFile, type ParsedSession } from '../../src/store/session-parser.js';
@@ -221,6 +222,44 @@ describe('session-indexer', () => {
       const result = indexAllSessions(dbManager, '/nonexistent/path');
       assert.strictEqual(result.sessionsProcessed, 0);
     });
+
+    it('skips files outside the retention window and reports expiredSkipped', () => {
+      const sessionsDir = path.join(tmpDir, 'sessions');
+      const projDir = path.join(sessionsDir, 'test-project');
+      fs.mkdirSync(projDir, { recursive: true });
+
+      const write = (fileName: string, sessionId: string) => {
+        const lines = [
+          JSON.stringify({ type: 'session', id: sessionId, timestamp: '2026-05-03T00:00:00Z', cwd: '/test' }),
+          JSON.stringify({
+            type: 'message',
+            id: `${sessionId}-m1`,
+            parentId: null,
+            timestamp: '2026-05-03T00:01:00Z',
+            message: { role: 'user', content: [{ type: 'text', text: 'Hello' }], timestamp: Date.now() },
+          }),
+        ];
+        fs.writeFileSync(path.join(projDir, fileName), lines.join('\n'));
+      };
+      write('recent.jsonl', 'recent');
+      write('expired.jsonl', 'expired');
+
+      // Age the second file beyond the retention window.
+      const old = new Date('2026-01-01T00:00:00Z');
+      fs.utimesSync(path.join(projDir, 'expired.jsonl'), old, old);
+
+      const cutoff = Date.parse('2026-03-01T00:00:00Z');
+      const result = indexAllSessions(dbManager, sessionsDir, undefined, cutoff);
+      assert.strictEqual(result.sessionsIndexed, 1);
+      assert.strictEqual(result.expiredSkipped, 1);
+      assert.strictEqual(dbManager.getStats().sessions, 1);
+
+      // Without a cutoff the same directory indexes both files.
+      const result2 = indexAllSessions(dbManager, sessionsDir);
+      assert.strictEqual(result2.sessionsIndexed, 1);
+      assert.strictEqual(result2.expiredSkipped, undefined);
+      assert.strictEqual(dbManager.getStats().sessions, 2);
+    });
   });
 
   describe('indexChangedSessions', () => {
@@ -565,6 +604,75 @@ describe('session-indexer', () => {
       assert.strictEqual(needsBackfill(dbManager, sessionsDir, new Date('2026-05-03T01:00:00Z')), true);
     });
 
+    it('needsBackfill returns no work when retention is enabled and every file is expired, even without a backfill timestamp', () => {
+      const sessionsDir = path.join(tmpDir, 'sessions');
+      writeJsonlSession(sessionsDir, 'project-a', 's1');
+      const filePath = path.join(sessionsDir, 'project-a', 's1.jsonl');
+
+      // Age the file beyond the retention window.
+      const old = new Date('2026-01-01T00:00:00Z');
+      fs.utimesSync(filePath, old, old);
+
+      const now = new Date('2026-05-03T01:00:00Z');
+      const cutoff = Date.parse('2026-03-01T00:00:00Z');
+      assert.ok(old.getTime() < cutoff, 'sanity: the file must be outside the window');
+
+      // Fresh DB: no indexed rows and no backfill timestamp, so the periodic
+      // timestamp check alone would demand a backfill. With retention enabled
+      // and no retained files, there is no work to do — this must return
+      // false instead of scheduling an empty backfill on every startup.
+      assert.strictEqual(needsBackfill(dbManager, sessionsDir, now, cutoff), false);
+    });
+
+    it('needsBackfill ignores expired files instead of using a blind file-count shortcut', () => {
+      const sessionsDir = path.join(tmpDir, 'sessions');
+      // Two files on disk, zero indexed rows: a file-count-based shortcut
+      // would return true here. With retention enabled and every file
+      // expired, there is nothing to backfill.
+      writeJsonlSession(sessionsDir, 'project-a', 's1');
+      writeJsonlSession(sessionsDir, 'project-b', 's2');
+      const old = new Date('2026-01-01T00:00:00Z');
+      fs.utimesSync(path.join(sessionsDir, 'project-a', 's1.jsonl'), old, old);
+      fs.utimesSync(path.join(sessionsDir, 'project-b', 's2.jsonl'), old, old);
+
+      const cutoff = Date.parse('2026-03-01T00:00:00Z');
+      assert.strictEqual(needsBackfill(dbManager, sessionsDir, new Date('2026-05-03T01:00:00Z'), cutoff), false);
+
+      // A retained file with no stored metadata still demands a backfill,
+      // even though the file count alone (2 files, 0 rows) is unchanged.
+      const recent = new Date('2026-04-15T00:00:00Z');
+      fs.utimesSync(path.join(sessionsDir, 'project-b', 's2.jsonl'), recent, recent);
+      assert.strictEqual(needsBackfill(dbManager, sessionsDir, new Date('2026-05-03T01:00:00Z'), cutoff), true);
+    });
+
+    it('needsBackfill still schedules when a retained file exists without a backfill timestamp', () => {
+      const sessionsDir = path.join(tmpDir, 'sessions');
+      writeJsonlSession(sessionsDir, 'project-a', 's1');
+      const filePath = path.join(sessionsDir, 'project-a', 's1.jsonl');
+
+      // File stays inside the retention window.
+      const recent = new Date('2026-04-15T00:00:00Z');
+      fs.utimesSync(filePath, recent, recent);
+
+      const now = new Date('2026-05-03T01:00:00Z');
+      const cutoff = Date.parse('2026-03-01T00:00:00Z');
+      assert.ok(recent.getTime() >= cutoff, 'sanity: the file must be inside the window');
+
+      assert.strictEqual(needsBackfill(dbManager, sessionsDir, now, cutoff), true);
+    });
+
+    it('needsBackfill keeps the periodic check active when retention is disabled', () => {
+      const sessionsDir = path.join(tmpDir, 'sessions');
+      writeJsonlSession(sessionsDir, 'project-a', 's1');
+      const filePath = path.join(sessionsDir, 'project-a', 's1.jsonl');
+
+      // An old file is still eligible when retention is disabled (cutoff 0).
+      const old = new Date('2026-01-01T00:00:00Z');
+      fs.utimesSync(filePath, old, old);
+
+      assert.strictEqual(needsBackfill(dbManager, sessionsDir, new Date('2026-05-03T01:00:00Z')), true);
+    });
+
     it('touchBackfillTimestamp upserts the metadata row', () => {
       touchBackfillTimestamp(dbManager, new Date('2026-05-03T00:00:00Z'));
       touchBackfillTimestamp(dbManager, new Date('2026-05-03T01:00:00Z'));
@@ -602,6 +710,131 @@ describe('session-indexer', () => {
     });
   });
 
+  describe('retention and backfill alignment', () => {
+    /** Write a session JSONL file and force its mtime to `ms` (ms epoch). */
+    function writeJsonlSessionAt(sessionsDir: string, sessionId: string, ms: number): string {
+      const filePath = path.join(sessionsDir, 'project-a', `${sessionId}.jsonl`);
+      fs.mkdirSync(path.dirname(filePath), { recursive: true });
+      const lines = [
+        JSON.stringify({ type: 'session', id: sessionId, timestamp: new Date(ms).toISOString(), cwd: `/test/${sessionId}` }),
+        JSON.stringify({ type: 'message', id: `${sessionId}-m1`, parentId: null, timestamp: new Date(ms + 1000).toISOString(), message: { role: 'user', content: [{ type: 'text', text: `Hello ${sessionId}` }], timestamp: Date.now() } }),
+      ];
+      fs.writeFileSync(filePath, lines.join('\n'));
+      fs.utimesSync(filePath, new Date(ms), new Date(ms));
+      return filePath;
+    }
+
+    const DAY = 24 * 60 * 60 * 1000;
+    const now = () => Date.now();
+    const cutoffFor = (days: number) => now() - days * DAY;
+
+    it('does not re-index a session file outside the retention cutoff after pruning', () => {
+      const sessionsDir = path.join(tmpDir, 'sessions');
+      // A file last modified 60 days ago; retention window of 30 days => expired.
+      writeJsonlSessionAt(sessionsDir, 's1', cutoffFor(60));
+      const cutoff = cutoffFor(30);
+
+      // Fresh index (no cutoff) mirrors the pre-retention state, then retention
+      // pruning removes the session row; the on-disk file stays.
+      indexAllSessions(dbManager, sessionsDir);
+      const pruned = pruneOldSessions(dbManager, 30);
+      assert.strictEqual(pruned.sessionsRemoved, 1);
+      assert.strictEqual(dbManager.getStats().sessions, 0);
+
+      // A later startup backfill, given the same retention cutoff, must NOT
+      // re-queue the expired file -- otherwise the pruned session returns.
+      const result = indexChangedSessions(dbManager, sessionsDir, { retentionCutoffMs: cutoff });
+      assert.strictEqual(result.sessionsProcessed, 0);
+      assert.strictEqual(result.sessionsIndexed, 0);
+      assert.strictEqual(result.sessionsSkipped, 0);
+      assert.strictEqual(dbManager.getStats().sessions, 0);
+    });
+
+    it('does not schedule a startup backfill when only expired files remain', () => {
+      const sessionsDir = path.join(tmpDir, 'sessions');
+      writeJsonlSessionAt(sessionsDir, 's1', cutoffFor(60));
+      const cutoff = cutoffFor(30);
+      indexAllSessions(dbManager, sessionsDir);
+      pruneOldSessions(dbManager, 30);
+      touchBackfillTimestamp(dbManager);
+
+      // With every file outside the window, needsBackfill must be false so no
+      // backfill is scheduled on the next startup (no repeated re-indexing).
+      assert.strictEqual(needsBackfill(dbManager, sessionsDir, new Date(), cutoff), false);
+    });
+
+    it('still indexes files within the retention cutoff even when others are expired', () => {
+      const sessionsDir = path.join(tmpDir, 'sessions');
+      writeJsonlSessionAt(sessionsDir, 'old', cutoffFor(60));
+      writeJsonlSessionAt(sessionsDir, 'fresh', now());
+      const cutoff = cutoffFor(30);
+
+      const result = indexChangedSessions(dbManager, sessionsDir, { retentionCutoffMs: cutoff });
+      // Only the fresh file is eligible; the expired one is skipped.
+      assert.strictEqual(result.sessionsProcessed, 1);
+      assert.strictEqual(result.sessionsIndexed, 1);
+      const stats = getSessionStats(dbManager);
+      assert.deepStrictEqual(stats.projects[0].sessions, 1); // only the retained session
+      assert.strictEqual(needsBackfill(dbManager, sessionsDir, new Date(), cutoff), true);
+    });
+
+    it('prunes only sessions whose file mtime is outside the retention window', () => {
+      const sessionsDir = path.join(tmpDir, 'sessions');
+      writeJsonlSessionAt(sessionsDir, 'old', cutoffFor(60));
+      writeJsonlSessionAt(sessionsDir, 'recent', now());
+      indexAllSessions(dbManager, sessionsDir);
+
+      const pruned = pruneOldSessions(dbManager, 30);
+      // 'old' has an expired file mtime and is pruned; 'recent' has a fresh
+      // file mtime and is kept, even though both were indexed.
+      assert.strictEqual(pruned.sessionsRemoved, 1);
+      const stats = getSessionStats(dbManager);
+      assert.strictEqual(stats.totalSessions, 1);
+      const remaining = dbManager.getDb().prepare('SELECT id FROM sessions').all() as { id: string }[];
+      assert.deepStrictEqual(remaining.map((r) => r.id), ['recent']);
+    });
+  });
+
+  describe('pruneOldSessions', () => {
+    it('removes nothing when the database is empty', () => {
+      const result = pruneOldSessions(dbManager, 30);
+      assert.deepStrictEqual(result, { sessionsRemoved: 0, messagesRemoved: 0 });
+    });
+
+    it('removes sessions older than the retention window and their messages', () => {
+      indexSession(dbManager, createTestSession({ id: 'old', startedAt: '2020-01-01T00:00:00Z' }));
+      indexSession(dbManager, createTestSession({ id: 'recent', startedAt: new Date().toISOString() }));
+
+      const result = pruneOldSessions(dbManager, 30);
+      assert.strictEqual(result.sessionsRemoved, 1);
+      assert.strictEqual(result.messagesRemoved, 2); // old session has 2 messages
+
+      const stats = getSessionStats(dbManager);
+      assert.strictEqual(stats.totalSessions, 1);
+      assert.strictEqual(stats.totalMessages, 2);
+      const remaining = dbManager.getDb().prepare('SELECT id FROM sessions').all() as { id: string }[];
+      assert.deepStrictEqual(remaining.map((r) => r.id), ['recent']);
+    });
+
+    it('leaves sessions exactly at the retention boundary (not strictly older) untouched', () => {
+      const now = Date.now();
+      const justWithin = new Date(now - 10 * 24 * 60 * 60 * 1000).toISOString(); // 10 days ago
+      indexSession(dbManager, createTestSession({ id: 'within', startedAt: justWithin }));
+
+      const result = pruneOldSessions(dbManager, 30);
+      assert.strictEqual(result.sessionsRemoved, 0);
+      assert.strictEqual(dbManager.getStats().sessions, 1);
+    });
+
+    it('is idempotent across repeated calls', () => {
+      indexSession(dbManager, createTestSession({ id: 'old', startedAt: '2020-01-01T00:00:00Z' }));
+
+      pruneOldSessions(dbManager, 30);
+      const again = pruneOldSessions(dbManager, 30);
+      assert.deepStrictEqual(again, { sessionsRemoved: 0, messagesRemoved: 0 });
+    });
+  });
+
   describe('getSessionStats', () => {
     it('should return zero counts for empty database', () => {
       const stats = getSessionStats(dbManager);

package/dist/extensions/pi-hermes-memory/tests/store/session-search.test.ts

@@ -50,6 +50,18 @@ describe('session-search', () => {
       assert.ok(results.length > 0);
       assert.ok(results.some(r => r.content.includes('Prisma')));
     });
+    it('degrades an all-stop-word query to the LIKE fallback instead of []', () => {
+      // "the" is a stop word and "and"/"or" connectors, so FTS5 normalization
+      // leaves nothing to match. The query must fall through to the scoped
+      // literal fallback (which still searches the raw terms) rather than
+      // hard-return an empty result set.
+      indexSession(dbManager, createTestSession());
+
+      const results = searchSessions(dbManager, 'the and or');
+      assert.ok(results.length > 0, 'all-stop-word query must reach the LIKE fallback, not []');
+      assert.ok(results.some(r => r.content.includes('the')));
+    });
+
     it('finds pure CJK substrings with the trigram tokenizer', () => {
       indexSession(dbManager, createTestSession({ id: 'cjk-trigram-session', messages: [
         { id: 'cjk-trigram-session-msg-1', role: 'assistant', content: '设备清单包含 NAS 和备份策略', timestamp: '2026-05-03T00:01:00Z' },