minovative-mind-cli 1.3.0 → 1.4.0

package/README.md

@@ -1,43 +1,47 @@
 # Minovative Mind CLI
 
-## The CLI agent that makes Flash models perform like Pro.
-
-### The result: **Genuine Pro-level accuracy at Flash-level cost.**
+## The CLI agent that makes Flash models perform like a Pro reasoning model.
 
 Most AI coding tools throw your entire codebase at the biggest model available
-and hope for the best. This CLI does the opposite — it uses a custom built
+and hope for the best.
+
+This CLI does the opposite — it uses a custom built agentic system called,
 **Precision-Context Verification (PCV)** engine to feed lightweight Flash models
-exactly the right context, verify the output compiles, and self-correct, if it even needs to, until
-the build is green.
+exactly the right context, execute code, verify the output compiles, and self-correct (if it even needs to), until
+the build/performance metrics are green.
+
+> The result: **Genuine Pro reasoning accuracy at Flash-level speed and efficiency.**
 
 [![oclif](https://img.shields.io/badge/cli-oclif-brightgreen.svg)](https://oclif.io)
 [![Version](https://img.shields.io/npm/v/minovative-mind-cli.svg)](https://npmjs.org/package/minovative-mind-cli)
 [![Downloads/week](https://img.shields.io/npm/dw/minovative-mind-cli.svg)](https://npmjs.org/package/minovative-mind-cli)
 
+- Official Website: [https://www.minovativemind.dev/](https://www.minovativemind.dev/)
+- Latest Updates: [https://www.minovativemind.dev/updates](https://www.minovativemind.dev/updates)
+
 ---
 
 ## How it works
 
-Standard AI coding agents: big model + noisy context = expensive and redundant mistakes
-
-Minovative Mind CLI: flash models + precise context + verified output = better results.
+- Standard AI coding agents: big model + noisy context = expensive and redundant mistakes
+- Minovative Mind CLI: flash models + precise context + verified output = better and cheaper results.
 
-The PCV engine runs in three stages before returning a single line of code:
+### The PCV engine runs in three stages before returning a single line of code:
 
 **1. Investigate**
-A dedicated Context Agent reads your project structure, traces import
-dependencies, detects recently modified files, and searches the web for
-external documentation — all before the coding agent touches anything.
+
+- **Maps your project:** Traces import dependencies and identifies recently modified files to understand your focus.
+- **Researches context:** Gathers external web documentation and completes background research before touching any code.
 
 **2. Execute with precision**
-Instead of dumping your entire codebase into a prompt, the engine feeds the
-coding agent a compressed, surgical snapshot of only what's relevant.
-40–50% fewer broken generations on large files vs. standard zero-shot prompts.
+
+- **Surgical snapshots:** Feeds the agent a compressed, relevant slice of code instead of dumping the entire codebase.
+- **Higher success rates:** Delivers 40–50% fewer broken generations on large files compared to standard zero-shot prompts.
 
 **3. Verify and self-correct**
-After every change, it runs your actual build (`npm run build`, `cargo check`,
-`make`, etc.), reads the exact compiler output, and autonomously fixes errors —
-up to 3 correction cycles without you typing a word.
+
+- **Runs native builds & audits:** Automatically executes your actual build commands (`npm run build`, `cargo check`, etc.) and scans for performance flaws on modified files only.
+- **Autonomously debugs:** Reads the exact compiler output and fixes its own errors across up to 3 hands-free correction cycles.
 
 ---
 
@@ -54,6 +58,12 @@ up to 3 correction cycles without you typing a word.
 npm install -g minovative-mind-cli
 ```
 
+### Update to latest version
+
+```bash
+npm update -g minovative-mind-cli
+```
+
 Create a free account at [minovativemind.dev](https://www.minovativemind.dev),
 then:
 
@@ -63,7 +73,7 @@ cd your-project
 minovative-mind-cli chat    # Start coding
 ```
 
-Works in any terminal — SSH, Docker, CI pipelines, Vim, anywhere Node runs.
+Works in any terminal — SSH, Docker, CI pipelines, Vim, Windows Command Prompt, PowerShell, anywhere Node runs.
 
 ---
 
@@ -77,9 +87,9 @@ Hot-swap during a session with `/models`:
 | **Gemini 3.1 Pro**             | Complex architectural changes       |
 | **Gemini 3.1 Flash Lite**      | Maximum speed and cost efficiency   |
 
-> Intent routing, context compression, and commit generation always run on
-> lightweight models automatically — you only pay Pro rates when you
-> explicitly ask for it.
+> Background tasks (routing, compression, commits) always use lightweight
+> models automatically. You only pay for what your selected model costs
+> during chat and code execution. Use `/debug` to see exactly what's running.
 
 ---
 
@@ -97,6 +107,34 @@ Hot-swap during a session with `/models`:
 
 ---
 
+## 🌐 Supported Languages
+
+Minovative Mind CLI features deep, context-aware analysis across **11 major programming language families**. Our core engines—**Smart Dependency Tracing**, **Performance Auditing**, and **Ephemeral Analysis Scripts**—provide tailored support depending on the language's syntax and runtime model:
+
+| Language Family              | Supported Extensions                         | Dependency Tracing | Performance Auditing | Ephemeral Analysis |
+| :--------------------------- | :------------------------------------------- | :----------------: | :------------------: | :----------------: |
+| **JavaScript / TypeScript**  | `.js`, `.jsx`, `.ts`, `.tsx`, `.mjs`, `.cjs` |         ✅         |          ✅          |         ✅         |
+| **Python**                   | `.py`, `.pyw`                                |         ✅         |          ✅          |         ✅         |
+| **Rust**                     | `.rs`                                        |         ✅         |          ✅          |         ✅         |
+| **Go**                       | `.go`                                        |         ✅         |          ✅          |         ✅         |
+| **C / C++**                  | `.c`, `.h`, `.cpp`, `.hpp`, `.cc`            |         ✅         |        ⚠️ \*         |       ⚠️ \*        |
+| **Java / Kotlin**            | `.java`, `.kt`, `.kts`                       |         ✅         |        ⚠️ \*         |       ⚠️ \*        |
+| **PHP**                      | `.php`                                       |         ✅         |          ✅          |         ❌         |
+| **CSS / SCSS / SASS / LESS** | `.css`, `.scss`, `.sass`, `.less`            |         ✅         |          ❌          |         ❌         |
+| **Ruby**                     | `.rb`                                        |         ✅         |          ❌          |         ❌         |
+| **Swift**                    | `.swift`                                     |         ✅         |          ❌          |         ❌         |
+| **Dart**                     | `.dart`                                      |         ✅         |          ❌          |         ❌         |
+
+_⚠️\*Support is limited or requires custom local system tooling/environment setup._
+
+### Why do some features only support specific languages?
+
+1. **Dependency Tracing:** Fully supported for all 11 languages. It uses lightning-fast static regex pattern matching to resolve local import structures and determine the "blast radius" of code changes without requiring local compilations.
+2. **Performance Auditing:** Uses regex-based heuristic analysis to scan for issues. Extending this to complex grammars (such as Ruby or Swift) with pure regex can cause high false-positive rates; those require full AST parsing, which runs counter to the auditor's ultra-fast (<50ms) and zero-dependency goals.
+3. **Ephemeral Analysis Scripts:** Runs temporary files in sandbox directories to parse and extract local symbols. This requires having local runtimes/interpreters installed (e.g., Node, Python, Rust, Go compilers) and standard single-file execution support, which is not suitable for complex build setups (Java Maven/Gradle, C++ Makefiles) or non-executable languages (CSS).
+
+---
+
 ## Legal
 
 [Terms of Service](https://www.minovativemind.dev/legal/cli-terms) ·

package/dist/commands/chat.js

@@ -6,6 +6,7 @@ import * as p from '@clack/prompts';
 import pc from 'picocolors';
 import { startAgentLoop } from '../services/agent.js';
 import { getAuthorizedIdToken, login } from '../services/auth.js';
+import { printLogo } from '../utils/logo.js';
 import { updateWorkspaceStatus } from '../services/workspace.js';
 /**
  * @class DefaultCommand
@@ -36,10 +37,7 @@ Chat Controls:
     /**
      * Example usages for the chat command shown in help output.
      */
-    static examples = [
-        '<%= config.bin %> chat',
-        '<%= config.bin %> chat --help',
-    ];
+    static examples = ['<%= config.bin %> chat', '<%= config.bin %> chat --help'];
     /**
      * The main execution logic for the chat command.
      * - Initializes update notifications.
@@ -53,7 +51,8 @@ Chat Controls:
         // Setup update notifier
         const pkg = JSON.parse(await fs.promises.readFile(new URL('../../package.json', import.meta.url), 'utf8'));
         updateNotifier({ pkg }).notify();
-        p.intro(`${pc.bgCyan(pc.black(' Minovative Mind '))} ${pc.dim('v' + this.config.version)}`);
+        printLogo();
+        p.intro(`${pc.bgCyan(pc.black(' Minovative Mind CLI '))} ${pc.dim('v' + this.config.version)}`);
         // Check authentication
         let idToken = await getAuthorizedIdToken();
         if (!idToken) {

package/dist/services/agent-tools.js

@@ -1,5 +1,6 @@
 import { exec } from 'node:child_process';
 import { promises as fs } from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import { promisify } from 'node:util';
 import { SchemaType } from '@google/generative-ai';
@@ -283,7 +284,7 @@ async function getIgnoredPaths(workspaceRoot) {
             .map((l) => l.trim())
             .filter((l) => l && !l.startsWith('#'));
         for (const line of lines) {
-            const cleanLine = line.replace(/^\//, '').replace(/\/$/, '');
+            const cleanLine = line.replace(/\\/g, '/').replace(/^\//, '').replace(/\/$/, '');
             if (!cleanLine.includes('*')) {
                 ignoredDirs.add(cleanLine);
                 ignoredFiles.add(cleanLine);
@@ -525,18 +526,18 @@ export async function runCommand(workspaceRoot, command, abortSignal) {
         });
         let output = [stdout, stderr].filter(Boolean).join('\n');
         // Truncate command output to prevent memory blowout from massive build logs
-        const MAX_CMD_OUTPUT = 50_000;
+        const MAX_CMD_OUTPUT = 15_000;
         if (output.length > MAX_CMD_OUTPUT) {
-            output = output.substring(0, MAX_CMD_OUTPUT) + '\n... (output truncated — exceeded 50KB limit)';
+            output = output.substring(0, MAX_CMD_OUTPUT) + `\n\n... (Output truncated: ${output.length} bytes exceeded 15KB limit. To view the rest, pipe the command to a file and read it in chunks, or use grep.)`;
         }
         return { output: output || '(command produced no output)' };
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         // Also truncate error output
-        const MAX_ERR_OUTPUT = 30_000;
+        const MAX_ERR_OUTPUT = 15_000;
         const truncatedMsg = message.length > MAX_ERR_OUTPUT
-            ? message.substring(0, MAX_ERR_OUTPUT) + '\n... (error output truncated)'
+            ? message.substring(0, MAX_ERR_OUTPUT) + `\n\n... (Error output truncated: ${message.length} bytes exceeded 15KB limit. Pipe to a file if you need full logs.)`
             : message;
         return { output: '', error: `Command failed: ${truncatedMsg}` };
     }
@@ -544,29 +545,86 @@ export async function runCommand(workspaceRoot, command, abortSignal) {
 export async function grepSearch(workspaceRoot, pattern, fileGlob, abortSignal) {
     try {
         const { ignoredDirs } = await getIgnoredPaths(workspaceRoot);
-        const excludeDirArgs = Array.from(ignoredDirs)
-            .map((dir) => `--exclude-dir="${dir}"`)
-            .concat('--exclude-dir=".*"') // Exclude all hidden directories
-            .join(' ');
-        const excludeFileArgs = EXCLUDED_EXTENSIONS.map((ext) => `--exclude="${ext}"`)
-            .concat('--exclude=".*"') // Exclude all hidden files
-            .join(' ');
-        // Build a grep command that works cross-platform via node
-        // We use grep -rnIEi for recursive, line numbers, skip binary, extended regex, case-insensitive
-        const globArg = fileGlob ? ` --include="${fileGlob}"` : '';
-        const cmd = `grep -rnIEi --color=never ${excludeDirArgs} ${excludeFileArgs}${globArg} "${pattern.replace(/"/g, '\\"')}" .`;
-        const { stdout } = await execAsync(cmd, {
-            cwd: workspaceRoot,
-            timeout: 15_000,
-            maxBuffer: 1024 * 1024 * 2,
-            signal: abortSignal,
-        });
-        // Limit output to 50 results
-        const lines = stdout.trim().split('\n');
-        const limited = lines.slice(0, 50);
-        const resultText = limited.join('\n') + (lines.length > 50 ? `\n\n... (${lines.length - 50} more results truncated)` : '');
-        if (!resultText)
+        if (os.platform() !== 'win32') {
+            const excludeDirArgs = Array.from(ignoredDirs)
+                .map((dir) => `--exclude-dir="${dir}"`)
+                .concat('--exclude-dir=".*"') // Exclude all hidden directories
+                .join(' ');
+            const excludeFileArgs = EXCLUDED_EXTENSIONS.map((ext) => `--exclude="${ext}"`)
+                .concat('--exclude=".*"') // Exclude all hidden files
+                .join(' ');
+            // Build a grep command that works cross-platform via node
+            // We use grep -rnIEi for recursive, line numbers, skip binary, extended regex, case-insensitive
+            const globArg = fileGlob ? ` --include="${fileGlob}"` : '';
+            const cmd = `grep -rnIEi --color=never ${excludeDirArgs} ${excludeFileArgs}${globArg} "${pattern.replace(/"/g, '\\"')}" .`;
+            const { stdout } = await execAsync(cmd, {
+                cwd: workspaceRoot,
+                timeout: 15_000,
+                maxBuffer: 1024 * 1024 * 2,
+                signal: abortSignal,
+            });
+            // Limit output to 50 results
+            const lines = stdout.trim().split('\n');
+            const limited = lines.slice(0, 50);
+            const resultText = limited.join('\n') + (lines.length > 50 ? `\n\n... (${lines.length - 50} more results truncated)` : '');
+            if (!resultText)
+                return { output: `No matches found for "${pattern}".` };
+            const wrappedResult = `<workspace_file path="grep_search_results">\n<content_data><![CDATA[\n${sanitizeForCDATA(resultText)}\n]]></content_data>\n</workspace_file>`;
+            return { output: wrappedResult };
+        }
+        // Node.js fallback for Windows
+        const regexPattern = new RegExp(pattern, 'gi'); // Emulate grep -i and global match
+        const globPattern = fileGlob ? new RegExp('^' + fileGlob.replace(/\./g, '\\.').replace(/\*/g, '.*') + '$', 'i') : null;
+        const results = [];
+        async function walk(dir) {
+            if (results.length >= 50)
+                return;
+            let entries;
+            try {
+                entries = await fs.readdir(dir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const entry of entries) {
+                if (results.length >= 50)
+                    return;
+                if (entry.name.startsWith('.'))
+                    continue;
+                if (entry.isDirectory()) {
+                    if (ignoredDirs.has(entry.name))
+                        continue;
+                    await walk(path.join(dir, entry.name));
+                }
+                else if (entry.isFile()) {
+                    if (EXCLUDED_EXTENSIONS.some((ext) => entry.name.endsWith(ext.replace('*', ''))))
+                        continue;
+                    if (globPattern && !globPattern.test(entry.name))
+                        continue;
+                    try {
+                        const filePath = path.join(dir, entry.name);
+                        const content = await fs.readFile(filePath, 'utf-8');
+                        const lines = content.split(/\r?\n/);
+                        for (let i = 0; i < lines.length; i++) {
+                            if (results.length >= 50)
+                                break;
+                            regexPattern.lastIndex = 0;
+                            if (regexPattern.test(lines[i])) {
+                                const relPath = path.relative(workspaceRoot, filePath).replace(/\\/g, '/');
+                                results.push(`${relPath}:${i + 1}:${lines[i]}`);
+                            }
+                        }
+                    }
+                    catch {
+                        // Ignore unreadable files (binaries, etc)
+                    }
+                }
+            }
+        }
+        await walk(workspaceRoot);
+        if (results.length === 0)
             return { output: `No matches found for "${pattern}".` };
+        const resultText = results.join('\n') + (results.length >= 50 ? `\n\n... (more results truncated)` : '');
         const wrappedResult = `<workspace_file path="grep_search_results">\n<content_data><![CDATA[\n${sanitizeForCDATA(resultText)}\n]]></content_data>\n</workspace_file>`;
         return { output: wrappedResult };
     }
@@ -633,7 +691,7 @@ export async function findRecentChanges(workspaceRoot, dirPath = '.', minutes =
                         const filePath = path.join(currentPath, entry.name);
                         const stats = await fs.stat(filePath);
                         if (stats.mtimeMs >= thresholdMs) {
-                            const relPath = path.relative(workspaceRoot, filePath);
+                            const relPath = path.relative(workspaceRoot, filePath).replace(/\\/g, '/');
                             recentFiles.push({ path: relPath, mtime: stats.mtimeMs });
                         }
                     }
@@ -698,9 +756,13 @@ export async function runDebugScript(workspaceRoot, language, code, abortSignal)
             case 'go':
                 cmd = `go run ${tmpFileName}`;
                 break;
-            case 'rust':
-                cmd = `rustc ${tmpFileName} && ./${tmpFileName.replace('.rs', '')}`;
+            case 'rust': {
+                const binExt = os.platform() === 'win32' ? '.exe' : '';
+                const binPath = tmpFileName.replace('.rs', binExt);
+                const runCmd = os.platform() === 'win32' ? binPath : `./${binPath}`;
+                cmd = `rustc ${tmpFileName} -o ${binPath} && ${runCmd}`;
                 break;
+            }
             default:
                 return { output: '', error: `Unsupported language runtime: ${language}` };
         }
@@ -738,7 +800,8 @@ export async function runDebugScript(workspaceRoot, language, code, abortSignal)
         try {
             await fs.rm(absPath, { force: true });
             if (language.toLowerCase() === 'rust') {
-                const binPath = absPath.replace('.rs', '');
+                const binExt = os.platform() === 'win32' ? '.exe' : '';
+                const binPath = absPath.replace('.rs', binExt);
                 await fs.rm(binPath, { force: true });
             }
         }

package/dist/services/agent.js

@@ -22,6 +22,8 @@ import path from 'node:path';
 import { exec } from 'node:child_process';
 import { promisify } from 'node:util';
 import { debugLog, toggleDebugMode } from '../utils/logger.js';
+import { ensureProjectStorage, ensureIgnored, readCache, writeCache, invalidateCacheForDependents } from '../utils/projectStorage.js';
+import * as crypto from 'node:crypto';
 const execAsync = promisify(exec);
 /**
  * Asynchronous Input Handler (AsyncInputHandler)
@@ -181,6 +183,7 @@ export class AsyncInputHandler {
                 const originalMessage = spinner.message.bind(spinner);
                 spinner.message = (msg) => {
                     if (msg) {
+                        ;
                         spinner._lastMessage = msg;
                     }
                     originalMessage(msg);
@@ -188,6 +191,7 @@ export class AsyncInputHandler {
                 const originalStart = spinner.start.bind(spinner);
                 spinner.start = (msg) => {
                     if (msg) {
+                        ;
                         spinner._lastMessage = msg;
                     }
                     originalStart(msg);
@@ -231,6 +235,7 @@ import { consumeSkipOnce, executeTool, getApprovalMode, setApprovalMode } from '
 import { createSharedChatSession, getGeneralChatConfig, getPlanExecutionConfig, ProxyChatSession, compressTextUsingFlashLite, } from './ai.js';
 import { changeLogger } from './changeLogger.js';
 import { gatherContext, routeIntent } from './contextAgent.js';
+import { printLogo } from '../utils/logo.js';
 import { verifyChangedFiles } from './verificationService.js';
 import { buildContextInjection } from '../utils/contextPrompts.js';
 import { readPaste } from '../utils/paste.js';
@@ -309,30 +314,108 @@ function formatToolCall(name, args) {
     const details = formatter ? formatter() : '';
     return `${icon} ${label}${details}`;
 }
+function isCommandDestructive(command) {
+    const destructivePatterns = [
+        // Unix deletion (catches rm -r, rm -rf, rm -fr, rm --recursive, rm --force, anywhere in args)
+        /\brm\s+.*?(?:-[a-zA-Z]*[rfR]|--(?:recursive|force))\b/i,
+        /\bmv\s+.*\/dev\/null\b/i, // Move to void
+        // Windows deletion (catches rd /s, del /f /s)
+        /\b(?:rd|rmdir)\s+.*\/[sq]\b/i,
+        /\bdel\s+.*\/[fs]\b/i,
+        // Remote script execution (catches curl/wget piped to any shell or runtime)
+        /\b(?:curl|wget)\b.*?\|\s*(?:sh|bash|zsh|dash|python|node|ruby|perl)\b/i,
+        // Git overwriting (catches hard resets, clean -f, force pushes, hard branch deletes)
+        /\bgit\s+(?:reset|clean)\s+.*(?:--hard|-f|--force)\b/i,
+        /\bgit\s+push\s+.*(?:-f|--force)\b/i,
+        /\bgit\s+branch\s+.*-D\b/i,
+        // DB & Cluster Drops (catches truncates, deletes, drop db/table, docker volume/system prunes, kubectl wipes)
+        /\b(?:drop|truncate|delete)\s+(?:database|table|schema)\b/i,
+        /\bdocker\s+system\s+prune\b/i,
+        /\bdocker\s+volume\s+(?:rm|prune)\b/i,
+        /\bkubectl\s+delete\s+(?:namespace|all|--all)\b/i,
+        // Disk & System destruction (format, fdisk, dd, overwriting block devices, shutdown, fork bombs)
+        /\b(?:mkfs|fdisk|parted|mkswap)\b/i,
+        /\bformat\s+[A-Z]:/i,
+        /\bdd\s+.*(?:if=|of=)\b/i,
+        />\s*\/dev\/(?:sda|disk|hda|nvme)\b/i,
+        /\b(?:shutdown|reboot|halt|poweroff)\b/i,
+        /:\(\)\{\s*:\|:&\s*\};:/, // Fork bomb
+        // User data/config erasure
+        /\bcrontab\s+-r\b/i,
+        /\bhistory\s+-c\b/i,
+        // Massive permission shifts (chmod 777, recursive chowns)
+        /\bchmod\s+(?:-[R\w]*\s+)?777\b/i,
+        /\bchown\s+-[R\w]*\b/i,
+    ];
+    return destructivePatterns.some((pattern) => pattern.test(command));
+}
+function isCommandSafe(command) {
+    // Do not auto-approve chained, redirected, or sudo commands
+    if (/[;&|>]/.test(command) || /\bsudo\b/.test(command)) {
+        return false;
+    }
+    const safePatterns = [
+        /^\s*ls\b/i,
+        /^\s*pwd\b/i,
+        /^\s*whoami\b/i,
+        /^\s*cat\b/i,
+        /^\s*echo\b/i,
+        /^\s*grep\b/i,
+        /^\s*find\b/i,
+        /^\s*npm\s+(install|i|ci|run\b)/i,
+        /^\s*yarn\s+(install|add|build|lint|test|run\b)/i,
+        /^\s*pnpm\s+(install|i|add|build|lint|test|run\b)/i,
+        /^\s*bun\s+(install|i|add|run\b)/i,
+        /^\s*cargo\s+(build|check|add|test|run\b)/i,
+        /^\s*go\s+(mod|get|build|test|run\b)/i,
+        /^\s*pip\s+(install|list|show)\b/i,
+        /^\s*uv\s+(add|pip|sync|run\b)/i,
+        /^\s*rustc\b/i,
+        /^\s*git\s+(status|log|diff|show|branch)\b/i,
+        /^\s*(node|python|ruby|java|go|rustc)\s+(--version|-v)\b/i,
+        /^\s*tsc\b/i,
+        /^\s*eslint\b/i,
+        /^\s*prettier\b/i,
+    ];
+    return safePatterns.some((pattern) => pattern.test(command));
+}
 /**
- * Prompts the user to approve a pending shell command requested by the AI.
- * Implements a safety gate to protect the host machine's environment from arbitrary code execution.
+ * Executes an interactive approval prompt via `@clack/prompts`.
  *
- * Supports three approval models:
- * 1. **Ask**: Prompts the user for every shell execution command.
+ * Supports pattern-based approvals and three user approval models:
+ * 1. **Ask**: Prompts the user for every shell execution command (except implicitly safe ones).
  * 2. **Skip-Once**: Automatically grants permission to the current command, then resets.
- * 3. **Skip-All / Auto-Approve**: Grants permission to all future terminal commands in the current session.
+ * 3. **Skip-All / Auto-Approve**: Grants permission to all future terminal commands.
+ *
+ * Destructive commands will ALWAYS prompt the user, regardless of mode.
  *
  * @param command - The terminal string requested for execution.
  * @returns A promise resolving to `true` if approved, or `false` if denied/cancelled.
  */
 async function requestCommandApproval(command) {
     const mode = getApprovalMode();
-    if (mode === 'skip-all') {
-        p.log.info(`${pc.dim('Auto-approved (skip-all):')} ${pc.yellow(command)}`);
-        return true;
+    const isDestructive = isCommandDestructive(command);
+    const isSafe = isCommandSafe(command);
+    // Force prompt for destructive commands
+    if (isDestructive) {
+        p.log.warn(`${pc.bgRed(pc.white(' WARNING '))} Destructive command detected. Explicit approval required.`);
     }
-    if (mode === 'skip-once') {
-        p.log.info(`${pc.dim('Auto-approved (skip-once):')} ${pc.yellow(command)}`);
-        consumeSkipOnce();
-        return true;
+    else {
+        if (mode === 'skip-all') {
+            p.log.info(`${pc.dim('Auto-approved (skip-all):')} ${pc.yellow(command)}`);
+            return true;
+        }
+        if (mode === 'skip-once') {
+            p.log.info(`${pc.dim('Auto-approved (skip-once):')} ${pc.yellow(command)}`);
+            consumeSkipOnce();
+            return true;
+        }
+        if (isSafe) {
+            p.log.info(`${pc.dim('Auto-approved (safe command):')} ${pc.yellow(command)}`);
+            return true;
+        }
     }
-    // mode === 'ask'
+    // mode === 'ask' or isDestructive
     const result = await p.select({
         message: `Approve command: ${pc.yellow(command)}`,
         options: [
@@ -599,6 +682,11 @@ async function processResponse(chat, result, workspaceRoot, inputHandler, agentS
  * @param version - The Semantic Version string of the active tool distribution.
  */
 export async function startAgentLoop(workspaceRoot, version) {
+    // Initialize project-level storage and ensure it is safely ignored from version control
+    ensureProjectStorage(workspaceRoot);
+    ensureIgnored(workspaceRoot);
+    // Initialize persistent change ledger
+    changeLogger.init(workspaceRoot);
     const chat = createSharedChatSession();
     const inputHandler = new AsyncInputHandler();
     let isRawPasteMode = false;
@@ -643,8 +731,9 @@ export async function startAgentLoop(workspaceRoot, version) {
                 }
             }
             let line = (userInputRaw || '');
-            if (line.trimEnd().endsWith('\\')) {
-                const cleanLine = line.trimEnd().slice(0, -1);
+            // Require a space before the backslash to prevent Windows directory paths (e.g., C:\foo\) from triggering multiline
+            if (line.trimEnd().endsWith(' \\')) {
+                const cleanLine = line.trimEnd().slice(0, -2);
                 lines.push(cleanLine);
                 isMultiLine = true;
                 // Clack's text prompt dims the submitted value, which can be completely invisible on some terminal themes.
@@ -720,7 +809,8 @@ export async function startAgentLoop(workspaceRoot, version) {
         else if (userInput.toLowerCase() === '/clear') {
             chat.clearHistory();
             process.stdout.write('\x1B[2J\x1B[3J\x1B[H'); // Hard clear screen and scrollback
-            p.intro(`${pc.bgCyan(pc.black(' Minovative Mind '))} ${pc.dim('v' + version)}`);
+            printLogo();
+            p.intro(`${pc.bgCyan(pc.black(' Minovative Mind CLI '))} ${pc.dim('v' + version)}`);
             p.log.info(`${pc.dim('Workspace:')} ${pc.cyan(workspaceRoot)}`);
             p.log.info(`${pc.dim('Commands:')} Type ${pc.yellow('/')} to open the command menu and "${pc.yellow('stop')}" to stop the ai generation. Type ${pc.yellow('exit')} to leave.`);
             p.log.success('Chat history cleared.');
@@ -772,25 +862,62 @@ export async function startAgentLoop(workspaceRoot, version) {
             continue;
         }
         if (userInput.toLowerCase() === '/revert') {
-            const lastChangeSet = changeLogger.popLastChangeSet();
-            if (!lastChangeSet) {
+            const history = changeLogger.getHistory();
+            if (!history || history.length === 0) {
                 p.log.warn('No changes to revert.');
                 continue;
             }
+            const lastChangeSet = history[history.length - 1];
+            const truncate = (str, max) => (str.length > max ? str.substring(0, max - 3) + '...' : str);
+            const revertMenu = await p.select({
+                message: 'Revert Menu',
+                options: [
+                    { value: 'revert_last', label: `Revert last change (${truncate(lastChangeSet.description, 50)})` },
+                    { value: 'view_history', label: 'View history' },
+                    { value: 'cancel', label: 'Cancel' },
+                ],
+            });
+            if (p.isCancel(revertMenu) || revertMenu === 'cancel') {
+                continue;
+            }
+            let targetTimestamp = lastChangeSet.timestamp;
+            if (revertMenu === 'view_history') {
+                // Reverse history so newest is at the top
+                const historyOptions = history
+                    .slice()
+                    .reverse()
+                    .map((cs, i) => ({
+                    value: cs.timestamp,
+                    label: `[${i === 0 ? 'Latest' : `-${i}`}] ${truncate(cs.description, 50)} (${new Date(cs.timestamp).toLocaleTimeString()})`,
+                    hint: `Reverts this and all ${i} changes after it`,
+                }));
+                const selectedHistory = await p.select({
+                    message: 'Select the point in history to revert back to:',
+                    options: [...historyOptions, { value: -1, label: 'Cancel' }],
+                });
+                if (p.isCancel(selectedHistory) || selectedHistory === -1) {
+                    continue;
+                }
+                targetTimestamp = selectedHistory;
+            }
             const spinner = p.spinner();
-            spinner.start('Reverting last changes...');
+            spinner.start('Reverting selected changes...');
             try {
-                for (const change of lastChangeSet.changes) {
-                    const absPath = path.resolve(workspaceRoot, change.filePath);
-                    if (change.action === 'create') {
-                        await fs.rm(absPath, { force: true });
-                    }
-                    else if (change.originalContent !== null) {
-                        await fs.writeFile(absPath, change.originalContent, 'utf-8');
+                const changesToRevert = changeLogger.popUntil(targetTimestamp);
+                // changesToRevert is ordered from newest to oldest. We must apply them sequentially.
+                for (const changeSet of changesToRevert) {
+                    for (const change of changeSet.changes) {
+                        const absPath = path.resolve(workspaceRoot, change.filePath);
+                        if (change.action === 'create') {
+                            await fs.rm(absPath, { force: true });
+                        }
+                        else if (change.originalContent !== null) {
+                            await fs.writeFile(absPath, change.originalContent, 'utf-8');
+                        }
                     }
                 }
                 spinner.stop('Reverted successfully.');
-                p.log.success(`Reverted changes for: ${lastChangeSet.description}`);
+                p.log.success(`Reverted ${changesToRevert.length} changeset(s) successfully.`);
             }
             catch (err) {
                 spinner.stop('Revert failed.');
@@ -839,6 +966,7 @@ ${diffOut}
             continue;
         }
         // ─── Main Execution Cycle ────────────────────────────────────────
+        const turnStartTime = Date.now();
         const spinner = p.spinner();
         const ac = new AbortController();
         inputHandler.setAbortController(ac);
@@ -890,11 +1018,46 @@ ${diffOut}
             let dynamicSystemInstruction = config.systemInstruction;
             // Inject gathered workspace directories, dependency configurations, and matching search patterns
             if (gatherRes.contextResult) {
-                let contextInjection = buildContextInjection(gatherRes.contextResult);
-                debugLog(`Raw context injection size: ${contextInjection.length} chars`);
-                // Compress context inputs using Gemini Flash Lite to optimize prompt density and prevent token bloat
-                contextInjection = await compressTextUsingFlashLite(contextInjection, `Summarize the following project context concisely. Preserve all file paths, project types, and the high-level purpose of the read files. Keep it under 2000 characters if possible.\nCRITICAL: Focus specifically on details relevant to the user's current request: "${userInput}"`);
-                debugLog(`Compressed context injection size: ${contextInjection.length} chars`);
+                const cachedContext = readCache(workspaceRoot, 'context_cache.json') || {};
+                let cacheUpdated = false;
+                // Compress each relevant file individually to allow granular cache hits
+                const compressedFiles = new Map();
+                for (const [filePath, content] of gatherRes.contextResult.relevantFiles.entries()) {
+                    if (content.length < 2000) {
+                        debugLog(`Bypassing cache and compression for ${filePath} (length ${content.length} < 2000)`);
+                        compressedFiles.set(filePath, content);
+                        continue;
+                    }
+                    const fileHash = crypto.createHash('sha256').update(filePath + content).digest('hex');
+                    if (cachedContext[fileHash]) {
+                        debugLog(`Context cache HIT for file ${filePath} (hash ${fileHash.substring(0, 8)})`);
+                        compressedFiles.set(filePath, cachedContext[fileHash]);
+                    }
+                    else {
+                        debugLog(`Context cache MISS for file ${filePath} (hash ${fileHash.substring(0, 8)})`);
+                        const compressPrompt = `Summarize the following file contents concisely. Preserve all exports, functions, classes, variables, and architectural purpose. Keep it under 2000 characters if possible. File: ${filePath}`;
+                        const summary = await compressTextUsingFlashLite(content, compressPrompt);
+                        compressedFiles.set(filePath, summary);
+                        cachedContext[fileHash] = summary;
+                        cacheUpdated = true;
+                    }
+                }
+                if (cacheUpdated) {
+                    // Keep cache size manageable by restricting to recent 100 file entries
+                    const keys = Object.keys(cachedContext);
+                    if (keys.length > 100) {
+                        const toDelete = keys.length - 100;
+                        for (let i = 0; i < toDelete; i++) {
+                            delete cachedContext[keys[i]];
+                        }
+                    }
+                    writeCache(workspaceRoot, 'context_cache.json', cachedContext);
+                }
+                // Replace raw file contents with their compressed summaries
+                gatherRes.contextResult.relevantFiles = compressedFiles;
+                // Assemble the final context injection string
+                const contextInjection = buildContextInjection(gatherRes.contextResult);
+                debugLog(`Final compressed context injection size: ${contextInjection.length} chars`);
                 dynamicSystemInstruction += '\n\n' + contextInjection;
             }
             // Apply the dynamic prompt updates and tool registrations to the active chat session
@@ -993,8 +1156,13 @@ ${diffOut}
                 result = await chat.sendMessage(correctionPrompt);
                 spinner.stop('');
             }
-            // Persist the verified changes into our session change ledger
-            changeLogger.commitChangeSet();
+            const postExecutionChanges = changeLogger.getCurrentChangeSet()?.changes || [];
+            const modifiedFiles = postExecutionChanges
+                .filter((c) => c.action === 'modify' || c.action === 'create' || c.action === 'delete')
+                .map((c) => path.relative(workspaceRoot, c.filePath));
+            if (modifiedFiles.length > 0) {
+                await invalidateCacheForDependents(workspaceRoot, modifiedFiles);
+            }
             if (finalText) {
                 console.log(`\n${pc.blue('◆')} ${pc.bold('Minovative Mind')} ${pc.dim(`(${chat.getModel()})`)}\n`);
                 // Strip out excessive empty lines generated by LLMs to prevent huge visual gaps in marked-terminal
@@ -1004,11 +1172,20 @@ ${diffOut}
             if (latestUsage && latestUsage.remainingBalance !== undefined) {
                 p.log.info(`${pc.dim('Credits Remaining:')} ${pc.cyan(latestUsage.remainingBalance.toLocaleString())}`);
             }
+            const turnEndTime = Date.now();
+            const turnDuration = ((turnEndTime - turnStartTime) / 1000).toFixed(1);
+            p.log.info(`${pc.dim('Generated in')} ${pc.cyan(turnDuration + 's')}`);
         }
         catch (err) {
             spinner.stop('');
             const message = err instanceof Error ? err.message : String(err);
             p.log.error(`${pc.red('Error:')} ${message}`);
         }
+        finally {
+            // Persist any verified or partial changes into our session change ledger.
+            // This ensures that if the process crashes, errors out, or is aborted mid-generation,
+            // the user can still use /revert to undo the partial file mutations.
+            changeLogger.commitChangeSet();
+        }
     }
 }

package/dist/services/changeLogger.d.ts

@@ -11,6 +11,12 @@ export interface ChangeSet {
 declare class ChangeLogger {
     private changeStack;
     private currentChangeSet;
+    private workspaceRoot;
+    private readonly MAX_HISTORY;
+    init(workspaceRoot: string): void;
+    private saveState;
+    getHistory(): ChangeSet[];
+    popUntil(timestamp: number): ChangeSet[];
     startChangeSet(description: string): void;
     logChange(filePath: string, originalContent: string | null, action: 'create' | 'modify' | 'delete'): void;
     commitChangeSet(): void;

package/dist/services/changeLogger.js

@@ -1,6 +1,41 @@
+import { readCache, writeCache } from '../utils/projectStorage.js';
 class ChangeLogger {
     changeStack = [];
     currentChangeSet = null;
+    workspaceRoot = '';
+    MAX_HISTORY = 10;
+    init(workspaceRoot) {
+        this.workspaceRoot = workspaceRoot;
+        const savedState = readCache(workspaceRoot, 'revert_state.json');
+        if (savedState && Array.isArray(savedState)) {
+            this.changeStack = savedState;
+        }
+    }
+    saveState() {
+        if (!this.workspaceRoot)
+            return;
+        // Enforce history limit
+        if (this.changeStack.length > this.MAX_HISTORY) {
+            this.changeStack = this.changeStack.slice(-this.MAX_HISTORY);
+        }
+        writeCache(this.workspaceRoot, 'revert_state.json', this.changeStack);
+    }
+    getHistory() {
+        return [...this.changeStack];
+    }
+    popUntil(timestamp) {
+        const changesToRevert = [];
+        while (this.changeStack.length > 0) {
+            const top = this.changeStack[this.changeStack.length - 1];
+            changesToRevert.push(top);
+            this.changeStack.pop();
+            if (top.timestamp === timestamp) {
+                break;
+            }
+        }
+        this.saveState();
+        return changesToRevert;
+    }
     startChangeSet(description) {
         if (this.currentChangeSet) {
             this.commitChangeSet();
@@ -34,6 +69,7 @@ class ChangeLogger {
     commitChangeSet() {
         if (this.currentChangeSet && this.currentChangeSet.changes.length > 0) {
             this.changeStack.push(this.currentChangeSet);
+            this.saveState();
         }
         this.currentChangeSet = null;
     }
@@ -48,7 +84,11 @@ class ChangeLogger {
     popLastChangeSet() {
         if (this.changeStack.length === 0)
             return null;
-        return this.changeStack.pop() || null;
+        const popped = this.changeStack.pop() || null;
+        if (popped) {
+            this.saveState();
+        }
+        return popped;
     }
     hasChanges() {
         return this.changeStack.length > 0;

package/dist/utils/analysisRunner.js

@@ -39,7 +39,8 @@ function buildCommand(language, scriptPath) {
         case 'go':
             return `go run "${scriptPath}"`;
         case 'rust': {
-            const binPath = scriptPath.replace('.rs', '');
+            const binExt = os.platform() === 'win32' ? '.exe' : '';
+            const binPath = scriptPath.replace('.rs', binExt);
             return `rustc "${scriptPath}" -o "${binPath}" && "${binPath}"`;
         }
         default:
@@ -87,7 +88,8 @@ export async function runEphemeralScript(workspaceRoot, language, code, options)
     // Collect all temp files created so we can clean them up unconditionally
     const tempFiles = [scriptPath];
     if (language.toLowerCase() === 'rust') {
-        tempFiles.push(scriptPath.replace('.rs', ''));
+        const binExt = os.platform() === 'win32' ? '.exe' : '';
+        tempFiles.push(scriptPath.replace('.rs', binExt));
     }
     try {
         await fs.writeFile(scriptPath, code, 'utf-8');

package/dist/utils/dependencyTracer.js

@@ -438,7 +438,7 @@ async function walkWorkspace(workspaceRoot) {
             .map((l) => l.trim())
             .filter((l) => l && !l.startsWith('#'));
         for (const line of lines) {
-            const clean = line.replace(/^\//, '').replace(/\/$/, '');
+            const clean = line.replace(/\\/g, '/').replace(/^\//, '').replace(/\/$/, '');
             if (!clean.includes('*')) {
                 extraIgnored.add(clean);
             }

package/dist/utils/logo.d.ts

@@ -0,0 +1,2 @@
+export declare const LOGO: string;
+export declare function printLogo(): void;

package/dist/utils/logo.js

@@ -0,0 +1,12 @@
+import pc from 'picocolors';
+export const LOGO = `
+           ${pc.blue('///')}      ${pc.cyan('//')}               ${pc.cyan('\\\\')}      ${pc.blue('\\\\\\')}      ${pc.blue('  __  __  __  __    ____ _     ___ ')}
+          ${pc.blue('///')}      ${pc.cyan('//')}                 ${pc.cyan('\\\\')}      ${pc.blue('\\\\\\')}     ${pc.blue(' |  \\/  ||  \\/  |  / ___| |   |_ _|')}
+         ${pc.blue('///')}      ${pc.cyan('//')}         ${pc.cyan('●')}         ${pc.cyan('\\\\')}      ${pc.blue('\\\\\\')}    ${pc.blue(' | |\\/| || |\\/| | | |   | |    | | ')}
+         ${pc.blue('\\\\\\')}      ${pc.cyan('\\\\')}                   ${pc.cyan('//')}      ${pc.blue('///')}    ${pc.blue(' | |  | || |  | | | |___| |___ | | ')}
+          ${pc.blue('\\\\\\')}      ${pc.cyan('\\\\')}                 ${pc.cyan('//')}      ${pc.blue('///')}     ${pc.blue(' |_|  |_||_|  |_|  \\____|_____|___|')}
+           ${pc.blue('\\\\\\')}      ${pc.cyan('\\\\')}               ${pc.cyan('//')}      ${pc.blue('///')}
+`;
+export function printLogo() {
+    console.log(pc.bold(LOGO));
+}

package/dist/utils/performanceAuditor.js

@@ -5,6 +5,7 @@ const EXTENSION_MAP = {
     '.py': 'python', '.pyw': 'python',
     '.go': 'go',
     '.rs': 'rust',
+    '.php': 'php',
 };
 function detectLanguage(filePath) {
     return EXTENSION_MAP[path.extname(filePath).toLowerCase()] ?? 'unknown';
@@ -26,16 +27,16 @@ function stripStringsAndComments(source, lang) {
     while (i < source.length) {
         const ch = source[i];
         const next = source[i + 1];
-        // ── JS/TS/Go/Rust: line comments (//) ─────────────────────
-        if ((lang === 'js' || lang === 'go' || lang === 'rust') && ch === '/' && next === '/') {
+        // ── JS/TS/Go/Rust/PHP: line comments (//) ─────────────────────
+        if ((lang === 'js' || lang === 'go' || lang === 'rust' || lang === 'php') && ch === '/' && next === '/') {
             const eol = source.indexOf('\n', i);
             const end = eol === -1 ? source.length : eol;
             result += ' '.repeat(end - i);
             i = end;
             continue;
         }
-        // ── JS/TS/Go/Rust: block comments (/* ... */) ─────────────
-        if ((lang === 'js' || lang === 'go' || lang === 'rust') && ch === '/' && next === '*') {
+        // ── JS/TS/Go/Rust/PHP: block comments (/* ... */) ─────────────
+        if ((lang === 'js' || lang === 'go' || lang === 'rust' || lang === 'php') && ch === '/' && next === '*') {
             const end = source.indexOf('*/', i + 2);
             const closePos = end === -1 ? source.length : end + 2;
             // Preserve newlines for line counting
@@ -44,8 +45,8 @@ function stripStringsAndComments(source, lang) {
             i = closePos;
             continue;
         }
-        // ── Python: line comments (#) ─────────────────────────────
-        if (lang === 'python' && ch === '#') {
+        // ── Python/PHP: line comments (#) ─────────────────────────────
+        if ((lang === 'python' || lang === 'php') && ch === '#') {
             const eol = source.indexOf('\n', i);
             const end = eol === -1 ? source.length : eol;
             result += ' '.repeat(end - i);
@@ -62,6 +63,26 @@ function stripStringsAndComments(source, lang) {
             i = closePos;
             continue;
         }
+        // ── PHP: Heredoc/Nowdoc (<<<EOF ... EOF;) ─────────────────────
+        if (lang === 'php' && ch === '<' && next === '<' && source[i + 2] === '<') {
+            const eol = source.indexOf('\n', i);
+            if (eol !== -1) {
+                // e.g. <<<EOF or <<<'EOF'
+                const idMatch = source.substring(i + 3, eol).match(/[A-Za-z0-9_]+/);
+                if (idMatch) {
+                    const identifier = idMatch[0];
+                    const closePattern = new RegExp(`\\n${identifier}(;|\\n|$)`);
+                    const match = source.substring(eol).match(closePattern);
+                    if (match) {
+                        const end = eol + match.index + match[0].length;
+                        const segment = source.substring(i, end);
+                        result += segment.replace(/[^\n]/g, ' ');
+                        i = end;
+                        continue;
+                    }
+                }
+            }
+        }
         // ── All languages: string literals ────────────────────────
         if (ch === '"' || ch === "'" || (lang === 'js' && ch === '`')) {
             const quote = ch;
@@ -119,7 +140,7 @@ const detectNestedLoops = (source, stripped, lang, findings) => {
         return;
     }
     // C-family: scan for loop keywords and track brace depth
-    const loopPattern = /\b(for|while|do)\s*[\s(]/g;
+    const loopPattern = /\b(for|foreach|while|do)\s*[\s(]/g;
     const lines = stripped.split('\n');
     for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
@@ -144,7 +165,7 @@ const detectNestedLoops = (source, stripped, lang, findings) => {
             }
             // Check lines inside the outer loop body for nested loops
             if (j > i && foundOpening && depth > 0) {
-                if (/\b(for|while|do)\s*[\s(]/.test(innerLine)) {
+                if (/\b(for|foreach|while|do)\s*[\s(]/.test(innerLine)) {
                     findings.push({
                         severity: 'WARNING',
                         code: 'PERF-001',
@@ -484,6 +505,21 @@ const detectUnboundedFetch = (_source, stripped, lang, findings) => {
                 }
             }
         }
+        if (lang === 'php') {
+            if (/\.(all|get|findAll|query)\s*\(|::all\s*\(/.test(line)) {
+                const window = lines.slice(i, Math.min(i + 5, lines.length)).join('\n');
+                if (!/\.(limit|take|paginate|offset)\s*\(/.test(window) &&
+                    !/\bLIMIT\b/i.test(window)) {
+                    findings.push({
+                        severity: 'WARNING',
+                        code: 'PERF-008',
+                        line: i + 1,
+                        message: 'Database/ORM query without limit() or paginate() — may fetch unbounded rows into memory.',
+                        suggestion: 'Add a limit() or use pagination.',
+                    });
+                }
+            }
+        }
         // Go / Rust: detect SQL queries without LIMIT
         if (lang === 'go' || lang === 'rust') {
             if (/SELECT\s+/i.test(line) && !/\bLIMIT\b/i.test(line)) {
@@ -502,6 +538,67 @@ const detectUnboundedFetch = (_source, stripped, lang, findings) => {
         }
     }
 };
+// ── PERF-PHP1 / PHP2 / PHP3: PHP-specific loop anti-patterns ───────
+const detectPhpInLoopOperations = (_source, stripped, lang, findings) => {
+    if (lang !== 'php')
+        return;
+    const lines = stripped.split('\n');
+    let loopDepth = 0;
+    let braceDepth = 0;
+    let inLoop = false;
+    let loopBraceStart = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (/\b(for|foreach|while|do)\s*[\s(]/.test(line) && !inLoop) {
+            inLoop = true;
+            loopBraceStart = braceDepth;
+            loopDepth++;
+        }
+        for (const ch of line) {
+            if (ch === '{')
+                braceDepth++;
+            else if (ch === '}') {
+                braceDepth--;
+                if (inLoop && braceDepth <= loopBraceStart) {
+                    inLoop = false;
+                    loopDepth--;
+                }
+            }
+        }
+        if (loopDepth > 0) {
+            // PERF-PHP1: array_merge
+            if (/\barray_merge\s*\(/.test(line)) {
+                findings.push({
+                    severity: 'WARNING',
+                    code: 'PERF-PHP1',
+                    line: i + 1,
+                    message: 'array_merge() inside a loop — causes O(n²) memory inflation and copying.',
+                    suggestion: 'Append to array with $arr[] = $val and merge once outside the loop, or use the splat operator.',
+                });
+            }
+            // PERF-PHP2: N+1 queries
+            if (/(->get\(|->find\(|->query\(|->findAll\(|::find\(|DB::|->execute\()/.test(line)) {
+                findings.push({
+                    severity: 'WARNING',
+                    code: 'PERF-PHP2',
+                    line: i + 1,
+                    message: 'Database query execution inside a loop (N+1 query problem).',
+                    suggestion: 'Pre-fetch data outside the loop using eager loading (e.g., with()) or a single IN() query.',
+                });
+            }
+            // PERF-PHP3: Blocking I/O
+            if (/\b(file_get_contents|curl_exec|fopen)\s*\(/.test(line)) {
+                findings.push({
+                    severity: 'WARNING',
+                    code: 'PERF-PHP3',
+                    line: i + 1,
+                    message: 'Blocking I/O operation inside a loop.',
+                    suggestion: 'Perform I/O in parallel using curl_multi_exec, or bulk fetch data before the loop.',
+                });
+            }
+        }
+    }
+};
 // ─── Rule Registry ───────────────────────────────────────────────────
 const ALL_RULES = [
     detectNestedLoops,
@@ -512,6 +609,7 @@ const ALL_RULES = [
     detectDangerousEval,
     detectUnsafeJsonParse,
     detectUnboundedFetch,
+    detectPhpInLoopOperations,
 ];
 // ─── Supported Extensions for Auditing ───────────────────────────────
 const AUDITABLE_EXTENSIONS = new Set(Object.keys(EXTENSION_MAP));

package/dist/utils/projectStorage.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Gets the path to the project's .minovativemind storage directory.
+ */
+export declare function getProjectStorageDir(workspaceRoot: string): string;
+/**
+ * Ensures that the .minovativemind directory exists in the workspace root.
+ * This is a self-healing directory used for crash-safe state and caching.
+ */
+export declare function ensureProjectStorage(workspaceRoot: string): void;
+/**
+ * Ensures that the .minovativemind directory is safely ignored from version control,
+ * docker images, and npm packages to prevent state leakage.
+ */
+export declare function ensureIgnored(workspaceRoot: string): void;
+/**
+ * Reads a JSON file from the project's .minovativemind directory.
+ * Returns null if the file does not exist or is corrupted.
+ */
+export declare function readCache<T = any>(workspaceRoot: string, filename: string): T | null;
+/**
+ * Writes data to a JSON file in the project's .minovativemind directory using an atomic write pattern
+ * to prevent corruption from concurrent accesses.
+ */
+export declare function writeCache(workspaceRoot: string, filename: string, data: any): Promise<void>;
+/**
+ * Invalidates the context cache for files that depend on the given modified files.
+ * This ensures that if a core file changes, its dependents are forced to generate
+ * fresh summaries reflecting the new behavior.
+ */
+export declare function invalidateCacheForDependents(workspaceRoot: string, changedFiles: string[]): Promise<void>;

package/dist/utils/projectStorage.js

@@ -0,0 +1,157 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as pc from 'picocolors';
+import { buildDependencyGraph } from './dependencyTracer.js';
+/**
+ * Gets the path to the project's .minovativemind storage directory.
+ */
+export function getProjectStorageDir(workspaceRoot) {
+    return path.join(workspaceRoot, '.minovativemind');
+}
+/**
+ * Ensures that the .minovativemind directory exists in the workspace root.
+ * This is a self-healing directory used for crash-safe state and caching.
+ */
+export function ensureProjectStorage(workspaceRoot) {
+    const storageDir = getProjectStorageDir(workspaceRoot);
+    if (!fs.existsSync(storageDir)) {
+        try {
+            fs.mkdirSync(storageDir, { recursive: true });
+        }
+        catch (err) {
+            // Non-fatal error, CLI can proceed without cache if permissions fail
+            console.warn(pc.yellow(`Failed to create .minovativemind directory: ${err instanceof Error ? err.message : String(err)}`));
+        }
+    }
+}
+/**
+ * Ensures that the .minovativemind directory is safely ignored from version control,
+ * docker images, and npm packages to prevent state leakage.
+ */
+export function ensureIgnored(workspaceRoot) {
+    const ignoreFiles = ['.gitignore', '.dockerignore', '.npmignore', '.eslintignore', '.prettierignore'];
+    const gitDirExists = fs.existsSync(path.join(workspaceRoot, '.git'));
+    // If .git exists but .gitignore doesn't, we should create a minimal .gitignore
+    if (gitDirExists && !fs.existsSync(path.join(workspaceRoot, '.gitignore'))) {
+        try {
+            fs.writeFileSync(path.join(workspaceRoot, '.gitignore'), '# Minovative CLI Data\n.minovativemind/\n', 'utf-8');
+        }
+        catch (e) {
+            // ignore
+        }
+    }
+    for (const ignoreFile of ignoreFiles) {
+        const filePath = path.join(workspaceRoot, ignoreFile);
+        // Only modify the file if it actually exists (except for the .gitignore creation above)
+        if (fs.existsSync(filePath)) {
+            try {
+                const content = fs.readFileSync(filePath, 'utf-8');
+                // Check if it already ignores .minovativemind or .minovativemind/
+                if (!content.includes('.minovativemind')) {
+                    // Append with a newline just in case the file doesn't end with one
+                    const appendContent = content.endsWith('\n') || content.length === 0 ? '.minovativemind/\n' : '\n.minovativemind/\n';
+                    fs.appendFileSync(filePath, appendContent, 'utf-8');
+                }
+            }
+            catch (e) {
+                // Silently ignore permissions errors etc.
+            }
+        }
+    }
+}
+/**
+ * Reads a JSON file from the project's .minovativemind directory.
+ * Returns null if the file does not exist or is corrupted.
+ */
+export function readCache(workspaceRoot, filename) {
+    const filePath = path.join(getProjectStorageDir(workspaceRoot), filename);
+    if (!fs.existsSync(filePath))
+        return null;
+    try {
+        const data = fs.readFileSync(filePath, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch (err) {
+        // Treat parsing errors as cache misses
+        return null;
+    }
+}
+/**
+ * Writes data to a JSON file in the project's .minovativemind directory using an atomic write pattern
+ * to prevent corruption from concurrent accesses.
+ */
+export async function writeCache(workspaceRoot, filename, data) {
+    ensureProjectStorage(workspaceRoot); // Self-healing check
+    const filePath = path.join(getProjectStorageDir(workspaceRoot), filename);
+    const tempPath = `${filePath}.${Date.now()}-${Math.floor(Math.random() * 1000)}.tmp`;
+    try {
+        fs.writeFileSync(tempPath, JSON.stringify(data, null, 2), 'utf-8');
+        // Windows retry logic for EPERM/EBUSY on file replace
+        const maxRetries = 3;
+        let attempt = 0;
+        while (attempt <= maxRetries) {
+            try {
+                fs.renameSync(tempPath, filePath);
+                break; // Success
+            }
+            catch (err) {
+                if (attempt === maxRetries || (err.code !== 'EPERM' && err.code !== 'EBUSY')) {
+                    throw err;
+                }
+                attempt++;
+                const delay = attempt === 1 ? 10 : attempt === 2 ? 50 : 100;
+                await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+        }
+    }
+    catch (err) {
+        // Non-fatal, clean up temp file if possible
+        try {
+            if (fs.existsSync(tempPath))
+                fs.unlinkSync(tempPath);
+        }
+        catch { }
+    }
+}
+/**
+ * Invalidates the context cache for files that depend on the given modified files.
+ * This ensures that if a core file changes, its dependents are forced to generate
+ * fresh summaries reflecting the new behavior.
+ */
+export async function invalidateCacheForDependents(workspaceRoot, changedFiles) {
+    if (!changedFiles || changedFiles.length === 0)
+        return;
+    try {
+        const cachedContext = readCache(workspaceRoot, 'context_cache.json');
+        if (!cachedContext)
+            return;
+        let updated = false;
+        const graph = await buildDependencyGraph(workspaceRoot);
+        for (const file of changedFiles) {
+            const reverseDeps = graph.getImportedBy(file);
+            for (const dep of reverseDeps) {
+                try {
+                    const content = fs.readFileSync(path.join(workspaceRoot, dep), 'utf-8');
+                    const crypto = await import('crypto');
+                    const fileHash = crypto
+                        .createHash('sha256')
+                        .update(dep + content)
+                        .digest('hex');
+                    if (cachedContext[fileHash]) {
+                        delete cachedContext[fileHash];
+                        updated = true;
+                    }
+                }
+                catch (e) {
+                    // If we can't read the dependent file, it might have been deleted. Skip it.
+                }
+            }
+        }
+        if (updated) {
+            writeCache(workspaceRoot, 'context_cache.json', cachedContext);
+        }
+    }
+    catch (err) {
+        console.warn(pc.yellow(`Failed to invalidate cache for dependents: ${err}`));
+    }
+}

package/oclif.manifest.json

@@ -65,5 +65,5 @@
       ]
     }
   },
-  "version": "1.3.0"
+  "version": "1.4.0"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "minovative-mind-cli",
   "description": "An automated AI agent powered by Vertex AI that helps you write software",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "author": "Daniel Ward",
   "bin": {
     "minovative-mind-cli": "./bin/run.js"