agent-enderun 1.1.2 → 1.1.4

package/src/cli/utils/memory.ts

@@ -1,82 +1,77 @@
 import fs from "fs";
+import os from "os";
 import path from "path";
 import { sleep } from "./time.js";
 import { generateULID } from "./time.js";
 import { FRAMEWORK_DIR_CANDIDATES } from "../adapters.js";
+import { EnderunConfigSchema } from "./config-schema.js";
 
-const targetDir = process.cwd();
+const CWD = process.cwd();
+const HOME = os.homedir();
 
-export function getFrameworkDir(): string {
-    // 1. Check if configured in package.json to force a single, unified framework directory
+function findFrameworkDir(basePath: string): string | null {
     try {
-        const pkgPath = path.join(targetDir, "package.json");
+        const pkgPath = path.join(basePath, "package.json");
         if (fs.existsSync(pkgPath)) {
             const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
             if (pkg.enderun && typeof pkg.enderun.frameworkDir === "string") {
-                const customDir = pkg.enderun.frameworkDir;
-                if (fs.existsSync(path.join(targetDir, customDir))) {
-                    return customDir;
-                }
+                const customDir = path.join(basePath, pkg.enderun.frameworkDir);
+                if (fs.existsSync(customDir)) return customDir;
             }
         }
-    } catch {
-        // ignore: non-critical parsing errors
-    }
+    } catch { /* ignore */ }
 
-    // 2. Fall back to dynamic candidate scanning
     for (const dir of FRAMEWORK_DIR_CANDIDATES) {
-        const dirPath = path.join(targetDir, dir);
-        if (!fs.existsSync(dirPath)) continue;
+        const dirPath = path.join(basePath, dir);
+        if (fs.existsSync(dirPath) && fs.lstatSync(dirPath).isDirectory()) {
+            return dirPath;
+        }
+    }
+    return null;
+}
 
-        // Support both legacy flat memory and current memory/ subdir layout (AL/cross-adapter fix)
-        const hasMemory = fs.existsSync(path.join(dirPath, "PROJECT_MEMORY.md")) ||
-                          fs.existsSync(path.join(dirPath, "memory", "PROJECT_MEMORY.md"));
+export function getLocalFrameworkDir(): string {
+    const localDir = findFrameworkDir(CWD);
+    return localDir || path.join(CWD, ".gemini");
+}
 
-        const hasAgents = fs.existsSync(path.join(dirPath, "agents")) || 
-                           fs.existsSync(path.join(dirPath, "skills")) ||
-                           fs.existsSync(path.join(dirPath, "plugins"));
+export function getConfigDir(): string {
+    const localDir = findFrameworkDir(CWD);
+    if (localDir) return localDir;
+    const globalDir = findFrameworkDir(HOME);
+    return globalDir || path.join(HOME, ".gemini");
+}
 
