agent-enderun 0.8.8 → 0.9.0

package/README.md

@@ -1,12 +1,4 @@
-# 🏛️ Agent Enderun — Supreme Enterprise AI Governance & Orchestration Framework
-
-**Agent Enderun** is a production-grade, highly-disciplined AI orchestration and process governance framework designed for building secure, scalable, and audit-ready enterprise software. It enforces contract-first development, zero-mock safety, static security scanning, and strict multi-agent coordination under a single source of truth.
-
-**Current Version:** `0.8.8`  
-**Author:** Yusuf BEKAR  
-**License:** MIT  
-
----
+# 🏛️ Agent Enderun — Supreme Enterprise AI Governance Framework (v0.9.0)
 
 [English](#english) | [Türkçe](#türkçe)
 
@@ -14,454 +6,138 @@
 
 # English
 
-## Table of Contents
-- [1. Introduction & Core Philosophy](#1-introduction--core-philosophy)
-- [2. Installation & Quickstart](#2-installation--quickstart)
-  - [Prerequisites](#prerequisites)
-  - [Step-by-Step Installation](#step-by-step-installation)
-  - [Verification & Health Check](#verification--health-check)
-- [3. Adapters & Use Cases](#3-adapters--use-cases)
-  - [Gemini Adapter (Standard & Recommended)](#gemini-adapter-standard--recommended)
-  - [Claude & Cursor Adapters](#claude--cursor-adapters)
-  - [Integrating with Claude Code / Claude Desktop](#integrating-with-claude-code--claude-desktop)
-- [4. Project Development Workflow & Best Practices](#4-project-development-workflow--best-practices)
-  - [A. Phase-Based Lifecycle](#a-phase-based-lifecycle)
-  - [B. Trace ID Protocol](#b-trace-id-protocol)
-  - [C. Contract-First & Branded Types](#c-contract-first--branded-types)
-  - [D. Zero Mock & Zero UI-Library Policy](#d-zero-mock--zero-ui-library-policy)
-  - [E. Security & Compliance Scanning](#e-security--compliance-scanning)
-  - [F. Hermes Messaging & Task Queues](#f-hermes-messaging--task-queues)
-- [5. CLI Reference Manual](#5-cli-reference-manual)
-- [6. Project Layout Directory Structure](#6-project-layout-directory-structure)
+**Agent Enderun** is not just a code generator; it is a high-discipline **AI Governance & Autonomous Command System** designed for complex, scalable, and fully auditable enterprise software projects. 
 
----
+With v0.9.0, the framework has evolved into a **"Living Engineering Organism"** that manages its own memory, performs surgical codebase modifications, and unifies diverse AI ecosystems under a single constitutional discipline.
 
-## 1. Introduction & Core Philosophy
+## 💎 Strategic Platform Synergy (The Core Four)
 
-AI assistance in software development often introduces technical debt, code drift, and unstructured modifications. **Agent Enderun** solves this by establishing a **Structured Governance Framework**. Rather than acting as a loose code generator, AI assistants within this framework are treated as disciplined engineers under a unified command structure led by the `@manager` (Team-Lead) agent.
+Agent Enderun integrates the world's most powerful AI ecosystems, mapping each to a specific strategic role within the project:
 
-### The Five Pillars of Enderun
-1. **Absolute Traceability:** Every action, commit, and state change is stamped with a unique ULID-based **Trace ID**.
-2. **Katalyst Contracts:** Zero code is written until API contracts and **Branded Types** are defined and verified.
-3. **Pristine Sandboxing:** Complete separation between the **User's Project** and the **Framework Internals**.
-4. **Permanent Memory:** The AI's context and status live persistently inside your project, not in transient chat logs or the OS `/tmp` directory.
-5. **Zero Mock Policy:** All analytical and operational screens must interact with actual, validated schemas and live endpoints.
+1.  **🚀 Claude Code (Operational Surgery):** The project's **Field Engineer**. With unrivaled file-system speed and the `patch_file` tool, it manages autonomous code edits with surgical precision.
+2.  **♊ Gemini & Vertex AI (Strategic Brain):** The **Command Center**. Utilizing a 2M+ token context window, it analyzes the entire project history and architectural map simultaneously to make high-level decisions.
+3.  **🛸 Antigravity (Internal Discipline):** The **Military Academy**. A high-discipline, isolated environment designed to enforce internal project standards and rigorous AI training.
+4.  **🤖 Grok / X.ai (Reconnaissance Unit):** The **Autonomous Vision**. Used for testing futuristic agent protocols and pushing the boundaries of AI-native development.
 
----
+## 🛡️ The Five Pillars of Enderun Discipline
 
-## 2. Installation & Quickstart
+1.  **Absolute Traceability (Trace ID):** Every decision, commit, and line of code is stamped with a ULID-based Trace ID. Full enterprise auditability is achieved in seconds.
+2.  **Contract-First Law:** No implementation is permitted without verified type contracts. Type safety between `@backend` and `@frontend` is the project's supreme law.
+3.  **Surgical Edit Standard:** Overwriting entire files is prohibited. The system mandates `replace_text` and `patch_file` via MCP for precise, non-destructive modifications.
+4.  **Autonomous Memory Pruning:** `PROJECT_MEMORY.md` never bloats. Histories exceeding 10 entries are auto-archived to keep the context window fresh and cost-efficient.
+5.  **Constitutional SSOT:** All platforms (Claude, Gemini, etc.) are 100% loyal to a single source of truth: the `.enderun/ENDERUN.md` constitution.
 
-### Prerequisites
-- **Node.js** v20.0.0 or higher (LTS recommended).
-- **npm** v9+ or **pnpm** v8+ or **yarn** v3+.
-- **Git** initialized in the project directory.
+## 🛠️ Installation & Deployment
 
-### Step-by-Step Installation
+Initialize the framework for your preferred platform with a single command:
 
-#### Step 1: Initialize Git in your directory
 ```bash
-mkdir my-enterprise-app
-cd my-enterprise-app
-git init
-```
+# For Gemini CLI and Antigravity (Standard)
+agent-enderun init gemini
 
-#### Step 2: Run the Framework Initializer
-To scaffold the entire governance structure, run the command below. By default, it will detect your package manager and environment.
-```bash
-npx agent-enderun init gemini
-```
-*Note: If you do not specify an adapter, it will default to `gemini` and build the runtime within the `.enderun/` directory.*
+# For Claude Code (CLI & Desktop) — Optimized for Surgery
+agent-enderun init claude
 
-#### Step 3: Install Workspace Dependencies & Compile the MCP Server
-```bash
-npm install
-npm run enderun:build
-```
-
----
+# For Antigravity IDE/CLI Independent Setup
+agent-enderun init antigravity
 
-### Verification & Health Check
-
-Always run the built-in health diagnostic after installation or after making major project transitions:
-```bash
-npx agent-enderun check
+# For Grok Build / X.ai Autonomous Agents
+agent-enderun init grok
 ```
 
-#### What does the Health Check validate?
-- **Constitution Integrity:** Verifies the existence and checksum of `ENDERUN.md`.
-- **Memory Connectivity:** Checks if `PROJECT_MEMORY.md` is active and writeable.
-- **Contract Parity:** Ensures `apps/backend/contract.version.json` exists.
-- **MCP compilation:** Confirms `framework-mcp/dist/index.js` is fully compiled and ready.
-- **Documentation Portals:** Ensures technical stack details are filled inside `docs/tech-stack.md`.
-
----
+## 📋 CLI Command Registry
 
-## 3. Adapters & Use Cases
+| Command | Description |
+| :--- | :--- |
+| `status` | Shows the active phase, Trace ID, and real-time agent health scores. |
+| `check` | Audits system health, MCP connectivity, and constitutional integrity. |
+| `trace:new` | Starts a new task chain with a unique ID and briefs the Army. |
+| `create-app` | Generates an enterprise monorepo (Fastify/React) from natural language. |
+| `verify-contract` | Seals the type alignment between backend and frontend modules. |
 
-Agent Enderun is designed to support the specific AI adapter that matches your IDE or CLI environment.
+## 📂 Architecture Map
 
 ```text
-               ┌───────────────────────┐
-               │    agent-enderun      │
-               └───────────┬───────────┘
-                           │
-         ┌─────────────────┼─────────────────┐
-         ▼                 ▼                 ▼
-  .enderun/          .claude/           .cursor/
-(Gemini Adapter)   (Claude Code)     (Cursor IDE)
+├── .enderun/               <-- The Framework Brain
+│   ├── agents/             <-- 12 Specialist Directives (Manager, Architect, QA...)
+│   ├── knowledge/          <-- Enterprise Standards (ESLint, API, Security)
+│   ├── memory-graph/       <-- Shared Facts & Agent Private Contexts
+│   ├── queue/              <-- Hermes Messaging & Task Queue
+│   └── ENDERUN.md          <-- The Supreme Constitution
+├── apps/                   <-- Enterprise Application Space
+├── docs/                   <-- Project Architectural Portal (ADRs, Tech-Stack)
+└── framework-mcp/          <-- Autonomous Operations Server
 ```
 
-### Gemini Adapter (Standard & Recommended)
-- **Folder:** `.enderun/`
-- **Target Use:** Gemini CLI, Google Vertex AI, and direct Gemini API environments.
-- **Shim File:** `gemini.md` (placed at the project root as the initial context instructions).
-- **Benefit:** Full Model Context Protocol (MCP) server hooks natively tuned for Gemini's large-context window.
-
-### Claude & Cursor Adapters
-- **Claude Adapter (`init claude`):** Creates the `.claude/` directory and shims. Configures automated MCP access for **Claude Code CLI** and **Claude Desktop**.
-- **Cursor Adapter (`init cursor`):** Creates `.cursor/` directory containing `.cursorrules` to immediately guide the Cursor IDE agent with Enderun's strict coding boundaries.
-
-### Integrating with Claude Code / Claude Desktop
-
-Agent Enderun provides a fully-functional **Model Context Protocol (MCP)** server. To connect it to your Claude environment, append the following block to your `claude_desktop_config.json` or global Claude CLI configuration:
-
-```json
-{
-  "mcpServers": {
-    "agent-enderun-mcp": {
-      "command": "node",
-      "args": ["/absolute/path/to/your/project/framework-mcp/dist/index.js"]
-    }
-  }
-}
-```
-
-Once connected, your AI assistant will gain access to tools such as:
-- `search_codebase` (Surgical context parsing)
-- `read_project_memory` & `update_project_memory` (State machine updates)
-- `verify_api_contract` (TypeScript type validation)
-- `send_agent_message` (Hermes protocol queues)
-
----
-
-## 4. Project Development Workflow & Best Practices
-
-To successfully develop a project within the Agent Enderun framework, follow this rigid workflow.
-
-### A. Phase-Based Lifecycle
-Development progresses sequentially through five states. Do not skip phases:
-1. **`PHASE_0` - Discovery & Setup:** Fill out `docs/tech-stack.md` and select the execution profile (Lightweight MVP vs. Full Enterprise).
-2. **`PHASE_1` - Architecture & Contracts:** Create your models and API definitions first. Establish contract hashes.
-3. **`PHASE_2` - Core Development:** Develop features inside `apps/backend/` and `apps/web/` in parallel.
-4. **`PHASE_3` - Integration & Testing:** Run end-to-end integration and reach the mandatory **80% test coverage gate** via `@qa`.
-5. **`PHASE_4` - Optimization & Deployment:** Perform a final performance audit and deploy.
-
-### B. Trace ID Protocol
-Never write code or commit files without an active task ULID. 
-1. Create a new task tracking chain:
-   ```bash
-   npx agent-enderun trace:new "Implement JWT Authentication" backend P1
-   ```
-2. This generates a ULID (e.g., `01H7G8K5TJ5S6MF9Z7H8N4C2P`) and appends it to the `ACTIVE TASKS` table in `PROJECT_MEMORY.md`.
-3. Use the Trace ID prefix in your git commit messages:
-   ```bash
-   git commit -m "[01H7G8K5TJ5S6MF9Z7H8N4C2P] feat(auth): add JWT fastify plugins"
-   ```
-
-### C. Contract-First & Branded Types
-Under Agent Enderun, all ID types must use strict **Branded Types** to avoid type confusion:
-```typescript
-// apps/backend/src/types/brands.ts
-export type Brand<T, K extends string> = T & { __brand: K };
-
-export type UserID = Brand<string, "UserID">;
-export type ProjectID = Brand<string, "ProjectID">;
-```
-Ensure `@backend` compiles all types into a shared folder BEFORE `@frontend` starts any page implementation. Update the contract version in `apps/backend/contract.version.json`.
-
-### D. Zero Mock & Zero UI-Library Policy
-- **No Mocking:** All developed user interfaces must pull data from actual verified backend endpoints or Kysely repositories (with exceptions only for 3rd-party platforms like Stripe or Twilio).
-- **Panda CSS & Custom UI:** External pre-styled components (e.g. TailwindCSS, MUI, Shadcn/UI) are forbidden in core workspaces unless explicitly authorized by `@manager`. Rely entirely on the type-safe token system of **Panda CSS** to construct custom, responsive interfaces.
-
-### E. Security & Compliance Scanning
-Run static scanning checks locally on your codebase:
-* **Security Audit:** Searches for unsafe database strings, hardcoded keys, innerHTML assignments, and `any` types.
-  ```bash
-  npx agent-enderun check:security
-  ```
-* **Constitution Compliance:** Inspects files for forbidden libraries, unbranded ID types, and missing error-handling parameters.
-  ```bash
-  npx agent-enderun check:compliance
-  ```
-
-### F. Hermes Messaging & Task Queues
-If working with multiple sub-agents in parallel, agents communicate via `messages/` under the Hermes Protocol. The files are locked via `.lock` tokens to ensure thread safety, and execution routes asynchronously through `.enderun/queue/`.
-
----
-
-## 5. CLI Reference Manual
-
-| Command | Arguments | Description |
-| :--- | :--- | :--- |
-| `init` | `[adapter]` | Initializes the framework. Supported adapters: `gemini` (creates `.enderun/`), `claude` (`.claude/`), `cursor` (`.cursor/`). |
-| `check` | *None* | Performs full framework diagnostic and codebase health check. |
-| `status` | *None* | Displays current active Phase, Trace IDs, agent states, and blockers. |
-| `trace:new` | `<description> [agent] [priority]` | Generates a new ULID Trace ID and appends it to active tasks. |
-| `create-app` | `<idea>` | Generates a full-stack monorepo application template from natural language. |
-| `verify-contract` | *None* | Computes API hashes to verify type parity between backend and frontend. |
-| `check:security` | `[path]` | Runs static scan for SQL injections, secrets, and illegal variables. |
-| `check:compliance` | `[path]` | Audits compliance with Branded Types and forbidden UI libraries. |
-| `explorer:graph` | `[path]` | Generates a visual Mermaid TD dependency diagram of the local files. |
-| `explorer:audit` | `[path]` | Executes static analysis mapping files to corresponding agent owners. |
-| `git:commit` | `<trace-id>` | Inspects staged files and suggests a perfect semantic git commit message. |
-| `mcp` | *None* | Starts the Model Context Protocol stdio server. |
-| `version` | *None* | Prints the current framework release version. |
-
----
-
-## 6. Project Layout Directory Structure
-
-A fully-governed monorepo structured under Agent Enderun looks as follows:
-
-```text
-├── .enderun/               <-- Framework Runtime & Memory (v0.8.8)
-│   ├── agents/             <-- Specialist agent Blueprints & SOPs
-│   ├── knowledge/          <-- Rigid architecture patterns & rules
-│   ├── memory-graph/       <-- Global facts & private agent states
-│   ├── logs/               <-- Structured JSON audit trail
-│   ├── queue/              <-- Asynchronous task queues
-│   ├── PROJECT_MEMORY.md   <-- Unified state brain (SSOT)
-│   └── STATUS.md           <-- Agent army dashboard
-├── apps/
-│   ├── backend/            <-- Fastify & Kysely backend workspace
-│   │   └── contract.json   <-- API contract registry & hash metadata
-│   └── web/                <-- React & Panda CSS client workspace
-├── docs/                   <-- User's technical stack & requirements
-├── framework-mcp/          <-- MCP Server source code & tools
-├── bin/                    <-- Executable CLI entrypoint binaries
-├── ENDERUN.md              <-- System Constitution (Supreme Law)
-└── package.json            <-- Monorepo workspaces & shared actions
-```
-
----
 ---
 
 # Türkçe
 
-## İçindekiler
-- [1. Giriş ve Temel Felsefe](#1-giriş-ve-temel-felsefe)
-- [2. Kurulum ve Hızlı Başlangıç](#2-kurulum-ve-hızlı-başlangıç)
-  - [Ön Gereksinimler](#ön-gereksinimler)
-  - [Adım Adım Kurulum](#adım-adım-kurulum)
-  - [Sağlık ve Doğrulama Taraması](#sağlık-ve-doğrulama-taraması)
-- [3. Adaptörler ve Kullanım Senaryoları](#3-adaptörler-ve-kullanım-senaryoları)
-  - [Gemini Adaptörü (Standart & Önerilen)](#gemini-adaptörü-standart--önerilen)
-  - [Claude & Cursor Adaptörleri](#claude--cursor-adaptörleri)
-  - [Claude Code / Claude Desktop Entegrasyonu](#claude-code--claude-desktop-entegrasyonu)
-- [4. Proje Geliştirme Akışları ve En İyi Pratikler](#4-proje-geliştirme-akışları-ve-en-iyi-pratikler)
-  - [A. Aşama Tabanlı Yaşam Döngüsü](#a-aşama-tabanlı-yaşam-döngüsü)
-  - [B. Trace ID Protokolü](#b-trace-id-protokolü)
-  - [C. Kontrat Öncelikli Geliştirme & Branded Types](#c-kontrat-öncelikli-geliştirme--branded-types)
-  - [D. Sıfır Sahte Veri (Zero-Mock) & Sıfır UI Kütüphanesi Kanunu](#d-sıfır-sahte-veri-zero-mock--sıfır-ui-kütüphanesi-kanunu)
-  - [E. Güvenlik ve Uyumluluk Taramaları](#e-güvenlik-ve-uyumluluk-taramaları)
-  - [F. Hermes Mesajlaşması & Görev Kuyrukları](#f-hermes-mesajlaşması--görev-kuyrukları)
-- [5. CLI Referans Klavuzu](#5-cli-referans-klavuzu)
-- [6. Proje Klasör Dizilim Mimarisi](#6-proje-klasör-dizilim-mimarisi)
-
----
-
-## 1. Giriş ve Temel Felsefe
+**Agent Enderun**, sıradan bir kod üreticisi değil; karmaşık, ölçeklenebilir ve mutlak denetlenebilir kurumsal yazılım projeleri için tasarlanmış bir **Yapay Zeka Yönetişim ve Otonom Ordu Komuta Sistemidir**.
 
-Yazılım geliştirme süreçlerindeki yapay zeka yardımı genellikle plansız değişikliklere, teknik borç birikimine ve kontrolsüz kod sapmalarına neden olur. **Agent Enderun**, yapay zekayı basit bir kod üreteci olarak konumlandırmak yerine, onu `@manager` (Takım Lideri) ajanı komutasında çalışan, kurallara bağlı disiplinli bir mühendislik ordusu haline getiren **Kurumsal Yapay Zeka Yönetişim Framework'üdür**.
+v0.9.0 sürümüyle birlikte sistem; kendi hafızasını yönetebilen, kod tabanına cerrahi müdahaleler yapabilen ve farklı YZ ekosistemlerini tek bir anayasal disiplin altında birleştiren **"Yaşayan bir Mühendislik Organizması"** haline gelmiştir.
 
-### Enderun’un Beş Ana Sütunu
-1.  **Mutlak İzlenebilirlik:** Yapılan her işlem, commit ve durum değişikliği ULID tabanlı bir **Trace ID** ile damgalanır.
-2.  **Önce Sözleşme (Contract-First):** API rotaları ve veri tipleri (**Branded Types**) tanımlanıp onaylanmadan tek satır kod yazılamaz.
-3.  **Kalıcı Yerel Hafıza:** Yapay zekanın tüm bağlamı (context) ve projenin mevcut durumu, işletim sisteminin `/tmp` dizininde değil, doğrudan projenizin içinde saklanır.
-4.  **Sınırların Korunması (Pristine Sandboxing):** Framework çekirdeği ile sizin uygulama kodunuz arasında aşılmaz sınırlar çizilir.
-5.  **Gerçekçi Veri (Zero Mock Policy):** Tüm analiz ve operasyon ekranları sahte verilerle (mock) değil, onaylanmış canlı veritabanı şemalarıyla konuşur.
+## 💎 Stratejik Platform Sinerjisi (Dörtlü Güç)
 
----
+Agent Enderun, sektördeki en güçlü YZ ekosistemlerini bir araya getirerek her birini proje içinde stratejik bir rolle görevlendirir:
 
-## 2. Kurulum ve Hızlı Başlangıç
+1.  **🚀 Claude Code (Operasyonel Cerrahi):** Projenin **Saha Mühendisi**dir. Dosya sistemi üzerindeki rakipsiz hızı ve `patch_file` aracıyla otonom kod düzenlemelerini cerrahi hassasiyetle yönetir.
+2.  **♊ Gemini & Vertex AI (Stratejik Akıl):** Sistemin **Komuta Merkezi**dir. 2M+ token bağlam kapasitesiyle projenin tüm geçmişini ve mimari yapısını aynı anda analiz ederek üst düzey kararlar alır.
+3.  **🛸 Antigravity (İç Disiplin):** Projenin **Askeri Akademisi**dir. İç standartlarımızı korumak için tasarlanmış, dış dünyadan izole ve yüksek disiplinli geliştirme ortamıdır.
+4.  **🤖 Grok / X.ai (Keşif Birliği):** Projenin **Otonom Vizyonu**dur. Gelecek odaklı ajan protokollerini test etmek ve YZ tabanlı geliştirme sınırlarını zorlamak için kullanılır.
 
-### Ön Gereksinimler
-- **Node.js** v20.0.0 veya üzeri (LTS sürümü önerilir).
-- **npm** v9+ veya **pnpm** v8+ veya **yarn** v3+.
-- **Git** (proje dizininde başlatılmış olmalıdır).
+## 🛡️ Enderun Disiplininin Beş Sarsılmaz Sütunu
 
-### Adım Adım Kurulum
+1.  **Mutlak İzlenebilirlik (Trace ID):** Her karar, her commit ve her kod satırı ULID tabanlı bir Trace ID ile damgalanır. Kurumsal denetim (audit) saniyeler içinde yapılabilir.
+2.  **Önce Sözleşme (Contract-First):** Backend ve Frontend arasındaki veri kontratları mühürlenmeden kod yazılamaz. Tip güvenliği projenin kutsal yasasıdır.
+3.  **Cerrahi Düzenleme Standardı:** Dosyaların tamamını üzerine yazmak yasaktır. Sistem, sadece değişen satırları güncelleyen `replace_text` ve `patch_file` araçlarını zorunlu kılar.
+4.  **Otonom Hafıza Arşivleme (Auto-Prune):** `PROJECT_MEMORY.md` asla şişmez. 10 kayıt sınırını geçen tarihçeler otomatik arşivlenir; sistem her zaman taze ve ekonomik kalır.
+5.  **Anayasal SSOT:** Tüm platformlar (Claude, Gemini vb.) tek bir üst otoriteye, `.enderun/ENDERUN.md` anayasasına %100 sadakatle bağlıdır.
 
-#### Adım 1: Proje dizininizi oluşturun ve Git'i başlatın
-```bash
-mkdir benim-kurumsal-uygulamam
-cd benim-kurumsal-uygulamam
-git init
-```
+## 🛠️ Kurulum ve Dağıtım
 
-#### Adım 2: Framework'ü Başlatın
-Aşağıdaki komut, projenizi analiz ederek uygun adaptörü kurar ve yönetişim yapısını hazırlar:
-```bash
-npx agent-enderun init gemini
-```
-*Not: Bir adaptör belirtilmezse standart olarak `gemini` kurulur ve framework çalışma ortamı `.enderun/` dizininde oluşturulur.*
+Kullandığınız platforma göre tek komutla Agent Enderun'u başlatın:
 
-#### Adım 3: Bağımlılıkları Yükleyin ve MCP Sunucusunu Derleyin
 ```bash
-npm install
-npm run enderun:build
-```
+# Gemini CLI ve Antigravity için (Standart)
+agent-enderun init gemini
 
----
+# Claude Code (CLI & Desktop) için — Cerrahi Odaklı
+agent-enderun init claude
 
-### Sağlık ve Doğrulama Taraması
+# Antigravity IDE/CLI Bağımsız Kurulumu
+agent-enderun init antigravity
 
-Kurulum sonrasında veya büyük aşama geçişlerinde projenizin sağlık durumunu denetlemek için yerleşik tarayıcıyı çalıştırın:
-```bash
-npx agent-enderun check
+# Grok Build / X.ai Otonom Ajanları İçin
+agent-enderun init grok
 ```
 
-#### Bu tarama neleri doğrular?
-- **Anayasa Güvenliği:** `ENDERUN.md` dosyasının mevcudiyetini ve doğruluğunu kontrol eder.
-- **Bellek Erişimi:** `.enderun/PROJECT_MEMORY.md` dosyasının etkin ve yazılabilir olduğunu denetler.
-- **Sözleşme Bütünlüğü:** `apps/backend/contract.version.json` dosyasını denetler.
-- **MCP Derlemesi:** `framework-mcp/dist/index.js` dosyasının derlendiğini doğrular.
-- **Teknoloji Yığını:** Projenin mimari stack tanımının `docs/tech-stack.md` içine yazılıp yazılmadığını kontrol eder.
-
----
-
-## 3. Adaptörler ve Kullanım Senaryoları
+## 📋 CLI Komut Rehberi
 
-Agent Enderun, kullandığınız editör veya yapay zeka aracına uygun adaptörü dinamik olarak etkinleştirir.
+| Komut | Açıklama |
+| :--- | :--- |
+| `status` | Aktif fazı, Trace ID'yi ve ajanların anlık sağlık skorlarını gösterir. |
+| `check` | Sistemin anayasal sağlığını ve dosya bütünlüğünü denetler. |
+| `trace:new` | Yeni bir görev zinciri başlatır ve orduyu görevlendirir. |
+| `create-app` | Doğal dilden kurumsal monorepo (Fastify/React) üretir. |
+| `verify-contract` | Backend ve Frontend arasındaki tip uyumluluğunu mühürler. |
 
-### Gemini Adaptörü (Standart & Önerilen)
-- **Dizin:** `.enderun/`
-- **Hedef:** Gemini CLI, Google Vertex AI ve doğrudan Gemini API ortamları.
-- **Tetikleyici:** Proje kökündeki `gemini.md` dosyası (yapay zeka ilk bu dosyayı okuyarak anayasayı yükler).
-- **Avantaj:** Gemini'ın devasa bağlam (context window) kapasitesine göre optimize edilmiş araç çağrıları.
+## 📂 Sistem Mimarisi
 
-### Claude & Cursor Adaptörleri
-- **Claude Adaptörü (`init claude`):** `.claude/` çalışma dizinini hazırlar. **Claude Code CLI** ve **Claude Desktop** için otomatik MCP bağlantılarını yapılandırır.
-- **Cursor Adaptörü (`init cursor`):** `.cursor/` klasörünü ve `.cursorrules` dosyasını oluşturarak Cursor IDE'nin kendi kod üretim sınırlarını Enderun kurallarına kilitler.
-
-### Claude Code / Claude Desktop Entegrasyonu
-
-Agent Enderun, tam teşekküllü bir **Model Context Protocol (MCP)** sunucusu içerir. Bunu Claude ortamınıza bağlamak için `claude_desktop_config.json` dosyanıza veya global Claude CLI ayarlarınıza şu bloğu eklemeniz yeterlidir:
-
-```json
-{
-  "mcpServers": {
-    "agent-enderun-mcp": {
-      "command": "node",
-      "args": ["/absolute/path/to/your/project/framework-mcp/dist/index.js"]
-    }
-  }
-}
-```
-
-Bağlantı kurulduğunda, yapay zekanız şu araçları (tools) kullanma yeteneği kazanır:
-- `search_codebase` (Cerrahi kod arama)
-- `read_project_memory` & `update_project_memory` (Hafıza güncelleme)
-- `verify_api_contract` (Tip uyumluluk kontrolü)
-- `send_agent_message` (Ajanlar arası Hermes mesajlaşması)
-
----
-
-## 4. Proje Geliştirme Akışları ve En İyi Pratikler
-
-Agent Enderun framework'ü üzerinde başarılı bir geliştirme süreci yürütmek için aşağıdaki adımları takip etmeniz zorunludur:
-
-### A. Aşama Tabanlı Yaşam Döngüsü
-Geliştirme süreci asla atlanamayacak 5 ardışık fazdan oluşur:
-1.  **`PHASE_0` - Keşif ve Yapılandırma:** `docs/tech-stack.md` doldurulur ve Lightweight (MVP) veya Full (Kurumsal) yürütme profili seçilir.
-2.  **`PHASE_1` - Mimari ve Sözleşmeler:** Veri modelleri, API rotaları ve tip sözleşmeleri kilitlenir.
-3.  **`PHASE_2` - Çekirdek Geliştirme:** `apps/backend` ve `apps/web` paralel olarak kodlanır.
-4.  **`PHASE_3` - Entegrasyon ve Test:** `@qa` ajanı denetiminde **en az %80 birim/entegrasyon test kapsamı** zorunlu kapı olarak geçilir.
-5.  **`PHASE_4` - Optimizasyon ve Dağıtım:** Performans denetimleri tamamlanarak uygulama canlıya alınır.
-
-### B. Trace ID Protokolü
-Aktif bir iş ULID'si olmadan kod yazmak veya commit atmak yasaktır.
-1.  Yeni bir göreve başlarken terminalden yeni bir Trace oluşturun:
-    ```bash
-    npx agent-enderun trace:new "JWT Yetkilendirme Modülü" backend P1
-    ```
-2.  Bu komut benzersiz bir ULID üretir (örn: `01H7G8K5TJ5S6MF9Z7H8N4C2P`) ve bunu `.enderun/PROJECT_MEMORY.md` içindeki aktif görevler tablosuna yazar.
-3.  Tüm Git commit mesajlarınızda bu Trace ID'yi ön ek olarak kullanın:
-    ```bash
-    git commit -m "[01H7G8K5TJ5S6MF9Z7H8N4C2P] feat(auth): add JWT fastify plugins"
-    ```
-
-### C. Kontrat Öncelikli Geliştirme & Branded Types
-Hatalı kimlik atamalarını ve tip belirsizliklerini önlemek için projedeki tüm benzersiz kimlikler (ID) **Branded Types** formatında markalanmalıdır:
-```typescript
-// apps/backend/src/types/brands.ts
-export type Brand<T, K extends string> = T & { __brand: K };
-
-export type UserID = Brand<string, "UserID">;
-export type ProjectID = Brand<string, "ProjectID">;
+```text
+├── .enderun/               <-- Sistemin Beyni
+│   ├── agents/             <-- 12 Uzman Ajan Direktifi (Manager, Architect, QA...)
+│   ├── knowledge/          <-- Kurumsal Akıl (ESLint, API, Güvenlik Standartları)
+│   ├── memory-graph/       <-- Ortak Hafıza ve Ajan Bağlamları
+│   ├── queue/              <-- Hermes Mesajlaşma ve Görev Kuyruğu
+│   └── ENDERUN.md          <-- Proje Anayasası (Üst Yasa)
+├── apps/                   <-- Kurumsal Uygulama Alanı
+├── docs/                   <-- Proje Mimari Portalı (ADRs, Tech-Stack)
+└── framework-mcp/          <-- Otonom Operasyon Sunucusu
 ```
-`@backend` ajanı tüm bu tipleri ortak sözleşmeye yazıp `apps/backend/contract.version.json` dosyasını güncellemeden, `@frontend` ajanı kullanıcı arayüzü tasarlamaya başlayamaz.
-
-### D. Sıfır Sahte Veri (Zero-Mock) & Sıfır UI Kütüphanesi Kanunu
-*   **Sahte Veri Yasağı:** Arayüzler doğrudan doğrulanmış Fastify uç noktalarından ve Kysely veritabanı depolarından beslenmelidir (Stripe, Twilio gibi dış servis entegrasyonları hariç).
-*   **Panda CSS Kullanımı:** TailwindCSS, MUI veya Shadcn/UI gibi hazır stillendirilmiş kütüphaneler (aksine bir `@manager` izni yoksa) yasaktır. Tasarımlar tamamen tip-güvenli **Panda CSS** belirteçleri (tokens) ile el değerek oluşturulur.
-
-### E. Güvenlik ve Uyumluluk Taramaları
-Kaynak kodunuzu yerel olarak statik analizlerden geçirin:
-*   **Güvenlik Denetimi:** Güvensiz veritabanı sorgularını, açık parola tanımlarını ve `any` veri tipi ihlallerini yakalar:
-    ```bash
-    npx agent-enderun check:security
-    ```
-*   **Anayasa Uyumluluğu:** Markalanmamış kimlik kullanımlarını ve yasaklı harici UI kütüphane bağımlılıklarını denetler:
-    ```bash
-    npx agent-enderun check:compliance
-    ```
-
-### F. Hermes Mesajlaşması & Görev Kuyrukları
-Paralel çalışan alt ajanlar (sub-agents), birbirleriyle Hermes Protokolü (`messages/` klasörü) üzerinden asenkron olarak mesajlaşır. İşlemler `.lock` kilit dosyalarıyla güvenceye alınır ve asenkron kuyruklar `.enderun/queue/` altında güvenle sıraya konur.
-
----
-
-## 5. CLI Referans Klavuzu
-
-| Komut | Parametreler | Açıklama |
-| :--- | :--- | :--- |
-| `init` | `[adapter]` | Framework'ü başlatır. Desteklenen adaptörler: `gemini` (`.enderun/`), `claude` (`.claude/`), `cursor` (`.cursor/`). |
-| `check` | *Yok* | Projenin genel sağlık ve anayasal uyumluluk durumunu denetler. |
-| `status` | *Yok* | Aktif aşamayı, Trace ID'lerini, aktif ajan durumlarını ve engelleri (blockers) gösterir. |
-| `trace:new` | `<açıklama> [ajan] [öncelik]` | Yeni bir ULID Trace ID'si oluşturarak proje hafızasındaki aktif görevlere ekler. |
-| `create-app` | `<fikir>` | Doğal dil ile girilen gereksinimlerden sıfırdan kurumsal monorepo uygulaması üretir. |
-| `verify-contract` | *Yok* | Sözleşme karma değerlerini (hash) hesaplayarak backend-frontend tip uyumluluğunu doğrular. |
-| `check:security` | `[yol]` | Ham SQL, açık anahtarlar, innerHTML ve `any` tipi için güvenlik taraması yapar. |
-| `check:compliance` | `[yol]` | Branded Types uyumluluğunu ve yasaklı arayüz kütüphanelerini denetler. |
-| `explorer:graph` | `[yol]` | Dosyalar arası bağımlılıkları analiz ederek görsel Mermaid TD şeması üretir. |
-| `explorer:audit` | `[yol]` | Kod dosyalarının hangi uzman ajanın mülkiyetinde olduğunu listeleyen statik analiz yapar. |
-| `git:commit` | `<trace-id>` | Commit aşamasındaki staged dosyaları inceleyerek Trace ID uyumlu semantik commit mesajı önerir. |
-| `mcp` | *Yok* | Model Context Protocol stdio sunucusunu başlatır. |
-| `version` | *Yok* | Framework'ün mevcut sürüm numarasını yazdırır. |
 
 ---
 
-## 6. Proje Klasör Dizilim Mimarisi
-
-Agent Enderun altında yönetilen örnek bir kurumsal monorepo yapısı:
-
-```text
-├── .enderun/               <-- Çalışma Zamanı & Hafıza Klasörü (v0.8.8)
-│   ├── agents/             <-- Uzman Ajan Direktifleri ve SOP Belgeleri
-│   ├── knowledge/          <-- Mimari Desenler ve Kodlama Kuralları
-│   ├── memory-graph/       <-- Paylaşılan Gerçekler ve Ajan Durumları
-│   ├── logs/               <-- Denetlenebilir Yapılandırılmış JSON Logları
-│   ├── queue/              <-- Asenkron Görev Yönetim Kuyruğu
-│   ├── PROJECT_MEMORY.md   <-- Projenin Tek Güvenilir Ortak Beyni (SSOT)
-│   └── STATUS.md           <-- Ajan Ordusu Durum Gösterge Paneli
-├── apps/
-│   ├── backend/            <-- Fastify ve Kysely tabanlı Backend Çalışma Alanı
-│   │   └── contract.json   <-- API Sözleşmeleri ve Doğrulama Özetleri
-│   └── web/                <-- React ve Panda CSS tabanlı Client Çalışma Alanı
-├── docs/                   <-- Kullanıcının Mimari İstekleri ve Stack Bilgileri
-├── framework-mcp/          <-- MCP Sunucu Kaynak Kodları ve Araçlar
-├── bin/                    <-- Çalıştırılabilir CLI Giriş Noktası Binaries
-├── ENDERUN.md              <-- Sistem Anayasası (Supreme Law)
-└── package.json            <-- Monorepo Çalışma Alanı Tanımları & Betikler
-```
+**Geliştiren / Developed by:** Yusuf BEKAR  
+**Sürüm / Version:** v0.9.0  
+**Lisans / License:** MIT

package/agent.md

@@ -0,0 +1,25 @@
+# Agent Enderun — Antigravity Adapter
+
+This is the primary entry point when using Agent Enderun within the Antigravity (IDE & CLI) ecosystem.
+
+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
+You are operating under the Agent Enderun governance framework.
+
+At the **start of every session**, before any work:
+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.
+
+### 🛡️ 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/bin/cli.js

@@ -1,19 +1,19 @@
 #!/usr/bin/env node
-import { spawn } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
-const cliPath = join(__dirname, '../src/cli/index.ts');
+const cliPath = join(__dirname, "../src/cli/index.ts");
 
 // shell: false kullanarak argümanların (tırnakların) bozulmasını önle
-const child = spawn('npx', ['tsx', cliPath, ...process.argv.slice(2)], {
-  stdio: 'inherit',
-  shell: false 
+const child = spawn("npx", ["tsx", cliPath, ...process.argv.slice(2)], {
+    stdio: "inherit",
+    shell: false 
 });
 
-child.on('exit', (code) => {
-  process.exit(code ?? 0);
+child.on("exit", (code) => {
+    process.exit(code ?? 0);
 });