context-mode 1.0.56 → 1.0.58

package/build/adapters/opencode/index.js

@@ -151,8 +151,11 @@ export class OpenCodeAdapter {
         if (this.platform === "kilo") {
             return [
                 resolve("kilo.json"),
-                resolve(".kilocode", "kilo.json"),
+                resolve("kilo.jsonc"),
+                resolve(".kilo", "kilo.json"),
+                resolve(".kilo", "kilo.jsonc"),
                 join(homedir(), ".config", "kilo", "kilo.json"),
+                join(homedir(), ".config", "kilo", "kilo.jsonc"),
             ];
         }
         return [
@@ -165,7 +168,14 @@ export class OpenCodeAdapter {
         ];
     }
     getSessionDir() {
-        const dir = join(homedir(), ".config", this.platform, "context-mode", "sessions");
+        let configDir;
+        if (process.platform === "win32") {
+            configDir = process.env.APPDATA || join(homedir(), "AppData", "Roaming");
+        }
+        else {
+            configDir = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+        }
+        const dir = join(configDir, this.platform, "context-mode", "sessions");
         mkdirSync(dir, { recursive: true });
         return dir;
     }
@@ -224,25 +234,38 @@ export class OpenCodeAdapter {
         };
     }
     readSettings() {
-        // Try project-local paths first, then global config
-        // const paths = this.getConfigFilePaths();
-        // for (const configPath of paths) {
         this.settingsPath = undefined;
-        for (const configPath of this.paths()) {
+        const configPaths = this.paths();
+        const globalPaths = new Set(configPaths.filter(p => p.includes(homedir())));
+        let firstValidSettings = null;
+        let firstValidPath;
+        for (const configPath of configPaths) {
             try {
                 const raw = readFileSync(configPath, "utf-8");
-                this.settingsPath = configPath;
                 const text = configPath.endsWith(".jsonc") ? stripJsonComments(raw) : raw;
-                return JSON.parse(text);
+                const settings = JSON.parse(text);
+                if (!firstValidSettings) {
+                    firstValidSettings = settings;
+                    firstValidPath = configPath;
+                }
+                const isGlobalConfig = globalPaths.has(configPath);
+                if (this.hasContextModePlugin(settings) || isGlobalConfig) {
+                    this.settingsPath = configPath;
+                    return settings;
+                }
             }
             catch {
                 continue;
             }
         }
+        if (firstValidSettings) {
+            this.settingsPath = firstValidPath;
+            return firstValidSettings;
+        }
         return null;
     }
     writeSettings(settings) {
-        // Write to opencode.json/kilo.json in current directory
+        // Write to opencode.json(c)/kilo.json(c) in current directory
         writeFileSync(this.getSettingsPath(), JSON.stringify(settings, null, 2) + "\n", "utf-8");
     }
     // ── Diagnostics (doctor) ─────────────────────────────────
@@ -259,9 +282,8 @@ export class OpenCodeAdapter {
             return results;
         }
         // Check for "context-mode" in plugin array
-        const plugins = settings.plugin;
-        if (plugins && Array.isArray(plugins)) {
-            const hasPlugin = plugins.some((p) => p.includes("context-mode"));
+        const hasPlugin = this.hasContextModePlugin(settings);
+        if (Array.isArray(settings.plugin)) {
             results.push({
                 check: "Plugin registration",
                 status: hasPlugin ? "pass" : "fail",
@@ -277,7 +299,7 @@ export class OpenCodeAdapter {
             results.push({
                 check: "Plugin registration",
                 status: "fail",
-                message: "No plugin array found in opencode.json",
+                message: `No plugin array found in ${this.platform}.json or ${this.platform}.jsonc`,
                 fix: "context-mode upgrade",
             });
         }
@@ -285,7 +307,7 @@ export class OpenCodeAdapter {
         results.push({
             check: "SessionStart hook",
             status: "warn",
-            message: "SessionStart not supported in OpenCode (see issues #14808, #5409)",
+            message: `SessionStart not supported in ${this.name} (see issues #14808, #5409)`,
         });
         return results;
     }
@@ -298,21 +320,17 @@ export class OpenCodeAdapter {
                 message: `Could not read ${this.platform}.json or ${this.platform}.jsonc`,
             };
         }
-        const plugins = settings.plugin;
-        if (plugins && Array.isArray(plugins)) {
-            const hasPlugin = plugins.some((p) => p.includes("context-mode"));
-            if (hasPlugin) {
-                return {
-                    check: "Plugin registration",
-                    status: "pass",
-                    message: "context-mode found in plugin array",
-                };
-            }
+        if (this.hasContextModePlugin(settings)) {
+            return {
+                check: "Plugin registration",
+                status: "pass",
+                message: "context-mode found in plugin array",
+            };
         }
         return {
             check: "Plugin registration",
             status: "fail",
-            message: "context-mode not found in opencode.json plugin array",
+            message: `context-mode not found in ${this.platform}.json plugin array`,
             fix: "context-mode upgrade",
         };
     }
@@ -347,20 +365,23 @@ export class OpenCodeAdapter {
         return changes;
     }
     backupSettings() {
-        this.settingsPath = undefined;
-        for (const configPath of this.paths()) {
+        const check = this.checkPluginRegistration();
+        if (!this.settingsPath)
+            return null;
+        if (check.status === "pass") {
+            return this.settingsPath;
+        }
+        else {
             try {
-                accessSync(configPath, constants.R_OK);
-                this.settingsPath = configPath;
-                const backupPath = configPath + ".bak";
-                copyFileSync(configPath, backupPath);
+                accessSync(this.settingsPath, constants.R_OK);
+                const backupPath = this.settingsPath + ".bak";
+                copyFileSync(this.settingsPath, backupPath);
                 return backupPath;
             }
             catch {
-                continue;
+                return null;
             }
         }
-        return null;
     }
     setHookPermissions(_pluginRoot) {
         // OpenCode uses TS plugin paradigm — no shell scripts to chmod
@@ -370,6 +391,13 @@ export class OpenCodeAdapter {
         // OpenCode manages plugins through npm/opencode.json — no separate registry
     }
     // ── Internal helpers ───────────────────────────────────
+    /**
+     * Check whether a settings object has the context-mode plugin registered.
+     */
+    hasContextModePlugin(settings) {
+        const plugins = settings.plugin;
+        return Array.isArray(plugins) && plugins.some((p) => typeof p === "string" && p.includes("context-mode"));
+    }
     /**
      * Extract session ID from OpenCode hook input.
      * OpenCode uses camelCase sessionID.

package/build/cli.js

@@ -17,7 +17,7 @@ import { execFileSync } from "node:child_process";
 import { readFileSync, writeFileSync, cpSync, accessSync, existsSync, rmSync, closeSync, openSync, chmodSync, constants } from "node:fs";
 import { request as httpsRequest } from "node:https";
 import { resolve, dirname, join } from "node:path";
-import { tmpdir, devNull } from "node:os";
+import { tmpdir, devNull, homedir } from "node:os";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { detectRuntimes, getRuntimeSummary, hasBunRuntime, getAvailableLanguages, } from "./runtime.js";
 // ── Adapter imports ──────────────────────────────────────
@@ -98,7 +98,7 @@ else {
 export function toUnixPath(p) {
     return p.replace(/\\/g, "/");
 }
-function getPluginRoot() {
+function defaultPluginRoot() {
     const __filename = fileURLToPath(import.meta.url);
     const __dirname = dirname(__filename);
     // build/cli.js or src/cli.ts → go up one level; cli.bundle.mjs at project root → stay here
@@ -108,6 +108,23 @@ function getPluginRoot() {
     }
     return __dirname;
 }
+// Opencode/Kilocode install plugins from npm into .cache folder
+function cachePluginRoot(platform) {
+    if (process.platform === "win32") {
+        const localApp = process.env.LOCALAPPDATA;
+        if (localApp)
+            return resolve(localApp, platform, "node_modules", "context-mode");
+        return resolve(homedir(), "AppData", "Local", platform, "node_modules", "context-mode");
+    }
+    return resolve(homedir(), ".cache", platform, "node_modules", "context-mode");
+}
+function getPluginRoot() {
+    const platform = detectPlatform().platform;
+    if (platform === 'opencode' || platform === 'kilo') {
+        return cachePluginRoot(platform);
+    }
+    return defaultPluginRoot();
+}
 function getLocalVersion() {
     try {
         const pkg = JSON.parse(readFileSync(resolve(getPluginRoot(), "package.json"), "utf-8"));
@@ -358,6 +375,8 @@ async function upgrade() {
         const newVersion = newPkg.version ?? "unknown";
         if (newVersion === localVersion) {
             p.log.success(color.green("Already on latest") + ` — v${localVersion}`);
+            rmSync(tmpDir, { recursive: true, force: true });
+            return;
         }
         else {
             p.log.info(`Update available: ${color.yellow("v" + localVersion)} → ${color.green("v" + newVersion)}`);
@@ -412,23 +431,25 @@ async function upgrade() {
             timeout: 60000,
         });
         s.stop("Dependencies ready");
-        // Rebuild native addons for current Node.js ABI (fixes #131)
-        s.start("Rebuilding native addons");
-        try {
-            execFileSync("npm", ["rebuild", "better-sqlite3"], {
-                cwd: pluginRoot,
-                stdio: "pipe",
-                timeout: 60000,
-            });
-            s.stop(color.green("Native addons rebuilt"));
-            changes.push("Rebuilt better-sqlite3 for current Node.js");
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            s.stop(color.yellow("Native addon rebuild warning"));
-            p.log.warn(color.yellow("better-sqlite3 rebuild issue") +
-                ` — ${message}` +
-                color.dim(`\n  Try manually: cd "${pluginRoot}" && npm rebuild better-sqlite3`));
+        if (detection.platform !== 'opencode' && detection.platform !== 'kilo') {
+            // Rebuild native addons for current Node.js ABI (fixes #131)
+            s.start("Rebuilding native addons");
+            try {
+                execFileSync("npm", ["rebuild", "better-sqlite3"], {
+                    cwd: pluginRoot,
+                    stdio: "pipe",
+                    timeout: 60000,
+                });
+                s.stop(color.green("Native addons rebuilt"));
+                changes.push("Rebuilt better-sqlite3 for current Node.js");
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                s.stop(color.yellow("Native addon rebuild warning"));
+                p.log.warn(color.yellow("better-sqlite3 rebuild issue") +
+                    ` — ${message}` +
+                    color.dim(`\n  Try manually: cd "${pluginRoot}" && npm rebuild better-sqlite3`));
+            }
         }
         // Update global npm
         s.start("Updating npm global package");
@@ -465,10 +486,13 @@ async function upgrade() {
     // Step 3: Backup settings — adapter-aware
     p.log.step(`Backing up ${adapter.name} settings...`);
     const backupPath = adapter.backupSettings();
-    if (backupPath) {
+    if (backupPath?.endsWith(".bak")) {
         p.log.success(color.green("Backup created") + color.dim(" -> " + backupPath));
         changes.push("Backed up settings");
     }
+    else if (backupPath) {
+        p.log.success(color.green("Backup skipped") + color.dim(" — no changes needed"));
+    }
     else {
         p.log.warn(color.yellow("No existing settings to backup") +
             " — a new one will be created");

package/build/db-base.d.ts

@@ -69,13 +69,13 @@ export declare function closeDB(db: DatabaseInstance): void;
  */
 export declare function defaultDBPath(prefix?: string): string;
 /**
- * SQLiteBase — minimal base class that handles open/close/cleanup lifecycle.
- *
- * Subclasses call `super(dbPath)` to open the database with WAL pragmas
- * applied, then implement `initSchema()` and `prepareStatements()`.
- *
- * The `db` getter exposes the raw `DatabaseInstance` to subclasses only.
+ * Retry a DB operation with exponential backoff on SQLITE_BUSY errors.
+ * Catches errors containing "SQLITE_BUSY" or "database is locked" and
+ * retries up to 3 times with delays: 100ms, 500ms, 2000ms.
+ * If all retries fail, throws a descriptive error.
+ * Pass custom delays for testing (e.g., [0, 0, 0] to skip waits).
  */
+export declare function withRetry<T>(fn: () => T, delays?: number[]): T;
 export declare abstract class SQLiteBase {
     #private;
     constructor(dbPath: string);
@@ -89,6 +89,7 @@ export declare abstract class SQLiteBase {
     get dbPath(): string;
     /** Close the database connection without deleting files. */
     close(): void;
+    protected withRetry<T>(fn: () => T): T;
     /**
      * Close the connection and delete all associated DB files (main, WAL, SHM).
      * Call on process exit or at end of session lifecycle.

package/build/db-base.js

@@ -178,6 +178,38 @@ export function defaultDBPath(prefix = "context-mode") {
     return join(tmpdir(), `${prefix}-${process.pid}.db`);
 }
 // ─────────────────────────────────────────────────────────
+// Retry helper
+// ─────────────────────────────────────────────────────────
+/**
+ * Retry a DB operation with exponential backoff on SQLITE_BUSY errors.
+ * Catches errors containing "SQLITE_BUSY" or "database is locked" and
+ * retries up to 3 times with delays: 100ms, 500ms, 2000ms.
+ * If all retries fail, throws a descriptive error.
+ * Pass custom delays for testing (e.g., [0, 0, 0] to skip waits).
+ */
+export function withRetry(fn, delays = [100, 500, 2000]) {
+    let lastError;
+    for (let attempt = 0; attempt <= delays.length; attempt++) {
+        try {
+            return fn();
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (!msg.includes("SQLITE_BUSY") && !msg.includes("database is locked")) {
+                throw err;
+            }
+            lastError = err instanceof Error ? err : new Error(msg);
+            if (attempt < delays.length) {
+                const delay = delays[attempt];
+                const start = Date.now();
+                while (Date.now() - start < delay) { /* busy-wait for sync retry */ }
+            }
+        }
+    }
+    throw new Error(`SQLITE_BUSY: database is locked after ${delays.length} retries. ` +
+        `Original error: ${lastError?.message}`);
+}
+// ─────────────────────────────────────────────────────────
 // Base class
 // ─────────────────────────────────────────────────────────
 /**
@@ -188,13 +220,40 @@ export function defaultDBPath(prefix = "context-mode") {
  *
  * The `db` getter exposes the raw `DatabaseInstance` to subclasses only.
  */
+/**
+ * Track all live DatabaseInstance objects so we can close them on process exit.
+ * Prevents better-sqlite3 segfaults caused by V8 garbage-collecting Database
+ * objects after the native addon context is already torn down.
+ *
+ * Uses a global symbol so the set and exit handler survive vitest's module
+ * re-imports within the same fork process (ESM isolate mode clears
+ * module-level state but globalThis persists).
+ */
+const _kLiveDBs = Symbol.for("__context_mode_live_dbs__");
+const _liveDBs = (() => {
+    const g = globalThis;
+    if (!g[_kLiveDBs]) {
+        g[_kLiveDBs] = new Set();
+        process.on("exit", () => {
+            for (const db of g[_kLiveDBs]) {
+                try {
+                    db.close();
+                }
+                catch { /* already closed */ }
+            }
+            g[_kLiveDBs].clear();
+        });
+    }
+    return g[_kLiveDBs];
+})();
 export class SQLiteBase {
     #dbPath;
     #db;
     constructor(dbPath) {
         const Database = loadDatabase();
         this.#dbPath = dbPath;
-        this.#db = new Database(dbPath, { timeout: 5000 });
+        this.#db = new Database(dbPath, { timeout: 30000 });
+        _liveDBs.add(this.#db);
         applyWALPragmas(this.#db);
         this.initSchema();
         this.prepareStatements();
@@ -209,13 +268,18 @@ export class SQLiteBase {
     }
     /** Close the database connection without deleting files. */
     close() {
+        _liveDBs.delete(this.#db);
         closeDB(this.#db);
     }
+    withRetry(fn) {
+        return withRetry(fn);
+    }
     /**
      * Close the connection and delete all associated DB files (main, WAL, SHM).
      * Call on process exit or at end of session lifecycle.
      */
     cleanup() {
+        _liveDBs.delete(this.#db);
         closeDB(this.#db);
         deleteDBFiles(this.#dbPath);
     }

package/build/opencode-plugin.d.ts

@@ -53,7 +53,7 @@ interface CompactingHookOutput {
 /**
  * OpenCode plugin factory. Called once when OpenCode loads the plugin.
  * Returns an object mapping hook event names to async handler functions.
- */
+*/
 export declare const ContextModePlugin: (ctx: PluginContext) => Promise<{
     "tool.execute.before": (input: BeforeHookInput, output: BeforeHookOutput) => Promise<void>;
     "tool.execute.after": (input: AfterHookInput, output: AfterHookOutput) => Promise<void>;

package/build/opencode-plugin.js

@@ -14,37 +14,25 @@
  *   - No routing file auto-write (avoid dirtying project trees)
  *   - Session cleanup happens at plugin init (no SessionStart)
  */
-import { createHash, randomUUID } from "node:crypto";
-import { mkdirSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
+import { randomUUID } from "node:crypto";
+import { dirname, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { SessionDB } from "./session/db.js";
 import { extractEvents } from "./session/extract.js";
 import { buildResumeSnapshot } from "./session/snapshot.js";
+import { OpenCodeAdapter } from "./adapters/opencode/index.js";
 // ── Helpers ───────────────────────────────────────────────
 function getPlatform() {
     return process.env.KILO ? "kilo" : "opencode";
 }
-function getSessionDir() {
-    const dir = join(homedir(), ".config", getPlatform(), "context-mode", "sessions");
-    mkdirSync(dir, { recursive: true });
-    return dir;
-}
-function getDBPath(projectDir) {
-    const hash = createHash("sha256")
-        .update(projectDir)
-        .digest("hex")
-        .slice(0, 16);
-    return join(getSessionDir(), `${hash}.db`);
-}
 // ── Plugin Factory ────────────────────────────────────────
 /**
  * OpenCode plugin factory. Called once when OpenCode loads the plugin.
  * Returns an object mapping hook event names to async handler functions.
- */
+*/
 export const ContextModePlugin = async (ctx) => {
     // Resolve build dir from compiled JS location
+    const adapter = new OpenCodeAdapter(getPlatform());
     const buildDir = dirname(fileURLToPath(import.meta.url));
     // Load routing module (ESM .mjs, lives outside build/ in hooks/)
     const routingPath = resolve(buildDir, "..", "hooks", "core", "routing.mjs");
@@ -52,7 +40,7 @@ export const ContextModePlugin = async (ctx) => {
     await routing.initSecurity(buildDir);
     // Initialize session
     const projectDir = ctx.directory;
-    const db = new SessionDB({ dbPath: getDBPath(projectDir) });
+    const db = new SessionDB({ dbPath: adapter.getSessionDBPath(projectDir) });
     const sessionId = randomUUID();
     db.ensureSession(sessionId, projectDir);
     // Clean up old sessions on startup (replaces SessionStart hook)

package/build/server.js

@@ -127,7 +127,43 @@ const sessionStats = {
     cacheBytesSaved: 0, // bytes avoided by TTL cache hits
     sessionStart: Date.now(),
 };
+/**
+ * Reset session stats to zero. Called when /clear flag is detected.
+ * The SessionStart hook writes a .clear-stats flag file on /clear,
+ * and the server checks for it before each tool call.
+ */
+function resetSessionStats() {
+    sessionStats.calls = {};
+    sessionStats.bytesReturned = {};
+    sessionStats.bytesIndexed = 0;
+    sessionStats.bytesSandboxed = 0;
+    sessionStats.cacheHits = 0;
+    sessionStats.cacheBytesSaved = 0;
+    sessionStats.sessionStart = Date.now();
+    // Also reset FTS5 content store — drop and recreate on next getStore() call
+    if (_store) {
+        try {
+            _store.cleanup();
+        }
+        catch { /* best effort */ }
+        _store = null;
+    }
+}
+/** Check for .clear-stats flag and reset stats if found. */
+function checkClearStatsFlag() {
+    const sessDir = join(homedir(), ".claude", "context-mode", "sessions");
+    try {
+        const flags = readdirSync(sessDir).filter((f) => f.endsWith(".clear-stats"));
+        for (const f of flags) {
+            unlinkSync(join(sessDir, f));
+        }
+        if (flags.length > 0)
+            resetSessionStats();
+    }
+    catch { /* best effort */ }
+}
 function trackResponse(toolName, response) {
+    checkClearStatsFlag();
     const bytes = response.content.reduce((sum, c) => sum + Buffer.byteLength(c.text), 0);
     sessionStats.calls[toolName] = (sessionStats.calls[toolName] || 0) + 1;
     sessionStats.bytesReturned[toolName] =
@@ -1370,8 +1406,18 @@ server.registerTool("ctx_stats", {
     description: "Returns context consumption statistics for the current session. " +
         "Shows total bytes returned to context, breakdown by tool, call counts, " +
         "estimated token usage, and context savings ratio.",
-    inputSchema: z.object({}),
-}, async () => {
+    inputSchema: z.object({
+        reset: z.boolean().optional().describe("Reset all stats and FTS5 store to zero. Use after /clear."),
+    }),
+}, async ({ reset }) => {
+    // Check for clear flag BEFORE reading stats
+    checkClearStatsFlag();
+    if (reset) {
+        resetSessionStats();
+        return trackResponse("ctx_stats", {
+            content: [{ type: "text", text: "Session stats and search index reset." }],
+        });
+    }
     const totalBytesReturned = Object.values(sessionStats.bytesReturned).reduce((sum, b) => sum + b, 0);
     const totalCalls = Object.values(sessionStats.calls).reduce((sum, c) => sum + c, 0);
     const uptimeMs = Date.now() - sessionStats.sessionStart;

package/build/store.d.ts

@@ -17,6 +17,8 @@ export declare function cleanupStaleDBs(): number;
 /**
  * Clean up stale per-project content store DBs older than maxAgeDays.
  * Scans the given directory for *.db files and checks mtime.
+ * Also detects zombie processes holding WAL locks — if a WAL file exists
+ * but the owning PID is dead, the DB files are cleaned up regardless of age.
  */
 export declare function cleanupStaleContentDBs(contentDir: string, maxAgeDays: number): number;
 export declare class ContentStore {

package/build/store.js

@@ -7,7 +7,7 @@
  * Use for documentation, API references, and any content where
  * you need EXACT text later — not summaries.
  */
-import { loadDatabase, applyWALPragmas, closeDB } from "./db-base.js";
+import { loadDatabase, applyWALPragmas, closeDB, withRetry } from "./db-base.js";
 import { readFileSync, readdirSync, unlinkSync, existsSync, statSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -116,9 +116,24 @@ export function cleanupStaleDBs() {
     catch { /* ignore readdir errors */ }
     return cleaned;
 }
+/**
+ * Check if a PID is still alive (not a zombie holding a WAL lock).
+ * Returns true if the process exists, false if it's dead.
+ */
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Clean up stale per-project content store DBs older than maxAgeDays.
  * Scans the given directory for *.db files and checks mtime.
+ * Also detects zombie processes holding WAL locks — if a WAL file exists
+ * but the owning PID is dead, the DB files are cleaned up regardless of age.
  */
 export function cleanupStaleContentDBs(contentDir, maxAgeDays) {
     let cleaned = 0;
@@ -131,7 +146,25 @@ export function cleanupStaleContentDBs(contentDir, maxAgeDays) {
             try {
                 const filePath = join(contentDir, file);
                 const mtime = statSync(filePath).mtimeMs;
-                if (mtime < cutoff) {
+                let shouldClean = mtime < cutoff;
+                // Detect zombie processes holding WAL locks:
+                // If a WAL file exists, try to read the WAL header to extract the PID.
+                // WAL files from dead processes can block new connections.
+                if (!shouldClean) {
+                    const walPath = filePath + "-wal";
+                    if (existsSync(walPath)) {
+                        try {
+                            const walStat = statSync(walPath);
+                            // If WAL file is non-empty and DB hasn't been modified in >1 hour,
+                            // the owning process may be dead — check via mtime staleness
+                            if (walStat.size > 0 && (Date.now() - walStat.mtimeMs) > 3600_000) {
+                                shouldClean = true;
+                            }
+                        }
+                        catch { /* ignore WAL check errors */ }
+                    }
+                }
+                if (shouldClean) {
                     for (const suffix of ["", "-wal", "-shm"]) {
                         try {
                             unlinkSync(filePath + suffix);
@@ -234,7 +267,7 @@ export class ContentStore {
         const Database = loadDatabase();
         this.#dbPath =
             dbPath ?? join(tmpdir(), `context-mode-${process.pid}.db`);
-        this.#db = new Database(this.#dbPath, { timeout: 5000 });
+        this.#db = new Database(this.#dbPath, { timeout: 30000 });
         applyWALPragmas(this.#db);
         this.#initSchema();
         this.#prepareStatements();
@@ -496,7 +529,7 @@ export class ContentStore {
         const text = content ?? readFileSync(path, "utf-8");
         const label = source ?? path ?? "untitled";
         const chunks = this.#chunkMarkdown(text);
-        return this.#insertChunks(chunks, label, text);
+        return withRetry(() => this.#insertChunks(chunks, label, text));
     }
     // ── Index Plain Text ──
     /**
@@ -613,7 +646,7 @@ export class ContentStore {
             stmt = this.#stmtSearchPorter;
             params = [sanitized, limit];
         }
-        return this.#mapSearchRows(stmt.all(...params));
+        return withRetry(() => this.#mapSearchRows(stmt.all(...params)));
     }
     // ── Trigram Search (Layer 2) ──
     searchTrigram(query, limit = 3, source, mode = "AND", contentType, sourceMatchMode = "like") {