minovative-mind-cli 2.4.0 → 2.5.0

package/dist/services/metrics.d.ts

@@ -16,15 +16,13 @@ export interface MetricCollector {
     recordSelfCorrection(): void;
     recordVerificationResult(passed: boolean): void;
     recordMatchTier(tier: 'exact' | 'normalized' | 'levenshtein' | 'none'): void;
-    recordCacheHit(): void;
-    recordCacheMiss(): void;
-    recordInvestigationFailure(): void;
-    recordToolFailure(toolName: string): void;
-    recordModifyFailure(): void;
-    recordWriteFailure(): void;
-    recordCacheHit(cacheType: 'investigation' | 'read'): void;
-    recordCacheMiss(cacheType: 'investigation' | 'read'): void;
+    recordCacheHit(cacheType?: 'investigation' | 'read'): void;
+    recordCacheMiss(cacheType?: 'investigation' | 'read'): void;
     recordCachePerformance(cacheType: 'investigation' | 'read', durationMs: number): void;
+    recordWriteFailure?(): void;
+    recordModifyFailure?(): void;
+    recordToolFailure?(toolName?: string): void;
+    recordInvestigationFailure?(): void;
 }
 export declare function setMetricCollector(collector: MetricCollector | null): void;
 export declare function getMetricCollector(): MetricCollector | null;

package/dist/services/orchestration/investigationAgent.js

@@ -113,9 +113,6 @@ export class InvestigationAgentRunner {
             }
             currentMessage += `\n\nStart investigating to find relevant files within your assigned domains.`;
             let isFinished = false;
