agent-enderun 1.1.1 → 1.1.3

package/src/cli/commands/orchestrate.ts

@@ -1,15 +1,21 @@
 import fs from "fs";
 import path from "path";
+import chalk from "chalk";
 import { getFrameworkDir } from "../utils/memory.js";
+import { UI } from "../utils/ui.js";
 
+/**
+ * Hermes Protocol Message for Multi-Agent Collaboration.
+ */
 interface HermesMessage {
   timestamp: string;
   from: string;
   to: string;
-  category: string;
+  category: "ACTION" | "DELEGATION" | "SUBTASK" | "REPLY" | "ALERT";
   content: string;
   traceId: string;
-  status: "PENDING" | "PROCESSED";
+  parentId?: string; // Links sub-tasks to parent tasks
+  status: "PENDING" | "PROCESSED" | "WAITING";
 }
 
 export async function orchestrateCommand() {
@@ -17,166 +23,146 @@ export async function orchestrateCommand() {
     const messagesDir = path.join(process.cwd(), frameworkDir, "messages");
 
     if (!fs.existsSync(messagesDir)) {
-        console.log("ℹ️ Henüz işlenecek bir mesaj yok (.messages dizini bulunamadı).");
+        UI.success("Henüz işlenecek bir mesaj yok.");
         return;
     }
 
     const messageFiles = fs.readdirSync(messagesDir).filter((f) => f.endsWith(".json"));
     const pendingMessages: HermesMessage[] = [];
+    const fileMessagesMap: Record<string, HermesMessage[]> = {};
 
     for (const file of messageFiles) {
         const filePath = path.join(messagesDir, file);
         try {
             const content = fs.readFileSync(filePath, "utf8").trim();
             if (!content) continue;
-            // Messages are stored as newline-delimited JSON
             const lines = content.split("\n");
+            const allMsgs: HermesMessage[] = [];
             lines.forEach((line) => {
                 if (!line.trim()) return;
                 const msg = JSON.parse(line) as HermesMessage;
                 if (msg.status === "PENDING") {
                     pendingMessages.push(msg);
                 }
+                allMsgs.push(msg);
             });
+            fileMessagesMap[file] = allMsgs;
         } catch {
-            console.error(`❌ ${file} mesajı okunurken hata oluştu.`);
+            UI.error(`${file} mesajı okunurken hata oluştu.`);
         }
     }
 
     if (pendingMessages.length === 0) {
-        console.log("✅ Tüm mesajlar işlenmiş, bekleyen görev yok.");
+        UI.success("Tüm mesajlar işlenmiş, bekleyen görev yok.");
         return;
     }
 
-    console.log(`📡 ${pendingMessages.length} adet bekleyen görev bulundu. İşleniyor...\n`);
+    UI.intent("Multi-Agent Orkestrasyonu", `${pendingMessages.length} adet bekleyen görev ve işbirliği mesajı bulundu.`);
 
     for (const msg of pendingMessages) {
-        const { to, content, traceId, category } = msg;
-
-        console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
-        console.log(`🔹 HEDEF: ${to}`);
-        console.log(`🔹 TRACE: ${traceId}`);
-        console.log(`🔹 KATEGORİ: ${category}`);
-        console.log(`🔹 GÖREV: ${content}`);
-
-        // Determine agent folder based on adapter (detection or default)
-        let agentFolder = "agents";
-        if (frameworkDir === ".agents") {
-            agentFolder = "skills";
-        } else if (frameworkDir === ".grok") {
-            agentFolder = "plugins";
-        }
+        const { from, to, content, traceId, category, parentId } = msg;
+
+        // Visual distinction for Sub-tasks
+        const isSubtask = category === "SUBTASK" || !!parentId;
+        const agentLabel = isSubtask ? `${to} (Sub-Agent)` : to;
+
+        UI.agentBox(agentLabel, content, `Trace: ${traceId} | From: ${from} | Category: ${category}`);
 
-        // Determine target state based on category
         let targetState = "EXECUTING";
-        if (category === "DELEGATION") targetState = "BRIEFED";
-        if (category === "ALERT" || category === "FAILED") targetState = "BLOCKED";
+        if (category === "DELEGATION" || category === "SUBTASK") targetState = "BRIEFED";
 
-        // 1. Transition the target agent state in STATUS.md
         transitionAgentState(to, targetState, content);
 
         if (targetState === "BRIEFED") {
-            console.log(`\n📝 ${to} agent'ı bilgilendirildi (BRIEFED). Hazırlık bekleniyor...`);
-            // Auto-transition to EXECUTING for CLI flow if no blockers
+            UI.success(`${to} bilgilendirildi ve görevi devraldı.`);
             transitionAgentState(to, "EXECUTING", content);
         }
 
-        console.log("\n🤖 Görev Devredildi!");
-        console.log(`👉 Lütfen ${to} agent talimatlarını (${frameworkDir}/${agentFolder}/${to.replace("@", "")}.md) okuyun ve görevi yerine getirin.`);
-        console.log("\n💡 İpucu: İş bittiğinde, mesajı PROCESSED olarak işaretlemek ve ajanı boşa çıkarmak için:");
-        console.log("   npx agent-enderun status komutuyla kontrol edin.");
+        if (isSubtask) {
+            UI.success(`Alt görev bağlantısı kuruldu (Parent: ${parentId || "Unknown"}).`);
+        }
+
+        UI.success(`İşbirliği başlatıldı: ${from} -> ${to}`);
+        console.warn(chalk.gray(`  👉 Talimatlar: ${frameworkDir}/agents/${to.replace("@", "")}.md`));
+
+        // Mark message as processed
+        msg.status = "PROCESSED";
+    }
+
+    // Write back updated message statuses to files
+    for (const file of Object.keys(fileMessagesMap)) {
+        const filePath = path.join(messagesDir, file);
+        const msgs = fileMessagesMap[file];
+        try {
+            const updatedContent = msgs.map(m => JSON.stringify(m)).join("\n") + "\n";
+            fs.writeFileSync(filePath, updatedContent, "utf8");
+        } catch {
+            UI.error(`${file} mesaj dosyası güncellenirken hata oluştu.`);
+        }
     }
 }
 
-export function sendMessage(args: {
-  from: string;
-  to: string;
-  category: string;
-  content: string;
-  traceId: string;
+/**
+ * Standard tool for agents to delegate tasks to other agents.
+ */
+export function sendMessage(args: { 
+    from: string; 
+    to: string; 
+    category: "ACTION" | "DELEGATION" | "SUBTASK" | "REPLY" | "ALERT"; 
+    content: string; 
+    traceId: string;
+    parentId?: string;
 }) {
     const frameworkDir = getFrameworkDir();
     const messagesDir = path.join(process.cwd(), frameworkDir, "messages");
     const agentName = args.to.replace("@", "");
     const messagePath = path.join(messagesDir, `${agentName}.json`);
-    const lockPath = path.join(messagesDir, ".lock");
-
-    // Hermes Lock Protocol: Retry 3 times with 500ms delay
-    let retries = 3;
-    while (retries > 0 && fs.existsSync(lockPath)) {
-        const stats = fs.statSync(lockPath);
-        // Stale lock check (older than 5 seconds)
-        if (Date.now() - stats.mtimeMs > 5000) {
-            fs.unlinkSync(lockPath);
-            break;
-        }
-        retries--;
-        if (retries > 0) {
-            // Synchronous sleep for CLI simplicity
-            const g = global as unknown as { Atomics: { wait: (ia: Int32Array, index: number, value: number, timeout: number) => string }; SharedArrayBuffer: { new (size: number): ArrayBufferLike } };
-            if (g.Atomics && g.SharedArrayBuffer) {
-                g.Atomics.wait(new Int32Array(new g.SharedArrayBuffer(4)), 0, 0, 500);
-            }
-        }
-    }
 
     try {
-        fs.mkdirSync(messagesDir, { recursive: true });
-        fs.writeFileSync(lockPath, `Locked by ${args.from} at ${new Date().toISOString()}`);
+        if (!fs.existsSync(messagesDir)) fs.mkdirSync(messagesDir, { recursive: true });
         
-        const message = {
+        const message: HermesMessage = {
             timestamp: new Date().toISOString(),
-            from: args.from,
-            to: args.to,
-            category: args.category,
-            traceId: args.traceId,
-            content: args.content,
+            ...args,
             status: "PENDING"
         };
-
+        
         fs.appendFileSync(messagePath, JSON.stringify(message) + "\n");
+        
+        // Log collaboration to audit log
+        const auditPath = path.join(process.cwd(), frameworkDir, "observability/audit_log.md");
+        if (fs.existsSync(auditPath)) {
+            const logEntry = `\n- **[${message.timestamp}]** ${args.from} -> ${args.to} | ${args.category} | Trace: ${args.traceId}`;
+            fs.appendFileSync(auditPath, logEntry);
+        }
+        
         return message;
-    } finally {
-        if (fs.existsSync(lockPath)) fs.unlinkSync(lockPath);
+    } catch {
+        UI.error(`Mesaj iletilemedi: ${args.from} -> ${args.to}`);
     }
 }
 
 function transitionAgentState(agent: string, state: string, task: string) {
     const frameworkDir = getFrameworkDir();
     const statusPath = path.join(process.cwd(), frameworkDir, "STATUS.md");
-
     if (!fs.existsSync(statusPath)) return;
-
     try {
         const content = fs.readFileSync(statusPath, "utf8");
         const lines = content.split("\n");
         const targetName = agent.startsWith("@") ? agent : `@${agent}`;
-
-        const newLines: string[] = [];
-        let found = false;
-
-        lines.forEach((line) => {
+        const newLines = lines.map(line => {
             if (line.includes(`| ${targetName} |`)) {
-                found = true;
-                // Example: | @backend | IDLE | — | — | 9.2/10 | — |
                 const parts = line.split("|");
                 if (parts.length >= 7) {
                     parts[2] = ` ${state} `;
-                    parts[3] = ` ${task.slice(0, 20)}... `;
-                    newLines.push(parts.join("|"));
-                } else {
-                    newLines.push(line);
+                    parts[3] = ` ${task.slice(0, 25)}... `;
+                    return parts.join("|");
                 }
-            } else {
-                newLines.push(line);
             }
+            return line;
         });
-
-        if (found) {
-            fs.writeFileSync(statusPath, newLines.join("\n"));
-            console.log(`✅ STATUS.md üzerinde ${agent} durumu başarıyla '${state}' yapıldı.`);
-        }
+        fs.writeFileSync(statusPath, newLines.join("\n"));
     } catch {
-        console.error("❌ STATUS.md güncellenirken hata oluştu.");
+        UI.error("STATUS.md güncellenemedi.");
     }
 }

package/src/cli/index.ts

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
-
+import fs from "fs";
 import { getPackageVersion, getValidatorPath } from "./utils/pkg.js";
+import { getMemoryPath, readActiveTraceId } from "./utils/memory.js";
 import { initCommand } from "./commands/init.js";
 import { checkCommand } from "./commands/check.js";
 import { statusCommand } from "./commands/status.js";
@@ -19,8 +20,10 @@ async function main() {
 
     const KNOWN_COMMANDS = [
         "init", "check", "status", "trace:new", "update_project_memory", 
-        "create-app", "orchestrate", "verify-contract", "update-contract", 
-        "validate", "validate-army", "check:al", "version", "-v", "--version", "help", "-h", "--help"
+        "create-app", "orchestrate", "loop", "verify-contract", "update-contract", 
+        "validate", "validate-army", "check:al", "version", "-v", "--version", "help", "-h", "--help",
+        "git:commit", "git:sync", "check:compliance", "explorer:graph", "explorer:audit",
+        "knowledge:update", "knowledge:search", "log:action", "run-script", "security:audit", "check:lint"
     ];
 
     // Handle @agent delegation syntax
@@ -29,21 +32,17 @@ async function main() {
         const content = args.slice(1).join(" ");
         if (!content) {
             console.error(`❌ Error: Missing task content for ${to}.`);
-            console.log(`Usage: agent-enderun ${to} "Your task description"`);
+            console.warn(`Usage: agent-enderun ${to} "Your task description"`);
             process.exit(64);
         }
 
-        const { getMemoryPath } = await import("./utils/memory.js");
-        const fs = await import("fs");
         const memoryPath = getMemoryPath();
 
         let traceId = "T-000";
-        if (fs.default.existsSync(memoryPath)) {
-            const content = fs.default.readFileSync(memoryPath, "utf8");
-            // More robust regex: look for any ULID-like string in the Active Trace ID column or near the label
-            const match = content.match(/Active Trace ID\s*\|.*\|\s*\n\|.*\|.*\|.*\|\s*([A-Z0-9]+)\s*\|/i) || 
-                          content.match(/Active Trace ID[:\s|]+([A-Z0-9]+)/i);
-            if (match) traceId = match[1].trim();
+        if (fs.existsSync(memoryPath)) {
+            const memoryContent = fs.readFileSync(memoryPath, "utf8");
+            const tid = readActiveTraceId(memoryContent);
+            if (tid) traceId = tid.trim();
         }
 
         sendMessage({
@@ -54,16 +53,17 @@ async function main() {
             traceId
         });
 
-        console.log(`✅ Task delegated to ${to} (Trace: ${traceId})`);
-        console.log("👉 Run \"agent-enderun orchestrate\" to process.");
+        console.warn(`✅ Task delegated to ${to} (Trace: ${traceId})`);
+        console.warn("👉 Run \"agent-enderun orchestrate\" to process.");
         return;
     }
 
     switch (command) {
     case "init": {
         const dryRun = args.includes("--dry-run");
+        const isInteractive = args.includes("--interactive");
         const adapter = args.find(a => !a.startsWith("-") && a !== "init");
-        await initCommand(adapter, dryRun);
+        await initCommand(adapter, dryRun, isInteractive);
         break;
     }
 
@@ -99,6 +99,7 @@ async function main() {
         break;
 
     case "orchestrate":
+    case "loop":
         orchestrateCommand();
         break;
 
@@ -123,10 +124,93 @@ async function main() {
         break;
     }
 
+    case "git:commit": {
+        const memoryContent = fs.existsSync(getMemoryPath()) ? fs.readFileSync(getMemoryPath(), "utf8") : "";
+        const traceId = readActiveTraceId(memoryContent) || "T-000";
+        const { gitCommitCommand } = await import("./commands/git.js");
+        gitCommitCommand(traceId);
+        break;
+    }
+
+    case "git:sync": {
+        const { gitSyncCommand } = await import("./commands/git.js");
+        gitSyncCommand();
+        break;
+    }
+
+    case "check:compliance": {
+        const targetPath = args[1] || "src";
+        const { complianceCheckCommand } = await import("./commands/compliance.js");
+        complianceCheckCommand(targetPath);
+        break;
+    }
+
+    case "explorer:graph": {
+        const targetPath = args[1] || "src";
+        const { explorerGraphCommand } = await import("./commands/explorer.js");
+        explorerGraphCommand(targetPath);
+        break;
+    }
+
+    case "explorer:audit": {
+        const targetPath = args[1] || "src";
+        const { explorerAuditCommand } = await import("./commands/explorer.js");
+        explorerAuditCommand(targetPath);
+        break;
+    }
+
+    case "knowledge:update": {
+        const topic = args[1];
+        const content = args[2];
+        const { updateKnowledgeBaseCommand } = await import("./commands/knowledge.js");
+        updateKnowledgeBaseCommand(topic, content);
+        break;
+    }
+
+    case "knowledge:search": {
+        const query = args[1];
+        const { searchKnowledgeBaseCommand } = await import("./commands/knowledge.js");
+        searchKnowledgeBaseCommand(query);
+        break;
+    }
+
+    case "log:action": {
+        const agent = args[1];
+        const action = args[2];
+        const status = args[3] || "SUCCESS";
+        const summary = args[4] || "";
+        const memoryContent = fs.existsSync(getMemoryPath()) ? fs.readFileSync(getMemoryPath(), "utf8") : "";
+        const traceId = readActiveTraceId(memoryContent) || "T-000";
+        const { logAgentActionCommand } = await import("./commands/log.js");
+        logAgentActionCommand({ agent, action, status, summary, traceId });
+        break;
+    }
+
+    case "run-script": {
+        const script = args[1];
+        const projectPath = args[2] || ".";
+        const { runScriptCommand } = await import("./commands/script.js");
+        runScriptCommand(script, projectPath);
+        break;
+    }
+
+    case "security:audit": {
+        const targetPath = args[1] || "src";
+        const { securityAuditCommand } = await import("./commands/security.js");
+        securityAuditCommand(targetPath);
+        break;
+    }
+
+    case "check:lint": {
+        const { lintCommand } = await import("./commands/lint.js");
+        lintCommand();
+        break;
+    }
+
     case "version":
     case "-v":
     case "--version":
-        console.log(`v${getPackageVersion()}`);
+        console.warn(`v${getPackageVersion()}`);
         break;
 
     case "help":
@@ -139,17 +223,13 @@ async function main() {
         if (command && !KNOWN_COMMANDS.includes(command)) {
             // Natural language request fallback to @manager
             const content = args.join(" ");
-            const { getMemoryPath } = await import("./utils/memory.js");
-            const fs = await import("fs");
             const memoryPath = getMemoryPath();
 
             let traceId = "T-000";
-            if (fs.default.existsSync(memoryPath)) {
-                const content = fs.default.readFileSync(memoryPath, "utf8");
-                // More robust regex: look for any ULID-like string in the Active Trace ID column or near the label
-                const match = content.match(/Active Trace ID\s*\|.*\|\s*\n\|.*\|.*\|.*\|\s*([A-Z0-9]+)\s*\|/i) || 
-                              content.match(/Active Trace ID[:\s|]+([A-Z0-9]+)/i);
-                if (match) traceId = match[1].trim();
+            if (fs.existsSync(memoryPath)) {
+                const memoryContent = fs.readFileSync(memoryPath, "utf8");
+                const tid = readActiveTraceId(memoryContent);
+                if (tid) traceId = tid.trim();
             }
 
             sendMessage({
@@ -160,8 +240,8 @@ async function main() {
                 traceId
             });
 
-            console.log(`📡 Request sent to @manager: "${content}" (Trace: ${traceId})`);
-            console.log("👉 Run 'agent-enderun orchestrate' to process.");
+            console.warn(`📡 Request sent to @manager: "${content}" (Trace: ${traceId})`);
+            console.warn("👉 Run 'agent-enderun orchestrate' to process.");
         } else {
             showHelp();
         }
@@ -170,8 +250,8 @@ async function main() {
 }
 
 function showHelp() {
-    console.log(`
-🤖 Agent Enderun CLI — Enterprise AI Orchestration
+    console.warn(`
+🎖️  Enderun Core CLI (v${getPackageVersion()}) — The Supreme AI Orchestrator
 
 Usage:
   agent-enderun <command> [options]
@@ -180,7 +260,8 @@ Usage:
 
 Commands:
   @<agent> <task>     Delegate a task to a specialist agent (e.g. @backend, @frontend)
-  init [adapter]      Initialize Agent Enderun framework (gemini, claude, grok, etc.)
+  init [adapter]      Initialize Agent Enderun framework.
+                      Options: --interactive, --dry-run
   check               Perform an enterprise-grade system health check
   status              Show active phase, trace ID, and agent statuses
   trace:new <desc>    Start a new task chain with a unique Trace ID
@@ -188,6 +269,17 @@ Commands:
   orchestrate         Start the dynamic Hermes agent orchestration loop
   verify-contract     Validate type alignment between backend and frontend
   update-contract     Generate and synchronize a new contract hash
+  git:commit          Suggest git commit messages matching the Trace ID
+  git:sync            Sync and rebase the project with remote repository
+  check:compliance    Verify file compliance with ENDERUN.md rules
+  explorer:graph      Generate import dependency charts in Mermaid format
+  explorer:audit      Scan source files for lines-of-code complexity
+  knowledge:update    Add or update a topic in the local knowledge base
+  knowledge:search    Search the local knowledge base for a topic query
+  log:action          Record structured logs for agent executions
+  run-script          Execute package scripts in the project directory
+  security:audit      Audit source files for secrets and unsafe coding
+  check:lint          Run ESLint checks on the project files
   version             Show version information
 
 Natural Language:

package/src/cli/utils/app.ts

@@ -2,7 +2,7 @@ import fs from "fs";
 import path from "path";
 import crypto from "crypto";
 import { ensureDir, writeTextFile, writeJsonFile } from "../utils/fs.js";
-import { updateProjectMemoryCommand } from "../commands/memory.js"; 
+import { updateProjectMemory } from "./memory.js"; 
 import { slugifyName, titleCase } from "../utils/string.js";
 import { getConfiguredPaths, getMemoryPath } from "./memory.js";
 import { getDependencyVersions } from "./pkg.js";
@@ -278,7 +278,7 @@ export interface Task {
     console.warn(`✅ Base types created in ${path.relative(targetDir, typesDir)}`);
 }
 
-interface AppSpec {
+export interface AppSpec {
     rawDescription: string;
     appName: string;
     title: string;
@@ -735,7 +735,7 @@ export function updateMemoryForGeneratedApp(spec: AppSpec, traceId: string) {
         `- **Files:** ${pathsMap.backend}, ${pathsMap.frontend}, project docs`,
     ].join("\n");
 
-    updateProjectMemoryCommand("HISTORY", history);
+    updateProjectMemory("HISTORY", history);
 }
 
 export async function collectCreateAppDescription(args: string[]) {

package/src/cli/utils/config-schema.ts

@@ -0,0 +1,48 @@
+import { z } from "zod";
+
+/**
+ * Standard Color Palette Schema
+ */
+export const ColorPaletteSchema = z.object({
+    primary: z.string().regex(/^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/),
+    secondary: z.string().regex(/^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/),
+    accent: z.string().regex(/^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/),
+});
+
+/**
+ * Enderun Core config.json Schema
+ */
+export const EnderunConfigSchema = z.object({
+    name: z.string().default("Enderun Core"),
+    version: z.string(),
+    frameworkDir: z.string().optional(),
+    theme: z.object({
+        palette: z.string(),
+        colors: ColorPaletteSchema
+    }).optional(),
+    paths: z.object({
+        backend: z.string(),
+        frontend: z.string(),
+        docs: z.string(),
+        tests: z.string(),
+    }).default({
+        backend: "apps/backend",
+        frontend: "apps/web",
+        docs: "docs",
+        tests: "tests"
+    })
+});
+
+/**
+ * MCP mcp.json Schema
+ */
+export const McpConfigSchema = z.object({
+    mcpServers: z.record(z.object({
+        command: z.string(),
+        args: z.array(z.string()),
+        env: z.record(z.string()).optional()
+    }))
+});
+
+export type EnderunConfig = z.infer<typeof EnderunConfigSchema>;
+export type McpConfig = z.infer<typeof McpConfigSchema>;

package/src/cli/utils/fs.ts

@@ -3,6 +3,9 @@ import path from "path";
 
 import { remapFrameworkContent } from "../adapters.js"; // Import from the new adapters.js
 import type { AdapterId } from "../adapters.js";
+import { ensureDir, writeTextFile, writeJsonFile } from "../../shared/fs.js";
+
+export { ensureDir, writeTextFile, writeJsonFile };
 
 export function updateGitIgnore(targetPath: string, frameworkDir = ".gemini", dryRun = false): void {
     const IGNORE_LINES = [
@@ -39,29 +42,6 @@ export function updateGitIgnore(targetPath: string, frameworkDir = ".gemini", dr
     }
 }
 
-export function ensureDir(dirPath: string, dryRun = false): void {
-    if (!fs.existsSync(dirPath)) {
-        if (dryRun) {
-            console.warn(`[DRY RUN] Would create directory: ${dirPath}`);
-        } else {
-            fs.mkdirSync(dirPath, { recursive: true });
-        }
-    }
-}
-
-export function writeTextFile(filePath: string, content: string, dryRun = false): void {
-    if (dryRun) {
-        console.warn(`[DRY RUN] Would write file: ${filePath}`);
-        return;
-    }
-    ensureDir(path.dirname(filePath));
-    // Use template literal for content handling to avoid issues with raw newlines
-    fs.writeFileSync(filePath, content.endsWith("\n") ? content : `${content}\n`);
-}
-
-export function writeJsonFile(filePath: string, value: unknown, dryRun = false): void {
-    writeTextFile(filePath, JSON.stringify(value, null, 2), dryRun);
-}
 
 interface SanitizeJsonFunction {
   (obj: unknown, targetScope?: string): unknown;
@@ -90,14 +70,17 @@ export function copyDir(
 
         const srcPath = path.join(src, entry.name);
         
-        // Physical folder remapping during copy
+        // Physical folder remapping during copy.
+        // In unified mode (frameworkDir === ".enderun") folder names are always standard —
+        // agents/ stays agents/, knowledge/ stays knowledge/.
+        // Only remap when using a legacy non-unified adapter directory.
         let effectiveEntryName = entry.name;
-        if (entry.isDirectory()) {
+        if (entry.isDirectory() && frameworkDir !== ".enderun") {
             if (entry.name === "agents") {
-                if (adapterId === "antigravity") effectiveEntryName = "skills";
+                if (adapterId === "antigravity-cli") effectiveEntryName = "skills";
                 else if (adapterId === "grok") effectiveEntryName = "plugins";
             } else if (entry.name === "knowledge") {
-                if (adapterId === "antigravity") effectiveEntryName = "rules";
+                if (adapterId === "antigravity-cli") effectiveEntryName = "rules";
             }
         }