agent-enderun 1.1.1 → 1.1.3

package/src/cli/commands/init.ts

@@ -1,353 +1,205 @@
 import fs from "fs";
 import path from "path";
-import { fileURLToPath } from "url";
-import { execSync } from "child_process";
+import readline from "readline";
 
 import {
     resolveAdapter,
-    isAdapterShimFile,
-    remapFrameworkContent,
     runAdapterPostInit,
+    remapFrameworkContent,
     type AdapterConfig,
+    type AdapterId,
 } from "../adapters.js";
-import { mergePackageJson, deepCleanProtocols, sanitizeJson, getPackageVersion, getValidatorPath } from "../utils/pkg.js";
-import { updateGitIgnore, ensureDir, writeJsonFile, copyDir, writeTextFile } from "../utils/fs.js";
+import { getPackageRoot, getPackageVersion } from "../utils/pkg.js";
+import { ensureDir, writeJsonFile } from "../utils/fs.js";
 import { initializeMemory } from "../utils/memory.js";
-import { checkCommand } from "./check.js";
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const sourceDir = path.join(__dirname, "../../..");
-const targetDir = process.cwd();
+// Import Modular Definitions
+import { ALL_AGENTS, buildAgentJson } from "../../modules/agents/definitions.js";
+import { CORE_SKILLS } from "../../modules/skills/definitions.js";
 
-const FRAMEWORK_VERSION = getPackageVersion();
 
-const CORE_FILES = [
-    ".enderun",
-    "mcp.json",
-    ".env.example",
-    "ENDERUN.md",
-    "package.json",
-    "tsconfig.json",
-    "panda.config.ts",
-    "vitest.config.ts",
-    "framework-mcp",
-    "docs",
-    "eslint.config.js",
-];
+const FRAMEWORK_NAME = "Enderun Core";
+const FRAMEWORK_VERSION = getPackageVersion();
 
 const FRAMEWORK_SUBDIRS = [
+    "apps",
     "agents",
-    "agents/schema",
     "skills",
     "knowledge",
-    "benchmarks",
-    "monitoring",
-    "logs",
-    "messages",
-    "memory-graph",
-    "memory-graph/agent-contexts",
-    "queue",
-    "queue/pending",
-    "queue/processing",
-    "queue/completed",
-    "queue/failed",
-    "queue/pipelines",
+    "memory",
+    "router",
+    "registry",
+    "observability",
+    "rules",
 ];
 
