atabey 0.0.13 → 0.0.15

package/framework-mcp/dist/framework-mcp/src/tools/shell/run_command.js

@@ -1,107 +1,162 @@
-import { exec } from "child_process";
+import { spawn } from "child_process";
 import { Metrics } from "../../utils/metrics.js";
+// Each entry defines the executable and its allowed args prefix
 const COMMAND_ALLOW_LIST = [
     // Package managers
-    "npm test",
-    "npm run",
-    "npm install",
-    "npm ci",
-    "npm audit",
-    "npx vitest",
-    "npx tsc",
-    "npx eslint",
-    "yarn test",
-    "yarn run",
-    "yarn install",
-    "pnpm test",
-    "pnpm run",
-    "pnpm install",
+    { cmd: "npm", args: ["test"] },
+    { cmd: "npm", args: ["run"] },
+    { cmd: "npm", args: ["install"] },
+    { cmd: "npm", args: ["ci"] },
+    { cmd: "npm", args: ["audit"] },
+    { cmd: "npx", args: ["vitest"] },
+    { cmd: "npx", args: ["tsc"] },
+    { cmd: "npx", args: ["eslint"] },
+    { cmd: "yarn", args: ["test"] },
+    { cmd: "yarn", args: ["run"] },
+    { cmd: "yarn", args: ["install"] },
+    { cmd: "pnpm", args: ["test"] },
+    { cmd: "pnpm", args: ["run"] },
+    { cmd: "pnpm", args: ["install"] },
     // Git
-    "git status",
-    "git diff",
-    "git log",
-    "git branch",
-    "git stash",
-    "git add",
-    "git commit",
-    "git push",
-    "git pull",
-    "git fetch",
-    "git merge",
-    "git rebase",
-    "git checkout",
-    "git reset",
+    { cmd: "git", args: ["status"] },
+    { cmd: "git", args: ["diff"] },
+    { cmd: "git", args: ["log"] },
+    { cmd: "git", args: ["branch"] },
+    { cmd: "git", args: ["stash"] },
+    { cmd: "git", args: ["add"] },
+    { cmd: "git", args: ["commit"] },
+    { cmd: "git", args: ["push"] },
+    { cmd: "git", args: ["pull"] },
+    { cmd: "git", args: ["fetch"] },
+    { cmd: "git", args: ["merge"] },
+    { cmd: "git", args: ["rebase"] },
+    { cmd: "git", args: ["checkout"] },
+    { cmd: "git", args: ["reset"] },
     // Build tools
-    "npm run build",
-    "npx tsc",
-    "npx vite build",
-    "npx webpack",
-    "npx rollup",
-    "npx esbuild",
-    "make",
-    "cmake",
-    "dotnet test",
-    "dotnet format",
-    "dotnet build",
-    "dotnet run",
-    "dotnet restore",
-    "go test",
-    "go fmt",
-    "go build",
-    "go run",
-    "go vet",
-    "go mod",
-    "pytest",
-    "ruff check",
-    "ruff format",
-    "mvn",
-    "./gradlew",
-    "cargo test",
-    "cargo build",
-    "cargo check",
-    "cargo fmt",
-    // File operations (safe) — NOTE: "rm -rf" and "rm -r" intentionally excluded.
-    // Only "rmdir" is allowed to prevent dangerous commands like "rm -rf /".
-    "mkdir",
-    "cp",
-    "mv",
-    "rmdir",
-    "cat",
-    "ls",
-    "touch",
-    "head",
-    "tail",
-    "wc",
-    "grep",
-    "find",
-    "sort",
-    "uniq",
-    "echo",
-    "pwd",
-    "which",
-    "file",
-    "du",
-    "df",
+    { cmd: "make" },
+    { cmd: "cmake" },
+    { cmd: "dotnet", args: ["test"] },
+    { cmd: "dotnet", args: ["format"] },
+    { cmd: "dotnet", args: ["build"] },
+    { cmd: "dotnet", args: ["run"] },
+    { cmd: "dotnet", args: ["restore"] },
+    { cmd: "go", args: ["test"] },
+    { cmd: "go", args: ["fmt"] },
+    { cmd: "go", args: ["build"] },
+    { cmd: "go", args: ["run"] },
+    { cmd: "go", args: ["vet"] },
+    { cmd: "go", args: ["mod"] },
+    { cmd: "pytest" },
+    { cmd: "ruff", args: ["check"] },
+    { cmd: "ruff", args: ["format"] },
+    { cmd: "mvn" },
+    { cmd: "./gradlew" },
+    { cmd: "cargo", args: ["test"] },
+    { cmd: "cargo", args: ["build"] },
+    { cmd: "cargo", args: ["check"] },
+    { cmd: "cargo", args: ["fmt"] },
+    // File operations (safe) — spawn prevents shell injection
+    { cmd: "mkdir" },
+    { cmd: "cp" },
+    { cmd: "mv" },
+    { cmd: "rmdir" },
+    { cmd: "cat" },
+    { cmd: "ls" },
+    { cmd: "touch" },
+    { cmd: "head" },
+    { cmd: "tail" },
+    { cmd: "wc" },
+    { cmd: "grep" },
+    { cmd: "find" },
+    { cmd: "sort" },
+    { cmd: "uniq" },
+    { cmd: "echo" },
+    { cmd: "pwd" },
+    { cmd: "which" },
+    { cmd: "file" },
+    { cmd: "du" },
+    { cmd: "df" },
 ];
 const TIMEOUT = 30000; // 30 seconds
