@neurcode-ai/cli 0.9.7 → 0.9.9

package/dist/utils/plan-cache.js

@@ -1,21 +1,58 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeIntent = normalizeIntent;
-exports.getPlanCachePath = getPlanCachePath;
-exports.computePlanCacheKey = computePlanCacheKey;
+exports.getRepoIdentity = getRepoIdentity;
 exports.getGitRepoFingerprint = getGitRepoFingerprint;
 exports.getFilesystemFingerprintFromTree = getFilesystemFingerprintFromTree;
+exports.computePromptHash = computePromptHash;
+exports.computePolicyVersionHash = computePolicyVersionHash;
+exports.getNeurcodeVersion = getNeurcodeVersion;
+exports.computePlanCacheKey = computePlanCacheKey;
+exports.getBrainDbPath = getBrainDbPath;
+exports.getBrainPointerPath = getBrainPointerPath;
+exports.getBrainFallbackCachePath = getBrainFallbackCachePath;
+exports.getPlanCachePath = getPlanCachePath;
+exports.getBrainStorageMode = getBrainStorageMode;
+exports.setNoCodeStorageMode = setNoCodeStorageMode;
+exports.isNoCodeStorageMode = isNoCodeStorageMode;
 exports.readCachedPlan = readCachedPlan;
+exports.peekCachedPlan = peekCachedPlan;
 exports.writeCachedPlan = writeCachedPlan;
+exports.listCachedPlans = listCachedPlans;
+exports.deleteCachedPlans = deleteCachedPlans;
 exports.findSimilarCachedPlans = findSimilarCachedPlans;
+exports.getBrainDbSizeBytes = getBrainDbSizeBytes;
+exports.getBrainStoreBackend = getBrainStoreBackend;
+exports.closeBrainStore = closeBrainStore;
 const child_process_1 = require("child_process");
 const crypto_1 = require("crypto");
 const fs_1 = require("fs");
 const path_1 = require("path");
 const secret_masking_1 = require("./secret-masking");
-const CACHE_SCHEMA_VERSION = 1;
-const CACHE_FILE_NAME = 'plan-cache.json';
-const MAX_ENTRIES = 50;
+let sqliteCtor = null;
+function getSqliteCtor() {
+    if (sqliteCtor)
+        return sqliteCtor;
+    try {
+        sqliteCtor = require('better-sqlite3');
+        return sqliteCtor;
+    }
+    catch {
+        return null;
+    }
+}
+const CACHE_SCHEMA_VERSION = 2;
+const BRAIN_DB_FILE_NAME = 'brain.db';
+const BRAIN_POINTER_FILE_NAME = 'brain.json';
+const LEGACY_CACHE_FILE_NAME = 'plan-cache.json';
+const FALLBACK_CACHE_FILE_NAME = 'plan-cache.json';
+const MAX_ENTRIES = 500;
+const NON_SEMANTIC_GIT_PATH_MARKERS = [
+    '.neurcode/',
+    '.gitignore',
+];
+const dbConnections = new Map();
+let cachedCliVersion = null;
 function sha256Hex(input) {
     return (0, crypto_1.createHash)('sha256').update(input).digest('hex');
 }
@@ -25,129 +62,669 @@ function normalizeIntent(intent) {
         .replace(/\s+/g, ' ')
         .toLowerCase();
 }