-const allAgents = [
-    {
-        name: "manager",
-        displayName: "Orchestration & Governance (Team-Lead)",
-        description: "CTO, Lead Architect, and Orchestrator for Agent Enderun.",
-        instructions: "You are the manager agent. Orchestrate workspace tasks, manage DAG dependency graphs, handle phase transitions, and enforce architectural standards.\n\n🛑 NON-NEGOTIABLE CORE RULES:\n- Single Point of Authority: You are the sole entry point. No specialist acts without your briefing.\n- Traceability: Every action MUST inherit the active Trace ID.\n- Memory Discipline: MUST update PROJECT_MEMORY.md and log actions at the end of EVERY turn."
-    },
-    {
-        name: "backend",
-        displayName: "Domain Logic & Databases Specialist",
-        description: "Responsible for core business logic, database migrations, security standards, API contracts, and server architecture.",
-        instructions: "You are the backend agent. Build secure, high-performance, and consistent server architecture.\n\n🛑 NON-NEGOTIABLE CORE RULES:\n- No UI: Never implement UI or frontend logic.\n- Contract-First: Define shared contracts/branded types BEFORE any consumer code.\n- Branded Types Law: ALL IDs must use branded types (e.g., UserID). Plain strings are forbidden.\n- Zero Mock Policy: Use real endpoints/contracts only.\n- Surgical Edits: Use replace_text for all code changes."
-    },
-    {
-        name: "frontend",
-        displayName: "Fluid Responsive UI Specialist",
-        description: "Builds responsive fluid user interfaces, manages styling tokens with Panda CSS, and implements state machines.",
-        instructions: "You are the frontend agent. Build original, high-performance, and responsive user interfaces.\n\n🛑 NON-NEGOTIABLE CORE RULES:\n- Responsive-First: Mobile-First (320px) is mandatory. Fixed-width is forbidden.\n- Zero UI Library Policy: No shadcn/ui, MUI, etc. Build everything with Panda CSS.\n- Zero Mock Policy: Use real endpoints/contracts only.\n- Contract-First: Use branded types from apps/backend/src/types.\n- No Native Alerts: Use integrated Toaster/Modal components."
-    },
-    {
-        name: "quality",
-        displayName: "Automated Testing & Quality Specialist",
-        description: "Verifies test coverage, audits compliance with the constitution, conducts AST scanning, and verifies CI/CD status.",
-        instructions: "You are the quality agent. Ensure no code is merged or deployed without meeting standards.\n\n🛑 NON-NEGOTIABLE CORE RULES:\n- Final Gate: No code merges or deploys proceed without quality sign-off.\n- Verification-First: Audit lint, typecheck, contract drift, and branded types before sign-off.\n- Never Implement: Audit and assess only. Never write application features.\n- Zero Mock Policy: Integration tests must use real/service-compatible backends.\n- Coverage Gate: Reject approvals if coverage falls below >80% threshold in core."
-    },
-    {
-        name: "database",
-        displayName: "Database Migrations & Tuning Specialist",
-        description: "Designs SQL schemas, manages migration scripts via Kysely, optimizes queries, indexes, and seeding logic.",
-        instructions: "You are the database agent. Build secure, optimized, and scalable data layers.\n\n🛑 NON-NEGOTIABLE CORE RULES:\n- Self-Contained DB: Every backend application MUST manage its own schema/migrations/seeds in its own src/database/ directory.\n- Contract-First: All schemas MUST be derived from branded types.\n- Kysely Standard: Use Kysely for application queries. Raw SQL is forbidden.\n- Zero Mock Policy: Realistic, contract-aware seed data only.\n- Surgical Edits: Use replace_text for all schema/migration changes."
-    },
-    {
-        name: "devops",
-        displayName: "Infrastructure & CI/CD Specialist",
-        description: "Handles deployment pipelines, environment variables, system containerization, logging & telemetry integrations.",
-        instructions: "You are the devops agent. Ensure reliable execution in every environment with strict quality gates.\n\n🛑 NON-NEGOTIABLE CORE RULES:\n- Gate Approvals: NEVER deploy to production without quality gate approval.\n- No Docker Policy: Prefer native Node.js unless explicitly overridden by manager.\n- Environment Parity: Identical configs across dev/staging/prod (except secrets).\n- Secrets Security: NEVER hardcode secrets. Use environment variables.\n- Rollback First: Deployment is BLOCKED if no documented rollback plan exists."
-    },
-    {
-        name: "explorer",
-        displayName: "Codebase Discovery Specialist",
-        description: "Maps code dependencies, performs project scans, identifies architectural gaps, and supports legacy onboarding.",
-        instructions: "You are the explorer agent. Map project structure and provide deep context to other agents.\n\n🛑 NON-NEGOTIABLE CORE RULES:\n- Read-Only: Never write production code. Only discover, map, and report.\n- Search-First: Always use search_codebase before reading large files.\n- Surgical Discovery: Focus on entry points and core domain logic.\n- Zero Mock Policy: Analyze real system state only.\n- Traceability: All findings must be linked to a Trace ID."
-    },
-    {
-        name: "git",
-        displayName: "Version Control Specialist",
-        description: "Manages commit histories, branches, Trace ID alignment, semantic tagging, and merge conflicts.",
-        instructions: "You are the git agent. Ensure a clean, atomic, and traceable repository history.\n\n🛑 NON-NEGOTIABLE CORE RULES:\n- Trace ID Tagging: EVERY commit must include the active Trace ID in the message.\n- Atomic Integrity: Every commit must represent exactly one logical change.\n- Health-First: Never commit code that fails build or basic tests.\n- No Push: Do not run git push without explicit USER approval.\n- No Force: Never use git push --force on public branches."
-    },
-    {
-        name: "mobile",
-        displayName: "Mobile App Specialist",
-        description: "Develops cross-platform mobile apps using React Native and Expo with clean component states.",
-        instructions: "You are the mobile agent. Build high-performance, responsive mobile apps (React Native/Expo).\n\n🛑 NON-NEGOTIABLE CORE RULES:\n- Zero UI Library: Same discipline as web. Build UI from scratch.\n- Contract-First: Use shared types from apps/backend/src/types.\n- Responsive-First: Mobile-First approach is mandatory.\n- Safe Area: Handle iOS/Android safe area insets on every screen.\n- Performance: Target 60 FPS."
-    },
-    {
-        name: "native",
-        displayName: "Native OS Integration Specialist",
-        description: "Builds lightweight desktop wrappers and system integrations using Tauri or Electron.",
-        instructions: "You are the native agent. Build secure, efficient desktop apps (Tauri/Electron).\n\n🛑 NON-NEGOTIABLE CORE RULES:\n- Security-First: No remote code execution. Mandatory sandboxing and strict CSP.\n- Secure Storage: Use Keychain/Credential Manager for sensitive data.\n- IPC Contract: All communication between frontend and native MUST be typed.\n- Contract-First: Define IPC and data contracts before implementation.\n- Surgical Edits: Use replace_text for all code changes."
-    },
-    {
-        name: "security",
-        displayName: "Security & Cryptography Specialist",
-        description: "Enforces authentication flows, CSP policies, credential rotation, RLS constraints, and cryptographic safety.",
-        instructions: "You are the security agent. Ensure all endpoints, database connections, and authentication flows satisfy strict enterprise compliance policies.\n\n🛑 NON-NEGOTIABLE CORE RULES:\n- Sandboxed Security First: Enforce Row Level Security (RLS) on all database tables.\n- Credential Rotation Policy: Credentials, keys, and tokens must never be hardcoded. Use vault/env variables.\n- CSP & CORS Strictness: Never open wildcards (*) for CORS or CSP policies.\n- Surgical Edits: Use replace_text for all security patches."
-    },
-    {
-        name: "analyst",
-        displayName: "Contract Verification & Business Analyst",
-        description: "Validates business specifications, tests database contract integrity, and audits constitutional compliance.",
-        instructions: "You are the analyst agent. Independently verify compliance with contracts and specifications between frontend, backend, and the constitution.\n\n🛑 NON-NEGOTIABLE CORE RULES:\n- Independent Stance: Act as an objective verification gate.\n- Contract-First Law: Ensure contract.version.json perfectly matches types.\n- Escalation Priority: Report all contract drift to manager immediately.\n- Surgical Edits: Use replace_text for all document updates."
-    }
-];
+const COLOR_PALETTES = {
+    "Modern Blue": { primary: "#0ea5e9", secondary: "#64748b", accent: "#f43f5e" },
+    "Enterprise Slate": { primary: "#334155", secondary: "#94a3b8", accent: "#10b981" },
+    "Deep Purple": { primary: "#8b5cf6", secondary: "#d8b4fe", accent: "#f59e0b" }
+};
 
