minovative-mind-cli 2.3.3 → 2.5.0

package/dist/services/orchestration/investigationCache.js

@@ -0,0 +1,135 @@
+import { promises as fs, statSync } from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { readCache, writeCache } from '../../utils/projectStorage.js';
+import { debugLog } from '../../utils/logger.js';
+const CACHE_FILE = 'investigation_cache.json';
+const MAX_CACHE_SIZE_BYTES = 5 * 1024 * 1024; // 5MB
+export function normalizePrompt(prompt) {
+    let normalized = prompt.toLowerCase().trim();
+    normalized = normalized.replace(/\s+/g, ' ');
+    const fillerWords = ['please ', 'can you ', 'could you ', 'help me ', 'i need '];
+    for (const word of fillerWords) {
+        if (normalized.startsWith(word)) {
+            normalized = normalized.slice(word.length).trim();
+        }
+    }
+    return normalized;
+}
+export function hashPrompt(normalized) {
+    return crypto.createHash('sha256').update(normalized).digest('hex');
+}
+export async function generateWorkspaceFingerprint(workspaceRoot, relevantFiles) {
+    const fileStats = [];
+    for (const file of relevantFiles) {
+        try {
+            const fullPath = path.join(workspaceRoot, file);
+            const stat = await fs.stat(fullPath);
+            // Use mtimeMs and size for a robust fingerprint
+            fileStats.push(`${file}:${stat.mtimeMs}:${stat.size}`);
+        }
+        catch (e) {
+            if (e.code === 'ENOENT') {
+                fileStats.push(`${file}:deleted`);
+            }
+            else if (e.code === 'EACCES' || e.code === 'EPERM') {
+                // Handle permission issues by marking as changed to force re-evaluation
+                fileStats.push(`${file}:inaccessible`);
+            }
+            else {
+                // For other errors, assume it's changed
+                fileStats.push(`${file}:error`);
+            }
+        }
+    }
+    fileStats.sort();
+    return crypto.createHash('sha256').update(fileStats.join('\n')).digest('hex');
+}
+export async function lookupInvestigation(workspaceRoot, userPrompt) {
+    const normalized = normalizePrompt(userPrompt);
+    const hash = hashPrompt(normalized);
+    const store = readCache(workspaceRoot, CACHE_FILE);
+    if (!store || !store.entries || !store.entries[hash]) {
+        return null;
+    }
+    const entry = store.entries[hash];
+    const currentFingerprint = await generateWorkspaceFingerprint(workspaceRoot, entry.relevantFiles);
+    if (entry.workspaceFingerprint !== currentFingerprint) {
+        debugLog(`Investigation cache: relevant files modified, invalidating cache entry`);
+        delete store.entries[hash];
+        writeCache(workspaceRoot, CACHE_FILE, store);
+        return null;
+    }
+    debugLog(`Investigation cache: HIT for hash ${hash}`);
+    const bytesSaved = JSON.stringify(entry).length;
+    return { entry, bytesSaved };
+}
+export async function saveInvestigation(workspaceRoot, userPrompt, relevantFiles, summary) {
+    const store = readCache(workspaceRoot, CACHE_FILE) || { entries: {} };
+    const normalized = normalizePrompt(userPrompt);
+    const hash = hashPrompt(normalized);
+    const fingerprint = await generateWorkspaceFingerprint(workspaceRoot, relevantFiles);
+    store.entries[hash] = {
+        promptHash: hash,
+        relevantFiles,
+        summary,
+        workspaceFingerprint: fingerprint,
+        createdAt: Date.now(),
+    };
+    // Enforce 5MB LRU limit
+    let storeJson = JSON.stringify(store);
+    while (Buffer.byteLength(storeJson, 'utf8') > MAX_CACHE_SIZE_BYTES) {
+        const keys = Object.keys(store.entries);
+        if (keys.length === 0)
+            break;
+        let oldestKey = keys[0];
+        let oldestTime = store.entries[oldestKey].createdAt;
+        for (let i = 1; i < keys.length; i++) {
+            if (store.entries[keys[i]].createdAt < oldestTime) {
+                oldestKey = keys[i];
+                oldestTime = store.entries[keys[i]].createdAt;
+            }
+        }
+        delete store.entries[oldestKey];
+        storeJson = JSON.stringify(store);
+    }
+    writeCache(workspaceRoot, CACHE_FILE, store);
+    debugLog(`💾 Investigation cached for future reuse`);
+}
+export async function invalidateFilesFromInvestigationCache(workspaceRoot, changedFiles) {
+    const store = readCache(workspaceRoot, CACHE_FILE);
+    if (!store || !store.entries)
+        return;
+    let invalidated = 0;
+    for (const hash of Object.keys(store.entries)) {
+        const entry = store.entries[hash];
+        const dependsOnChange = entry.relevantFiles.some((f) => changedFiles.includes(f));
+        if (dependsOnChange) {
+            delete store.entries[hash];
+            invalidated++;
+        }
+    }
+    if (invalidated > 0) {
+        writeCache(workspaceRoot, CACHE_FILE, store);
+        debugLog(`[DEBUG] Investigation cache: invalidated ${invalidated} entries referencing changed files`);
+    }
+}
+export function getInvestigationCacheStats(workspaceRoot) {
+    const store = readCache(workspaceRoot, CACHE_FILE);
+    const entriesCount = store?.entries ? Object.keys(store.entries).length : 0;
+    let sizeBytes = 0;
+    try {
+        const cachePath = path.join(workspaceRoot, '.minovativemind', CACHE_FILE);
+        const stat = statSync(cachePath);
+        sizeBytes = stat.size;
+    }
+    catch (e) {
+        // ignore
+    }
+    return {
+        entries: entriesCount,
+        sizeBytes,
+        hitCount: 0,
+        missCount: 0,
+    };
+}

