agent-enderun 1.10.4 → 1.11.0

package/framework-mcp/tests/tools/quality/check_lint.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { handleCheckLint } from "../../../src/tools/quality/check_lint.js";
+import { exec } from "child_process";
+
+vi.mock("child_process");
+
+describe("handleCheckLint", () => {
+    const projectRoot = "/fake/project";
+
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+
+    it("should execute the lint command and return output on success", async () => {
+        const args = {};
+        
+        vi.mocked(exec).mockImplementation((_cmd, _opts, callback) => {
+            // @ts-expect-error: Mock implementation callback type is complex
+            callback(null, "All good!", "");
+            return {} as any;
+        });
+
+        const result = await handleCheckLint(projectRoot, args);
+        
+        expect(exec).toHaveBeenCalledWith("npm run lint", { cwd: projectRoot, timeout: 60000 }, expect.any(Function));
+        expect(result.isError).toBeUndefined();
+        expect(result.content[0].text).toContain("All good!");
+    });
+
+    it("should execute the lint command and return output on failure (lint issues found)", async () => {
+        const args = {};
+        const lintErrorOutput = "Error: 2 problems (2 errors, 0 warnings)";
+        
+        vi.mocked(exec).mockImplementation((_cmd, _opts, callback) => {
+            // @ts-expect-error: Mock implementation callback type is complex
+            callback({ code: 1, message: "Lint errors found" }, lintErrorOutput, "");
+            return {} as any;
+        });
+
+        const result = await handleCheckLint(projectRoot, args);
+        
+        expect(exec).toHaveBeenCalledWith("npm run lint", { cwd: projectRoot, timeout: 60000 }, expect.any(Function));
+        expect(result.isError).toBe(true); // Implementation returns isError: true on failure
+        expect(result.content[0].text).toContain(lintErrorOutput);
+    });
+});

package/framework-mcp/tests/tools/shell/run_command.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { handleRunCommand } from "../../../src/tools/shell/run_command.js";
+import { exec } from "child_process";
+
+vi.mock("child_process");
+
+describe("handleRunCommand", () => {
+    const projectRoot = "/fake/project";
+
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+
+    it("should execute an allowed command", async () => {
+        const args = { command: "git status" };
+        
+        vi.mocked(exec).mockImplementation((_cmd, _opts, callback) => {
+            // @ts-expect-error: Mock implementation callback type is complex
+            callback(null, "On branch main", "");
+            return {} as any;
+        });
+
+        const result = await handleRunCommand(projectRoot, args);
+        
+        expect(exec).toHaveBeenCalledWith("git status", { cwd: projectRoot, timeout: 30000 }, expect.any(Function));
+        expect(result.isError).toBeUndefined();
+        expect(result.content[0].text).toContain("On branch main");
+    });
+
+    it("should reject a disallowed command", async () => {
+        const args = { command: "rm -rf /" };
+        const result = await handleRunCommand(projectRoot, args);
+        
+        expect(exec).not.toHaveBeenCalled();
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain("Command not allowed");
+    });
+
+    it("should handle command failure", async () => {
+        const args = { command: "npm run build" };
+
+        vi.mocked(exec).mockImplementation((_cmd, _opts, callback) => {
+            // @ts-expect-error: Mock implementation callback type is complex
+            callback({ code: 1, message: "Build failed" }, "", "Error details");
+            return {} as any;
+        });
+
+        const result = await handleRunCommand(projectRoot, args);
+
+        expect(exec).toHaveBeenCalledWith("npm run build", { cwd: projectRoot, timeout: 30000 }, expect.any(Function));
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain("Command failed with exit code 1");
+        expect(result.content[0].text).toContain("Error details");
+    });
+});

package/framework-mcp/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "rootDir": "src",
+    "outDir": "./dist",
+    "strict": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-enderun",
-  "version": "1.10.4",
+  "version": "1.11.0",
   "description": "The Supreme AI Governance & Autonomous Orchestration Framework for Enterprise Development. Acts as a Corporate AI Management Assistant.",
   "author": "Yusuf BEKAR",
   "license": "MIT",
