agent-enderun 1.1.5 → 1.1.7

package/framework-mcp/src/tools/search/grep_search.ts

@@ -0,0 +1,66 @@
+import fs from "fs";
+import path from "path";
+import { safePath } from "../../utils/security.js";
+import { ToolArgs, ToolResult } from "../types.js";
+
+/**
+ * Searches for a regex pattern within files in the project.
+ */
+export function handleGrepSearch(projectRoot: string, args: ToolArgs): ToolResult {
+    const pattern = args.pattern as string;
+    const includePattern = args.includePattern as string || ""; // e.g., ".ts"
+    const excludePattern = args.excludePattern as string || "node_modules";
+    
+    if (!pattern) {
+        throw new Error("Search pattern is required.");
+    }
+
+    const results: string[] = [];
+    const regex = new RegExp(pattern, "g");
+
+    const walk = (dir: string) => {
+        const files = fs.readdirSync(dir);
+        for (const file of files) {
+            const fullPath = path.join(dir, file);
+            const relativePath = path.relative(projectRoot, fullPath);
+
+            // Skip excluded directories/files
+            if (relativePath.includes(excludePattern)) continue;
+
+            try {
+                const stat = fs.statSync(fullPath);
+                if (stat.isDirectory()) {
+                    walk(fullPath);
+                } else if (stat.isFile()) {
+                    // Check include pattern
+                    if (includePattern && !file.endsWith(includePattern)) continue;
+
+                    const content = fs.readFileSync(fullPath, "utf8");
+                    const lines = content.split("\n");
+                    lines.forEach((line, index) => {
+                        if (regex.test(line)) {
+                            results.push(`${relativePath}:${index + 1}: ${line.trim()}`);
+                            // Reset regex lastIndex because of 'g' flag
+                            regex.lastIndex = 0;
+                        }
+                    });
+                }
+            } catch {
+                // Ignore read errors
+            }
+            
+            if (results.length > 100) break; // Limit results
+        }
+    };
+
+    walk(projectRoot);
+
+    return {
+        content: [{
+            type: "text",
+            text: results.length > 0 
+                ? `Found ${results.length} matches:\n\n${results.join("\n")}`
+                : "No matches found."
+        }]
+    };
+}

package/framework-mcp/src/tools/search/list_dir.ts

@@ -0,0 +1,34 @@
+import fs from "fs";
+import path from "path";
+import { safePath } from "../../utils/security.js";
+import { ToolArgs, ToolResult } from "../types.js";
+
+/**
+ * Lists the contents of a directory.
+ */
+export function handleListDir(projectRoot: string, args: ToolArgs): ToolResult {
+    const dirPath = safePath(projectRoot, args.path as string || ".");
+    
+    if (!fs.existsSync(dirPath)) {
+        throw new Error(`Directory not found: ${args.path}`);
+    }
+
+    const stats = fs.statSync(dirPath);
+    if (!stats.isDirectory()) {
+        throw new Error(`Path is not a directory: ${args.path}`);
+    }
+
+    const files = fs.readdirSync(dirPath);
+    const results = files.map(file => {
+        const fullPath = path.join(dirPath, file);
+        const isDir = fs.statSync(fullPath).isDirectory();
+        return `${isDir ? "[DIR] " : "      "}${file}`;
+    });
+
+    return {
+        content: [{
+            type: "text",
+            text: `Directory listing for ${args.path || "."}:\n\n${results.join("\n")}`
+        }]
+    };
+}

package/framework-mcp/src/tools/types.ts

@@ -3,7 +3,7 @@ export interface ToolDefinition {
     description: string;
     inputSchema: {
         type: "object";
-        properties: Record<string, { type: string; description?: string; enum?: string[] }>;
+        properties: Record<string, any>;
         required?: string[];
     };
 }