package/dist/services/orchestration/investigationOrchestrator.js

@@ -27,7 +27,7 @@ import { buildDependencyGraph } from '../../utils/dependencyTracer.js';
 import { debugLog } from '../../utils/logger.js';
 // ─── Constants ───────────────────────────────────────────────────────
 /** Maximum total relevant files across all agents after merge. */
-const MAX_TOTAL_FILES = 15;
+const MAX_TOTAL_FILES = 30;
 // ─── Investigation Orchestrator ──────────────────────────────────────
 export class InvestigationOrchestrator {
     /**
@@ -106,6 +106,10 @@ export class InvestigationOrchestrator {
             `Files: ${mergedResult.relevantFiles.size} (deduped from ${totalFilesBeforeDedup}) | ` +
             `Cache hits: ${cacheStats.hitCount}\n` +
             `  Duration: ${duration}s | Tokens: ${totalTokens.toLocaleString()} ${pc.dim(`(Input: ${totalInputTokens.toLocaleString()}, Output: ${totalOutputTokens.toLocaleString()})`)}`);
+        if (mergedResult && mergedResult.relevantFiles.size > 0) {
+            const { saveInvestigation } = await import('./investigationCache.js');
+            await saveInvestigation(workspaceRoot, userRequest, Array.from(mergedResult.relevantFiles.keys()), mergedResult.summary);
+        }
         return mergedResult;
     }
     /**

package/dist/services/orchestration/messageBus.d.ts

@@ -86,7 +86,7 @@ export declare class MessageBus {
     private readonly persistPath;
     private readonly workspaceRoot;
     /** Maximum semantic signals any single agent can post */
-    static readonly MAX_SIGNALS_PER_AGENT = 20;
+    static readonly MAX_SIGNALS_PER_AGENT = 50;
     constructor(workspaceRoot: string, conversationId: string);
     /**
      * Records a tool execution into the activity log. Called by the scoped tool

package/dist/services/orchestration/messageBus.js

@@ -38,7 +38,7 @@ export class MessageBus {
     persistPath;
     workspaceRoot;
     /** Maximum semantic signals any single agent can post */
-    static MAX_SIGNALS_PER_AGENT = 20;
+    static MAX_SIGNALS_PER_AGENT = 50;
     constructor(workspaceRoot, conversationId) {
         this.workspaceRoot = workspaceRoot;
         const orchestrationDir = path.join(workspaceRoot, '.minovativemind', 'orchestration');
@@ -64,7 +64,7 @@ export class MessageBus {
      * @returns `true` if the signal was accepted, `false` if the agent hit the cap.
      */
     postSignal(signal) {
-        const agentSignalCount = this.signals.filter(s => s.fromAgent === signal.fromAgent).length;
+        const agentSignalCount = this.signals.filter((s) => s.fromAgent === signal.fromAgent).length;
         if (agentSignalCount >= MessageBus.MAX_SIGNALS_PER_AGENT) {
             debugLog(`MessageBus: Agent ${signal.fromAgent} hit signal cap (${MessageBus.MAX_SIGNALS_PER_AGENT}). ` +
                 `Dropping signal of type "${signal.type}".`);
@@ -85,12 +85,8 @@ export class MessageBus {
     getUnread(agentId) {
         const actCursor = this.activityCursors.get(agentId) ?? 0;
         const sigCursor = this.signalCursors.get(agentId) ?? 0;
-        const activities = this.activityLog
-            .slice(actCursor)
-            .filter(e => e.agentId !== agentId);
-        const signals = this.signals
-            .slice(sigCursor)
-            .filter(s => s.fromAgent !== agentId);
+        const activities = this.activityLog.slice(actCursor).filter((e) => e.agentId !== agentId);
+        const signals = this.signals.slice(sigCursor).filter((s) => s.fromAgent !== agentId);
         // Advance cursors to current end
         this.activityCursors.set(agentId, this.activityLog.length);
         this.signalCursors.set(agentId, this.signals.length);
@@ -111,7 +107,7 @@ export class MessageBus {
      * recovery — collecting partial progress before re-dispatch).
      */
     getAgentActivity(agentId) {
-        return this.activityLog.filter(e => e.agentId === agentId);
+        return this.activityLog.filter((e) => e.agentId === agentId);
     }
     /**
      * Returns the total number of activity entries and signals in the bus.
@@ -131,11 +127,13 @@ export class MessageBus {
     static formatActivityEntries(entries) {
         if (entries.length === 0)
             return '';
-        return entries.map(e => {
+        return entries
+            .map((e) => {
             const statusIcon = e.status === 'success' ? '✓' : '✗';
             const summary = e.resultSummary ? ` | ${e.resultSummary}` : '';
             return `  ${e.agentId} | ${e.tool.padEnd(14)} → ${e.target.padEnd(40)} | ${statusIcon} ${e.action}${summary}`;
-        }).join('\n');
+        })
+            .join('\n');
     }
     /**
      * Formats semantic signals into a readable string for agent context injection.
@@ -143,7 +141,8 @@ export class MessageBus {
     static formatSignals(signals) {
         if (signals.length === 0)
             return '';
-        return signals.map(s => {
+        return signals
+            .map((s) => {
             const tag = s.type.toUpperCase();
             switch (s.type) {
                 case 'discovery':
@@ -157,7 +156,8 @@ export class MessageBus {
                 default:
                     return `  [SIGNAL from ${s.fromAgent}]: ${JSON.stringify(s)}`;
             }
-        }).join('\n');
+        })
+            .join('\n');
     }
     // ─── Persistence ─────────────────────────────────────────────────
     /**
@@ -173,7 +173,7 @@ export class MessageBus {
             signalCursors: Object.fromEntries(this.signalCursors),
         };
         // Fire-and-forget — don't block the calling agent's tool loop
-        atomicWriteFile(this.persistPath, JSON.stringify(snapshot)).catch(err => {
+        atomicWriteFile(this.persistPath, JSON.stringify(snapshot)).catch((err) => {
             debugLog(`MessageBus: Failed to persist to disk: ${err}`);
         });
     }

package/dist/services/orchestration/orchestrator.js

@@ -260,7 +260,7 @@ export class Orchestrator {
                 'DO NOT list changes by task name or separate them by agent. ' +
                 'Be concise, helpful, and conclude by asking if they need any further adjustments.\n' +
                 '</directives>';
-            const synthesized = await compressTextUsingFlashLite(payloadWithContext, instruction);
+            const synthesized = await compressTextUsingFlashLite(payloadWithContext, instruction, undefined, true);
             finalSummary += synthesized + '\n\n';
         }
         catch (e) {

package/dist/services/orchestration/readCache.js

@@ -17,6 +17,7 @@
  *   to prevent OOM on very large monorepos.
  */
 import { debugLog } from '../../utils/logger.js';
+import { getMetricCollector } from '../metrics.js';
 // ─── Constants ───────────────────────────────────────────────────────
 /** Maximum total bytes of cached file content before LRU eviction kicks in. */
 const MAX_CACHE_BYTES = 5 * 1024 * 1024; // 5 MB
@@ -45,11 +46,14 @@ export class ReadCache {
      */
     has(filePath) {
         const found = this.cache.has(filePath);
+        const collector = getMetricCollector();
         if (found) {
             this.hitCount++;
+            collector?.recordCacheHit();
         }
         else {
             this.missCount++;
+            collector?.recordCacheMiss();
         }
         return found;
     }

package/dist/services/orchestration/scopedTools.js

@@ -145,7 +145,8 @@ export async function executeScopedTool(name, args, workspaceRoot, agentId, bus,
         else if (name === 'grep_search') {
             targetDesc = args.pattern;
             actionDesc = 'Searched';
-            const matchCount = Array.isArray(result) ? result.length : 0;
+            const outputText = typeof result === 'object' && result?.output ? result.output : String(result || '');
+            const matchCount = (outputText.match(/\.\/[^:]+:\d+:/g) || []).length;
             resultSummary = `${matchCount} matches`;
         }
         return result;

package/dist/services/orchestration/subAgent.js

@@ -63,11 +63,14 @@ export class SubAgentRunner {
             `${this.globalContext}\n` +
             `</reference_context>\n\n` +
             `<critical_guidelines>\n` +
-            `1. You are ONE worker in a team. You MUST ONLY focus on your specific objective: "${this.intent}".\n` +
-            `2. DO NOT attempt to fulfill the entire original user request in the reference context. Other agents are handling the other parts.\n` +
-            `3. You are part of a parallelized system. Use 'post_message' to coordinate if you discover breaking changes.\n` +
-            `4. When you have completed your objective, stop using tools and provide a final summary of your work.\n` +
-            `5. If you encounter an insurmountable error, provide a summary of what went wrong so the orchestrator can re-assign or fix it.\n` +
+            `1. You are ONE worker in a team. Focus EXCLUSIVELY on your specific objective: "${this.intent}".\n` +
+            `2. DO NOT attempt to fulfill the entire original user request in the reference context. Other agents handle other tasks.\n` +
+            `3. EXECUTION WORKFLOW:\n` +
+            `   - Step 1 (Locate): Call 'grep_search' or 'read_file' ONCE to inspect the file you need to edit.\n` +
+            `   - Step 2 (Modify): Call 'modify_file' or 'write_file' to implement the required changes.\n` +
+            `   - Step 3 (Conclude): Immediately STOP using tools and return a text summary of your changes.\n` +
+            `4. Do NOT call 'grep_search' or 'run_command' repeatedly in a loop. Once you have file context or command results, proceed directly to modifying code or responding with your text summary.\n` +
+            `5. Use 'post_message' only if you discover breaking changes affecting other agents.\n` +
             `</critical_guidelines>`);
     }
     /**
@@ -87,12 +90,10 @@ export class SubAgentRunner {
      */
     async execute(signal) {
         return runWithAgentId(this.taskId, async () => {
-            debugLog(`SubAgent [${this.taskId}]: Starting execution.`);
-            this.lastHeartbeat = Date.now();
             let success = false;
             let finalSummary = '';
             let crashed = false;
-            // Health Monitor Timer
+            // Health monitor interval: checks every 5s if the last tool execution/heartbeat stalled
             const healthMonitor = setInterval(() => {
                 if (Date.now() - this.lastHeartbeat > SubAgentRunner.STALL_TIMEOUT_MS) {
                     debugLog(`SubAgent [${this.taskId}]: STALL DETECTED. No heartbeat for ${SubAgentRunner.STALL_TIMEOUT_MS}ms.`);
@@ -103,14 +104,12 @@ export class SubAgentRunner {
             }, 5000);
             try {
                 // Send initial prompt
-                const prompt = `Begin execution for task: ${this.taskId}\nObjective: ${this.intent}\n\nYou must use tools to achieve this objective. Do not stop until the objective is fully complete.`;
+                const prompt = `Begin execution for task: ${this.taskId}\nObjective: ${this.intent}\n\nFollow the 3-step workflow: 1) inspect file -> 2) modify code -> 3) respond with text summary. Do not repeat search tools once results are returned.`;
                 let turnResult = await this.chat.sendMessage(prompt, undefined, signal);
                 this.updateUsage(turnResult);
                 // Tool Loop
                 const MAX_TURNS = Infinity;
                 let turns = 0;
-                // Anti-loop tracking
-                const visitedToolCalls = new Set();
                 while (turns < MAX_TURNS && !crashed && !signal.aborted) {
                     this.pingHeartbeat();
                     const calls = turnResult.response.functionCalls();
@@ -125,21 +124,6 @@ export class SubAgentRunner {
                     for (const call of calls) {
                         if (crashed || signal.aborted)
                             break;
-                        // Anti-loop check: Hash the call to detect exact repetitions
-                        const callSignature = `${call.name}:${JSON.stringify(call.args)}`;
-                        if (visitedToolCalls.has(callSignature)) {
-                            debugLog(`SubAgent [${this.taskId}]: Detected identical tool call ${call.name}. Blocking to prevent loop.`);
-                            toolResponses.push({
-                                functionResponse: {
-                                    name: call.name,
-                                    response: {
-                                        error: 'You have already made this exact tool call previously. Please review your context history or try a different action.',
-                                    },
-                                },
-                            });
-                            continue;
-                        }
-                        visitedToolCalls.add(callSignature);
                         this.pingHeartbeat();
                         if (this.onProgress) {
                             this.onProgress(`executing ${call.name}...`);

package/dist/services/proxyClient.d.ts

@@ -32,6 +32,14 @@ export declare function peekTurnUsage(): {
     remainingBalance: number | undefined;
     modelsUsed: Record<string, number>;
 };
+export declare function accumulateTurnUsage(usage: {
+    promptTokens?: number;
+    candidatesTokens?: number;
+    cachedTokens?: number;
+    promptTokenCount?: number;
+    candidatesTokenCount?: number;
+    cachedContentTokenCount?: number;
+}, modelName: string): void;
 /**
  * Client service interacting directly with the serverless Gemini proxy endpoint.
  * Ensures authorization via Firebase token passing and parses streamed content.

package/dist/services/proxyClient.js

@@ -1,4 +1,5 @@
 import { debugLog } from '../utils/logger.js';
+import { getMetricCollector } from './metrics.js';
 /**
  * ============================================================================
  *                               PROXY CLIENT SERVICE
@@ -58,6 +59,16 @@ export function getAndResetTurnUsage() {
 export function peekTurnUsage() {
     return { ...globalSessionAccumulatedUsage };
 }
+export function accumulateTurnUsage(usage, modelName) {
+    const pTokens = usage.promptTokens ?? usage.promptTokenCount ?? 0;
+    const cTokens = usage.candidatesTokens ?? usage.candidatesTokenCount ?? 0;
+    const cachedTokens = usage.cachedTokens ?? usage.cachedContentTokenCount ?? 0;
+    globalSessionAccumulatedUsage.promptTokens += pTokens;
+    globalSessionAccumulatedUsage.candidatesTokens += cTokens;
+    globalSessionAccumulatedUsage.cachedTokens += cachedTokens;
+    globalSessionAccumulatedUsage.totalTokenCount += pTokens + cachedTokens + cTokens;
+    globalSessionAccumulatedUsage.modelsUsed[modelName] = (globalSessionAccumulatedUsage.modelsUsed[modelName] || 0) + 1;
+}
 /**
  * Client service interacting directly with the serverless Gemini proxy endpoint.
  * Ensures authorization via Firebase token passing and parses streamed content.
@@ -183,6 +194,12 @@ export class ProxyClient {
                             else if (data.type === 'done') {
                                 if (data.usage) {
                                     usageMetadata = data.usage;
+                                    const collector = getMetricCollector();
+                                    collector?.accumulateUsage({
+                                        promptTokens: data.usage.promptTokens || 0,
+                                        candidatesTokens: data.usage.candidatesTokens || 0,
+                                        cachedTokens: data.usage.cachedTokens || 0
+                                    });
                                     globalSessionAccumulatedUsage.promptTokens += data.usage.promptTokens || 0;
                                     globalSessionAccumulatedUsage.candidatesTokens += data.usage.candidatesTokens || 0;
                                     globalSessionAccumulatedUsage.cachedTokens += data.usage.cachedTokens || 0;

package/dist/services/verificationService.js

@@ -11,7 +11,7 @@ export async function detectVerificationCommand(workspaceRoot) {
         { name: 'pnpm-lock.yaml', prefix: 'pnpm run' },
         { name: 'yarn.lock', prefix: 'yarn run' },
         { name: 'bun.lockb', prefix: 'bun run' },
-        { name: 'bun.lock', prefix: 'bun run' }
+        { name: 'bun.lock', prefix: 'bun run' },
     ];
     for (const lf of lockFiles) {
         try {
@@ -66,14 +66,20 @@ export async function detectVerificationCommand(workspaceRoot) {
     catch { }
     try {
         await fs.access(path.join(workspaceRoot, 'build.gradle'));
-        return (await fs.access(path.join(workspaceRoot, 'gradlew')).then(() => true).catch(() => false))
+        return (await fs
+            .access(path.join(workspaceRoot, 'gradlew'))
+            .then(() => true)
+            .catch(() => false))
             ? './gradlew classes testClasses'
             : 'gradle classes testClasses';
     }
     catch { }
     try {
         await fs.access(path.join(workspaceRoot, 'build.gradle.kts'));
-        return (await fs.access(path.join(workspaceRoot, 'gradlew')).then(() => true).catch(() => false))
+        return (await fs
+            .access(path.join(workspaceRoot, 'gradlew'))
+            .then(() => true)
+            .catch(() => false))
             ? './gradlew classes testClasses'
             : 'gradle classes testClasses';
     }
@@ -126,7 +132,10 @@ export async function detectVerificationCommand(workspaceRoot) {
     }
     try {
         await fs.access(path.join(workspaceRoot, 'Gemfile'));
-        return (await fs.access(path.join(workspaceRoot, 'spec')).then(() => true).catch(() => false))
+        return (await fs
+            .access(path.join(workspaceRoot, 'spec'))
+            .then(() => true)
+            .catch(() => false))
             ? 'bundle exec rspec'
             : 'bundle exec rubocop';
     }
@@ -137,7 +146,7 @@ export async function runVerification(workspaceRoot, abortSignal) {
     const command = await detectVerificationCommand(workspaceRoot);
     if (!command)
         return null;
-    const MAX_VERIFY_OUTPUT = 20_000; // 20KB cap on verification output
+    const MAX_VERIFY_OUTPUT = 50_000; // 50KB cap on verification output
     debugLog(`Running project-level verification command: ${command}`);
     try {
         const { stdout, stderr } = await execAsync(command, {
@@ -225,7 +234,7 @@ ${result.errors.join('\n')}
 
 Please fix these errors using the modify_file tool.`;
 }
-import { auditFilePerformance, formatAuditForModel, formatAuditForTerminal, isAuditableFile } from '../utils/performanceAuditor.js';
+import { auditFilePerformance, formatAuditForModel, formatAuditForTerminal, isAuditableFile, } from '../utils/performanceAuditor.js';
 export async function verifyChangedFiles(workspaceRoot, filePaths, abortSignal) {
     const errors = [];
     const perfAudits = [];

package/dist/utils/config.d.ts

@@ -23,3 +23,7 @@ export declare const GEMINI_MODELS: {
 export declare const DEFAULT_MODEL: "auto";
 /** Maximum tokens the model can output per response. */
 export declare const MAX_OUTPUT_TOKENS = 60000;
+/**
+ * Checks if BYOK is currently enabled for the user.
+ */
+export declare function isByokEnabled(): Promise<boolean>;

package/dist/utils/config.js

@@ -23,3 +23,11 @@ export const GEMINI_MODELS = {
 export const DEFAULT_MODEL = GEMINI_MODELS.AUTO;
 /** Maximum tokens the model can output per response. */
 export const MAX_OUTPUT_TOKENS = 60_000;
+/**
+ * Checks if BYOK is currently enabled for the user.
+ */
+export async function isByokEnabled() {
+    const { loadCredentials } = await import('./credentialStore.js');
+    const creds = await loadCredentials();
+    return !!(creds.useByok && creds.geminiApiKey);
+}

package/dist/utils/credentialStore.d.ts

@@ -4,6 +4,8 @@ export interface StoredCredentials {
     idToken?: string;
     refreshToken?: string;
     idTokenExpiry?: number;
+    geminiApiKey?: string;
+    useByok?: boolean;
 }
 /**
  * Persists authentication credentials to the most secure available store.
@@ -15,6 +17,11 @@ export interface StoredCredentials {
  * 4. AES-256-GCM encrypted file with 0600 permissions
  */
 export declare function saveCredentials(data: StoredCredentials): Promise<void>;
+/**
+ * Updates a specific credential field without reloading all existing fields.
+ * Useful for partial updates (e.g., toggling BYOK).
+ */
+export declare function updateCredentialField<K extends keyof StoredCredentials>(key: K, value: StoredCredentials[K]): Promise<void>;
 /**
  * Loads authentication credentials from the secure store.
  * Returns an empty object if no credentials are found.

package/dist/utils/credentialStore.js

@@ -388,6 +388,14 @@ export async function saveCredentials(data) {
         }
     }
 }
+/**
+ * Updates a specific credential field without reloading all existing fields.
+ * Useful for partial updates (e.g., toggling BYOK).
+ */
+export async function updateCredentialField(key, value) {
+    const current = await loadCredentials();
+    await saveCredentials({ ...current, [key]: value });
+}
 /**
  * Loads authentication credentials from the secure store.
  * Returns an empty object if no credentials are found.

package/dist/utils/projectStorage.js

@@ -222,6 +222,13 @@ export async function invalidateCacheForDependents(workspaceRoot, changedFiles)
         if (updated) {
             writeCache(workspaceRoot, 'context_cache.json', cachedContext);
         }
+        try {
+            const { invalidateFilesFromInvestigationCache } = await import('../services/orchestration/investigationCache.js');
+            await invalidateFilesFromInvestigationCache(workspaceRoot, changedFiles);
+        }
+        catch (e) {
+            // Ignored
+        }
     }
     catch (err) {
         console.warn(pc.yellow(`Failed to invalidate cache for dependents: ${err}`));