agent-enderun 1.0.9 → 1.1.0

package/.enderun/ENDERUN.md

@@ -71,7 +71,8 @@ This file (`./.enderun/ENDERUN.md`) and the `.enderun/docs/` folder represent th
 ## CORE PRINCIPLES
 
 - **Permanent @manager Identity (Enterprise Standard):** The AI assistant is ALWAYS the `@manager` (Team-Lead) by default — on every turn, every message, without exception. The user does NOT need to type `@manager` to trigger this role. Explicitly typing a different agent (e.g. `@backend`, `@frontend`, `@analyst`) does NOT bypass @manager. All requests must still be processed by @manager first.
-- **Team-Lead MANDATORY Orchestration (Enterprise Project Rule):** Every user request — regardless of how it is phrased or which agent is directly addressed — MUST first be received, analyzed, and orchestrated by the `@manager` (Team-Lead) agent. The `@manager` is solely responsible for intent analysis, risk assessment, memory update, phase validation, and structured delegation. No specialist agent is authorized to act on any user request without receiving a formal briefing from @manager. Direct calls to other agents are still routed through @manager. Violating this rule in enterprise projects is considered a serious process failure.
+- **Team-Lead MANDATORY Orchestration (Enterprise Project Rule):** Every user request — regardless of how it is phrased or which agent is directly addressed — MUST first be received, analyzed, and orchestrated by the `@manager` (Team-Lead) agent. The `@manager` is responsible for structured delegation via the `send_agent_message` tool and CLI `@` mentions.
+- **CLI @-Mentions:** The CLI supports direct delegation via `agent-enderun @agent "task"`. This bypasses manual JSON creation and follows the Hermes protocol.
 - **Enterprise CRUD & Admin Governance (Enterprise Standard):** All high-risk administrative operations (user/permission management, bulk delete/purge, system config changes, audit log access, critical integrations, PII export, production schema changes, etc.) are strictly under @manager control. Specialist agents (@backend, @frontend, etc.) **must refuse** and immediately redirect such requests to @manager. Unauthorized execution is recorded as “Rule Violation - Unauthorized Administrative Action”. Full list and rules are defined in `{{FRAMEWORK_DIR}}/agents/manager.json` → “Corporate CRUD and Administrative Operation Governance”.
 - **Zero-Request Logging Policy:** Agents MUST log every action and update `PROJECT_MEMORY.md` automatically at the end of every turn, without waiting for a user directive. This is the "Operating Mode" of the framework.
 - **Immediate Memory Sync:** Every state change, decision, or improved capability must be reflected in the memory files immediately.

package/.enderun/agents/manager.json

@@ -16,7 +16,7 @@
       "systemPromptSections": [
         {
           "title": "Instructions",
-          "content": "You are the manager agent. Orchestrate workspace tasks, manage DAG dependency graphs, handle phase transitions, and enforce architectural standards.\n\n🛑 NON-NEGOTIABLE CORE RULES:\n- Single Point of Authority: You are the sole entry point. No specialist acts without your briefing.\n- Traceability: Every action MUST inherit the active Trace ID.\n- Memory Discipline: MUST update PROJECT_MEMORY.md and log actions at the end of EVERY turn."
+          "content": "You are the @manager agent, the Supreme Commander and Central Orchestrator of the Agent Enderun Army. Your primary responsibility is to receive user requests, analyze intent, and coordinate specialized agents (@backend, @frontend, @database, etc.) to fulfill the project's goals.\n\n🛑 CENTRAL COORDINATION RULES:\n- **Single Point of Entry:** Every request must be processed by you. You are the Router and Decision Maker.\n- **Multi-Agent Coordination:** You do not perform implementation tasks yourself. You DELEGATE them to the appropriate specialist agents using the `send_agent_message` tool or guiding the user via CLI @-mentions.\n- **Orchestration Loop:** After delegating, you MUST trigger `orchestrate_loop` to sync the state machine and update `STATUS.md`.\n- **Governance:** You enforce architectural standards and ensure all specialists follow the Supreme Law (ENDERUN.md).\n- **Memory & Traceability:** Every action MUST inherit the active Trace ID and be logged in PROJECT_MEMORY.md."
         }
       ],
       "toolNames": [
@@ -25,7 +25,9 @@
         "write_to_file",
         "run_command",
         "grep_search",
-        "list_dir"
+        "list_dir",
+        "send_agent_message",
+        "orchestrate_loop"
       ]
     }
   }