-function scaffoldCoreAgents(agentsBaseDir: string, dryRun: boolean) {
-    ensureDir(agentsBaseDir, dryRun);
-    const agentSchemaDir = path.join(agentsBaseDir, "schema");
-    ensureDir(agentSchemaDir, dryRun);
+async function runInteractiveInit(): Promise<{ selectedDirs: string[], selectedAgents: string[], selectedPalette: string }> {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const question = (query: string): Promise<string> => new Promise((resolve) => rl.question(query, resolve));
 
-    const agentArmySchema = {
-        "$schema": "http://json-schema.org/draft-07/schema#",
-        "title": "Agent Lifecycle (AL) Agent Army Schema",
-        "description": "Defines the required fields for an AL-compliant agent definition (e.g. agent.json or agent.md YAML frontmatter).",
-        "type": "object",
-        "required": ["name", "description", "role", "capability", "stateMachine", "tags"],
-        "properties": {
-            "name": { "type": "string" },
-            "description": { "type": "string" },
-            "role": { "type": "string" },
-            "capability": { "type": "integer", "minimum": 1, "maximum": 10 },
-            "stateMachine": {
-                "type": "object",
-                "required": ["schemaRef"],
-                "properties": { "schemaRef": { "type": "string" } }
-            },
-            "tags": { "type": "array", "items": { "type": "string" }, "minItems": 1 },
-            "permittedTools": { "type": "array", "items": { "type": "string" } },
-            "hidden": { "type": "boolean" },
-            "displayName": { "type": "string" },
-            "customAgentSpec": {
-                "type": "object",
-                "properties": {
-                    "customAgent": {
-                        "type": "object",
-                        "properties": {
-                            "systemPromptSections": {
-                                "type": "array",
-                                "items": {
-                                    "type": "object",
-                                    "properties": { "title": { "type": "string" }, "content": { "type": "string" } },
-                                    "required": ["title", "content"]
-                                }
-                            },
-                            "toolNames": { "type": "array", "items": { "type": "string" } }
-                        },
-                        "required": ["systemPromptSections", "toolNames"]
-                    }
-                },
-                "required": ["customAgent"]
-            }
-        }
-    };
-    writeJsonFile(path.join(agentsBaseDir, "agent_army_schema.json"), agentArmySchema, dryRun);
+    try {
+        console.warn(`\n🚀 Welcome to ${FRAMEWORK_NAME} Interactive Setup!`);
+        console.warn("\nAvailable Framework Directories:");
+        FRAMEWORK_SUBDIRS.forEach((d, i) => console.warn(`${i + 1}. ${d}`));
+        const dirInput = await question("\nEnter directory numbers to include (e.g. 1,2,3) or Enter for ALL: ");
+        const selectedDirs = dirInput ? dirInput.split(",").map(n => FRAMEWORK_SUBDIRS[parseInt(n.trim()) - 1]).filter(Boolean) : [...FRAMEWORK_SUBDIRS];
+
+        console.warn("\nAvailable Core Agents:");
+        ALL_AGENTS.forEach((a, i) => console.warn(`${i + 1}. ${a.name}`));
+        const agentInput = await question("\nEnter agent numbers to include (e.g. 1,2) or Enter for ALL: ");
+        const selectedAgents = agentInput ? agentInput.split(",").map(n => ALL_AGENTS[parseInt(n.trim()) - 1].name).filter(Boolean) : ALL_AGENTS.map(a => a.name);
+
+        console.warn("\nAvailable Color Palettes:");
+        const palettes = Object.keys(COLOR_PALETTES);
+        palettes.forEach((p, i) => console.warn(`${i + 1}. ${p}`));
+        const palInput = await question("\nSelect palette (1-3) or Enter for 'Modern Blue': ");
+        const selectedPalette = palettes[parseInt(palInput.trim()) - 1] || "Modern Blue";
+
+        return { selectedDirs, selectedAgents, selectedPalette };
+    } finally { rl.close(); }
+}
 
-    const agentLifecycleSchema = {
-        "$schema": "http://json-schema.org/draft-07/schema#",
-        "title": "Agent Lifecycle State Machine Schema",
-        "type": "object",
-        "required": ["initialState", "states"],
-        "properties": {
-            "initialState": { "type": "string" },
-            "states": {
-                "type": "object",
-                "patternProperties": {
-                    "^[a-zA-Z0-9_]+$": {
-                        "type": "object",
-                        "properties": {
-                            "on": { "type": "object", "patternProperties": { "^[a-zA-Z0-9_]+$": { "type": "string" } } },
-                            "actions": { "type": "array", "items": { "type": "string" } }
-                        },
-                        "required": ["on"]
-                    }
-                }
-            }
+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.`;
+    try {
+        const templatePath = path.join(getPackageRoot(), "ENDERUN.md");
+        if (fs.existsSync(templatePath)) {
+            content = fs.readFileSync(templatePath, "utf8");
         }
-    };
-    writeJsonFile(path.join(agentSchemaDir, "agent-lifecycle-schema.json"), agentLifecycleSchema, dryRun);
-
-    for (const ag of allAgents) {
-        const payload = {
-            name: ag.name,
-            displayName: ag.displayName,
-            description: ag.description,
-            role: ag.displayName.split(" (")[0],
-            capability: 9,
-            hidden: false,
-            stateMachine: { schemaRef: "../schema/agent-lifecycle-schema.json" },
-            tags: ["core"],
-            customAgentSpec: {
-                customAgent: {
-                    systemPromptSections: [{ title: "Instructions", content: ag.instructions }],
-                    toolNames: ["view_file", "replace_file_content", "write_to_file", "run_command", "grep_search", "list_dir"]
-                }
-            }
-        };
-        writeJsonFile(path.join(agentsBaseDir, `${ag.name}.json`), payload, dryRun);
+    } catch {
+        // Fallback to default content
     }
-    console.warn(`✅ Scaffolding ${allAgents.length} core agents under ${path.relative(targetDir, agentsBaseDir)}/...`);
+    content = remapFrameworkContent(content, frameworkDir, adapterId);
+    fs.writeFileSync(path.join(targetDir, "ENDERUN.md"), content);
 }
 
-function buildDirsToCreate(adapter: AdapterConfig): string[] {
-    const dirs = [
-        adapter.frameworkDir,
-        ...FRAMEWORK_SUBDIRS.map((d) => `${adapter.frameworkDir}/${d}`),
-        "apps/web", "apps/backend", "docs", "framework-mcp", "tests",
-    ];
-    if (adapter.nestedDirs) {
-        for (const nested of adapter.nestedDirs) dirs.push(`${adapter.frameworkDir}/${nested}`);
+function scaffoldCoreAgents(agentsToScaffold: string[], agentsBaseDir: string, adapterId: string, dryRun: boolean) {
+    if (dryRun) return;
+    ensureDir(agentsBaseDir, dryRun);
+    
+    for (const name of agentsToScaffold) {
+        const ag = ALL_AGENTS.find(a => a.name === name);
+        if (!ag) continue;
+
+        // AGY standard requires nested folders: agents/{name}/agent.md (or .json)
+        const isNestedAdapter = adapterId === "antigravity-cli";
+        const agentDir = isNestedAdapter ? path.join(agentsBaseDir, name) : agentsBaseDir;
+        const agentFileName = isNestedAdapter ? "agent.md" : `${ag.name}.md`;
+        
+        if (isNestedAdapter) ensureDir(agentDir, dryRun);
+
+        if (isNestedAdapter) {
+            if (!dryRun) {
+                const jsonContent = buildAgentJson(ag);
+                fs.writeFileSync(path.join(agentDir, "agent.json"), jsonContent);
+            }
+        } else {
+            const mdContent = `---
+name: "${ag.name}"
+description: "${ag.description}"
+capability: ${ag.capability}
+tags: [${ag.tags.map(t => `"${t}"`).join(", ")}]
+---
+
+# 🎖️ ${FRAMEWORK_NAME} — @${ag.name} (${ag.displayName})
+
+## 🤖 Talimatlar (Instructions)
+${ag.instructions}
+
+## 🛡️ Çekirdek Kurallar (Core Mandates)
+- **Traceability:** Her eylem aktif Trace ID'yi miras almalıdır.
+- **Surgical Precision:** Sadece \`replace_text\` veya \`patch_file\` kullanarak dosya düzenleyin.
+`;
+            if (!dryRun) {
+                fs.writeFileSync(path.join(agentDir, agentFileName), mdContent);
+            }
+        }
     }
-    if (adapter.shimFile.includes("/")) dirs.push(path.dirname(adapter.shimFile));
-    return [...new Set(dirs)];
 }
 