+/**
+ * Parse a command string into executable + args array.
+ * Uses spawn for safety (no shell injection).
+ */
+function parseCommand(cmdString) {
+    const parts = cmdString.trim().split(/\s+/);
+    if (parts.length === 0)
+        return null;
+    return { cmd: parts[0], args: parts.slice(1) };
+}
+/**
+ * Check if a parsed command matches the allow list.
+ */
+function isAllowed(parsed) {
+    return COMMAND_ALLOW_LIST.some(entry => {
+        if (entry.cmd !== parsed.cmd)
+            return false;
+        if (!entry.args)
+            return true; // Any args allowed for this cmd
+        if (!parsed.args || parsed.args.length < entry.args.length)
+            return false;
+        // Check that args start with the allowed prefix
+        return entry.args.every((arg, i) => parsed.args[i] === arg);
+    });
+}
 export function handleRunCommand(projectRoot, args) {
     const command = args.command;
-    const isAllowed = COMMAND_ALLOW_LIST.some(allowedCmd => command.startsWith(allowedCmd));
-    if (!isAllowed) {
-        const errorMsg = `Command not allowed: "${command}". Only commands starting with the following are allowed: ${COMMAND_ALLOW_LIST.join(", ")}`;
+    // Parse command into executable + args
+    const parsed = parseCommand(command);
+    if (!parsed) {
+        return Promise.resolve({
+            content: [{ type: "text", text: "ERROR: Empty command." }],
+            isError: true,
+        });
+    }
+    if (!isAllowed(parsed)) {
+        const allowedList = COMMAND_ALLOW_LIST.map(e => e.args ? `${e.cmd} ${e.args.join(" ")}` : e.cmd);
+        const errorMsg = `Command not allowed: "${command}". Only the following are allowed: ${allowedList.join(", ")}`;
         Metrics.logError(projectRoot, "@mcp", `run_shell_command: ${command} (denied)`, errorMsg);
         return Promise.resolve({
             content: [{ type: "text", text: `ERROR: ${errorMsg}` }],
             isError: true,
         });
     }
+    // Reject any args containing shell metacharacters
+    const hasShellMetacharacters = parsed.args.some(a => /[;&|><$`\n\r]/.test(a));
+    if (hasShellMetacharacters) {
+        const errorMsg = "Command rejected: Shell metacharacters are forbidden to prevent command injection.";
+        Metrics.logError(projectRoot, "@mcp", `run_shell_command: ${command} (denied: metacharacters)`, errorMsg);
+        return Promise.resolve({
+            content: [{ type: "text", text: `ERROR: ${errorMsg}` }],
+            isError: true,
+        });
+    }
     return new Promise((resolve) => {
-        exec(command, { cwd: projectRoot, timeout: TIMEOUT }, (error, stdout, stderr) => {
+        const child = spawn(parsed.cmd, parsed.args, {
+            cwd: projectRoot,
+            timeout: TIMEOUT,
+            shell: false,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (data) => { stdout += data.toString(); });
+        child.stderr.on("data", (data) => { stderr += data.toString(); });
+        child.on("error", (err) => {
+            const errorMsg = `Failed to start command: ${err.message}`;
+            Metrics.logError(projectRoot, "@mcp", `run_shell_command: ${command}`, errorMsg);
+            resolve({
+                content: [{ type: "text", text: `ERROR: ${errorMsg}` }],
+                isError: true,
+            });
+        });
+        child.on("close", (code) => {
             const output = stdout + stderr;
             const tokens = Metrics.estimateTokens(output);
             Metrics.logUsage(projectRoot, "@mcp", `run_shell_command: ${command}`, tokens);
-            if (error) {
-                const errorMsg = `Command failed with exit code ${error.code}: ${error.message}.`;
+            if (code !== 0) {
+                const errorMsg = `Command failed with exit code ${code}.`;
                 Metrics.logError(projectRoot, "@mcp", `run_shell_command: ${command}`, errorMsg);
                 resolve({
                     content: [{ type: "text", text: `ERROR: ${errorMsg}. Output: ${output}` }],
@@ -111,11 +166,12 @@ export function handleRunCommand(projectRoot, args) {
             }
             // Truncate long outputs
             const MAX_OUTPUT_LENGTH = 5000;
-            let truncatedOutput = output;
-            if (output.length > MAX_OUTPUT_LENGTH) {
-                truncatedOutput = output.substring(0, MAX_OUTPUT_LENGTH) + "... [TRUNCATED] ..."; // Simplified
-            }
-            resolve({ content: [{ type: "text", text: truncatedOutput }] });
+            const truncatedOutput = output.length > MAX_OUTPUT_LENGTH
+                ? output.substring(0, MAX_OUTPUT_LENGTH) + "... [TRUNCATED] ..."
+                : output;
+            resolve({
+                content: [{ type: "text", text: truncatedOutput }],
+            });
         });
     });
 }

package/framework-mcp/dist/framework-mcp/src/tools/types.js

@@ -1 +1,2 @@
+// Import types locally for ToolArgs union usage
 export {};

package/framework-mcp/dist/framework-mcp/src/utils/auth.js

@@ -0,0 +1,78 @@
+/**
+ * ─── MCP AUTHENTICATION ──────────────────────────────────────────
+ *
+ * Simple API key authentication for MCP server.
+ * When MCP_AUTH_TOKEN is set, all MCP and API requests require
+ * Authorization: Bearer <token> header.
+ *
+ * Environment Variables:
+ *   MCP_AUTH_TOKEN     - API key for authentication (optional)
+ *   MCP_AUTH_USERS     - Comma-separated list of user:token pairs (optional)
+ *                        Example: "alice:key1,bob:key2"
+ *
+ * If neither is set, authentication is disabled (open access).
+ */
+let authUsers = [];
+let masterToken = null;
+/**
+ * Initialize authentication from environment variables.
+ */
+export function initAuth() {
+    masterToken = process.env.MCP_AUTH_TOKEN || null;
+    const usersStr = process.env.MCP_AUTH_USERS || "";
+    if (usersStr) {
+        authUsers = usersStr.split(",").map(pair => {
+            const [name, token] = pair.split(":");
+            return { name: name?.trim() || "unknown", token: token?.trim() || "" };
+        }).filter(u => u.token);
+    }
+    if (masterToken) {
+        process.stderr.write(`[AUTH] Master token configured (${masterToken.length} chars)\n`);
+    }
+    if (authUsers.length > 0) {
+        process.stderr.write(`[AUTH] ${authUsers.length} user(s) configured: ${authUsers.map(u => u.name).join(", ")}\n`);
+    }
+    if (!masterToken && authUsers.length === 0) {
+        process.stderr.write("[AUTH] No authentication configured - OPEN ACCESS\n");
+        process.stderr.write("[AUTH] Set MCP_AUTH_TOKEN=<key> or MCP_AUTH_USERS=user1:key1,user2:key2 to enable\n");
+    }
+}
+/**
+ * Authenticate a request using the Authorization header.
+ * Returns the authenticated user name or null if unauthorized.
+ */
+export function authenticate(req) {
+    if (!masterToken && authUsers.length === 0) {
+        // Auth disabled - allow all
+        return { authenticated: true, user: "anonymous" };
+    }
+    const authHeader = req.headers["authorization"];
+    if (!authHeader) {
+        return { authenticated: false, user: "" };
+    }
+    // Support both "Bearer <key>" and "<key>" formats
+    const token = authHeader.startsWith("Bearer ") ? authHeader.slice(7) : authHeader;
+    // Check master token first
+    if (masterToken && token === masterToken) {
+        return { authenticated: true, user: "admin" };
+    }
+    // Check user tokens
+    for (const user of authUsers) {
+        if (token === user.token) {
+            return { authenticated: true, user: user.name };
+        }
+    }
+    return { authenticated: false, user: "" };
+}
+/**
+ * Generate authentication headers for MCP client configuration.
+ */
+export function getAuthHeader(user, token) {
+    return `Bearer ${token}`;
+}
+/**
+ * Check if authentication is enabled.
+ */
+export function isAuthEnabled() {
+    return !!masterToken || authUsers.length > 0;
+}

package/framework-mcp/dist/framework-mcp/src/utils/auto-rollback.js

@@ -0,0 +1,265 @@
+/**
+ * ─── AUTO-ROLLBACK + REGENERATE ───────────────────────────────────
+ *
+ * When the AI generates code that violates governance rules (e.g., `any` type,
+ * console.log, copyleft license), this module:
+ *   1. Captures the file content before the write
+ *   2. Validates the new content against governance rules
+ *   3. If violation found: blocks the write, restores original, and sends
+ *      a regenerate instruction back to the AI via MCP notification
+ *
+ * Flow:
+ *   [Pre-Write Snapshot] → [Validate Content] → [Violation?] ─yes→ [Rollback] → [Notify AI]
+ *                                                         └─no─→ [Allow Write]
+ *
+ * Key Innovation: Unlike simple blocking, this tells the AI WHY it was
+ * blocked and gives it specific instructions to self-correct.
+ */
+import fs from "fs";
+import path from "path";
+class SnapshotManager {
+    snapshots = new Map();
+    /**
+     * Capture a pre-write snapshot of a file.
+     */
+    capture(filePath, traceId) {
+        const resolvedPath = path.resolve(filePath);
+        let originalContent = null;
+        try {
+            if (fs.existsSync(resolvedPath)) {
+                originalContent = fs.readFileSync(resolvedPath, "utf8");
+            }
+        }
+        catch { /* file doesn't exist yet (new file) */ }
+        this.snapshots.set(resolvedPath, {
+            filePath: resolvedPath,
+            originalContent,
+            timestamp: Date.now(),
+            traceId,
+            restored: false,
+        });
+    }
+    /**
+     * Get a snapshot for a file.
+     */
+    get(filePath) {
+        return this.snapshots.get(path.resolve(filePath));
+    }
+    /**
+     * Restore a file to its pre-write state.
+     * Returns true if restored, false if no snapshot exists.
+     */
+    restore(filePath) {
+        const resolvedPath = path.resolve(filePath);
+        const snapshot = this.snapshots.get(resolvedPath);
+        if (!snapshot || snapshot.restored)
+            return false;
+        try {
+            if (snapshot.originalContent !== null) {
+                // File existed before – restore original
+                fs.writeFileSync(resolvedPath, snapshot.originalContent, "utf8");
+                process.stderr.write(`[ROLLBACK] Restored: ${path.relative(process.cwd(), resolvedPath)}\n`);
+            }
+            else {
+                // File was new – delete it
+                if (fs.existsSync(resolvedPath)) {
+                    fs.unlinkSync(resolvedPath);
+                    process.stderr.write(`[ROLLBACK] Deleted (new file): ${path.relative(process.cwd(), resolvedPath)}\n`);
+                }
+            }
+            snapshot.restored = true;
+            return true;
+        }
+        catch (error) {
+            process.stderr.write(`[ROLLBACK] Failed to restore ${resolvedPath}: ${error}\n`);
+            return false;
+        }
+    }
+    /**
+     * Clean up old snapshots.
+     */
+    cleanup(maxAgeMs = 300000) {
+        const cutoff = Date.now() - maxAgeMs;
+        for (const [filePath, snapshot] of this.snapshots) {
+            if (snapshot.timestamp < cutoff) {
+                this.snapshots.delete(filePath);
+            }
+        }
+    }
+    /**
+     * Get all active snapshots.
+     */
+    getAll() {
+        return Array.from(this.snapshots.values());
+    }
+}
+// ─── Auto-Rollback Engine ─────────────────────────────────────────
+export class AutoRollback {
+    static snapshots = new SnapshotManager();
+    /**
+     * Initialize the auto-rollback system.
+     * Sets up file watcher cleanup.
+     */
+    static initialize() {
+        // Periodic cleanup of old snapshots (every 5 minutes)
+        setInterval(() => {
+            AutoRollback.snapshots.cleanup();
+        }, 300000);
+    }
+    /**
+     * Prepare for a file write by capturing the current state.
+     * Call this BEFORE the tool handler writes to the file.
+     */
+    static prepareWrite(filePath, traceId) {
+        AutoRollback.snapshots.capture(filePath, traceId);
+    }
+    /**
+     * Validate content and rollback if violations are found.
+     * This is called after the tool handler writes the file, but
+     * BEFORE the response is returned to the AI.
+     *
+     * Returns:
+     *   - null if content is clean
+     *   - ViolationRecord[] if violations were found and rolled back
+     */
+    static validateAndRollback(filePath, content, violations) {
+        if (violations.length === 0)
+            return null;
+        // Restore the original file
+        const restored = AutoRollback.snapshots.restore(filePath);
+        if (restored) {
+            process.stderr.write(`[ROLLBACK] Rolled back ${path.relative(process.cwd(), filePath)} due to ${violations.length} violation(s)\n`);
+        }
+        return violations;
+    }
+    /**
+     * Build a regenerate instruction for the AI.
+     * This is what gets sent back to the AI to tell it to fix its output.
+     */
+    static buildRegenerateInstruction(violations, toolName) {
+        const criticalViolations = violations.filter(v => v.severity === "CRITICAL");
+        const lines = [
+            "## ⛔ AI Output Blocked – Governance Violation",
+            "",
+            `The code you generated for tool "${toolName}" has been BLOCKED and ROLLED BACK.`,
+            "The file has been restored to its previous state.",
+            "",
+        ];
+        if (criticalViolations.length > 0) {
+            lines.push(`### 🔴 Critical Violations (${criticalViolations.length})`);
+            lines.push("");
+            for (const v of criticalViolations) {
+                lines.push(`- **${v.rule}** (${v.filePath}:${v.line})`);
+                lines.push(`  - Detail: ${v.detail}`);
+                lines.push(`  - Fix: ${v.regenerateInstruction}`);
+                lines.push("");
+            }
+        }
+        const otherViolations = violations.filter(v => v.severity !== "CRITICAL");
+        if (otherViolations.length > 0) {
+            lines.push(`### 🟠 Other Violations (${otherViolations.length})`);
+            lines.push("");
+            for (const v of otherViolations) {
+                lines.push(`- **${v.rule}** (${v.filePath}:${v.line})`);
+                lines.push(`  - Detail: ${v.detail}`);
+                lines.push(`  - Fix: ${v.regenerateInstruction}`);
+                lines.push("");
+            }
+        }
+        lines.push("---");
+        lines.push("> **Instruction:** Please regenerate the code for this operation.");
+        lines.push("> Address ALL violations listed above.");
+        lines.push("> Do NOT reintroduce the same violations.");
+        return lines.join("\n");
+    }
+    /**
+     * Validate tool response content against governance rules.
+     * Used by the MCP middleware to check file write content before returning.
+     */
+    static checkWriteContent(filePath, content, traceId) {
+        const ext = path.extname(filePath).toLowerCase();
+        const violations = [];
+        // Only check source files
+        if (![".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".java", ".rs", ".swift", ".kt"].includes(ext)) {
+            return { allowed: true, violations: [], instruction: null };
+        }
+        const lines = content.split("\n");
+        // 1. Check for `any` type (CRITICAL)
+        if ([".ts", ".tsx"].includes(ext)) {
+            for (let i = 0; i < lines.length; i++) {
+                const anyMatch = lines[i].match(/:\s*any\b/);
+                if (anyMatch) {
+                    violations.push({
+                        rule: "No `any` Type",
+                        severity: "CRITICAL",
+                        filePath,
+                        line: i + 1,
+                        detail: `Line ${i + 1}: ${anyMatch[0].substring(0, 60)}`,
+                        regenerateInstruction: "Replace `any` with `unknown` and add proper type guards. Or use a specific interface/type.",
+                    });
+                }
+            }
+        }
+        // 2. Check for console.log (CRITICAL)
+        for (let i = 0; i < lines.length; i++) {
+            const consoleMatch = lines[i].match(/console\.(log|error|warn|debug)\s*\(/);
+            if (consoleMatch) {
+                // Check if file is exempt
+                if (!filePath.includes("logger.ts") && !filePath.includes("cli.ts") && !filePath.includes("compliance.ts")) {
+                    violations.push({
+                        rule: "No Console Log",
+                        severity: "CRITICAL",
+                        filePath,
+                        line: i + 1,
+                        detail: `Line ${i + 1}: ${consoleMatch[0].substring(0, 60)}`,
+                        regenerateInstruction: "Replace with the project's logger (import from the appropriate logger module).",
+                    });
+                }
+            }
+        }
+        // 3. Check for hardcoded secrets (HIGH)
+        const secretPatterns = [
+            { pattern: /(['"])sk-[a-zA-Z0-9]{20,}['"]/, name: "OpenAI API Key" },
+            { pattern: /(['"])ghp_[a-zA-Z0-9]{36,}['"]/, name: "GitHub Token" },
+            { pattern: /(['"])AIza[0-9A-Za-z_-]{35}['"]/, name: "Google API Key" },
+        ];
+        for (let i = 0; i < lines.length; i++) {
+            for (const { pattern, name } of secretPatterns) {
+                if (pattern.test(lines[i])) {
+                    violations.push({
+                        rule: `Hardcoded Secret: ${name}`,
+                        severity: "HIGH",
+                        filePath,
+                        line: i + 1,
+                        detail: `Potential ${name} hardcoded at line ${i + 1}`,
+                        regenerateInstruction: `Use environment variables (process.env.*) instead of hardcoding ${name}.`,
+                    });
+                }
+            }
+        }
+        // If violations found, prepare snapshot and rollback
+        if (violations.length > 0) {
+            AutoRollback.prepareWrite(filePath, traceId);
+            const rolledBack = AutoRollback.validateAndRollback(filePath, content, violations);
+            const instruction = AutoRollback.buildRegenerateInstruction(violations, "write_file");
+            return {
+                allowed: false,
+                violations: rolledBack || violations,
+                instruction,
+            };
+        }
+        return { allowed: true, violations: [], instruction: null };
+    }
+    /**
+     * Get snapshot stats.
+     */
+    static getSnapshotStats() {
+        const all = AutoRollback.snapshots.getAll();
+        return {
+            total: all.length,
+            restored: all.filter(s => s.restored).length,
+            pending: all.filter(s => !s.restored).length,
+        };
+    }
+}
+export { AutoRollback as AutoRollbackEngine };

package/framework-mcp/dist/framework-mcp/src/utils/compliance.js

@@ -53,7 +53,14 @@ export function verifyCorporateCompliance(content, filePath) {
                 }
                 // 5. Secure CLI Policy (No direct child_process)
                 if (moduleSpecifier.text === "child_process") {
-                    errors.push(`[ERROR] Corporate Compliance Breach: Direct 'child_process' usage is forbidden at line ${sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1}. Use secure framework APIs.`);
+                    const isExempt = filePath.includes("src/cli/commands/") ||
+                        filePath.includes("shared/fs.ts") ||
+                        filePath.includes("shared/lock.ts") ||
+                        filePath.includes("quality-gate.ts") ||
+                        filePath.includes("providers/shared.ts");
+                    if (!isExempt) {
+                        errors.push(`[ERROR] Corporate Compliance Breach: Direct 'child_process' usage is forbidden at line ${sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1}. Use secure framework APIs.`);
+                    }
                 }
             }
         }
@@ -75,10 +82,11 @@ export function verifyCorporateCompliance(content, filePath) {
             const prop = node.expression;
             if (ts.isIdentifier(prop.expression) && prop.expression.text === "fs") {
                 if (["writeFileSync", "appendFileSync"].includes(prop.name.text)) {
-                    // Lock files are exempt
+                    // Lock files, core atomic fs wrapper, and mcp configs are exempt
                     const args = node.arguments;
                     const firstArgText = args.length > 0 ? args[0].getText(sourceFile).toLowerCase() : "";
-                    if (!firstArgText.includes("lock")) {
+                    const isExemptFile = filePath.includes("shared/fs.ts") || filePath.includes("src/cli/commands/mcp.ts");
+                    if (!firstArgText.includes("lock") && !isExemptFile) {
                         errors.push(`[ERROR] Corporate Compliance Breach: Raw 'fs.${prop.name.text}' mutation detected at line ${sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1}. Use atomic utilities instead.`);
                     }
                 }
@@ -118,7 +126,7 @@ export function scanProjectCompliance(targetDir = "src") {
     const files = getAllFiles(targetDir);
     for (const file of files) {
         // Skip exempt files
-        if (file.includes("compliance") || file.includes("definitions") || file.includes("logger") || file.includes("cli/index.ts"))
+        if (file.includes("compliance") || file.includes("definitions") || file.includes("logger") || file.includes("cli/index.ts") || file.includes("shared/fs.ts") || file.includes("shared/lock.ts"))
             continue;
         const content = fs.readFileSync(file, "utf8");
         try {