-            const visitedToolCalls = new Set();
-            let consecutiveDuplicates = 0;
-            const MAX_CONSECUTIVE_DUPLICATES = 3;
             // Tool loop — mirrors the existing context agent loop in contextAgent.ts
             while (!crashed && !abortSignal.aborted && !isFinished) {
                 this.pingHeartbeat();
@@ -143,35 +140,6 @@ export class InvestigationAgentRunner {
                     this.pingHeartbeat();
                     const args = call.args;
                     const logPrefix = `[${this.agentLabel}]`;
-                    // Deduplicate identical tool calls
-                    const callSignature = `${call.name}:${JSON.stringify(args)}`;
-                    if (call.name !== 'finish_investigation' && visitedToolCalls.has(callSignature)) {
-                        consecutiveDuplicates++;
-                        if (consecutiveDuplicates >= MAX_CONSECUTIVE_DUPLICATES) {
-                            // Force-finish: the model is stuck in a loop
-                            const forceMsg = `Investigation auto-completed: the model repeated the same tool call ${MAX_CONSECUTIVE_DUPLICATES} times consecutively.`;
-                            debugLog(`InvestigationAgent [${this.agentLabel}]: ${forceMsg}`);
-                            if (onProgress)
-                                onProgress(`[${this.agentLabel}] ${forceMsg}`);
-                            if (!summary || summary === 'No relevant context found.') {
-                                summary = 'Investigation was auto-completed due to repeated duplicate tool calls. Review the gathered files for context.';
-                            }
-                            isFinished = true;
-                            success = relevantFiles.size > 0;
-                            break;
-                        }
-                        functionResponses.push({
-                            functionResponse: {
-                                name: call.name,
-                                response: {
-                                    error: `DUPLICATE CALL BLOCKED (attempt ${consecutiveDuplicates}/${MAX_CONSECUTIVE_DUPLICATES}): You already executed this exact tool call. Do NOT retry it. Use the results you already have and call finish_investigation now, or try a DIFFERENT tool call with different parameters.`,
-                                },
-                            },
-                        });
-                        continue;
-                    }
-                    consecutiveDuplicates = 0;
-                    visitedToolCalls.add(callSignature);
                     if (call.name === 'finish_investigation') {
                         summary = args.summary || '';
                         const filesToRead = args.relevantFiles || [];

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 {
     /**

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/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,7 +46,6 @@ export class ReadCache {
      */
     has(filePath) {
         const found = this.cache.has(filePath);
-        const { getMetricCollector } = require('./metrics.js');
         const collector = getMetricCollector();
         if (found) {
             this.hitCount++;

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/syntaxValidator.js

@@ -1,9 +1,20 @@
 import * as path from 'node:path';
+const C_STYLE_EXTS = new Set([
+    '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.mts', '.cts',
+    '.css', '.scss', '.sass', '.less', '.vue', '.svelte',
+    '.java', '.kt', '.kts', '.swift', '.cs',
+    '.cpp', '.c', '.h', '.hpp', '.cc', '.cxx', '.hh', '.hxx',
+    '.go', '.rs', '.php', '.dart',
+]);
+const PYTHON_EXTS = new Set(['.py', '.pyi']);
+const HASH_STYLE_EXTS = new Set(['.yaml', '.yml', '.toml', '.sh', '.bash', '.zsh', '.env']);
 export function validateSyntax(content, filePath) {
     const ext = path.extname(filePath).toLowerCase();
+    const fileName = path.basename(filePath).toLowerCase();
     const errors = [];
-    // Fast check for truncation markers from AI
-    if (/(\/\/|\/\*)\s*\.\.\./.test(content) || /<!--\s*\.\.\.\s*-->/.test(content)) {
+    // Fast check for standalone truncation markers from AI (e.g., lines containing only "// ...")
+    if (/^\s*(\/\/|\/\*|#)\s*\.\.\.\s*(\*\/)?\s*$/m.test(content) ||
+        /^\s*<!--\s*\.\.\.\s*-->\s*$/m.test(content)) {
         errors.push('File contains a truncation marker (e.g., "// ..."). Please output the complete file content without truncating.');
     }
     // Language specific checks
@@ -14,11 +25,25 @@ export function validateSyntax(content, filePath) {
         catch (err) {
             errors.push(`Invalid JSON syntax: ${err instanceof Error ? err.message : String(err)}`);
         }
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
     }
-    else if (['.ts', '.tsx', '.js', '.jsx', '.css', '.scss'].includes(ext)) {
-        const braceBalance = countBalance(content, '{', '}');
-        const bracketBalance = countBalance(content, '[', ']');
-        const parenBalance = countBalance(content, '(', ')');
+    let family = 'none';
+    if (C_STYLE_EXTS.has(ext)) {
+        family = 'c-style';
+    }
+    else if (PYTHON_EXTS.has(ext)) {
+        family = 'python';
+    }
+    else if (HASH_STYLE_EXTS.has(ext) || fileName === 'dockerfile' || fileName === 'makefile') {
+        family = 'hash-style';
+    }
+    if (family !== 'none') {
+        const braceBalance = countBalance(content, '{', '}', family);
+        const bracketBalance = countBalance(content, '[', ']', family);
+        const parenBalance = countBalance(content, '(', ')', family);
         if (braceBalance > 0)
             errors.push(`Unmatched opening brace '{' (missing ${braceBalance} closing braces)`);
         if (braceBalance < 0)
@@ -37,41 +62,120 @@ export function validateSyntax(content, filePath) {
         errors,
     };
 }
-function countBalance(text, openChar, closeChar) {
+function countBalance(text, openChar, closeChar, lang) {
     let balance = 0;
-    let inString = false;
-    let stringChar = '';
+    let stringStack = [];
+    let inRegex = false;
+    let inCharClass = false;
+    let lastCodeChar = '';
     for (let i = 0; i < text.length; i++) {
         const char = text[i];
-        // Skip string contents
-        if (inString) {
+        const topString = stringStack[stringStack.length - 1];
+        if (topString && topString !== '${') {
+            if (char === '\\') {
+                i++; // Skip escaped character
+                continue;
+            }
+            // Handle Triple Quotes in Python
+            if (topString === '"""' || topString === "'''") {
+                if (text.slice(i, i + 3) === topString) {
+                    stringStack.pop();
+                    i += 2;
+                }
+                continue;
+            }
+            if (char === topString) {
+                stringStack.pop();
+                continue;
+            }
+            if (topString === '`' && char === '$' && text[i + 1] === '{') {
+                stringStack.push('${');
+                i++; // Skip {
+                continue;
+            }
+            if (char === '\n' && topString !== '`') {
+                // Single-line strings reset on newline
+                stringStack.pop();
+            }
+            continue;
+        }
+        if (topString === '${') {
+            if (char === '}') {
+                stringStack.pop();
+                continue;
+            }
+            // Fall through to normal code parsing inside ${...}
+        }
+        if (inRegex) {
             if (char === '\\') {
                 i++; // Skip escaped character
                 continue;
             }
-            if (char === stringChar) {
-                inString = false;
+            if (char === '\n') {
+                inRegex = false;
+                inCharClass = false;
+                continue;
+            }
+            if (char === '[' && !inCharClass) {
+                inCharClass = true;
+                continue;
+            }
+            if (char === ']' && inCharClass) {
+                inCharClass = false;
+                continue;
+            }
+            if (char === '/' && !inCharClass) {
+                inRegex = false;
+                continue;
             }
             continue;
         }
-        // Entering a string
-        if (char === '"' || char === "'" || char === '`') {
-            inString = true;
-            stringChar = char;
+        // Hash comments (Python, Shell, YAML, etc.)
+        if ((lang === 'python' || lang === 'hash-style') && char === '#') {
+            const nextLine = text.indexOf('\n', i);
+            i = nextLine !== -1 ? nextLine : text.length;
             continue;
         }
-        // Basic comment skipping
-        if (char === '/' && text[i + 1] === '/') {
+        // C-style single-line comment
+        if (lang === 'c-style' && char === '/' && text[i + 1] === '/') {
             const nextLine = text.indexOf('\n', i);
             i = nextLine !== -1 ? nextLine : text.length;
             continue;
         }
-        // Block comment skip
-        if (char === '/' && text[i + 1] === '*') {
+        // C-style block comment
+        if (lang === 'c-style' && char === '/' && text[i + 1] === '*') {
             const nextEnd = text.indexOf('*/', i + 2);
             i = nextEnd !== -1 ? nextEnd + 1 : text.length;
             continue;
         }
+        // HTML block comment
+        if (char === '<' && text.slice(i, i + 4) === '<!--') {
+            const nextEnd = text.indexOf('-->', i + 4);
+            i = nextEnd !== -1 ? nextEnd + 2 : text.length;
+            continue;
+        }
+        // Python triple quotes
+        if (lang === 'python' && (text.slice(i, i + 3) === '"""' || text.slice(i, i + 3) === "'''")) {
+            stringStack.push(text.slice(i, i + 3));
+            i += 2;
+            continue;
+        }
+        // Entering string
+        if (char === '"' || char === "'" || (lang === 'c-style' && char === '`')) {
+            stringStack.push(char);
+            continue;
+        }
+        // Entering regex (C-style)
+        if (lang === 'c-style' && char === '/') {
+            if (!lastCodeChar || /[=+(,;:!&|?~^<{[-]+/.test(lastCodeChar)) {
+                inRegex = true;
+                inCharClass = false;
+                continue;
+            }
+        }
+        if (!/\s/.test(char)) {
+            lastCodeChar = char;
+        }
         if (char === openChar)
             balance++;
         else if (char === closeChar)