atabey 0.0.15 → 0.0.17

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

@@ -1,300 +0,0 @@
-import ts from "typescript";
-import fs from "fs";
-import path from "path";
-import { resolveFrameworkDir } from "./security.js";
-/**
- * Enterprise Compliance Guardrail
- * Checks content against corporate standards using AST analysis before allowing file mutations.
- */
-export function verifyCorporateCompliance(content, filePath) {
-    // Skip compliance checks for non-source files or specific ignored files
-    if (filePath.endsWith(".json") || filePath.endsWith(".md") || filePath.endsWith(".env.example")) {
-        return;
-    }
-    const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
-    const errors = [];
-    /**
-     * Recursive AST Visitor
-     */
-    function visit(node) {
-        // 1. Zero Console Policy
-        if (ts.isPropertyAccessExpression(node)) {
-            const expression = node.expression;
-            const name = node.name.text;
-            if (ts.isIdentifier(expression) && expression.text === "console") {
-                if (["log", "warn", "error"].includes(name)) {
-                    // Check if file is exempt
-                    if (!filePath.includes("logger.ts") && !filePath.includes("check.ts") && !filePath.includes("cli.ts") && !filePath.includes("compliance.ts")) {
-                        errors.push(`[ERROR] Corporate Compliance Breach: 'console.${name}' usage is forbidden at line ${sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1}.`);
-                    }
-                }
-            }
-            // 2. Unsafe DOM Policy (Avoid XSS)
-            if (name === "innerHTML" || name === "outerHTML") {
-                errors.push(`[ERROR] Corporate Compliance Breach: Unsafe usage of '${name}' detected at line ${sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1}. Avoid XSS.`);
-            }
-        }
-        // 3. No Explicit Any Policy
-        if (ts.isTypeReferenceNode(node)) {
-            if (ts.isIdentifier(node.typeName) && node.typeName.text === "any") {
-                if (!filePath.includes("definitions.ts") && !filePath.includes("types.ts")) {
-                    errors.push(`[ERROR] Corporate Compliance Breach: 'any' type is forbidden at line ${sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1}.`);
-                }
-            }
-        }
-        // 4. Zero UI Library Policy
-        if (ts.isImportDeclaration(node)) {
-            const moduleSpecifier = node.moduleSpecifier;
-            if (ts.isStringLiteral(moduleSpecifier)) {
-                const forbiddenLibs = ["@chakra-ui", "mui", "@shadcn", "antd", "bootstrap"];
-                const lib = forbiddenLibs.find(l => moduleSpecifier.text.includes(l));
-                if (lib) {
-                    errors.push(`[ERROR] Corporate Compliance Breach: External UI library '${lib}' usage is FORBIDDEN at line ${sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1}. Build atomic components manually instead.`);
-                }
-                // 5. Secure CLI Policy (No direct child_process)
-                if (moduleSpecifier.text === "child_process") {
-                    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.`);
-                    }
-                }
-            }
-        }
-        // Handle 'any' as a keyword type
-        if (node.kind === ts.SyntaxKind.AnyKeyword) {
-            if (!filePath.includes("definitions.ts") && !filePath.includes("types.ts")) {
-                errors.push(`[ERROR] Corporate Compliance Breach: 'any' keyword is forbidden at line ${sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1}.`);
-            }
-        }
-        // 6. SQL Safety Policy (Kysely only)
-        if (ts.isTaggedTemplateExpression(node)) {
-            const tag = node.tag;
-            if (ts.isIdentifier(tag) && tag.text === "sql") {
-                errors.push(`[ERROR] Corporate Compliance Breach: Raw SQL tagged template detected at line ${sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1}. Use Kysely query builder.`);
-            }
-        }
-        // 7. Atomic FS Policy (No raw fs mutations)
-        if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
-            const prop = node.expression;
-            if (ts.isIdentifier(prop.expression) && prop.expression.text === "fs") {
-                if (["writeFileSync", "appendFileSync"].includes(prop.name.text)) {
-                    // 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() : "";
-                    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.`);
-                    }
-                }
-            }
-        }
-        ts.forEachChild(node, visit);
-    }
-    visit(sourceFile);
-    // 8. Hardcoded Secrets & PII Guard
-    const piiKeywords = [
-        { regex: /API_KEY\s*=\s*['"][^'"]+['"]/i, msg: "Hardcoded API Key" },
-        { regex: /SECRET\s*=\s*['"][^'"]+['"]/i, msg: "Hardcoded Secret" },
-        { regex: /PASSWORD\s*=\s*['"][^'"]+['"]/i, msg: "Hardcoded Password" },
-        { regex: /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/, msg: "PII Detected: Email Address" },
-        { regex: /\b\d{4}[- ]?\d{4}[- ]?\d{4}[- ]?\d{4}\b/, msg: "PII Detected: Credit Card Pattern" }
-    ];
-    for (const { regex, msg } of piiKeywords) {
-        if (regex.test(content)) {
-            if (msg.includes("Email") && (filePath.endsWith("README.md") || filePath.endsWith("package.json") || filePath.includes("CONTRIBUTING"))) {
-                continue;
-            }
-            errors.push(`[ERROR] Corporate Compliance Breach: ${msg} detected.`);
-        }
-    }
-    if (errors.length > 0) {
-        throw new Error(errors.join("\n"));
-    }
-}
-/**
- * Enterprise Compliance Scanner
- * Scans a directory for compliance issues.
- */
-export function scanProjectCompliance(targetDir = "src") {
-    const issues = [];
-    if (!fs.existsSync(targetDir))
-        return [];
-    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") || file.includes("shared/fs.ts") || file.includes("shared/lock.ts"))
-            continue;
-        const content = fs.readFileSync(file, "utf8");
-        try {
-            verifyCorporateCompliance(content, file);
-        }
-        catch (err) {
-            const errorLines = err.message.split("\n");
-            for (const errorLine of errorLines) {
-                const match = errorLine.match(/line (\d+)\./);
-                const line = match ? parseInt(match[1]) : 0;
-                issues.push({ file, line, rule: errorLine });
-            }
-        }
-        // Technical Debt (TODO/FIXME)
-        const lines = content.split("\n");
-        lines.forEach((line, index) => {
-            if (/\b(TODO|FIXME)\b/i.test(line)) {
-                issues.push({ file, line: index + 1, rule: "Unresolved Technical Debt (TODO/FIXME) found" });
-            }
-        });
-    }
-    return issues;
-}
-function getAllFiles(dirPath, arrayOfFiles = []) {
-    const files = fs.readdirSync(dirPath);
-    files.forEach((file) => {
-        const fullPath = path.join(dirPath, file);
-        if (fs.statSync(fullPath).isDirectory()) {
-            if (file !== "node_modules" && !file.startsWith(".")) {
-                arrayOfFiles = getAllFiles(fullPath, arrayOfFiles);
-            }
-        }
-        else {
-            const ext = path.extname(fullPath);
-            if ([".ts", ".tsx", ".js", ".jsx"].includes(ext)) {
-                arrayOfFiles.push(fullPath);
-            }
-        }
-    });
-    return arrayOfFiles;
-}
-export function isHighRiskOperation(content, filePath) {
-    const fileName = filePath.toLowerCase();
-    // 1. Database Deletions
-    if (fileName.endsWith(".sql") || fileName.endsWith(".ts") || fileName.endsWith(".js") || fileName.endsWith(".go")) {
-        const dropRegex = /\b(DROP\s+(DATABASE|TABLE|SCHEMA|VIEW|INDEX)|TRUNCATE\s+TABLE)\b/i;
-        if (dropRegex.test(content)) {
-            return { isRisk: true, reason: "Database structural deletion detected (DROP/TRUNCATE)" };
-        }
-    }
-    // 2. Package Updates
-    if (fileName.endsWith("package.json")) {
-        return { isRisk: true, reason: "Dependency/package update operation detected" };
-    }
-    // 3. Deployment Scripts
-    if (fileName.includes("deploy") ||
-        fileName.includes("dockerfile") ||
-        fileName.includes("docker-compose") ||
-        fileName.includes("k8s") ||
-        fileName.includes("github/workflows")) {
-        return { isRisk: true, reason: "Infrastructure or deployment script mutation detected" };
-    }
-    return { isRisk: false };
-}
-export async function verifyRiskAndAwaitApproval(projectRoot, content, filePath) {
-    const assessment = isHighRiskOperation(content, filePath);
-    if (!assessment.isRisk) {
-        return;
-    }
-    const frameworkDir = resolveFrameworkDir(projectRoot);
-    const absoluteFrameworkPath = path.isAbsolute(frameworkDir)
-        ? frameworkDir
-        : path.resolve(projectRoot, frameworkDir);
-    const statusPath = path.join(absoluteFrameworkPath, "memory", "status.json");
-    const statePath = path.join(absoluteFrameworkPath, "memory", "state.json");
-    const messagesDir = path.join(absoluteFrameworkPath, "messages");
-    const managerMsgPath = path.join(messagesDir, "manager.json");
-    let activeAgent = null;
-    let traceId = "UNKNOWN";
-    if (fs.existsSync(statePath)) {
-        try {
-            const state = JSON.parse(fs.readFileSync(statePath, "utf8"));
-            if (state && state.traceId)
-                traceId = state.traceId;
-        }
-        catch { /* ignore */ }
-    }
-    let statusData = {};
-    if (fs.existsSync(statusPath)) {
-        try {
-            statusData = JSON.parse(fs.readFileSync(statusPath, "utf8"));
-            for (const [agentName, info] of Object.entries(statusData)) {
-                if (info.state === "EXECUTING") {
-                    activeAgent = agentName.startsWith("@") ? agentName : `@${agentName}`;
-                    break;
-                }
-            }
-        }
-        catch { /* ignore */ }
-    }
-    if (!activeAgent)
-        throw new Error(`Security Exception: High-risk operation blocked. ${assessment.reason}.`);
-    const statusKey = activeAgent.replace("@", "");
-    const originalTask = statusData[statusKey]?.task || "Executing task";
-    statusData[statusKey] = {
-        state: "WAITING_FOR_APPROVAL",
-        task: `[PAUSED] Waiting for approval: ${assessment.reason} on ${filePath}`
-    };
-    try {
-        fs.writeFileSync(statusPath, JSON.stringify(statusData, null, 2));
-    }
-    catch { /* ignore */ }
-    if (!fs.existsSync(messagesDir))
-        fs.mkdirSync(messagesDir, { recursive: true });
-    const alertMsg = {
-        timestamp: new Date().toISOString(),
-        from: activeAgent,
-        to: "@manager",
-        category: "ALERT",
-        content: `High-risk operation: ${assessment.reason} on ${filePath}`,
-        traceId: traceId,
-        status: "PENDING",
-        priority: "HIGH",
-        requiresApproval: true,
-        action: `MUTATION:${filePath}`
-    };
-    try {
-        fs.appendFileSync(managerMsgPath, JSON.stringify(alertMsg) + "\n");
-    }
-    catch (err) {
-        statusData[statusKey] = { state: "EXECUTING", task: originalTask };
-        fs.writeFileSync(statusPath, JSON.stringify(statusData, null, 2));
-        throw new Error("Security Exception: Failed to queue approval request.", { cause: err });
-    }
-    const pollIntervalMs = 500;
-    const timeoutMs = 60000;
-    const start = Date.now();
-    while (Date.now() - start < timeoutMs) {
-        await new Promise(resolve => setTimeout(resolve, pollIntervalMs));
-        if (fs.existsSync(managerMsgPath)) {
-            try {
-                const lines = fs.readFileSync(managerMsgPath, "utf8").trim().split("\n");
-                for (const line of lines) {
-                    if (!line.trim())
-                        continue;
-                    const parsed = JSON.parse(line);
-                    if (parsed.traceId === traceId && parsed.category === "ALERT" && parsed.action === `MUTATION:${filePath}`) {
-                        if (parsed.status === "APPROVED") {
-                            statusData[statusKey] = { state: "EXECUTING", task: originalTask };
-                            fs.writeFileSync(statusPath, JSON.stringify(statusData, null, 2));
-                            return;
-                        }
-                        else if (parsed.status === "PROCESSED" || parsed.status === "DENIED") {
-                            throw new Error("Security Exception: High-risk operation was explicitly DENIED.");
-                        }
-                    }
-                }
-            }
-            catch (err) {
-                if (err.message.includes("explicitly DENIED"))
-                    throw err;
-            }
-        }
-    }
-    statusData[statusKey] = { state: "EXECUTING", task: originalTask };
-    try {
-        fs.writeFileSync(statusPath, JSON.stringify(statusData, null, 2));
-    }
-    catch { /* ignore */ }
-    throw new Error("Security Exception: High-risk operation timed out waiting for approval.");
-}

