agent-enderun 1.11.3 → 1.11.5

package/framework-mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-enderun/mcp",
-  "version": "1.10.7",
+  "version": "1.11.5",
   "description": "Agent Enderun Model Context Protocol (MCP) Server",
   "type": "module",
   "scripts": {
@@ -14,6 +14,6 @@
   },
   "devDependencies": {
     "@types/node": "^25.9.1",
-    "typescript": "^5.0.0"
+    "typescript": "^5.9.3"
   }
 }

package/framework-mcp/src/index.ts

@@ -57,13 +57,25 @@ function validateArgs(toolName: string, args: Record<string, unknown>): string |
     return null;
 }
 
-server.setRequestHandler(ListToolsRequestSchema, async () => {
+server.setRequestHandler(ListToolsRequestSchema, async (request) => {
+    // 2026 Stateless Spec: Log client info from metadata if available
+    const meta = (request as { _meta?: { client?: { name?: string; version?: string } } })._meta;
+    if (meta) {
+        process.stderr.write(`[MCP] Stateless ListTools from ${meta.client?.name || "unknown"} v${meta.client?.version || "?.?"}\n`);
+    }
     return { tools: TOOLS };
 });
 
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const req = request as { params: { name: string, arguments?: Record<string, unknown> } };
     const { name, arguments: args } = req.params;
+    const meta = (request as { _meta?: { client?: { name?: string; version?: string } } })._meta;
+    
+    // 2026 Stateless Spec: Prioritize metadata-driven context
+    if (meta) {
+        process.stderr.write(`[MCP] Stateless CallTool: ${name} (Client: ${meta.client?.name || "unknown"})\n`);
+    }
+
     const projectRoot = process.env.ENDERUN_PROJECT_ROOT || process.cwd();
 
     try {

package/framework-mcp/src/tools/control_plane/locking.ts

@@ -15,6 +15,7 @@ export async function handleAcquireLock(projectRoot: string, args: AcquireLockAr
     try {
         if (!fs.existsSync(lockDir)) fs.mkdirSync(lockDir, { recursive: true });
 
+        // Check for stale lock first
         if (fs.existsSync(lockPath)) {
             const stat = fs.statSync(lockPath);
             const now = new Date().getTime();
@@ -26,15 +27,28 @@ export async function handleAcquireLock(projectRoot: string, args: AcquireLockAr
                     content: [{ type: "text", text: `Resource '${resource}' is currently locked by another agent.` }]
                 };
             }
-            // Lock expired, safe to override
-            fs.unlinkSync(lockPath);
+            // Lock expired, safe to override by deleting first
+            try {
+                fs.unlinkSync(lockPath);
+            } catch (unlinkErr) {
+                // If another agent unlinked it first, ignore
+            }
         }
 
-        fs.writeFileSync(lockPath, JSON.stringify({ agent, timestamp: new Date().toISOString() }));
+        // Use 'wx' flag for atomic file creation
+        const lockData = JSON.stringify({ agent, timestamp: new Date().toISOString() });
+        fs.writeFileSync(lockPath, lockData, { flag: "wx" });
+        
         return {
             content: [{ type: "text", text: `✅ Lock acquired for resource '${resource}' by ${agent}.` }]
         };
-    } catch (e) {
+    } catch (e: any) {
+        if (e.code === "EEXIST") {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Resource '${resource}' was just acquired by another agent.` }]
+            };
+        }
         return {
             isError: true,
             content: [{ type: "text", text: `Failed to acquire lock: ${String(e)}` }]

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

@@ -151,16 +151,6 @@ export const TOOLS: ToolDefinition[] = [
             }
         }
     },
-    {
-        name: "start_dashboard",
-        description: "Start the Enderun Web Dashboard (Command Center) to visualize real-time agent status, logs, and system metrics in the browser.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                port: { type: "number", description: "Optional: Port to run the dashboard on (default: 5858)" }
-            }
-        }
-    },
     {
         name: "get_framework_status",
         description: "Get the current project phase, active traces, and agent states.",

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

@@ -14,7 +14,6 @@ import { handleAuditDependencies } from "./framework/audit_deps.js";
 import { handleRunTests } from "./framework/run_tests.js";
 import { handleGetSystemHealth } from "./observability/get_health.js";
 import { handleCheckPorts } from "./observability/check_ports.js";
-import { handleStartDashboard } from "./dashboard/start_dashboard.js";
 import { handleOrchestrateLoop } from "./framework/orchestrate.js";
 import { handleUpdateContractHash } from "./framework/update_contract_hash.js";
 import { handleReadProjectMemory } from "./memory/read_memory.js";
@@ -51,7 +50,6 @@ export const toolHandlers: Record<string, ToolHandler> = {
     run_tests: bind(handleRunTests),
     get_system_health: bind(handleGetSystemHealth),
     check_active_ports: bind(handleCheckPorts),
-    start_dashboard: bind(handleStartDashboard),
     orchestrate_loop: bind(handleOrchestrateLoop),
     send_agent_message: bind(handleSendAgentMessage),
     log_agent_action: bind(handleLogAgentAction),

package/framework-mcp/src/tools/memory/get_insights.ts

@@ -19,14 +19,14 @@ export function handleGetMemoryInsights(projectRoot: string, _args: ToolArgs): T
         const content = fs.readFileSync(memoryPath, "utf8");
         const lines = content.split("\n");
         
-        const activePhase = lines.find(l => l.includes("Active Phase:"))?.split(":")[1]?.trim() || "Unknown";
-        const activeTrace = lines.find(l => l.includes("Active Trace:"))?.split(":")[1]?.trim() || "None";
+        const activePhase = lines.find(l => l.includes("**Phase:**"))?.split("**Phase:**")[1]?.trim() || "Unknown";
+        const activeTrace = lines.find(l => l.includes("**Trace ID:**"))?.split("**Trace ID:**")[1]?.trim() || "None";
         
         // Find the last 5 history items (heuristic)
-        const historyStartIndex = lines.findIndex(l => l.includes("## History"));
+        const historyStartIndex = lines.findIndex(l => l.toUpperCase().includes("HISTORY"));
         let recentHistory = "No history found.";
         if (historyStartIndex !== -1) {
-            recentHistory = lines.slice(historyStartIndex + 1, historyStartIndex + 15)
+            recentHistory = lines.slice(historyStartIndex + 1)
                 .filter(l => l.trim().startsWith("-"))
                 .slice(-5)
                 .join("\n");

package/framework-mcp/src/tools/messaging/send_message.ts

@@ -5,7 +5,7 @@ import { SendAgentMessageArgs, ToolResult } from "../types.js";
 import { Metrics } from "../../utils/metrics.js";
 
 export async function handleSendAgentMessage(projectRoot: string, args: SendAgentMessageArgs): Promise<ToolResult> {
-    const { to, category, content, traceId } = args;
+    const { to, category, content, traceId, parentId, requiresApproval } = args;
     const from = args.from || "@mcp";
 
     if (!to || !category || !content || !traceId) {
@@ -20,15 +20,15 @@ export async function handleSendAgentMessage(projectRoot: string, args: SendAgen
     const messagePath = path.join(messagesDir, `${agentName}.json`);
     const lockPath = path.join(messagesDir, `${agentName}.lock`);
 
-    // Hermes Lock Protocol: Retry 3 times with 500ms delay
-    let retries = 3;
+    // Hermes Lock Protocol: Retry 20 times with 500ms delay
+    let retries = 20;
     let acquired = false;
     while (retries > 0) {
         try {
             if (fs.existsSync(lockPath)) {
                 try {
                     const stats = fs.statSync(lockPath);
-                    if (Date.now() - stats.mtimeMs > 5000) {
+                    if (Date.now() - stats.mtimeMs > 10000) {
                         fs.unlinkSync(lockPath);
                     }
                 } catch {
@@ -60,15 +60,21 @@ export async function handleSendAgentMessage(projectRoot: string, args: SendAgen
 
     try {
         const defaultPriority = (category === "ALERT" || category === "ACTION") ? "HIGH" : "NORMAL";
+        const finalRequiresApproval = requiresApproval !== undefined
+            ? requiresApproval
+            : category === "ALERT";
+
         const message = {
             timestamp: new Date().toISOString(),
             from,
             to,
             category,
             traceId,
+            parentId,
             content,
             priority: args.priority || defaultPriority,
-            status: "PENDING"
+            status: "PENDING",
+            requiresApproval: finalRequiresApproval
         };
 
         fs.appendFileSync(messagePath, JSON.stringify(message) + "\n");

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

@@ -18,9 +18,8 @@ export function handleGrepSearch(projectRoot: string, args: GrepSearchArgs): Too
     }
 
     const results: string[] = [];
-    let regex: RegExp;
     try {
-        regex = new RegExp(pattern, "g");
+        new RegExp(pattern);
     } catch (e) {
         const err = `Invalid regex pattern: ${String(e)}`;
         Metrics.logError(projectRoot, "@mcp", "grep_search", err);
@@ -53,7 +52,7 @@ export function handleGrepSearch(projectRoot: string, args: GrepSearchArgs): Too
                     }
                 }
             }
-        } catch (e) {
+        } catch {
             // Ignore directories that cannot be read
         }
     };

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

@@ -1,37 +1,95 @@
+import ts from "typescript";
+
 /**
  * Enterprise Compliance Guardrail
- * Checks content against corporate standards before allowing file mutations.
+ * Checks content against corporate standards using AST analysis 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."
-            );
-        }
+    // Skip compliance checks for non-source files or specific ignored files
+    if (filePath.endsWith(".json") || filePath.endsWith(".md") || filePath.endsWith(".env.example")) {
+        return;
     }
 
-    // 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."
-            );
+    const sourceFile = ts.createSourceFile(
+        filePath,
+        content,
+        ts.ScriptTarget.Latest,
+        true
+    );
+
+    const errors: string[] = [];
+
+    /**
+     * Recursive AST Visitor
+     */
+    function visit(node: ts.Node) {
+        // 1. Zero Console Policy
+        if (ts.isPropertyAccessExpression(node)) {
+            const expression = node.expression;
+            const name = node.name.text;
+            if (ts.isIdentifier(expression) && expression.text === "console") {
+                if (["log", "warn", "error"].includes(name)) {
+                    // Check if file is exempt
+                    if (!filePath.includes("logger.ts") && !filePath.includes("check.ts") && !filePath.includes("cli.ts")) {
+                        errors.push(`❌ Corporate Compliance Breach: 'console.${name}' usage is forbidden at line ${sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1}.`);
+                    }
+                }
+            }
+        }
+
+        // 2. No Explicit Any Policy
+        if (ts.isTypeReferenceNode(node)) {
+            if (ts.isIdentifier(node.typeName) && node.typeName.text === "any") {
+                if (!filePath.includes("definitions.ts") && !filePath.includes("types.ts")) {
+                    errors.push(`❌ Corporate Compliance Breach: 'any' type is forbidden at line ${sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1}.`);
+                }
+            }
         }
+        
+        // 3. Zero UI Library Policy (No @chakra-ui, mui, @shadcn)
+        if (ts.isImportDeclaration(node)) {
+            const moduleSpecifier = node.moduleSpecifier;
+            if (ts.isStringLiteral(moduleSpecifier)) {
+                const forbiddenLibs = ["@chakra-ui", "mui", "@shadcn", "antd", "bootstrap"];
+                const lib = forbiddenLibs.find(l => moduleSpecifier.text.includes(l));
+                if (lib) {
+                    errors.push(`❌ Corporate Compliance Breach: External UI library '${lib}' usage is FORBIDDEN at line ${sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1}. Build atomic components manually instead.`);
+                }
+            }
+        }
+        
+        // Handle 'any' as a keyword type (e.g., parameter: any)
+        if (node.kind === ts.SyntaxKind.AnyKeyword) {
+            if (!filePath.includes("definitions.ts") && !filePath.includes("types.ts")) {
+                errors.push(`❌ Corporate Compliance Breach: 'any' keyword is forbidden at line ${sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1}.`);
+            }
+        }
+
+        ts.forEachChild(node, visit);
     }
 
-    // 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."
-            );
+    visit(sourceFile);
+
+    // 3. Hardcoded Secrets & PII Guard
+    const piiKeywords = [
+        { regex: /API_KEY\s*=\s*['"][^'"]+['"]/i, msg: "Hardcoded API Key" },
+        { regex: /SECRET\s*=\s*['"][^'"]+['"]/i, msg: "Hardcoded Secret" },
+        { regex: /PASSWORD\s*=\s*['"][^'"]+['"]/i, msg: "Hardcoded Password" },
+        { regex: /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/, msg: "PII Detected: Email Address" },
+        { regex: /\b\d{4}[- ]?\d{4}[- ]?\d{4}[- ]?\d{4}\b/, msg: "PII Detected: Credit Card Pattern" }
+    ];
+    
+    for (const { regex, msg } of piiKeywords) {
+        if (regex.test(content)) {
+            // Allow emails in specific files like README or package.json
+            if (msg.includes("Email") && (filePath.endsWith("README.md") || filePath.endsWith("package.json") || filePath.includes("CONTRIBUTING"))) {
+                continue;
+            }
+            errors.push(`❌ Corporate Compliance Breach: ${msg} detected.`);
         }
     }
+
+    if (errors.length > 0) {
+        throw new Error(errors.join("\n"));
+    }
 }

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

@@ -72,16 +72,16 @@ describe("Hermes Lock Protocol & Message sending", () => {
 
         expect(result.isError).toBe(true);
         expect(result.content[0].text).toContain("❌ Could not send message to @backend: Hermes lock is busy.");
-        // Retries takes 3 attempts with 500ms delay -> duration should be at least ~1000ms
-        expect(duration).toBeGreaterThanOrEqual(1000);
-    });
+        // Retries takes 20 attempts with 500ms delay -> duration should be at least ~9000ms
+        expect(duration).toBeGreaterThanOrEqual(9000);
+    }, 15000);
 
-    it("should bypass and acquire lock if existing lock is stale (older than 5s)", async () => {
+    it("should bypass and acquire lock if existing lock is stale (older than 10s)", async () => {
         fs.mkdirSync(MESSAGES_DIR, { recursive: true });
-        // Set lock file mtime to 10 seconds ago
+        // Set lock file mtime to 15 seconds ago
         fs.writeFileSync(BACKEND_LOCK_FILE, "Locked by @test at " + new Date().toISOString(), "utf8");
-        const tenSecondsAgo = new Date(Date.now() - 10000);
-        fs.utimesSync(BACKEND_LOCK_FILE, tenSecondsAgo, tenSecondsAgo);
+        const fifteenSecondsAgo = new Date(Date.now() - 15000);
+        fs.utimesSync(BACKEND_LOCK_FILE, fifteenSecondsAgo, fifteenSecondsAgo);
 
         const args: ToolArgs = {
             to: "@backend",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-enderun",
-  "version": "1.11.3",
+  "version": "1.11.5",
   "description": "The Supreme AI Governance & Autonomous Orchestration Framework for Enterprise Development. Acts as a Corporate AI Management Assistant.",
   "author": "Yusuf BEKAR",
   "license": "MIT",
@@ -24,7 +24,8 @@
     "framework"
   ],
   "workspaces": [
-    "framework-mcp"
+    "framework-mcp",
+    "apps/*"
   ],
   "bin": {
     "agent-enderun": "bin/cli.js"
@@ -48,7 +49,6 @@
     "enderun:verify": "agent-enderun verify-contract",
     "enderun:update-contract": "agent-enderun update-contract",
     "enderun:check": "agent-enderun check",
-    "enderun:dashboard": "node bin/enderun-dashboard.js",
     "test:init": "node dist/src/cli/index.js init",
     "enderun:lint": "eslint .",
     "lint": "eslint .",
@@ -66,12 +66,12 @@
     "eslint": "^10.4.0",
     "globals": "^17.6.0",
     "tsx": "^4.22.3",
-    "typescript": "^5.0.0",
+    "typescript": "^5.9.3",
     "typescript-eslint": "^8.0.0",
     "vitest": "^3.0.0"
   },
   "enderun": {
-    "version": "1.11.3",
+    "version": "1.11.5",
     "initializedAt": "2026-06-04T18:51:28.970Z",
     "frameworkDir": ".enderun"
   },

package/src/cli/adapters/scaffold.ts

@@ -20,7 +20,8 @@ export function scaffoldAgents(
     dryRun: boolean, 
     agentsToScaffold?: string[],
     explicitDestDir?: string,
-    explicitExt?: string
+    explicitExt?: string,
+    paths?: Record<string, string>
 ): void {
     const adapter = ADAPTERS[adapterId];
     if (!adapter) return;
@@ -46,27 +47,27 @@ export function scaffoldAgents(
 
             switch (adapterId) {
                 case "gemini":
-                    content = toGeminiCliMd(agent, baseKnowledgeDir);
+                    content = toGeminiCliMd(agent, baseKnowledgeDir, paths);
                     break;
                 case "grok":
                     // Grok uses same Gemini-compatible YAML format
-                    content = toGeminiCliMd(agent, baseKnowledgeDir);
+                    content = toGeminiCliMd(agent, baseKnowledgeDir, paths);
                     break;
                 case "claude":
-                    content = toClaudeCodeMd(agent, baseKnowledgeDir);
+                    content = toClaudeCodeMd(agent, baseKnowledgeDir, paths);
                     break;
                 case "cursor":
-                    content = toCursorMdc(agent, baseKnowledgeDir);
+                    content = toCursorMdc(agent, baseKnowledgeDir, paths);
                     break;
                 case "codex":
-                    content = toCodexMd(agent, baseKnowledgeDir);
+                    content = toCodexMd(agent, baseKnowledgeDir, paths);
                     break;
                 case "antigravity-cli": {
                     // Antigravity uses nested folders: agents/{name}/agent.json and agents/{name}/agent.md
                     const agentDir = path.join(destAgentsDir, agent.name);
                     if (!dryRun) fs.mkdirSync(agentDir, { recursive: true });
                     
-                    content = toAntigravityJson(agent, baseKnowledgeDir);
+                    content = toAntigravityJson(agent, baseKnowledgeDir, paths);
                     fileName = path.join(agent.name, "agent.json");
                     
                     secondaryContent = `# 🎖️ Agent Enderun — @${agent.name}\n\n${agent.instructions.identity}\n\n${agent.instructions.mission}`;
@@ -75,7 +76,7 @@ export function scaffoldAgents(
                 }
                 default:
                     // Fallback to Gemini format
-                    content = toGeminiCliMd(agent, baseKnowledgeDir);
+                    content = toGeminiCliMd(agent, baseKnowledgeDir, paths);
                     break;
             }
 

package/src/cli/commands/check.ts

@@ -2,7 +2,7 @@ import fs from "fs";
 import path from "path";
 import { execSync } from "child_process";
 
-import { getFrameworkDir, getMemoryPath, getConfiguredPaths, isFrameworkDevelopmentRepo } from "../utils/memory.js";
+import { getFrameworkDir, getMemoryPath, getConfiguredPaths, isFrameworkDevelopmentRepo, readState } from "../utils/memory.js";
 import { getPackageVersion, getValidatorPath } from "../utils/pkg.js";
 import { UI } from "../utils/ui.js";
 import { logger } from "../../shared/logger.js";
@@ -10,16 +10,41 @@ import { scanProjectCompliance } from "../utils/compliance.js";
 import { ALL_AGENTS } from "../../modules/agents/definitions.js";
 import { detectActiveAgentLayouts, findAgentInstruction } from "../adapters/paths.js";
 
+import { verifyApiContractCommand } from "./contract.js";
+
 export async function checkCommand() {
     UI.intent("Agent Enderun Health Check", `Checking system health and discipline rules (v${getPackageVersion()})...`);
     let issues = 0;
 
+    const state = readState();
+    if (!state) {
+        UI.error("Memory state not found. Run 'init' first.");
+        return;
+    }
+
     const frameworkDir = getFrameworkDir();
     const memoryPath = getMemoryPath();
     const pathsMap = getConfiguredPaths();
 
     UI.success(`Using framework dir: ${frameworkDir}`);
 
+    // --- Contract Gate (Phase 2+ Discipline) ---
+    if (["PHASE_2", "PHASE_3", "PHASE_4"].includes(state.phase)) {
+        console.warn("\n📝 Validating API Contracts (Phase 2+ Required)...");
+        try {
+            const contractOk = await verifyApiContractCommand({ silent: true });
+            if (!contractOk) {
+                UI.error("Contract verification FAILED! You cannot be in Phase 2+ with unverified contracts.");
+                issues++;
+            } else {
+                UI.success("API Contracts verified and sealed.");
+            }
+        } catch {
+            UI.error("Error during contract verification.");
+            issues++;
+        }
+    }
+
     let knowledgeDir = "knowledge";
     if (frameworkDir === ".github") knowledgeDir = "instructions";
 
@@ -57,7 +82,6 @@ export async function checkCommand() {
         { 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") },
     ];
 
     for (const check of checks) {
@@ -135,52 +159,6 @@ export async function checkCommand() {
         logger.debug("npx tsc --noEmit check failed", err);
     }
 
-    interface MetricEntry {
-        timestamp: string;
-        agent: string;
-        action: string;
-        estimatedTokens: number;
-    }
-
-    const metricsPath = path.join(frameworkDir, "observability/metrics.json");
-    if (fs.existsSync(metricsPath)) {
-        try {
-            const raw = fs.readFileSync(metricsPath, "utf8");
-            const metrics: MetricEntry[] = JSON.parse(raw);
-            if (Array.isArray(metrics) && metrics.length > 0) {
-                console.warn("\n📊  Token Consumption Report:");
-                let totalTokens = 0;
-                const breakdown: Record<string, { count: number; tokens: number }> = {};
-
-                for (const entry of metrics) {
-                    const tokens = typeof entry.estimatedTokens === "number" ? entry.estimatedTokens : 0;
-                    totalTokens += tokens;
-
-                    const actionName = (entry.action || "unknown").split(":")[0].trim();
-                    if (!breakdown[actionName]) {
-                        breakdown[actionName] = { count: 0, tokens: 0 };
-                    }
-                    breakdown[actionName].count += 1;
-                    breakdown[actionName].tokens += tokens;
-                }
-
-                console.warn(`  - Total Operations: ${metrics.length}`);
-                console.warn(`  - Total Estimated Tokens: ${totalTokens}`);
-                console.warn("\n  Breakdown by Action:");
-                for (const [action, data] of Object.entries(breakdown)) {
-                    console.warn(`    - ${action}: ${data.count} ops (${data.tokens} tokens)`);
-                }
-            } else {
-                console.warn("\n📊  Token Consumption Report: No token usage logged yet.");
-            }
-        } 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.");
-    }
-
     if (issues === 0) {
         UI.success("\n🚀 All systems green! Agent Enderun is ready.");
     } else {

package/src/cli/commands/contract.ts

@@ -7,13 +7,14 @@ import { ValidationError } from "../../shared/errors.js";
 /**
  * Verify type safety between backend and frontend contracts.
  */
-export async function verifyApiContractCommand() {
+export async function verifyApiContractCommand(options: { silent?: boolean } = {}): Promise<boolean> {
     const projectRoot = process.cwd();
     const pathsMap = getConfiguredPaths();
     const sharedDir = path.join(projectRoot, pathsMap.backend, "src/types");
     const contractPath = path.join(projectRoot, pathsMap.backend, "contract.version.json");
 
     if (!fs.existsSync(sharedDir) || !fs.existsSync(contractPath)) {
+        if (options.silent) return false;
         throw new ValidationError(
             "API types or contract version file missing.",
             null,
@@ -25,8 +26,10 @@ export async function verifyApiContractCommand() {
     const contract = JSON.parse(fs.readFileSync(contractPath, "utf8"));
 
     if (contract.contract_hash === currentHash) {
-        console.warn("✅ Contract is valid and synchronized.");
+        if (!options.silent) console.warn("✅ Contract is valid and synchronized.");
+        return true;
     } else {
+        if (options.silent) return false;
         throw new ValidationError(
             "Contract drift detected!",
             { stored: contract.contract_hash, actual: currentHash },

package/src/cli/commands/init/scaffold-core.ts

@@ -45,7 +45,7 @@ export function scaffoldFrameworkConfigs(
     adapter: AdapterConfig, 
     dryRun: boolean, 
     selectedPalette: string,
-    options?: { unified?: boolean; adapters?: string[] }
+    options?: { unified?: boolean; adapters?: string[]; profile?: string }
 ) {
     if (dryRun) return;
     const frameworkDir = path.join(targetDir, fDir);
@@ -55,6 +55,7 @@ export function scaffoldFrameworkConfigs(
         name: FRAMEWORK_NAME,
         version: getPackageVersion(),
         unified: options?.unified || false,
+        profile: options?.profile || "full",
         adapters: options?.adapters || [adapter.id],
         theme: {
             palette: selectedPalette,
@@ -77,10 +78,25 @@ export function scaffoldFrameworkConfigs(
     }
 
     let statusContent = "# 🎖️ Status\n\n| Agent | State | Active Task | Last Updated | Notes | Extra | Backup |\n|---|---|---|---|---|---|---|\n";
-    for (const ag of ALL_AGENTS) {
+    
+    const liteAgents = ["manager", "architect", "frontend"];
+    const activeAgents = (options?.profile === "lite")
+        ? ALL_AGENTS.filter(ag => liteAgents.includes(ag.name))
+        : ALL_AGENTS;
+
+    const initialStatusJson: Record<string, { state: string; task: string; lastUpdated: string }> = {};
+    const now = new Date().toISOString();
+
+    for (const ag of activeAgents) {
         statusContent += "| @" + ag.name + " | READY | Idle | - | - | - | - |\n";
+        initialStatusJson[ag.name] = { state: "READY", task: "Idle", lastUpdated: now };
     }
     writeTextFile(path.join(frameworkDir, "STATUS.md"), statusContent);
+
+    // Populate initial status.json
+    const statusJsonPath = path.join(frameworkDir, "memory", "status.json");
+    if (!fs.existsSync(path.join(frameworkDir, "memory"))) fs.mkdirSync(path.join(frameworkDir, "memory"), { recursive: true });
+    writeJsonFile(statusJsonPath, initialStatusJson, dryRun);
 }
 
 export function scaffoldShims(

package/src/cli/commands/init/scaffold-ops.ts

@@ -48,9 +48,6 @@ export function scaffoldOps(frameworkDir: string, dryRun: boolean) {
     };
     writeJsonFile(path.join(frameworkDir, "cli-commands.json"), cliCommands, dryRun);
 
-    // Scaffold BRAIN_DASHBOARD.md
-    writeTextFile(path.join(frameworkDir, "BRAIN_DASHBOARD.md"), "# 🧠 Brain Dashboard\n\nActive Trace: T-000\nActive Phase: PHASE_0 (Genesis)\n\n## Agent Statuses\n- @manager: READY\n- @architect: READY\n- @backend: READY\n- @frontend: READY\n- @quality: READY\n");
-
     // Scaffold router/routing_rules.md
     const routerDir = path.join(frameworkDir, "router");
     if (!fs.existsSync(routerDir)) fs.mkdirSync(routerDir, { recursive: true });