agent-enderun 1.10.2 → 1.11.0

package/framework-mcp/tests/tools/quality/check_lint.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { handleCheckLint } from "../../../src/tools/quality/check_lint.js";
+import { exec } from "child_process";
+
+vi.mock("child_process");
+
+describe("handleCheckLint", () => {
+    const projectRoot = "/fake/project";
+
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+
+    it("should execute the lint command and return output on success", async () => {
+        const args = {};
+        
+        vi.mocked(exec).mockImplementation((_cmd, _opts, callback) => {
+            // @ts-expect-error: Mock implementation callback type is complex
+            callback(null, "All good!", "");
+            return {} as any;
+        });
+
+        const result = await handleCheckLint(projectRoot, args);
+        
+        expect(exec).toHaveBeenCalledWith("npm run lint", { cwd: projectRoot, timeout: 60000 }, expect.any(Function));
+        expect(result.isError).toBeUndefined();
+        expect(result.content[0].text).toContain("All good!");
+    });
+
+    it("should execute the lint command and return output on failure (lint issues found)", async () => {
+        const args = {};
+        const lintErrorOutput = "Error: 2 problems (2 errors, 0 warnings)";
+        
+        vi.mocked(exec).mockImplementation((_cmd, _opts, callback) => {
+            // @ts-expect-error: Mock implementation callback type is complex
+            callback({ code: 1, message: "Lint errors found" }, lintErrorOutput, "");
+            return {} as any;
+        });
+
+        const result = await handleCheckLint(projectRoot, args);
+        
+        expect(exec).toHaveBeenCalledWith("npm run lint", { cwd: projectRoot, timeout: 60000 }, expect.any(Function));
+        expect(result.isError).toBe(true); // Implementation returns isError: true on failure
+        expect(result.content[0].text).toContain(lintErrorOutput);
+    });
+});

package/framework-mcp/tests/tools/shell/run_command.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { handleRunCommand } from "../../../src/tools/shell/run_command.js";
+import { exec } from "child_process";
+
+vi.mock("child_process");
+
+describe("handleRunCommand", () => {
+    const projectRoot = "/fake/project";
+
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+
+    it("should execute an allowed command", async () => {
+        const args = { command: "git status" };
+        
+        vi.mocked(exec).mockImplementation((_cmd, _opts, callback) => {
+            // @ts-expect-error: Mock implementation callback type is complex
+            callback(null, "On branch main", "");
+            return {} as any;
+        });
+
+        const result = await handleRunCommand(projectRoot, args);
+        
+        expect(exec).toHaveBeenCalledWith("git status", { cwd: projectRoot, timeout: 30000 }, expect.any(Function));
+        expect(result.isError).toBeUndefined();
+        expect(result.content[0].text).toContain("On branch main");
+    });
+
+    it("should reject a disallowed command", async () => {
+        const args = { command: "rm -rf /" };
+        const result = await handleRunCommand(projectRoot, args);
+        
+        expect(exec).not.toHaveBeenCalled();
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain("Command not allowed");
+    });
+
+    it("should handle command failure", async () => {
+        const args = { command: "npm run build" };
+
+        vi.mocked(exec).mockImplementation((_cmd, _opts, callback) => {
+            // @ts-expect-error: Mock implementation callback type is complex
+            callback({ code: 1, message: "Build failed" }, "", "Error details");
+            return {} as any;
+        });
+
+        const result = await handleRunCommand(projectRoot, args);
+
+        expect(exec).toHaveBeenCalledWith("npm run build", { cwd: projectRoot, timeout: 30000 }, expect.any(Function));
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain("Command failed with exit code 1");
+        expect(result.content[0].text).toContain("Error details");
+    });
+});

package/framework-mcp/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "rootDir": "src",
+    "outDir": "./dist",
+    "strict": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-enderun",
-  "version": "1.10.2",
+  "version": "1.11.0",
   "description": "The Supreme AI Governance & Autonomous Orchestration Framework for Enterprise Development. Acts as a Corporate AI Management Assistant.",
   "author": "Yusuf BEKAR",
   "license": "MIT",
