agent-enderun 1.1.1 → 1.1.3

package/src/cli/adapters.ts

@@ -1,106 +1,62 @@
 import path from "path";
 import fs from "fs";
+import { writeJsonFile } from "./utils/fs.js";
+import { getPackageRoot } from "./utils/pkg.js";
 
-import { findClaudeConfigPath, addMcpServerToClaude } from "./utils/claude.js";
-import { writeJsonFile, writeTextFile } from "./utils/fs.js";
-
-export const ADAPTER_IDS = ["gemini", "claude", "grok", "cursor", "codex", "antigravity", "antigravity-cli"] as const;
-export type AdapterId = (typeof ADAPTER_IDS)[number];
-
-export interface AdapterConfig {
-  id: AdapterId;
-  /** Runtime framework directory created by init */
-  frameworkDir: string;
-  /** Root shim file (e.g. gemini.md) */
-  shimFile: string;
-  /** Package template copied into frameworkDir */
-  templateDir: ".enderun";
-  /** Extra directories under frameworkDir (gemini only for nested auto-scaffold) */
-  nestedDirs?: string[];
-}
+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: {
-        id: "gemini",
-        frameworkDir: ".gemini",
-        shimFile: "gemini.md",
-        templateDir: ".enderun",
-        nestedDirs: ["agents", "skills", "knowledge"],
-    },
-    claude: {
-        id: "claude",
-        frameworkDir: ".claude",
-        shimFile: "CLAUDE.md",
-        templateDir: ".enderun",
-        nestedDirs: ["agents", "skills", "knowledge"],
-    },
-    cursor: {
-        id: "cursor",
-        frameworkDir: ".enderun",
-        shimFile: ".cursor/rules/global.mdc",
-        templateDir: ".enderun",
-        nestedDirs: ["agents", "skills", "knowledge"],
-    },
-    codex: {
-        id: "codex",
-        frameworkDir: ".enderun",
-        shimFile: ".github/copilot-instructions.md",
-        templateDir: ".enderun",
-        nestedDirs: ["agents", "skills", "knowledge"],
-    },
-    grok: {
-        id: "grok",
-        frameworkDir: ".grok",
-        shimFile: "grok.md",
-        templateDir: ".enderun",
-        nestedDirs: ["plugins", "agents", "knowledge"],
-    },
-    antigravity: {
-        id: "antigravity",
-        frameworkDir: ".agent",
-        shimFile: "agent.md",
-        templateDir: ".enderun",
-        nestedDirs: ["skills", "workflows", "rules", "knowledge"],
-    },
-    "antigravity-cli": {
-        id: "antigravity-cli",
-        frameworkDir: ".gemini/antigravity-cli",
-        shimFile: "agent.md",
-        templateDir: ".enderun",
-        nestedDirs: ["agents", "skills"],
-    },
+    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,
 };
 
-/** 
- * All framework runtime directories (for discovery). 
- * Verified against 2026 industry standards.
- * Includes .agent for direct antigravity adapter installs.
- */
 export const FRAMEWORK_DIR_CANDIDATES = [
     ".enderun",
+    ".cursor",
     ".claude",
+    ".github",
     ".grok",
+    ".windsurf",
+    ".antigravity",
     ".agent",
+    ".gemini/antigravity-cli",
     ".gemini",
-    ".agents", // Keep .agents for Antigravity-CLI compatibility
+    ".agents",
 ] as const;
 
