agent-enderun 1.10.4 → 1.11.1

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.1",
   "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.1",
     "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;
 
@@ -38,6 +48,10 @@ export function scaffoldAgents(projectRoot: string, adapterId: AdapterId, dryRun
                 case "gemini":
                     content = toGeminiCliMd(agent, baseKnowledgeDir);
                     break;
+                case "grok":
+                    // Grok uses same Gemini-compatible YAML format
+                    content = toGeminiCliMd(agent, baseKnowledgeDir);
+                    break;
                 case "claude":
                     content = toClaudeCodeMd(agent, baseKnowledgeDir);
                     break;
@@ -52,7 +66,7 @@ export function scaffoldAgents(projectRoot: string, adapterId: AdapterId, dryRun
                     const agentDir = path.join(destAgentsDir, agent.name);
                     if (!dryRun) fs.mkdirSync(agentDir, { recursive: true });
                     
-                    content = toAntigravityJson(agent);
+                    content = toAntigravityJson(agent, baseKnowledgeDir);
                     fileName = path.join(agent.name, "agent.json");
                     
                     secondaryContent = `# 🎖️ Agent Enderun — @${agent.name}\n\n${agent.instructions.identity}\n\n${agent.instructions.mission}`;
@@ -72,8 +86,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/orchestrate.ts

@@ -28,11 +28,16 @@ export type HermesMessage = z.infer<typeof HermesMessageSchema>;
 let agentStatusCache: Record<string, { state: string; task: string; lastUpdated?: string }> = {};
 let isLooping = false;
 
-export async function orchestrateCommand() {
+export async function orchestrateCommand(options?: { maxIterations?: number }) {
     UI.intent("Hermes Message Broker", "Starting the live agent orchestration loop...");
 
     const frameworkDir = getFrameworkDir();
     const messagesDir = path.join(frameworkDir, "messages");
+    const maxIterations = options?.maxIterations;
+    let iterationCount = 0;
+
+    // Reset in-memory cache so each invocation starts fresh (important for test isolation)
+    agentStatusCache = {};
 
     // Graceful Shutdown Handling
     const shutdown = async () => {
@@ -93,16 +98,36 @@ export async function orchestrateCommand() {
                                 const parsed = JSON.parse(line);
                                 const msg = HermesMessageSchema.parse(parsed);
 
-                                // Contract Validation
+                                // Contract Validation for structured task messages
+                                // ACTION & DELEGATION must be valid TaskRequest payloads
+                                // SUBTASK must have a parentId and valid task payload
+                                // ALERT must have a content string (free-form, no schema required)
                                 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}`);
+                                        UI.error(`Invalid task contract payload in ${msg.category} from @${msg.from}: ${(e as Error).message}`);
                                         return; // Skip invalid message
                                     }
                                 }
+                                if (msg.category === "SUBTASK") {
+                                    if (!msg.parentId) {
+                                        UI.error(`SUBTASK from @${msg.from} is missing required parentId — skipping.`);
+                                        return;
+                                    }
+                                    try {
+                                        const payload = JSON.parse(msg.content);
+                                        TaskRequestSchema.parse(payload);
+                                    } catch (e) {
+                                        UI.error(`Invalid SUBTASK payload from @${msg.from}: ${(e as Error).message}`);
+                                        return;
+                                    }
+                                }
+                                if (msg.category === "ALERT" && !msg.content.trim()) {
+                                    UI.error(`ALERT from @${msg.from} has empty content — skipping.`);
+                                    return;
+                                }
 
                                 // A message is actionable if it's pending, or if it's been approved.
                                 if (msg.status === "PENDING" || msg.status === "APPROVED") {
@@ -227,6 +252,13 @@ export async function orchestrateCommand() {
             logger.debug("Hermes global loop failure", globalLoopErr);
         }
 
+        iterationCount++;
+        // If maxIterations is set (e.g. in tests), stop after N iterations without sleeping
+        if (maxIterations !== undefined && iterationCount >= maxIterations) {
+            isLooping = false;
+            break;
+        }
+
         // Prevent 100% CPU and provide breathing room for I/O
         await sleep(2000);
     }
@@ -295,7 +327,12 @@ 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");
+        // Only ALERT requires manager approval by default.
+        // ACTION messages flow freely unless the caller explicitly sets requiresApproval=true.
+        // This prevents workflow blockage on normal agent-to-agent task delegation.
+        const requiresApproval = args.requiresApproval !== undefined
+            ? args.requiresApproval
+            : args.category === "ALERT";
 
         const message: HermesMessage = {
             timestamp: new Date().toISOString(),

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 \"...\"");
 }