agent-enderun 0.8.7 → 0.9.0

package/bin/validate-agent-army.js

@@ -3,16 +3,39 @@
 import fs from "fs";
 import path from "path";
 
-const frameworkDir = fs.existsSync("./.enderun") ? "./.enderun" : "./.gemini";
-const AGENTS_DIR = path.resolve(frameworkDir, "agents");
-const SCHEMA_PATH = path.resolve(frameworkDir, "agents/agent_army_schema.json");
+const FRAMEWORK_CANDIDATES = [".gemini", ".claude", ".agent", ".enderun"];
+
+function detectFrameworkDir() {
+    for (const dir of FRAMEWORK_CANDIDATES) {
+        const agentsPath = path.resolve(dir, "agents");
+        const schemaPath = path.resolve(dir, "agents/agent_army_schema.json");
+        if (fs.existsSync(agentsPath)) {
+            return { frameworkDir: dir, agentsDir: agentsPath, schemaPath };
+        }
+    }
+    return null;
+}
+
+const detected = detectFrameworkDir();
+if (!detected) {
+    console.error("❌ No framework agents/ directory found. Run: agent-enderun init <adapter>");
+    console.error(`   Looked for: ${FRAMEWORK_CANDIDATES.map((d) => `${d}/agents`).join(", ")}`);
+    process.exit(1);
+}
+
+const { frameworkDir, agentsDir, schemaPath } = detected;
 
 console.log(`🛡️  STARTING AUTOMATED AGENT ARMY VALIDATION (${frameworkDir})...`);
 
 try {
-    const schema = JSON.parse(fs.readFileSync(SCHEMA_PATH, "utf8"));
+    if (!fs.existsSync(schemaPath)) {
+        console.error(`❌ Schema missing: ${schemaPath}`);
+        process.exit(1);
+    }
+
+    const schema = JSON.parse(fs.readFileSync(schemaPath, "utf8"));
     const requiredKeys = schema.required;
-    const files = fs.readdirSync(AGENTS_DIR);
+    const files = fs.readdirSync(agentsDir);
     let totalFailed = 0;
 
     console.log("--------------------------------------------------");
@@ -21,10 +44,9 @@ try {
 
     for (const fileName of files) {
         if (!fileName.endsWith(".md")) continue;
-        const filePath = path.join(AGENTS_DIR, fileName);
+        const filePath = path.join(agentsDir, fileName);
         const content = fs.readFileSync(filePath, "utf8");
 
-        // Simple YAML frontmatter parser
         const match = content.match(/^---\n([\s\S]*?)\n---/);
         if (!match) {
             console.log(`| ${fileName.padEnd(9)} | ❌ NO YAML | ----- | ---------------- |`);
@@ -34,11 +56,10 @@ try {
 
         const yamlContent = match[1];
         const agent = {};
-        yamlContent.split("\n").forEach(line => {
+        yamlContent.split("\n").forEach((line) => {
             const [key, ...valParts] = line.split(":");
             if (key && valParts.length > 0) {
                 let val = valParts.join(":").trim();
-                // Clean quotes and handle numbers
                 val = val.replace(/^['"]|['"]$/g, "");
                 if (!isNaN(val) && val !== "") {
                     agent[key.trim()] = Number(val);
@@ -48,13 +69,17 @@ try {
             }
         });
 
-        const missing = requiredKeys.filter(k => agent[k] === undefined);
+        const missing = requiredKeys.filter((k) => agent[k] === undefined);
 
         if (missing.length > 0) {
-            console.log(`| ${fileName.replace(".md", "").padEnd(9)} | ❌ FAILED  | ----- | ${`Missing: ${missing.join(",")}`.slice(0, 16)} |`);
+            console.log(
+                `| ${fileName.replace(".md", "").padEnd(9)} | ❌ FAILED  | ----- | ${`Missing: ${missing.join(",")}`.slice(0, 16)} |`,
+            );
             totalFailed++;
         } else {
-            console.log(`| ${agent.name.padEnd(9)} | ✅ PASSED  | ${String(agent.capability).padEnd(5)} | ${agent.role.substring(0,14).padEnd(14)} |`);
+            console.log(
+                `| ${agent.name.padEnd(9)} | ✅ PASSED  | ${String(agent.capability).padEnd(5)} | ${agent.role.substring(0, 14).padEnd(14)} |`,
+            );
         }
     }
 
@@ -63,7 +88,7 @@ try {
         console.error(`❌ Validation failed! Detected ${totalFailed} invalid agent configurations.`);
         process.exit(1);
     } else {
-        console.log("🎉 SUCCESS: All 8 core agents comply 100% with the Master Agent Army Schema!");
+        console.log("🎉 SUCCESS: All core agents comply with the Master Agent Army Schema!");
     }
 } catch (e) {
     console.error("❌ Critical error during schema validation:", e);

package/claude.md

@@ -1,19 +1,25 @@
-# Agent Enderun — Claude Code CLI Adapter
+# Agent Enderun — Claude Code Adapter
 
-This file is the entry point when using Agent Enderun with Claude Code CLI.
+This is the primary entry point when using Agent Enderun within the Claude Code (CLI & Desktop) ecosystem.
 
-The framework installs into the `.claude/` folder for Claude users.
+The framework operates under a unified governance structure located in the `.enderun/` directory.
 
 ### Primary Constitution
 All governance rules, agent checklists, and project memory live here:
 
-👉 **[.claude/ENDERUN.md](.claude/ENDERUN.md)**
+👉 **[.enderun/ENDERUN.md](.enderun/ENDERUN.md)**
 
-### 🤖 Agent Directive (Claude Code CLI users)
+### 🤖 Agent Directive
 You are operating under the Agent Enderun governance framework.
 
 At the **start of every session**, before any work:
-1. Read `.claude/PROJECT_MEMORY.md` to restore state, active Trace ID, and history.
-2. Read the relevant agent definition under `.claude/agents/{agent}.md` (especially `@manager`).
+1. **Restore Memory:** Read `.enderun/PROJECT_MEMORY.md` to restore state, active Trace ID, and history.
+2. **Load Identity:** Read the relevant agent definition under `.enderun/agents/{agent}.md` (default to `@manager`).
+3. **Internalize Knowledge:** Reference the `.enderun/knowledge/` base for architectural and coding standards.
 
-All paths and references inside `.claude/` use the Claude adapter structure. No migration to other CLIs is required.
+### 🛡️ Core Mandates
+- **Surgical Edits:** Use `replace_text` or `patch_file` via MCP for precise changes.
+- **Traceability:** Every action must inherit the active Trace ID from memory.
+- **Contract First:** No implementation without verified types.
+
+All paths and references inside the project must comply with the Supreme Constitution located at `.enderun/ENDERUN.md`.

package/docs/README.md

@@ -1,26 +1,45 @@
-# Agent Enderun — Corporate Project Portal
+# 🏛️ Agent Enderun — Kurumsal Mimari ve Yönetişim Portalı
 
-Welcome to the central documentation portal for your corporate project. This portal is designed to provide your **Agent Army** and human developers with a structured, clean, and unambiguous framework for software design, architecture, and governance.
+Bu portal, Agent Enderun framework'ü altında geliştirilen kurumsal projelerin **Merkezi Bilgi Kaynağıdır**. Projenin mimari kararları, standartları ve yönetişim protokolleri burada mühürlenmiştir.
 
 ---
 
-## 📂 Documentation Directory
+## 🏗️ Mimari Felsefemiz: "Disiplinli Otonomi"
 
-### [1. Architecture & Governance](architecture/)
-- **[Architecture Decisions (ADRs)](architecture/decisions/)**: Log of key architectural choices and design patterns.
-- **[Approval & High-Risk Workflows](architecture/approval-flows.md)**: Detailed contracts and state machines for `managerApproval` tokens.
-- **[Notification Strategy](architecture/notification-strategy.md)**: Dynamic notification patterns and toaster integrations.
+Sıradan projelerin aksine, Agent Enderun projeleri yapay zeka ajanlarının otonom çalıştığı ancak insan eliyle yazılmış katı bir anayasaya bağlı kaldığı bir yapıdır. Bu dökümantasyon, hem AI ajanları (Army) hem de insan geliştiriciler için **Değişmez Rehberdir**.
 
-### [2. Frontend Standards](frontend/)
-- **[Component Patterns](frontend/component-patterns.md)**: Guidelines for custom, Zero-UI-Library React components styled with Panda CSS.
-- **[Form Validations](frontend/forms.md)**: Type-safe form states using Zod and React hooks.
-- **[Toaster Notifications](frontend/notifications.md)**: Integration guides for Sonner toast configurations.
+### 📋 Dokümantasyon Rehberi
 
-### [3. Backend Standards](backend/)
-- **[Error Handling](backend/error-handling.md)**: Standardized `DomainError` class hierarchies and Fastify error maps.
-- **[Audit Logging](backend/audit-logging.md)**: Database auditing schemes and transaction log contracts.
+#### [1. Mimari ve Yönetişim (Architecture & Governance)](architecture/)
+*   **[Mimari Karar Kayıtları (ADRs)](architecture/decisions/)**: Projenin kritik dönüm noktalarında alınan kararların "Neden" ve "Nasıl" sorularına verilen cevaplardır.
+*   **[Onay ve Yüksek Riskli İş akışları](architecture/approval-flows.md)**: `managerApproval` token'larının nasıl üretildiği, denetlendiği ve yüksek riskli işlemlerin (örn: veritabanı silme, yetki yükseltme) nasıl mühürlendiği anlatılır.
+*   **[Bildirim Stratejisi](architecture/notification-strategy.md)**: Kullanıcı deneyimini kesintiye uğratmayan, dinamik ve kurumsal bildirim desenleri.
+
+#### [2. Frontend Standartları (Frontend)](frontend/)
+*   **[Bileşen Desenleri (Component Patterns)](frontend/component-patterns.md)**: **Zero-UI-Library** politikamız gereği, tüm bileşenlerin Panda CSS ile nasıl "el yapımı" ve tip-güvenli olarak inşa edileceği rehberi.
+*   **[Form Doğrulamaları](frontend/forms.md)**: Zod ve React hooks ile yönetilen, hata payı sıfır form yönetim sistemleri.
+*   **[Toaster Yapılandırması](frontend/notifications.md)**: Sonner ve benzeri araçların kurumsal tema ile entegrasyonu.
+
+#### [3. Backend Standartları (Backend)](backend/)
+*   **[Hata Yönetimi (Error Handling)](backend/error-handling.md)**: `DomainError` sınıfları üzerinden, front-end'e sızmayan ve loglarda izlenebilen profesyonel hata yönetim hiyerarşisi.
+*   **[Denetim Günlükleri (Audit Logging)](backend/audit-logging.md)**: Her işlemin bir `Trace ID` ile veritabanına kalıcı olarak nasıl işleneceğinin kontratları.
+
+---
+
+## 🛰️ Faz Bazlı Geliştirme Döngüsü (Life Cycle)
+
+Tüm projeler aşağıdaki 5 fazı sırasıyla ve eksiksiz geçmek zorundadır:
+
+1.  **PHASE_0 (Keşif):** Teknoloji yığını (`tech-stack.md`) mühürlenir, risk analizi yapılır.
+2.  **PHASE_1 (Mimari & Kontrat):** Önce tipler ve API sözleşmeleri yazılır. Tek satır uygulama kodu yazılmadan kontratlar onaylanmalıdır.
+3.  **PHASE_2 (Çekirdek Geliştirme):** Backend ve Frontend paralel olarak inşa edilir. `Branded Types` kullanımı zorunludur.
+4.  **PHASE_3 (Entegrasyon & Test):** `@qa` ajanı devreye girer. **%80 Test Coverage** barajı geçilmeden bir sonraki faza geçilemez.
+5.  **PHASE_4 (Optimizasyon & Dağıtım):** Güvenlik taramaları (`check:security`) ve performans testleri tamamlanır.
 
 ---
 
-> [!TIP]
-> **Enforcement Rule:** All agents in the army are mandated to read these guidelines before writing any code, ensuring 100% architectural alignment and clean, modular codebase organization.
+> [!IMPORTANT]
+> **Ajan Talimatı:** Bu klasör altındaki dökümanlar, ajanların operasyonel sınırlarını çizer. Bir ajan, burada tanımlanan bir kuralın dışına çıkamaz. Eğer bir kuralın güncellenmesi gerekiyorsa, bu ancak `@manager` onayıyla ve ADR kaydıyla yapılabilir.
+
+**Sürüm:** v0.8.8  
+**Durum:** Aktif Yönetişim

package/docs/roadmap.md

@@ -42,7 +42,7 @@ This program systematically audits current agent maturity levels and runs struct
 | **@explorer** | 6.5 | 8.5 | High / Stable. Highly capable in dependency analysis and codebase intelligence. |
 | **@analyst** | 6.5 | 8.5 | Medium / Stable. Handles system health metrics and compliance audits. |
 | **@git** | 6.0 | 8.0 | Medium / Stable. Coordinates PRs, semantic commits, and version compliance. |
-| **@mobile & @native** | 2.0 | 7.5 | Low / Dormant. Foundational blueprints and Hermes safety rules added. |
+| **@mobile** | 2.0 | 7.5 | Low / Dormant. Foundational blueprints and Hermes safety rules added. |
 
 > **Note:** `@frontend` is currently the highest risk to enterprise onboarding and is the top priority.
 

package/docs/tech-stack.md

@@ -0,0 +1,30 @@
+# 🛠️ Agent Enderun — Technology Stack (v0.8.8)
+
+This document defines the official, non-negotiable tech stack for the project. All agents must comply with these choices.
+
+---
+
+## 🏗️ Core Backend
+- **Runtime:** Node.js 22+ (LTS)
+- **Framework:** Fastify (RCSR Architecture)
+- **Database:** PostgreSQL (with Multi-Tenant RLS & PostGIS)
+- **ORM / Query Builder:** Kysely (Typed SQL)
+- **Validation:** Zod (Contract-First)
+- **Language:** TypeScript 6 (Strict Mode)
+
+## 🎨 Core Frontend
+- **Framework:** React 19
+- **Build Tool:** Vite
+- **Styling:** Panda CSS (Type-safe, Zero-Runtime CSS-in-JS)
+- **State Management:** React Context / TanStack Query
+- **Components:** Zero-UI-Library Policy (Handcrafted atomic components)
+
+## 🧪 Quality & DevOps
+- **Testing:** Vitest (80% Coverage Threshold)
+- **CI/CD:** GitHub Actions
+- **Monorepo:** npm Workspaces
+- **Logging:** Structured JSON logging with Trace ID integrity
+
+---
+
+**Note:** Any deviation from this stack requires a formal ADR (Architecture Decision Record) approved by @manager.

package/eslint.config.js

@@ -0,0 +1,68 @@
+import globals from "globals";
+import js from "@eslint/js";
+import tseslint from "typescript-eslint";
+
+const styleRules = {
+    indent: ["error", 4],
+    "linebreak-style": ["error", "unix"],
+    quotes: ["error", "double"],
+    semi: ["error", "always"],
+    "no-constant-condition": "warn",
+};
+
+export default tseslint.config(
+    {
+        ignores: [
+            "**/node_modules/**",
+            "**/dist/**",
+            "framework-mcp/dist/**",
+            "apps/*/dist/**",
+            ".agent/**",
+            ".gemini/**",
+            ".claude/**",
+            ".cursor/**",
+            ".enderun/logs/**",
+            "panda.config.ts",
+        ],
+    },
+    js.configs.recommended,
+    ...tseslint.configs.recommended,
+    {
+        files: ["**/*.{ts,tsx}"],
+        languageOptions: {
+            ecmaVersion: 2022,
+            sourceType: "module",
+            globals: {
+                ...globals.node,
+                ...globals.es2021,
+            },
+            parserOptions: {
+                project: ["./tsconfig.json", "./apps/*/tsconfig.json", "./framework-mcp/tsconfig.json"],
+                tsconfigRootDir: import.meta.dirname,
+            },
+
+        },
+        rules: {
+            ...styleRules,
+            "no-unused-vars": "off",
+            "@typescript-eslint/no-explicit-any": "warn",
+            "@typescript-eslint/explicit-module-boundary-types": "off",
+            "@typescript-eslint/no-unused-vars": ["warn", { argsIgnorePattern: "^_" }],
+        },
+    },
+    {
+        files: ["**/*.js"],
+        languageOptions: {
+            ecmaVersion: 2022,
+            sourceType: "module",
+            globals: {
+                ...globals.node,
+                ...globals.es2021,
+            },
+        },
+        rules: {
+            ...styleRules,
+            "no-unused-vars": ["warn", { argsIgnorePattern: "^_" }],
+        },
+    },
+);

package/framework-mcp/dist/index.js

@@ -1,41 +1,201 @@
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
-import { allTools, allHandlers } from "./tools/index.js";
-import { FRAMEWORK_VERSION } from "./utils.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import fs from "fs";
+import path from "path";
+import { execSync } from "child_process";
 const server = new Server({
-    name: "ai-enderun-mcp",
-    version: FRAMEWORK_VERSION,
+    name: "agent-enderun-mcp",
+    version: "0.9.0",
 }, {
     capabilities: {
         tools: {},
     },
 });
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-    return {
-        tools: allTools,
-    };
+const TOOLS = [
+    {
+        name: "read_file",
+        description: "Read the content of a file within the project.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: { type: "string", description: "Path to the file relative to project root" },
+            },
+            required: ["path"],
+        },
+    },
+    {
+        name: "write_file",
+        description: "Write content to a file. Creates directories if missing.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: { type: "string", description: "Path to the file relative to project root" },
+                content: { type: "string", description: "Complete content of the file" },
+            },
+            required: ["path", "content"],
+        },
+    },
+    {
+        name: "replace_text",
+        description: "Surgically replace a string in a file with another string.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: { type: "string", description: "Path to the file" },
+                oldText: { type: "string", description: "The exact text to find" },
+                newText: { type: "string", description: "The text to replace it with" },
+            },
+            required: ["path", "oldText", "newText"],
+        },
+    },
+    {
+        name: "patch_file",
+        description: "Safely update a file by replacing a specific line range with new content.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: { type: "string", description: "Path to the file" },
+                startLine: { type: "number", description: "Starting line number (1-indexed)" },
+                endLine: { type: "number", description: "Ending line number (inclusive)" },
+                newContent: { type: "string", description: "The new lines to insert" },
+            },
+            required: ["path", "startLine", "endLine", "newContent"],
+        },
+    },
+    {
+        name: "get_framework_status",
+        description: "Get the current project phase, active traces, and agent states.",
+        inputSchema: { type: "object", properties: {} },
+    },
+    {
+        name: "update_project_memory",
+        description: "Update a specific section in PROJECT_MEMORY.md.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                section: { type: "string", description: "Section name (e.g., HISTORY, ACTIVE TASKS)" },
+                content: { type: "string", description: "Markdown content to append or set" },
+            },
+            required: ["section", "content"],
+        },
+    },
+    {
+        name: "create_app",
+        description: "Generate a new full-stack application from a natural language idea.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                idea: { type: "string", description: "The application idea or requirements" },
+            },
+            required: ["idea"],
+        },
+    },
+    {
+        name: "send_agent_message",
+        description: "Send a Hermes protocol message to another agent.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                to: { type: "string", description: "Target agent (e.g., @backend, @qa)" },
+                category: { type: "string", enum: ["ACTION", "DELEGATION", "INFO", "ALERT"] },
+                content: { type: "string", description: "Message content" },
+                traceId: { type: "string", description: "Active Trace ID" },
+            },
+            required: ["to", "category", "content", "traceId"],
+        },
+    },
+];
+server.onRequest(ListToolsRequestSchema, async () => {
+    return { tools: TOOLS };
 });
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
+server.onRequest(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     const projectRoot = process.cwd();
-    // Handle compatibility for context search
-    let effectiveArgs = args;
-    if (name === "codebase_context_search") {
-        effectiveArgs = { extension: "md", ...(args ?? {}) };
+    try {
+        switch (name) {
+            case "read_file": {
+                const filePath = path.join(projectRoot, args?.path);
+                const content = fs.readFileSync(filePath, "utf8");
+                return { content: [{ type: "text", text: content }] };
+            }
+            case "write_file": {
+                const filePath = path.join(projectRoot, args?.path);
+                fs.mkdirSync(path.dirname(filePath), { recursive: true });
+                fs.writeFileSync(filePath, args?.content);
+                return { content: [{ type: "text", text: `✅ File written: ${args?.path}` }] };
+            }
+            case "replace_text": {
+                const filePath = path.join(projectRoot, args?.path);
+                let content = fs.readFileSync(filePath, "utf8");
+                const oldText = args?.oldText;
+                const newText = args?.newText;
+                if (!content.includes(oldText)) {
+                    throw new Error(`Text not found in file: ${oldText}`);
+                }
+                content = content.replace(oldText, newText);
+                fs.writeFileSync(filePath, content);
+                return { content: [{ type: "text", text: `✅ Surgical edit successful in ${args?.path}` }] };
+            }
+            case "patch_file": {
+                const filePath = path.join(projectRoot, args?.path);
+                const lines = fs.readFileSync(filePath, "utf8").split("\n");
+                const start = args?.startLine - 1;
+                const end = args?.endLine;
+                const newContent = (args?.newContent).split("\n");
+                if (start < 0 || start > lines.length)
+                    throw new Error("Invalid start line.");
+                lines.splice(start, end - start, ...newContent);
+                fs.writeFileSync(filePath, lines.join("\n"));
+                return { content: [{ type: "text", text: `✅ File patched successfully: ${args?.path}` }] };
+            }
+            case "get_framework_status": {
+                const output = execSync("npx agent-enderun status").toString();
+                return { content: [{ type: "text", text: output }] };
+            }
+            case "update_project_memory": {
+                const section = args?.section;
+                const content = args?.content;
+                // Escape quotes for shell
+                const safeContent = content.replace(/"/g, "\\\"");
+                execSync(`npx agent-enderun update_project_memory "${section}" "${safeContent}"`);
+                return { content: [{ type: "text", text: `✅ Section ${section} updated.` }] };
+            }
+            case "create_app": {
+                const idea = args?.idea;
+                const output = execSync(`npx agent-enderun create-app "${idea.replace(/"/g, "\\\"")}"`).toString();
+                return { content: [{ type: "text", text: output }] };
+            }
+            case "send_agent_message": {
+                const { to, category, content, traceId } = args;
+                const frameworkDir = fs.existsSync(path.join(projectRoot, ".enderun")) ? ".enderun" : ".gemini";
+                const messagePath = path.join(projectRoot, frameworkDir, "messages", `${to.replace("@", "")}.json`);
+                const message = {
+                    timestamp: new Date().toISOString(),
+                    from: "@mcp",
+                    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}` }] };
+            }
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
     }
-    const handler = allHandlers[name];
-    if (handler) {
-        return await handler(effectiveArgs, projectRoot);
+    catch (error) {
+        return {
+            isError: true,
+            content: [{ type: "text", text: error.message }],
+        };
     }
-    throw new Error(`Tool not found: ${name}`);
 });
-async function main() {
+async function run() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error("Framework MCP Server running on stdio");
 }
-main().catch((error) => {
-    console.error("Fatal error in main():", error);
-    process.exit(1);
-});
+run().catch(console.error);

package/framework-mcp/package.json

@@ -1,46 +1,19 @@
 {
-  "name": "ai-enderun-mcp",
-  "version": "0.8.7",
-  "description": "Enterprise-grade MCP Server for AI Agent Framework",
-  "author": "Yusuf BEKAR",
-  "license": "MIT",
-  "readme": "README.md",
+  "name": "@agent-enderun/mcp",
+  "version": "0.9.0",
+  "description": "Agent Enderun Model Context Protocol (MCP) Server",
   "type": "module",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/ysf-bkr/Agent-Enderun.git"
-  },
-  "bugs": {
-    "url": "https://github.com/ysf-bkr/Agent-Enderun/issues"
-  },
-  "homepage": "https://github.com/ysf-bkr/Agent-Enderun#readme",
-  "main": "dist/index.js",
-  "module": "dist/index.js",
-  "types": "dist/index.js",
-  "bin": {
-    "framework-mcp": "dist/index.js"
-  },
-  "files": [
-    "src",
-    "dist",
-    "README.md"
-  ],
-  "publishConfig": {
-    "access": "public"
-  },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "npx tsc",
     "start": "node dist/index.js",
     "dev": "tsx src/index.ts"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.29.0",
-    "ts-morph": "^28.0.0",
+    "@modelcontextprotocol/sdk": "^1.26.0",
     "zod": "^3.24.2"
   },
   "devDependencies": {
-    "@types/node": "^25.9.1",
-    "tsx": "^4.19.4",
+    "@types/node": "^22.19.19",
     "typescript": "^5.9.3"
   }
 }

package/framework-mcp/tsconfig.json

@@ -4,13 +4,10 @@
     "module": "NodeNext",
     "moduleResolution": "NodeNext",
     "outDir": "./dist",
+    "rootDir": "./src",
     "strict": true,
-    "esModuleInterop": true,
     "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "allowJs": true,
-    "types": ["node"]
+    "esModuleInterop": true
   },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
+  "include": ["src/**/*.ts"]
 }

package/gemini.md

@@ -1,19 +1,25 @@
 # Agent Enderun — Gemini CLI Adapter
 
-This file is the entry point when using Agent Enderun with Gemini CLI.
+This is the primary entry point when using Agent Enderun within the Gemini CLI ecosystem.
 
-The framework installs into the `.enderun/` folder for Gemini users.
+The framework operates under a unified governance structure located in the `.enderun/` directory.
 
 ### Primary Constitution
 All governance rules, agent checklists, and project memory live here:
 
 👉 **[.enderun/ENDERUN.md](.enderun/ENDERUN.md)**
 
-### 🤖 Agent Directive (Gemini CLI users)
+### 🤖 Agent Directive
 You are operating under the Agent Enderun governance framework.
 
 At the **start of every session**, before any work:
-1. Read `.enderun/PROJECT_MEMORY.md` to restore state, active Trace ID, and history.
-2. Read the relevant agent definition under `.enderun/agents/{agent}.md` (especially `@manager`).
+1. **Restore Memory:** Read `.enderun/PROJECT_MEMORY.md` to restore state, active Trace ID, and history.
+2. **Load Identity:** Read the relevant agent definition under `.enderun/agents/{agent}.md` (default to `@manager`).
+3. **Internalize Knowledge:** Reference the `.enderun/knowledge/` base for architectural and coding standards.
 
-All paths and references inside `.enderun/` use the Enderun adapter structure. No migration to other CLIs is required.
+### 🛡️ Core Mandates
+- **Surgical Edits:** Use `replace_text` or `patch_file` via MCP for precise changes.
+- **Traceability:** Every action must inherit the active Trace ID from memory.
+- **Contract First:** No implementation without verified types.
+
+All paths and references inside the project must comply with the Supreme Constitution located at `.enderun/ENDERUN.md`.