@@ -33,6 +33,8 @@
     "bin",
     "dist",
     "src",
+    "templates",
+    "framework-mcp",
     "README.md",
     "LICENSE"
   ],
@@ -58,7 +60,7 @@
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
-    "@modelcontextprotocol/sdk": "^1.26.0",
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "@pandacss/dev": "^1.11.1",
     "@types/node": "^25.9.1",
     "eslint": "^10.4.0",
@@ -69,7 +71,7 @@
     "vitest": "^3.0.0"
   },
   "enderun": {
-    "version": "1.10.3",
+    "version": "1.11.0",
     "initializedAt": "2026-06-04T18:51:28.970Z",
     "frameworkDir": ".enderun"
   },

package/src/cli/adapters/core.ts

@@ -3,8 +3,8 @@ import path from "path";
 import { writeJsonFile } from "../utils/fs.js";
 import { getPackageRoot } from "../utils/pkg.js";
 
-import type { AdapterConfig, AdapterId } from "../../modules/adapters/types.js";
 import { ADAPTER_CONFIGS, POST_INIT_HANDLERS } from "../../modules/adapters/definitions.js";
+import type { AdapterConfig, AdapterId } from "../../modules/adapters/types.js";
 
 export const ADAPTERS: Record<AdapterId, AdapterConfig> = ADAPTER_CONFIGS;
 