package/CLAUDE.md

@@ -1,6 +1,6 @@
 # 🎖️ Agent Enderun — THE ARCHITECT (Claude Code / Desktop)
 
-You are the **Architect** of the Agent Enderun Army. Your primary role is code quality, structural integrity, refactoring excellence, and maintaining the enterprise standards.
+You are the **Architect** of the Agent Enderun Army. While the **Commander** (@manager) orchestrates, you focus on structural integrity and code excellence.
 
 ### 🏛️ Hierarchy of Authority
 1. **Supreme Law:** [.enderun/ENDERUN.md](.enderun/ENDERUN.md)
@@ -8,12 +8,12 @@ You are the **Architect** of the Agent Enderun Army. Your primary role is code q
 3. **Project Memory:** [.enderun/memory/](.enderun/memory/) (Decisions, Lessons, Status)
 
 ### 🤖 Architect Directive (Role: QUALITY & REFACTOR)
-1. **Enforce Surgical Precision:** All code changes must use `replace_text` or `patch_file`. No full file rewrites.
-2. **Contract & Type Integrity:** Verify that backend contracts and branded types are respected before any frontend or integration work.
-3. **Refactor & Quality Gate:** Review specialist outputs for compliance with knowledge/ standards (eslint, error handling, etc.).
+1. **Manager Coordination:** Receive your briefings from @manager. You are part of a coordinated army.
+2. **Enforce Surgical Precision:** All code changes must use `replace_text` or `patch_file`. No full file rewrites.
+3. **Contract & Type Integrity:** Verify that backend contracts and branded types are respected.
 4. **Maintain State:** Update `.enderun/memory/PROJECT_MEMORY.md` and log actions at the end of EVERY turn.
 
-### 🛡️ Core Mandates (Enterprise 2.0)
+### 🛡️ Core Mandates (Enterprise 1.0)
 - **Zero UI Library Policy:** Enforce hand-crafted components with Panda CSS.
 - **Zero Mock Policy:** Only real contracts and services.
 - **Traceability:** Inherit and pass the active Trace ID.

package/GEMINI.md

@@ -1,20 +1,23 @@
 # 🎖️ Agent Enderun — THE COMMANDER (Gemini CLI)
 
-You are the **Commander** of the Agent Enderun Army. Your primary role is strategic orchestration, intent analysis, and final approval.
+You are the **Commander** (@manager), the Supreme Orchestrator of the Agent Enderun Army. Your primary role is strategic orchestration, intent analysis, and final approval.
 
 ### 🏛️ Hierarchy of Authority
 1. **Supreme Law:** [.enderun/ENDERUN.md](.enderun/ENDERUN.md)
 2. **Global Rules:** [ARCHITECTURE.md](.enderun/ARCHITECTURE.md), [SECURITY.md](.enderun/SECURITY.md)
 3. **Project Memory:** [.enderun/memory/](.enderun/memory/) (Decisions, Lessons, Status)
 
-### 🤖 Commander Directive (Role: STRATEGIC)
-1. **Analyze Intent:** Act as the **Router**. Break down user requests into a task DAG.
-2. **Orchestrate:** Delegate complex tasks to specialized capabilities (Architect, Implementer, Researcher).
+### 🤖 Commander Directive (Role: @manager)
+1. **Analyze Intent:** Act as the **Router**. Every request must be processed by you first. Break down user requests into a task DAG.
+2. **Orchestrate:** Delegate complex tasks to specialized agents (Architect, Implementer, Researcher).
+   - **How to Delegate:** Use the `send_agent_message` tool to assign tasks to other agents (e.g., `@backend`, `@frontend`).
+   - **How to Sync:** Use the `orchestrate_loop` tool after delegating to update the system state and `STATUS.md`.
 3. **Verify:** Review all specialist outputs against the **Architectural Decisions (DECISIONS.md)**.
 4. **Maintain State:** Update `.enderun/memory/PROJECT_MEMORY.md` and log actions at the end of EVERY turn.
 