@@ -33,6 +33,8 @@
     "bin",
     "dist",
     "src",
+    "templates",
+    "framework-mcp",
     "README.md",
     "LICENSE"
   ],
@@ -58,20 +60,20 @@
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
-    "@modelcontextprotocol/sdk": "^1.26.0",
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "@pandacss/dev": "^1.11.1",
     "@types/node": "^25.9.1",
     "eslint": "^10.4.0",
     "globals": "^17.6.0",
     "tsx": "^4.22.3",
-    "typescript": "^6.0.3",
-    "typescript-eslint": "^8.60.0",
-    "vitest": "^4.1.7"
+    "typescript": "^5.0.0",
+    "typescript-eslint": "^8.0.0",
+    "vitest": "^3.0.0"
   },
   "enderun": {
-    "version": "1.10.0",
+    "version": "1.11.0",
     "initializedAt": "2026-06-04T18:51:28.970Z",
-    "frameworkDir": ".gemini"
+    "frameworkDir": ".enderun"
   },
   "dependencies": {
     "chalk": "^5.6.2",

package/src/cli/adapters/core.ts

@@ -3,8 +3,8 @@ import path from "path";
 import { writeJsonFile } from "../utils/fs.js";
 import { getPackageRoot } from "../utils/pkg.js";
 
-import type { AdapterConfig, AdapterId } from "../../modules/adapters/types.js";
 import { ADAPTER_CONFIGS, POST_INIT_HANDLERS } from "../../modules/adapters/definitions.js";
+import type { AdapterConfig, AdapterId } from "../../modules/adapters/types.js";
 
 export const ADAPTERS: Record<AdapterId, AdapterConfig> = ADAPTER_CONFIGS;
 
@@ -21,11 +21,17 @@ export const FRAMEWORK_DIR_CANDIDATES = [
     ".gemini/antigravity-cli",
     ".gemini",
     ".agents",
+    "antigravity-cli"
 ] as const;
 
 export function buildMcpServerEntry(projectRoot: string) {
     const packageRoot = getPackageRoot();
     const mcpServerPath = path.join(packageRoot, "framework-mcp/dist/index.js");
+
+    if (!fs.existsSync(mcpServerPath)) {
+        console.warn(`⚠️  MCP Server not found at ${mcpServerPath}. Did you run 'npm run build'?`);
+    }
+
     const relativePath = path.relative(projectRoot, mcpServerPath) || mcpServerPath;
 
     return {

package/src/cli/adapters/index.ts

@@ -2,3 +2,4 @@ export { ADAPTER_IDS, type AdapterConfig, type AdapterId, type AdapterRole } fro
 export { ADAPTERS, FRAMEWORK_DIR_CANDIDATES, runAdapterPostInit, buildMcpServerEntry } from "./core.js";
 export { resolveAdapter, isAdapterShimFile, remapFrameworkContent } from "./utils.js";
 export { scaffoldAgents } from "./scaffold.js";
+export { resolveAgentsDir, mirrorUnifiedAgentsToNative } from "./paths.js";

package/src/cli/adapters/paths.ts

@@ -0,0 +1,134 @@
+import fs from "fs";
+import path from "path";
+import type { AdapterId } from "../../modules/adapters/types.js";
+import { ADAPTER_IDS } from "../../modules/adapters/types.js";
+import {
+    LEGACY_AGENT_LAYOUT_BASES,
+    UNIFIED_ADAPTER_SLUG,
+    UNIFIED_HUB_DIR,
+    pathJoin,
+    unifiedAdapterPath,
+} from "../../shared/constants.js";
+import { ADAPTERS } from "./core.js";
+
+export {
+    CORE_FRAMEWORK_DIR,
+    UNIFIED_HUB_DIR,
+    UNIFIED_ADAPTER_SLUG,
+} from "../../shared/constants.js";
+
+export interface AgentsDestination {
+    agentsDir: string;
+    agentsExt: string;
+    nestedAntigravity: boolean;
+}
+
+export function unifiedAdapterRoot(aiToolDir: string, adapterId: AdapterId): string {
+    return pathJoin(aiToolDir, UNIFIED_ADAPTER_SLUG[adapterId]);
+}
+
+export function resolveAgentsDir(
+    adapterId: AdapterId,
+    isUnified: boolean,
+    aiToolDir: string = UNIFIED_HUB_DIR,
+): AgentsDestination {
+    const adapter = ADAPTERS[adapterId];
+
+    if (!isUnified) {
+        return {
+            agentsDir: adapter.agentsDir ?? pathJoin(adapter.frameworkDir, "agents"),
+            agentsExt: adapter.agentsExt ?? ".md",
+            nestedAntigravity: adapterId === "antigravity-cli",
+        };
+    }
+
+    const base = unifiedAdapterRoot(aiToolDir, adapterId);
+
+    switch (adapterId) {
+        case "cursor":
+            return { agentsDir: pathJoin(base, "rules"), agentsExt: ".mdc", nestedAntigravity: false };
+        case "codex":
+            return { agentsDir: pathJoin(base, "instructions"), agentsExt: ".md", nestedAntigravity: false };
+        case "antigravity-cli":
+            return { agentsDir: pathJoin(base, "agents"), agentsExt: ".md", nestedAntigravity: true };
+        default:
+            return { agentsDir: pathJoin(base, "agents"), agentsExt: ".md", nestedAntigravity: false };
+    }
+}
+
+export function getUnifiedAgentLayoutBases(aiToolDir: string = UNIFIED_HUB_DIR): string[] {
+    return ADAPTER_IDS.map((id) => resolveAgentsDir(id, true, aiToolDir).agentsDir);
+}
+
+const AGENT_INSTRUCTION_CANDIDATES: Array<(name: string) => string[]> = [
+    (n) => ADAPTER_IDS.flatMap((id) => {
+        const { agentsDir, nestedAntigravity, agentsExt } = resolveAgentsDir(id, true);
+        if (nestedAntigravity) {
+            return [pathJoin(agentsDir, n, "agent.json"), pathJoin(agentsDir, n, "agent.md")];
+        }
+        return [pathJoin(agentsDir, `${n}${agentsExt}`)];
+    }),
+    (n) => LEGACY_AGENT_LAYOUT_BASES.flatMap((base) => {
+        if (base.includes("antigravity")) {
+            return [pathJoin(base, n, "agent.json"), pathJoin(base, n, "agent.md")];
+        }
+        const ext = base.includes("rules") ? ".mdc" : ".md";
+        return [pathJoin(base, `${n}${ext}`)];
+    }),
+];
+
+export function findAgentInstruction(projectRoot: string, agentName: string): string | null {
+    for (const buildPaths of AGENT_INSTRUCTION_CANDIDATES) {
+        for (const rel of buildPaths(agentName)) {
+            const full = path.join(projectRoot, rel);
+            if (fs.existsSync(full)) return rel;
+        }
+    }
+    return null;
+}
+
+export function detectActiveAgentLayouts(projectRoot: string): string[] {
+    const unified = getUnifiedAgentLayoutBases()
+        .filter((b) => fs.existsSync(path.join(projectRoot, b)));
+
+    const legacy = LEGACY_AGENT_LAYOUT_BASES
+        .filter((b) => fs.existsSync(path.join(projectRoot, b)));
+
+    return [...new Set([...unified, ...legacy])];
+}
+
+function copyDirectoryRecursive(src: string, dest: string): void {
+    fs.mkdirSync(dest, { recursive: true });
+    for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            copyDirectoryRecursive(srcPath, destPath);
+        } else {
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+}
+
+export function mirrorUnifiedAgentsToNative(projectRoot: string, adapterId: AdapterId): void {
+    const { agentsDir: unifiedDir } = resolveAgentsDir(adapterId, true);
+    const nativeRel = ADAPTERS[adapterId].agentsDir;
+    if (!nativeRel) return;
+
+    const src = path.join(projectRoot, unifiedDir);
+    const dest = path.join(projectRoot, nativeRel);
+    if (!fs.existsSync(src) || path.resolve(src) === path.resolve(dest)) return;
+
+    if (fs.existsSync(dest)) {
+        fs.rmSync(dest, { recursive: true, force: true });
+    }
+    copyDirectoryRecursive(src, dest);
+}
+
+/** Cursor global rule destinations (native + unified hub). */
+export function getCursorGlobalRulePaths(projectRoot: string): string[] {
+    return [
+        path.join(projectRoot, ADAPTERS.cursor.frameworkDir, "rules", "global.mdc"),
+        path.join(projectRoot, unifiedAdapterPath(UNIFIED_ADAPTER_SLUG.cursor, "rules", "global.mdc")),
+    ];
+}

package/src/cli/adapters/scaffold.ts

@@ -1,6 +1,7 @@
 import { writeTextFile } from "../utils/fs.js";
 import path from "path";
 import fs from "fs";
+import { getPackageRoot } from "../utils/pkg.js";
 import { 
     ALL_AGENTS, 
     toClaudeCodeMd, 
@@ -13,14 +14,24 @@ import {
 import type { AdapterId } from "../../modules/adapters/types.js";
 import { ADAPTERS } from "./core.js";
 
-export function scaffoldAgents(projectRoot: string, adapterId: AdapterId, dryRun: boolean, agentsToScaffold?: string[]): void {
+export function scaffoldAgents(
+    projectRoot: string, 
+    adapterId: AdapterId, 
+    dryRun: boolean, 
+    agentsToScaffold?: string[],
+    explicitDestDir?: string,
+    explicitExt?: string
+): void {
     const adapter = ADAPTERS[adapterId];
-    if (!adapter || !adapter.agentsDir || !adapter.agentsExt) return;
+    if (!adapter) return;
 
     const allowedAgents = agentsToScaffold ? new Set(agentsToScaffold) : undefined;
-    const destAgentsDir = path.join(projectRoot, adapter.agentsDir);
+    const destAgentsDir = explicitDestDir ? path.join(projectRoot, explicitDestDir) : (adapter.agentsDir ? path.join(projectRoot, adapter.agentsDir) : null);
+    const extension = explicitExt || adapter.agentsExt || ".md";
 
-    const baseKnowledgeDir = path.join(projectRoot, "templates/standards");
+    if (!destAgentsDir) return;
+
+    const baseKnowledgeDir = path.join(getPackageRoot(), "templates/standards");
 
     try {
         if (!dryRun) fs.mkdirSync(destAgentsDir, { recursive: true });
@@ -29,7 +40,7 @@ export function scaffoldAgents(projectRoot: string, adapterId: AdapterId, dryRun
             if (allowedAgents && !allowedAgents.has(agent.name)) continue;
             
             let content = "";
-            let fileName = `${agent.name}${adapter.agentsExt}`;
+            let fileName = `${agent.name}${extension}`;
             let secondaryContent: string | null = null;
             let secondaryFileName: string | null = null;
 
@@ -71,8 +82,7 @@ export function scaffoldAgents(projectRoot: string, adapterId: AdapterId, dryRun
                 }
             }
         }
-        console.warn(`✅ Generated ${allowedAgents ? allowedAgents.size : ALL_AGENTS.length} Agent/Rule definitions under ${path.relative(projectRoot, destAgentsDir)}/`);
     } catch (e) {
-        console.warn(`⚠️  Failed to scaffold agents: ${e}`);
+        console.warn(`⚠️  Failed to scaffold agents for ${adapterId}: ${e}`);
     }
 }

package/src/cli/commands/check.ts

@@ -2,12 +2,13 @@ import fs from "fs";
 import path from "path";
 import { execSync } from "child_process";
 
-import { getFrameworkDir, getMemoryPath, getConfiguredPaths } from "../utils/memory.js";
+import { getFrameworkDir, getMemoryPath, getConfiguredPaths, isFrameworkDevelopmentRepo } from "../utils/memory.js";
 import { getPackageVersion, getValidatorPath } from "../utils/pkg.js";
 import { UI } from "../utils/ui.js";
 import { logger } from "../../shared/logger.js";
 import { scanProjectCompliance } from "../utils/compliance.js";
 import { ALL_AGENTS } from "../../modules/agents/definitions.js";
+import { detectActiveAgentLayouts, findAgentInstruction } from "../adapters/paths.js";
 
 export async function checkCommand() {
     UI.intent("Agent Enderun Health Check", `Checking system health and discipline rules (v${getPackageVersion()})...`);
@@ -32,18 +33,7 @@ export async function checkCommand() {
         issues++;
     }
 
-    let isFrameworkDevelopment = false;
-    try {
-        const localPkgPath = path.join(process.cwd(), "package.json");
-        if (fs.existsSync(localPkgPath)) {
-            const localPkg = JSON.parse(fs.readFileSync(localPkgPath, "utf8"));
-            if (localPkg.name === "agent-enderun") {
-                isFrameworkDevelopment = true;
-            }
-        }
-    } catch (err) {
-        logger.debug("Failed to read package.json in checkCommand", err);
-    }
+    const isFrameworkDevelopment = isFrameworkDevelopmentRepo();
 
     const checks = [
         { name: "Constitution (ENDERUN.md)", path: constitutionPath },
@@ -99,35 +89,23 @@ export async function checkCommand() {
 
     // Agent Documentation Check (Live Integrity)
     console.warn("\n📚 Checking Agent Integrity (Instructions)...");
-    
-    // We check both the main framework dir and common subdirs
-    const possibleAgentDirs = [
-        path.join(process.cwd(), ".agents"),
-        path.join(process.cwd(), ".gemini/agents"),
-        path.join(process.cwd(), ".claude/agents"),
-        path.join(process.cwd(), ".cursor/rules"),
-        path.join(process.cwd(), ".grok"),
-        path.join(process.cwd(), ".antigravity/agents"),
-    ];
 
-    const activeAgentDir = possibleAgentDirs.find(d => fs.existsSync(d));
-
-    if (activeAgentDir) {
-        ALL_AGENTS.forEach(agent => {
-            const agentName = agent.name.replace("@", "");
-            // Support both .md and .mdc (Cursor)
-            const mdPath = path.join(activeAgentDir, `${agentName}.md`);
-            const mdcPath = path.join(activeAgentDir, `${agentName}.mdc`);
-            
-            if (fs.existsSync(mdPath) || fs.existsSync(mdcPath)) {
-                UI.success(`Instructions for @${agentName} found in ${path.relative(process.cwd(), activeAgentDir)}`);
+    const projectRoot = process.cwd();
+    const activeLayouts = detectActiveAgentLayouts(projectRoot);
+
+    if (activeLayouts.length > 0) {
+        UI.success(`Active agent layout(s): ${activeLayouts.join(", ")}`);
+        ALL_AGENTS.forEach((agent) => {
+            const found = findAgentInstruction(projectRoot, agent.name);
+            if (found) {
+                UI.success(`Instructions for @${agent.name} found at ${found}`);
             } else {
-                UI.error(`Instructions for @${agentName} MISSING! Expected in ${path.relative(process.cwd(), activeAgentDir)}`);
+                UI.error(`Instructions for @${agent.name} MISSING! Run 'agent-enderun init' to scaffold.`);
                 issues++;
             }
         });
     } else {
-        UI.warning("No active agent instruction directory detected (.gemini/agents, .claude/agents, etc.). Run 'init' first.");
+        UI.warning("No active agent instruction directory detected. Run 'agent-enderun init [adapter]' first.");
         issues++;
     }
 
@@ -149,12 +127,12 @@ export async function checkCommand() {
     }
 
     try {
+        UI.intent("Type Check", "Running 'npx tsc --noEmit' (this may take a few seconds)...");
         execSync("npx tsc --noEmit", { stdio: "pipe" });
         UI.success("TypeScript type check PASSED.");
     } catch (err) {
-        UI.error("TypeScript type check FAILED.");
+        UI.warning("TypeScript type check FAILED or 'tsc' not found. This is a non-blocking warning for lightweight checks.");
         logger.debug("npx tsc --noEmit check failed", err);
-        issues++;
     }
 
     interface MetricEntry {

package/src/cli/commands/dashboard/data-service.ts

@@ -74,6 +74,54 @@ export function parseProjectMemory() {
     }
 }
 
+interface ProjectStructureEntry {
+  name: string;
+  path: string;
+  type: "directory" | "file";
+  children?: ProjectStructureEntry[];
+}
+
+export function getProjectStructure(): ProjectStructureEntry[] {
+    const projectRoot = process.cwd();
+
+    function walk(dir: string, depth = 0): ProjectStructureEntry[] {
+        if (depth > 3) return []; // Limit depth for performance
+
+        const entries: ProjectStructureEntry[] = [];
+        let files: fs.Dirent[];
+
+        try {
+            files = fs.readdirSync(dir, { withFileTypes: true });
+        } catch (_e) {
+            // Silently ignore directories that cannot be read
+            return [];
+        }
+        
+        for (const file of files) {
+            if (file.name.startsWith(".") || file.name === "node_modules" || file.name === "dist") continue;
+            
+            const fullPath = path.join(dir, file.name);
+            const entry: ProjectStructureEntry = {
+                name: file.name,
+                path: path.relative(projectRoot, fullPath),
+                type: file.isDirectory() ? "directory" : "file"
+            };
+
+            if (file.isDirectory()) {
+                entry.children = walk(fullPath, depth + 1);
+            }
+            entries.push(entry);
+        }
+        return entries;
+    }
+
+    try {
+        return walk(projectRoot);
+    } catch {
+        return [];
+    }
+}
+
 export function readManagerLogs() {
     const frameworkDir = getFrameworkDir();
     if (!frameworkDir) return [];

package/src/cli/commands/init/scaffold-core.ts

@@ -3,7 +3,8 @@ import path from "path";
 import { 
     remapFrameworkContent, 
     type AdapterConfig, 
-    type AdapterId 
+    type AdapterId,
+    ADAPTERS
 } from "../../adapters/index.js";
 import { SHIM_TEMPLATES } from "../../shims.js";
 import { writeJsonFile, writeTextFile } from "../../utils/fs.js";
@@ -38,7 +39,14 @@ export function scaffoldConstitution(targetDir: string, frameworkDir: string, ad
     console.warn(`✅ Constitution file created inside: ${frameworkDir}/ENDERUN.md${readSuccess ? "" : " (default template)"}`);
 }
 
-export function scaffoldFrameworkConfigs(targetDir: string, fDir: string, adapter: AdapterConfig, dryRun: boolean, selectedPalette: string) {
+export function scaffoldFrameworkConfigs(
+    targetDir: string, 
+    fDir: string, 
+    adapter: AdapterConfig, 
+    dryRun: boolean, 
+    selectedPalette: string,
+    options?: { unified?: boolean; adapters?: string[] }
+) {
     if (dryRun) return;
     const frameworkDir = path.join(targetDir, fDir);
     const palette = COLOR_PALETTES[selectedPalette as keyof typeof COLOR_PALETTES] || COLOR_PALETTES["Modern Blue"];
@@ -46,12 +54,28 @@ export function scaffoldFrameworkConfigs(targetDir: string, fDir: string, adapte
     const config = {
         name: FRAMEWORK_NAME,
         version: getPackageVersion(),
+        unified: options?.unified || false,
+        adapters: options?.adapters || [adapter.id],
         theme: {
             palette: selectedPalette,
             colors: palette
         }
     };
     writeJsonFile(path.join(frameworkDir, "config.json"), config, dryRun);
+
+    // Scaffold shared-facts.json in memory-graph
+    const graphDir = path.join(frameworkDir, "memory-graph");
+    if (!fs.existsSync(graphDir)) fs.mkdirSync(graphDir, { recursive: true });
+    const sharedFactsPath = path.join(graphDir, "shared-facts.json");
+    if (!fs.existsSync(sharedFactsPath)) {
+        writeJsonFile(sharedFactsPath, {
+            project: FRAMEWORK_NAME,
+            initializedAt: new Date().toISOString(),
+            stack: [],
+            policies: []
+        }, dryRun);
+    }
+
     let statusContent = "# 🎖️ Status\n\n| Agent | State | Active Task | Last Updated | Notes | Extra | Backup |\n|---|---|---|---|---|---|---|\n";
     for (const ag of ALL_AGENTS) {
         statusContent += "| @" + ag.name + " | READY | Idle | - | - | - | - |\n";
@@ -59,13 +83,28 @@ export function scaffoldFrameworkConfigs(targetDir: string, fDir: string, adapte
     writeTextFile(path.join(frameworkDir, "STATUS.md"), statusContent);
 }
 
-export function scaffoldShims(projectRoot: string, coreDir: string, adapterId: AdapterId, adapter: AdapterConfig, dryRun: boolean) {
+export function scaffoldShims(
+    projectRoot: string, 
+    coreDir: string, 
+    adapterId: AdapterId, 
+    adapter: AdapterConfig, 
+    dryRun: boolean,
+    unified: boolean = false
+) {
     for (const [name, content] of Object.entries(SHIM_TEMPLATES)) {
-        if (name.toLowerCase() === adapterId.split("-")[0] || name === adapterId) {
+        const isSelectedAdapter = name.toLowerCase() === adapterId.split("-")[0] || name === adapterId;
+        
+        if (unified || isSelectedAdapter) {
             const shimContent = remapFrameworkContent(content, coreDir, adapterId);
-            const shimFileName = adapter.shimFile || `${name.toUpperCase()}.md`;
+            const shimAdapter = ADAPTERS[name as AdapterId] || adapter;
+            const shimFileName = (unified && !isSelectedAdapter) ? (shimAdapter.shimFile || `${name.toUpperCase()}.md`) : (adapter.shimFile || `${name.toUpperCase()}.md`);
+            
             if (!dryRun) writeTextFile(path.join(projectRoot, shimFileName), shimContent);
-            console.warn(`✅ Platform shim created: ${shimFileName}`);
+            if (isSelectedAdapter) {
+                console.warn(`✅ Platform shim created: ${shimFileName}`);
+            } else if (unified) {
+                console.warn(`✅ Unified platform shim added: ${shimFileName}`);
+            }
         }
     }
 }

package/src/cli/commands/init/scaffold-standards.ts

@@ -43,7 +43,12 @@ This document outlines the strict ESLint coding standards for Agent Enderun proj
         { file: "quality-standards.md", template: "templates/standards/quality-standards.md", default: "# ⚖️ Corporate Code Quality Standards" },
         { file: "logging-and-secrets.md", template: "templates/standards/logging-and-secrets.md", default: "# 🪵 Corporate Logging Standards" },
         { file: "testing-standards.md", template: "templates/standards/testing-standards.md", default: "# 🧪 Corporate Testing Standards" },
-        { file: "i18n-standards.md", template: "templates/standards/i18n-standards.md", default: "# 🌐 Corporate i18n Standards" }
+        { file: "i18n-standards.md", template: "templates/standards/i18n-standards.md", default: "# 🌐 Corporate i18n Standards" },
+        { file: "llm-governance.md", template: "templates/standards/llm-governance.md", default: "# 🤖 LLM Governance Standards" },
+        { file: "observability-standards.md", template: "templates/standards/observability-standards.md", default: "# 📈 Corporate Observability Standards" },
+        { file: "deployment-standards.md", template: "templates/standards/deployment-standards.md", default: "# 🚀 Corporate Deployment Standards" },
+        { file: "performance-standards.md", template: "templates/standards/performance-standards.md", default: "# ⚡ Corporate Performance Standards" },
+        { file: "security-audit-standards.md", template: "templates/standards/security-audit-standards.md", default: "# 🔍 Corporate Security Audit Standards" }
     ];
 
     for (const std of standards) {