-export async function initCommand(adapterInput?: string, dryRun = false) {
-    const adapter = resolveAdapter(adapterInput);
-    const { frameworkDir, shimFile, templateDir } = adapter;
-    const targetFrameworkDir = path.join(targetDir, frameworkDir);
-
-    if (dryRun) console.warn("\n🔍 DRY RUN MODE ACTIVE\n");
-    console.warn(`🚀 Installing Agent Enderun (Adapter: ${adapter.id} → ${frameworkDir}/)...`);
-
-    ensureDir(targetFrameworkDir, dryRun);
-    for (const dir of buildDirsToCreate(adapter)) ensureDir(path.join(targetDir, dir), dryRun);
-
-    const filesToProcess = [...CORE_FILES, shimFile].filter(f => CORE_FILES.includes(f) || f === shimFile || fs.existsSync(path.join(sourceDir, f)));
-
-    ensureDir(path.join(targetDir, "apps/backend"), dryRun);
-    const initContractPath = path.join(targetDir, "apps/backend/contract.version.json");
-    if (!fs.existsSync(initContractPath)) {
-        writeJsonFile(initContractPath, { contract_hash: "initial_hash_placeholder", last_updated: new Date().toISOString() }, dryRun);
+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`;
+        fs.writeFileSync(path.join(skillsBaseDir, `${key.toLowerCase()}.md`), mdContent);
     }
+}
 
-    let targetPkg: Record<string, unknown> = {};
-    try {
-        const targetPkgPath = path.join(targetDir, "package.json");
-        if (fs.existsSync(targetPkgPath)) targetPkg = JSON.parse(fs.readFileSync(targetPkgPath, "utf8"));
-    } catch { /* ignore */ }
-
-    const pkgName = typeof targetPkg.name === "string" ? targetPkg.name : "";
-    const targetScope = pkgName ? (pkgName.startsWith("@") ? pkgName.split("/")[0] : `@${pkgName}`) : `@${path.basename(targetDir)}`;
-
-    for (const item of filesToProcess) {
-        const src = path.join(sourceDir, item);
-        let dest = path.join(targetDir, item);
-        const isDevMode = src === dest;
-
-        if (item === "framework-mcp" && fs.existsSync(dest) && !isDevMode) {
-            if (!dryRun) fs.rmSync(dest, { recursive: true, force: true });
+function scaffoldFrameworkConfigs(targetDir: string, fDir: string, adapter: AdapterConfig, dryRun: boolean, selectedPalette: string) {
+    if (dryRun) return;
+    const frameworkDir = path.join(targetDir, fDir);
+    const palette = COLOR_PALETTES[selectedPalette as keyof typeof COLOR_PALETTES] || COLOR_PALETTES["Modern Blue"];
+
+    const config = {
+        name: FRAMEWORK_NAME,
+        version: FRAMEWORK_VERSION,
+        theme: {
+            palette: selectedPalette,
+            colors: palette
         }
-
-        if (item === templateDir || item.startsWith(`${templateDir}/`)) {
-            let relativePath = item.replace(templateDir, "").replace(/^\//, "");
-            if (relativePath.startsWith("agents")) {
-                if (adapter.id === "antigravity") relativePath = relativePath.replace("agents", "skills");
-                else if (adapter.id === "grok") relativePath = relativePath.replace("agents", "plugins");
-            } else if (relativePath.startsWith("knowledge") && adapter.id === "antigravity") {
-                relativePath = relativePath.replace("knowledge", "rules");
-            }
-            dest = path.join(targetDir, frameworkDir, relativePath);
+    };
+    writeJsonFile(path.join(frameworkDir, "config.json"), config, dryRun);
+    fs.writeFileSync(path.join(frameworkDir, "STATUS.md"), "# 🎖️ Status\n\nStable.\n");
+    
+    // Scaffold cli-commands.json
+    const cliCommands = {
+        commands: {
+            init: { agent: "manager", description: "Initialize Enderun Core structure and AI configuration." },
+            check: { agent: "quality", description: "Verify framework files and code quality discipline." },
+            status: { agent: "manager", description: "Show the current status of the active project phase." },
+            "trace:new": { agent: "manager", description: "Generate a new Trace ID to start a task sequence." },
+            orchestrate: { agent: "manager", description: "Execute the Hermes message broker loop." },
+            "verify-contract": { agent: "architect", description: "Validate type contracts between backend and frontend." },
+            "update-contract": { agent: "architect", description: "Update the contract signature hash." }
         }
+    };
+    writeJsonFile(path.join(frameworkDir, "cli-commands.json"), cliCommands, dryRun);
 
-        if (isDevMode && !isAdapterShimFile(item) && item !== "package.json") continue;
-        if (item === "ENDERUN.md") dest = path.join(targetFrameworkDir, "ENDERUN.md");
-        if (isAdapterShimFile(item)) dest = path.join(targetDir, item);
-
-        if (!fs.existsSync(src)) continue;
-
-        if (fs.lstatSync(src).isDirectory()) {
-            const skipFiles = item === templateDir ? ["logs", "PROJECT_MEMORY.md", "PROJECT_MEMORY.lock"] : [];
-            copyDir(src, dest, new Set(skipFiles), ["docs", templateDir].includes(item), frameworkDir, targetScope, sanitizeJson, adapter.id, dryRun);
-        } else {
-            if (item === "package.json") continue;
-            if (fs.existsSync(dest) && !isAdapterShimFile(item)) continue;
+    // 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");
 
-            const ext = path.extname(item);
-            if ([".md", ".json", ".js", ".ts", ".txt", ""].includes(ext)) {
-                let content = fs.readFileSync(src, "utf8");
-                content = remapFrameworkContent(content, frameworkDir, adapter.id);
-                if (ext === ".json") {
-                    try {
-                        const json = JSON.parse(content);
-                        content = JSON.stringify(sanitizeJson(json, targetScope), null, 2);
-                        content = remapFrameworkContent(content, frameworkDir, adapter.id);
-                    } catch { content = content.replace(/workspace:[^"'\s]*/g, "*"); }
-                }
-                writeTextFile(dest, content, dryRun);
-            } else if (!dryRun) {
-                fs.copyFileSync(src, dest);
-            }
-        }
+    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`);
     }