-const SHIM_FILES = ADAPTER_IDS.map((id) => ADAPTERS[id].shimFile);
+const SHIM_FILES = (Object.keys(ADAPTERS) as AdapterId[]).map((id) => ADAPTERS[id].shimFile);
 
 export function resolveAdapter(input?: string): AdapterConfig {
     const normalized = (input || "gemini").toLowerCase() as AdapterId;
     let config: AdapterConfig;
-    if (ADAPTER_IDS.includes(normalized)) {
+    if (normalized in ADAPTERS) {
         config = { ...ADAPTERS[normalized] };
     } else {
-        console.warn(`⚠️  Unknown adapter "${input}". Falling back to gemini (.gemini/).`);
+        console.warn(`⚠️  Unknown adapter "${input}". Falling back to gemini.`);
         config = { ...ADAPTERS.gemini };
     }
 
-    // Dynamic Unified Mode Check:
-    // If a root `.enderun` folder exists, --unified flag is passed, or configured in package.json,
-    // we override `frameworkDir` to be `.enderun` to avoid folder clutter!
-    // We bypass the folder exists check if running unit tests (Vitest) to preserve test integrity.
     const targetDir = process.cwd();
     const enderunExists = fs.existsSync(path.join(targetDir, ".enderun"));
     const hasUnifiedFlag = process.argv.includes("--unified");
@@ -112,14 +68,11 @@ export function resolveAdapter(input?: string): AdapterConfig {
         if (fs.existsSync(pkgPath)) {
             const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
             if (pkg.enderun && (pkg.enderun.frameworkDir === ".enderun" || pkg.enderun.frameworkDir === "unified")) {
-                // Only force enderun if not testing a specific adapter that expects a different frameworkDir
                 if (isTesting && config.frameworkDir !== ".enderun") {
-                    // Do not force .enderun if we are testing adapters that expect a different frameworkDir
-                    // and this is not a 'unified' adapter.
                     if (config.id !== "cursor" && config.id !== "codex") {
                         forceEnderun = false;
                     } else {
-                        forceEnderun = true; // Still force if it's a unified adapter like cursor/codex
+                        forceEnderun = true;
                     }
                 } else {
                     forceEnderun = true;
@@ -132,7 +85,6 @@ export function resolveAdapter(input?: string): AdapterConfig {
 
     if (forceEnderun) {
         config.frameworkDir = ".enderun";
-        // Ensure standard folder names inside .enderun for universal access
         config.nestedDirs = ["agents", "skills", "knowledge"];
     }
 
@@ -150,34 +102,29 @@ export function remapFrameworkContent(
 ): string {
     let result = content;
 
-    // 1. Dynamic Agent Folder Mapping based on adapter (Only remap if NOT in unified .enderun mode)
+    result = result.replace(/\{\{FRAMEWORK_DIR\}\}/g, frameworkDir);
+    result = result.replace(/\{\{ADAPTER\}\}/g, adapterId);
+
     let agentFolder = "agents";
     let knowledgeFolder = "knowledge";
-    
+
     if (frameworkDir !== ".enderun") {
-        if (adapterId === "antigravity") {
-            agentFolder = "skills";
+        if (adapterId === "antigravity-cli") {
+            agentFolder = "agents";
             knowledgeFolder = "rules";
         } else if (adapterId === "grok") {
             agentFolder = "plugins";
         }
     }
 
-    // 2. Replacements
-    result = result.replace(/\{\{FRAMEWORK_DIR\}\}/g, frameworkDir);
-    result = result.replace(/\{\{ADAPTER\}\}/g, adapterId);
-    
-    // Replace standard patterns with adapter-specific ones
     const frameworkPattern = ".enderun/";
     result = result.replace(new RegExp(frameworkPattern + "agents/", "g"), `${frameworkDir}/${agentFolder}/`);
     result = result.replace(new RegExp(frameworkPattern + "knowledge/", "g"), `${frameworkDir}/${knowledgeFolder}/`);
-    
-    // Generic fallback for other .enderun/ paths
+
     result = result.replace(/\.enderun\//g, `${frameworkDir}/`);
     result = result.replace(/`\.enderun`/g, `\`${frameworkDir}\``);
     result = result.replace(/\.enderun(?![\w/-])/g, frameworkDir);
 
-    // Read config paths dynamically to map directory tokens
     let backend = "apps/backend";
     let frontend = "apps/web";
     let docs = "docs";
@@ -208,88 +155,115 @@ export function remapFrameworkContent(
 export function buildMcpServerEntry(projectRoot: string) {
     return {
         command: "node",
-        args: [path.join(projectRoot, "framework-mcp/dist/index.js")],
+        args: [path.join(getPackageRoot(), "framework-mcp/dist/index.js")],
         env: {
             ENDERUN_PROJECT_ROOT: projectRoot,
         },
     };
 }
 
-function writeAntigravityScaffold(frameworkDirPath: string): void {
-    const antigravityReadme = `# Antigravity IDE — Agent Enderun
+export function generateAdapterAgentRules(projectRoot: string, frameworkDir: string, adapterId: AdapterId): void {
+    const agentsDir = path.join(projectRoot, frameworkDir, "agents");
+    if (!fs.existsSync(agentsDir)) return;
+
+    const adapter = ADAPTERS[adapterId];
+    if (!adapter || !adapter.rulesDir || !adapter.rulesExt) return;
+
+    const destRulesDir = path.join(projectRoot, adapter.rulesDir);
+    const fileExt = adapter.rulesExt;
+
+    try {
+        fs.mkdirSync(destRulesDir, { recursive: true });
+        const files = fs.readdirSync(agentsDir).filter((f) => f.endsWith(".json") && f !== "agent_army_schema.json");
+
+        const GLOB_MAP: Record<string, string> = {
+            backend: "apps/backend/**/*",
+            frontend: "apps/web/**/*",
+            database: "apps/backend/src/database/**/*",
+            mobile: "apps/mobile/**/*",
+            native: "apps/native/**/*",
+            quality: "*",
+            security: "*",
+            devops: "*",
+            explorer: "*",
+            git: "*",
+            analyst: "*",
+            manager: "*",
+        };
 
-Antigravity IDE integration for the Gemini adapter.
+        for (const file of files) {
+            const filePath = path.join(agentsDir, file);
+            const agent = JSON.parse(fs.readFileSync(filePath, "utf8"));
+            const name = agent.name;
+            const displayName = agent.displayName || name;
+            const description = agent.description || "";
+            const systemPrompt = agent.customAgentSpec?.customAgent?.systemPromptSections?.[0]?.content || "";
+            const glob = GLOB_MAP[name] || "*";
+            const ruleDestPath = path.join(destRulesDir, `${name}${fileExt}`);
 
-- Framework root: \`${path.basename(frameworkDirPath)}/\`
-- Nested path: \`antigravity/\`
-- Use the parent \`mcp_config.json\` and \`gemini.md\` entrypoint at the project root.
+            let mdcContent: string;
+            if (fileExt === ".mdc") {
+                mdcContent = `---
+description: Agent Enderun — @${name} rules for ${displayName}. ${description.slice(0, 100)}
+globs: ${glob}
+alwaysApply: false
+---
+
+# 🎖️ 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\`)
+
+## 🤖 Specialist Directive (Role: @${name})
+${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.
 `;
+            } else {
+                mdcContent = `# 🎖️ Agent Enderun — @${name} (${displayName})
+
+You are the **${displayName}** of the Agent Enderun Army.
 
-    const antigravityCliReadme = `# Antigravity CLI — Agent Enderun
+## 🏛️ 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\`)
 
-Antigravity CLI integration for the Gemini adapter.
+## 🤖 Specialist Directive (Role: @${name})
+${systemPrompt}
 
-- Framework root: \`${path.basename(frameworkDirPath)}/\`
-- Nested path: \`antigravity-cli/\`
-- Register MCP from the project root \`mcp.json\` or \`.gemini/mcp_config.json\`.
+## 🛡️ 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.
 `;
+            }
 
-    writeTextFile(path.join(frameworkDirPath, "antigravity/README.md"), antigravityReadme);
-    writeTextFile(path.join(frameworkDirPath, "antigravity-cli/README.md"), antigravityCliReadme);
+            fs.writeFileSync(ruleDestPath, mdcContent);
+        }
+        console.warn(`✅ Generated 12 Agent Rules under ${path.relative(projectRoot, destRulesDir)}/`);
+    } catch (e) {
+        console.warn(`⚠️  Failed to generate Agent rules: ${e}`);
+    }
 }
 
-/**
- * Adapter-specific MCP and IDE hooks after scaffold.
- */
 export function runAdapterPostInit(adapter: AdapterConfig, projectRoot: string): void {
     const mcpEntry = buildMcpServerEntry(projectRoot);
     const mcpBlock = { mcpServers: { "agent-enderun": mcpEntry } };
 
-    switch (adapter.id) {
-    case "gemini": {
-        writeJsonFile(path.join(projectRoot, adapter.frameworkDir, "mcp_config.json"), mcpBlock);
-        writeAntigravityScaffold(path.join(projectRoot, adapter.frameworkDir));
-        console.warn(`✅ Gemini MCP → ${adapter.frameworkDir}/mcp_config.json`);
-        console.warn(`✅ Antigravity → ${adapter.frameworkDir}/antigravity/ & antigravity-cli/`);
-        break;
-    }
-    case "antigravity": {
-        writeJsonFile(path.join(projectRoot, adapter.frameworkDir, "mcp_config.json"), mcpBlock);
-        console.warn(`✅ Antigravity IDE MCP → ${adapter.frameworkDir}/mcp_config.json`);
-        break;
-    }
-    case "antigravity-cli": {
-        writeJsonFile(path.join(projectRoot, adapter.frameworkDir, "mcp_config.json"), mcpBlock);
-        console.warn(`✅ Antigravity CLI MCP → ${adapter.frameworkDir}/mcp_config.json`);
-        break;
-    }
-    case "grok": {
-        writeJsonFile(path.join(projectRoot, adapter.frameworkDir, "mcp_config.json"), mcpBlock);
-        console.warn(`✅ Grok MCP → ${adapter.frameworkDir}/mcp_config.json`);
-        break;
-    }
-    case "claude": {
-        const configPath = findClaudeConfigPath();
-        if (configPath) {
-            const ok = addMcpServerToClaude(configPath, "agent-enderun", mcpEntry);
-            if (ok) {
-                console.warn(`✅ Claude MCP registered → ${configPath}`);
-            } else {
-                console.warn("⚠️  Could not patch Claude config automatically.");
-            }
-        } else {
-            console.warn("⚠️  Claude config not found. Add MCP manually (see README).");
-        }
-        writeJsonFile(path.join(projectRoot, adapter.frameworkDir, "mcp_config.json"), mcpBlock);
-        writeJsonFile(path.join(projectRoot, ".mcp.json"), mcpBlock);
-        console.warn("✅ Claude Code Project MCP → .mcp.json");
-        break;
-    }
-    default:
-        break;
+    const postInitFn = POST_INIT_MAP[adapter.id];
+    if (postInitFn) {
+        postInitFn(projectRoot, mcpBlock);
+        generateAdapterAgentRules(projectRoot, adapter.frameworkDir, adapter.id);
     }
 
-    // Keep root mcp.json in sync when missing or empty
     const rootMcpPath = path.join(projectRoot, "mcp.json");
     if (!fs.existsSync(rootMcpPath)) {
         writeJsonFile(rootMcpPath, mcpBlock);

package/src/cli/commands/check.ts

@@ -2,35 +2,25 @@ import fs from "fs";
 import path from "path";
 import { execSync } from "child_process";
 
-import { getFrameworkDir, getConfiguredPaths, getMemoryPath } from "../utils/memory.js";
-import { getPackageVersion, getValidatorPath } from "../utils/pkg.js"; // To get FRAMEWORK_VERSION + robust npm-installed bin/validator resolution
+import { getFrameworkDir, getMemoryPath } from "../utils/memory.js";
+import { getPackageVersion, getValidatorPath } from "../utils/pkg.js";
+import { UI } from "../utils/ui.js";
 
 const FRAMEWORK_VERSION = getPackageVersion();
 
-/**
- * Check framework health and MCP status.
- * Now also runs full AL (Agent Lifecycle) army validation so that
- * `agent-enderun check` guarantees that init setups are AL-compliant.
- */
 export function checkCommand() {
-    console.warn(`🔍 Checking Agent Enderun Health (v${FRAMEWORK_VERSION})...`);
+    UI.intent("Enderun Core Health Check", `Sistem sağlığı ve disiplin kuralları denetleniyor (v${FRAMEWORK_VERSION})...`);
     let issues = 0;
 
     const frameworkDir = getFrameworkDir();
-    const pathsMap = getConfiguredPaths();
     const memoryPath = getMemoryPath();
 
-    console.warn(`   Using framework dir: ${frameworkDir} (AL cross-adapter aware)`);
+    UI.success(`Using framework dir: ${frameworkDir}`);
 
-    // Determine folder names based on adapter detection (AL + cross-adapter support)
     let knowledgeDir = "knowledge";
-    if (frameworkDir === ".agents" || frameworkDir === ".agent") {
-        knowledgeDir = "rules";
-    }
+    if (frameworkDir === ".github") knowledgeDir = "instructions";
 
-    const constitutionPath = fs.existsSync(path.join(process.cwd(), "ENDERUN.md"))
-        ? "ENDERUN.md"
-        : path.join(frameworkDir, "ENDERUN.md");
+    const constitutionPath = fs.existsSync(path.join(process.cwd(), "ENDERUN.md")) ? "ENDERUN.md" : path.join(frameworkDir, "ENDERUN.md");
 
     const checks = [
         { name: "Constitution (ENDERUN.md)", path: constitutionPath },
@@ -41,76 +31,82 @@ export function checkCommand() {
         { name: "MCP Config (mcp.json)", path: "mcp.json" },
         { name: "ESLint Config (eslint.config.js)", path: "eslint.config.js" },
         { name: "ESLint Standards", path: path.join(frameworkDir, `${knowledgeDir}/eslint-standards.md`) },
-        { name: "Backend Contract", path: path.join(pathsMap.backend, "contract.version.json") },
         { name: "MCP Server", path: "framework-mcp/package.json" },
-        { name: "Panda CSS Config", path: "panda.config.ts" },
+        { name: "Panda CSS Config", path: "panda.config.ts", optional: true },
         { name: "Brain Dashboard", path: path.join(frameworkDir, "BRAIN_DASHBOARD.md") },
-        { name: "Project Architectural Portal (docs/README.md)", path: path.join(pathsMap.docs, "README.md") },
-        { name: "System Getting Started Guide (docs/getting-started.md)", path: path.join(pathsMap.docs, "getting-started.md") },
-        { name: "Enterprise Approval Flows Protocol", path: path.join(pathsMap.docs, "architecture/approval-flows.md") },
-        { name: "Professional Error Handling Pattern", path: path.join(pathsMap.docs, "backend/error-handling.md") },
-        { name: "Atomic Component Standards", path: path.join(pathsMap.docs, "frontend/component-patterns.md") },
     ];
 
     for (const check of checks) {
-        if (fs.existsSync(path.join(process.cwd(), check.path))) {
-            console.warn(`✅ ${check.name} found.`);
+        const fullPath = path.isAbsolute(check.path) ? check.path : path.join(process.cwd(), check.path);
+        if (fs.existsSync(fullPath)) {
+            UI.success(`${check.name} found.`);
         } else {
-            console.warn(`❌ ${check.name} MISSING! (${check.path})`);
-            issues++;
+            if (check.optional) {
+                UI.warning(`${check.name} MISSING! (${check.path}) [Optional]`);
+            } else {
+                UI.error(`${check.name} MISSING! (${check.path})`);
+                issues++;
+            }
         }
     }
 
-    // Dependency Check
-    const mcpNodeModules = path.join(process.cwd(), "framework-mcp/node_modules");
-    const rootNodeModules = path.join(process.cwd(), "node_modules");
-    if (!fs.existsSync(mcpNodeModules) && !fs.existsSync(rootNodeModules)) {
-        console.warn("❌ Dependencies MISSING! (Run 'npm install')");
+    // Agent Army Check
+    console.warn("\n🛡️  Running Agent Army Compliance...");
+    try {
+        const validatorScript = getValidatorPath();
+        execSync(`node "${validatorScript}"`, { stdio: "pipe" });
+        UI.success("Agent Army AL validation PASSED.");
+    } catch (error: unknown) {
+        const err = error as Error & { stderr?: Buffer };
+        UI.error(`Agent Army AL validation FAILED: ${err.message}`);
+        if (err.stderr) console.error(err.stderr.toString());
         issues++;
-    } else {
-        console.warn("✅ Dependencies found.");
     }
 
-    // MCP Build Check
-    const mcpPath = path.join(process.cwd(), "framework-mcp/dist/index.js");
-    if (!fs.existsSync(mcpPath)) {
-        console.warn("❌ MCP Build MISSING! (Run 'npm run enderun:build')");
+    // Code Quality
+    console.warn("\n⚖️  Checking Discipline (Code Quality)...");
+    const consoleLogIssues = checkConsoleLogs();
+    if (consoleLogIssues.length > 0) {
+        UI.error(`Forbidden 'console.log' found in ${consoleLogIssues.length} locations.`);
         issues++;
     } else {
-        console.warn("✅ MCP Build found.");
-        console.warn("⏳ Testing MCP Server syntax...");
-        try {
-            execSync(`node --check ${mcpPath}`, { stdio: "pipe" });
-            console.warn("✅ MCP Server syntax valid.");
-        } catch {
-            // If --check fails on ESM, we might skip it or use a better check
-            console.warn("⚠️  MCP Syntax check skipped (ESM/Environment).");
-        }
+        UI.success("No forbidden 'console.log' detected.");
     }
 
-    // === AL (Agent Lifecycle) Army Validation ===
-    // This makes `agent-enderun check` also enforce that init'ed agents are AL-compliant
-    // (stateMachine + tags present and parseable). Works across adapters (skills/plugins/agents).
-    // Uses getValidatorPath() so it resolves inside node_modules/... when installed via npm (not just source cwd).
-    console.warn("\n🛡️  Running Agent Army AL Compliance (validate-agent-army)...");
     try {
-        const validatorPath = getValidatorPath();
-        execSync(`node "${validatorPath}"`, { stdio: "pipe" });
-        console.warn("✅ Agent Army AL validation PASSED (all agents have stateMachine + tags).");
+        execSync("npx tsc --noEmit", { stdio: "pipe" });
+        UI.success("TypeScript type check PASSED.");
     } catch {
-        console.warn("❌ Agent Army AL validation FAILED.");
-        console.warn("   Run manually: agent-enderun validate   (or: npx agent-enderun validate-army)");
-        console.warn("   This usually means your init used an adapter that remapped agents (e.g. antigravity → skills).");
-        console.warn("   The core .md definitions should still be correct; the standalone validator just couldn't locate them.");
-        console.warn("   (Note: from npm package, bare 'node bin/...' will not work — use the CLI command above.)");
+        UI.error("TypeScript type check FAILED.");
         issues++;
     }
 
     if (issues === 0) {
-        console.warn("\n🚀 All systems green! Agent Enderun is ready for orchestration.");
+        UI.success("\n🚀 All systems green! Enderun Core is ready.");
     } else {
-        console.warn(`
-⚠️  Found ${issues} issues. Please fix them before starting.`);
+        UI.error(`\n⚠️  Found ${issues} issues. Please fix them.`);
         process.exit(1);
     }
-}
+}
+
+function checkConsoleLogs(): 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");
+                const target = "console." + "log(";
+                if (content.includes(target) && !fullPath.includes("check.ts")) {
+                    issues.push(fullPath);
+                }
+            }
+        }
+    };
+    walk(srcDir);
+    return issues;
+}