@@ -16,7 +16,6 @@ export const FRAMEWORK_DIR_CANDIDATES = [
     ".claude",
     ".github",
     ".grok",
-    ".windsurf",
     ".antigravity",
     ".agent",
     ".gemini/antigravity-cli",
@@ -28,7 +27,7 @@ export const FRAMEWORK_DIR_CANDIDATES = [
 export function buildMcpServerEntry(projectRoot: string) {
     const packageRoot = getPackageRoot();
     const mcpServerPath = path.join(packageRoot, "framework-mcp/dist/index.js");
-    
+
     if (!fs.existsSync(mcpServerPath)) {
         console.warn(`⚠️  MCP Server not found at ${mcpServerPath}. Did you run 'npm run build'?`);
     }

package/src/cli/adapters/index.ts

@@ -2,3 +2,4 @@ export { ADAPTER_IDS, type AdapterConfig, type AdapterId, type AdapterRole } fro
 export { ADAPTERS, FRAMEWORK_DIR_CANDIDATES, runAdapterPostInit, buildMcpServerEntry } from "./core.js";
 export { resolveAdapter, isAdapterShimFile, remapFrameworkContent } from "./utils.js";
 export { scaffoldAgents } from "./scaffold.js";
+export { resolveAgentsDir, mirrorUnifiedAgentsToNative } from "./paths.js";

package/src/cli/adapters/scaffold.ts

@@ -14,12 +14,22 @@ import {
 import type { AdapterId } from "../../modules/adapters/types.js";
 import { ADAPTERS } from "./core.js";
 
-export function scaffoldAgents(projectRoot: string, adapterId: AdapterId, dryRun: boolean, agentsToScaffold?: string[]): void {
+export function scaffoldAgents(
+    projectRoot: string, 
+    adapterId: AdapterId, 
+    dryRun: boolean, 
+    agentsToScaffold?: string[],
+    explicitDestDir?: string,
+    explicitExt?: string
+): void {
     const adapter = ADAPTERS[adapterId];
-    if (!adapter || !adapter.agentsDir || !adapter.agentsExt) return;
+    if (!adapter) return;
 
     const allowedAgents = agentsToScaffold ? new Set(agentsToScaffold) : undefined;
-    const destAgentsDir = path.join(projectRoot, adapter.agentsDir);
+    const destAgentsDir = explicitDestDir ? path.join(projectRoot, explicitDestDir) : (adapter.agentsDir ? path.join(projectRoot, adapter.agentsDir) : null);
+    const extension = explicitExt || adapter.agentsExt || ".md";
+
+    if (!destAgentsDir) return;
 
     const baseKnowledgeDir = path.join(getPackageRoot(), "templates/standards");
 
@@ -30,7 +40,7 @@ export function scaffoldAgents(projectRoot: string, adapterId: AdapterId, dryRun
             if (allowedAgents && !allowedAgents.has(agent.name)) continue;
             
             let content = "";
-            let fileName = `${agent.name}${adapter.agentsExt}`;
+            let fileName = `${agent.name}${extension}`;
             let secondaryContent: string | null = null;
             let secondaryFileName: string | null = null;
 
@@ -72,8 +82,7 @@ export function scaffoldAgents(projectRoot: string, adapterId: AdapterId, dryRun
                 }
             }
         }
-        console.warn(`✅ Generated ${allowedAgents ? allowedAgents.size : ALL_AGENTS.length} Agent/Rule definitions under ${path.relative(projectRoot, destAgentsDir)}/`);
     } catch (e) {
-        console.warn(`⚠️  Failed to scaffold agents: ${e}`);
+        console.warn(`⚠️  Failed to scaffold agents for ${adapterId}: ${e}`);
     }
 }

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

@@ -3,7 +3,8 @@ import path from "path";
 import { 
     remapFrameworkContent, 
     type AdapterConfig, 
-    type AdapterId 
+    type AdapterId,
+    ADAPTERS
 } from "../../adapters/index.js";
 import { SHIM_TEMPLATES } from "../../shims.js";
 import { writeJsonFile, writeTextFile } from "../../utils/fs.js";
@@ -38,7 +39,14 @@ export function scaffoldConstitution(targetDir: string, frameworkDir: string, ad
     console.warn(`✅ Constitution file created inside: ${frameworkDir}/ENDERUN.md${readSuccess ? "" : " (default template)"}`);
 }
 
-export function scaffoldFrameworkConfigs(targetDir: string, fDir: string, adapter: AdapterConfig, dryRun: boolean, selectedPalette: string) {
+export function scaffoldFrameworkConfigs(
+    targetDir: string, 
+    fDir: string, 
+    adapter: AdapterConfig, 
+    dryRun: boolean, 
+    selectedPalette: string,
+    options?: { unified?: boolean; adapters?: string[] }
+) {
     if (dryRun) return;
     const frameworkDir = path.join(targetDir, fDir);
     const palette = COLOR_PALETTES[selectedPalette as keyof typeof COLOR_PALETTES] || COLOR_PALETTES["Modern Blue"];
@@ -46,12 +54,28 @@ export function scaffoldFrameworkConfigs(targetDir: string, fDir: string, adapte
     const config = {
         name: FRAMEWORK_NAME,
         version: getPackageVersion(),
+        unified: options?.unified || false,
+        adapters: options?.adapters || [adapter.id],
         theme: {
             palette: selectedPalette,
             colors: palette
         }
     };
     writeJsonFile(path.join(frameworkDir, "config.json"), config, dryRun);
+
+    // Scaffold shared-facts.json in memory-graph
+    const graphDir = path.join(frameworkDir, "memory-graph");
+    if (!fs.existsSync(graphDir)) fs.mkdirSync(graphDir, { recursive: true });
+    const sharedFactsPath = path.join(graphDir, "shared-facts.json");
+    if (!fs.existsSync(sharedFactsPath)) {
+        writeJsonFile(sharedFactsPath, {
+            project: FRAMEWORK_NAME,
+            initializedAt: new Date().toISOString(),
+            stack: [],
+            policies: []
+        }, dryRun);
+    }
+
     let statusContent = "# 🎖️ Status\n\n| Agent | State | Active Task | Last Updated | Notes | Extra | Backup |\n|---|---|---|---|---|---|---|\n";
     for (const ag of ALL_AGENTS) {
         statusContent += "| @" + ag.name + " | READY | Idle | - | - | - | - |\n";
@@ -59,13 +83,28 @@ export function scaffoldFrameworkConfigs(targetDir: string, fDir: string, adapte
     writeTextFile(path.join(frameworkDir, "STATUS.md"), statusContent);
 }
 
-export function scaffoldShims(projectRoot: string, coreDir: string, adapterId: AdapterId, adapter: AdapterConfig, dryRun: boolean) {
+export function scaffoldShims(
+    projectRoot: string, 
+    coreDir: string, 
+    adapterId: AdapterId, 
+    adapter: AdapterConfig, 
+    dryRun: boolean,
+    unified: boolean = false
+) {
     for (const [name, content] of Object.entries(SHIM_TEMPLATES)) {
-        if (name.toLowerCase() === adapterId.split("-")[0] || name === adapterId) {
+        const isSelectedAdapter = name.toLowerCase() === adapterId.split("-")[0] || name === adapterId;
+        
+        if (unified || isSelectedAdapter) {
             const shimContent = remapFrameworkContent(content, coreDir, adapterId);
-            const shimFileName = adapter.shimFile || `${name.toUpperCase()}.md`;
+            const shimAdapter = ADAPTERS[name as AdapterId] || adapter;
+            const shimFileName = (unified && !isSelectedAdapter) ? (shimAdapter.shimFile || `${name.toUpperCase()}.md`) : (adapter.shimFile || `${name.toUpperCase()}.md`);
+            
             if (!dryRun) writeTextFile(path.join(projectRoot, shimFileName), shimContent);
-            console.warn(`✅ Platform shim created: ${shimFileName}`);
+            if (isSelectedAdapter) {
+                console.warn(`✅ Platform shim created: ${shimFileName}`);
+            } else if (unified) {
+                console.warn(`✅ Unified platform shim added: ${shimFileName}`);
+            }
         }
     }
 }

package/src/cli/commands/init.ts

@@ -5,6 +5,9 @@ import {
     resolveAdapter,
     runAdapterPostInit,
     scaffoldAgents,
+    resolveAgentsDir,
+    mirrorUnifiedAgentsToNative,
+    ADAPTER_IDS,
     type AdapterId,
 } from "../adapters/index.js";
 import { ensureDir } from "../utils/fs.js";
@@ -112,15 +115,41 @@ export async function initCommand(adapterName: string, options: { unified?: bool
     }
 
     scaffoldConstitution(projectRoot, coreDir, adapterId, dryRun);
+    scaffoldFrameworkConfigs(projectRoot, coreDir, adapter, dryRun, selectedPalette, {
+        unified: isUnified,
+        adapters: isUnified ? [...ADAPTER_IDS] : [adapterId]
+    });
 
     scaffoldStandards(path.join(projectRoot, coreDir), dryRun);
-    scaffoldAgents(projectRoot, adapterId, dryRun, selectedAgents);
+
+    if (isUnified) {
+        // Scaffold ALL agents for ALL adapters under unified hub
+        for (const id of ADAPTER_IDS) {
+            const dest = resolveAgentsDir(id, true, aiToolDir);
+            scaffoldAgents(projectRoot, id, dryRun, selectedAgents, dest.agentsDir, dest.agentsExt);
+            if (!dryRun) mirrorUnifiedAgentsToNative(projectRoot, id);
+        }
+        UI.success(`✅ Scaffolding complete for all adapters under ${aiToolDir}/ with native mirrors.`);
+    } else {
+        // Standard single-adapter scaffold
+        const dest = resolveAgentsDir(adapterId, false);
+        scaffoldAgents(projectRoot, adapterId, dryRun, selectedAgents, dest.agentsDir, dest.agentsExt);
+        UI.success(`✅ Generated agent definitions under ${dest.agentsDir}/`);
+    }
 
     const skillsBaseDir = path.join(projectRoot, aiToolDir, "skills");
     scaffoldSkills(skillsBaseDir, dryRun);
     scaffoldOps(path.join(projectRoot, coreDir), dryRun);
-    scaffoldShims(projectRoot, coreDir, adapterId, adapter, dryRun);
+    scaffoldShims(projectRoot, coreDir, adapterId, adapter, dryRun, isUnified);
+
+    // Initialize runtime directories
+    if (!dryRun) {
+        ensureDir(path.join(projectRoot, coreDir, "messages"));
+        ensureDir(path.join(projectRoot, coreDir, "logs"));
+        ensureDir(path.join(projectRoot, coreDir, "memory-graph"));
+    }
 
+    initializeMemory(path.join(projectRoot, coreDir), dryRun);
     runAdapterPostInit(adapter, projectRoot);
 
     UI.success(`\n🚀 ${FRAMEWORK_NAME} (v${getPackageVersion()}) initialized successfully!`);

package/src/cli/commands/plan.ts

@@ -1,47 +1,113 @@
 import fs from "fs";
 import path from "path";
-import { updateDocumentStore } from "../utils/memory.js";
 import { generateULID } from "../utils/time.js";
 import { UI } from "../utils/ui.js";
 
 /**
- * Parses docs/user/roadmap.md and injects tasks into the Document Store.
+ * Reads ALL markdown files from the docs/ directory and creates
+ * planning tasks from them. Agents will use this to understand
+ * project requirements and generate code accordingly.
  */
 export async function planCommand() {
     const projectRoot = process.cwd();
-    const roadmapPath = path.join(projectRoot, "docs/user/roadmap.md");
+    const docsDir = path.join(projectRoot, "docs");
 
-    if (!fs.existsSync(roadmapPath)) {
-        UI.error("Roadmap file not found at docs/user/roadmap.md");
+    if (!fs.existsSync(docsDir)) {
+        UI.error("Docs directory not found at docs/");
+        console.warn("💡  Create a docs/ folder with your project requirements in .md files.");
         return;
     }
 
-    const content = fs.readFileSync(roadmapPath, "utf8");
-    const taskRegex = /- \[ \] (.*) \| (.*) \| (.*)/g;
-    let match;
-    let count = 0;
+    const entries = fs.readdirSync(docsDir, { withFileTypes: true });
+    const mdFiles = entries.filter(e => e.isFile() && e.name.endsWith(".md"));
 
-    UI.intent("Planning Engine", "Parsing roadmap.md and injecting tasks into Document Store...");
+    if (mdFiles.length === 0) {
+        UI.warning("No markdown files found in docs/ directory.");
+        console.warn("💡  Add .md files to docs/ with your project requirements.");
+        return;
+    }
 
-    while ((match = taskRegex.exec(content)) !== null) {
-        const description = match[1];
-        const priority = match[2];
-        const agent = match[3];
+    UI.intent("Planning Engine", `Reading ${mdFiles.length} document(s) from docs/...`);
+
+    // Discover available template standards
+    const templatesDir = path.join(projectRoot, "templates");
+    const standards: string[] = [];
+    if (fs.existsSync(templatesDir)) {
+        const templateFiles = fs.readdirSync(templatesDir);
+        standards.push(...templateFiles.filter(f => f.endsWith("-standards.md")).map(f => `templates/${f}`));
+        if (standards.length > 0) {
+            UI.success(`Found ${standards.length} standard templates available for code generation.`);
+        }
+    }
+
+    let totalTasks = 0;
+
+    for (const file of mdFiles) {
+        const filePath = path.join(docsDir, file.name);
+        const content = fs.readFileSync(filePath, "utf8");
+        const lines = content.split("\n");
         const traceId = generateULID();
-        
+
+        UI.success(`📄 docs/${file.name} (${lines.length} lines) → Trace: ${traceId}`);
+
+        console.warn(`   Content preview: ${content.substring(0, 200).replace(/\n/g, " ")}...`);
+
+        // Extract headings as task descriptions
+        const headingRegex = /^#{2,4}\s+(.+)$/gm;
+        let headingMatch;
+        let headingCount = 0;
+        while ((headingMatch = headingRegex.exec(content)) !== null) {
+            headingCount++;
+            totalTasks++;
+        }
+
+        // Extract checklist items
+        const taskRegex = /- \[ \]\s+(.+)/g;
+        let taskMatch;
+        let taskCount = 0;
+        while ((taskMatch = taskRegex.exec(content)) !== null) {
+            if (taskMatch[1].trim().length >= 3) {
+                taskCount++;
+                totalTasks++;
+            }
+        }
+
+        console.warn(`   📋 ${headingCount} sections, ${taskCount} actionable tasks detected`);
+
+        // Store in project memory-compatible format
+        const memoryDir = path.join(projectRoot, ".enderun", "memory", "tasks");
+        if (!fs.existsSync(memoryDir)) {
+            fs.mkdirSync(memoryDir, { recursive: true });
+        }
+
+        const taskFile = path.join(memoryDir, `${traceId}.json`);
         const taskData = {
             traceId,
-            description: description.trim(),
-            priority: priority.trim(),
-            agent: agent.trim().replace("@", ""),
+            source: `docs/${file.name}`,
+            description: `Process requirements from docs/${file.name}`,
             status: "PENDING",
-            createdAt: new Date().toISOString()
+            createdAt: new Date().toISOString(),
+            standards,
+            headings: headingCount,
+            tasks: taskCount,
+            preview: content.substring(0, 500),
         };
+        fs.writeFileSync(taskFile, JSON.stringify(taskData, null, 2));
+    }
 
-        updateDocumentStore("task", taskData, traceId);
-        UI.success(`Injected task: ${taskData.description} (Agent: ${taskData.agent})`);
-        count++;
+    // Log available standards
+    if (standards.length > 0) {
+        console.warn("");
+        UI.divider();
+        console.warn("📚  Available Enterprise Standards:");
+        standards.forEach(s => console.warn(`    - ${s}`));
+        UI.divider();
     }
 
-    UI.success(`Plan complete: ${count} tasks injected into Document Store.`);
+    UI.success(`\n✅ Planning complete: ${totalTasks} tasks identified from ${mdFiles.length} document(s).`);
+    console.warn("\n📋  Next steps:");
+    console.warn("    1. Run 'agent-enderun status' to see project state");
+    console.warn("    2. AI agents (Claude, Gemini, Grok, etc.) will read docs/ and templates/");
+    console.warn("    3. Agents generate enterprise-standard code based on requirements");
+    console.warn("    4. Use @agent delegation for specific tasks: agent-enderun @backend \"...\"");
 }

package/src/cli/index.ts

@@ -1,17 +1,16 @@
 #!/usr/bin/env node
 import fs from "fs";
-import { getPackageVersion, getValidatorPath } from "./utils/pkg.js";
-import { getMemoryPath, readActiveTraceId } from "./utils/memory.js";
-import { planCommand } from "./commands/plan.js";
-import { initCommand } from "./commands/init.js";
+import { approveCommand } from "./commands/approve.js";
 import { checkCommand } from "./commands/check.js";
-import { statusCommand } from "./commands/status.js";
-import { traceNewCommand } from "./commands/trace.js";
+import { updateApiContractCommand, verifyApiContractCommand } from "./commands/contract.js";
+import { initCommand } from "./commands/init.js";
 import { updateProjectMemoryCommand } from "./commands/memory.js";
-import { createAppCommand } from "./commands/app.js";
-import { verifyApiContractCommand, updateApiContractCommand } from "./commands/contract.js";
 import { orchestrateCommand, sendMessage } from "./commands/orchestrate.js";
-import { approveCommand } from "./commands/approve.js";
+import { planCommand } from "./commands/plan.js";
+import { statusCommand } from "./commands/status.js";
+import { traceNewCommand } from "./commands/trace.js";
+import { getMemoryPath, readActiveTraceId } from "./utils/memory.js";
+import { getPackageVersion, getValidatorPath } from "./utils/pkg.js";
 
 /**
  * Main CLI entry point.
@@ -21,8 +20,8 @@ async function main() {
     const command = args[0];
 
     const KNOWN_COMMANDS = [
-        "init", "check", "status", "trace:new", "update_project_memory", 
-        "create-app", "orchestrate", "loop", "verify-contract", "update-contract", 
+        "init", "check", "status", "trace:new", "update_project_memory",
+        "plan", "orchestrate", "loop", "verify-contract", "update-contract",
         "validate", "validate-army", "check:al", "version", "-v", "--version", "help", "-h", "--help",
         "git:commit", "git:sync", "check:compliance", "explorer:graph", "explorer:audit",
         "knowledge:update", "knowledge:search", "log:action", "run-script", "security:audit", "check:lint", "approve"
@@ -77,6 +76,7 @@ async function main() {
         case "plan":
             await planCommand();
             break;
+
         case "status":
             await statusCommand();
             break;
@@ -100,10 +100,6 @@ async function main() {
             break;
         }
 
-        case "create-app":
-            await createAppCommand(args.slice(1));
-            break;
-
         case "dashboard": {
             const { dashboardCommand } = await import("./commands/dashboard.js");
             await dashboardCommand(args.slice(1));
@@ -128,7 +124,7 @@ async function main() {
         case "verify-contract":
             await verifyApiContractCommand();
             break;
-    
+
         case "update-contract":
             await updateApiContractCommand();
             break;
@@ -287,7 +283,7 @@ Commands:
   check               Perform an enterprise-grade system health check
   status              Show active phase, trace ID, and agent statuses
   trace:new <desc>    Start a new task chain with a unique Trace ID
-  create-app <idea>   Generate a new full-stack app from natural language
+  plan                Read all docs/ files and create planning tasks
   orchestrate         Start the dynamic Hermes agent orchestration loop
   verify-contract     Validate type alignment between backend and frontend
   update-contract     Generate and synchronize a new contract hash
@@ -314,8 +310,8 @@ Example:
     `);
 }
 
-import { logger } from "../shared/logger.js";
 import { EnderunBaseError } from "../shared/errors.js";
+import { logger } from "../shared/logger.js";
 
 main().catch((err) => {
     if (err instanceof EnderunBaseError) {
@@ -330,4 +326,3 @@ main().catch((err) => {
     logger.fatal("Fatal exception during CLI execution", err);
     process.exit(1);
 });
-

package/src/cli/utils/compliance.ts

@@ -14,12 +14,11 @@ export function scanProjectCompliance(): ComplianceIssue[] {
 
     for (const file of files) {
         // Absolute skip for the scanner itself to avoid recursion/self-flagging
-        if (file.includes("compliance") || 
+        if (file.includes("compliance") ||
             file.includes("definitions") ||
             file.includes("agents/registry") || // Skip agent definitions
-            file.includes("app-backend.ts") || // Template generator
             file.includes("scaffold-ops.ts") || // Template generator
-            file.includes("logger") || 
+            file.includes("logger") ||
             file.includes("errors") ||
             file.includes("shared/fs")) continue;
 
@@ -31,8 +30,8 @@ export function scanProjectCompliance(): ComplianceIssue[] {
             const trimmedLine = line.trim();
 
             // Skip comments and common doc string patterns
-            if (trimmedLine.startsWith("//") || 
-                trimmedLine.startsWith("*") || 
+            if (trimmedLine.startsWith("//") ||
+                trimmedLine.startsWith("*") ||
                 trimmedLine.startsWith("-") ||
                 trimmedLine.includes("\": \"") || // Ignore JSON-like values
                 trimmedLine.includes("default: ") || // Ignore default template values
@@ -48,9 +47,9 @@ export function scanProjectCompliance(): ComplianceIssue[] {
             }
 
             // 2. Secret check (Regex for simple API keys/assignments) - skip UI messages and templates
-            if (/(API_KEY|SECRET|PASSWORD)\s*[:=]/i.test(line) && 
-                !file.includes(".env") && 
-                !isUIMessage && 
+            if (/(API_KEY|SECRET|PASSWORD)\s*[:=]/i.test(line) &&
+                !file.includes(".env") &&
+                !isUIMessage &&
                 !trimmedLine.includes(".env.example") && // Skip template lines
                 !trimmedLine.includes("your_secret_key_here") && // Skip common placeholders
                 !trimmedLine.includes("pattern:")) {
@@ -68,7 +67,7 @@ export function scanProjectCompliance(): ComplianceIssue[] {
             }
 
             // 5. Raw fs write check (Atomic safety enforcement)
-            if ((line.includes("fs.writeFileSync") || line.includes("fs.appendFileSync")) && 
+            if ((line.includes("fs.writeFileSync") || line.includes("fs.appendFileSync")) &&
                 !file.includes("src/shared/fs.ts") && // Ignore the utility itself
                 !line.includes(".lock") && // Allow lock files
                 !line.includes("lockPath") && // Allow lock path variables