@selesai/code 0.13.15 → 0.13.18

package/dist/extensions/pi-hermes-memory/tests/handlers/review-memory-ops.test.ts

@@ -14,6 +14,8 @@ import {
 } from "../../src/handlers/review-memory-ops.js";
 import { DatabaseManager } from "../../src/store/db.js";
 import { getMemories, reconcileMarkdownMemoryScope } from "../../src/store/sqlite-memory-store.js";
+import { acquireMarkdownMutationLock } from "../../src/store/markdown-mutation-lock.js";
+import { MEMORY_FILE } from "../../src/constants.js";
 
 function mockModel(reasoning: boolean): Model<Api> {
   return {
@@ -90,6 +92,19 @@ describe("provider auth resolution", () => {
     return { usedKeys, complete };
   }
 
+  function registryWithHeaderAuth(...headers: Array<Record<string, string | null>>) {
+    let authCalls = 0;
+    return {
+      getApiKeyAndHeaders: async () => ({
+        ok: true as const,
+        headers: headers[Math.min(authCalls++, headers.length - 1)],
+      }),
+      getAll: () => [mockModel(false)],
+      getAvailable: () => [mockModel(false)],
+      get authCalls() { return authCalls; },
+    };
+  }
+
   const emptyOperations = {
     stopReason: "stop",
     content: [{ type: "text", text: JSON.stringify({ operations: [] }) }],
@@ -99,6 +114,18 @@ describe("provider auth resolution", () => {
     return { userPrompt: "u", systemPrompt: "s", config: {} };
   }
 
+  async function runReview(modelRegistry: unknown, complete: unknown) {
+    return runDirectMemoryCompletion(
+      { model: mockModel(false), modelRegistry } as never,
+      null as never,
+      null,
+      directOptions(),
+      null,
+      null,
+      { completeSimple: complete as never },
+    );
+  }
+
   it("resolves credentials through the public registry API", async () => {
     const registry = registryWithAuthResponses("current-key");
     const { usedKeys, complete } = completionStub(() => emptyOperations);
@@ -118,6 +145,44 @@ describe("provider auth resolution", () => {
     assert.deepStrictEqual(usedKeys, ["current-key"]);
   });
 
+  it("runs direct review with header-only OAuth request auth", async () => {
+    const headers = {
+      Authorization: "Bearer kimi-oauth-token",
+      "User-Agent": "pi-coding-agent",
+      "X-Drop": null,
+    };
+    const usedHeaders: Array<Record<string, string | null> | undefined> = [];
+    const complete = async (_model: unknown, _request: unknown, options: { headers?: Record<string, string | null> }) => {
+      usedHeaders.push(options.headers);
+      return emptyOperations;
+    };
+
+    const result = await runReview(registryWithHeaderAuth(headers), complete);
+
+    assert.strictEqual(result.ok, true);
+    assert.deepStrictEqual(usedHeaders, [headers]);
+  });
+
+  for (const { name, headers } of [
+    { name: "empty headers", headers: {} },
+    { name: "User-Agent-only headers", headers: { "User-Agent": "pi-coding-agent" } },
+    { name: "null credential headers", headers: { Authorization: null, "x-api-key": null } },
+  ]) {
+    it(`rejects ${name} as missing request authentication`, async () => {
+      let completionCalls = 0;
+      const complete = async () => {
+        completionCalls++;
+        return emptyOperations;
+      };
+
+      const result = await runReview(registryWithHeaderAuth(headers), complete);
+
+      assert.strictEqual(result.ok, false);
+      assert.strictEqual(result.fallbackReason, "no_auth");
+      assert.strictEqual(completionCalls, 0);
+    });
+  }
+
   it("re-resolves credentials after a provider auth rejection", async () => {
     const { modelRegistry } = registryWithAuthResponses("revoked-key", "rotated-key");
     const { usedKeys, complete } = completionStub((_key, attempt) => {
@@ -139,6 +204,35 @@ describe("provider auth resolution", () => {
     assert.deepStrictEqual(usedKeys, ["revoked-key", "rotated-key"]);
   });
 
+  it("re-resolves rotated header-only OAuth credentials after rejection", async () => {
+    const usedHeaders: Array<Record<string, string> | undefined> = [];
+    const complete = async (_model: unknown, _request: unknown, options: { headers?: Record<string, string> }) => {
+      usedHeaders.push(options.headers);
+      if (usedHeaders.length === 1) throw new Error("HTTP 401 Unauthorized: token expired");
+      return emptyOperations;
+    };
+    const modelRegistry = registryWithHeaderAuth(
+      { Authorization: "Bearer stale-token" },
+      { Authorization: "Bearer fresh-token" },
+    );
+
+    const result = await runDirectMemoryCompletion(
+      { model: mockModel(false), modelRegistry } as never,
+      null as never,
+      null,
+      directOptions(),
+      null,
+      null,
+      { completeSimple: complete as never },
+    );
+
+    assert.strictEqual(result.ok, true);
+    assert.deepStrictEqual(usedHeaders, [
+      { Authorization: "Bearer stale-token" },
+      { Authorization: "Bearer fresh-token" },
+    ]);
+  });
+
   it("does not retry when the refreshed key is the same one the provider rejected", async () => {
     const { modelRegistry } = registryWithAuthResponses("only-key");
     const { usedKeys, complete } = completionStub(() => new Error("HTTP 401 Unauthorized"));
@@ -158,6 +252,129 @@ describe("provider auth resolution", () => {
     assert.strictEqual(usedKeys.length, 1, "an unchanged key means a real auth problem, not a rotation race");
   });
 
+  it("does not retry an unchanged header-only OAuth credential", async () => {
+    let completionCalls = 0;
+    const complete = async () => {
+      completionCalls++;
+      throw new Error("HTTP 401 Unauthorized");
+    };
+    const modelRegistry = registryWithHeaderAuth({ Authorization: "Bearer unchanged-token" });
+
+    const result = await runDirectMemoryCompletion(
+      { model: mockModel(false), modelRegistry } as never,
+      null as never,
+      null,
+      directOptions(),
+      null,
+      null,
+      { completeSimple: complete as never },
+    );
+
+    assert.strictEqual(result.ok, false);
+    assert.strictEqual(result.fallbackReason, "provider_error");
+    assert.strictEqual(completionCalls, 1);
+  });
+
+  it("rotates header-only auth after an error assistant 401 response", async () => {
+    const usedHeaders: Array<Record<string, string | null> | undefined> = [];
+    const complete = async (_model: unknown, _request: unknown, options: { headers?: Record<string, string | null> }) => {
+      usedHeaders.push(options.headers);
+      if (usedHeaders.length === 1) {
+        return { stopReason: "error", errorMessage: "HTTP 401 Unauthorized: token expired" };
+      }
+      return emptyOperations;
+    };
+    const modelRegistry = registryWithHeaderAuth(
+      { Authorization: "Bearer stale-token" },
+      { Authorization: "Bearer fresh-token" },
+    );
+
+    const result = await runDirectMemoryCompletion(
+      { model: mockModel(false), modelRegistry } as never,
+      null as never,
+      null,
+      directOptions(),
+      null,
+      null,
+      { completeSimple: complete as never },
+    );
+
+    assert.strictEqual(result.ok, true);
+    assert.deepStrictEqual(usedHeaders, [
+      { Authorization: "Bearer stale-token" },
+      { Authorization: "Bearer fresh-token" },
+    ]);
+  });
+
+  it("does not retry when only the credential header name casing changed", async () => {
+    let completionCalls = 0;
+    const complete = async () => {
+      completionCalls++;
+      throw new Error("HTTP 401 Unauthorized");
+    };
+    const modelRegistry = registryWithHeaderAuth(
+      { Authorization: "Bearer same-token" },
+      { authorization: "Bearer same-token" },
+    );
+
+    const result = await runDirectMemoryCompletion(
+      { model: mockModel(false), modelRegistry } as never,
+      null as never,
+      null,
+      directOptions(),
+      null,
+      null,
+      { completeSimple: complete as never },
+    );
+
+    assert.strictEqual(result.ok, false);
+    assert.strictEqual(result.fallbackReason, "provider_error");
+    assert.strictEqual(completionCalls, 1);
+  });
+
+  it("retries once when a duplicate-case credential header value changes", async () => {
+    const stale = { Authorization: "Bearer stale", authorization: "Bearer shared" };
+    const fresh = { Authorization: "Bearer fresh", authorization: "Bearer shared" };
+    const usedHeaders: Array<Record<string, string | null> | undefined> = [];
+    const complete = async (_model: unknown, _request: unknown, options: { headers?: Record<string, string | null> }) => {
+      usedHeaders.push(options.headers);
+      if (usedHeaders.length === 1) {
+        return { stopReason: "error", errorMessage: "HTTP 401 Unauthorized: token expired" };
+      }
+      return emptyOperations;
+    };
+    const modelRegistry = registryWithHeaderAuth(stale, fresh);
+
+    const result = await runReview(modelRegistry, complete);
+
+    assert.strictEqual(result.ok, true);
+    assert.strictEqual(modelRegistry.authCalls, 2);
+    assert.deepStrictEqual(usedHeaders, [stale, fresh]);
+  });
+
+  it("returns provider_error after a second auth failure without a third completion", async () => {
+    let completionCalls = 0;
+    const complete = async () => {
+      completionCalls++;
+      if (completionCalls <= 2) {
+        return { stopReason: "error", errorMessage: "HTTP 401 Unauthorized" };
+      }
+      return emptyOperations;
+    };
+    const modelRegistry = registryWithHeaderAuth(
+      { Authorization: "Bearer stale-token" },
+      { Authorization: "Bearer still-bad-token" },
+      { Authorization: "Bearer should-not-be-used" },
+    );
+
+    const result = await runReview(modelRegistry, complete);
+
+    assert.strictEqual(result.ok, false);
+    assert.strictEqual(result.fallbackReason, "provider_error");
+    assert.strictEqual(completionCalls, 2);
+    assert.strictEqual(modelRegistry.authCalls, 2);
+  });
+
   it("classifies provider auth rejections without swallowing other failures", () => {
     for (const message of [
       "HTTP 401 Unauthorized",
@@ -182,6 +399,87 @@ describe("provider auth resolution", () => {
   });
 });
 
+describe("fallback model chain", () => {
+  function twoModelRegistry() {
+    const m1 = { id: "m1", provider: "p1", api: "openai-completions", reasoning: false } as Model<Api>;
+    const m2 = { id: "m2", provider: "p2", api: "openai-completions", reasoning: false } as Model<Api>;
+    let authCalls = 0;
+    const registry = {
+      getApiKeyAndHeaders: async () => {
+        authCalls++;
+        return { ok: true as const, apiKey: "k" };
+      },
+      getAll: () => [m1, m2],
+      getAvailable: () => [m1, m2],
+    };
+    return { registry, get authCalls() { return authCalls; } };
+  }
+
+  function chainOptions(signal?: AbortSignal) {
+    return {
+      userPrompt: "u",
+      systemPrompt: "s",
+      config: { llmModelOverride: "p1/m1", llmFallbackModels: ["p2/m2"] },
+      ...(signal ? { signal } : {}),
+    };
+  }
+
+  const emptyReview = {
+    stopReason: "stop",
+    content: [{ type: "text", text: JSON.stringify({ operations: [] }) }],
+  };
+
+  it("stops the chain when the caller aborts instead of trying the next model", async () => {
+    const caller = new AbortController();
+    const attempted: string[] = [];
+    const complete = async (model: Model<Api>) => {
+      attempted.push(model.id);
+      caller.abort();
+      return { stopReason: "aborted" };
+    };
+    const chain = twoModelRegistry();
+
+    const result = await runDirectMemoryCompletion(
+      { model: undefined, modelRegistry: chain.registry } as never,
+      null as never,
+      null,
+      chainOptions(caller.signal),
+      null,
+      null,
+      { completeSimple: complete as never },
+    );
+
+    assert.strictEqual(result.ok, false);
+    assert.strictEqual(result.fallbackReason, "aborted");
+    assert.deepStrictEqual(attempted, ["m1"]);
+    assert.strictEqual(chain.authCalls, 1);
+  });
+
+  it("still tries the next model after a per-model timeout while the caller is alive", async () => {
+    const caller = new AbortController();
+    const attempted: string[] = [];
+    const complete = async (model: Model<Api>) => {
+      attempted.push(model.id);
+      if (attempted.length === 1) return { stopReason: "aborted" };
+      return emptyReview;
+    };
+
+    const chain = twoModelRegistry();
+    const result = await runDirectMemoryCompletion(
+      { model: undefined, modelRegistry: chain.registry } as never,
+      null as never,
+      null,
+      chainOptions(caller.signal),
+      null,
+      null,
+      { completeSimple: complete as never },
+    );
+
+    assert.deepStrictEqual(attempted, ["m1", "m2"]);
+    assert.strictEqual(result.ok, true);
+  });
+});
+
 describe("parseReviewOperations", () => {
   it("parses valid JSON operations", () => {
     const parsed = parseReviewOperations(JSON.stringify({
@@ -575,6 +873,160 @@ describe("applyReviewOperations", () => {
     assert.deepStrictEqual(store.getMemoryEntries(), beforeEntries);
   });
 
+  it("skips auth, provider, and store work when the external signal is already aborted", async () => {
+    let authCalls = 0;
+    let completeCalls = 0;
+    let mutated = false;
+    const controller = new AbortController();
+    controller.abort();
+    const store = {
+      add: async () => {
+        mutated = true;
+        return { success: true };
+      },
+    };
+    const modelRegistry = {
+      getApiKeyAndHeaders: async () => {
+        authCalls++;
+        return { ok: true as const, apiKey: "test-key" };
+      },
+      getAll: () => [mockModel(false)],
+      getAvailable: () => [mockModel(false)],
+    };
+
+    const result = await runDirectMemoryCompletion(
+      { model: mockModel(false), modelRegistry } as never,
+      store as never,
+      null,
+      {
+        userPrompt: "u",
+        systemPrompt: "s",
+        config: {},
+        signal: controller.signal,
+      },
+      null,
+      null,
+      {
+        completeSimple: (async () => {
+          completeCalls++;
+          return {
+            stopReason: "stop",
+            content: [{ type: "text", text: JSON.stringify({ operations: [{ action: "add", target: "memory", content: "late" }] }) }],
+          };
+        }) as never,
+      },
+    );
+
+    assert.deepStrictEqual(result, { ok: false, appliedCount: 0, fallbackReason: "aborted" });
+    assert.equal(authCalls, 0);
+    assert.equal(completeCalls, 0);
+    assert.equal(mutated, false);
+  });
+
+  it("does not apply operations when the provider ignores abort and returns success", async () => {
+    const store = new MemoryStore({
+      memoryDir: tmpDir,
+      memoryCharLimit: 5000,
+      userCharLimit: 5000,
+      autoConsolidate: true,
+    });
+    await store.loadFromDisk();
+    const controller = new AbortController();
+    const modelRegistry = {
+      getApiKeyAndHeaders: async () => ({ ok: true as const, apiKey: "test-key" }),
+      getAll: () => [mockModel(false)],
+      getAvailable: () => [mockModel(false)],
+    };
+    const complete = async () => {
+      controller.abort();
+      return {
+        stopReason: "stop",
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            operations: [{ action: "add", target: "memory", content: "should not persist after cancel" }],
+          }),
+        }],
+      };
+    };
+
+    const result = await runDirectMemoryCompletion(
+      { model: mockModel(false), modelRegistry } as never,
+      store,
+      null,
+      {
+        userPrompt: "u",
+        systemPrompt: "s",
+        config: {},
+        signal: controller.signal,
+      },
+      null,
+      null,
+      { completeSimple: complete as never },
+    );
+
+    assert.deepStrictEqual(result, { ok: false, appliedCount: 0, fallbackReason: "aborted" });
+    assert.equal(store.getMemoryEntries().some((entry) => entry.includes("should not persist after cancel")), false);
+  });
+
+  it("does not write after abort while waiting for the markdown mutation lock", async () => {
+    const store = new MemoryStore({
+      memoryDir: tmpDir,
+      memoryCharLimit: 5000,
+      userCharLimit: 5000,
+      autoConsolidate: true,
+    });
+    await store.loadFromDisk();
+    const controller = new AbortController();
+    const modelRegistry = {
+      getApiKeyAndHeaders: async () => ({ ok: true as const, apiKey: "test-key" }),
+      getAll: () => [mockModel(false)],
+      getAvailable: () => [mockModel(false)],
+    };
+    const completeEntered = Promise.withResolvers<void>();
+    const continueComplete = Promise.withResolvers<void>();
+    const complete = async () => {
+      completeEntered.resolve();
+      await continueComplete.promise;
+      return {
+        stopReason: "stop",
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            operations: [{ action: "add", target: "memory", content: "late-after-shutdown" }],
+          }),
+        }],
+      };
+    };
+    const lease = await acquireMarkdownMutationLock(path.join(tmpDir, MEMORY_FILE));
+    try {
+      const completion = runDirectMemoryCompletion(
+        { model: mockModel(false), modelRegistry } as never,
+        store,
+        null,
+        {
+          userPrompt: "u",
+          systemPrompt: "s",
+          config: {},
+          signal: controller.signal,
+        },
+        null,
+        null,
+        { completeSimple: complete as never },
+      );
+      await completeEntered.promise;
+      continueComplete.resolve();
+      await new Promise((resolve) => setTimeout(resolve, 30));
+      controller.abort();
+      lease.release();
+      const result = await completion;
+      assert.deepStrictEqual(result, { ok: false, appliedCount: 0, fallbackReason: "aborted" });
+      assert.equal(store.getMemoryEntries().some((entry) => entry.includes("late-after-shutdown")), false);
+    } finally {
+      lease.release();
+    }
+  });
+
   it("uses the in-lock mutation observer as the sole SQLite reconciliation path", async () => {
     const store = new MemoryStore({
       memoryDir: tmpDir,

package/dist/extensions/pi-hermes-memory/tests/handlers/session-backfill.test.ts

@@ -189,4 +189,43 @@ describe('session backfill handler', () => {
 
     assert.equal(completed, false);
   });
+
+  it('propagates the retention cutoff to the backfill file set', async () => {
+    // Only an expired file exists (mtime older than the 30-day cutoff). Even
+    // with recent backfill timestamps, the backfill must not be scheduled
+    // because the file is outside the retained window.
+    writeJsonlSession(sessionsDir, 'project-a', 'old');
+    const oldFile = path.join(sessionsDir, 'project-a', 'old.jsonl');
+    const cutoffMs = Date.now() - 30 * 24 * 60 * 60 * 1000;
+    const oldMtime = cutoffMs - 1000;
+    fs.utimesSync(oldFile, new Date(oldMtime), new Date(oldMtime));
+
+    touchBackfillTimestamp(dbManager);
+
+    let receivedCutoff: number | undefined;
+    let indexOptions: { retentionCutoffMs?: number } | undefined;
+    const state: SessionBackfillState = { inProgress: false, promise: null };
+
+    const scheduled = scheduleSessionBackfill(dbManager, sessionsDir, {
+      state,
+      retentionCutoffMs: cutoffMs,
+      setTimeoutFn: () => 0,
+      // Capture the cutoff that would be forwarded to the store so we prove
+      // the wiring reaches both the eligibility check and the indexer.
+      needsBackfillFn: (_db, _dir, _now, cutoff) => {
+        receivedCutoff = cutoff;
+        return false;
+      },
+      indexSessionsFn: (_db, _dir, options) => {
+        indexOptions = options;
+        return { sessionsProcessed: 0, sessionsIndexed: 0, sessionsSkipped: 0, messagesIndexed: 0, reachedLimit: undefined, errors: [] };
+      },
+    });
+
+    // needsBackfill ran and received the cutoff; because it returned false for
+    // an expired file set, no backfill pass was scheduled.
+    assert.equal(scheduled, false);
+    assert.equal(receivedCutoff, cutoffMs);
+    assert.equal(indexOptions, undefined);
+  });
 });

package/dist/extensions/pi-hermes-memory/tests/integration/corruption-recovery-integration.test.ts

@@ -0,0 +1,91 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { DatabaseManager } from '../../src/store/db.js';
+import { isFts5QueryError } from '../../src/store/fts-query.js';
+import { reconcileMarkdownMemoryScope } from '../../src/store/sqlite-memory-store.js';
+
+/**
+ * Behavior change under test (PR #184): reconcileMarkdownMemoryScope now
+ * runs its persistence inside DatabaseManager.withCorruptionRecovery().
+ * Before this change, corruption errors ("database disk image is malformed",
+ * SQLITE_CORRUPT, SQLITE_NOTADB) thrown during markdown reconciliation
+ * surfaced as raw failures on every memory write — corruption recovery was
+ * only wired into the session-indexing paths, so a corrupt sessions.db kept
+ * failing markdown syncs until repaired by hand. Now the markdown reconcile
+ * path participates in the same recovery: the corrupt database is
+ * quarantined, rebuilt, and the reconcile is retried on a fresh handle, so
+ * the memory entry is persisted instead of lost.
+ *
+ * The FTS5 soft fallback stays narrow: only genuine FTS query/index errors
+ * (isFts5QueryError) degrade to a warned, repair-guided result. Corruption
+ * signals never match that classifier, so they can never be swallowed into a
+ * zero-count success here.
+ */
+describe('Corruption recovery during markdown sync', () => {
+  it('keeps corruption signals out of the FTS5 fallback classifier', () => {
+    // Corruption/recovery signals must propagate so DatabaseManager can
+    // quarantine + rebuild, not be swallowed by the search-index fallback.
+    assert.equal(isFts5QueryError(new Error('database disk image is malformed')), false);
+    assert.equal(isFts5QueryError(new Error('SQL logic error')), false);
+    assert.equal(isFts5QueryError(new Error('file is not a database')), false);
+    // Genuine FTS5 query/index errors remain recoverable search-path failures.
+    assert.equal(isFts5QueryError(new Error('fts5: syntax error near "AND"')), true);
+    assert.equal(isFts5QueryError(new Error('fts5: unterminated string')), true);
+  });
+
+  it('withCorruptionRecovery quarantines a corrupt DB, rebuilds, and persists the entry', async () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'hermes-corruption-'));
+    const dbManager = new DatabaseManager(tmpDir);
+    const dbFile = path.join(tmpDir, 'sessions.db');
+
+    try {
+      // 1. Prime a healthy database with one memory.
+      const first = reconcileMarkdownMemoryScope(dbManager, ['first healthy entry'], 'memory', null);
+      assert.equal(first.inserted, 1);
+      await dbManager.waitForStartupIntegrityScan();
+
+      // 2. Close the handle and corrupt the DB file on disk.
+      dbManager.close();
+      fs.writeFileSync(dbFile, 'GARBAGE-NOT-A-SQLITE-DB'.repeat(32), 'utf-8');
+      assert.equal(isFts5QueryError(new Error('file is not a database')), false);
+
+      // 3. Reconcile a second entry. The corrupt file must be detected,
+      // quarantined, and a fresh database rebuilt — and the entry persisted
+      // on the healthy database instead of being swallowed as a zero-count
+      // "successful" reconcile.
+      const second = reconcileMarkdownMemoryScope(dbManager, ['second entry after corruption'], 'memory', null);
+
+      // 4. Recovery must have run (not a no-op reuse of the corrupt file).
+      const recovery = dbManager.getLastRecovery();
+      assert.ok(recovery, 'expected a corruption recovery to be recorded');
+      assert.notEqual(recovery.strategy, 'reused', 'the corrupt file must not have been reused');
+      assert.ok(recovery.backupPaths.length >= 1, 'the corrupt file must have been quarantined to a backup');
+      for (const backup of recovery.backupPaths) {
+        assert.ok(fs.existsSync(backup), `quarantined backup missing: ${backup}`);
+      }
+
+      // 5. The entry must actually be persisted in the rebuilt database —
+      // a swallowed zero-count success would leave the memory in markdown only.
+      assert.ok(second.inserted >= 1, `expected the entry to persist after recovery, got ${JSON.stringify(second)}`);
+      const rows = dbManager.getDb()
+        .prepare('SELECT content FROM memories WHERE target = ? ORDER BY id ASC')
+        .all('memory') as Array<{ content: string }>;
+      assert.ok(
+        rows.some((row) => row.content.includes('second entry after corruption')),
+        'the second entry must be present in the rebuilt database',
+      );
+
+      // 6. The original path must now hold a fresh, healthy database.
+      const header = fs.readFileSync(dbFile).subarray(0, 16).toString('utf-8');
+      assert.equal(header, 'SQLite format 3\x00', 'a fresh SQLite database must exist at the original path');
+    } finally {
+      try { dbManager.close(); } catch { /* best effort */ }
+      // Best-effort: on Windows the shared AtomicLockCoordinator keeps
+      // .pi-hermes-locks.sqlite open, so the directory may not be removable.
+      try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch { /* OS cleans temp eventually */ }
+    }
+  });
+});

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

@@ -905,6 +905,35 @@ describe('DatabaseManager', () => {
       assert.ok(fs.readdirSync(tmpDir).some((name) => name.startsWith('sessions.db.corrupt-')), 'corrupt DB should be quarantined');
     });
 
+    it('skips the startup integrity scan when disabled while preserving normal reads and writes', async () => {
+      const db = dbManager.getDb();
+      db.prepare(`
+        INSERT INTO sessions (id, project, cwd, started_at)
+        VALUES (?, ?, ?, ?)
+      `).run('skip-scan-session', 'skip-scan-project', '/work/skip-scan', '2026-05-03T00:00:00Z');
+      db.prepare(`
+        INSERT INTO messages (id, session_id, role, content, timestamp)
+        VALUES (?, ?, ?, ?, ?)
+      `).run('skip-scan-message', 'skip-scan-session', 'user', 'readable message', '2026-05-03T00:00:00Z');
+      dbManager.close();
+
+      corruptRecoverableIndexPage(path.join(tmpDir, 'sessions.db'), 'idx_messages_timestamp');
+
+      dbManager = new DatabaseManager(tmpDir);
+      dbManager.setQuickCheckOnOpen(false);
+      const reopenedDb = dbManager.getDb();
+      await dbManager.waitForStartupIntegrityScan();
+
+      assert.strictEqual(dbManager.getLastRecovery(), null);
+      const sessionCount = reopenedDb.prepare('SELECT COUNT(*) AS count FROM sessions').get();
+      assert.strictEqual(sessionCount.count, 1);
+      reopenedDb.prepare(`
+        INSERT INTO sessions (id, project, cwd, started_at)
+        VALUES (?, ?, ?, ?)
+      `).run('skip-scan-session-2', 'skip-scan-project', '/work/skip-scan', '2026-05-03T00:01:00Z');
+      assert.strictEqual(reopenedDb.prepare('SELECT COUNT(*) AS count FROM sessions').get().count, 2);
+    });
+
     it('quarantines unrecoverable files and recreates an empty database', () => {
       dbManager.close();
       const dbPath = path.join(tmpDir, 'sessions.db');