@@ -36,6 +36,16 @@ export interface ToolArgs {
     timeout?: number;
     from?: string;
     priority?: "HIGH" | "NORMAL" | "LOW";
+    // Added for new tools
+    port?: number;
+    pattern?: string;
+    includePattern?: string;
+    excludePattern?: string;
+    maxDepth?: number;
+    includeFiles?: boolean;
+    edits?: any[];
+    command?: string;
+    filter?: string;
 }
 
 export interface ToolResult {

package/framework-mcp/src/utils/compliance.ts

@@ -0,0 +1,37 @@
+/**
+ * Enterprise Compliance Guardrail
+ * Checks content against corporate standards before allowing file mutations.
+ */
+export function verifyCorporateCompliance(content: string, filePath: string): void {
+    // 1. Zero Console Policy
+    if (content.includes("console.log(") || content.includes("console.warn(") || content.includes("console.error(")) {
+        if (!filePath.includes("logger.ts") && !filePath.includes("check.ts") && !filePath.includes("cli.ts")) {
+            throw new Error(
+                "❌ Corporate Compliance Breach: 'console.log/warn/error' usage is forbidden. " +
+                "Use the 'logger' system from '@/shared/logger' instead."
+            );
+        }
+    }
+
+    // 2. No Explicit Any Policy
+    const anyRegex = /[:<]\s*any\b|\bas\s+any\b/g;
+    if (anyRegex.test(content)) {
+        if (!filePath.includes("definitions.ts") && !filePath.includes("types.ts")) {
+            throw new Error(
+                "❌ Corporate Compliance Breach: 'any' type is forbidden. " +
+                "Use 'unknown', 'generics', or proper interfaces for type safety."
+            );
+        }
+    }
+
+    // 3. Hardcoded Secrets Guard (Simple heuristic)
+    const secretKeywords = [/API_KEY\s*=\s*['"][^'"]+['"]/i, /SECRET\s*=\s*['"][^'"]+['"]/i, /PASSWORD\s*=\s*['"][^'"]+['"]/i];
+    for (const regex of secretKeywords) {
+        if (regex.test(content) && !filePath.endsWith(".env.example")) {
+            throw new Error(
+                "❌ Corporate Compliance Breach: Hardcoded secrets detected. " +
+                "All sensitive data must be managed via '.env' files."
+            );
+        }
+    }
+}

package/framework-mcp/tests/tools/messaging/send_message.test.ts

@@ -6,7 +6,7 @@ import { ToolArgs } from "../../../src/tools/types.js";
 
 const TEST_DIR = path.resolve(__dirname, "../../_temp_messaging_tests");
 const MESSAGES_DIR = path.join(TEST_DIR, ".gemini/messages");
-const LOCK_FILE = path.join(MESSAGES_DIR, ".lock");
+const BACKEND_LOCK_FILE = path.join(MESSAGES_DIR, "backend.lock");
 
 beforeEach(() => {
     fs.mkdirSync(TEST_DIR, { recursive: true });
@@ -56,7 +56,7 @@ describe("Hermes Lock Protocol & Message sending", () => {
     it("should retry and fail to send message if lock is kept busy", async () => {
         // Prepare a busy lock file
         fs.mkdirSync(MESSAGES_DIR, { recursive: true });
-        fs.writeFileSync(LOCK_FILE, "Locked by @test at " + new Date().toISOString(), "utf8");
+        fs.writeFileSync(BACKEND_LOCK_FILE, "Locked by @test at " + new Date().toISOString(), "utf8");
 
         const args: ToolArgs = {
             to: "@backend",
@@ -79,9 +79,9 @@ describe("Hermes Lock Protocol & Message sending", () => {
     it("should bypass and acquire lock if existing lock is stale (older than 5s)", async () => {
         fs.mkdirSync(MESSAGES_DIR, { recursive: true });
         // Set lock file mtime to 10 seconds ago
-        fs.writeFileSync(LOCK_FILE, "Locked by @test at " + new Date().toISOString(), "utf8");
+        fs.writeFileSync(BACKEND_LOCK_FILE, "Locked by @test at " + new Date().toISOString(), "utf8");
         const tenSecondsAgo = new Date(Date.now() - 10000);
-        fs.utimesSync(LOCK_FILE, tenSecondsAgo, tenSecondsAgo);
+        fs.utimesSync(BACKEND_LOCK_FILE, tenSecondsAgo, tenSecondsAgo);
 
         const args: ToolArgs = {
             to: "@backend",
@@ -93,7 +93,7 @@ describe("Hermes Lock Protocol & Message sending", () => {
 
         const result = await handleSendAgentMessage(TEST_DIR, args);
         expect(result.content[0].text).toContain("✅ Message sent to @backend");
-        expect(fs.existsSync(LOCK_FILE)).toBe(false); // Lock should have been unlinked in finally
+        expect(fs.existsSync(BACKEND_LOCK_FILE)).toBe(false); // Lock should have been unlinked in finally
     });
 
     it("should safely resolve concurrent messages and execute them in sequence", async () => {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "agent-enderun",
-  "version": "1.1.5",
-  "description": "The Supreme AI Governance & Orchestration Framework for Enterprise Development",
+  "version": "1.1.7",
+  "description": "The Supreme AI Governance & Autonomous Orchestration Framework for Enterprise Development. Acts as a Corporate AL Management Assistant.",
   "author": "Yusuf BEKAR",
   "license": "MIT",
   "readme": "README.md",
@@ -84,7 +84,7 @@
     "vitest": "^4.1.7"
   },
   "enderun": {
-    "version": "1.1.5",
+    "version": "1.1.6",
     "initializedAt": "2026-06-04T18:51:28.970Z",
     "frameworkDir": ".gemini"
   },

package/src/cli/adapters/types.ts

@@ -11,6 +11,6 @@ export interface AdapterConfig {
   role: AdapterRole;
   templateDir: ".enderun";
   nestedDirs?: string[];
-  rulesDir?: string; // Directory to write individual rules, relative to projectRoot
-  rulesExt?: string; // Extensions for rules files (.md or .mdc)
+  agentsDir?: string; // Directory to write individual agents/rules, relative to projectRoot
+  agentsExt?: string; // Extensions for agent files (.md or .mdc)
 }

package/src/cli/adapters.ts

@@ -2,35 +2,18 @@ import path from "path";
 import fs from "fs";
 import { writeJsonFile } from "./utils/fs.js";
 import { getPackageRoot } from "./utils/pkg.js";
-import { ALL_AGENTS } from "../modules/agents/definitions.js";
+import { UI } from "./utils/ui.js";
+import { ALL_AGENTS, buildAgentJson } from "../modules/agents/definitions.js";
+import { logger } from "../shared/logger.js";
 
 import type { AdapterId, AdapterConfig } from "./adapters/types.js";
 export { ADAPTER_IDS, type AdapterId, type AdapterRole, type AdapterConfig } from "./adapters/types.js";
 
-import * as gemini from "../modules/adapters/gemini.js";
-import * as claude from "../modules/adapters/claude.js";
-import * as grok from "../modules/adapters/grok.js";
-import * as cursor from "../modules/adapters/cursor.js";
-import * as codex from "../modules/adapters/codex.js";
-import * as antigravityCli from "../modules/adapters/antigravity-cli.js";
-
-export const ADAPTERS: Record<AdapterId, AdapterConfig> = {
-    gemini: gemini.config,
-    claude: claude.config,
-    grok: grok.config,
-    cursor: cursor.config,
-    codex: codex.config,
-    "antigravity-cli": antigravityCli.config,
-};
-
-const POST_INIT_MAP: Record<AdapterId, (projectRoot: string, mcpBlock: unknown) => void> = {
-    gemini: gemini.postInit,
-    claude: claude.postInit,
-    grok: grok.postInit,
-    cursor: cursor.postInit,
-    codex: codex.postInit,
-    "antigravity-cli": antigravityCli.postInit,
-};
+import { ADAPTER_CONFIGS, POST_INIT_HANDLERS } from "../modules/adapters/definitions.js";
+
+export const ADAPTERS: Record<AdapterId, AdapterConfig> = ADAPTER_CONFIGS;
+
+const POST_INIT_MAP: Record<AdapterId, (projectRoot: string, mcpBlock: unknown) => void> = POST_INIT_HANDLERS;
 
 export const FRAMEWORK_DIR_CANDIDATES = [
     ".enderun",
@@ -60,41 +43,10 @@ export function resolveAdapter(input?: string): AdapterConfig {
     if (normalized in ADAPTERS) {
         config = { ...ADAPTERS[normalized as AdapterId] };
     } else {
-        console.warn(`⚠️  Unknown adapter "${input}". Falling back to gemini.`);
+        UI.warning(`Unknown adapter "${input}". Falling back to gemini.`);
         config = { ...ADAPTERS.gemini };
     }
 
-    const targetDir = process.cwd();
-    const enderunExists = fs.existsSync(path.join(targetDir, ".enderun"));
-    const hasUnifiedFlag = process.argv.includes("--unified");
-    const isTesting = process.env.VITEST === "true" || process.env.NODE_ENV === "test";
-    
-    let forceEnderun = (enderunExists && !isTesting) || hasUnifiedFlag;
-    try {
-        const pkgPath = path.join(targetDir, "package.json");
-        if (fs.existsSync(pkgPath)) {
-            const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
-            if (pkg.enderun && (pkg.enderun.frameworkDir === ".enderun" || pkg.enderun.frameworkDir === "unified")) {
-                if (isTesting && config.frameworkDir !== ".enderun") {
-                    if (config.id !== "cursor" && config.id !== "codex") {
-                        forceEnderun = false;
-                    } else {
-                        forceEnderun = true;
-                    }
-                } else {
-                    forceEnderun = true;
-                }
-            }
-        }
-    } catch {
-        // ignore
-    }
-
-    if (forceEnderun) {
-        config.frameworkDir = ".enderun";
-        config.nestedDirs = ["agents", "skills", "knowledge"];
-    }
-
     return config;
 }
 
@@ -147,8 +99,8 @@ export function remapFrameworkContent(
                 if (config.paths.tests) tests = config.paths.tests;
             }
         }
-    } catch {
-        // ignore
+    } catch (err) {
+        logger.debug("Failed to read config.json in remapFrameworkContent", err);
     }
 
     result = result.replace(/\{\{BACKEND_DIR\}\}/g, backend);
@@ -169,15 +121,15 @@ export function buildMcpServerEntry(projectRoot: string) {
     };
 }
 
-export function generateAdapterAgentRules(projectRoot: string, frameworkDir: string, adapterId: AdapterId): void {
+export function scaffoldAgents(projectRoot: string, adapterId: AdapterId, dryRun: boolean): void {
     const adapter = ADAPTERS[adapterId];
-    if (!adapter || !adapter.rulesDir || !adapter.rulesExt) return;
+    if (!adapter || !adapter.agentsDir || !adapter.agentsExt) return;
 
-    const destRulesDir = path.join(projectRoot, adapter.rulesDir);
-    const fileExt = adapter.rulesExt;
+    const destAgentsDir = path.join(projectRoot, adapter.agentsDir);
+    const fileExt = adapter.agentsExt;
 
     try {
-        fs.mkdirSync(destRulesDir, { recursive: true });
+        if (!dryRun) fs.mkdirSync(destAgentsDir, { recursive: true });
 
         const GLOB_MAP: Record<string, string> = {
             backend: "apps/backend/**/*",
@@ -200,11 +152,17 @@ export function generateAdapterAgentRules(projectRoot: string, frameworkDir: str
             const description = agent.description || "";
             const systemPrompt = agent.instructions || "";
             const glob = GLOB_MAP[name] || "*";
-            const ruleDestPath = path.join(destRulesDir, `${name}${fileExt}`);
 
-            let mdcContent: string;
+            // Support nested format for Antigravity-CLI standard if needed
+            const isAntigravity = adapterId === "antigravity-cli";
+            const agentDir = isAntigravity ? path.join(destAgentsDir, name) : destAgentsDir;
+            const agentFileName = isAntigravity ? "agent.md" : `${name}${fileExt}`;
+            
+            if (isAntigravity && !dryRun) fs.mkdirSync(agentDir, { recursive: true });
+
+            let content: string;
             if (fileExt === ".mdc") {
-                mdcContent = `---
+                content = `---
 description: Agent Enderun — @${name} rules for ${displayName}. ${description.slice(0, 100)}
 globs: ${glob}
 alwaysApply: false
@@ -215,9 +173,9 @@ alwaysApply: false
 You are the **${displayName}** of the Agent Enderun Army.
 
 ## 🏛️ Hierarchy of Authority
-1. **Supreme Law:** [\`${frameworkDir}/ENDERUN.md\`](\`${frameworkDir}/ENDERUN.md\`)
-2. **Global Rules:** [\`${frameworkDir}/knowledge/ARCHITECTURE.md\`](\`${frameworkDir}/knowledge/ARCHITECTURE.md\`), [\`${frameworkDir}/knowledge/SECURITY.md\`](\`${frameworkDir}/knowledge/SECURITY.md\`)
-3. **Project Memory:** [\`${frameworkDir}/memory/PROJECT_MEMORY.md\`](\`${frameworkDir}/memory/PROJECT_MEMORY.md\`)
+1. **Supreme Law:** [\`.enderun/ENDERUN.md\`](\`.enderun/ENDERUN.md\`)
+2. **Global Rules:** [\`.enderun/knowledge/architecture-standards.md\`](\`.enderun/knowledge/architecture-standards.md\`), [\`.enderun/knowledge/security-standards.md\`](\`.enderun/knowledge/security-standards.md\`)
+3. **Project Memory:** [\`.enderun/memory/PROJECT_MEMORY.md\`](\`.enderun/memory/PROJECT_MEMORY.md\`)
 
 ## 🤖 Specialist Directive (Role: @${name})
 ${systemPrompt}
@@ -227,15 +185,21 @@ ${systemPrompt}
 - **Traceability:** Inherit and pass the active Trace ID across all delegations.
 - **Approval Signature:** High-risk actions require manager approval signature.
 `;
+            } else if (isAntigravity) {
+                // Antigravity-CLI specific JSON
+                content = buildAgentJson(agent);
+                if (!dryRun) fs.writeFileSync(path.join(agentDir, "agent.json"), content);
+                // Also write MD rule
+                content = `# 🎖️ Agent Enderun — @${name} (${displayName})\n\n${systemPrompt}`;
             } else {
-                mdcContent = `# 🎖️ Agent Enderun — @${name} (${displayName})
+                content = `# 🎖️ Agent Enderun — @${name} (${displayName})
 
 You are the **${displayName}** of the Agent Enderun Army.
 
 ## 🏛️ Hierarchy of Authority
-1. **Supreme Law:** [\`${frameworkDir}/ENDERUN.md\`](\`${frameworkDir}/ENDERUN.md\`)
-2. **Global Rules:** [\`${frameworkDir}/knowledge/ARCHITECTURE.md\`](\`${frameworkDir}/knowledge/ARCHITECTURE.md\`), [\`${frameworkDir}/knowledge/SECURITY.md\`](\`${frameworkDir}/knowledge/SECURITY.md\`)
-3. **Project Memory:** [\`${frameworkDir}/memory/PROJECT_MEMORY.md\`](\`${frameworkDir}/memory/PROJECT_MEMORY.md\`)
+1. **Supreme Law:** [\`.enderun/ENDERUN.md\`](\`.enderun/ENDERUN.md\`)
+2. **Global Rules:** [\`.enderun/knowledge/architecture-standards.md\`](\`.enderun/knowledge/architecture-standards.md\`)
+3. **Project Memory:** [\`.enderun/memory/PROJECT_MEMORY.md\`](\`.enderun/memory/PROJECT_MEMORY.md\`)
 
 ## 🤖 Specialist Directive (Role: @${name})
 ${systemPrompt}
@@ -243,19 +207,20 @@ ${systemPrompt}
 ## 🛡️ Core Mandates
 - **Surgical Precision:** Enforce replace_text / replace_file_content for all code modifications.
 - **Traceability:** Inherit and pass the active Trace ID across all delegations.
-- **Approval Signature:** High-risk actions require manager approval signature.
 `;
             }
 
-            fs.writeFileSync(ruleDestPath, mdcContent);
+            if (!dryRun) {
+                const finalPath = isAntigravity ? path.join(agentDir, "agent.md") : path.join(agentDir, agentFileName);
+                fs.writeFileSync(finalPath, content);
+            }
         }
-        console.warn(`✅ Generated 13 Agent Rules under ${path.relative(projectRoot, destRulesDir)}/`);
+        console.warn(`✅ Generated 13 Agent/Rule definitions under ${path.relative(projectRoot, destAgentsDir)}/`);
     } catch (e) {
-        console.warn(`⚠️  Failed to generate Agent rules: ${e}`);
+        console.warn(`⚠️  Failed to scaffold agents: ${e}`);
     }
 }
 
-
 export function runAdapterPostInit(adapter: AdapterConfig, projectRoot: string): void {
     const mcpEntry = buildMcpServerEntry(projectRoot);
     const mcpBlock = { mcpServers: { "agent-enderun": mcpEntry } };
@@ -263,7 +228,7 @@ export function runAdapterPostInit(adapter: AdapterConfig, projectRoot: string):
     const postInitFn = POST_INIT_MAP[adapter.id];
     if (postInitFn) {
         postInitFn(projectRoot, mcpBlock);
-        generateAdapterAgentRules(projectRoot, adapter.frameworkDir, adapter.id);
+        // We handle agent scaffolding centrally now in initCommand
     }
 
     const rootMcpPath = path.join(projectRoot, "mcp.json");

package/src/cli/commands/check.ts

@@ -5,6 +5,7 @@ import { execSync } from "child_process";
 import { getFrameworkDir, getMemoryPath, getConfiguredPaths } from "../utils/memory.js";
 import { getPackageVersion, getValidatorPath } from "../utils/pkg.js";
 import { UI } from "../utils/ui.js";
+import { logger } from "../../shared/logger.js";
 
 const FRAMEWORK_VERSION = getPackageVersion();
 
@@ -40,8 +41,8 @@ export function checkCommand() {
                 isFrameworkDevelopment = true;
             }
         }
-    } catch {
-        // ignore
+    } catch (err) {
+        logger.debug("Failed to read package.json in checkCommand", err);
     }
 
     const checks = [
@@ -53,6 +54,17 @@ export function checkCommand() {
         { name: "MCP Config (mcp.json)", path: "mcp.json" },
         { name: "ESLint Config (eslint.config.js)", path: "eslint.config.js", optional: !isFrameworkDevelopment },
         { name: "ESLint Standards", path: path.join(frameworkDir, `${knowledgeDir}/eslint-standards.md`) },
+        { name: "CRUD Governance Standards", path: path.join(frameworkDir, `${knowledgeDir}/crud-governance.md`) },
+        { name: "Architecture Standards", path: path.join(frameworkDir, `${knowledgeDir}/architecture-standards.md`) },
+        { name: "Frontend Standards", path: path.join(frameworkDir, `${knowledgeDir}/frontend-standards.md`) },
+        { name: "Tailwind Standards", path: path.join(frameworkDir, `${knowledgeDir}/tailwind-standards.md`), optional: true },
+        { name: "Mobile Standards", path: path.join(frameworkDir, `${knowledgeDir}/mobile-standards.md`) },
+        { name: "Security Standards", path: path.join(frameworkDir, `${knowledgeDir}/security-standards.md`) },
+        { name: "Quality & Discipline Standards", path: path.join(frameworkDir, `${knowledgeDir}/quality-standards.md`) },
+        { name: "Logging & Secrets Standards", path: path.join(frameworkDir, `${knowledgeDir}/logging-and-secrets.md`) },
+        { name: "Testing Standards", path: path.join(frameworkDir, `${knowledgeDir}/testing-standards.md`) },
+        { name: "i18n Standards", path: path.join(frameworkDir, `${knowledgeDir}/i18n-standards.md`) },
+        { name: ".env.example", path: ".env.example" },
         ...(isFrameworkDevelopment ? [{ name: "MCP Server", path: "framework-mcp/package.json" }] : []),
         { name: "Panda CSS Config", path: appPandaPath, optional: true },
         { name: "Brain Dashboard", path: path.join(frameworkDir, "BRAIN_DASHBOARD.md") },
@@ -95,6 +107,14 @@ export function checkCommand() {
         UI.success("No forbidden 'console.log' detected.");
     }
 
+    const anyUsageIssues = checkAnyUsage();
+    if (anyUsageIssues.length > 0) {
+        UI.error(`Forbidden 'any' type usage found in ${anyUsageIssues.length} locations.`);
+        issues++;
+    } else {
+        UI.success("No forbidden 'any' type usage detected.");
+    }
+
     const rootTestFiles = checkRootTestFiles();
     if (rootTestFiles.length > 0) {
         UI.warning(`Test files found in the root directory: ${rootTestFiles.join(", ")}. It is recommended to place all test files under the 'tests/' folder or application-specific directories.`);
@@ -103,8 +123,9 @@ export function checkCommand() {
     try {
         execSync("npx tsc --noEmit", { stdio: "pipe" });
         UI.success("TypeScript type check PASSED.");
-    } catch {
+    } catch (err) {
         UI.error("TypeScript type check FAILED.");
+        logger.debug("npx tsc --noEmit check failed", err);
         issues++;
     }
 
@@ -146,8 +167,9 @@ export function checkCommand() {
             } else {
                 console.warn("\n📊  Token Consumption Report: No token usage logged yet.");
             }
-        } catch {
+        } catch (err) {
             console.warn("\n📊  Token Consumption Report: Could not read or parse metrics file.");
+            logger.debug("Failed to read or parse metrics.json in checkCommand", err);
         }
     } else {
         console.warn("\n📊  Token Consumption Report: No token usage logged yet.");
@@ -184,6 +206,30 @@ function checkConsoleLogs(): string[] {
     return issues;
 }
 
+function checkAnyUsage(): string[] {
+    const issues: string[] = [];
+    const srcDir = path.join(process.cwd(), "src");
+    if (!fs.existsSync(srcDir)) return [];
+    
+    const walk = (dir: string) => {
+        const files = fs.readdirSync(dir);
+        for (const file of files) {
+            const fullPath = path.join(dir, file);
+            if (fs.statSync(fullPath).isDirectory()) walk(fullPath);
+            else if (file.endsWith(".ts") && !file.includes(".test.")) {
+                const content = fs.readFileSync(fullPath, "utf8");
+                // Match ": any", "<any>", "as any" but try to avoid false positives in comments if possible
+                const anyRegex = /[:<]\s*any\b|\bas\s+any\b/g;
+                if (anyRegex.test(content) && !fullPath.includes("check.ts") && !fullPath.includes("definitions.ts")) {
+                    issues.push(fullPath);
+                }
+            }
+        }
+    };
+    walk(srcDir);
+    return issues;
+}
+
 function checkRootTestFiles(): string[] {
     const rootDir = process.cwd();
     if (!fs.existsSync(rootDir)) return [];
@@ -197,8 +243,8 @@ function checkRootTestFiles(): string[] {
                     testFiles.push(file);
                 }
             }
-        } catch {
-            // Ignore stat errors for broken symlinks or permission issues
+        } catch (err) {
+            logger.debug(`Failed to stat file ${fullPath} in checkRootTestFiles`, err);
         }
     }
     return testFiles;