agent-enderun 1.10.2 → 1.11.0

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,18 +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);
-
-    initializeMemory(path.join(projectRoot, coreDir), dryRun);
-    scaffoldFrameworkConfigs(projectRoot, coreDir, adapter, dryRun, selectedPalette);
-    scaffoldStandards(path.join(projectRoot, coreDir), 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/orchestrate.ts

@@ -1,6 +1,5 @@
 import fs from "fs";
 import path from "path";
-import chalk from "chalk";
 import { getFrameworkDir, updateDocumentStore, readStatus } from "../utils/memory.js";
 import { UI } from "../utils/ui.js";
 import { writeTextFile, appendFile } from "../utils/fs.js";
@@ -19,7 +18,8 @@ export const HermesMessageSchema = z.object({
     parentId: z.string().optional(),
     status: z.enum(["PENDING", "PROCESSED", "WAITING", "APPROVED"]),
     priority: z.enum(["HIGH", "NORMAL", "LOW"]).optional(),
-    action: z.string().optional()
+    action: z.string().optional(),
+    requiresApproval: z.boolean().optional(),
 });
 
 export type HermesMessage = z.infer<typeof HermesMessageSchema>;
@@ -49,162 +49,182 @@ export async function orchestrateCommand() {
     isLooping = true;
 
     while (isLooping) {
-        // Initial load from disk to sync the cache
-        if (Object.keys(agentStatusCache).length === 0) {
-            const diskStatus = readStatus();
-            agentStatusCache = diskStatus || {};
-        }
+        try {
+            // Initial load from disk to sync the cache
+            if (Object.keys(agentStatusCache).length === 0) {
+                const diskStatus = readStatus();
+                agentStatusCache = diskStatus || {};
+            }
 
-        // Check for agent timeouts (e.g. 30 minutes in EXECUTING state)
-        const agentStatuses = readStatus();
-        let updatedStatus = false;
-        for (const [agentName, info] of Object.entries(agentStatuses)) {
-            const { state, lastUpdated } = info as { state: string; task: string; lastUpdated?: string };
-            if (state === "EXECUTING" && lastUpdated) {
-                const lastUpdatedTime = Date.parse(lastUpdated);
-                if (!isNaN(lastUpdatedTime) && Date.now() - lastUpdatedTime > 30 * 60 * 1000) {
-                    UI.error(`⚠️  Agent ${agentName} has TIMED OUT (in EXECUTING state for >30m). Transitioning to BLOCKED.`);
-                    agentStatuses[agentName] = { state: "BLOCKED", task: "Timeout occurred", lastUpdated: new Date().toISOString() };
-                    updatedStatus = true;
+            // Check for agent timeouts (e.g. 30 minutes in EXECUTING state)
+            const agentStatuses = readStatus();
+            let updatedStatus = false;
+            for (const [agentName, info] of Object.entries(agentStatuses)) {
+                const { state, lastUpdated } = info as { state: string; task: string; lastUpdated?: string };
+                if (state === "EXECUTING" && lastUpdated) {
+                    const lastUpdatedTime = Date.parse(lastUpdated);
+                    if (!isNaN(lastUpdatedTime) && Date.now() - lastUpdatedTime > 30 * 60 * 1000) {
+                        UI.error(`⚠️  Agent ${agentName} has TIMED OUT (in EXECUTING state for >30m). Transitioning to BLOCKED.`);
+                        agentStatuses[agentName] = { state: "BLOCKED", task: "Timeout occurred", lastUpdated: new Date().toISOString() };
+                        updatedStatus = true;
+                    }
                 }
             }
-        }
-        if (updatedStatus) {
-            updateDocumentStore("status", agentStatuses);
-            agentStatusCache = { ...agentStatuses }; // Sync cache
-        }
+            if (updatedStatus) {
+                updateDocumentStore("status", agentStatuses);
+                agentStatusCache = { ...agentStatuses }; // Sync cache
+            }
 
-        if (fs.existsSync(messagesDir)) {
-            const messageFiles = fs.readdirSync(messagesDir).filter((f) => f.endsWith(".json"));
-            const pendingMessages: HermesMessage[] = [];
-            const fileMessagesMap: Record<string, HermesMessage[]> = {};
+            if (fs.existsSync(messagesDir)) {
+                const messageFiles = fs.readdirSync(messagesDir).filter((f) => f.endsWith(".json"));
+                const pendingMessages: HermesMessage[] = [];
+                const fileMessagesMap: Record<string, HermesMessage[]> = {};
 
-            for (const file of messageFiles) {
-                const filePath = path.join(messagesDir, file);
-                try {
-                    const content = fs.readFileSync(filePath, "utf8").trim();
-                    if (!content) continue;
-                    const lines = content.split("\n");
-                    const allMsgs: HermesMessage[] = [];
-                    lines.forEach((line) => {
-                        if (!line.trim()) return;
-                        try {
-                            const parsed = JSON.parse(line);
-                            const msg = HermesMessageSchema.parse(parsed);
-
-                            // Contract Validation
-                            if (msg.category === "ACTION" || msg.category === "DELEGATION") {
-                                try {
-                                    const payload = JSON.parse(msg.content);
-                                    TaskRequestSchema.parse(payload);
-                                } catch (e) {
-                                    UI.error(`Invalid task contract payload: ${(e as Error).message}`);
-                                    return; // Skip invalid message
+                for (const file of messageFiles) {
+                    const filePath = path.join(messagesDir, file);
+                    try {
+                        const content = fs.readFileSync(filePath, "utf8").trim();
+                        if (!content) continue;
+                        const lines = content.split("\n");
+                        const allMsgs: HermesMessage[] = [];
+                        lines.forEach((line) => {
+                            if (!line.trim()) return;
+                            try {
+                                const parsed = JSON.parse(line);
+                                const msg = HermesMessageSchema.parse(parsed);
+
+                                // Contract Validation
+                                if (msg.category === "ACTION" || msg.category === "DELEGATION") {
+                                    try {
+                                        const payload = JSON.parse(msg.content);
+                                        TaskRequestSchema.parse(payload);
+                                    } catch (e) {
+                                        UI.error(`Invalid task contract payload: ${(e as Error).message}`);
+                                        return; // Skip invalid message
+                                    }
                                 }
-                            }
 
-                            if (msg.status === "PENDING") {
-                                pendingMessages.push(msg);
+                                // A message is actionable if it's pending, or if it's been approved.
+                                if (msg.status === "PENDING" || msg.status === "APPROVED") {
+                                    pendingMessages.push(msg);
+                                }
+                                allMsgs.push(msg);
+                            } catch (e) {
+                                UI.error(`Skipping invalid Hermes message format: ${(e as Error).message}`);
                             }
-                            allMsgs.push(msg);
-                        } catch (e) {
-                            UI.error(`Skipping invalid Hermes message format: ${(e as Error).message}`);
-                        }
-                    });
-                    fileMessagesMap[file] = allMsgs;
-                } catch (err) {
-                    UI.error(`Error occurred while reading ${file}.`);
-                    logger.debug(`Failed to read message file ${file}`, err);
+                        });
+                        fileMessagesMap[file] = allMsgs;
+                    } catch (err) {
+                        UI.error(`Error occurred while reading ${file}.`);
+                        logger.debug(`Failed to read message file ${file}`, err);
+                    }
                 }
-            }
 
-            if (pendingMessages.length > 0) {
-                // Sort by priority: HIGH -> NORMAL -> LOW
-                const priorityOrder = { HIGH: 1, NORMAL: 2, LOW: 3 };
-                pendingMessages.sort((a, b) => {
-                    const pA = priorityOrder[a.priority || "NORMAL"] || 2;
-                    const pB = priorityOrder[b.priority || "NORMAL"] || 2;
-                    if (pA !== pB) return pA - pB;
-                    return Date.parse(a.timestamp) - Date.parse(b.timestamp);
-                });
+                if (pendingMessages.length > 0) {
+                    // Sort by priority: HIGH -> NORMAL -> LOW
+                    const priorityOrder = { HIGH: 1, NORMAL: 2, LOW: 3 };
+                    pendingMessages.sort((a, b) => {
+                        const pA = priorityOrder[a.priority || "NORMAL"] || 2;
+                        const pB = priorityOrder[b.priority || "NORMAL"] || 2;
+                        if (pA !== pB) return pA - pB;
+                        return Date.parse(a.timestamp) - Date.parse(b.timestamp);
+                    });
+
+                    UI.intent("Multi-Agent Orchestration", `${pendingMessages.length} pending tasks and collaboration messages found.`);
 
-                UI.intent("Multi-Agent Orchestration", `${pendingMessages.length} pending tasks and collaboration messages found.`);
+                    const statusChanges: Record<string, { state: string; task: string }> = {};
 
-                const statusChanges: Record<string, { state: string; task: string }> = {};
+                    for (const msg of pendingMessages) {
+                        const { from, to, content, traceId, category, status, requiresApproval } = msg;
 
-                for (const msg of pendingMessages) {
-                    const { from, to, content, traceId, category, parentId } = msg;
+                        // Approval Gate for high-risk actions.
+                        // If it requires approval but isn't approved yet, skip it for now.
+                        if ((category === "ACTION" || category === "ALERT") && requiresApproval && status !== "APPROVED") {
+                            logger.debug(`Action for @${to} (Trace: ${traceId}) is pending manager approval.`);
+                            continue;
+                        }
+                        
+                        // Gate for regular messages.
+                        // If it's a non-approval-required message, it should only be processed when PENDING.
+                        // This prevents re-processing of SUBTASK/REPLY messages that might get set to APPROVED.
+                        if (!(category === "ACTION" || category === "ALERT") && status !== "PENDING") {
+                            continue;
+                        }
 
-                    const isSubtask = category === "SUBTASK" || !!parentId;
-                    const agentLabel = isSubtask ? `${to} (Sub-Agent)` : to;
 
-                    UI.agentBox(agentLabel, content, `Trace: ${traceId} | From: ${from} | Category: ${category}`);
+                        const isSubtask = category === "SUBTASK" || !!msg.parentId;
+                        const agentLabel = isSubtask ? `${to} (Sub-Agent)` : to;
 
-                    let targetState = "EXECUTING";
-                    if (category === "DELEGATION" || category === "SUBTASK") targetState = "BRIEFED";
+                        UI.agentBox(agentLabel, content, `Trace: ${traceId} | From: ${from} | Category: ${category}`);
 
-                    let taskDescription = content;
-                    if (category === "DELEGATION" || category === "ACTION") {
-                        try {
-                            const payload = JSON.parse(content);
-                            taskDescription = payload.task || content;
-                        } catch {
-                            // Ignore
+                        let targetState = "EXECUTING";
+                        if (category === "DELEGATION" || category === "SUBTASK") targetState = "BRIEFED";
+
+                        let taskDescription = content;
+                        if (category === "DELEGATION" || category === "ACTION") {
+                            try {
+                                const payload = JSON.parse(content);
+                                taskDescription = payload.task || content;
+                            } catch {
+                                // Ignore
+                            }
                         }
-                    }
 
-                    statusChanges[to] = { state: targetState, task: taskDescription };
+                        statusChanges[to] = { state: targetState, task: taskDescription };
 
-                    if (targetState === "BRIEFED") {
-                        UI.success(`${to} informed and took over the task.`);
-                        statusChanges[to] = { state: "EXECUTING", task: taskDescription };
-                    }
+                        if (targetState === "BRIEFED") {
+                            UI.success(`${to} informed and took over the task.`);
+                            statusChanges[to] = { state: "EXECUTING", task: taskDescription };
+                        }
 
-                    if (isSubtask) {
-                        UI.success(`Sub-task connection established (Parent: ${parentId || "Unknown"}).`);
-                    }
+                        if (isSubtask) {
+                            UI.success(`Sub-task connection established (Parent: ${msg.parentId || "Unknown"}).`);
+                        }
 
-                    UI.success(`Collaboration initiated: ${from} -> ${to}`);
-                    console.warn(chalk.gray(`  👉 Instructions: ${frameworkDir}/agents/${to.replace("@", "")}.md`));
+                        UI.success(`Collaboration initiated: ${from} -> ${to}`);
 
-                    msg.status = "PROCESSED";
-                }
+                        msg.status = "PROCESSED";
+                    }
 
-                applyBatchStatusUpdates(statusChanges);
+                    applyBatchStatusUpdates(statusChanges);
 
-                const archiveDir = path.join(messagesDir, "archive");
-                
-                for (const file of Object.keys(fileMessagesMap)) {
-                    const filePath = path.join(messagesDir, file);
-                    const msgs = fileMessagesMap[file];
-                    
-                    const activeMsgs = msgs.filter(m => m.status !== "PROCESSED");
-                    const processedMsgs = msgs.filter(m => m.status === "PROCESSED");
+                    const archiveDir = path.join(messagesDir, "archive");
                     
-                    try {
-                        if (activeMsgs.length > 0) {
-                            const updatedContent = activeMsgs.map(m => JSON.stringify(m)).join("\n") + "\n";
-                            writeTextFile(filePath, updatedContent);
-                        } else if (fs.existsSync(filePath)) {
-                            writeTextFile(filePath, "");
-                        }
+                    for (const file of Object.keys(fileMessagesMap)) {
+                        const filePath = path.join(messagesDir, file);
+                        const msgs = fileMessagesMap[file];
+                        
+                        const activeMsgs = msgs.filter(m => m.status !== "PROCESSED");
+                        const processedMsgs = msgs.filter(m => m.status === "PROCESSED");
+                        
+                        try {
+                            if (activeMsgs.length > 0) {
+                                const updatedContent = activeMsgs.map(m => JSON.stringify(m)).join("\n") + "\n";
+                                writeTextFile(filePath, updatedContent);
+                            } else if (fs.existsSync(filePath)) {
+                                writeTextFile(filePath, "");
+                            }
 
-                        if (processedMsgs.length > 0) {
-                            if (!fs.existsSync(archiveDir)) {
-                                fs.mkdirSync(archiveDir, { recursive: true });
+                            if (processedMsgs.length > 0) {
+                                if (!fs.existsSync(archiveDir)) {
+                                    fs.mkdirSync(archiveDir, { recursive: true });
+                                }
+                                const agentName = file.replace(".json", "");
+                                const archivePath = path.join(archiveDir, `${agentName}_archive.json`);
+                                const archiveContent = processedMsgs.map(m => JSON.stringify(m)).join("\n") + "\n";
+                                appendFile(archivePath, archiveContent);
+                                UI.success(`Archived ${processedMsgs.length} messages for @${agentName}`);
                             }
-                            const agentName = file.replace(".json", "");
-                            const archivePath = path.join(archiveDir, `${agentName}_archive.json`);
-                            const archiveContent = processedMsgs.map(m => JSON.stringify(m)).join("\n") + "\n";
-                            appendFile(archivePath, archiveContent);
-                            UI.success(`Archived ${processedMsgs.length} messages for @${agentName}`);
+                        } catch (err) {
+                            UI.error(`Error occurred while updating and archiving the message file ${file}.`);
+                            logger.debug(`Failed to update and archive message file ${file}`, err);
                         }
-                    } catch (err) {
-                        UI.error(`Error occurred while updating and archiving the message file ${file}.`);
-                        logger.debug(`Failed to update and archive message file ${file}`, err);
                     }
                 }
             }
+        } catch (globalLoopErr) {
+            UI.error(`⚠️  Critical error in Hermes orchestration loop: ${(globalLoopErr as Error).message}`);
+            logger.debug("Hermes global loop failure", globalLoopErr);
         }
 
         // Prevent 100% CPU and provide breathing room for I/O
@@ -223,6 +243,7 @@ export async function sendMessage(args: {
     traceId: string;
     parentId?: string;
     priority?: "HIGH" | "NORMAL" | "LOW";
+    requiresApproval?: boolean;
 }) {
     const frameworkDir = getFrameworkDir();
     const messagesDir = path.join(frameworkDir, "messages");
@@ -274,11 +295,14 @@ export async function sendMessage(args: {
 
     try {
         const defaultPriority = (args.category === "ALERT" || args.category === "ACTION") ? "HIGH" : "NORMAL";
+        const requiresApproval = args.requiresApproval !== undefined ? args.requiresApproval : (args.category === "ALERT" || args.category === "ACTION");
+
         const message: HermesMessage = {
             timestamp: new Date().toISOString(),
             priority: args.priority || defaultPriority,
             ...args,
-            status: "PENDING"
+            status: "PENDING",
+            requiresApproval: requiresApproval,
         };
         
         appendFile(messagePath, JSON.stringify(message) + "\n");

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);
 });
-