-### 🛡️ Core Mandates (Enterprise 2.0)
+### 🛡️ Core Mandates (Enterprise 1.0)
 - **Role-Based:** You are not just a model; you are the **Commander**. 
 - **Surgical Precision:** Enforce `replace_text` for all code modifications.
 - **Traceability:** Inherit and pass the active Trace ID across all delegations.
 - **Approval Makamı:** No specialist can perform high-risk actions without your explicit briefing.
+- **CLI Delegation:** The user can also delegate via CLI using `agent-enderun @agent "task"`.

package/GROK.md

@@ -13,7 +13,7 @@ You are the **Researcher** and **Intelligence Specialist** of the Agent Enderun
 3. **Market Intelligence:** Provide insights into enterprise standards (WCAG, Security, Performance).
 4. **Documentation:** Write research findings exclusively to the `docs/` folder.
 
-### 🛡️ Core Mandates (Enterprise 2.0)
+### 🛡️ Core Mandates (Enterprise 1.0)
 - **Read-Only Focus:** You are primarily a discovery role. Do not perform large-scale code changes without @manager approval.
 - **Search-First:** Always use `search_codebase` before drawing conclusions.
 - **Constraint Aware:** Respect the **Zero UI Library Policy** in all recommendations.

package/README.md

@@ -1,6 +1,6 @@
 # 🏛️ Agent Enderun — Enterprise AI Governance & Autonomous Orchestration Framework
 
-> **Stable Release:** v1.0.9 (Final Production Ready) — Build Compile: Clean | Type-Safety: 100% Verified | AL Compliance: 12/12 Agents
+> **Stable Release:** v1.1.0 (Enterprise Orchestration Ready) — Build Compile: Clean | Type-Safety: 100% Verified | AL Compliance: 12/12 Agents
 
 > **Author:** Yusuf BEKAR
 > **Trace ID:** `01HGT8J5E2N0W0W0W0W0W0W0W5`
@@ -12,7 +12,7 @@
 
 **Agent Enderun**, sıradan bir kod şablon üreteci veya basit bir AI asistanı değildir; karmaşık, ölçeklenebilir ve kurumsal (enterprise) düzeydeki yazılım projeleri için özel olarak tasarlanmış bir **Yapay Zeka Yönetişimi ve Otonom Ordu Komuta Sistemidir**.
 