package/framework-mcp/dist/framework-mcp/src/utils/context-optimizer.js

@@ -1,156 +0,0 @@
-/**
- * ─── CONTEXT OPTIMIZER ─────────────────────────────────────────────
- *
- * Prevents context poisoning and runaway token consumption by AI CLIs.
- * Acts as a Circuit Breaker at the MCP middleware layer.
- *
- * Features:
- * - Token Budget Enforcer: Max tokens per tool call response
- * - File Read Limiter: Auto-truncate large file reads
- * - Token-Based Rate Limiter: Max token spend per window
- * - Response Size Governor: Truncates oversized responses
- *
- * [KVKK/GDPR] Also prevents PII leakage via oversized responses.
- */
-// ─── Configuration ────────────────────────────────────────────────
-const CONFIG = {
-    /** Max tokens allowed in a single tool response */
-    MAX_TOKENS_PER_CALL: parseInt(process.env.MCP_MAX_TOKENS_PER_CALL || "4000", 10),
-    /** Max tokens per minute across all calls for an agent */
-    MAX_TOKENS_PER_MINUTE: parseInt(process.env.MCP_MAX_TOKENS_PER_MINUTE || "20000", 10),
-    /** Max tokens per hour across all calls for an agent */
-    MAX_TOKENS_PER_HOUR: parseInt(process.env.MCP_MAX_TOKENS_PER_HOUR || "100000", 10),
-    /** Max file size in bytes before auto-truncation (100KB) */
-    MAX_FILE_READ_SIZE: parseInt(process.env.MCP_MAX_FILE_READ_SIZE || "102400", 10),
-    /** Max lines to return for truncated files */
-    MAX_FILE_LINES: parseInt(process.env.MCP_MAX_FILE_LINES || "200", 10),
-    /** Token estimation ratio (chars per token) */
-    CHARS_PER_TOKEN: 4,
-};
-const agentBudgets = new Map();
-function getOrCreateBudget(agent) {
-    if (!agentBudgets.has(agent)) {
-        agentBudgets.set(agent, {
-            records: [],
-            totalTokens: 0,
-            lastWarning: 0,
-            blockedUntil: null,
-        });
-    }
-    return agentBudgets.get(agent);
-}
-function pruneOldRecords(agent) {
-    const oneHourAgo = Date.now() - 3600000;
-    agent.records = agent.records.filter(r => r.timestamp > oneHourAgo);
-}
-function sumTokensInWindow(agent, windowMs) {
-    const cutoff = Date.now() - windowMs;
-    return agent.records
-        .filter(r => r.timestamp > cutoff)
-        .reduce((sum, r) => sum + r.tokens, 0);
-}
-/**
- * Estimate token count from text.
- * Uses 4 chars per token as a conservative estimate.
- */
-export function estimateTokens(text) {
-    if (!text)
-        return 0;
-    return Math.ceil(text.length / CONFIG.CHARS_PER_TOKEN);
-}
-/**
- * Check if a tool response is within token budget.
- * Returns null if allowed, or an error message if blocked.
- */
-export function checkTokenBudget(agent, toolName, responseText) {
-    const budget = getOrCreateBudget(agent);
-    // Check if agent is currently blocked
-    if (budget.blockedUntil && Date.now() < budget.blockedUntil) {
-        const remaining = Math.ceil((budget.blockedUntil - Date.now()) / 1000);
-        return `[TOKEN BUDGET] Agent ${agent} is blocked for ${remaining}s. Token limit exceeded.`;
-    }
-    const estimatedTokens = estimateTokens(responseText);
-    // 1. Check per-call limit
-    if (estimatedTokens > CONFIG.MAX_TOKENS_PER_CALL) {
-        return `[TOKEN BUDGET] Response too large: ~${estimatedTokens} tokens (max: ${CONFIG.MAX_TOKENS_PER_CALL}). Truncate your request.`;
-    }
-    // Record the token usage
-    budget.records.push({
-        tokens: estimatedTokens,
-        timestamp: Date.now(),
-        toolName,
-    });
-    budget.totalTokens += estimatedTokens;
-    // Prune old records
-    pruneOldRecords(budget);
-    // 2. Check per-minute limit
-    const minuteTokens = sumTokensInWindow(budget, 60000);
-    if (minuteTokens > CONFIG.MAX_TOKENS_PER_MINUTE) {
-        budget.blockedUntil = Date.now() + 30000; // 30s cooldown
-        return `[TOKEN BUDGET] Agent ${agent} exceeded ${CONFIG.MAX_TOKENS_PER_MINUTE} tokens/min. Cooldown 30s.`;
-    }
-    // 3. Check per-hour limit
-    const hourTokens = sumTokensInWindow(budget, 3600000);
-    if (hourTokens > CONFIG.MAX_TOKENS_PER_HOUR) {
-        budget.blockedUntil = Date.now() + 120000; // 2min cooldown
-        return `[TOKEN BUDGET] Agent ${agent} exceeded ${CONFIG.MAX_TOKENS_PER_HOUR} tokens/hour. Cooldown 2min.`;
-    }
-    // 4. Warning at 80% of per-minute limit
-    if (minuteTokens > CONFIG.MAX_TOKENS_PER_MINUTE * 0.8) {
-        const now = Date.now();
-        if (now - budget.lastWarning > 10000) { // Throttle warnings to once per 10s
-            budget.lastWarning = now;
-            process.stderr.write(`[TOKEN BUDGET WARNING] Agent ${agent} at ${Math.round(minuteTokens / CONFIG.MAX_TOKENS_PER_MINUTE * 100)}% of minute token budget.\n`);
-        }
-    }
-    return null;
-}
-/**
- * Truncate file content to fit within token budget.
- * Returns truncated content with a header note.
- */
-export function truncateFileContent(content, filePath, maxTokens = CONFIG.MAX_TOKENS_PER_CALL) {
-    const estimatedTokens = estimateTokens(content);
-    if (estimatedTokens <= maxTokens)
-        return content;
-    const lines = content.split("\n");
-    const maxLines = Math.min(CONFIG.MAX_FILE_LINES, Math.floor(maxTokens * CONFIG.CHARS_PER_TOKEN / 80));
-    const truncated = lines.slice(0, maxLines).join("\n");
-    const remaining = lines.length - maxLines;
-    return `[TRUNCATED] File "${filePath}" is too large (~${estimatedTokens} tokens). Showing first ${maxLines}/${lines.length} lines.\n\n${truncated}\n\n[... ${remaining} more lines truncated. Use grep_search for targeted queries.]`;
-}
-/**
- * Get token budget stats for an agent.
- */
-export function getTokenBudgetStats(agent) {
-    const budget = agentBudgets.get(agent);
-    if (!budget) {
-        return { totalTokens: 0, recentMinute: 0, recentHour: 0, blocked: false, blockedRemaining: 0, callCount: 0 };
-    }
-    pruneOldRecords(budget);
-    return {
-        totalTokens: budget.totalTokens,
-        recentMinute: sumTokensInWindow(budget, 60000),
-        recentHour: sumTokensInWindow(budget, 3600000),
-        blocked: budget.blockedUntil !== null && Date.now() < budget.blockedUntil,
-        blockedRemaining: budget.blockedUntil ? Math.max(0, budget.blockedUntil - Date.now()) : 0,
-        callCount: budget.records.length,
-    };
-}
-/**
- * Get all agents' token budget stats.
- */
-export function getAllTokenBudgetStats() {
-    const stats = {};
-    for (const [agent] of agentBudgets) {
-        stats[agent] = getTokenBudgetStats(agent);
-    }
-    return stats;
-}
-/**
- * Reset all token budgets.
- */
-export function resetTokenBudgets() {
-    agentBudgets.clear();
-}
-export { CONFIG as TokenBudgetConfig };

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

