agent-enderun 1.1.4 → 1.1.5

package/src/cli/commands/init.ts

@@ -11,7 +11,8 @@ import {
 } from "../adapters.js";
 import { getPackageRoot, getPackageVersion } from "../utils/pkg.js";
 import { ensureDir, writeJsonFile } from "../utils/fs.js";
-import { initializeMemory } from "../utils/memory.js";
+import { initializeMemory, getConfiguredPaths } from "../utils/memory.js";
+import { SHIM_TEMPLATES } from "../shims.js";
 
 // Import Modular Definitions
 import { ALL_AGENTS, buildAgentJson } from "../../modules/agents/definitions.js";
@@ -22,7 +23,6 @@ const FRAMEWORK_NAME = "Enderun Core";
 const FRAMEWORK_VERSION = getPackageVersion();
 
 const FRAMEWORK_SUBDIRS = [
-    "apps",
     "agents",
     "skills",
     "knowledge",
@@ -33,6 +33,7 @@ const FRAMEWORK_SUBDIRS = [
     "rules",
 ];
 
+
 const COLOR_PALETTES = {
     "Modern Blue": { primary: "#0ea5e9", secondary: "#64748b", accent: "#f43f5e" },
     "Enterprise Slate": { primary: "#334155", secondary: "#94a3b8", accent: "#10b981" },
@@ -68,16 +69,19 @@ async function runInteractiveInit(): Promise<{ selectedDirs: string[], selectedA
 function scaffoldConstitution(targetDir: string, frameworkDir: string, adapterId: AdapterId, dryRun: boolean) {
     if (dryRun) return;
     let content = `# 🎖️ ${FRAMEWORK_NAME} — Constitution (v${FRAMEWORK_VERSION})\n\nDiscipline and Order.`;
+    let readSuccess = false;
     try {
         const templatePath = path.join(getPackageRoot(), "ENDERUN.md");
         if (fs.existsSync(templatePath)) {
             content = fs.readFileSync(templatePath, "utf8");
+            readSuccess = true;
         }
-    } catch {
-        // Fallback to default content
+    } catch (e) {
+        console.warn(`⚠️  Failed to read global constitution template: ${e}`);
     }
     content = remapFrameworkContent(content, frameworkDir, adapterId);
     fs.writeFileSync(path.join(targetDir, "ENDERUN.md"), content);
+    console.warn(`✅ Constitution file created: ENDERUN.md${readSuccess ? "" : " (default template)"}`);
 }
 
 function scaffoldCoreAgents(agentsToScaffold: string[], agentsBaseDir: string, adapterId: string, dryRun: boolean) {
@@ -104,10 +108,12 @@ function scaffoldCoreAgents(agentsToScaffold: string[], agentsBaseDir: string, a
             const mdContent = `---
 name: "${ag.name}"
 description: "${ag.description}"
-capability: ${ag.capability}
-tags: [${ag.tags.map(t => `"${t}"`).join(", ")}]
 ---
 
+<!-- capability: ${ag.capability} -->
+<!-- tags: [${ag.tags.map(t => `"${t}"`).join(", ")}] -->
+
+
 # 🎖️ ${FRAMEWORK_NAME} — @${ag.name} (${ag.displayName})
 
 ## 🤖 Talimatlar (Instructions)
@@ -128,7 +134,16 @@ function scaffoldSkills(skillsBaseDir: string, dryRun: boolean) {
     if (dryRun) return;
     ensureDir(skillsBaseDir, dryRun);
     for (const [key, skill] of Object.entries(CORE_SKILLS)) {
-        const mdContent = `# 🛠️ ${FRAMEWORK_NAME} Skill — ${skill.name}\n\n${skill.mandates.join("\n")}\n`;
+        const mdContent = `# 🛠️ ${FRAMEWORK_NAME} Skill — ${skill.name}
+
+${skill.description}
+
+## 🔌 Associated Tools
+${skill.tools.map(t => `- \`${t}\``).join("\n")}
+
+## 🛡️ Core Mandates
+${skill.mandates.join("\n")}
+`;
         fs.writeFileSync(path.join(skillsBaseDir, `${key.toLowerCase()}.md`), mdContent);
     }
 }
@@ -147,7 +162,29 @@ function scaffoldFrameworkConfigs(targetDir: string, fDir: string, adapter: Adap
         }
     };
     writeJsonFile(path.join(frameworkDir, "config.json"), config, dryRun);
-    fs.writeFileSync(path.join(frameworkDir, "STATUS.md"), "# 🎖️ Status\n\nStable.\n");
+    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";
+    }
+    fs.writeFileSync(path.join(frameworkDir, "STATUS.md"), statusContent);
+
+    // Scaffold eslint-standards.md
+    let knowledgeDir = "knowledge";
+    if (fDir === ".github") knowledgeDir = "instructions";
+    const eslintStandardsContent = `# 🎖️ Agent Enderun — ESLint Standards
+
+This document outlines the strict ESLint coding standards for Agent Enderun projects.
+
+## 📏 Core Rules
+- **Indentation:** 4 spaces (strict).
+- **Quotes:** Double quotes (\`"\`) for strings.
+- **Semicolons:** Always terminate statements with a semicolon (\`;\`).
+- **No Explicit Any:** Avoid using \`any\`. Use strongly typed interfaces, generics, or \`unknown\` with type assertions.
+- **Unused Variables:** Warning on unused variables unless prefixed with an underscore (\`_\`).
+`;
+    const knowledgePath = path.join(frameworkDir, knowledgeDir);
+    if (!fs.existsSync(knowledgePath)) fs.mkdirSync(knowledgePath, { recursive: true });
+    fs.writeFileSync(path.join(knowledgePath, "eslint-standards.md"), eslintStandardsContent);
     
     // Scaffold cli-commands.json
     const cliCommands = {
@@ -166,9 +203,125 @@ function scaffoldFrameworkConfigs(targetDir: string, fDir: string, adapter: Adap
     // Scaffold BRAIN_DASHBOARD.md
     fs.writeFileSync(path.join(frameworkDir, "BRAIN_DASHBOARD.md"), "# 🧠 Brain Dashboard\n\nActive Trace: T-000\nActive Phase: PHASE_0 (Genesis)\n\n## Ajan Durumları (Agent Statuses)\n- @manager: READY\n- @architect: READY\n- @backend: READY\n- @frontend: READY\n- @quality: READY\n");
 
+    // Scaffold router/routing_rules.md
+    const routerDir = path.join(frameworkDir, "router");
+    if (!fs.existsSync(routerDir)) fs.mkdirSync(routerDir, { recursive: true });
+    fs.writeFileSync(
+        path.join(routerDir, "routing_rules.md"),
+        `# 📡 Agent Enderun — Natural Language & Event Router
+
+This configuration governs how user inputs and event messages are routed across the 12 expert agents.
+
+## 🧭 Routing Engine Protocols
+- **User Input Routing:** By default, all un-targeted natural language prompts are routed to the \`@manager\` agent for analysis and decomposition into a Directed Acyclic Graph (DAG) task list.
+- **Targeted Input Routing:** Prompts beginning with \`@<agent_name>\` (e.g., \`@backend\`) bypass the general manager routing and are directly appended to the target agent's Hermes mailbox.
+- **Hermes Event Loops:** Agents publish status changes and handoffs which the message broker routes dynamically according to active dependencies.
+`
+    );
+
+    // Scaffold registry/agent_registry.md
+    const registryDir = path.join(frameworkDir, "registry");
+    if (!fs.existsSync(registryDir)) fs.mkdirSync(registryDir, { recursive: true });
+    fs.writeFileSync(
+        path.join(registryDir, "agent_registry.md"),
+        `# 🎖️ Agent Enderun — Army Registry
+
+List of active agents, their roles, capacities, and matching directory patterns.
+
+| Agent Name | Role | Scope / Globs | Action Compliance |
+|---|---|---|---|
+| \`@manager\` | Orchestrator & Controller | \`*\` | Rules Verification |
+| \`@quality\` | Quality & Test Enforcer | \`*\` | AST Security Scans |
+| \`@database\` | Database Optimizer | \`apps/backend/src/database/**/*\` | Schema & Migrations |
+| \`@backend\` | Core Domain Developer | \`apps/backend/**/*\` | Branded Types & APIs |
+| \`@frontend\` | UI/UX Developer | \`apps/web/**/*\` | Panda CSS, Fluid UI |
+| \`@mobile\` | Mobile App Specialist | \`apps/mobile/**/*\` | Expo/React Native |
+| \`@native\` | Desktop / Native Integrator | \`apps/native/**/*\` | Electron/Tauri |
+| \`@devops\` | Deployment & CI/CD | CI/CD YAML & Deployment files | Native Rollbacks |
+| \`@explorer\` | Codebase Discovery | All source directories | Onboarding & Audit |
+| \`@git\` | Version Control System | \`.git/\` & Commit traces | Trace ID commits |
+| \`@security\` | Security Officer | All source directories | RLS & Secrets Scan |
+| \`@analyst\` | Contract Validator | Contract and API schema definitions | SHA-256 validation |
+`
+    );
+
+    // Scaffold observability files
+    const obsDir = path.join(frameworkDir, "observability");
+    if (!fs.existsSync(obsDir)) fs.mkdirSync(obsDir, { recursive: true });
+    fs.writeFileSync(
+        path.join(obsDir, "audit_log.md"),
+        `# 🕵️ Agent Enderun — Audit Log
+
+This log tracks all asynchronous agent communication and state transitions handled by the Hermes Message Broker.
+
+## Hermes Event Log
+`
+    );
+    fs.writeFileSync(
+        path.join(obsDir, "telemetry.md"),
+        `# 📊 Agent Enderun — Telemetry & Memory Observability
+
+## 🧠 Context & Token Observability
+- **Memory File:** \`${fDir}/memory/PROJECT_MEMORY.md\` (SSOT)
+- **Pruning Trigger:** Active history entries are pruned and archived under \`${fDir}/memory-graph/archive/\` once the log exceeds 10 records.
+- **Audit Logs:** Agent interactions are saved locally inside \`observability/audit_log.md\` to keep API usage transparent and track performance bottlenecks.
+`
+    );
+
     if (fDir === adapter.frameworkDir) {
         const entryFileName = adapter.shimFile || `${adapter.id.toUpperCase()}.md`;
-        fs.writeFileSync(path.join(targetDir, entryFileName), `# 🎖️ ${FRAMEWORK_NAME} — ${adapter.id.toUpperCase()} Strategy\n`);
+        const destShimPath = path.join(targetDir, entryFileName);
+        
+        let shimContent = SHIM_TEMPLATES[adapter.id] || `# 🎖️ ${FRAMEWORK_NAME} — ${adapter.id.toUpperCase()} Strategy\n`;
+        shimContent = remapFrameworkContent(shimContent, fDir, adapter.id);
+        
+        fs.writeFileSync(destShimPath, shimContent);
+        console.warn(`✅ Strategy shim created: ${entryFileName}`);
+    }
+}
+
+function scaffoldKnowledgeDocs(targetDir: string, fDir: string, dryRun: boolean) {
+    if (dryRun) return;
+    const pkgRoot = getPackageRoot();
+    const sourceDocsDir = path.join(pkgRoot, "templates");
+    const frameworkDir = path.join(targetDir, fDir);
+    
+    let knowledgeDirName = "knowledge";
+    if (fDir === ".github") knowledgeDirName = "instructions";
+    const destKnowledgeDir = path.join(frameworkDir, knowledgeDirName);
+    
+    if (!fs.existsSync(destKnowledgeDir)) {
+        fs.mkdirSync(destKnowledgeDir, { recursive: true });
+    }
+
+    const filesToCopy = [
+        { src: "architecture/standards/data-fetching-patterns.md", dest: "data-fetching-patterns.md" },
+        { src: "architecture/standards/design-system.md", dest: "design-system.md" },
+        { src: "architecture/standards/logging.md", dest: "logging.md" },
+        { src: "architecture/standards/tech-stack.md", dest: "tech-stack.md" },
+        { src: "architecture/standards/documentation-ownership.md", dest: "documentation_ownership.md" },
+        { src: "architecture/standards/mobile-standards.md", dest: "mobile_standards.md" },
+        { src: "architecture/standards/crud-governance.md", dest: "crud-governance.md" },
+        { src: "backend/error-handling.md", dest: "error-handling.md" },
+        { src: "frontend/component-patterns.md", dest: "component-patterns.md" },
+        { src: "architecture/enterprise-architecture.md", dest: "enterprise-architecture.md" },
+        { src: "architecture/approval-flows.md", dest: "approval-flows.md" },
+        { src: "architecture/agents-manifest.md", dest: "agents-manifest.md" }
+    ];
+
+    for (const item of filesToCopy) {
+        const srcPath = path.join(sourceDocsDir, item.src);
+        const destPath = path.join(destKnowledgeDir, item.dest);
+        try {
+            if (fs.existsSync(srcPath)) {
+                let content = fs.readFileSync(srcPath, "utf8");
+                content = remapFrameworkContent(content, fDir, fDir === ".github" ? "codex" : "gemini");
+                fs.writeFileSync(destPath, content);
+                console.warn(`✅ Copied document: ${item.dest} to ${fDir}/${knowledgeDirName}/`);
+            }
+        } catch (e) {
+            console.warn(`⚠️  Failed to copy ${item.src} to ${destPath}: ${e}`);
+        }
     }
 }
 
@@ -187,6 +340,7 @@ export async function initCommand(adapterInput?: string, dryRun = false, isInter
         scaffoldCoreAgents(selections.selectedAgents, path.join(base, "agents"), adapter.id, dryRun);
         scaffoldSkills(path.join(base, "skills"), dryRun);
         scaffoldFrameworkConfigs(targetDir, fdir, adapter, dryRun, selections.selectedPalette);
+        scaffoldKnowledgeDocs(targetDir, fdir, dryRun);
 
         // NATIVE TOOL CONFIGURATION (MCP REGISTRATION)
         if (!dryRun) {
@@ -196,10 +350,33 @@ export async function initCommand(adapterInput?: string, dryRun = false, isInter
     
     scaffoldConstitution(targetDir, adapter.frameworkDir, adapter.id, dryRun);
     ensureDir(path.join(targetDir, "apps"), dryRun);
+
+    // Scaffold target project docs/ folder
+    const targetDocsDir = path.join(targetDir, "docs");
+    ensureDir(targetDocsDir, dryRun);
+    if (!dryRun) {
+        const readmePath = path.join(targetDocsDir, "README.md");
+        if (!fs.existsSync(readmePath)) {
+            fs.writeFileSync(readmePath, "# 📝 Project Documentation\n\nWelcome to your new project scaffolded with Agent Enderun.\n\n## Project Overview\nWrite your project description, goals, and target audience here. The AI agents will read this file to understand the scope.\n");
+        }
+        const gettingStartedPath = path.join(targetDocsDir, "getting-started.md");
+        if (!fs.existsSync(gettingStartedPath)) {
+            fs.writeFileSync(gettingStartedPath, "# 🚀 Getting Started\n\n## Project Requirements\nWrite the core requirements and features of your application here.\n");
+        }
+        console.warn("✅ Project docs folder initialized with placeholders.");
+    }
+
     initializeMemory(path.join(targetDir, adapter.frameworkDir, "memory/PROJECT_MEMORY.md"), adapter.frameworkDir, dryRun);
     const mcpConfig = { mcpServers: { "agent-enderun": { command: "node", args: [path.join(getPackageRoot(), "framework-mcp/dist/index.js")], env: { ENDERUN_PROJECT_ROOT: targetDir } } } };
     fs.writeFileSync(path.join(targetDir, "mcp.json"), JSON.stringify(mcpConfig, null, 2));
+    
+    const paths = getConfiguredPaths();
+    const frontendDir = path.join(targetDir, paths.frontend);
+    ensureDir(frontendDir, dryRun);
+
     const pandaTemplate = `import { defineConfig } from "@pandacss/dev";\nexport default defineConfig({ theme: { extend: { tokens: { colors: { primary: { value: "${COLOR_PALETTES[selections.selectedPalette as keyof typeof COLOR_PALETTES]?.primary || "#0ea5e9"}" } } } } } });`;
-    fs.writeFileSync(path.join(targetDir, "panda.config.ts"), pandaTemplate);
+    if (!dryRun) {
+        fs.writeFileSync(path.join(frontendDir, "panda.config.ts"), pandaTemplate);
+    }
     console.warn(`\n✨ ${FRAMEWORK_NAME} scaffolded! (v${FRAMEWORK_VERSION})`);
 }

package/src/cli/commands/knowledge.ts

@@ -3,15 +3,13 @@ import path from "path";
 
 import { getFrameworkDir } from "../utils/memory.js";
 
-const targetDir = process.cwd(); // Assuming targetDir is process.cwd() in the CLI context
-
 export function updateKnowledgeBaseCommand(topic: string, content: string) {
     if (!topic || !content) {
         console.error("❌ Usage: agent-enderun update_knowledge_base <topic> <content>");
         return;
     }
     const frameworkDir = getFrameworkDir();
-    const kbDir = path.join(targetDir, frameworkDir, "knowledge");
+    const kbDir = path.join(frameworkDir, "knowledge");
     if (!fs.existsSync(kbDir)) fs.mkdirSync(kbDir, { recursive: true });
     const fileName = topic.replace(/[^a-z0-9]/gi, "_").toLowerCase() + ".md";
     fs.writeFileSync(path.join(kbDir, fileName), content);
@@ -24,7 +22,7 @@ export function searchKnowledgeBaseCommand(query: string) {
         return;
     }
     const frameworkDir = getFrameworkDir();
-    const kbDir = path.join(targetDir, frameworkDir, "knowledge");
+    const kbDir = path.join(frameworkDir, "knowledge");
     if (!fs.existsSync(kbDir)) {
         console.warn("ℹ️ Knowledge base is empty.");
         return;

package/src/cli/commands/log.ts

@@ -4,11 +4,9 @@ import path from "path";
 import { getFrameworkDir } from "../utils/memory.js";
 import { normalizeAgentName } from "../utils/string.js";
 
-const targetDir = process.cwd(); // Assuming targetDir is process.cwd() in the CLI context
-
 export function logAgentActionCommand(data: { agent?: unknown; action?: string; requestId?: string; traceId?: string; status?: string; summary?: string; files?: string[]; details?: Record<string, unknown> }) {
     const frameworkDir = getFrameworkDir();
-    const logsDir = path.join(targetDir, frameworkDir, "logs");
+    const logsDir = path.join(frameworkDir, "logs");
     if (!fs.existsSync(logsDir)) {
         fs.mkdirSync(logsDir, { recursive: true });
     }

package/src/cli/commands/orchestrate.ts

@@ -3,24 +3,69 @@ import path from "path";
 import chalk from "chalk";
 import { getFrameworkDir } from "../utils/memory.js";
 import { UI } from "../utils/ui.js";
+import { z } from "zod";
 
-/**
- * Hermes Protocol Message for Multi-Agent Collaboration.
- */
-interface HermesMessage {
-  timestamp: string;
-  from: string;
-  to: string;
-  category: "ACTION" | "DELEGATION" | "SUBTASK" | "REPLY" | "ALERT";
-  content: string;
-  traceId: string;
-  parentId?: string; // Links sub-tasks to parent tasks
-  status: "PENDING" | "PROCESSED" | "WAITING";
-}
+export const HermesMessageSchema = z.object({
+    timestamp: z.string(),
+    from: z.string(),
+    to: z.string(),
+    category: z.enum(["ACTION", "DELEGATION", "SUBTASK", "REPLY", "ALERT"]),
+    content: z.string(),
+    traceId: z.string(),
+    parentId: z.string().optional(),
+    status: z.enum(["PENDING", "PROCESSED", "WAITING", "APPROVED"]),
+    priority: z.enum(["HIGH", "NORMAL", "LOW"]).optional(),
+    action: z.string().optional()
+});
+
+export type HermesMessage = z.infer<typeof HermesMessageSchema>;
 
 export async function orchestrateCommand() {
     const frameworkDir = getFrameworkDir();
-    const messagesDir = path.join(process.cwd(), frameworkDir, "messages");
+    const messagesDir = path.join(frameworkDir, "messages");
+
+    // Check for agent timeouts (e.g. 30 minutes in EXECUTING state)
+    const statusPath = path.join(frameworkDir, "STATUS.md");
+    if (fs.existsSync(statusPath)) {
+        try {
+            const content = fs.readFileSync(statusPath, "utf8");
+            const lines = content.split("\n");
+            let updatedStatus = false;
+            const newLines = lines.map(line => {
+                if (line.includes("| @") && line.includes("| EXECUTING |")) {
+                    const parts = line.split("|");
+                    if (parts.length >= 7) {
+                        const lastUpdatedStr = parts[4].trim();
+                        if (lastUpdatedStr && lastUpdatedStr !== "-") {
+                            const lastUpdatedTime = Date.parse(lastUpdatedStr);
+                            if (!isNaN(lastUpdatedTime) && Date.now() - lastUpdatedTime > 30 * 60 * 1000) {
+                                const agentName = parts[1].trim();
+                                UI.error(`⚠️  Agent ${agentName} has TIMED OUT (in EXECUTING state for >30m). Transitioning to BLOCKED.`);
+                                parts[2] = " BLOCKED ";
+                                parts[3] = " Timeout occurred ";
+                                parts[4] = ` ${new Date().toISOString()} `;
+                                updatedStatus = true;
+                                
+                                // Log to audit log
+                                const auditPath = path.join(frameworkDir, "observability/audit_log.md");
+                                if (fs.existsSync(auditPath)) {
+                                    const logEntry = `\n- **[${new Date().toISOString()}]** ${agentName} status auto-escalated to BLOCKED due to 30m execution timeout.`;
+                                    fs.appendFileSync(auditPath, logEntry);
+                                }
+                                return parts.join("|");
+                            }
+                        }
+                    }
+                }
+                return line;
+            });
+            if (updatedStatus) {
+                fs.writeFileSync(statusPath, newLines.join("\n"));
+            }
+        } catch {
+            UI.error("Ajan zaman aşımı kontrolü sırasında hata oluştu.");
+        }
+    }
 
     if (!fs.existsSync(messagesDir)) {
         UI.success("Henüz işlenecek bir mesaj yok.");
@@ -40,11 +85,16 @@ export async function orchestrateCommand() {
             const allMsgs: HermesMessage[] = [];
             lines.forEach((line) => {
                 if (!line.trim()) return;
-                const msg = JSON.parse(line) as HermesMessage;
-                if (msg.status === "PENDING") {
-                    pendingMessages.push(msg);
+                try {
+                    const parsed = JSON.parse(line);
+                    const msg = HermesMessageSchema.parse(parsed);
+                    if (msg.status === "PENDING") {
+                        pendingMessages.push(msg);
+                    }
+                    allMsgs.push(msg);
+                } catch (e) {
+                    UI.error(`Geçersiz Hermes mesaj formatı atlandı: ${(e as Error).message}`);
                 }
-                allMsgs.push(msg);
             });
             fileMessagesMap[file] = allMsgs;
         } catch {
@@ -57,6 +107,15 @@ export async function orchestrateCommand() {
         return;
     }
 
+    // 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 Orkestrasyonu", `${pendingMessages.length} adet bekleyen görev ve işbirliği mesajı bulundu.`);
 
     for (const msg of pendingMessages) {
@@ -89,15 +148,41 @@ export async function orchestrateCommand() {
         msg.status = "PROCESSED";
     }
 
-    // Write back updated message statuses to files
+    // Write back updated message statuses to files and archive processed messages
+    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");
+        
         try {
-            const updatedContent = msgs.map(m => JSON.stringify(m)).join("\n") + "\n";
-            fs.writeFileSync(filePath, updatedContent, "utf8");
+            // Write remaining active messages
+            if (activeMsgs.length > 0) {
+                const updatedContent = activeMsgs.map(m => JSON.stringify(m)).join("\n") + "\n";
+                fs.writeFileSync(filePath, updatedContent, "utf8");
+            } else {
+                // Empty the file if no active messages
+                if (fs.existsSync(filePath)) {
+                    fs.writeFileSync(filePath, "", "utf8");
+                }
+            }
+
+            // Archive processed messages
+            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";
+                fs.appendFileSync(archivePath, archiveContent, "utf8");
+                UI.success(`Archived ${processedMsgs.length} messages for @${agentName}`);
+            }
         } catch {
-            UI.error(`${file} mesaj dosyası güncellenirken hata oluştu.`);
+            UI.error(`${file} mesaj dosyası güncellenirken ve arşivlenirken hata oluştu.`);
         }
     }
 }
@@ -105,24 +190,65 @@ export async function orchestrateCommand() {
 /**
  * Standard tool for agents to delegate tasks to other agents.
  */
-export function sendMessage(args: { 
+export async function sendMessage(args: { 
     from: string; 
     to: string; 
     category: "ACTION" | "DELEGATION" | "SUBTASK" | "REPLY" | "ALERT"; 
     content: string; 
     traceId: string;
     parentId?: string;
+    priority?: "HIGH" | "NORMAL" | "LOW";
 }) {
     const frameworkDir = getFrameworkDir();
-    const messagesDir = path.join(process.cwd(), frameworkDir, "messages");
+    const messagesDir = path.join(frameworkDir, "messages");
     const agentName = args.to.replace("@", "");
     const messagePath = path.join(messagesDir, `${agentName}.json`);
+    const lockPath = path.join(messagesDir, ".lock");
+
+    let retries = 3;
+    let acquired = false;
+    while (retries > 0) {
+        try {
+            if (fs.existsSync(lockPath)) {
+                try {
+                    const stats = fs.statSync(lockPath);
+                    if (Date.now() - stats.mtimeMs > 5000) {
+                        fs.unlinkSync(lockPath);
+                    }
+                } catch {
+                    // ignore if concurrently unlinked
+                }
+            }
+            if (!fs.existsSync(messagesDir)) {
+                fs.mkdirSync(messagesDir, { recursive: true });
+            }
+            fs.writeFileSync(lockPath, `Locked by ${args.from} at ${new Date().toISOString()}`, { flag: "wx" });
+            acquired = true;
+            break;
+        } catch (err: unknown) {
+            const error = err as { code?: string; message?: string };
+            if (error.code === "EEXIST") {
+                retries--;
+                if (retries > 0) {
+                    await new Promise((resolve) => setTimeout(resolve, 500));
+                }
+            } else {
+                UI.error(`Kilit alınırken beklenmedik hata oluştu: ${error.message || String(err)}`);
+                break;
+            }
+        }
+    }
+
+    if (!acquired) {
+        UI.error(`Mesaj iletilemedi: Hermes kilidi meşgul. (${args.from} -> ${args.to})`);
+        return;
+    }
 
     try {
-        if (!fs.existsSync(messagesDir)) fs.mkdirSync(messagesDir, { recursive: true });
-        
+        const defaultPriority = (args.category === "ALERT" || args.category === "ACTION") ? "HIGH" : "NORMAL";
         const message: HermesMessage = {
             timestamp: new Date().toISOString(),
+            priority: args.priority || defaultPriority,
             ...args,
             status: "PENDING"
         };
@@ -130,21 +256,29 @@ export function sendMessage(args: {
         fs.appendFileSync(messagePath, JSON.stringify(message) + "\n");
         
         // Log collaboration to audit log
-        const auditPath = path.join(process.cwd(), frameworkDir, "observability/audit_log.md");
+        const auditPath = path.join(frameworkDir, "observability/audit_log.md");
         if (fs.existsSync(auditPath)) {
-            const logEntry = `\n- **[${message.timestamp}]** ${args.from} -> ${args.to} | ${args.category} | Trace: ${args.traceId}`;
+            const logEntry = `\n- **[${message.timestamp}]** ${args.from} -> ${args.to} | ${args.category} | Priority: ${message.priority} | Trace: ${args.traceId}`;
             fs.appendFileSync(auditPath, logEntry);
         }
         
         return message;
     } catch {
         UI.error(`Mesaj iletilemedi: ${args.from} -> ${args.to}`);
+    } finally {
+        if (acquired && fs.existsSync(lockPath)) {
+            try {
+                fs.unlinkSync(lockPath);
+            } catch {
+                // Ignore delete errors if concurrently unlinked
+            }
+        }
     }
 }
 
 function transitionAgentState(agent: string, state: string, task: string) {
     const frameworkDir = getFrameworkDir();
-    const statusPath = path.join(process.cwd(), frameworkDir, "STATUS.md");
+    const statusPath = path.join(frameworkDir, "STATUS.md");
     if (!fs.existsSync(statusPath)) return;
     try {
         const content = fs.readFileSync(statusPath, "utf8");
@@ -156,6 +290,7 @@ function transitionAgentState(agent: string, state: string, task: string) {
                 if (parts.length >= 7) {
                     parts[2] = ` ${state} `;
                     parts[3] = ` ${task.slice(0, 25)}... `;
+                    parts[4] = ` ${new Date().toISOString()} `;
                     return parts.join("|");
                 }
             }

package/src/cli/commands/status.ts

@@ -1,4 +1,6 @@
 import fs from "fs";
+import path from "path";
+import chalk from "chalk";
 
 import { getMemoryPath, getFrameworkDir } from "../utils/memory.js";
 
@@ -49,6 +51,37 @@ export function statusCommand() {
         console.warn("⚠️  Status data could not be parsed in standard formats.");
     }
 
+    // Army status check
+    const statusPath = path.join(frameworkDir, "STATUS.md");
+    if (fs.existsSync(statusPath)) {
+        try {
+            const statusContent = fs.readFileSync(statusPath, "utf8");
+            const lines = statusContent.split("\n");
+            const agentRows = lines.filter(line => line.includes("| @") && line.includes("|"));
+            if (agentRows.length > 0) {
+                console.warn("\n🎖️  Enderun Army Status (Agent States):");
+                agentRows.forEach(row => {
+                    const parts = row.split("|");
+                    if (parts.length >= 4) {
+                        const agentName = parts[1].trim();
+                        const state = parts[2].trim();
+                        const activeTask = parts[3].trim();
+                        
+                        let coloredState = state;
+                        if (state === "READY") coloredState = chalk.green(state);
+                        else if (state === "EXECUTING") coloredState = chalk.yellow(state);
+                        else if (state === "BLOCKED" || state === "TIMEOUT") coloredState = chalk.red(state);
+                        else if (state === "WAITING") coloredState = chalk.cyan(state);
+                        
+                        console.warn(`  ${chalk.bold(agentName.padEnd(12))} : [${coloredState}] - ${activeTask}`);
+                    }
+                });
+            }
+        } catch {
+            // Ignore status read errors
+        }
+    }
+
     const tasksSection = content.match(/## ACTIVE TASKS\n\n([\s\S]*?)(?=\n##|$)/);
     if (tasksSection) {
         console.warn("\n📋 Active Tasks:");