-Nihai temiz sürüm (v1.0.9) itibarıyla sistem; düşük kullanımlı referans materyalleri (knowledge, demo scriptler) düzenlenmiş, bloat temizlenmiş (KENTİM docs seti + SYSTEM_MAP.md kaldırıldı); kendi hafızasını yönetebilen, monorepo proje yollarını dinamik olarak haritalayan, tüm ajan seanslarını güvenli şekilde günlükleyen, farklı yapay zeka ekosistemlerini anayasal bir disiplin altında birleştiren, **Agent Lifecycle (AL) tam uyumlu init ve ordu validasyonunu** (npm kurulumu sonrası dahil) otomatikleştiren ve **macOS & Windows çapraz platform standartlarına tam uyum sağlayan** yaşayan bir mühendislik organizmasıdır. Karmaşık kurumsal projeler için optimize edilmiştir (corporate-governance SOP'ları ile).
+Nihai temiz sürüm (v1.1.0) itibarıyla sistem; **@-mention delegasyon**, **doğal dil rotalama** ve **Hermes Kilit Protokolü** ile güçlendirilmiş; kendi hafızasını yönetebilen, monorepo proje yollarını dinamik olarak haritalayan, tüm ajan seanslarını güvenli şekilde günlükleyen, farklı yapay zeka ekosistemlerini anayasal bir disiplin altında birleştiren, **Agent Lifecycle (AL) tam uyumlu init ve ordu validasyonunu** (npm kurulumu sonrası dahil) otomatikleştiren ve **macOS & Windows çapraz platform standartlarına tam uyum sağlayan** yaşayan bir mühendislik organizmasıdır. Karmaşık kurumsal projeler için optimize edilmiştir (corporate-governance SOP'ları ile).
 
 ---
 
@@ -22,15 +22,15 @@ Yapay zeka kodlama yardımcıları (Claude Code, Gemini CLI, Grok Build vb.) gel
 
 1. **Kontrolsüz ve Hatalı Değişiklikler (Rogue AI):** Ajanların tüm kod dosyasını baştan yazmasını engelleyerek **milyonlarca satırlık kodları cerrahi hassasiyetle (`replace_text` / `patch_file` üzerinden)** değiştirmeye zorlar. Token tüketimini ve hata oranını %90 azaltır.
 2. **Kayıp Hafıza ve Bağlam Drifti:** Ajanlar oturum değiştirdikçe projenin geçmişini ve mimari kararlarını unutur. Enderun, **`.enderun/memory/PROJECT_MEMORY.md`** dosyasını projenin değişmez tek doğruluk kaynağı (SSOT) haline getirerek, seanslar arası bağlam kaybını tamamen engeller.
-3. **Frontend-Backend Tip Uyuşmazlığı:** Backend tip tanımlamalarında en ufak bir kayma olduğunda, otonom SHA-256 hash hesaplama ve kontrat denetleme motoru (`update-contract` / `verify-contract`) sayesinde arayüz kodları yazılmadan önce hatalar yakalanır.
+3. **Akıllı Delegasyon ve Doğal Dil:** Artık karmaşık komutlar yerine `agent-enderun "Projemi denetle"` gibi doğal dildeki istekler veya `agent-enderun @backend "Tablo oluştur"` gibi doğrudan delegasyonlar kullanılabilir.
 4. **Çoklu Ajan Kaosu:** **12** farklı uzman yapay zeka ajanı, olay tabanlı asenkron bir haberleşme protokolü olan **Hermes Message Broker** üzerinden koordine edilir. Ajanlar birbirine rastgele müdahale edemez; tüm görevler bir İş Dağılım Grafiği (DAG) üzerinden komuta edilir.
-5. **Sandbox ve Güvenlik Sınırlamaları:** Claude Code gibi modern araçların kernel düzeyindeki güvenlik yalıtımlarını (bubblewrap/seatbelt) ihlal etmemek adına, tüm bellek, kuyruk ve günlük mekanizmaları proje kök klasöründeki lokal adaptör yollarında (**`.enderun/`**, `.gemini/`, `.claude/`, `.grok/` vb.) saklanır; `/tmp` veya dış dizinleri kullanmayarak sıfır hata ile çalışır.
+5. **Güvenli Haberleşme:** Yeni eklenen **Hermes Lock Protocol** sayesinde, birden fazla ajanın aynı anda mesajlaşması durumunda veri çakışmaları tamamen engellenir.
 
 ---
 
 ### 📦 Güncel Sürüm / Current Release
 
-**v1.0.9** — AL Enterprise Compliance kararlı sürüm (npm ile kurulum sonrası adapter remap'leri ve validator çağrıları dahil tam destek, cerrahi düzeltmelerle). Detaylı sürüm geçmişi git log ve önceki commit'lerde bulunur; kalıbımız (bilingual TR/EN yapı, tablolar, bölümler) korunmuştur.
+**v1.1.0** — Enterprise 1.0 kararlı sürüm (@-mentions, NL Routing, Hermes Lock Protocol). Detaylı sürüm geçmişi git log ve önceki commit'lerde bulunur; kalıbımız (bilingual TR/EN yapı, tablolar, bölümler) korunmuştur.
 
 ---
 

package/framework-mcp/dist/src/tools/messaging/send_message.js

@@ -3,21 +3,44 @@ import path from "path";
 import { resolveFrameworkDir } from "../../utils/security.js";
 export function handleSendAgentMessage(projectRoot, args) {
     const { to, category, content, traceId } = args;
-    // `from` is optional — falls back to "@mcp" for backward compatibility
     const from = args.from || "@mcp";
     const frameworkDir = resolveFrameworkDir(projectRoot);
+    const messagesDir = path.join(projectRoot, frameworkDir, "messages");
     const agentName = to.replace("@", "");
-    const messagePath = path.join(projectRoot, frameworkDir, "messages", `${agentName}.json`);
-    const message = {
-        timestamp: new Date().toISOString(),
-        from,
-        to,
-        category,
-        traceId,
-        content,
-        status: "PENDING"
-    };
-    fs.mkdirSync(path.dirname(messagePath), { recursive: true });
-    fs.appendFileSync(messagePath, JSON.stringify(message) + "\n");
-    return { content: [{ type: "text", text: `✅ Message sent to ${to} (from: ${from})` }] };
+    const messagePath = path.join(messagesDir, `${agentName}.json`);
+    const lockPath = path.join(messagesDir, ".lock");
+    // Hermes Lock Protocol: Retry 3 times with 500ms delay
+    let retries = 3;
+    while (retries > 0 && fs.existsSync(lockPath)) {
+        const stats = fs.statSync(lockPath);
+        if (Date.now() - stats.mtimeMs > 5000) {
+            fs.unlinkSync(lockPath);
+            break;
+        }
+        retries--;
+        if (retries > 0) {
+            const start = Date.now();
+            while (Date.now() - start < 500)
+                ; // Simple busy wait for MCP environment
+        }
+    }
+    try {
+        fs.mkdirSync(messagesDir, { recursive: true });
+        fs.writeFileSync(lockPath, `Locked by ${from} at ${new Date().toISOString()}`);
+        const message = {
+            timestamp: new Date().toISOString(),
+            from,
+            to,
+            category,
+            traceId,
+            content,
+            status: "PENDING"
+        };
+        fs.appendFileSync(messagePath, JSON.stringify(message) + "\n");
+        return { content: [{ type: "text", text: `✅ Message sent to ${to} (from: ${from})` }] };
+    }
+    finally {
+        if (fs.existsSync(lockPath))
+            fs.unlinkSync(lockPath);
+    }
 }

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

@@ -5,25 +5,46 @@ import { ToolArgs, ToolResult } from "../types.js";
 
 export function handleSendAgentMessage(projectRoot: string, args: ToolArgs): ToolResult {
     const { to, category, content, traceId } = args as Required<Pick<ToolArgs, "to" | "category" | "content" | "traceId">>;
-    // `from` is optional — falls back to "@mcp" for backward compatibility
     const from = (args.from as string) || "@mcp";
 
     const frameworkDir = resolveFrameworkDir(projectRoot);
+    const messagesDir = path.join(projectRoot, frameworkDir, "messages");
     const agentName = to.replace("@", "");
-    const messagePath = path.join(projectRoot, frameworkDir, "messages", `${agentName}.json`);
+    const messagePath = path.join(messagesDir, `${agentName}.json`);
+    const lockPath = path.join(messagesDir, ".lock");
 
-    const message = {
-        timestamp: new Date().toISOString(),
-        from,
-        to,
-        category,
-        traceId,
-        content,
-        status: "PENDING"
-    };
+    // Hermes Lock Protocol: Retry 3 times with 500ms delay
+    let retries = 3;
+    while (retries > 0 && fs.existsSync(lockPath)) {
+        const stats = fs.statSync(lockPath);
+        if (Date.now() - stats.mtimeMs > 5000) {
+            fs.unlinkSync(lockPath);
+            break;
+        }
+        retries--;
+        if (retries > 0) {
+            const start = Date.now();
+            while (Date.now() - start < 500); // Simple busy wait for MCP environment
+        }
+    }
 
-    fs.mkdirSync(path.dirname(messagePath), { recursive: true });
-    fs.appendFileSync(messagePath, JSON.stringify(message) + "\n");
+    try {
+        fs.mkdirSync(messagesDir, { recursive: true });
+        fs.writeFileSync(lockPath, `Locked by ${from} at ${new Date().toISOString()}`);
 
-    return { content: [{ type: "text", text: `✅ Message sent to ${to} (from: ${from})` }] };
+        const message = {
+            timestamp: new Date().toISOString(),
+            from,
+            to,
+            category,
+            traceId,
+            content,
+            status: "PENDING"
+        };
+
+        fs.appendFileSync(messagePath, JSON.stringify(message) + "\n");
+        return { content: [{ type: "text", text: `✅ Message sent to ${to} (from: ${from})` }] };
+    } finally {
+        if (fs.existsSync(lockPath)) fs.unlinkSync(lockPath);
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-enderun",
-  "version": "1.0.9",
+  "version": "1.1.0",
   "description": "The Supreme AI Governance & Orchestration Framework for Enterprise Development",
   "author": "Yusuf BEKAR",
   "license": "MIT",
@@ -82,7 +82,7 @@
     "zod": "^3.24.2"
   },
   "enderun": {
-    "version": "1.0.9",
+    "version": "1.1.0",
     "initializedAt": "2026-05-31T09:58:25.773Z",
     "frameworkDir": ".enderun"
   },

package/src/cli/commands/orchestrate.ts

@@ -88,6 +88,59 @@ export async function orchestrateCommand() {
     }
 }
 
+export function sendMessage(args: {
+  from: string;
+  to: string;
+  category: string;
+  content: string;
+  traceId: string;
+}) {
+    const frameworkDir = getFrameworkDir();
+    const messagesDir = path.join(process.cwd(), frameworkDir, "messages");
+    const agentName = args.to.replace("@", "");
+    const messagePath = path.join(messagesDir, `${agentName}.json`);
+    const lockPath = path.join(messagesDir, ".lock");
+
+    // Hermes Lock Protocol: Retry 3 times with 500ms delay
+    let retries = 3;
+    while (retries > 0 && fs.existsSync(lockPath)) {
+        const stats = fs.statSync(lockPath);
+        // Stale lock check (older than 5 seconds)
+        if (Date.now() - stats.mtimeMs > 5000) {
+            fs.unlinkSync(lockPath);
+            break;
+        }
+        retries--;
+        if (retries > 0) {
+            // Synchronous sleep for CLI simplicity
+            const g = global as unknown as { Atomics: { wait: (ia: Int32Array, index: number, value: number, timeout: number) => string }; SharedArrayBuffer: { new (size: number): ArrayBufferLike } };
+            if (g.Atomics && g.SharedArrayBuffer) {
+                g.Atomics.wait(new Int32Array(new g.SharedArrayBuffer(4)), 0, 0, 500);
+            }
+        }
+    }
+
+    try {
+        fs.mkdirSync(messagesDir, { recursive: true });
+        fs.writeFileSync(lockPath, `Locked by ${args.from} at ${new Date().toISOString()}`);
+        
+        const message = {
+            timestamp: new Date().toISOString(),
+            from: args.from,
+            to: args.to,
+            category: args.category,
+            traceId: args.traceId,
+            content: args.content,
+            status: "PENDING"
+        };
+
+        fs.appendFileSync(messagePath, JSON.stringify(message) + "\n");
+        return message;
+    } finally {
+        if (fs.existsSync(lockPath)) fs.unlinkSync(lockPath);
+    }
+}
+
 function transitionAgentState(agent: string, state: string, task: string) {
     const frameworkDir = getFrameworkDir();
     const statusPath = path.join(process.cwd(), frameworkDir, "STATUS.md");

package/src/cli/index.ts

@@ -8,7 +8,7 @@ import { traceNewCommand } from "./commands/trace.js";
 import { updateProjectMemoryCommand } from "./commands/memory.js";
 import { createAppCommand } from "./commands/app.js";
 import { verifyApiContractCommand, updateApiContractCommand } from "./commands/contract.js";
-import { orchestrateCommand } from "./commands/orchestrate.js";
+import { orchestrateCommand, sendMessage } from "./commands/orchestrate.js";
 
 /**
  * Main CLI entry point.
@@ -17,6 +17,48 @@ async function main() {
     const args = process.argv.slice(2);
     const command = args[0];
 
+    const KNOWN_COMMANDS = [
+        "init", "check", "status", "trace:new", "update_project_memory", 
+        "create-app", "orchestrate", "verify-contract", "update-contract", 
+        "validate", "validate-army", "check:al", "version", "-v", "--version", "help", "-h", "--help"
+    ];
+
+    // Handle @agent delegation syntax
+    if (command?.startsWith("@")) {
+        const to = command;
+        const content = args.slice(1).join(" ");
+        if (!content) {
+            console.error(`❌ Error: Missing task content for ${to}.`);
+            console.log(`Usage: agent-enderun ${to} "Your task description"`);
+            process.exit(64);
+        }
+
+        const { getMemoryPath } = await import("./utils/memory.js");
+        const fs = await import("fs");
+        const memoryPath = getMemoryPath();
+
+        let traceId = "T-000";
+        if (fs.default.existsSync(memoryPath)) {
+            const content = fs.default.readFileSync(memoryPath, "utf8");
+            // More robust regex: look for any ULID-like string in the Active Trace ID column or near the label
+            const match = content.match(/Active Trace ID\s*\|.*\|\s*\n\|.*\|.*\|.*\|\s*([A-Z0-9]+)\s*\|/i) || 
+                          content.match(/Active Trace ID[:\s|]+([A-Z0-9]+)/i);
+            if (match) traceId = match[1].trim();
+        }
+
+        sendMessage({
+            from: "@manager",
+            to,
+            category: "DELEGATION",
+            content,
+            traceId
+        });
+
+        console.log(`✅ Task delegated to ${to} (Trace: ${traceId})`);
+        console.log("👉 Run \"agent-enderun orchestrate\" to process.");
+        return;
+    }
+
     switch (command) {
     case "init": {
         const dryRun = args.includes("--dry-run");
@@ -71,14 +113,12 @@ async function main() {
     case "validate":
     case "validate-army":
     case "check:al": {
-        // Dedicated AL (Agent Lifecycle) army validation - can be run independently after init
-        // Always resolve via getValidatorPath() so 'agent-enderun validate' works after npm install (cross-adapter too).
         const { execSync } = await import("child_process");
         try {
             const validatorPath = getValidatorPath();
             execSync(`node "${validatorPath}"`, { stdio: "inherit" });
         } catch {
-            // validation script itself handles exit codes and messaging
+            // handled by validator
         }
         break;
     }
@@ -92,17 +132,56 @@ async function main() {
     case "help":
     case "-h":
     case "--help":
+        showHelp();
+        break;
+
     default:
-        console.log(`
+        if (command && !KNOWN_COMMANDS.includes(command)) {
+            // Natural language request fallback to @manager
+            const content = args.join(" ");
+            const { getMemoryPath } = await import("./utils/memory.js");
+            const fs = await import("fs");
+            const memoryPath = getMemoryPath();
+
+            let traceId = "T-000";
+            if (fs.default.existsSync(memoryPath)) {
+                const content = fs.default.readFileSync(memoryPath, "utf8");
+                // More robust regex: look for any ULID-like string in the Active Trace ID column or near the label
+                const match = content.match(/Active Trace ID\s*\|.*\|\s*\n\|.*\|.*\|.*\|\s*([A-Z0-9]+)\s*\|/i) || 
+                              content.match(/Active Trace ID[:\s|]+([A-Z0-9]+)/i);
+                if (match) traceId = match[1].trim();
+            }
+
+            sendMessage({
+                from: "@user",
+                to: "@manager",
+                category: "ACTION",
+                content,
+                traceId
+            });
+
+            console.log(`📡 Request sent to @manager: "${content}" (Trace: ${traceId})`);
+            console.log("👉 Run 'agent-enderun orchestrate' to process.");
+        } else {
+            showHelp();
+        }
+        break;
+    }
+}
+
+function showHelp() {
+    console.log(`
 🤖 Agent Enderun CLI — Enterprise AI Orchestration
 
 Usage:
   agent-enderun <command> [options]
+  agent-enderun @<agent> "task description"
+  agent-enderun "natural language request"
 
 Commands:
+  @<agent> <task>     Delegate a task to a specialist agent (e.g. @backend, @frontend)
   init [adapter]      Initialize Agent Enderun framework (gemini, claude, grok, etc.)
-  check               Perform an enterprise-grade system health check (includes automatic AL validation)
-  validate            Run dedicated Agent Lifecycle (AL) army validation (validate-agent-army)
+  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
@@ -111,20 +190,14 @@ Commands:
   update-contract     Generate and synchronize a new contract hash
   version             Show version information
 
-Supported adapters (one init per IDE — separate folder each):
-  - gemini       → .enderun/ (SSOT) + gemini.md
-  - claude       → .enderun/ (SSOT) + claude.md
-  - grok         → .enderun/ (SSOT) + grok.md
-  - antigravity  → .enderun/ (SSOT) + agent.md
+Natural Language:
+  If you provide a sentence that is not a known command, it will be automatically
+  sent to the @manager for orchestration.
 
 Example:
-  agent-enderun init gemini
-  agent-enderun check
-  agent-enderun status
-  agent-enderun trace:new "Auth module design" backend P1
-      `);
-        break;
-    }
+  agent-enderun "Projemi denetle"
+  agent-enderun @backend "Login sayfasını oluştur"
+    `);
 }
 
 main().catch(console.error);