@@ -1,217 +0,0 @@
-/**
- * ─── AI DISCIPLINE ENGINE ─────────────────────────────────────────
- *
- * Enforces strict rules on AI behavior at the MCP middleware layer.
- * Unlike agent instructions (which AI can ignore), these are enforced
- * at the tool level - AI cannot bypass them.
- *
- * Features:
- * - Tool call rate limiting (prevents abuse)
- * - File size limits (prevents reading/writing huge files)
- * - Call frequency tracking (detects loops)
- * - Tool blacklist per agent
- * - Agent-based tool whitelist
- * - Response content validation
- * - Max concurrent operations
- */
-import fs from "fs";
-import path from "path";
-// Per-agent discipline tracking
-const agentDiscipline = new Map();
-// ─── Configuration (from env or defaults) ─────────────────────────
-const CONFIG = {
-    MAX_CALLS_PER_MINUTE: parseInt(process.env.MCP_MAX_CALLS_PER_MINUTE || "60", 10),
-    MAX_TOTAL_CALLS: parseInt(process.env.MCP_MAX_TOTAL_CALLS || "500", 10),
-    MAX_FILE_SIZE: parseInt(process.env.MCP_MAX_FILE_SIZE || "1048576", 10),
-    MAX_ARGS_SIZE: parseInt(process.env.MCP_MAX_ARGS_SIZE || "102400", 10),
-    COOLDOWN_MS: parseInt(process.env.MCP_COOLDOWN_MS || "30000", 10),
-    MAX_RESPONSE_SIZE: parseInt(process.env.MCP_MAX_RESPONSE_SIZE || "512000", 10), // 500KB max response
-    MAX_CONSECUTIVE_SAME_TOOL: parseInt(process.env.MCP_MAX_CONSECUTIVE_SAME_TOOL || "10", 10),
-    RESTRICTED_TOOLS: (process.env.MCP_RESTRICTED_TOOLS || "")
-        .split(",").map(t => t.trim()).filter(Boolean),
-    // Agent-based tool whitelist (format: agent1:tool1,tool2;agent2:tool3,tool4)
-    AGENT_TOOL_WHITELIST: parseAgentWhitelist(process.env.MCP_AGENT_TOOL_WHITELIST || ""),
-};
-function parseAgentWhitelist(input) {
-    const map = new Map();
-    if (!input)
-        return map;
-    input.split(";").forEach(pair => {
-        const [agent, tools] = pair.split(":");
-        if (agent && tools) {
-            map.set(agent.trim(), new Set(tools.split(",").map(t => t.trim())));
-        }
-    });
-    return map;
-}
-const cooldowns = new Map();
-function getOrCreateAgent(agent) {
-    if (!agentDiscipline.has(agent)) {
-        const whitelist = CONFIG.AGENT_TOOL_WHITELIST.get(agent) || null;
-        agentDiscipline.set(agent, {
-            totalCalls: 0,
-            calls: [],
-            lastReset: Date.now(),
-            blacklistedTools: new Set(),
-            whitelistedTools: whitelist,
-            violations: 0,
-            lastViolation: null,
-        });
-    }
-    return agentDiscipline.get(agent);
-}
-function pruneOldCalls(agent, windowMs = 60000) {
-    const cutoff = Date.now() - windowMs;
-    agent.calls = agent.calls.filter(c => c.timestamp > cutoff);
-}
-function isInCooldown(agent) {
-    const until = cooldowns.get(agent);
-    if (!until)
-        return false;
-    if (Date.now() > until) {
-        cooldowns.delete(agent);
-        return false;
-    }
-    return true;
-}
-function recordViolation(agent, reason) {
-    const discipline = agentDiscipline.get(agent);
-    if (discipline) {
-        discipline.violations++;
-        discipline.lastViolation = reason;
-    }
-}
-/**
- * Enforce discipline on a tool call before execution.
- * Returns error message if blocked, null if allowed.
- */
-export async function enforceDiscipline(agent, toolName, args) {
-    const discipline = getOrCreateAgent(agent);
-    // 1. Check cooldown
-    if (isInCooldown(agent)) {
-        const until = cooldowns.get(agent);
-        const remaining = Math.ceil((until - Date.now()) / 1000);
-        return `[DISCIPLINE] Agent ${agent} is in cooldown for ${remaining}s. Too many requests.`;
-    }
-    // 2. Check restricted tools (global blacklist)
-    if (CONFIG.RESTRICTED_TOOLS.includes(toolName)) {
-        recordViolation(agent, `Attempted to use restricted tool: ${toolName}`);
-        return `[DISCIPLINE] Tool "${toolName}" is restricted. Agent ${agent} cannot use it.`;
-    }
-    // 3. Check agent-specific whitelist
-    if (discipline.whitelistedTools && !discipline.whitelistedTools.has(toolName)) {
-        recordViolation(agent, `Attempted to use non-whitelisted tool: ${toolName}`);
-        const allowed = Array.from(discipline.whitelistedTools).join(", ");
-        return `[DISCIPLINE] Agent ${agent} is not allowed to use "${toolName}". Allowed tools: ${allowed}`;
-    }
-    // 4. Check total call limit
-    if (discipline.totalCalls >= CONFIG.MAX_TOTAL_CALLS) {
-        cooldowns.set(agent, Date.now() + CONFIG.COOLDOWN_MS);
-        recordViolation(agent, `Exceeded max total calls (${CONFIG.MAX_TOTAL_CALLS})`);
-        return `[DISCIPLINE] Agent ${agent} exceeded max total calls (${CONFIG.MAX_TOTAL_CALLS}). Cooldown ${CONFIG.COOLDOWN_MS / 1000}s.`;
-    }
-    // 5. Check rate limit (calls per minute)
-    pruneOldCalls(discipline);
-    if (discipline.calls.length >= CONFIG.MAX_CALLS_PER_MINUTE) {
-        cooldowns.set(agent, Date.now() + CONFIG.COOLDOWN_MS);
-        recordViolation(agent, `Rate limit exceeded (${CONFIG.MAX_CALLS_PER_MINUTE}/min)`);
-        return `[DISCIPLINE] Agent ${agent} exceeded rate limit (${CONFIG.MAX_CALLS_PER_MINUTE}/min). Cooldown ${CONFIG.COOLDOWN_MS / 1000}s.`;
-    }
-    // 6. Check consecutive same tool (prevents loops)
-    if (discipline.calls.length >= CONFIG.MAX_CONSECUTIVE_SAME_TOOL) {
-        const lastCalls = discipline.calls.slice(-CONFIG.MAX_CONSECUTIVE_SAME_TOOL);
-        const allSame = lastCalls.every(c => c.tool === toolName);
-        if (allSame) {
-            cooldowns.set(agent, Date.now() + CONFIG.COOLDOWN_MS);
-            recordViolation(agent, `Consecutive same tool limit: ${toolName} x${CONFIG.MAX_CONSECUTIVE_SAME_TOOL}`);
-            return `[DISCIPLINE] Agent ${agent} called "${toolName}" ${CONFIG.MAX_CONSECUTIVE_SAME_TOOL} times in a row. Possible loop. Cooldown.`;
-        }
-    }
-    // 7. Check args size
-    const argsStr = JSON.stringify(args);
-    if (argsStr.length > CONFIG.MAX_ARGS_SIZE) {
-        recordViolation(agent, `Args too large: ${argsStr.length} bytes`);
-        return `[DISCIPLINE] Tool call args too large (${argsStr.length} bytes, max: ${CONFIG.MAX_ARGS_SIZE}).`;
-    }
-    // 8. Check file size for read/write operations
-    if ((toolName === "read_file" || toolName === "write_file") && args.path) {
-        try {
-            const projectRoot = process.env.ATABEY_PROJECT_ROOT || process.cwd();
-            const filePath = path.resolve(projectRoot, args.path);
-            if (fs.existsSync(filePath)) {
-                const stat = fs.statSync(filePath);
-                if (stat.size > CONFIG.MAX_FILE_SIZE) {
-                    return `[DISCIPLINE] File too large (${(stat.size / 1024 / 1024).toFixed(1)}MB, max: ${(CONFIG.MAX_FILE_SIZE / 1024 / 1024).toFixed(1)}MB). Use grep_search instead.`;
-                }
-            }
-        }
-        catch { /* ignore */ }
-    }
-    // Record the call
-    discipline.totalCalls++;
-    discipline.calls.push({
-        tool: toolName,
-        timestamp: Date.now(),
-        argsSize: argsStr.length,
-    });
-    return null;
-}
-/**
- * Validate tool response content before returning to AI.
- * Returns error message if blocked, null if allowed.
- */
-export function validateResponse(toolName, result) {
-    if (!result || !result.content)
-        return null;
-    for (const block of result.content) {
-        if (block.type !== "text" || !block.text)
-            continue;
-        // Check response size
-        if (block.text.length > CONFIG.MAX_RESPONSE_SIZE) {
-            return `[DISCIPLINE] Response too large (${(block.text.length / 1024).toFixed(1)}KB, max: ${(CONFIG.MAX_RESPONSE_SIZE / 1024).toFixed(1)}KB).`;
-        }
-        // Block binary/gibberish content in text responses
-        const nonPrintable = (block.text.match(/[^\x20-\x7E\n\r\t]/g) || []).length;
-        if (nonPrintable > block.text.length * 0.3) {
-            return `[DISCIPLINE] Response contains too much binary data (${nonPrintable} non-printable chars). Blocked.`;
-        }
-    }
-    return null;
-}
-/**
- * Get discipline stats for an agent.
- */
-export function getDisciplineStats(agent) {
-    const discipline = agentDiscipline.get(agent);
-    if (!discipline) {
-        return { totalCalls: 0, recentCalls: 0, inCooldown: false, cooldownRemaining: 0, violations: 0, lastViolation: null };
-    }
-    pruneOldCalls(discipline);
-    const cooldownUntil = cooldowns.get(agent);
-    return {
-        totalCalls: discipline.totalCalls,
-        recentCalls: discipline.calls.length,
-        inCooldown: isInCooldown(agent),
-        cooldownRemaining: cooldownUntil ? Math.max(0, cooldownUntil - Date.now()) : 0,
-        violations: discipline.violations,
-        lastViolation: discipline.lastViolation,
-    };
-}
-/**
- * Get all agents' discipline stats.
- */
-export function getAllDisciplineStats() {
-    const stats = {};
-    for (const [agent] of agentDiscipline) {
-        stats[agent] = getDisciplineStats(agent);
-    }
-    return stats;
-}
-/**
- * Reset discipline for all agents.
- */
-export function resetDiscipline() {
-    agentDiscipline.clear();
-    cooldowns.clear();
-}
-export { CONFIG as DisciplineConfig };