-        if (hasMemory || hasAgents) {
-            return dir;
-        }
-    }
-    for (const dir of FRAMEWORK_DIR_CANDIDATES) {
-        if (fs.existsSync(path.join(targetDir, dir))) {
-            return dir;
-        }
-    }
-    return ".gemini";
+export function getFrameworkDir(): string {
+    return getConfigDir();
 }
 
 export function getMemoryPath() {
-    const frameworkDir = getFrameworkDir();
-    const subPath = path.join(targetDir, frameworkDir, "memory/PROJECT_MEMORY.md");
+    const frameworkDir = getLocalFrameworkDir();
+    const subPath = path.join(frameworkDir, "memory/PROJECT_MEMORY.md");
     if (fs.existsSync(subPath)) return subPath;
-    return path.join(targetDir, frameworkDir, "PROJECT_MEMORY.md");
+    return path.join(frameworkDir, "PROJECT_MEMORY.md");
 }
 
 export function getConfiguredPaths(): { backend: string; frontend: string; docs: string; tests: string } {
-    let backend = "apps/backend";
-    let frontend = "apps/web";
-    let docs = "docs";
-    let tests = "tests";
-    
+    const defaultPaths = { backend: "apps/backend", frontend: "apps/web", docs: "docs", tests: "tests" };
     try {
-        const frameworkDir = getFrameworkDir();
-        const configPath = path.join(targetDir, frameworkDir, "config.json");
+        const frameworkDir = getConfigDir();
+        const configPath = path.join(frameworkDir, "config.json");
         if (fs.existsSync(configPath)) {
-            const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
-            if (config.paths) {
-                if (config.paths.backend) backend = config.paths.backend;
-                if (config.paths.frontend) frontend = config.paths.frontend;
-                if (config.paths.docs) docs = config.paths.docs;
-                if (config.paths.tests) tests = config.paths.tests;
+            const rawConfig = JSON.parse(fs.readFileSync(configPath, "utf8"));
+            const result = EnderunConfigSchema.safeParse(rawConfig);
+            if (result.success) {
+                return result.data.paths;
+            } else {
+                console.error(`\n❌ Configuration Error in ${configPath}:`);
+                result.error.issues.forEach(err => console.error(`   - ${err.path.join(".")}: ${err.message}`));
             }
         }
     } catch {
-        // ignore: non-critical parsing errors
+        console.error("\n❌ Critical Error: Could not read or parse configuration file.");
     }
-    return { backend, frontend, docs, tests };
+    return defaultPaths;
 }
 
 export function acquireMemoryLock(lockPath: string, maxRetries = 5): boolean {
@@ -88,6 +83,24 @@ export function acquireMemoryLock(lockPath: string, maxRetries = 5): boolean {
         } catch (error: unknown) {
             const err = error as NodeJS.ErrnoException;
             if (err?.code !== "EEXIST") throw error;
+
+            try {
+                if (fs.existsSync(lockPath)) {
+                    const stat = fs.statSync(lockPath);
+                    const ageMs = Date.now() - stat.mtimeMs;
+                    if (ageMs > 10000) { // 10 seconds timeout for memory writes
+                        console.warn(`\n⚠️  Stale memory lock detected (${Math.round(ageMs / 1000)}s old). Breaking lock: ${lockPath}`);
+                        fs.unlinkSync(lockPath);
+                        // Retry immediately
+                        const fd = fs.openSync(lockPath, "wx");
+                        fs.closeSync(fd);
+                        return true;
+                    }
+                }
+            } catch {
+                // ignore stat or unlink failures
+            }
+
             if (attempt < maxRetries - 1) sleep(1000);
         }
     }
@@ -98,80 +111,98 @@ export function releaseMemoryLock(lockPath: string): void {
     if (fs.existsSync(lockPath)) fs.unlinkSync(lockPath);
 }
 
-/**
- * Create initial PROJECT_MEMORY.md if missing.
- */
 export function initializeMemory(memoryPath: string, targetBase: string, dryRun = false): void {
     if (fs.existsSync(memoryPath)) return;
-
     const traceId = generateULID();
     const date = new Date().toISOString().split("T")[0];
-    const template = `# PROJECT MEMORY — Agent Enderun
-
-This file is the Single Source of Truth (SSOT) and the persistent memory of the project.
-
-## CURRENT STATUS
-
-| Active Phase | Profile | Last Update | Active Trace ID | Blockers |
-| :----------- | :------ | :---------- | :-------------- | :------- |
-| PHASE_0      | Lightweight | ${date} | ${traceId} | NONE |
-
-## PROJECT DEFINITION
-
-| Field | Value |
-| :--- | :--- |
-| Project Name | ${path.basename(process.cwd())} |
-| Platform | Not defined |
-| Frontend | React 19 + Vite + Panda CSS |
-| Backend | Node.js 20+ + Fastify |
-| DB | PostgreSQL |
-
-## DOD STATUS
-
-| Phase | Status | Note |
-| :--- | :--- | :--- |
-| PHASE_0 | IN_PROGRESS | Initializing project structure |
-| PHASE_1 | PENDING | |
-| PHASE_2 | PENDING | |
-| PHASE_3 | PENDING | |
-| PHASE_4 | PENDING | |
-
-## CRITICAL DECISIONS
-
-| Date | Decision | Rationale | Agent |
-| :--- | :--- | :--- | :--- |
-| ${date} | Project Initialized | Framework setup via CLI | @manager |
+    const template = `## CURRENT STATUS\n\n- Phase: PHASE_0 (Genesis)\n- Trace ID: ${traceId}\n\n## HISTORY\n### ${date} — Initialization\n- Action: Initialized Enderun Core.\n`;
+    if (dryRun) return;
+    const parentDir = path.dirname(memoryPath);
+    if (!fs.existsSync(parentDir)) fs.mkdirSync(parentDir, { recursive: true });
+    fs.writeFileSync(memoryPath, template);
+    console.warn("✅ PROJECT_MEMORY.md initialized.");
+}
 
-## DELIVERABLES
+export function updateProjectMemory(section: string, content: string) {
+    const memoryPath = getMemoryPath();
 
-| Module | Status | Agent | Date |
-| :--- | :--- | :--- | :--- |
+    if (!fs.existsSync(memoryPath)) {
+        console.error("❌ Error: PROJECT_MEMORY.md not found.");
+        return;
+    }
 
-## ACTIVE TASKS
+    const lockPath = `${memoryPath}.lock`;
+    if (!acquireMemoryLock(lockPath)) {
+        console.error("❌ Error: Memory lock timeout.");
+        return;
+    }
 
-| Trace ID | Task | Agent | Priority | Status |
-| :--- | :--- | :--- | :--- | :--- |
-| ${traceId} | Framework setup and architecture alignment | @manager | P1 | IN_PROGRESS |
+    try {
+        let memoryContent = fs.readFileSync(memoryPath, "utf8");
+
+        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;
+                }
+            }
 
-## HISTORY (Persistent Memory)
+            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`,
+            );
+        }
 
-### ${date} — Framework Initialization
+        fs.writeFileSync(memoryPath, memoryContent);
+        console.warn(`✅ Section ${section} updated in PROJECT_MEMORY.md`);
+    } finally {
+        releaseMemoryLock(lockPath);
+    }
+}
 
-- **Agent:** @manager
-- **Trace ID:** ${traceId}
-- **Action:** Initialized Agent Enderun framework and project structure.
-`;
+export function readActiveTraceId(memoryContent: string): string | null {
+    const match = memoryContent.match(/Trace ID:\s*([A-Z0-9]+)/i) ||
+                  memoryContent.match(/Trace ID\s*\|.*\|\s*\n\|.*\|.*\|.*\|\s*([A-Z0-9]+)\s*\|/i) ||
+                  memoryContent.match(/Active Trace ID[:\s|]+([A-Z0-9]+)/i);
+    return match ? match[1] : null;
+}
 
-    const finalTemplate = template.replace(/\{\{FRAMEWORK_DIR\}\}/g, targetBase);
 
-    if (dryRun) {
-        console.warn(`[DRY RUN] Would initialize PROJECT_MEMORY.md at ${memoryPath}`);
-    } else {
-        const parentDir = path.dirname(memoryPath);
-        if (!fs.existsSync(parentDir)) {
-            fs.mkdirSync(parentDir, { recursive: true });
-        }
-        fs.writeFileSync(memoryPath, finalTemplate);
-        console.warn(`✅ PROJECT_MEMORY.md initialized in ${targetBase}`);
-    }
-}