+}
 
-    if (!dryRun) mergePackageJson(path.join(targetDir, "package.json"), path.join(sourceDir, "package.json"));
-    updateGitIgnore(path.join(targetDir, ".gitignore"), frameworkDir, dryRun);
-    initializeMemory(path.join(targetFrameworkDir, "memory/PROJECT_MEMORY.md"), frameworkDir, dryRun);
-    if (!dryRun) deepCleanProtocols(targetDir, targetScope);
-
-    // Scaffold core agents under the central framework directory
-    let agentFolder = "agents";
-    if (frameworkDir !== ".enderun") {
-        if (adapter.id === "antigravity") {
-            agentFolder = "skills";
-        } else if (adapter.id === "grok") {
-            agentFolder = "plugins";
-        }
-    }
-    scaffoldCoreAgents(path.join(targetFrameworkDir, agentFolder), dryRun);
+export async function initCommand(adapterInput?: string, dryRun = false, isInteractive = false) {
+    const selections = isInteractive ? await runInteractiveInit() : { selectedDirs: FRAMEWORK_SUBDIRS, selectedAgents: ALL_AGENTS.map(a => a.name), selectedPalette: "Modern Blue" };
+    const targetDir = process.cwd();
+    const adapter = resolveAdapter(adapterInput);
+    const frameworkDirs = [adapter.frameworkDir];
 
-    if (!fs.existsSync(path.join(targetDir, ".git")) && !dryRun) {
-        try { execSync("git init", { cwd: targetDir, stdio: "ignore" }); } catch { /* ignore */ }
-    }
+    for (const fdir of [...new Set(frameworkDirs)]) {
+        const base = path.join(targetDir, fdir);
+        ensureDir(base, dryRun);
 
-    console.warn(`\n🛠️  Running ${adapter.id} adapter configuration...`);
-    if (!dryRun) runAdapterPostInit(adapter, targetDir);
+        for (const sub of selections.selectedDirs) ensureDir(path.join(base, sub), dryRun);
+        
+        scaffoldCoreAgents(selections.selectedAgents, path.join(base, "agents"), adapter.id, dryRun);
+        scaffoldSkills(path.join(base, "skills"), dryRun);
+        scaffoldFrameworkConfigs(targetDir, fdir, adapter, dryRun, selections.selectedPalette);
 
-    console.warn(`\n✨ Framework scaffolded! (v${FRAMEWORK_VERSION})`);
-    if (!dryRun && process.env.ENDERUN_SKIP_INSTALL !== "1") {
-        try {
-            console.warn("\n🔍 Running health check...");
-            checkCommand();
-            const validatorPath = getValidatorPath();
-            execSync(`node "${validatorPath}"`, { stdio: "inherit" });
-        } catch { /* ignore validation report */ }
+        // NATIVE TOOL CONFIGURATION (MCP REGISTRATION)
+        if (!dryRun) {
+            runAdapterPostInit(adapter, targetDir);
+        }
     }
+    
+    scaffoldConstitution(targetDir, adapter.frameworkDir, adapter.id, dryRun);
+    ensureDir(path.join(targetDir, "apps"), dryRun);
+    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 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);
+    console.warn(`\n✨ ${FRAMEWORK_NAME} scaffolded! (v${FRAMEWORK_VERSION})`);
 }

