minovative-mind-cli 1.2.3 → 1.3.1

package/LICENSE.md

@@ -2,7 +2,7 @@
 
 **Copyright (c) 2026 Minovative Mind. All Rights Reserved.**
 
-This software, including all source code, documentation, and associated files (the "Software"), is proprietary and confidential property of Minovative Mind.
+This software, including all source code, documentation, and associated files (the "Software"), is proprietary and confidential property of Ward Innovations.
 
 ## 1. Grant of License
 

package/README.md

@@ -1,152 +1,110 @@
-# Minovative Mind CLI (w/ Gemini 3.5 Flash & Gemini 3.1 Pro)
+# Minovative Mind CLI
 
-## Highly accurate, lightweight AI coding agent for any terminal (Designed for less errors). [(Click Demo)](https://youtu.be/KjE5nbKEf3w?si=mcjb5_2QLf4vofRC)
+## The CLI agent that makes Flash models perform like Pro.
 
-An automated, multi-agent AI coding assistant powered by Vertex AI. By utilizing a custom built **Precision-Context Verification (PCV)** engine (for coding) with AST-based structural analysis, it reads, writes, and refactors code with extreme accuracy—delivering a **40% to 50% reduction in broken code generations** on large files compared to standard zero-shot LLM prompts.
+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 agentic system called,
+**Precision-Context Verification (PCV)** engine to feed lightweight Flash models
+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-level accuracy at Flash-level cost.**
 
 [![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)
-
-## Supported Models
-
-The CLI supports the following advanced reasoning and coding models via Vertex AI Model Garden. You can hot-swap between these models at any time during a chat session by typing `/models` in the CLI:
-
-- **Gemini 3.1 Pro**: Best for highly complex architectural reasoning and large context windows.
-- **Gemini 3.5 Flash** (Default): Lightning fast, top-tier performance for everyday coding tasks.
-- **Gemini 3.1 Flash Lite**: Lightning fast, cost-effective performance for everyday coding tasks.
-
-## Table of Contents
-
-- [Quick Start](#quick-start)
-- [Commands](#commands)
+---
 
-<!-- tocstop -->
+## How it works
 
-## Quick Start
+- 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.
 
-Getting started with Minovative Mind CLI is easy!
+### The PCV engine runs in three stages before returning a single line of code:
 
-1. **Install Globally:**
+**1. Investigate**
 
-   ```bash
-   npm install -g minovative-mind-cli
-   ```
+- **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. **Authenticate:**
-   Before you can use the CLI, you need to create an account at [https://www.minovativemind.dev/](https://www.minovativemind.dev/).
-   Once you have an account, sign in securely using GitHub by running:
+**2. Execute with precision**
 
-   ```bash
-   minovative-mind-cli login
-   ```
+- **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. **Start Coding!**
-   Navigate to any project directory on your computer and start a chat session:
+**3. Verify and self-correct**
 
-   ```bash
-   cd your-project-folder
-   minovative-mind-cli chat
-   ```
+- **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.
 
-4. **Change Models (Optional):**
-   Once in a chat, type `/models` to switch between advanced reasoning models like Gemini 3.5 Flash and Gemini 3.1 Pro!
+---
 
-5. **Update the CLI:**
-   To ensure you have the latest features and bug fixes, you can update the CLI at any time by running the following command. (The CLI will automatically notify you when a new version is available!)
+## See it in action
 
-   ```bash
-   npm update -g minovative-mind-cli
-   ```
+- [AI builds a Python Generative Art Engine in one prompt](https://www.youtube.com/watch?v=dy3qNbETqfs)
+- [AI builds a Quiz Game from scratch](https://www.youtube.com/watch?v=KjE5nbKEf3w)
 
 ---
 
-# Commands
-
-<!-- commands -->
-* [`minovative-mind-cli chat`](#minovative-mind-cli-chat)
-* [`minovative-mind-cli help [COMMAND]`](#minovative-mind-cli-help-command)
-* [`minovative-mind-cli login`](#minovative-mind-cli-login)
-* [`minovative-mind-cli logout`](#minovative-mind-cli-logout)
+## Quick Start
 
-## `minovative-mind-cli chat`
+```bash
+npm install -g minovative-mind-cli
+```
 
-Start an interactive AI coding agent session powered by Vertex AI.
+### Update to latest version
 
+```bash
+npm update -g minovative-mind-cli
 ```
-USAGE
-  $ minovative-mind-cli chat
-
-DESCRIPTION
-  Start an interactive AI coding agent session powered by Vertex AI.
-
-  Inside the chat session, you can use the following commands in the slash menu:
-  /models        - Select the active model
-  /paste         - Enter multi-line paste mode for long snippets
-  /clear         - Clear conversation history
-  /debug         - Debug tests or command execution in a sandbox loop
-  /auto-approve  - Toggle automatic approval of tool/command runs
-  /revert        - Revert the last file modification made by the agent
-  /commit        - Commit current workspace changes to Git
-
-  Chat Controls:
-  - Multi-line Input: End a line with \ to continue on the next line
-  - Stop/Abort: Type "stop" to immediately interrupt agent generation
-  - Exit Session: Type "exit" or "quit" to end the agent session
-
-EXAMPLES
-  $ minovative-mind-cli chat
-
-  $ minovative-mind-cli chat --help
-```
-
-## `minovative-mind-cli help [COMMAND]`
 
-Display help for minovative-mind-cli.
+Create a free account at [minovativemind.dev](https://www.minovativemind.dev),
+then:
 
+```bash
+minovative-mind-cli login   # One-click GitHub sign-in
+cd your-project
+minovative-mind-cli chat    # Start coding
 ```
-USAGE
-  $ minovative-mind-cli help [COMMAND...] [-n]
 
-ARGUMENTS
-  [COMMAND...]  Command to show help for.
+Works in any terminal — SSH, Docker, CI pipelines, Vim, anywhere Node runs.
 
-FLAGS
-  -n, --nested-commands  Include all nested commands in the output.
-
-DESCRIPTION
-  Display help for minovative-mind-cli.
-```
+---
 
-## `minovative-mind-cli login`
+## Models
 
-Sign in to your Minovative Mind account using GitHub
+Hot-swap during a session with `/models`:
 
-```
-USAGE
-  $ minovative-mind-cli login
+| Model                          | Best for                            |
+| ------------------------------ | ----------------------------------- |
+| **Gemini 3.5 Flash** (default) | Everyday coding — fast and accurate |
+| **Gemini 3.1 Pro**             | Complex architectural changes       |
+| **Gemini 3.1 Flash Lite**      | Maximum speed and cost efficiency   |
 
-DESCRIPTION
-  Sign in to your Minovative Mind account using GitHub
-```
+> 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.
 
-## `minovative-mind-cli logout`
+---
 
-Sign out of your Minovative Mind account
+## Session Commands
 
-```
-USAGE
-  $ minovative-mind-cli logout
+| Command         | What it does                                          |
+| --------------- | ----------------------------------------------------- |
+| `/models`       | Hot-swap the active model                             |
+| `/revert`       | Instantly undo all changes from the last turn         |
+| `/commit`       | Generate a conventional commit message from your diff |
+| `/auto-approve` | Skip confirmation prompts for commands                |
+| `/paste`        | Multi-line input mode                                 |
+| `/debug`        | Expose internal agent diagnostics                     |
+| `stop`          | Abort generation immediately                          |
 
-DESCRIPTION
-  Sign out of your Minovative Mind account
-```
-<!-- commandsstop -->
+---
 
 ## Legal
 
-- [Terms of Service](https://www.minovativemind.dev/legal/cli-terms)
-- [Privacy Policy](https://www.minovativemind.dev/legal/cli-privacy)
+[Terms of Service](https://www.minovativemind.dev/legal/cli-terms) ·
+[Privacy Policy](https://www.minovativemind.dev/legal/cli-privacy)

package/dist/services/agent.js

@@ -893,7 +893,7 @@ ${diffOut}
                 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.');
+                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`);
                 dynamicSystemInstruction += '\n\n' + contextInjection;
             }
@@ -965,12 +965,16 @@ ${diffOut}
                     break;
                 // Stage 3: Static code analysis / verification
                 p.log.step('Verifying modified files...');
-                const verificationErrors = await verifyChangedFiles(workspaceRoot, changedFiles, ac.signal);
-                if (verificationErrors === '[Verification Aborted]') {
+                const verificationResult = await verifyChangedFiles(workspaceRoot, changedFiles, ac.signal);
+                if (verificationResult === '[Verification Aborted]') {
                     p.log.warn(pc.yellow('Verification aborted by user.'));
                     break;
                 }
-                if (!verificationErrors) {
+                // Print non-blocking performance warnings to the terminal
+                if (verificationResult.warnings) {
+                    p.log.warn('Performance Audit Warnings:\n' + verificationResult.warnings);
+                }
+                if (!verificationResult.errors) {
                     p.log.success('Verification passed.');
                     break;
                 }
@@ -980,11 +984,11 @@ ${diffOut}
                     break;
                 }
                 p.log.warn(`${pc.yellow('Verification failed. Auto-correcting errors')} (Attempt ${correctionAttempts}/${MAX_CORRECTIONS})...`);
-                const displayError = verificationErrors.split('\n').slice(0, 5).join('\n');
+                const displayError = verificationResult.errors.split('\n').slice(0, 5).join('\n');
                 console.log(pc.dim(`  ${displayError.replace(/\n/g, '\n  ')}\n  ...`));
-                debugLog(`Verification failed on attempt ${correctionAttempts}/${MAX_CORRECTIONS}. Errors:\n${verificationErrors}`);
+                debugLog(`Verification failed on attempt ${correctionAttempts}/${MAX_CORRECTIONS}. Errors:\n${verificationResult.errors}`);
                 // Compile compilation and syntax diagnostic warnings into an auto-correction prompt
-                const correctionPrompt = `AUTOMATED SYSTEM CHECK: Your previous changes resulted in the following errors:\n\n${verificationErrors}\n\nPlease analyze these errors and use your file modification tools to fix them.`;
+                const correctionPrompt = `AUTOMATED SYSTEM CHECK: Your previous changes resulted in the following errors:\n\n${verificationResult.errors}\n\nPlease analyze these errors and use your file modification tools to fix them.`;
                 spinner.start('Thinking (Correction)...');
                 result = await chat.sendMessage(correctionPrompt);
                 spinner.stop('');

package/dist/services/proxyClient.d.ts

@@ -1,13 +1,55 @@
 import type { Content, Tool, ToolConfig, FunctionCall } from '@google/generative-ai';
+/**
+ * ============================================================================
+ *                               PROXY CLIENT SERVICE
+ * ============================================================================
+ * Facilitates stream-based communication with the secure, Firebase-authenticated
+ * serverless Gemini content generation proxy.
+ *
+ * Core Capabilities:
+ * - Server-Sent Events (SSE) parsing for thoughts, text, and function calls.
+ * - Secure Authentication handling (Firebase ID Tokens).
+ * - Real-time stream-callback piping for instant responses.
+ * - Accurate token usage, credit consumption, and grounding metadata parsing.
+ * ============================================================================
+ */
+/**
+ * Metadata containing real-time proxy token and credit usage diagnostics.
+ */
 export interface ProxyUsageMetadata {
+    /** The number of tokens detected in the prompt/input. */
     promptTokens: number;
+    /** The number of tokens generated as candidates. */
     candidatesTokens: number;
+    /** The number of cached tokens, if context caching was utilized. */
     cachedTokens?: number;
+    /** The credit cost of this request in micro-credits or target monetary units. */
     creditsUsed: number;
+    /** The remaining balance left in the user's account. */
     remainingBalance: number;
 }
+/**
+ * Client service interacting directly with the serverless Gemini proxy endpoint.
+ * Ensures authorization via Firebase token passing and parses streamed content.
+ */
 export declare class ProxyClient {
     private readonly PROXY_URL;
+    /**
+     * Generates text, thoughts, or function calls via the secure Gemini proxy URL.
+     * Utilizes Server-Sent Events (SSE) to stream partial token responses back to the client.
+     *
+     * @param idToken - The Firebase ID token for authorization.
+     * @param modelName - The name of the Gemini model to target.
+     * @param contents - Structured conversations/contents matching Google's schema.
+     * @param tools - Optional tools available for the model to execute.
+     * @param toolConfig - Optional routing/forcing behavior configuration for the tools.
+     * @param systemInstruction - Optional instructions for guiding the model's persona/behavior.
+     * @param generationConfig - Optional parameters controlling model creativity, output type, etc.
+     * @param streamCallbacks - Optional callbacks triggered as thoughts/content stream in.
+     * @param abortSignal - Optional signal to abort the fetch request midway.
+     * @returns A structured promise resolving to gathered text, function calls, and metadata.
+     * @throws {Error} If authentication fails (401), credits are insufficient (402), or network/proxy errors occur.
+     */
     generateFunctionCallViaProxy(idToken: string, modelName: string, contents: Content[], tools?: Tool[], toolConfig?: ToolConfig, systemInstruction?: string | Content, generationConfig?: any, streamCallbacks?: {
         onChunk: (chunk: string) => void;
     }, abortSignal?: AbortSignal): Promise<{

package/dist/services/proxyClient.js

@@ -1,6 +1,26 @@
 import { debugLog } from '../utils/logger.js';
+/**
+ * Client service interacting directly with the serverless Gemini proxy endpoint.
+ * Ensures authorization via Firebase token passing and parses streamed content.
+ */
 export class ProxyClient {
     PROXY_URL = 'https://generatecontent-6obg3e4zwa-uc.a.run.app';
+    /**
+     * Generates text, thoughts, or function calls via the secure Gemini proxy URL.
+     * Utilizes Server-Sent Events (SSE) to stream partial token responses back to the client.
+     *
+     * @param idToken - The Firebase ID token for authorization.
+     * @param modelName - The name of the Gemini model to target.
+     * @param contents - Structured conversations/contents matching Google's schema.
+     * @param tools - Optional tools available for the model to execute.
+     * @param toolConfig - Optional routing/forcing behavior configuration for the tools.
+     * @param systemInstruction - Optional instructions for guiding the model's persona/behavior.
+     * @param generationConfig - Optional parameters controlling model creativity, output type, etc.
+     * @param streamCallbacks - Optional callbacks triggered as thoughts/content stream in.
+     * @param abortSignal - Optional signal to abort the fetch request midway.
+     * @returns A structured promise resolving to gathered text, function calls, and metadata.
+     * @throws {Error} If authentication fails (401), credits are insufficient (402), or network/proxy errors occur.
+     */
     async generateFunctionCallViaProxy(idToken, modelName, contents, tools, toolConfig, systemInstruction, generationConfig, streamCallbacks, abortSignal) {
         const response = await fetch(this.PROXY_URL, {
             method: 'POST',

package/dist/services/verificationService.d.ts

@@ -3,8 +3,13 @@ export interface VerificationResult {
     command: string;
     output: string;
     errors: string[];
+    aborted?: boolean;
 }
 export declare function detectVerificationCommand(workspaceRoot: string): Promise<string | null>;
 export declare function runVerification(workspaceRoot: string, abortSignal?: AbortSignal): Promise<VerificationResult | null>;
 export declare function formatVerificationForModel(result: VerificationResult): string;
-export declare function verifyChangedFiles(workspaceRoot: string, filePaths: string[], abortSignal?: AbortSignal): Promise<string | null>;
+export interface FullVerificationResult {
+    errors: string | null;
+    warnings: string | null;
+}
+export declare function verifyChangedFiles(workspaceRoot: string, filePaths: string[], abortSignal?: AbortSignal): Promise<FullVerificationResult | '[Verification Aborted]'>;

package/dist/services/verificationService.js

@@ -5,19 +5,35 @@ import { promisify } from 'node:util';
 import { debugLog } from '../utils/logger.js';
 const execAsync = promisify(exec);
 export async function detectVerificationCommand(workspaceRoot) {
+    // Package Manager Detection
+    let pmPrefix = 'npm run';
+    const lockFiles = [
+        { 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' }
+    ];
+    for (const lf of lockFiles) {
+        try {
+            await fs.access(path.join(workspaceRoot, lf.name));
+            pmPrefix = lf.prefix;
+            break;
+        }
+        catch { }
+    }
     try {
         const pkgJsonPath = path.join(workspaceRoot, 'package.json');
         const pkgJsonStr = await fs.readFile(pkgJsonPath, 'utf-8');
         const pkgJson = JSON.parse(pkgJsonStr);
         if (pkgJson.scripts) {
             if (pkgJson.scripts.build)
-                return 'npm run build';
+                return `${pmPrefix} build`;
             if (pkgJson.scripts.typecheck)
-                return 'npm run typecheck';
+                return `${pmPrefix} typecheck`;
             if (pkgJson.scripts.lint)
-                return 'npm run lint';
+                return `${pmPrefix} lint`;
             if (pkgJson.scripts.check)
-                return 'npm run check';
+                return `${pmPrefix} check`;
         }
     }
     catch {
@@ -33,6 +49,83 @@ export async function detectVerificationCommand(workspaceRoot) {
         return 'cargo check';
     }
     catch { }
+    try {
+        await fs.access(path.join(workspaceRoot, 'go.mod'));
+        return 'go build ./...';
+    }
+    catch { }
+    try {
+        await fs.access(path.join(workspaceRoot, 'pom.xml'));
+        return 'mvn clean compile test-compile';
+    }
+    catch { }
+    try {
+        await fs.access(path.join(workspaceRoot, 'build.gradle'));
+        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))
+            ? './gradlew classes testClasses'
+            : 'gradle classes testClasses';
+    }
+    catch { }
+    try {
+        await fs.access(path.join(workspaceRoot, 'pubspec.yaml'));
+        return 'dart analyze';
+    }
+    catch { }
+    // Python Environment Awareness
+    let isPython = false;
+    for (const pyFile of ['pytest.ini', 'pyproject.toml', 'poetry.lock', 'uv.lock', 'Pipfile', '.venv', 'venv']) {
+        try {
+            await fs.access(path.join(workspaceRoot, pyFile));
+            isPython = true;
+            break;
+        }
+        catch { }
+    }
+    if (isPython) {
+        try {
+            await fs.access(path.join(workspaceRoot, 'poetry.lock'));
+            return 'poetry run pytest';
+        }
+        catch { }
+        try {
+            await fs.access(path.join(workspaceRoot, 'uv.lock'));
+            return 'uv run pytest';
+        }
+        catch { }
+        try {
+            await fs.access(path.join(workspaceRoot, 'Pipfile'));
+            return 'pipenv run pytest';
+        }
+        catch { }
+        const isWindows = process.platform === 'win32';
+        try {
+            await fs.access(path.join(workspaceRoot, '.venv'));
+            const pytestPath = isWindows ? '.venv\\Scripts\\pytest' : '.venv/bin/pytest';
+            return pytestPath;
+        }
+        catch { }
+        try {
+            await fs.access(path.join(workspaceRoot, 'venv'));
+            const pytestPath = isWindows ? 'venv\\Scripts\\pytest' : 'venv/bin/pytest';
+            return pytestPath;
+        }
+        catch { }
+        return 'pytest';
+    }
+    try {
+        await fs.access(path.join(workspaceRoot, 'Gemfile'));
+        return (await fs.access(path.join(workspaceRoot, 'spec')).then(() => true).catch(() => false))
+            ? 'bundle exec rspec'
+            : 'bundle exec rubocop';
+    }
+    catch { }
     return null;
 }
 export async function runVerification(workspaceRoot, abortSignal) {
@@ -44,7 +137,7 @@ export async function runVerification(workspaceRoot, abortSignal) {
     try {
         const { stdout, stderr } = await execAsync(command, {
             cwd: workspaceRoot,
-            timeout: 90_000, // 90s (1 min & 30 secs) - builds can take a while (e.g., Next.js)
+            timeout: 120_000, // 120s (2 mins) - builds can take a while (e.g., Next.js, Gradle)
             maxBuffer: 1024 * 1024, // 1 MB buffer
             signal: abortSignal,
         });
@@ -72,9 +165,25 @@ export async function runVerification(workspaceRoot, abortSignal) {
         // Extract error lines with context
         const errors = [];
         let capturingError = false;
+        const isErrorLine = (line) => {
+            const lower = line.toLowerCase();
+            if (lower.includes('fail') ||
+                lower.includes('failed') ||
+                lower.includes('exception') ||
+                lower.includes('fatal') ||
+                lower.includes('panic') ||
+                lower.includes('traceback') ||
+                lower.includes('error') ||
+                lower.includes('err!') ||
+                /:\d+:\d+:/.test(line) ||
+                /:\d+:/.test(line)) {
+                return true;
+            }
+            return false;
+        };
         for (const line of lines) {
             const lower = line.toLowerCase();
-            if (lower.includes('error') || lower.includes('err!')) {
+            if (isErrorLine(line)) {
                 capturingError = true;
                 errors.push(line);
             }
@@ -87,6 +196,12 @@ export async function runVerification(workspaceRoot, abortSignal) {
                 }
             }
         }
+        if (errors.length === 0) {
+            const fallbackSource = rawStderr.trim() ? rawStderr : rawStdout;
+            const fallbackLines = fallbackSource.split('\n');
+            const last40 = fallbackLines.slice(-40);
+            errors.push(...last40);
+        }
         return {
             success: false,
             command,
@@ -105,11 +220,13 @@ ${result.errors.join('\n')}
 
 Please fix these errors using the modify_file tool.`;
 }
+import { auditFilePerformance, formatAuditForModel, formatAuditForTerminal, isAuditableFile } from '../utils/performanceAuditor.js';
 export async function verifyChangedFiles(workspaceRoot, filePaths, abortSignal) {
     if (filePaths.length === 0)
-        return null;
+        return { errors: null, warnings: null };
     const errors = [];
-    // Project-level build check (e.g., npm run build)
+    const perfAudits = [];
+    // 1. Project-level build check (e.g., npm run build)
     const buildResult = await runVerification(workspaceRoot, abortSignal);
     if (buildResult && !buildResult.success) {
         if (buildResult.aborted) {
@@ -118,5 +235,35 @@ export async function verifyChangedFiles(workspaceRoot, filePaths, abortSignal)
         const buildErrorMsg = `[Build Error: ${buildResult.command}]\n${buildResult.errors.join('\n').substring(0, 5000)}`;
         errors.push(buildErrorMsg);
     }
-    return errors.length > 0 ? errors.join('\n\n---\n\n') : null;
+    // 2. Performance Audit
+    // We run this even if the build failed, so the model gets all feedback at once
+    for (const file of filePaths) {
+        if (abortSignal?.aborted)
+            return '[Verification Aborted]';
+        if (!isAuditableFile(file))
+            continue;
+        try {
+            const absolutePath = path.resolve(workspaceRoot, file);
+            const content = await fs.readFile(absolutePath, 'utf-8');
+            const audit = auditFilePerformance(content, file);
+            if (audit.findings.length > 0) {
+                perfAudits.push(audit);
+            }
+        }
+        catch (err) {
+            debugLog(`Failed to audit performance for ${file}: ${err}`);
+        }
+    }
+    // Extract blocking performance errors (Severity: ERROR)
+    const perfModelPrompt = formatAuditForModel(perfAudits);
+    if (perfModelPrompt) {
+        errors.push(perfModelPrompt);
+    }
+    // Extract non-blocking performance warnings for the terminal (Severity: WARNING | INFO)
+    // We only show terminal warnings for files that actually had warnings or info (ignoring files that only had errors)
+    const terminalWarnings = formatAuditForTerminal(perfAudits.filter((a) => a.warnings.length > 0 || a.infos.length > 0));
+    return {
+        errors: errors.length > 0 ? errors.join('\n\n---\n\n') : null,
+        warnings: terminalWarnings || null,
+    };
 }

package/dist/utils/performanceAuditor.d.ts

@@ -0,0 +1,42 @@
+export type PerfSeverity = 'ERROR' | 'WARNING' | 'INFO';
+export interface PerfFinding {
+    severity: PerfSeverity;
+    code: string;
+    line: number;
+    message: string;
+    suggestion: string;
+}
+export interface PerfAuditResult {
+    filePath: string;
+    findings: PerfFinding[];
+    errors: PerfFinding[];
+    warnings: PerfFinding[];
+    infos: PerfFinding[];
+}
+/**
+ * Returns true if the file extension is supported by the performance auditor.
+ */
+export declare function isAuditableFile(filePath: string): boolean;
+/**
+ * Scans source code for performance anti-patterns using language-aware
+ * regex-based heuristics. Returns structured findings grouped by severity.
+ *
+ * This function is designed to be called inline during the verification
+ * phase — it's synchronous, zero-dependency, and executes in <50ms on
+ * files up to 10,000 lines.
+ *
+ * @param content - The raw source code string to audit.
+ * @param filePath - The file path (used for language detection via extension).
+ * @returns A structured audit result with findings separated by severity.
+ */
+export declare function auditFilePerformance(content: string, filePath: string): PerfAuditResult;
+/**
+ * Formats audit findings for beautiful terminal display using picocolors.
+ * Used for non-blocking warnings shown to the user after verification.
+ */
+export declare function formatAuditForTerminal(results: PerfAuditResult[]): string;
+/**
+ * Formats audit findings into a structured prompt for the AI auto-correction loop.
+ * Only includes ERROR-severity findings (warnings and info are non-blocking).
+ */
+export declare function formatAuditForModel(results: PerfAuditResult[]): string;