-function getPlanCachePath(cwd) {
-    return (0, path_1.join)(cwd, '.neurcode', CACHE_FILE_NAME);
+function sanitizeGitStatusPorcelain(status) {
+    const lines = status.split(/\r?\n/).filter((line) => line.trim().length > 0);
+    const filtered = lines.filter((line) => {
+        for (const marker of NON_SEMANTIC_GIT_PATH_MARKERS) {
+            if (line.includes(marker))
+                return false;
+        }
+        return true;
+    });
+    return filtered.join('\n');
 }
-function ensureNeurcodeDir(cwd) {
-    const dir = (0, path_1.join)(cwd, '.neurcode');
-    if (!(0, fs_1.existsSync)(dir)) {
-        (0, fs_1.mkdirSync)(dir, { recursive: true });
+function normalizeRepoIdentity(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return '';
+    // Convert SCP-like git syntax to URI form: git@host:owner/repo -> ssh://host/owner/repo
+    let normalized = trimmed;
+    const scpLike = /^[^@]+@[^:]+:.+$/;
+    if (scpLike.test(trimmed)) {
+        const at = trimmed.indexOf('@');
+        const colon = trimmed.indexOf(':', at);
+        const host = trimmed.slice(at + 1, colon);
+        const repoPath = trimmed.slice(colon + 1);
+        normalized = `ssh://${host}/${repoPath}`;
     }
-}
-function safeReadCacheFile(cachePath) {
-    if (!(0, fs_1.existsSync)(cachePath)) {
-        return { schemaVersion: CACHE_SCHEMA_VERSION, entries: {} };
+    try {
+        const parsed = new URL(normalized);
+        parsed.username = '';
+        parsed.password = '';
+        const noAuth = `${parsed.protocol}//${parsed.host}${parsed.pathname}`.replace(/\/+$/, '');
+        return noAuth.replace(/\.git$/i, '').toLowerCase();
+    }
+    catch {
+        return normalized.replace(/\/+$/, '').replace(/\.git$/i, '').toLowerCase();
     }
+}
+function fallbackRepoIdentity(cwd) {
+    return `local:${sha256Hex((0, path_1.resolve)(cwd))}`;
+}
+function getRepoIdentity(cwd) {
     try {
-        const raw = (0, fs_1.readFileSync)(cachePath, 'utf-8');
-        const parsed = JSON.parse(raw);
-        if (parsed.schemaVersion !== CACHE_SCHEMA_VERSION || !parsed.entries || typeof parsed.entries !== 'object') {
-            throw new Error('Invalid cache schema');
+        const inside = (0, child_process_1.execSync)('git rev-parse --is-inside-work-tree', {
+            cwd,
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim().toLowerCase();
+        if (inside === 'true') {
+            const remote = (0, child_process_1.execSync)('git config --get remote.origin.url', {
+                cwd,
+                encoding: 'utf-8',
+                stdio: ['ignore', 'pipe', 'ignore'],
+            }).trim();
+            const normalizedRemote = normalizeRepoIdentity(remote);
+            if (normalizedRemote)
+                return normalizedRemote;
         }
-        const cache = parsed;
-        // Best-effort: avoid persisting secrets in cached intents (older caches may include them).
-        // This does not affect cache keys (they remain stable), it only sanitizes the stored intent text.
-        try {
-            for (const entry of Object.values(cache.entries)) {
-                if (!entry?.input?.intent)
-                    continue;
-                entry.input.intent = (0, secret_masking_1.maskSecretsInText)(entry.input.intent).masked;
+    }
+    catch {
+        // ignore
+    }
+    return fallbackRepoIdentity(cwd);
+}
+function getGitRepoFingerprint(cwd) {
+    try {
+        const inside = (0, child_process_1.execSync)('git rev-parse --is-inside-work-tree', {
+            cwd,
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim().toLowerCase();
+        if (inside !== 'true')
+            return null;
+        const repoIdentity = getRepoIdentity(cwd);
+        const headSha = (0, child_process_1.execSync)('git rev-parse HEAD', {
+            cwd,
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
+        const headTreeSha = (0, child_process_1.execSync)('git rev-parse HEAD^{tree}', {
+            cwd,
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
+        const status = (0, child_process_1.execSync)('git status --porcelain', {
+            cwd,
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        const workingTreeHash = sha256Hex(sanitizeGitStatusPorcelain(status));
+        return { kind: 'git', repoIdentity, headSha, headTreeSha, workingTreeHash };
+    }
+    catch {
+        return null;
+    }
+}
+function getFilesystemFingerprintFromTree(fileTree, cwd = process.cwd()) {
+    const normalized = [...fileTree].sort().join('\n');
+    return {
+        kind: 'filesystem',
+        repoIdentity: fallbackRepoIdentity(cwd),
+        fileTreeHash: sha256Hex(normalized),
+    };
+}
+function computePromptHash(input) {
+    const normalized = normalizeIntent(input.intent);
+    const safeIntent = (0, secret_masking_1.maskSecretsInText)(normalized).masked;
+    const payload = [
+        `intent=${safeIntent}`,
+        `ticketRef=${input.ticketRef || ''}`,
+        `contextHash=${input.contextHash || ''}`,
+    ].join('\n');
+    return sha256Hex(payload);
+}
+function collectPolicyFiles(cwd) {
+    const out = [];
+    const candidates = [
+        (0, path_1.join)(cwd, 'neurcode.policy.json'),
+        (0, path_1.join)(cwd, 'neurcode.rules.json'),
+        (0, path_1.join)(cwd, '.neurcode', 'policy.json'),
+        (0, path_1.join)(cwd, '.neurcode', 'rules.json'),
+    ];
+    for (const filePath of candidates) {
+        if ((0, fs_1.existsSync)(filePath))
+            out.push(filePath);
+    }
+    const policyDir = (0, path_1.join)(cwd, '.neurcode', 'policies');
+    if ((0, fs_1.existsSync)(policyDir)) {
+        const walk = (dir) => {
+            const entries = (0, fs_1.readdirSync)(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const full = (0, path_1.join)(dir, entry.name);
+                if (entry.isDirectory()) {
+                    walk(full);
+                }
+                else if (entry.isFile()) {
+                    out.push(full);
+                }
             }
+        };
+        try {
+            walk(policyDir);
         }
         catch {
-            // ignore
+            // ignore unreadable dirs
         }
-        return cache;
     }
-    catch {
-        // Preserve the corrupted file for debugging, but do not block the command.
+    return [...new Set(out)].sort();
+}
+function computePolicyVersionHash(cwd) {
+    const lines = [];
+    const envPolicyVersion = process.env.NEURCODE_POLICY_VERSION;
+    if (envPolicyVersion && envPolicyVersion.trim()) {
+        lines.push(`env:${envPolicyVersion.trim()}`);
+    }
+    for (const policyFile of collectPolicyFiles(cwd)) {
         try {
-            const corruptPath = cachePath.replace(/\.json$/, `.corrupt-${Date.now()}.json`);
-            (0, fs_1.renameSync)(cachePath, corruptPath);
+            const content = (0, fs_1.readFileSync)(policyFile, 'utf-8');
+            lines.push(`${policyFile}:${sha256Hex(content)}`);
         }
         catch {
-            // ignore
+            // ignore unreadable files
         }
-        return { schemaVersion: CACHE_SCHEMA_VERSION, entries: {} };
     }
+    if (lines.length === 0) {
+        lines.push('default-policy');
+    }
+    return sha256Hex(lines.join('\n'));
 }
-function atomicWrite(cachePath, data) {
-    const tmpPath = `${cachePath}.tmp`;
-    (0, fs_1.writeFileSync)(tmpPath, data, 'utf-8');
-    (0, fs_1.renameSync)(tmpPath, cachePath);
-}
-function prune(cache) {
-    const keys = Object.keys(cache.entries);
-    if (keys.length <= MAX_ENTRIES)
-        return;
-    const sorted = keys
-        .map((k) => cache.entries[k])
-        .filter(Boolean)
-        .sort((a, b) => {
-        const aTime = Date.parse(a.lastUsedAt) || 0;
-        const bTime = Date.parse(b.lastUsedAt) || 0;
-        return aTime - bTime;
-    });
-    const toRemove = sorted.slice(0, Math.max(0, sorted.length - MAX_ENTRIES));
-    for (const entry of toRemove) {
-        delete cache.entries[entry.key];
+function getNeurcodeVersion() {
+    if (cachedCliVersion)
+        return cachedCliVersion;
+    const envVersion = process.env.npm_package_version;
+    if (envVersion && envVersion.trim()) {
+        cachedCliVersion = envVersion.trim();
+        return cachedCliVersion;
+    }
+    const candidates = [
+        (0, path_1.join)(__dirname, '../../package.json'),
+        (0, path_1.join)(process.cwd(), 'packages/cli/package.json'),
+        (0, path_1.join)(process.cwd(), 'package.json'),
+    ];
+    for (const path of candidates) {
+        try {
+            if (!(0, fs_1.existsSync)(path))
+                continue;
+            const raw = (0, fs_1.readFileSync)(path, 'utf-8');
+            const parsed = JSON.parse(raw);
+            if (parsed.version && parsed.version.trim()) {
+                cachedCliVersion = parsed.version.trim();
+                return cachedCliVersion;
+            }
+        }
+        catch {
+            // ignore parse/read errors
+        }
     }
+    cachedCliVersion = 'unknown';
+    return cachedCliVersion;
 }
 function computePlanCacheKey(input) {
-    const safeIntent = (0, secret_masking_1.maskSecretsInText)(input.intent).masked;
-    // Use an explicit, stable string rather than JSON.stringify of arbitrary objects.
     const payload = [
         `v=${input.schemaVersion}`,
-        `apiUrl=${input.apiUrl}`,
         `orgId=${input.orgId}`,
         `projectId=${input.projectId}`,
-        `intent=${safeIntent}`,
-        `ticketRef=${input.ticketRef || ''}`,
-        `contextHash=${input.contextHash || ''}`,
-        `repo.kind=${input.repo.kind}`,
+        `repoIdentity=${input.repo.repoIdentity}`,
+        `repoKind=${input.repo.kind}`,
         input.repo.kind === 'git'
-            ? `repo.headSha=${input.repo.headSha};repo.headTreeSha=${input.repo.headTreeSha};repo.statusHash=${input.repo.statusHash}`
-            : `repo.fileTreeHash=${input.repo.fileTreeHash}`,
+            ? [
+                `headSha=${input.repo.headSha}`,
+                `headTreeSha=${input.repo.headTreeSha}`,
+                `workingTreeHash=${input.repo.workingTreeHash}`,
+            ].join(';')
+            : `fileTreeHash=${input.repo.fileTreeHash}`,
+        `promptHash=${input.promptHash}`,
+        `policyVersionHash=${input.policyVersionHash}`,
+        `neurcodeVersion=${input.neurcodeVersion}`,
     ].join('\n');
     return sha256Hex(payload);
 }
-function getGitRepoFingerprint(cwd) {
+function getBrainDbPath(cwd) {
+    return (0, path_1.join)(cwd, '.neurcode', BRAIN_DB_FILE_NAME);
+}
+function getBrainPointerPath(cwd) {
+    return (0, path_1.join)(cwd, '.neurcode', BRAIN_POINTER_FILE_NAME);
+}
+function getFallbackCachePath(cwd) {
+    return (0, path_1.join)(cwd, '.neurcode', FALLBACK_CACHE_FILE_NAME);
+}
+function getBrainFallbackCachePath(cwd) {
+    return getFallbackCachePath(cwd);
+}
+// Backward-compatible helper name retained for callers.
+function getPlanCachePath(cwd) {
+    return getBrainDbPath(cwd);
+}
+function ensureNeurcodeDir(cwd) {
+    const dir = (0, path_1.join)(cwd, '.neurcode');
+    if (!(0, fs_1.existsSync)(dir)) {
+        (0, fs_1.mkdirSync)(dir, { recursive: true });
+    }
+}
+function readFallbackCache(cwd) {
     try {
-        const inside = (0, child_process_1.execSync)('git rev-parse --is-inside-work-tree', { cwd, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] })
-            .trim()
-            .toLowerCase();
-        if (inside !== 'true')
+        const path = getFallbackCachePath(cwd);
+        if (!(0, fs_1.existsSync)(path)) {
+            return { schemaVersion: CACHE_SCHEMA_VERSION, entries: {} };
+        }
+        const raw = (0, fs_1.readFileSync)(path, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (parsed.schemaVersion !== CACHE_SCHEMA_VERSION || !parsed.entries || typeof parsed.entries !== 'object') {
+            throw new Error('Invalid fallback cache schema');
+        }
+        return parsed;
+    }
+    catch {
+        return { schemaVersion: CACHE_SCHEMA_VERSION, entries: {} };
+    }
+}
+function writeFallbackCache(cwd, cache) {
+    try {
+        ensureNeurcodeDir(cwd);
+        const path = getFallbackCachePath(cwd);
+        const tmp = `${path}.tmp`;
+        (0, fs_1.writeFileSync)(tmp, JSON.stringify(cache, null, 2) + '\n', 'utf-8');
+        (0, fs_1.renameSync)(tmp, path);
+    }
+    catch {
+        // ignore
+    }
+}
+function pruneFallback(cache) {
+    const entries = Object.values(cache.entries);
+    if (entries.length <= MAX_ENTRIES)
+        return;
+    entries.sort((a, b) => {
+        const aTime = Date.parse(a.lastUsedAt) || 0;
+        const bTime = Date.parse(b.lastUsedAt) || 0;
+        return aTime - bTime;
+    });
+    const toDelete = entries.slice(0, Math.max(0, entries.length - MAX_ENTRIES));
+    for (const entry of toDelete) {
+        delete cache.entries[entry.key];
+    }
+}
+function readJsonSafe(path) {
+    try {
+        if (!(0, fs_1.existsSync)(path))
             return null;
-        const headSha = (0, child_process_1.execSync)('git rev-parse HEAD', { cwd, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
-        const headTreeSha = (0, child_process_1.execSync)('git rev-parse HEAD^{tree}', { cwd, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
-        const status = (0, child_process_1.execSync)('git status --porcelain', { cwd, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] });
-        const statusHash = sha256Hex(status);
-        return { kind: 'git', headSha, headTreeSha, statusHash };
+        const raw = (0, fs_1.readFileSync)(path, 'utf-8');
+        return JSON.parse(raw);
     }
     catch {
         return null;
     }
 }
-function getFilesystemFingerprintFromTree(fileTree) {
-    // Normalize ordering so the hash is stable even if scanning order changes.
-    const normalized = [...fileTree].sort().join('\n');
-    return { kind: 'filesystem', fileTreeHash: sha256Hex(normalized) };
+function writePointer(cwd, pointer) {
+    try {
+        ensureNeurcodeDir(cwd);
+        const pointerPath = getBrainPointerPath(cwd);
+        (0, fs_1.writeFileSync)(pointerPath, JSON.stringify(pointer, null, 2) + '\n', 'utf-8');
+    }
+    catch {
+        // ignore
+    }
+}
+function updatePointer(cwd, patch) {
+    const existing = readJsonSafe(getBrainPointerPath(cwd));
+    const next = {
+        schemaVersion: 1,
+        dbPath: '.neurcode/brain.db',
+        repoIdentity: patch.repoIdentity ?? existing?.repoIdentity,
+        settings: {
+            noCodeStorage: patch.settings?.noCodeStorage ?? existing?.settings?.noCodeStorage ?? false,
+        },
+        updatedAt: new Date().toISOString(),
+    };
+    writePointer(cwd, next);
+}
+function getBrainStorageMode(cwd) {
+    const env = process.env.NEURCODE_BRAIN_NO_CODE_STORAGE;
+    if (typeof env === 'string' && env.trim()) {
+        const normalized = env.trim().toLowerCase();
+        const enabled = normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'on';
+        return { noCodeStorage: enabled, source: 'env' };
+    }
+    const pointer = readJsonSafe(getBrainPointerPath(cwd));
+    if (pointer?.settings && typeof pointer.settings.noCodeStorage === 'boolean') {
+        return { noCodeStorage: pointer.settings.noCodeStorage, source: 'pointer' };
+    }
+    return { noCodeStorage: false, source: 'default' };
+}
+function setNoCodeStorageMode(cwd, enabled) {
+    updatePointer(cwd, { settings: { noCodeStorage: enabled } });
+}
+function isNoCodeStorageMode(cwd) {
+    return getBrainStorageMode(cwd).noCodeStorage;
+}
+function initDbSchema(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS brain_meta (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS plan_cache (
+      key TEXT PRIMARY KEY,
+      created_at TEXT NOT NULL,
+      last_used_at TEXT NOT NULL,
+      use_count INTEGER NOT NULL DEFAULT 1,
+      org_id TEXT NOT NULL,
+      project_id TEXT NOT NULL,
+      repo_kind TEXT NOT NULL,
+      repo_identity TEXT NOT NULL,
+      head_sha TEXT,
+      head_tree_sha TEXT,
+      working_tree_hash TEXT,
+      file_tree_hash TEXT,
+      prompt_hash TEXT NOT NULL,
+      policy_version_hash TEXT NOT NULL,
+      neurcode_version TEXT NOT NULL,
+      intent_norm TEXT NOT NULL,
+      intent_hash TEXT NOT NULL,
+      ticket_ref TEXT,
+      context_hash TEXT,
+      response_json TEXT NOT NULL,
+      no_code_storage INTEGER NOT NULL DEFAULT 0
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_plan_cache_scope ON plan_cache(org_id, project_id);
+    CREATE INDEX IF NOT EXISTS idx_plan_cache_lru ON plan_cache(last_used_at);
+    CREATE INDEX IF NOT EXISTS idx_plan_cache_repo ON plan_cache(repo_identity);
+  `);
+}
+function getMeta(db, key) {
+    try {
+        const row = db.prepare('SELECT value FROM brain_meta WHERE key = ?').get(key);
+        return row?.value || null;
+    }
+    catch {
+        return null;
+    }
+}
+function setMeta(db, key, value) {
+    try {
+        db.prepare(`
+      INSERT INTO brain_meta (key, value) VALUES (?, ?)
+      ON CONFLICT(key) DO UPDATE SET value = excluded.value
+    `).run(key, value);
+    }
+    catch {
+        // ignore
+    }
+}
+function sanitizeCachedResponseForStorage(response, noCodeStorage) {
+    if (!noCodeStorage) {
+        return response;
+    }
+    const summaryMasked = (0, secret_masking_1.maskSecretsInText)(response.plan.summary || '').masked;
+    const summaryHash = sha256Hex(summaryMasked);
+    const files = (response.plan.files || []).slice(0, 80).map((file) => ({
+        path: file.path,
+        action: file.action,
+        reason: [
+            file.reason ? `reasonHash=${sha256Hex((0, secret_masking_1.maskSecretsInText)(file.reason).masked)}` : null,
+            file.suggestion ? `suggestionHash=${sha256Hex((0, secret_masking_1.maskSecretsInText)(file.suggestion).masked)}` : null,
+        ].filter(Boolean).join(' | ') || undefined,
+        suggestion: undefined,
+    }));
+    const recommendations = (response.plan.recommendations || []).slice(0, 20).map((r) => {
+        const masked = (0, secret_masking_1.maskSecretsInText)(r).masked;
+        return `recHash=${sha256Hex(masked)}`;
+    });
+    return {
+        ...response,
+        plan: {
+            ...response.plan,
+            summary: `no-code-storage summaryHash=${summaryHash} files=${response.plan.files?.length || 0} recommendations=${response.plan.recommendations?.length || 0}`,
+            files,
+            recommendations,
+        },
+    };
+}
+function migrateLegacyJsonCache(cwd, db) {
+    const migrationKey = 'legacy_plan_cache_migrated_v1';
+    if (getMeta(db, migrationKey) === '1')
+        return;
+    const legacyPath = (0, path_1.join)(cwd, '.neurcode', LEGACY_CACHE_FILE_NAME);
+    if (!(0, fs_1.existsSync)(legacyPath)) {
+        setMeta(db, migrationKey, '1');
+        return;
+    }
+    try {
+        const raw = (0, fs_1.readFileSync)(legacyPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        const entries = parsed?.entries && typeof parsed.entries === 'object' ? Object.values(parsed.entries) : [];
+        const insertStmt = db.prepare(`
+      INSERT OR IGNORE INTO plan_cache (
+        key,
+        created_at,
+        last_used_at,
+        use_count,
+        org_id,
+        project_id,
+        repo_kind,
+        repo_identity,
+        head_sha,
+        head_tree_sha,
+        working_tree_hash,
+        file_tree_hash,
+        prompt_hash,
+        policy_version_hash,
+        neurcode_version,
+        intent_norm,
+        intent_hash,
+        ticket_ref,
+        context_hash,
+        response_json,
+        no_code_storage
+      ) VALUES (
+        @key,
+        @created_at,
+        @last_used_at,
+        @use_count,
+        @org_id,
+        @project_id,
+        @repo_kind,
+        @repo_identity,
+        @head_sha,
+        @head_tree_sha,
+        @working_tree_hash,
+        @file_tree_hash,
+        @prompt_hash,
+        @policy_version_hash,
+        @neurcode_version,
+        @intent_norm,
+        @intent_hash,
+        @ticket_ref,
+        @context_hash,
+        @response_json,
+        @no_code_storage
+      )
+    `);
+        for (const item of entries) {
+            const legacy = item;
+            const input = legacy?.input || {};
+            const response = legacy?.response || null;
+            if (!legacy?.key || !input?.orgId || !input?.projectId || !response)
+                continue;
+            const intentNorm = normalizeIntent(String(input.intent || ''));
+            const intentHash = sha256Hex(intentNorm);
+            const repoIdentity = getRepoIdentity(cwd);
+            const repoKind = input.repo?.kind === 'git' ? 'git' : 'filesystem';
+            const promptHash = computePromptHash({
+                intent: intentNorm,
+                ticketRef: input.ticketRef,
+                contextHash: input.contextHash,
+            });
+            insertStmt.run({
+                key: String(legacy.key),
+                created_at: String(legacy.createdAt || new Date().toISOString()),
+                last_used_at: String(legacy.lastUsedAt || legacy.createdAt || new Date().toISOString()),
+                use_count: Number(legacy.useCount || 1),
+                org_id: String(input.orgId),
+                project_id: String(input.projectId),
+                repo_kind: repoKind,
+                repo_identity: repoIdentity,
+                head_sha: repoKind === 'git' ? String(input.repo?.headSha || '') || null : null,
+                head_tree_sha: repoKind === 'git' ? String(input.repo?.headTreeSha || '') || null : null,
+                working_tree_hash: repoKind === 'git' ? String(input.repo?.statusHash || '') || null : null,
+                file_tree_hash: repoKind === 'filesystem' ? String(input.repo?.fileTreeHash || '') || null : null,
+                prompt_hash: promptHash,
+                policy_version_hash: 'legacy',
+                neurcode_version: 'legacy',
+                intent_norm: intentNorm,
+                intent_hash: intentHash,
+                ticket_ref: input.ticketRef ? String(input.ticketRef) : null,
+                context_hash: input.contextHash ? String(input.contextHash) : null,
+                response_json: JSON.stringify(response),
+                no_code_storage: 0,
+            });
+        }
+        try {
+            (0, fs_1.renameSync)(legacyPath, legacyPath.replace(/\.json$/, `.migrated-${Date.now()}.json`));
+        }
+        catch {
+            // ignore rename failures
+        }
+    }
+    catch {
+        // ignore invalid legacy cache
+    }
+    setMeta(db, migrationKey, '1');
+}
+function getDb(cwd) {
+    const dbPath = getBrainDbPath(cwd);
+    const existing = dbConnections.get(dbPath);
+    if (existing)
+        return existing;
+    const Ctor = getSqliteCtor();
+    if (!Ctor)
+        return null;
+    try {
+        ensureNeurcodeDir(cwd);
+        const db = new Ctor(dbPath);
+        db.pragma('journal_mode = WAL');
+        db.pragma('synchronous = NORMAL');
+        initDbSchema(db);
+        migrateLegacyJsonCache(cwd, db);
+        dbConnections.set(dbPath, db);
+        return db;
+    }
+    catch {
+        return null;
+    }
+}
+function prune(db) {
+    try {
+        const row = db.prepare('SELECT COUNT(*) as count FROM plan_cache').get();
+        const total = Number(row?.count || 0);
+        if (total <= MAX_ENTRIES)
+            return;
+        const toDelete = total - MAX_ENTRIES;
+        db.prepare(`
+      DELETE FROM plan_cache
+      WHERE key IN (
+        SELECT key
+        FROM plan_cache
+        ORDER BY last_used_at ASC
+        LIMIT ?
+      )
+    `).run(toDelete);
+    }
+    catch {
+        // ignore
+    }
+}
+function toEntry(row) {
+    if (!row)
+        return null;
+    try {
+        const response = JSON.parse(row.response_json);
+        const repo = row.repo_kind === 'git'
+            ? {
+                kind: 'git',
+                repoIdentity: row.repo_identity,
+                headSha: row.head_sha || '',
+                headTreeSha: row.head_tree_sha || '',
+                workingTreeHash: row.working_tree_hash || '',
+            }
+            : {
+                kind: 'filesystem',
+                repoIdentity: row.repo_identity,
+                fileTreeHash: row.file_tree_hash || '',
+            };
+        return {
+            key: row.key,
+            createdAt: row.created_at,
+            lastUsedAt: row.last_used_at,
+            useCount: Number(row.use_count || 0),
+            input: {
+                schemaVersion: CACHE_SCHEMA_VERSION,
+                orgId: row.org_id,
+                projectId: row.project_id,
+                repo,
+                promptHash: row.prompt_hash,
+                policyVersionHash: row.policy_version_hash,
+                neurcodeVersion: row.neurcode_version,
+                intent: row.intent_norm || '',
+                intentHash: row.intent_hash,
+                ticketRef: row.ticket_ref || undefined,
+                contextHash: row.context_hash || undefined,
+            },
+            response,
+        };
+    }
+    catch {
+        return null;
+    }
 }
 function readCachedPlan(cwd, key) {
     try {
-        const cachePath = getPlanCachePath(cwd);
-        const cache = safeReadCacheFile(cachePath);
-        const entry = cache.entries[key];
-        if (!entry)
+        const db = getDb(cwd);
+        if (!db) {
+            const cache = readFallbackCache(cwd);
+            const existing = cache.entries[key];
+            if (!existing)
+                return null;
+            const now = new Date().toISOString();
+            const next = {
+                ...existing,
+                lastUsedAt: now,
+                useCount: Number(existing.useCount || 0) + 1,
+            };
+            cache.entries[key] = next;
+            pruneFallback(cache);
+            writeFallbackCache(cwd, cache);
+            return next;
+        }
+        const row = db.prepare('SELECT * FROM plan_cache WHERE key = ?').get(key);
+        if (!row)
             return null;
-        // Update LRU metadata.
         const now = new Date().toISOString();
-        entry.lastUsedAt = now;
-        entry.useCount = (entry.useCount || 0) + 1;
-        cache.entries[key] = entry;
-        prune(cache);
-        atomicWrite(cachePath, JSON.stringify(cache, null, 2) + '\n');
-        return entry;
+        db.prepare(`
+      UPDATE plan_cache
+      SET last_used_at = ?, use_count = use_count + 1
+      WHERE key = ?
+    `).run(now, key);
+        row.last_used_at = now;
+        row.use_count = Number(row.use_count || 0) + 1;
+        return toEntry(row);
+    }
+    catch {
+        return null;
+    }
+}
+function peekCachedPlan(cwd, key) {
+    try {
+        const db = getDb(cwd);
+        if (!db) {
+            const cache = readFallbackCache(cwd);
+            return cache.entries[key] || null;
+        }
+        const row = db.prepare('SELECT * FROM plan_cache WHERE key = ?').get(key);
+        return toEntry(row);
     }
     catch {
         return null;
@@ -155,32 +732,193 @@ function readCachedPlan(cwd, key) {
 }
 function writeCachedPlan(cwd, entry) {
     try {
-        ensureNeurcodeDir(cwd);
-        const cachePath = getPlanCachePath(cwd);
-        const cache = safeReadCacheFile(cachePath);
         const now = new Date().toISOString();
-        const existing = cache.entries[entry.key];
-        const next = {
-            ...entry,
-            createdAt: existing?.createdAt || now,
-            lastUsedAt: now,
-            useCount: (existing?.useCount || 0) + 1,
-        };
-        // Best-effort: do not persist secrets in the on-disk cache.
-        try {
-            if (next.input?.intent) {
-                next.input.intent = (0, secret_masking_1.maskSecretsInText)(next.input.intent).masked;
+        const noCodeStorage = isNoCodeStorageMode(cwd);
+        const normalizedIntent = normalizeIntent(entry.input.intent || '');
+        const safeIntent = (0, secret_masking_1.maskSecretsInText)(normalizedIntent).masked;
+        const intentForStorage = noCodeStorage ? '' : safeIntent;
+        const intentHash = sha256Hex(safeIntent);
+        const responseToStore = sanitizeCachedResponseForStorage(entry.response, noCodeStorage);
+        const repo = entry.input.repo;
+        const repoIdentity = repo.repoIdentity || fallbackRepoIdentity(cwd);
+        const db = getDb(cwd);
+        if (!db) {
+            const cache = readFallbackCache(cwd);
+            const existing = cache.entries[entry.key];
+            const next = {
+                key: entry.key,
+                createdAt: existing?.createdAt || now,
+                lastUsedAt: now,
+                useCount: Number(existing?.useCount || 0) + 1,
+                input: {
+                    ...entry.input,
+                    schemaVersion: CACHE_SCHEMA_VERSION,
+                    repo: {
+                        ...repo,
+                        repoIdentity,
+                    },
+                    intent: intentForStorage,
+                    intentHash,
+                    ticketRef: entry.input.ticketRef,
+                    contextHash: entry.input.contextHash,
+                },
+                response: responseToStore,
+            };
+            cache.entries[entry.key] = next;
+            pruneFallback(cache);
+            writeFallbackCache(cwd, cache);
+            updatePointer(cwd, {
+                repoIdentity,
+                settings: { noCodeStorage },
+            });
+            return;
+        }
+        db.prepare(`
+      INSERT INTO plan_cache (
+        key,
+        created_at,
+        last_used_at,
+        use_count,
+        org_id,
+        project_id,
+        repo_kind,
+        repo_identity,
+        head_sha,
+        head_tree_sha,
+        working_tree_hash,
+        file_tree_hash,
+        prompt_hash,
+        policy_version_hash,
+        neurcode_version,
+        intent_norm,
+        intent_hash,
+        ticket_ref,
+        context_hash,
+        response_json,
+        no_code_storage
+      ) VALUES (
+        @key,
+        @created_at,
+        @last_used_at,
+        1,
+        @org_id,
+        @project_id,
+        @repo_kind,
+        @repo_identity,
+        @head_sha,
+        @head_tree_sha,
+        @working_tree_hash,
+        @file_tree_hash,
+        @prompt_hash,
+        @policy_version_hash,
+        @neurcode_version,
+        @intent_norm,
+        @intent_hash,
+        @ticket_ref,
+        @context_hash,
+        @response_json,
+        @no_code_storage
+      )
+      ON CONFLICT(key) DO UPDATE SET
+        last_used_at = excluded.last_used_at,
+        use_count = plan_cache.use_count + 1,
+        org_id = excluded.org_id,
+        project_id = excluded.project_id,
+        repo_kind = excluded.repo_kind,
+        repo_identity = excluded.repo_identity,
+        head_sha = excluded.head_sha,
+        head_tree_sha = excluded.head_tree_sha,
+        working_tree_hash = excluded.working_tree_hash,
+        file_tree_hash = excluded.file_tree_hash,
+        prompt_hash = excluded.prompt_hash,
+        policy_version_hash = excluded.policy_version_hash,
+        neurcode_version = excluded.neurcode_version,
+        intent_norm = excluded.intent_norm,
+        intent_hash = excluded.intent_hash,
+        ticket_ref = excluded.ticket_ref,
+        context_hash = excluded.context_hash,
+        response_json = excluded.response_json,
+        no_code_storage = excluded.no_code_storage
+    `).run({
+            key: entry.key,
+            created_at: now,
+            last_used_at: now,
+            org_id: entry.input.orgId,
+            project_id: entry.input.projectId,
+            repo_kind: repo.kind,
+            repo_identity: repoIdentity,
+            head_sha: repo.kind === 'git' ? repo.headSha : null,
+            head_tree_sha: repo.kind === 'git' ? repo.headTreeSha : null,
+            working_tree_hash: repo.kind === 'git' ? repo.workingTreeHash : null,
+            file_tree_hash: repo.kind === 'filesystem' ? repo.fileTreeHash : null,
+            prompt_hash: entry.input.promptHash,
+            policy_version_hash: entry.input.policyVersionHash,
+            neurcode_version: entry.input.neurcodeVersion,
+            intent_norm: intentForStorage,
+            intent_hash: intentHash,
+            ticket_ref: entry.input.ticketRef || null,
+            context_hash: entry.input.contextHash || null,
+            response_json: JSON.stringify(responseToStore),
+            no_code_storage: noCodeStorage ? 1 : 0,
+        });
+        prune(db);
+        updatePointer(cwd, {
+            repoIdentity,
+            settings: { noCodeStorage },
+        });
+    }
+    catch {
+        // Cache failures should never block plan generation.
+    }
+}
+function listCachedPlans(cwd) {
+    try {
+        const db = getDb(cwd);
+        if (!db) {
+            const cache = readFallbackCache(cwd);
+            return Object.values(cache.entries).sort((a, b) => {
+                const aTime = Date.parse(a.lastUsedAt) || 0;
+                const bTime = Date.parse(b.lastUsedAt) || 0;
+                return bTime - aTime;
+            });
+        }
+        const rows = db.prepare('SELECT * FROM plan_cache ORDER BY last_used_at DESC').all();
+        return rows.map((row) => toEntry(row)).filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+function deleteCachedPlans(cwd, shouldDelete) {
+    try {
+        const db = getDb(cwd);
+        if (!db) {
+            const cache = readFallbackCache(cwd);
+            let deleted = 0;
+            for (const [key, entry] of Object.entries(cache.entries)) {
+                if (!entry)
+                    continue;
+                if (shouldDelete(entry)) {
+                    delete cache.entries[key];
+                    deleted++;
+                }
             }
+            pruneFallback(cache);
+            writeFallbackCache(cwd, cache);
+            return { deleted, remaining: Object.keys(cache.entries).length };
         }
-        catch {
-            // ignore
+        const rows = db.prepare('SELECT * FROM plan_cache').all();
+        const entries = rows.map((row) => toEntry(row)).filter(Boolean);
+        const keysToDelete = entries.filter((entry) => shouldDelete(entry)).map((entry) => entry.key);
+        const stmt = db.prepare('DELETE FROM plan_cache WHERE key = ?');
+        for (const key of keysToDelete) {
+            stmt.run(key);
         }
-        cache.entries[entry.key] = next;
-        prune(cache);
-        atomicWrite(cachePath, JSON.stringify(cache, null, 2) + '\n');
+        const remainingRow = db.prepare('SELECT COUNT(*) as count FROM plan_cache').get();
+        return { deleted: keysToDelete.length, remaining: Number(remainingRow?.count || 0) };
     }
     catch {
-        // Cache failures should never block plan generation.
+        return { deleted: 0, remaining: 0 };
     }
 }
 function tokenize(text) {
@@ -194,8 +932,8 @@ function jaccard(a, b) {
     if (a.size === 0 || b.size === 0)
         return 0;
     let inter = 0;
-    for (const x of a) {
-        if (b.has(x))
+    for (const token of a) {
+        if (b.has(token))
             inter++;
     }
     const union = a.size + b.size - inter;
@@ -203,25 +941,112 @@ function jaccard(a, b) {
 }
 function findSimilarCachedPlans(cwd, filter, intent, k = 3) {
     try {
-        const cachePath = getPlanCachePath(cwd);
-        const cache = safeReadCacheFile(cachePath);
-        const entries = Object.values(cache.entries);
-        const queryTokens = new Set(tokenize(intent));
-        const scored = entries
-            .filter((e) => e.input.orgId === filter.orgId && e.input.projectId === filter.projectId)
-            .map((e) => {
-            const eTokens = new Set(tokenize(e.input.intent));
-            const score = jaccard(queryTokens, eTokens);
-            return { entry: e, score };
+        const db = getDb(cwd);
+        const normalizedIntent = normalizeIntent(intent);
+        const queryTokens = new Set(tokenize(normalizedIntent));
+        if (queryTokens.size === 0)
+            return [];
+        if (!db) {
+            const cache = readFallbackCache(cwd);
+            const entries = Object.values(cache.entries)
+                .filter((entry) => entry.input.orgId === filter.orgId && entry.input.projectId === filter.projectId)
+                .filter((entry) => !filter.repoIdentity || entry.input.repo.repoIdentity === filter.repoIdentity)
+                .filter((entry) => Boolean(entry.input.intent));
+            const scored = entries
+                .map((entry) => {
+                const tokens = new Set(tokenize(entry.input.intent || ''));
+                const score = jaccard(queryTokens, tokens);
+                if (score <= 0)
+                    return null;
+                return { entry, score };
+            })
+                .filter(Boolean);
+            return scored
+                .sort((a, b) => b.score - a.score)
+                .slice(0, k)
+                .map((x) => x.entry);
+        }
+        const rows = filter.repoIdentity
+            ? db.prepare(`
+          SELECT *
+          FROM plan_cache
+          WHERE org_id = ? AND project_id = ? AND repo_identity = ? AND intent_norm <> ''
+          ORDER BY last_used_at DESC
+          LIMIT 120
+        `).all(filter.orgId, filter.projectId, filter.repoIdentity)
+            : db.prepare(`
+          SELECT *
+          FROM plan_cache
+          WHERE org_id = ? AND project_id = ? AND intent_norm <> ''
+          ORDER BY last_used_at DESC
+          LIMIT 120
+        `).all(filter.orgId, filter.projectId);
+        const scored = rows
+            .map((row) => {
+            const entry = toEntry(row);
+            if (!entry)
+                return null;
+            if (!entry.input.intent)
+                return null;
+            const tokens = new Set(tokenize(entry.input.intent));
+            const score = jaccard(queryTokens, tokens);
+            if (score <= 0)
+                return null;
+            return { entry, score };
         })
-            .filter((s) => s.score > 0)
+            .filter(Boolean);
+        return scored
             .sort((a, b) => b.score - a.score)
             .slice(0, k)
-            .map((s) => s.entry);
-        return scored;
+            .map((x) => x.entry);
     }
     catch {
         return [];
     }
 }
+function getBrainDbSizeBytes(cwd) {
+    try {
+        const dbPath = getBrainDbPath(cwd);
+        if (!(0, fs_1.existsSync)(dbPath))
+            return null;
+        return (0, fs_1.statSync)(dbPath).size;
+    }
+    catch {
+        return null;
+    }
+}
+function getBrainStoreBackend(cwd) {
+    const db = getDb(cwd);
+    return db ? 'sqlite' : 'json-fallback';
+}
+function closeBrainStore(cwd) {
+    try {
+        if (cwd) {
+            const dbPath = getBrainDbPath(cwd);
+            const db = dbConnections.get(dbPath);
+            if (db) {
+                try {
+                    db.close();
+                }
+                catch {
+                    // ignore
+                }
+                dbConnections.delete(dbPath);
+            }
+            return;
+        }
+        for (const [dbPath, db] of dbConnections.entries()) {
+            try {
+                db.close();
+            }
+            catch {
+                // ignore
+            }
+            dbConnections.delete(dbPath);
+        }
+    }
+    catch {
+        // ignore
+    }
+}
 //# sourceMappingURL=plan-cache.js.map