package/src/cli/commands/log.ts

@@ -6,7 +6,7 @@ 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; status?: string; summary?: string; files?: string[]; details?: Record<string, unknown> }) {
+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");
     if (!fs.existsSync(logsDir)) {

package/src/cli/commands/memory.ts

@@ -1,83 +1,6 @@
-import fs from "fs";
-import path from "path";
-
-import { getMemoryPath, acquireMemoryLock, releaseMemoryLock } from "../utils/memory.js";
+import { updateProjectMemory } from "../utils/memory.js";
 
 export function updateProjectMemoryCommand(section: string, content: string) {
-    const memoryPath = getMemoryPath();
-    console.log("DEBUG: updateProjectMemoryCommand - memoryPath:", memoryPath);
-    console.log("DEBUG: updateProjectMemoryCommand - section:", section);
-    console.log("DEBUG: updateProjectMemoryCommand - content (first 100 chars):", content.substring(0, 100));
-
-    if (!fs.existsSync(memoryPath)) {
-        console.error("❌ Error: PROJECT_MEMORY.md not found.");
-        return;
-    }
-
-    const lockPath = `${memoryPath}.lock`;
-    if (!acquireMemoryLock(lockPath)) {
-        console.error("❌ Error: Memory lock timeout.");
-        return;
-    }
-
-    try {
-        let memoryContent = fs.readFileSync(memoryPath, "utf8");
-        console.log("DEBUG: updateProjectMemoryCommand - original memoryContent (first 100 chars):", memoryContent.substring(0, 100));
-
-        if (section === "HISTORY") {
-            const headers = ["## HISTORY (Persistent Memory)", "## HISTORY"];
-            let sectionIndex = -1;
-            for (const h of headers) {
-                sectionIndex = memoryContent.indexOf(h);
-                if (sectionIndex !== -1) {
-                    break;
-                }
-            }
-
-            if (sectionIndex === -1) {
-                console.error("❌ Error: HISTORY section not found.");
-                return;
-            }
-            const headerEnd = memoryContent.indexOf("\n", sectionIndex) + 1;
-            memoryContent =
-                memoryContent.slice(0, headerEnd) +
-                `\n${content.trim()}\n` +
-                memoryContent.slice(headerEnd);
-
-            // --- Auto-Prune Logic ---
-            const historySplit = memoryContent.split("### ");
-            if (historySplit.length > 11) { // Title + 10 entries
-                const frameworkDir = path.dirname(memoryPath);
-                const archiveDir = path.join(frameworkDir, "archive/history");
-                if (!fs.existsSync(archiveDir)) fs.mkdirSync(archiveDir, { recursive: true });
-
-                const toArchive = historySplit.slice(11); // Keep the first 10 entries (newest)
-                const preserved = historySplit.slice(0, 11);
-                
-                const archiveContent = "### " + toArchive.join("### ");
-                const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-                fs.writeFileSync(path.join(archiveDir, `history-${timestamp}.md`), archiveContent);
-                
-                memoryContent = preserved.join("### ").trim() + "\n";
-                console.warn(`📦 Auto-Pruned: ${toArchive.length} old entries moved to archive.`);
-            }
-            // ------------------------
-        } else {
-            const escaped = section.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-            const sectionRegex = new RegExp(`## ${escaped}[\\s\\S]*?(?=\\n## |$)`, "m");
-            if (!sectionRegex.test(memoryContent)) {
-                console.error(`❌ Error: Section not found: ${section}`);
-                return;
-            }
-            memoryContent = memoryContent.replace(
-                sectionRegex,
-                `## ${section}\n\n${content.trim()}\n`,
-            );
-        }
-
-        fs.writeFileSync(memoryPath, memoryContent);
-        console.warn(`✅ Section ${section} updated in PROJECT_MEMORY.md`);
-    } finally {
-        releaseMemoryLock(lockPath);
-    }
+    updateProjectMemory(section, content);
 }
+