package/src/cli/utils/pkg.ts

@@ -35,15 +35,15 @@ function findAgentEnderunPackageRoot(): string {
     let current = path.dirname(new URL(import.meta.url).pathname);
     const root = path.parse(current).root;
     while (current !== root) {
-        // Sandbox boundary guard: do not access parent paths outside the project workspace
-        if (!current.includes("agent-enderun")) {
-            break;
+        if (path.basename(current) === "dist") {
+            current = path.dirname(current);
+            continue;
         }
         const pkgPath = path.join(current, "package.json");
         if (fs.existsSync(pkgPath)) {
             try {
                 const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
-                if (pkg.name === "agent-enderun") {
+                if (pkg.name === "agent-enderun" || pkg.name === "enderun-core") {
                     return current;
                 }
             } catch {

package/src/cli/utils/ui.ts

@@ -0,0 +1,63 @@
+import chalk from "chalk";
+
+/**
+ * Professional UI Utilities for Enderun Core CLI.
+ * Standardizes headers, status boxes, and strategic intent reporting.
+ */
+
+export const UI = {
+    /**
+     * Renders a strategic intent block similar to Gemini CLI's topic updates.
+     */
+    intent: (title: string, intent: string) => {
+        console.warn(`\n${chalk.bold.cyan(title)}:`);
+        console.warn(`${chalk.italic.gray(`  ${intent}`)}\n`);
+    },
+
+    /**
+     * Renders a professional agent execution box.
+     */
+    agentBox: (agentName: string, action: string, details?: string) => {
+        const width = process.stdout.columns || 80;
+        const line = "─".repeat(width - 2);
+        
+        console.warn(chalk.gray(`╭${line}╮`));
+        console.warn(`${chalk.gray("│")} ${chalk.bold.yellow("≡")} ${chalk.white(`Running Agent: ${chalk.bold.green(agentName)}...`)} ${chalk.gray("(ctrl+o to expand)".padStart(width - agentName.length - 27))} ${chalk.gray("│")}`);
+        if (action) {
+            console.warn(`${chalk.gray("│")} ${chalk.blue("!")} ${chalk.cyan(action)} ${" ".repeat(width - action.length - 6)} ${chalk.gray("│")}`);
+        }
+        if (details) {
+            console.warn(`${chalk.gray("│")}   ${chalk.gray(details.slice(0, width - 10))} ${" ".repeat(width - details.length - 7)} ${chalk.gray("│")}`);
+        }
+        console.warn(chalk.gray(`╰${line}╯`));
+    },
+
+    /**
+     * Renders a success status message.
+     */
+    success: (msg: string) => {
+        console.warn(`${chalk.bold.green("✅")} ${msg}`);
+    },
+
+    /**
+     * Renders an error status message.
+     */
+    error: (msg: string) => {
+        console.error(`${chalk.bold.red("❌")} ${chalk.red(msg)}`);
+    },
+
+    /**
+     * Renders a warning status message.
+     */
+    warning: (msg: string) => {
+        console.warn(`${chalk.bold.yellow("⚠️")} ${chalk.yellow(msg)}`);
+    },
+
+    /**
+     * Renders an info/divider line.
+     */
+    divider: () => {
+        const width = process.stdout.columns || 80;
+        console.warn(chalk.gray("─".repeat(width)));
+    }
+};

package/src/modules/adapters/antigravity-cli.ts

@@ -0,0 +1,25 @@
+import path from "path";
+import { writeJsonFile } from "../../shared/fs.js";
+import type { AdapterConfig } from "./types.js";
+import { registerGlobalAntigravityPlugins } from "./shared.js";
+
+export const config: AdapterConfig = {
+    id: "antigravity-cli",
+    frameworkDir: ".agents",
+    shimFile: "AGENTS.md",
+    shimTemplate: "src/cli/shims/antigravity-cli.md",
+    role: "general",
+    templateDir: ".enderun",
+    nestedDirs: ["agents", "rules", "knowledge"],
+    rulesDir: ".agents/rules",
+    rulesExt: ".md"
+};
+
+export function postInit(projectRoot: string, mcpBlock: unknown): void {
+    writeJsonFile(path.join(projectRoot, config.frameworkDir, "mcp_config.json"), mcpBlock);
+    console.warn(`✅ Antigravity CLI MCP → ${config.frameworkDir}/mcp_config.json`);
+
+    // Global registration
+    registerGlobalAntigravityPlugins(mcpBlock);
+}
+

package/src/modules/adapters/claude.ts

@@ -0,0 +1,36 @@
+import path from "path";
+import { writeJsonFile } from "../../shared/fs.js";
+import { findClaudeConfigPath, addMcpServerToClaude } from "../../cli/utils/claude.js";
+import type { AdapterConfig } from "./types.js";
+
+export const config: AdapterConfig = {
+    id: "claude",
+    frameworkDir: ".claude",
+    shimFile: "CLAUDE.md",
+    shimTemplate: "src/cli/shims/claude.md",
+    role: "architect",
+    templateDir: ".enderun",
+    nestedDirs: ["agents", "rules", "knowledge"],
+    rulesDir: ".claude/rules",
+    rulesExt: ".md"
+};
+
+export function postInit(projectRoot: string, mcpBlock: unknown): void {
+    const configPath = findClaudeConfigPath();
+    if (configPath) {
+        const block = mcpBlock as { mcpServers: Record<string, unknown> };
+        // Build mcpEntry matching what adapters.ts does
+        const mcpEntry = block.mcpServers["agent-enderun"] as Record<string, unknown>;
+        const ok = addMcpServerToClaude(configPath, "agent-enderun", mcpEntry);
+        if (ok) {
+            console.warn(`✅ Claude MCP registered → ${configPath}`);
+        } else {
+            console.warn("⚠️  Could not patch Claude config automatically.");
+        }
+    } else {
+        console.warn("⚠️  Claude config not found. Add MCP manually (see README).");
+    }
+    writeJsonFile(path.join(projectRoot, config.frameworkDir, "mcp_config.json"), mcpBlock);
+    writeJsonFile(path.join(projectRoot, ".mcp.json"), mcpBlock);
+    console.warn("✅ Claude Code Project MCP → .mcp.json");
+}

package/src/modules/adapters/codex.ts

@@ -0,0 +1,22 @@
+import path from "path";
+import { writeJsonFile } from "../../shared/fs.js";
+import type { AdapterConfig } from "./types.js";
+
+export const config: AdapterConfig = {
+    id: "codex",
+    frameworkDir: ".github",
+    shimFile: "copilot-instructions.md",
+    shimTemplate: "src/cli/shims/codex.md",
+    role: "implementer",
+    templateDir: ".enderun",
+    nestedDirs: ["agents", "rules", "knowledge", "instructions"],
+    rulesDir: ".github/instructions",
+    rulesExt: ".md"
+};
+
+export function postInit(projectRoot: string, mcpBlock: unknown): void {
+    writeJsonFile(path.join(projectRoot, config.frameworkDir, "mcp_config.json"), mcpBlock);
+    writeJsonFile(path.join(projectRoot, ".vscode/mcp.json"), mcpBlock);
+    writeJsonFile(path.join(projectRoot, ".mcp.json"), mcpBlock);
+    console.warn("✅ GitHub Copilot Project MCP → .vscode/mcp.json & .mcp.json");
+}

package/src/modules/adapters/cursor.ts

@@ -0,0 +1,22 @@
+import path from "path";
+import { writeJsonFile } from "../../shared/fs.js";
+import type { AdapterConfig } from "./types.js";
+
+export const config: AdapterConfig = {
+    id: "cursor",
+    frameworkDir: ".cursor",
+    shimFile: "CURSOR.md",
+    shimTemplate: "src/cli/shims/cursor.mdc",
+    role: "implementer",
+    templateDir: ".enderun",
+    nestedDirs: ["agents", "rules", "knowledge"],
+    rulesDir: ".cursor/rules",
+    rulesExt: ".mdc"
+};
+
+export function postInit(projectRoot: string, mcpBlock: unknown): void {
+    const frameworkDir = config.frameworkDir;
+    // Native Cursor project-level MCP config
+    writeJsonFile(path.join(projectRoot, frameworkDir, "mcp.json"), mcpBlock);
+    console.warn(`✅ Cursor IDE Project MCP → ${frameworkDir}/mcp.json`);
+}

package/src/modules/adapters/gemini.ts

@@ -0,0 +1,27 @@
+import path from "path";
+import { writeJsonFile } from "../../shared/fs.js";
+import type { AdapterConfig } from "./types.js";
+import { registerGlobalAntigravityPlugins } from "./shared.js";
+
+export const config: AdapterConfig = {
+    id: "gemini",
+    frameworkDir: ".gemini",
+    shimFile: "GEMINI.md",
+    shimTemplate: "src/cli/shims/gemini.md",
+    role: "commander",
+    templateDir: ".enderun",
+    nestedDirs: ["agents", "rules", "knowledge"],
+    rulesDir: ".gemini/rules",
+    rulesExt: ".md"
+};
+
+export function postInit(projectRoot: string, mcpBlock: unknown): void {
+    const frameworkDir = config.frameworkDir;
+    // Standard project-level MCP config
+    writeJsonFile(path.join(projectRoot, frameworkDir, "mcp.json"), mcpBlock);
+    console.warn(`✅ Gemini MCP registered → ${frameworkDir}/mcp.json`);
+
+    // Global registration
+    registerGlobalAntigravityPlugins(mcpBlock);
+}
+

package/src/modules/adapters/grok.ts

@@ -0,0 +1,20 @@
+import path from "path";
+import { writeJsonFile } from "../../shared/fs.js";
+import type { AdapterConfig } from "./types.js";
+
+export const config: AdapterConfig = {
+    id: "grok",
+    frameworkDir: ".grok",
+    shimFile: "GROK.md",
+    shimTemplate: "src/cli/shims/grok.md",
+    role: "researcher",
+    templateDir: ".enderun",
+    nestedDirs: ["agents", "rules", "knowledge"],
+    rulesDir: ".grok/rules",
+    rulesExt: ".md"
+};
+
+export function postInit(projectRoot: string, mcpBlock: unknown): void {
+    writeJsonFile(path.join(projectRoot, config.frameworkDir, "mcp_config.json"), mcpBlock);
+    console.warn(`✅ Grok MCP → ${config.frameworkDir}/mcp_config.json`);
+}

package/src/modules/adapters/shared.ts

@@ -0,0 +1,90 @@
+import path from "path";
+import fs from "fs";
+import os from "os";
+import { writeJsonFile } from "../../shared/fs.js";
+import { ALL_AGENTS, buildAgentJson } from "../agents/definitions.js";
+import { CORE_SKILLS } from "../skills/definitions.js";
+
+export function registerGlobalAntigravityPlugins(mcpBlock: unknown): void {
+    const targets = [
+        path.join(os.homedir(), ".gemini/antigravity-cli")
+    ];
+
+    for (const globalDir of targets) {
+        try {
+            // Write directly under directory
+            fs.mkdirSync(globalDir, { recursive: true });
+            writeJsonFile(path.join(globalDir, "mcp.json"), mcpBlock);
+            writeJsonFile(path.join(globalDir, "mcp_config.json"), mcpBlock);
+            console.warn(`✅ Antigravity MCP registered → ${globalDir}/`);
+
+            // Global Plugin configuration under plugins/agent-enderun/
+            const globalPluginDir = path.join(globalDir, "plugins/agent-enderun");
+            fs.mkdirSync(globalPluginDir, { recursive: true });
+
+            // plugin.json marker
+            writeJsonFile(path.join(globalPluginDir, "plugin.json"), {
+                name: "agent-enderun",
+                version: "1.0.0",
+                description: "Agent Enderun AI Orchestration framework"
+            });
+
+            // MCP Server configs inside the plugin
+            writeJsonFile(path.join(globalPluginDir, "mcp.json"), mcpBlock);
+            writeJsonFile(path.join(globalPluginDir, "mcp_config.json"), mcpBlock);
+
+            // Scaffold 13 agents
+            const agentsBaseDir = path.join(globalPluginDir, "agents");
+            fs.mkdirSync(agentsBaseDir, { recursive: true });
+            for (const ag of ALL_AGENTS) {
+                const agentJson = buildAgentJson(ag);
+
+                // 1. Nested format (agents/{agent_name}/agent.json)
+                const nestedAgentDir = path.join(agentsBaseDir, ag.name);
+                fs.mkdirSync(nestedAgentDir, { recursive: true });
+                fs.writeFileSync(path.join(nestedAgentDir, "agent.json"), agentJson);
+
+                // 2. Direct flat format (agents/{agent_name}.json) as subagent definition templates
+                fs.writeFileSync(path.join(agentsBaseDir, `${ag.name}.json`), agentJson);
+            }
+
+            // Scaffold skills
+            const skillsDir = path.join(globalPluginDir, "skills");
+            fs.mkdirSync(skillsDir, { recursive: true });
+            for (const [key, skill] of Object.entries(CORE_SKILLS)) {
+                const skillContent = `# 🛠️ Skill — ${skill.name}\n\n${skill.mandates.join("\n")}\n`;
+                fs.writeFileSync(path.join(skillsDir, `${key.toLowerCase()}.md`), skillContent);
+            }
+
+            // Scaffold rules (Optional custom codebase rules files)
+            const rulesDir = path.join(globalPluginDir, "rules");
+            fs.mkdirSync(rulesDir, { recursive: true });
+            for (const ag of ALL_AGENTS) {
+                const ruleContent = `# 🎖️ Agent Enderun — @${ag.name} (${ag.displayName})
+
+You are the **${ag.displayName}** of the Agent Enderun Army.
+
+## 🤖 Specialist Directive (Role: @${ag.name})
+${ag.instructions}
+
+## 🛡️ Core Mandates
+- **Surgical Precision:** Enforce replace_text / replace_file_content for all code modifications.
+- **Traceability:** Inherit and pass the active Trace ID across all delegations.
+- **Approval Signature:** High-risk actions require manager approval signature.
+`;
+                fs.writeFileSync(path.join(rulesDir, `${ag.name}.md`), ruleContent);
+            }
+
+            // Scaffold optional empty hooks.json
+            writeJsonFile(path.join(globalPluginDir, "hooks.json"), {
+                preTool: [],
+                postTool: []
+            });
+
+            console.warn(`✅ Antigravity Plugin registered → ${globalPluginDir}/`);
+
+        } catch (e) {
+            console.warn(`⚠️ Failed to register plugin/MCP in ${globalDir}:`, e);
+        }
+    }
+}

package/src/modules/adapters/types.ts

@@ -0,0 +1,16 @@
+export const ADAPTER_IDS = ["gemini", "claude", "grok", "cursor", "codex", "antigravity-cli"] as const;
+export type AdapterId = (typeof ADAPTER_IDS)[number];
+
+export type AdapterRole = "commander" | "architect" | "researcher" | "implementer" | "general";
+
+export interface AdapterConfig {
+  id: AdapterId;
+  frameworkDir: string;
+  shimFile: string;
+  shimTemplate: string;
+  role: AdapterRole;
+  templateDir: ".enderun";
+  nestedDirs?: string[];
+  rulesDir?: string; // Directory to write individual rules, relative to projectRoot
+  rulesExt?: string; // Extensions for rules files (.md or .mdc)
+}