sentinelflow 0.2.0 → 0.2.1

package/dist/bundle.js

@@ -0,0 +1,4784 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+"use strict";
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// packages/core/dist/schema/agent.js
+var require_agent = __commonJS({
+  "packages/core/dist/schema/agent.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.createAgent = createAgent;
+    function createAgent(params) {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      return {
+        id: params.id ?? generateId(),
+        name: params.name,
+        description: params.description ?? "",
+        framework: params.framework,
+        framework_id: params.framework_id,
+        owner: params.owner,
+        team: params.team,
+        created_at: params.created_at ?? now,
+        updated_at: params.updated_at ?? now,
+        source_file: params.source_file,
+        repository: params.repository,
+        tools: params.tools ?? [],
+        allowed_tools: params.allowed_tools,
+        blocked_tools: params.blocked_tools,
+        model: params.model,
+        model_routing: params.model_routing,
+        mcp_servers: params.mcp_servers,
+        data_sources: params.data_sources ?? [],
+        data_classification: params.data_classification,
+        file_system_access: params.file_system_access,
+        network_access: params.network_access,
+        delegates_to: params.delegates_to,
+        delegated_from: params.delegated_from,
+        swarm_role: params.swarm_role ?? "standalone",
+        topology: params.topology ?? "standalone",
+        governance: params.governance ?? {
+          status: "discovered"
+        },
+        runtime: params.runtime
+      };
+    }
+    function generateId() {
+      return "sf-" + crypto.randomUUID();
+    }
+  }
+});
+
+// packages/core/dist/schema/finding.js
+var require_finding = __commonJS({
+  "packages/core/dist/schema/finding.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.createScanReport = createScanReport;
+    function createScanReport(rootDir, findings, frameworksDetected, agentsDiscovered, durationMs) {
+      const summary = {
+        critical: findings.filter((f) => f.severity === "critical").length,
+        high: findings.filter((f) => f.severity === "high").length,
+        medium: findings.filter((f) => f.severity === "medium").length,
+        low: findings.filter((f) => f.severity === "low").length,
+        info: findings.filter((f) => f.severity === "info").length,
+        total: findings.length
+      };
+      return {
+        id: `scan-${Date.now()}`,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        root_dir: rootDir,
+        duration_ms: durationMs,
+        frameworks_detected: frameworksDetected,
+        agents_discovered: agentsDiscovered,
+        findings,
+        summary
+      };
+    }
+  }
+});
+
+// packages/core/dist/schema/event.js
+var require_event = __commonJS({
+  "packages/core/dist/schema/event.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+  }
+});
+
+// packages/core/dist/registry/local.js
+var require_local = __commonJS({
+  "packages/core/dist/registry/local.js"(exports2) {
+    "use strict";
+    var __createBinding2 = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault2 = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar2 = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding2(result, mod, k[i]);
+        }
+        __setModuleDefault2(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.LocalRegistry = void 0;
+    var fs = __importStar2(require("fs"));
+    var path = __importStar2(require("path"));
+    var SF_DIR = ".sentinelflow";
+    var AGENTS_FILE = "agents.json";
+    var REPORTS_FILE = "reports.json";
+    var EVENTS_FILE = "events.json";
+    var MAX_REPORTS = 50;
+    var MAX_EVENTS = 1e4;
+    function atomicWriteSync(filePath, data) {
+      const tmpPath = filePath + ".tmp." + process.pid;
+      try {
+        fs.writeFileSync(tmpPath, data, "utf-8");
+        fs.renameSync(tmpPath, filePath);
+      } catch (error) {
+        try {
+          if (fs.existsSync(tmpPath)) {
+            fs.unlinkSync(tmpPath);
+          }
+        } catch {
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to write ${filePath}: ${message}`);
+      }
+    }
+    function safeReadJSON(filePath, fallback) {
+      try {
+        if (!fs.existsSync(filePath)) {
+          return fallback;
+        }
+        const raw = fs.readFileSync(filePath, "utf-8");
+        if (raw.trim() === "") {
+          return fallback;
+        }
+        return JSON.parse(raw);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(`Warning: Could not read ${filePath}: ${message}. Using defaults.`);
+        return fallback;
+      }
+    }
+    var LocalRegistry = class {
+      basePath;
+      agents = /* @__PURE__ */ new Map();
+      reports = [];
+      events = [];
+      initialized = false;
+      constructor(projectRoot) {
+        this.basePath = path.join(projectRoot, SF_DIR);
+      }
+      // ─── Lifecycle ────────────────────────────────────────────
+      async initialize() {
+        if (this.initialized)
+          return;
+        if (!fs.existsSync(this.basePath)) {
+          fs.mkdirSync(this.basePath, { recursive: true });
+        }
+        const agentsData = safeReadJSON(path.join(this.basePath, AGENTS_FILE), []);
+        for (const agent of agentsData) {
+          this.agents.set(agent.id, agent);
+        }
+        this.reports = safeReadJSON(path.join(this.basePath, REPORTS_FILE), []);
+        this.events = safeReadJSON(path.join(this.basePath, EVENTS_FILE), []);
+        this.initialized = true;
+      }
+      async close() {
+        if (!this.initialized)
+          return;
+        this.persistAll();
+        this.initialized = false;
+      }
+      // ─── Persistence ──────────────────────────────────────────
+      persistAgents() {
+        atomicWriteSync(path.join(this.basePath, AGENTS_FILE), JSON.stringify([...this.agents.values()], null, 2));
+      }
+      persistReports() {
+        atomicWriteSync(path.join(this.basePath, REPORTS_FILE), JSON.stringify(this.reports, null, 2));
+      }
+      persistAll() {
+        this.persistAgents();
+        this.persistReports();
+      }
+      ensureInitialized() {
+        if (!this.initialized) {
+          throw new Error("Registry not initialized. Call initialize() before using the registry.");
+        }
+      }
+      // ─── Agent CRUD ───────────────────────────────────────────
+      async upsertAgent(agent) {
+        this.ensureInitialized();
+        agent.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+        this.agents.set(agent.id, agent);
+        this.persistAgents();
+      }
+      async getAgent(id) {
+        this.ensureInitialized();
+        return this.agents.get(id) ?? null;
+      }
+      async getAgentByName(name, framework) {
+        this.ensureInitialized();
+        for (const agent of this.agents.values()) {
+          if (agent.name === name && agent.framework === framework) {
+            return agent;
+          }
+        }
+        return null;
+      }
+      async listAgents(options) {
+        this.ensureInitialized();
+        let agents = [...this.agents.values()];
+        if (options?.framework) {
+          agents = agents.filter((a) => a.framework === options.framework);
+        }
+        if (options?.status) {
+          agents = agents.filter((a) => a.governance.status === options.status);
+        }
+        if (options?.risk_level) {
+          agents = agents.filter((a) => a.governance.risk_level === options.risk_level);
+        }
+        if (options?.owner) {
+          agents = agents.filter((a) => a.owner === options.owner);
+        }
+        if (options?.team) {
+          agents = agents.filter((a) => a.team === options.team);
+        }
+        const offset = options?.offset ?? 0;
+        const limit = options?.limit ?? 100;
+        return agents.slice(offset, offset + limit);
+      }
+      async deleteAgent(id) {
+        this.ensureInitialized();
+        if (!this.agents.has(id)) {
+          throw new Error(`Agent not found: ${id}`);
+        }
+        this.agents.delete(id);
+        this.persistAgents();
+      }
+      async countAgents() {
+        this.ensureInitialized();
+        return this.agents.size;
+      }
+      // ─── Findings ─────────────────────────────────────────────
+      async storeScanReport(report) {
+        this.ensureInitialized();
+        this.reports.push(report);
+        if (this.reports.length > MAX_REPORTS) {
+          this.reports = this.reports.slice(-MAX_REPORTS);
+        }
+        this.persistReports();
+      }
+      async getLatestScanReport() {
+        this.ensureInitialized();
+        if (this.reports.length === 0)
+          return null;
+        return this.reports[this.reports.length - 1] ?? null;
+      }
+      async listFindings(agentId) {
+        this.ensureInitialized();
+        const latest = await this.getLatestScanReport();
+        if (!latest)
+          return [];
+        if (agentId) {
+          return latest.findings.filter((f) => f.agent_id === agentId);
+        }
+        return latest.findings;
+      }
+      // ─── Events (Phase 2) ────────────────────────────────────
+      async ingestEvents(events) {
+        this.ensureInitialized();
+        this.events.push(...events);
+        if (this.events.length > MAX_EVENTS) {
+          this.events = this.events.slice(-MAX_EVENTS);
+        }
+      }
+      async queryEvents(agentId, limit = 100) {
+        this.ensureInitialized();
+        return this.events.filter((e) => e.agent_id === agentId).slice(-limit);
+      }
+    };
+    exports2.LocalRegistry = LocalRegistry;
+  }
+});
+
+// packages/core/dist/index.js
+var require_dist = __commonJS({
+  "packages/core/dist/index.js"(exports2) {
+    "use strict";
+    var __createBinding2 = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding2(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.LocalRegistry = void 0;
+    __exportStar(require_agent(), exports2);
+    __exportStar(require_finding(), exports2);
+    __exportStar(require_event(), exports2);
+    var local_1 = require_local();
+    Object.defineProperty(exports2, "LocalRegistry", { enumerable: true, get: function() {
+      return local_1.LocalRegistry;
+    } });
+  }
+});
+
+// packages/parsers/dist/claude-code.js
+var require_claude_code = __commonJS({
+  "packages/parsers/dist/claude-code.js"(exports2) {
+    "use strict";
+    var __createBinding2 = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault2 = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar2 = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding2(result, mod, k[i]);
+        }
+        __setModuleDefault2(result, mod);
+        return result;
+      };
+    })();
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.ClaudeCodeParser = void 0;
+    var fs = __importStar2(require("fs"));
+    var path = __importStar2(require("path"));
+    var gray_matter_1 = __importDefault(require("gray-matter"));
+    var core_1 = require_dist();
+    function safeReadFile(filePath) {
+      try {
+        if (!fs.existsSync(filePath))
+          return null;
+        return fs.readFileSync(filePath, "utf-8");
+      } catch (error) {
+        return null;
+      }
+    }
+    function safeParseJSON(content, filePath) {
+      try {
+        return JSON.parse(content);
+      } catch (error) {
+        return null;
+      }
+    }
+    function safeListDir(dirPath, extensions) {
+      try {
+        if (!fs.existsSync(dirPath) || !fs.statSync(dirPath).isDirectory()) {
+          return [];
+        }
+        return fs.readdirSync(dirPath).filter((f) => extensions.some((ext) => f.endsWith(ext)));
+      } catch {
+        return [];
+      }
+    }
+    var ClaudeCodeParser = class {
+      framework = "claude-code";
+      displayName = "Claude Code";
+      markers = [".claude", "CLAUDE.md", "AGENTS.md"];
+      async detect(rootDir) {
+        return fs.existsSync(path.join(rootDir, ".claude")) || fs.existsSync(path.join(rootDir, "CLAUDE.md")) || fs.existsSync(path.join(rootDir, "AGENTS.md"));
+      }
+      async parse(rootDir) {
+        const agents = [];
+        const configFiles = [];
+        const warnings = [];
+        this.parseSettingsFile(rootDir, agents, configFiles, warnings);
+        this.parseAgentsDirectory(rootDir, agents, configFiles, warnings);
+        this.collectConfigFile(path.join(rootDir, "CLAUDE.md"), configFiles);
+        this.collectConfigFile(path.join(rootDir, "AGENTS.md"), configFiles);
+        this.collectConfigFile(path.join(rootDir, "hooks", "hooks.json"), configFiles);
+        const commandsDir = path.join(rootDir, ".claude", "commands");
+        for (const file of safeListDir(commandsDir, [".md"])) {
+          this.collectConfigFile(path.join(commandsDir, file), configFiles);
+        }
+        const claudeAgentsDir = path.join(rootDir, ".claude", "agents");
+        for (const file of safeListDir(claudeAgentsDir, [".md"])) {
+          const filePath = path.join(claudeAgentsDir, file);
+          const content = safeReadFile(filePath);
+          if (content !== null) {
+            configFiles.push({ path: filePath, content, framework: "claude-code" });
+            const agent = this.parseAgentMarkdown(content, filePath, warnings);
+            if (agent)
+              agents.push(agent);
+          }
+        }
+        if (agents.length === 0 && configFiles.length > 0) {
+          agents.push((0, core_1.createAgent)({
+            name: "claude-code-default",
+            framework: "claude-code",
+            description: "Default Claude Code agent for this project",
+            source_file: configFiles[0]?.path,
+            swarm_role: "standalone"
+          }));
+        }
+        return { agents, config_files: configFiles, warnings };
+      }
+      // ─── Private: Parse .claude/settings.json ───────────────────
+      parseSettingsFile(rootDir, agents, configFiles, warnings) {
+        const settingsPath = path.join(rootDir, ".claude", "settings.json");
+        const content = safeReadFile(settingsPath);
+        if (content === null)
+          return;
+        configFiles.push({ path: settingsPath, content, framework: "claude-code" });
+        const settings = safeParseJSON(content, settingsPath);
+        if (settings === null) {
+          warnings.push(`Invalid JSON in ${settingsPath}`);
+          return;
+        }
+        const allowedTools = Array.isArray(settings.allowedTools) ? settings.allowedTools : [];
+        const blockedTools = Array.isArray(settings.blockedTools) ? settings.blockedTools : [];
+        const mcpServers = [];
+        if (settings.mcpServers && typeof settings.mcpServers === "object") {
+          for (const [name, config] of Object.entries(settings.mcpServers)) {
+            mcpServers.push({
+              name,
+              url: typeof config.url === "string" ? config.url : void 0,
+              tools_exposed: Array.isArray(config.tools) ? config.tools : void 0
+            });
+          }
+        }
+        const tools = allowedTools.map((t) => this.classifyTool(t));
+        agents.push((0, core_1.createAgent)({
+          name: "claude-code-project",
+          framework: "claude-code",
+          description: "Project-level Claude Code configuration from settings.json",
+          source_file: settingsPath,
+          tools,
+          allowed_tools: allowedTools.length > 0 ? allowedTools : void 0,
+          blocked_tools: blockedTools.length > 0 ? blockedTools : void 0,
+          mcp_servers: mcpServers.length > 0 ? mcpServers : void 0,
+          swarm_role: "standalone"
+        }));
+        const localSettingsPath = path.join(rootDir, ".claude", "settings.local.json");
+        const localContent = safeReadFile(localSettingsPath);
+        if (localContent !== null) {
+          configFiles.push({
+            path: localSettingsPath,
+            content: localContent,
+            framework: "claude-code"
+          });
+        }
+      }
+      // ─── Private: Parse agents/ directory ───────────────────────
+      parseAgentsDirectory(rootDir, agents, configFiles, warnings) {
+        const agentsDir = path.join(rootDir, "agents");
+        const files = safeListDir(agentsDir, [".md", ".yaml", ".yml"]);
+        for (const file of files) {
+          const filePath = path.join(agentsDir, file);
+          const content = safeReadFile(filePath);
+          if (content === null)
+            continue;
+          configFiles.push({ path: filePath, content, framework: "claude-code" });
+          const agent = this.parseAgentMarkdown(content, filePath, warnings);
+          if (agent)
+            agents.push(agent);
+        }
+      }
+      // ─── Private: Parse a single agent Markdown file ────────────
+      parseAgentMarkdown(content, filePath, warnings) {
+        if (content.trim().length === 0) {
+          warnings.push(`Empty file: ${filePath}`);
+          return null;
+        }
+        let frontmatterData = {};
+        let bodyContent = content;
+        try {
+          const parsed = (0, gray_matter_1.default)(content);
+          frontmatterData = parsed.data;
+          bodyContent = parsed.content;
+        } catch (error) {
+          const name2 = path.basename(filePath, path.extname(filePath));
+          warnings.push(`Could not parse frontmatter in ${filePath}: ${error instanceof Error ? error.message : String(error)}. Using filename as agent name.`);
+          return (0, core_1.createAgent)({
+            name: name2,
+            framework: "claude-code",
+            description: bodyContent.slice(0, 200).trim(),
+            source_file: filePath
+          });
+        }
+        const name = typeof frontmatterData.name === "string" ? frontmatterData.name : path.basename(filePath, path.extname(filePath));
+        const description = typeof frontmatterData.description === "string" ? frontmatterData.description : bodyContent.trim().slice(0, 200);
+        const model = typeof frontmatterData.model === "string" ? frontmatterData.model : void 0;
+        let toolNames = [];
+        if (Array.isArray(frontmatterData.tools)) {
+          toolNames = frontmatterData.tools.map(String);
+        } else if (typeof frontmatterData.tools === "string") {
+          toolNames = frontmatterData.tools.split(",").map((t) => t.trim());
+        }
+        if (typeof frontmatterData["allowed-tools"] === "string") {
+          const additional = frontmatterData["allowed-tools"].split(",").map((t) => t.trim());
+          toolNames = [...toolNames, ...additional];
+        }
+        const tools = toolNames.filter((t) => t.length > 0).map((t) => this.classifyTool(t));
+        const swarmRole = this.inferSwarmRole(name, description);
+        return (0, core_1.createAgent)({
+          name,
+          framework: "claude-code",
+          description,
+          source_file: filePath,
+          model,
+          tools,
+          swarm_role: swarmRole
+        });
+      }
+      // ─── Private: Collect a config file without parsing agents ──
+      collectConfigFile(filePath, configFiles) {
+        const content = safeReadFile(filePath);
+        if (content !== null) {
+          configFiles.push({ path: filePath, content, framework: "claude-code" });
+        }
+      }
+      // ─── Private: Classify a tool name by type and risk ─────────
+      classifyTool(toolName) {
+        const lower = toolName.toLowerCase().trim();
+        if (lower.includes("bash") || lower.includes("shell") || lower.includes("exec") || lower === "command") {
+          return { name: toolName, type: "bash", risk_level: "high" };
+        }
+        if (lower.includes("write") || lower.includes("create_file") || lower.includes("str_replace") || lower === "edit") {
+          return { name: toolName, type: "file_write", risk_level: "medium" };
+        }
+        if (lower.includes("read") || lower.includes("view") || lower.includes("cat") || lower.includes("glob") || lower.includes("grep")) {
+          return { name: toolName, type: "file_read", risk_level: "low" };
+        }
+        if (lower.includes("search") || lower.includes("web_search")) {
+          return { name: toolName, type: "web_search", risk_level: "low" };
+        }
+        if (lower.includes("fetch") || lower.includes("http") || lower.includes("curl") || lower.includes("web_fetch")) {
+          return { name: toolName, type: "web_fetch", risk_level: "medium" };
+        }
+        if (lower.includes("mcp")) {
+          return { name: toolName, type: "mcp", risk_level: "medium" };
+        }
+        return { name: toolName, type: "custom", risk_level: "low" };
+      }
+      // ─── Private: Infer swarm role from name/description ────────
+      inferSwarmRole(name, description) {
+        const text = `${name} ${description}`.toLowerCase();
+        if (text.includes("planner") || text.includes("orchestrat") || text.includes("coordinat") || text.includes("dispatcher")) {
+          return "orchestrator";
+        }
+        if (text.includes("review") || text.includes("audit") || text.includes("check") || text.includes("verify")) {
+          return "reviewer";
+        }
+        if (text.includes("specialist") || text.includes("expert") || text.includes("specific") || text.includes("resolver")) {
+          return "specialist";
+        }
+        if (text.includes("worker") || text.includes("execut") || text.includes("build") || text.includes("runner")) {
+          return "worker";
+        }
+        return "standalone";
+      }
+    };
+    exports2.ClaudeCodeParser = ClaudeCodeParser;
+  }
+});
+
+// packages/parsers/dist/cursor.js
+var require_cursor = __commonJS({
+  "packages/parsers/dist/cursor.js"(exports2) {
+    "use strict";
+    var __createBinding2 = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault2 = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar2 = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding2(result, mod, k[i]);
+        }
+        __setModuleDefault2(result, mod);
+        return result;
+      };
+    })();
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.CursorParser = void 0;
+    var fs = __importStar2(require("fs"));
+    var path = __importStar2(require("path"));
+    var gray_matter_1 = __importDefault(require("gray-matter"));
+    var core_1 = require_dist();
+    function safeReadFile(filePath) {
+      try {
+        if (!fs.existsSync(filePath))
+          return null;
+        return fs.readFileSync(filePath, "utf-8");
+      } catch {
+        return null;
+      }
+    }
+    function safeListDir(dirPath, extensions) {
+      try {
+        if (!fs.existsSync(dirPath) || !fs.statSync(dirPath).isDirectory())
+          return [];
+        return fs.readdirSync(dirPath).filter((f) => extensions.some((ext) => f.endsWith(ext)));
+      } catch {
+        return [];
+      }
+    }
+    var CursorParser = class {
+      framework = "cursor";
+      displayName = "Cursor";
+      markers = [".cursor", ".cursorrules"];
+      async detect(rootDir) {
+        return fs.existsSync(path.join(rootDir, ".cursor")) || fs.existsSync(path.join(rootDir, ".cursorrules"));
+      }
+      async parse(rootDir) {
+        const agents = [];
+        const configFiles = [];
+        const warnings = [];
+        const rulesDir = path.join(rootDir, ".cursor", "rules");
+        for (const file of safeListDir(rulesDir, [".mdc", ".md"])) {
+          const filePath = path.join(rulesDir, file);
+          const content = safeReadFile(filePath);
+          if (!content)
+            continue;
+          configFiles.push({ path: filePath, content, framework: "cursor" });
+          try {
+            const parsed = (0, gray_matter_1.default)(content);
+            const data = parsed.data;
+            const name = typeof data.description === "string" ? data.description.substring(0, 60).replace(/[^a-zA-Z0-9-_ ]/g, "").trim().toLowerCase().replace(/\s+/g, "-") : path.basename(file, path.extname(file));
+            agents.push((0, core_1.createAgent)({
+              name: `cursor-rule-${name}`,
+              framework: "cursor",
+              description: typeof data.description === "string" ? data.description : parsed.content.slice(0, 200).trim(),
+              source_file: filePath,
+              model: typeof data.model === "string" ? data.model : void 0
+            }));
+          } catch (error) {
+            warnings.push(`Could not parse ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+          }
+        }
+        const legacyRulesPath = path.join(rootDir, ".cursorrules");
+        const legacyContent = safeReadFile(legacyRulesPath);
+        if (legacyContent) {
+          configFiles.push({ path: legacyRulesPath, content: legacyContent, framework: "cursor" });
+          agents.push((0, core_1.createAgent)({
+            name: "cursor-legacy-rules",
+            framework: "cursor",
+            description: legacyContent.slice(0, 200).trim(),
+            source_file: legacyRulesPath
+          }));
+        }
+        const mcpPath = path.join(rootDir, ".cursor", "mcp.json");
+        const mcpContent = safeReadFile(mcpPath);
+        if (mcpContent) {
+          configFiles.push({ path: mcpPath, content: mcpContent, framework: "cursor" });
+          try {
+            const mcpConfig = JSON.parse(mcpContent);
+            const servers = mcpConfig.mcpServers;
+            if (servers) {
+              const mcpServers = Object.entries(servers).map(([name, config]) => ({
+                name,
+                url: typeof config.url === "string" ? config.url : void 0,
+                tools_exposed: Array.isArray(config.tools) ? config.tools : void 0
+              }));
+              if (agents.length > 0 && agents[0]) {
+                agents[0].mcp_servers = mcpServers;
+              } else {
+                agents.push((0, core_1.createAgent)({
+                  name: "cursor-mcp-config",
+                  framework: "cursor",
+                  description: "Cursor MCP server configuration",
+                  source_file: mcpPath,
+                  mcp_servers: mcpServers
+                }));
+              }
+            }
+          } catch {
+            warnings.push(`Invalid JSON in ${mcpPath}`);
+          }
+        }
+        const ignorePath = path.join(rootDir, ".cursorignore");
+        const ignoreContent = safeReadFile(ignorePath);
+        if (ignoreContent) {
+          configFiles.push({ path: ignorePath, content: ignoreContent, framework: "cursor" });
+        }
+        if (agents.length === 0 && configFiles.length > 0) {
+          agents.push((0, core_1.createAgent)({
+            name: "cursor-default",
+            framework: "cursor",
+            description: "Default Cursor configuration for this project",
+            source_file: configFiles[0]?.path
+          }));
+        }
+        return { agents, config_files: configFiles, warnings };
+      }
+    };
+    exports2.CursorParser = CursorParser;
+  }
+});
+
+// packages/parsers/dist/codex.js
+var require_codex = __commonJS({
+  "packages/parsers/dist/codex.js"(exports2) {
+    "use strict";
+    var __createBinding2 = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault2 = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar2 = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding2(result, mod, k[i]);
+        }
+        __setModuleDefault2(result, mod);
+        return result;
+      };
+    })();
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.CodexParser = void 0;
+    var fs = __importStar2(require("fs"));
+    var path = __importStar2(require("path"));
+    var gray_matter_1 = __importDefault(require("gray-matter"));
+    var core_1 = require_dist();
+    function safeReadFile(filePath) {
+      try {
+        if (!fs.existsSync(filePath))
+          return null;
+        return fs.readFileSync(filePath, "utf-8");
+      } catch {
+        return null;
+      }
+    }
+    function safeListDir(dirPath, extensions) {
+      try {
+        if (!fs.existsSync(dirPath) || !fs.statSync(dirPath).isDirectory())
+          return [];
+        return fs.readdirSync(dirPath).filter((f) => extensions.some((ext) => f.endsWith(ext)));
+      } catch {
+        return [];
+      }
+    }
+    var CodexParser = class {
+      framework = "codex";
+      displayName = "Codex / OpenCode";
+      markers = [".codex", "codex.md", ".opencode", ".agents"];
+      async detect(rootDir) {
+        return fs.existsSync(path.join(rootDir, ".codex")) || fs.existsSync(path.join(rootDir, "codex.md")) || fs.existsSync(path.join(rootDir, ".opencode")) || fs.existsSync(path.join(rootDir, ".agents"));
+      }
+      async parse(rootDir) {
+        const agents = [];
+        const configFiles = [];
+        const warnings = [];
+        const codexConfigPath = path.join(rootDir, ".codex", "config.toml");
+        const codexConfig = safeReadFile(codexConfigPath);
+        if (codexConfig) {
+          configFiles.push({ path: codexConfigPath, content: codexConfig, framework: "codex" });
+          const modelMatch = codexConfig.match(/model\s*=\s*["']([^"']+)["']/);
+          const approvalMatch = codexConfig.match(/approval_mode\s*=\s*["']([^"']+)["']/);
+          const model = modelMatch?.[1];
+          const approvalMode = approvalMatch?.[1];
+          const tools = [];
+          if (approvalMode === "full-auto") {
+            tools.push({ name: "full-auto-execution", type: "bash", risk_level: "high" });
+            tools.push({ name: "full-auto-write", type: "file_write", risk_level: "high" });
+          } else if (approvalMode === "auto-edit") {
+            tools.push({ name: "auto-edit", type: "file_write", risk_level: "medium" });
+          }
+          agents.push((0, core_1.createAgent)({
+            name: "codex-project",
+            framework: "codex",
+            description: `Codex CLI configuration (approval_mode: ${approvalMode ?? "suggest"})`,
+            source_file: codexConfigPath,
+            model,
+            tools
+          }));
+        }
+        const codexMdPath = path.join(rootDir, "codex.md");
+        const codexMd = safeReadFile(codexMdPath);
+        if (codexMd) {
+          configFiles.push({ path: codexMdPath, content: codexMd, framework: "codex" });
+        }
+        const agentsDir = path.join(rootDir, ".agents");
+        for (const file of safeListDir(agentsDir, [".md", ".yaml", ".yml"])) {
+          const filePath = path.join(agentsDir, file);
+          const content = safeReadFile(filePath);
+          if (!content || content.trim().length === 0)
+            continue;
+          configFiles.push({ path: filePath, content, framework: "codex" });
+          try {
+            const parsed = (0, gray_matter_1.default)(content);
+            const data = parsed.data;
+            const name = typeof data.name === "string" ? data.name : path.basename(file, path.extname(file));
+            agents.push((0, core_1.createAgent)({
+              name,
+              framework: "codex",
+              description: typeof data.description === "string" ? data.description : parsed.content.trim().slice(0, 200),
+              source_file: filePath,
+              model: typeof data.model === "string" ? data.model : void 0
+            }));
+          } catch (error) {
+            warnings.push(`Could not parse ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+          }
+        }
+        const opencodePath = path.join(rootDir, ".opencode", "config.json");
+        const opencodeConfig = safeReadFile(opencodePath);
+        if (opencodeConfig) {
+          configFiles.push({ path: opencodePath, content: opencodeConfig, framework: "codex" });
+          try {
+            const config = JSON.parse(opencodeConfig);
+            if (!agents.some((a) => a.name === "codex-project")) {
+              agents.push((0, core_1.createAgent)({
+                name: "opencode-project",
+                framework: "codex",
+                description: "OpenCode project configuration",
+                source_file: opencodePath,
+                model: typeof config.model === "string" ? config.model : void 0
+              }));
+            }
+          } catch {
+            warnings.push(`Invalid JSON in ${opencodePath}`);
+          }
+        }
+        for (const subdir of ["instructions", "agents", "commands", "prompts"]) {
+          const dir = path.join(rootDir, ".opencode", subdir);
+          for (const file of safeListDir(dir, [".md", ".txt"])) {
+            const filePath = path.join(dir, file);
+            const content = safeReadFile(filePath);
+            if (content) {
+              configFiles.push({ path: filePath, content, framework: "codex" });
+            }
+          }
+        }
+        if (agents.length === 0 && configFiles.length > 0) {
+          agents.push((0, core_1.createAgent)({
+            name: "codex-default",
+            framework: "codex",
+            description: "Default Codex/OpenCode configuration",
+            source_file: configFiles[0]?.path
+          }));
+        }
+        return { agents, config_files: configFiles, warnings };
+      }
+    };
+    exports2.CodexParser = CodexParser;
+  }
+});
+
+// packages/parsers/dist/langchain.js
+var require_langchain = __commonJS({
+  "packages/parsers/dist/langchain.js"(exports2) {
+    "use strict";
+    var __createBinding2 = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault2 = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar2 = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding2(result, mod, k[i]);
+        }
+        __setModuleDefault2(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.LangChainParser = void 0;
+    var fs = __importStar2(require("fs"));
+    var path = __importStar2(require("path"));
+    var core_1 = require_dist();
+    function safeReadFile(filePath) {
+      try {
+        if (!fs.existsSync(filePath))
+          return null;
+        return fs.readFileSync(filePath, "utf-8");
+      } catch {
+        return null;
+      }
+    }
+    function findPythonFiles(dir, maxDepth = 3) {
+      const results = [];
+      function walk(currentDir, depth) {
+        if (depth > maxDepth)
+          return;
+        try {
+          const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+          for (const entry of entries) {
+            const fullPath = path.join(currentDir, entry.name);
+            if (entry.isDirectory() && !["node_modules", ".git", "__pycache__", ".venv", "venv", ".tox", "dist", "build"].includes(entry.name)) {
+              walk(fullPath, depth + 1);
+            } else if (entry.isFile() && entry.name.endsWith(".py")) {
+              results.push(fullPath);
+            }
+          }
+        } catch {
+        }
+      }
+      walk(dir, 0);
+      return results;
+    }
+    var AGENT_PATTERNS = [
+      { pattern: /(?:create_react_agent|create_openai_functions_agent|create_tool_calling_agent|create_structured_chat_agent)\s*\(/g, type: "agent_factory" },
+      { pattern: /AgentExecutor\s*(?:\(|\.from_agent_and_tools)/g, type: "agent_executor" },
+      { pattern: /class\s+(\w+).*(?:BaseTool|StructuredTool|Tool)/g, type: "custom_tool" },
+      { pattern: /StateGraph\s*\(/g, type: "langgraph" },
+      { pattern: /CompiledGraph|MessageGraph/g, type: "langgraph" }
+    ];
+    var TOOL_PATTERNS = [
+      { pattern: /(?:PythonREPLTool|ShellTool|BashTool)\s*\(/g, name: "code_execution", type: "bash", risk: "high" },
+      { pattern: /(?:SQLDatabaseToolkit|QuerySQLDataBaseTool)\s*\(/g, name: "database", type: "database", risk: "high" },
+      { pattern: /(?:RequestsGetTool|RequestsPostTool|RequestsPutTool)\s*\(/g, name: "http_requests", type: "web_fetch", risk: "medium" },
+      { pattern: /(?:FileSearchTool|DirectoryReadTool|ReadFileTool)\s*\(/g, name: "file_read", type: "file_read", risk: "low" },
+      { pattern: /(?:WriteFileTool|FileManagementToolkit)\s*\(/g, name: "file_write", type: "file_write", risk: "medium" },
+      { pattern: /(?:DuckDuckGoSearchRun|GoogleSearchAPIWrapper|TavilySearchResults|BraveSearchRun)\s*\(/g, name: "web_search", type: "web_search", risk: "low" },
+      { pattern: /(?:GmailToolkit|SlackToolkit|JiraToolkit)\s*\(/g, name: "saas_integration", type: "api_call", risk: "medium" }
+    ];
+    var MODEL_PATTERNS = [
+      { pattern: /ChatOpenAI\s*\([^)]*model\s*=\s*["']([^"']+)["']/g, provider: "openai" },
+      { pattern: /ChatAnthropic\s*\([^)]*model\s*=\s*["']([^"']+)["']/g, provider: "anthropic" },
+      { pattern: /ChatGoogleGenerativeAI\s*\([^)]*model\s*=\s*["']([^"']+)["']/g, provider: "google" },
+      { pattern: /AzureChatOpenAI\s*\(/g, provider: "azure_openai" },
+      { pattern: /ChatBedrock\s*\(/g, provider: "aws_bedrock" }
+    ];
+    var LangChainParser = class {
+      framework = "langchain";
+      displayName = "LangChain / LangGraph";
+      markers = ["langgraph.json"];
+      async detect(rootDir) {
+        const pyprojectPath = path.join(rootDir, "pyproject.toml");
+        const requirementsPath = path.join(rootDir, "requirements.txt");
+        const langgraphPath = path.join(rootDir, "langgraph.json");
+        if (fs.existsSync(langgraphPath))
+          return true;
+        for (const depFile of [pyprojectPath, requirementsPath]) {
+          const content = safeReadFile(depFile);
+          if (content && (content.includes("langchain") || content.includes("langgraph"))) {
+            return true;
+          }
+        }
+        const poetryLock = safeReadFile(path.join(rootDir, "poetry.lock"));
+        if (poetryLock && poetryLock.includes("langchain"))
+          return true;
+        return false;
+      }
+      async parse(rootDir) {
+        const agents = [];
+        const configFiles = [];
+        const warnings = [];
+        for (const depFile of ["pyproject.toml", "requirements.txt", "setup.py", "poetry.lock"]) {
+          const filePath = path.join(rootDir, depFile);
+          const content = safeReadFile(filePath);
+          if (content && (content.includes("langchain") || content.includes("langgraph"))) {
+            configFiles.push({ path: filePath, content, framework: "langchain" });
+          }
+        }
+        const lgPath = path.join(rootDir, "langgraph.json");
+        const lgContent = safeReadFile(lgPath);
+        if (lgContent) {
+          configFiles.push({ path: lgPath, content: lgContent, framework: "langchain" });
+        }
+        const pyFiles = findPythonFiles(rootDir);
+        let agentCount = 0;
+        for (const pyFile of pyFiles) {
+          const content = safeReadFile(pyFile);
+          if (!content)
+            continue;
+          if (!content.includes("langchain") && !content.includes("langgraph"))
+            continue;
+          configFiles.push({ path: pyFile, content, framework: "langchain" });
+          let hasAgent = false;
+          for (const { pattern, type } of AGENT_PATTERNS) {
+            pattern.lastIndex = 0;
+            if (pattern.test(content)) {
+              hasAgent = true;
+              break;
+            }
+          }
+          if (!hasAgent)
+            continue;
+          const tools = [];
+          for (const { pattern, name, type, risk } of TOOL_PATTERNS) {
+            pattern.lastIndex = 0;
+            if (pattern.test(content)) {
+              tools.push({ name, type, risk_level: risk });
+            }
+          }
+          let model;
+          for (const { pattern, provider } of MODEL_PATTERNS) {
+            pattern.lastIndex = 0;
+            const match = pattern.exec(content);
+            if (match) {
+              model = match[1] ? `${provider}/${match[1]}` : provider;
+              break;
+            }
+          }
+          const classMatch = content.match(/class\s+(\w+Agent)\b/);
+          const agentName = classMatch?.[1] ?? path.basename(pyFile, ".py").replace(/_/g, "-");
+          const isLangGraph = content.includes("StateGraph") || content.includes("langgraph");
+          agents.push((0, core_1.createAgent)({
+            name: agentName,
+            framework: "langchain",
+            description: `${isLangGraph ? "LangGraph" : "LangChain"} agent defined in ${path.relative(rootDir, pyFile)}`,
+            source_file: pyFile,
+            model,
+            tools,
+            swarm_role: isLangGraph ? "worker" : "standalone"
+          }));
+          agentCount++;
+        }
+        const envPath = path.join(rootDir, ".env");
+        const envContent = safeReadFile(envPath);
+        if (envContent) {
+          configFiles.push({ path: envPath, content: envContent, framework: "langchain" });
+        }
+        if (agents.length === 0 && configFiles.length > 0) {
+          agents.push((0, core_1.createAgent)({
+            name: "langchain-project",
+            framework: "langchain",
+            description: "LangChain/LangGraph project detected from dependencies",
+            source_file: configFiles[0]?.path
+          }));
+        }
+        return { agents, config_files: configFiles, warnings };
+      }
+    };
+    exports2.LangChainParser = LangChainParser;
+  }
+});
+
+// packages/parsers/dist/crewai.js
+var require_crewai = __commonJS({
+  "packages/parsers/dist/crewai.js"(exports2) {
+    "use strict";
+    var __createBinding2 = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault2 = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar2 = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding2(result, mod, k[i]);
+        }
+        __setModuleDefault2(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.CrewAIParser = void 0;
+    var fs = __importStar2(require("fs"));
+    var path = __importStar2(require("path"));
+    var core_1 = require_dist();
+    function safeReadFile(filePath) {
+      try {
+        if (!fs.existsSync(filePath))
+          return null;
+        return fs.readFileSync(filePath, "utf-8");
+      } catch {
+        return null;
+      }
+    }
+    function findPythonFiles(dir, maxDepth = 3) {
+      const results = [];
+      function walk(currentDir, depth) {
+        if (depth > maxDepth)
+          return;
+        try {
+          const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+          for (const entry of entries) {
+            const fullPath = path.join(currentDir, entry.name);
+            if (entry.isDirectory() && !["node_modules", ".git", "__pycache__", ".venv", "venv", "dist", "build"].includes(entry.name)) {
+              walk(fullPath, depth + 1);
+            } else if (entry.isFile() && entry.name.endsWith(".py")) {
+              results.push(fullPath);
+            }
+          }
+        } catch {
+        }
+      }
+      walk(dir, 0);
+      return results;
+    }
+    function parseCrewYAML(content) {
+      const agents = [];
+      const blocks = content.split(/\n(?=\w)/);
+      for (const block of blocks) {
+        const lines = block.split("\n");
+        const headerLine = lines[0];
+        if (!headerLine || !headerLine.trim().endsWith(":"))
+          continue;
+        const agentKey = headerLine.trim().replace(":", "");
+        const fields = { _key: agentKey };
+        for (let i = 1; i < lines.length; i++) {
+          const line = lines[i];
+          if (!line)
+            continue;
+          const match = line.match(/^\s+(\w[\w_]*):\s*(.*)/);
+          if (match && match[1] && match[2] !== void 0) {
+            const key = match[1];
+            let value = match[2].trim();
+            if (value === "true" || value === "True") {
+              fields[key] = true;
+            } else if (value === "false" || value === "False") {
+              fields[key] = false;
+            } else if (value.startsWith("[") && value.endsWith("]")) {
+              fields[key] = value.slice(1, -1).split(",").map((s) => s.trim().replace(/["']/g, ""));
+            } else {
+              fields[key] = value.replace(/^["']|["']$/g, "");
+            }
+          }
+        }
+        if (Object.keys(fields).length > 1) {
+          agents.push(fields);
+        }
+      }
+      return agents;
+    }
+    var CREWAI_TOOL_MAP = {
+      "SerperDevTool": { type: "web_search", risk: "low" },
+      "ScrapeWebsiteTool": { type: "web_fetch", risk: "medium" },
+      "WebsiteSearchTool": { type: "web_search", risk: "low" },
+      "FileReadTool": { type: "file_read", risk: "low" },
+      "FileWriterTool": { type: "file_write", risk: "medium" },
+      "DirectoryReadTool": { type: "file_read", risk: "low" },
+      "DirectorySearchTool": { type: "file_read", risk: "low" },
+      "CodeInterpreterTool": { type: "code_execution", risk: "high" },
+      "CodeDocsSearchTool": { type: "web_search", risk: "low" },
+      "GithubSearchTool": { type: "api_call", risk: "low" },
+      "PGSearchTool": { type: "database", risk: "medium" },
+      "MySQLSearchTool": { type: "database", risk: "medium" }
+    };
+    var CrewAIParser = class {
+      framework = "crewai";
+      displayName = "CrewAI";
+      markers = ["crew.yaml", "agents.yaml"];
+      async detect(rootDir) {
+        const yamlFiles = ["crew.yaml", "crew.yml", "agents.yaml", "agents.yml"];
+        for (const f of yamlFiles) {
+          if (fs.existsSync(path.join(rootDir, f)))
+            return true;
+          if (fs.existsSync(path.join(rootDir, "config", f)))
+            return true;
+        }
+        for (const depFile of ["pyproject.toml", "requirements.txt"]) {
+          const content = safeReadFile(path.join(rootDir, depFile));
+          if (content && content.includes("crewai"))
+            return true;
+        }
+        return false;
+      }
+      async parse(rootDir) {
+        const agents = [];
+        const configFiles = [];
+        const warnings = [];
+        const yamlLocations = [
+          path.join(rootDir, "crew.yaml"),
+          path.join(rootDir, "crew.yml"),
+          path.join(rootDir, "agents.yaml"),
+          path.join(rootDir, "agents.yml"),
+          path.join(rootDir, "config", "agents.yaml"),
+          path.join(rootDir, "config", "agents.yml")
+        ];
+        for (const yamlPath of yamlLocations) {
+          const content = safeReadFile(yamlPath);
+          if (!content)
+            continue;
+          configFiles.push({ path: yamlPath, content, framework: "crewai" });
+          const parsedAgents = parseCrewYAML(content);
+          for (const agentDef of parsedAgents) {
+            const name = String(agentDef._key ?? "unnamed");
+            const role = typeof agentDef.role === "string" ? agentDef.role : "";
+            const goal = typeof agentDef.goal === "string" ? agentDef.goal : "";
+            const backstory = typeof agentDef.backstory === "string" ? agentDef.backstory : "";
+            const toolNames = Array.isArray(agentDef.tools) ? agentDef.tools : typeof agentDef.tools === "string" ? [agentDef.tools] : [];
+            const tools = toolNames.map((t) => {
+              const mapped = CREWAI_TOOL_MAP[t];
+              return mapped ? { name: t, type: mapped.type, risk_level: mapped.risk } : { name: t, type: "custom", risk_level: "low" };
+            });
+            const allowDelegation = agentDef.allow_delegation;
+            const delegateTo = allowDelegation === true || allowDelegation === void 0 ? parsedAgents.filter((a) => a._key !== name).map((a) => String(a._key)) : void 0;
+            const swarmRole = role.toLowerCase().includes("manager") || role.toLowerCase().includes("lead") || role.toLowerCase().includes("coordinator") ? "orchestrator" : "worker";
+            agents.push((0, core_1.createAgent)({
+              name,
+              framework: "crewai",
+              description: `${role}${goal ? ` \u2014 ${goal}` : ""}`,
+              source_file: yamlPath,
+              tools,
+              swarm_role: swarmRole,
+              delegates_to: delegateTo && delegateTo.length > 0 ? delegateTo : void 0
+            }));
+          }
+        }
+        for (const tasksFile of ["tasks.yaml", "tasks.yml", "config/tasks.yaml"]) {
+          const content = safeReadFile(path.join(rootDir, tasksFile));
+          if (content) {
+            configFiles.push({ path: path.join(rootDir, tasksFile), content, framework: "crewai" });
+          }
+        }
+        const pyFiles = findPythonFiles(rootDir);
+        for (const pyFile of pyFiles) {
+          const content = safeReadFile(pyFile);
+          if (!content || !content.includes("crewai"))
+            continue;
+          configFiles.push({ path: pyFile, content, framework: "crewai" });
+          const agentDecorators = content.matchAll(/@agent\s*\n\s*def\s+(\w+)/g);
+          for (const match of agentDecorators) {
+            const name = match[1];
+            if (name && !agents.some((a) => a.name === name)) {
+              agents.push((0, core_1.createAgent)({
+                name,
+                framework: "crewai",
+                description: `CrewAI agent defined in ${path.relative(rootDir, pyFile)}`,
+                source_file: pyFile,
+                swarm_role: "worker"
+              }));
+            }
+          }
+        }
+        for (const depFile of ["pyproject.toml", "requirements.txt"]) {
+          const filePath = path.join(rootDir, depFile);
+          const content = safeReadFile(filePath);
+          if (content && content.includes("crewai")) {
+            configFiles.push({ path: filePath, content, framework: "crewai" });
+          }
+        }
+        if (agents.length === 0 && configFiles.length > 0) {
+          agents.push((0, core_1.createAgent)({
+            name: "crewai-project",
+            framework: "crewai",
+            description: "CrewAI project detected from configuration",
+            source_file: configFiles[0]?.path
+          }));
+        }
+        return { agents, config_files: configFiles, warnings };
+      }
+    };
+    exports2.CrewAIParser = CrewAIParser;
+  }
+});
+
+// packages/parsers/dist/kiro.js
+var require_kiro = __commonJS({
+  "packages/parsers/dist/kiro.js"(exports2) {
+    "use strict";
+    var __createBinding2 = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault2 = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar2 = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding2(result, mod, k[i]);
+        }
+        __setModuleDefault2(result, mod);
+        return result;
+      };
+    })();
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.KiroParser = void 0;
+    var fs = __importStar2(require("fs"));
+    var path = __importStar2(require("path"));
+    var gray_matter_1 = __importDefault(require("gray-matter"));
+    var core_1 = require_dist();
+    function safeReadFile(filePath) {
+      try {
+        if (!fs.existsSync(filePath))
+          return null;
+        return fs.readFileSync(filePath, "utf-8");
+      } catch {
+        return null;
+      }
+    }
+    function safeListDir(dirPath, extensions) {
+      try {
+        if (!fs.existsSync(dirPath) || !fs.statSync(dirPath).isDirectory())
+          return [];
+        return fs.readdirSync(dirPath).filter((f) => extensions.some((ext) => f.endsWith(ext)));
+      } catch {
+        return [];
+      }
+    }
+    var KiroParser = class {
+      framework = "custom";
+      // Kiro maps to "custom" in our framework enum
+      displayName = "Kiro";
+      markers = [".kiro", "kiro.md"];
+      async detect(rootDir) {
+        return fs.existsSync(path.join(rootDir, ".kiro")) || fs.existsSync(path.join(rootDir, "kiro.md"));
+      }
+      async parse(rootDir) {
+        const agents = [];
+        const configFiles = [];
+        const warnings = [];
+        const steeringDir = path.join(rootDir, ".kiro", "steering");
+        for (const file of safeListDir(steeringDir, [".md"])) {
+          const filePath = path.join(steeringDir, file);
+          const content = safeReadFile(filePath);
+          if (!content)
+            continue;
+          configFiles.push({ path: filePath, content, framework: "custom" });
+          try {
+            const parsed = (0, gray_matter_1.default)(content);
+            const data = parsed.data;
+            const name = typeof data.name === "string" ? data.name : path.basename(file, ".md");
+            agents.push((0, core_1.createAgent)({
+              name: `kiro-steering-${name}`,
+              framework: "custom",
+              description: typeof data.description === "string" ? data.description : parsed.content.trim().slice(0, 200),
+              source_file: filePath
+            }));
+          } catch (error) {
+            warnings.push(`Could not parse ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+          }
+        }
+        const specsDir = path.join(rootDir, ".kiro", "specs");
+        for (const file of safeListDir(specsDir, [".md"])) {
+          const filePath = path.join(specsDir, file);
+          const content = safeReadFile(filePath);
+          if (content) {
+            configFiles.push({ path: filePath, content, framework: "custom" });
+          }
+        }
+        const kiroMdPath = path.join(rootDir, "kiro.md");
+        const kiroMd = safeReadFile(kiroMdPath);
+        if (kiroMd) {
+          configFiles.push({ path: kiroMdPath, content: kiroMd, framework: "custom" });
+        }
+        if (agents.length === 0 && configFiles.length > 0) {
+          agents.push((0, core_1.createAgent)({
+            name: "kiro-default",
+            framework: "custom",
+            description: "Kiro IDE project configuration",
+            source_file: configFiles[0]?.path
+          }));
+        }
+        return { agents, config_files: configFiles, warnings };
+      }
+    };
+    exports2.KiroParser = KiroParser;
+  }
+});
+
+// packages/parsers/dist/auto-detect.js
+var require_auto_detect = __commonJS({
+  "packages/parsers/dist/auto-detect.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.detectFrameworks = detectFrameworks;
+    exports2.parseAll = parseAll;
+    var claude_code_1 = require_claude_code();
+    var cursor_1 = require_cursor();
+    var codex_1 = require_codex();
+    var langchain_1 = require_langchain();
+    var crewai_1 = require_crewai();
+    var kiro_1 = require_kiro();
+    function getAllParsers() {
+      return [
+        new claude_code_1.ClaudeCodeParser(),
+        new cursor_1.CursorParser(),
+        new codex_1.CodexParser(),
+        new langchain_1.LangChainParser(),
+        new crewai_1.CrewAIParser(),
+        new kiro_1.KiroParser()
+      ];
+    }
+    async function detectFrameworks(rootDir) {
+      const allParsers = getAllParsers();
+      const detected = [];
+      for (const parser of allParsers) {
+        if (await parser.detect(rootDir)) {
+          detected.push(parser);
+        }
+      }
+      return { detected, all_parsers: allParsers };
+    }
+    async function parseAll(rootDir) {
+      const { detected } = await detectFrameworks(rootDir);
+      const allAgents = [];
+      const allConfigFiles = [];
+      const allWarnings = [];
+      const frameworks = [];
+      for (const parser of detected) {
+        const result = await parser.parse(rootDir);
+        allAgents.push(...result.agents);
+        allConfigFiles.push(...result.config_files);
+        allWarnings.push(...result.warnings);
+        frameworks.push(parser.displayName);
+      }
+      return {
+        agents: allAgents,
+        config_files: allConfigFiles,
+        frameworks,
+        warnings: allWarnings
+      };
+    }
+  }
+});
+
+// packages/parsers/dist/index.js
+var require_dist2 = __commonJS({
+  "packages/parsers/dist/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.parseAll = exports2.detectFrameworks = exports2.KiroParser = exports2.CrewAIParser = exports2.LangChainParser = exports2.CodexParser = exports2.CursorParser = exports2.ClaudeCodeParser = void 0;
+    var claude_code_1 = require_claude_code();
+    Object.defineProperty(exports2, "ClaudeCodeParser", { enumerable: true, get: function() {
+      return claude_code_1.ClaudeCodeParser;
+    } });
+    var cursor_1 = require_cursor();
+    Object.defineProperty(exports2, "CursorParser", { enumerable: true, get: function() {
+      return cursor_1.CursorParser;
+    } });
+    var codex_1 = require_codex();
+    Object.defineProperty(exports2, "CodexParser", { enumerable: true, get: function() {
+      return codex_1.CodexParser;
+    } });
+    var langchain_1 = require_langchain();
+    Object.defineProperty(exports2, "LangChainParser", { enumerable: true, get: function() {
+      return langchain_1.LangChainParser;
+    } });
+    var crewai_1 = require_crewai();
+    Object.defineProperty(exports2, "CrewAIParser", { enumerable: true, get: function() {
+      return crewai_1.CrewAIParser;
+    } });
+    var kiro_1 = require_kiro();
+    Object.defineProperty(exports2, "KiroParser", { enumerable: true, get: function() {
+      return kiro_1.KiroParser;
+    } });
+    var auto_detect_1 = require_auto_detect();
+    Object.defineProperty(exports2, "detectFrameworks", { enumerable: true, get: function() {
+      return auto_detect_1.detectFrameworks;
+    } });
+    Object.defineProperty(exports2, "parseAll", { enumerable: true, get: function() {
+      return auto_detect_1.parseAll;
+    } });
+  }
+});
+
+// packages/scanner/dist/rules/interface.js
+var require_interface = __commonJS({
+  "packages/scanner/dist/rules/interface.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.createEnterpriseFinding = createEnterpriseFinding;
+    exports2.checkSuppression = checkSuppression;
+    exports2.parseInlineSuppressions = parseInlineSuppressions;
+    exports2.getRuleDocsUrl = getRuleDocsUrl;
+    function createEnterpriseFinding(rule, params) {
+      return {
+        id: params.id,
+        rule_id: rule.id,
+        rule_name: rule.name,
+        severity: rule.severity,
+        category: rule.category,
+        title: params.title,
+        description: params.description,
+        recommendation: params.recommendation,
+        agent_id: params.agent_id,
+        agent_name: params.agent_name,
+        framework: params.framework,
+        location: params.location,
+        compliance: rule.compliance,
+        cwe: params.cwe,
+        cve: params.cve,
+        mitre_atlas: params.mitre_atlas,
+        remediation_effort: params.remediation_effort,
+        auto_fix: params.auto_fix ?? rule.auto_fix,
+        metadata: params.metadata,
+        first_detected: (/* @__PURE__ */ new Date()).toISOString(),
+        status: "open"
+      };
+    }
+    function checkSuppression(ruleId, filePath, suppressions, now = /* @__PURE__ */ new Date()) {
+      for (const entry of suppressions) {
+        if (entry.rule_id !== ruleId)
+          continue;
+        if (entry.path && filePath) {
+          const pattern = entry.path.replace(/\*/g, ".*");
+          if (!new RegExp(`^${pattern}$`).test(filePath))
+            continue;
+        }
+        if (entry.expires) {
+          const expiresDate = new Date(entry.expires);
+          if (now > expiresDate) {
+            return { suppressed: false, entry, expired: true };
+          }
+        }
+        return { suppressed: true, entry };
+      }
+      return { suppressed: false };
+    }
+    var INLINE_SUPPRESS_PATTERN = /[#\/\/]\s*sentinelflow-ignore:\s*(SF-[A-Z]+-\d+)\s*(?:--\s*(.+))?$/;
+    function parseInlineSuppressions(filePath, content) {
+      const entries = [];
+      const lines = content.split("\n");
+      for (const line of lines) {
+        const match = INLINE_SUPPRESS_PATTERN.exec(line);
+        if (match && match[1]) {
+          entries.push({
+            rule_id: match[1],
+            path: filePath,
+            reason: match[2]?.trim() ?? "No justification provided",
+            source: "inline"
+          });
+        }
+      }
+      return entries;
+    }
+    function getRuleDocsUrl(rule) {
+      return rule.docs_url ?? `https://sentinelflow.dev/rules/${rule.id}`;
+    }
+  }
+});
+
+// packages/scanner/dist/rules/prompt-injection.js
+var require_prompt_injection = __commonJS({
+  "packages/scanner/dist/rules/prompt-injection.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.PROMPT_INJECTION_RULES = exports2.longContextWithoutSummarization = exports2.noOutputValidation = exports2.sensitiveDataInPrompts = exports2.noSystemPrompt = void 0;
+    var interface_1 = require_interface();
+    var COMPLIANCE_PI = [
+      { framework: "OWASP_LLM_2025", reference: "LLM01", description: "Prompt Injection" },
+      { framework: "MITRE_ATLAS", reference: "AML.T0051", description: "LLM Prompt Injection" },
+      { framework: "NIST_AI_RMF", reference: "MEASURE 2.4", description: "Input validation measures" }
+    ];
+    exports2.noSystemPrompt = {
+      id: "SF-PI-001",
+      name: "No System Prompt Defined",
+      description: "Agent operates without a system prompt, lacking any instruction boundary against prompt injection.",
+      category: "prompt_injection",
+      severity: "high",
+      frameworks: "all",
+      compliance: COMPLIANCE_PI,
+      phase: "static",
+      evaluate(ctx) {
+        return ctx.agents.filter((a) => !a.description || a.description.trim().length < 10).filter((a) => {
+          const hasClaudeMd = ctx.config_files.some((f) => f.path.endsWith("CLAUDE.md") && f.content.trim().length > 50);
+          return !hasClaudeMd;
+        }).map((agent) => (0, interface_1.createEnterpriseFinding)(this, {
+          id: `${this.id}-${agent.id}`,
+          title: `Agent "${agent.name}" has no system prompt or project guidance`,
+          description: `No CLAUDE.md, AGENTS.md, or substantial agent description found for "${agent.name}". Without a system prompt, the agent has no instruction boundary, making it fully susceptible to prompt injection from any input source.`,
+          recommendation: "Create a CLAUDE.md file with clear behavioral boundaries, or add a detailed description to the agent definition. Include explicit instructions about what the agent should and should NOT do.",
+          agent_id: agent.id,
+          agent_name: agent.name,
+          framework: agent.framework,
+          mitre_atlas: "AML.T0051",
+          remediation_effort: "low"
+        }));
+      }
+    };
+    var SENSITIVE_PATTERNS_IN_PROMPTS = [
+      { pattern: /(?:internal|private|confidential)\s*(?:url|endpoint|api|server)[:=\s]+\S+/gi, name: "internal URL" },
+      { pattern: /(?:database|db)\s*(?:host|server|connection)[:=\s]+\S+/gi, name: "database endpoint" },
+      { pattern: /(?:admin|root|superuser)\s*(?:password|credential|secret)[:=\s]+\S+/gi, name: "admin credential" },
+      { pattern: /(?:vpn|ssh|rdp)\s*[:=\s]+\S+\.(?:com|net|org|io)/gi, name: "infrastructure endpoint" }
+    ];
+    exports2.sensitiveDataInPrompts = {
+      id: "SF-PI-002",
+      name: "System Prompt Contains Sensitive Data",
+      description: "System prompts containing internal URLs, credentials, or infrastructure details are extractable via prompt injection techniques (OWASP LLM07).",
+      category: "prompt_injection",
+      severity: "high",
+      frameworks: "all",
+      compliance: [
+        ...COMPLIANCE_PI,
+        { framework: "OWASP_LLM_2025", reference: "LLM07", description: "System Prompt Leakage" }
+      ],
+      phase: "static",
+      evaluate(ctx) {
+        const findings = [];
+        let counter = 0;
+        const promptFiles = ctx.config_files.filter((f) => f.path.endsWith("CLAUDE.md") || f.path.endsWith("AGENTS.md") || f.path.includes("/agents/") || f.path.includes("/.claude/agents/"));
+        for (const file of promptFiles) {
+          for (const { pattern, name } of SENSITIVE_PATTERNS_IN_PROMPTS) {
+            pattern.lastIndex = 0;
+            let match;
+            while ((match = pattern.exec(file.content)) !== null) {
+              const line = file.content.substring(0, match.index).split("\n").length;
+              findings.push((0, interface_1.createEnterpriseFinding)(this, {
+                id: `${this.id}-${counter++}`,
+                title: `${name} found in prompt file ${file.path}`,
+                description: `A potential ${name} was found at line ${line} in a system prompt file. System prompts can be extracted via prompt injection, exposing this data.`,
+                recommendation: "Remove sensitive infrastructure details from system prompts. Use environment variables or secrets managers for endpoints and credentials. Refer to resources by abstract names rather than actual URLs.",
+                location: { file: file.path, line, snippet: match[0].substring(0, 60) },
+                cwe: "CWE-200",
+                remediation_effort: "low"
+              }));
+            }
+          }
+        }
+        return findings;
+      }
+    };
+    exports2.noOutputValidation = {
+      id: "SF-PI-005",
+      name: "No Output Validation Before Tool Execution",
+      description: "Agent passes LLM outputs directly to tools without schema validation, enabling injection chains.",
+      category: "prompt_injection",
+      severity: "high",
+      frameworks: ["langchain", "crewai", "autogen", "custom"],
+      compliance: [
+        ...COMPLIANCE_PI,
+        { framework: "OWASP_LLM_2025", reference: "LLM05", description: "Improper Output Handling" }
+      ],
+      phase: "static",
+      evaluate(ctx) {
+        const findings = [];
+        for (const file of ctx.config_files) {
+          const dangerousPatterns = [
+            { pattern: /eval\s*\(/g, name: "eval()" },
+            { pattern: /exec\s*\(/g, name: "exec()" },
+            { pattern: /subprocess\.(?:run|call|Popen)\s*\(/g, name: "subprocess execution" },
+            { pattern: /os\.system\s*\(/g, name: "os.system()" },
+            { pattern: /PythonREPLTool|ShellTool/g, name: "unrestricted code execution tool" }
+          ];
+          for (const { pattern, name } of dangerousPatterns) {
+            pattern.lastIndex = 0;
+            let match;
+            while ((match = pattern.exec(file.content)) !== null) {
+              const line = file.content.substring(0, match.index).split("\n").length;
+              findings.push((0, interface_1.createEnterpriseFinding)(this, {
+                id: `${this.id}-${findings.length}`,
+                title: `Dangerous ${name} pattern in ${file.path}`,
+                description: `${name} found at line ${line}. LLM outputs passed to code execution functions without validation enable prompt-to-RCE chains. LangChain CVE-2023-29374, CVE-2023-36258, and CVE-2024-21511 all exploited this pattern.`,
+                recommendation: "Add schema validation between LLM output and tool execution. Use structured output parsing (Pydantic models, JSON Schema validation) rather than passing raw LLM text to execution functions. Sandbox all code execution.",
+                location: { file: file.path, line, snippet: match[0] },
+                cwe: "CWE-94",
+                cve: ["CVE-2023-29374", "CVE-2023-36258", "CVE-2024-21511"],
+                remediation_effort: "medium"
+              }));
+            }
+          }
+        }
+        return findings;
+      }
+    };
+    exports2.longContextWithoutSummarization = {
+      id: "SF-PI-008",
+      name: "Large Context Window Without Summarization Strategy",
+      description: "Agents using maximum context windows are vulnerable to many-shot jailbreaking (Anthropic, April 2024).",
+      category: "prompt_injection",
+      severity: "medium",
+      frameworks: "all",
+      compliance: COMPLIANCE_PI,
+      phase: "static",
+      evaluate(ctx) {
+        const findings = [];
+        const hasCompaction = ctx.config_files.some((f) => f.content.includes("compact") || f.content.includes("summariz") || f.content.includes("context_window") || f.content.includes("max_tokens"));
+        if (!hasCompaction && ctx.agents.length > 0) {
+          findings.push((0, interface_1.createEnterpriseFinding)(this, {
+            id: `${this.id}-global`,
+            title: "No context window management or compaction strategy detected",
+            description: "No evidence of context window management (compaction, summarization, or token limits) found in the project configuration. Long context sessions are vulnerable to many-shot jailbreaking and increase prompt injection surface area.",
+            recommendation: "Implement a context compaction strategy. Use Claude Code's /compact command, set max_tokens limits, or implement conversation summarization. ECC's suggest-compact hook provides a reference implementation.",
+            remediation_effort: "medium"
+          }));
+        }
+        return findings;
+      }
+    };
+    exports2.PROMPT_INJECTION_RULES = [
+      exports2.noSystemPrompt,
+      exports2.sensitiveDataInPrompts,
+      exports2.noOutputValidation,
+      exports2.longContextWithoutSummarization
+    ];
+  }
+});
+
+// packages/scanner/dist/rules/access-control.js
+var require_access_control = __commonJS({
+  "packages/scanner/dist/rules/access-control.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.ACCESS_CONTROL_RULES = exports2.noOwner = exports2.privilegeEscalation = exports2.noHumanInTheLoop = exports2.excessivePermissions = exports2.hardcodedCredentials = void 0;
+    var interface_1 = require_interface();
+    var COMPLIANCE_AC = [
+      { framework: "OWASP_LLM_2025", reference: "LLM06", description: "Excessive Agency" },
+      { framework: "NIST_AI_RMF", reference: "GOVERN 2", description: "Identity and access management" },
+      { framework: "SOC2", reference: "CC6.1", description: "Logical access security" }
+    ];
+    var SECRET_PATTERNS = [
+      { pattern: /(?:sk-|pk_live_|pk_test_)[a-zA-Z0-9]{20,}/g, name: "API key" },
+      { pattern: /sk-ant-[a-zA-Z0-9-]{80,}/g, name: "Anthropic API key" },
+      { pattern: /(?:ghp_|gho_|ghu_|ghs_|ghr_)[a-zA-Z0-9]{36,}/g, name: "GitHub token" },
+      { pattern: /AKIA[0-9A-Z]{16}/g, name: "AWS Access Key ID" },
+      { pattern: /(?:aws_secret_access_key|AWS_SECRET)\s*[:=]\s*["']?[A-Za-z0-9/+=]{40}["']?/gi, name: "AWS Secret Key" },
+      { pattern: /AIza[0-9A-Za-z_-]{35}/g, name: "Google API key" },
+      { pattern: /glpat-[a-zA-Z0-9_-]{20,}/g, name: "GitLab token" },
+      { pattern: /xox[baprs]-[a-zA-Z0-9-]{10,}/g, name: "Slack token" },
+      { pattern: /(?:hooks\.slack\.com\/services\/)[A-Z0-9/]+/g, name: "Slack Webhook" },
+      { pattern: /(?:mongodb(?:\+srv)?:\/\/)[^\s"']+/g, name: "MongoDB connection string" },
+      { pattern: /(?:postgres(?:ql)?:\/\/)[^\s"']+/g, name: "PostgreSQL connection string" },
+      { pattern: /(?:mysql:\/\/)[^\s"']+/g, name: "MySQL connection string" },
+      { pattern: /(?:redis:\/\/)[^\s"']+/g, name: "Redis connection string" },
+      { pattern: /(?:password|passwd|pwd)\s*[:=]\s*["'][^"']{8,}["']/gi, name: "Password" },
+      { pattern: /(?:secret|token|api_key|apikey|auth_token)\s*[:=]\s*["'][^"']{8,}["']/gi, name: "Secret/Token" },
+      { pattern: /Bearer\s+[a-zA-Z0-9._~+/=-]{20,}/g, name: "Bearer token" }
+    ];
+    var IGNORE_FILE_PATTERNS = [/\.example$/, /\.template$/, /\.sample$/, /SKILL\.md$/, /node_modules/, /\.git\//];
+    function maskSecret(s) {
+      if (s.length <= 8)
+        return "****";
+      return s.substring(0, 4) + "****" + s.substring(s.length - 4);
+    }
+    exports2.hardcodedCredentials = {
+      id: "SF-AC-001",
+      name: "Hardcoded Credentials in Agent Configuration",
+      description: "Agents using hardcoded API keys, tokens, or passwords instead of managed identities or secrets managers.",
+      category: "access_control",
+      severity: "critical",
+      frameworks: "all",
+      compliance: [
+        ...COMPLIANCE_AC,
+        { framework: "HIPAA", reference: "\xA7164.312(d)", description: "Person or entity authentication" }
+      ],
+      phase: "static",
+      evaluate(ctx) {
+        const findings = [];
+        let counter = 0;
+        for (const file of ctx.config_files) {
+          if (IGNORE_FILE_PATTERNS.some((p) => p.test(file.path)))
+            continue;
+          for (const { pattern, name } of SECRET_PATTERNS) {
+            pattern.lastIndex = 0;
+            let match;
+            while ((match = pattern.exec(file.content)) !== null) {
+              const line = file.content.substring(0, match.index).split("\n").length;
+              findings.push((0, interface_1.createEnterpriseFinding)(this, {
+                id: `${this.id}-${counter++}`,
+                title: `${name} found in ${file.path}`,
+                description: `A potential ${name} was detected at line ${line}. Hardcoded credentials in agent configs can be exfiltrated via prompt injection, leaked through version control, or exposed in agent traces and logs.`,
+                recommendation: "Use managed identities (Azure Managed Identity, GCP Workload Identity) or a secrets manager (Infisical, Vault, AWS Secrets Manager). Reference secrets via environment variables: $ENV_VAR_NAME.",
+                location: { file: file.path, line, snippet: maskSecret(match[0]) },
+                cwe: "CWE-798",
+                remediation_effort: "low"
+              }));
+            }
+          }
+        }
+        return findings;
+      }
+    };
+    exports2.excessivePermissions = {
+      id: "SF-AC-002",
+      name: "Agent Permissions Exceed Least Privilege",
+      description: "Agent has broad tool access without explicit restrictions, violating the principle of least privilege.",
+      category: "access_control",
+      severity: "high",
+      frameworks: "all",
+      compliance: [
+        ...COMPLIANCE_AC,
+        { framework: "EU_AI_ACT", reference: "Article 15", description: "Accuracy, robustness, cybersecurity" }
+      ],
+      phase: "static",
+      evaluate(ctx) {
+        return ctx.agents.filter((a) => a.tools.length > 0 && (!a.allowed_tools || a.allowed_tools.length === 0) && (!a.blocked_tools || a.blocked_tools.length === 0)).map((agent) => (0, interface_1.createEnterpriseFinding)(this, {
+          id: `${this.id}-${agent.id}`,
+          title: `Agent "${agent.name}" has no explicit tool allowlist`,
+          description: `Agent "${agent.name}" has ${agent.tools.length} tools available with no explicit allowlist or blocklist. This grants implicit access to all tools, including potentially dangerous ones. Microsoft's Copilot oversharing incident showed how excessive permissions amplify data exposure across the entire tenant.`,
+          recommendation: "Define an explicit allowedTools list with only the tools this agent needs. For Claude Code, use granular Bash permissions: 'Bash(npm test)' instead of 'Bash(*)'.",
+          agent_id: agent.id,
+          agent_name: agent.name,
+          framework: agent.framework,
+          location: agent.source_file ? { file: agent.source_file } : void 0,
+          remediation_effort: "low"
+        }));
+      }
+    };
+    exports2.noHumanInTheLoop = {
+      id: "SF-AC-005",
+      name: "No Human-in-the-Loop for High-Impact Actions",
+      description: "Agent can perform irreversible actions (file writes, bash execution, network calls) without human approval gates.",
+      category: "access_control",
+      severity: "high",
+      frameworks: "all",
+      compliance: [
+        ...COMPLIANCE_AC,
+        { framework: "EU_AI_ACT", reference: "Article 14", description: "Human oversight" },
+        { framework: "NIST_AI_RMF", reference: "MANAGE 3", description: "Human oversight of AI" }
+      ],
+      phase: "static",
+      evaluate(ctx) {
+        const findings = [];
+        for (const agent of ctx.agents) {
+          const highRiskTools = agent.tools.filter((t) => t.type === "bash" || t.type === "file_write" || t.type === "api_call" || t.type === "database");
+          if (highRiskTools.length === 0)
+            continue;
+          const hasDangerousSkip = ctx.config_files.some((f) => f.content.includes("dangerously-skip-permissions") || f.content.includes("dangerouslySkipPermissions"));
+          const hasApprovalHook = ctx.config_files.some((f) => f.content.includes("PreToolUse") && (f.content.includes("block") || f.content.includes("approve")));
+          if (hasDangerousSkip || !hasApprovalHook) {
+            findings.push((0, interface_1.createEnterpriseFinding)(this, {
+              id: `${this.id}-${agent.id}`,
+              title: `Agent "${agent.name}" can execute high-impact actions without approval`,
+              description: `Agent "${agent.name}" has access to ${highRiskTools.map((t) => t.name).join(", ")} (high-impact tools) with ${hasDangerousSkip ? "permissions explicitly skipped" : "no PreToolUse approval hooks detected"}. EU AI Act Article 14 requires human oversight for high-risk AI systems.`,
+              recommendation: "Add PreToolUse hooks that gate high-impact actions. For Claude Code, remove --dangerously-skip-permissions and configure approval hooks in settings.json.",
+              agent_id: agent.id,
+              agent_name: agent.name,
+              framework: agent.framework,
+              remediation_effort: "medium"
+            }));
+          }
+        }
+        return findings;
+      }
+    };
+    exports2.privilegeEscalation = {
+      id: "SF-AC-007",
+      name: "Agent Can Escalate Its Own Privileges",
+      description: "Agent's tool set includes capabilities that could modify its own permissions or create new credentials.",
+      category: "access_control",
+      severity: "critical",
+      frameworks: "all",
+      compliance: COMPLIANCE_AC,
+      phase: "static",
+      evaluate(ctx) {
+        const findings = [];
+        for (const agent of ctx.agents) {
+          const hasBash = agent.tools.some((t) => t.type === "bash");
+          const hasFileWrite = agent.tools.some((t) => t.type === "file_write");
+          if (hasBash && hasFileWrite) {
+            const canModifyConfig = !agent.file_system_access?.blocked_paths?.some((p) => p.includes(".claude") || p.includes("settings"));
+            if (canModifyConfig) {
+              findings.push((0, interface_1.createEnterpriseFinding)(this, {
+                id: `${this.id}-${agent.id}`,
+                title: `Agent "${agent.name}" can modify its own configuration`,
+                description: `Agent has both bash execution and file write access without blocked paths for configuration directories. It could modify .claude/settings.json, install new MCP servers, change its own allowedTools, or create credentials.`,
+                recommendation: "Block write access to .claude/, .sentinelflow/, hooks/, and any configuration directories. Add these paths to file_system_access.blocked_paths.",
+                agent_id: agent.id,
+                agent_name: agent.name,
+                framework: agent.framework,
+                cwe: "CWE-269",
+                remediation_effort: "low"
+              }));
+            }
+          }
+        }
+        return findings;
+      }
+    };
+    exports2.noOwner = {
+      id: "SF-AC-008",
+      name: "Agent Has No Declared Owner",
+      description: "Unowned agents are shadow AI \u2014 no one is accountable for their behavior, security, or compliance.",
+      category: "access_control",
+      severity: "medium",
+      frameworks: "all",
+      compliance: [
+        ...COMPLIANCE_AC,
+        { framework: "ISO_42001", reference: "Clause 5.3", description: "Roles, responsibilities, authorities" }
+      ],
+      phase: "static",
+      evaluate(ctx) {
+        return ctx.agents.filter((a) => !a.owner && !a.team).map((agent) => (0, interface_1.createEnterpriseFinding)(this, {
+          id: `${this.id}-${agent.id}`,
+          title: `Agent "${agent.name}" has no declared owner`,
+          description: `No owner or team assigned. Microsoft's Cyber Pulse report found that organizations often don't know how many agents exist or who owns them \u2014 this is the governance gap.`,
+          recommendation: "Add an owner field to the agent definition or register it with: sentinelflow registry update <id> --owner <name>",
+          agent_id: agent.id,
+          agent_name: agent.name,
+          framework: agent.framework,
+          location: agent.source_file ? { file: agent.source_file } : void 0,
+          remediation_effort: "low"
+        }));
+      }
+    };
+    exports2.ACCESS_CONTROL_RULES = [
+      exports2.hardcodedCredentials,
+      exports2.excessivePermissions,
+      exports2.noHumanInTheLoop,
+      exports2.privilegeEscalation,
+      exports2.noOwner
+    ];
+  }
+});
+
+// packages/scanner/dist/rules/supply-chain.js
+var require_supply_chain = __commonJS({
+  "packages/scanner/dist/rules/supply-chain.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.SUPPLY_CHAIN_RULES = exports2.langchainPassthrough = exports2.configInPublicRepo = exports2.frameworkCVE = exports2.mcpNoAuth = exports2.toolDescriptionPoisoning = exports2.mcpNoIntegrity = void 0;
+    var interface_1 = require_interface();
+    var COMPLIANCE_SC = [
+      { framework: "OWASP_LLM_2025", reference: "LLM03", description: "Supply Chain Vulnerabilities" },
+      { framework: "MITRE_ATLAS", reference: "AML.T0010", description: "ML Supply Chain Compromise" },
+      { framework: "NIST_AI_RMF", reference: "GOVERN 5", description: "AI supply chain management" }
+    ];
+    var INJECTION_PATTERNS_IN_TOOL_DESC = [
+      /\bignore\b.*\bprevious\b.*\binstructions?\b/gi,
+      /\byou\s+(?:are|must|should|will)\b/gi,
+      /\bdo\s+not\b.*\btell\b.*\buser\b/gi,
+      /<!--[\s\S]*?-->/g,
+      /\u200B|\u200C|\u200D|\uFEFF/g
+      // Zero-width characters
+    ];
+    exports2.mcpNoIntegrity = {
+      id: "SF-SC-001",
+      name: "MCP Server Connected Without Integrity Verification",
+      description: "No tool definition hashing, signing, or pinning exists for connected MCP servers. Servers can mutate tool definitions between sessions.",
+      category: "supply_chain",
+      severity: "high",
+      frameworks: "all",
+      compliance: COMPLIANCE_SC,
+      phase: "static",
+      evaluate(ctx) {
+        const findings = [];
+        for (const agent of ctx.agents) {
+          if (agent.mcp_servers && agent.mcp_servers.length > 0) {
+            for (const server of agent.mcp_servers) {
+              findings.push((0, interface_1.createEnterpriseFinding)(this, {
+                id: `${this.id}-${agent.id}-${server.name}`,
+                title: `MCP server "${server.name}" connected without integrity verification`,
+                description: `MCP server "${server.name}" on agent "${agent.name}" has no tool definition hashing or pinning configured. The base MCP specification provides no integrity verification \u2014 a server can silently change tool definitions between sessions (rug-pull attack documented by Invariant Labs, 2025).`,
+                recommendation: "Hash all tool definitions at approval time and verify on each connection. SentinelFlow's Phase 2 interceptors will provide automatic tool definition monitoring.",
+                agent_id: agent.id,
+                agent_name: agent.name,
+                framework: agent.framework,
+                mitre_atlas: "AML.T0010",
+                remediation_effort: "medium"
+              }));
+            }
+          }
+        }
+        return findings;
+      }
+    };
+    exports2.toolDescriptionPoisoning = {
+      id: "SF-SC-003",
+      name: "Tool Description Contains Prompt Injection Patterns",
+      description: "MCP tool descriptions, SKILL.md files, or command definitions contain hidden instructions, Unicode manipulation, or references to credentials.",
+      category: "supply_chain",
+      severity: "critical",
+      frameworks: "all",
+      compliance: COMPLIANCE_SC,
+      phase: "static",
+      evaluate(ctx) {
+        const findings = [];
+        let counter = 0;
+        const skillFiles = ctx.config_files.filter((f) => f.path.includes("SKILL.md") || f.path.includes("/skills/") || f.path.includes("/commands/") || f.path.includes("mcp"));
+        for (const file of skillFiles) {
+          for (const pattern of INJECTION_PATTERNS_IN_TOOL_DESC) {
+            pattern.lastIndex = 0;
+            let match;
+            while ((match = pattern.exec(file.content)) !== null) {
+              const line = file.content.substring(0, match.index).split("\n").length;
+              findings.push((0, interface_1.createEnterpriseFinding)(this, {
+                id: `${this.id}-${counter++}`,
+                title: `Potential prompt injection in tool definition: ${file.path}`,
+                description: `Suspicious pattern found at line ${line}: "${match[0].substring(0, 50)}". Tool descriptions are injected into the agent's context and can override system instructions. This is the tool poisoning attack documented by Invariant Labs.`,
+                recommendation: "Review the flagged content manually. Remove any instructional language from tool descriptions. Tool descriptions should be purely descriptive, not prescriptive.",
+                location: { file: file.path, line, snippet: match[0].substring(0, 80) },
+                mitre_atlas: "AML.T0010.001",
+                remediation_effort: "low"
+              }));
+            }
+          }
+        }
+        return findings;
+      }
+    };
+    exports2.mcpNoAuth = {
+      id: "SF-SC-007",
+      name: "MCP Server Lacks Authentication",
+      description: "HTTP-transport MCP servers should require OAuth 2.0 or bearer token authentication.",
+      category: "supply_chain",
+      severity: "high",
+      frameworks: "all",
+      compliance: COMPLIANCE_SC,
+      phase: "static",
+      evaluate(ctx) {
+        const findings = [];
+        for (const agent of ctx.agents) {
+          if (!agent.mcp_servers)
+            continue;
+          for (const server of agent.mcp_servers) {
+            if (server.url && (server.url.startsWith("http://") || server.url.startsWith("https://"))) {
+              const mcpConfigs = ctx.config_files.filter((f) => f.path.includes("mcp") || f.path.includes("settings"));
+              const hasAuth = mcpConfigs.some((f) => f.content.includes("auth") || f.content.includes("token") || f.content.includes("bearer") || f.content.includes("oauth"));
+              if (!hasAuth) {
+                findings.push((0, interface_1.createEnterpriseFinding)(this, {
+                  id: `${this.id}-${agent.id}-${server.name}`,
+                  title: `MCP server "${server.name}" has no authentication configured`,
+                  description: `HTTP-transport MCP server "${server.name}" (${server.url}) has no authentication. Unauthenticated MCP servers can be accessed by any process on the network.`,
+                  recommendation: "Configure OAuth 2.0 or bearer token authentication for all HTTP-transport MCP servers.",
+                  agent_id: agent.id,
+                  agent_name: agent.name,
+                  cwe: "CWE-306",
+                  remediation_effort: "medium"
+                }));
+              }
+            }
+          }
+        }
+        return findings;
+      }
+    };
+    exports2.frameworkCVE = {
+      id: "SF-SC-009",
+      name: "Agent Framework Has Known Critical CVEs",
+      description: "Check for usage of agent frameworks with documented critical vulnerabilities.",
+      category: "supply_chain",
+      severity: "critical",
+      frameworks: ["langchain", "crewai", "autogen"],
+      compliance: COMPLIANCE_SC,
+      phase: "static",
+      evaluate(ctx) {
+        const findings = [];
+        const KNOWN_VULNERABLE_PATTERNS = [
+          { pattern: /langchain[<>=]*0\.0\./g, name: "LangChain 0.0.x", cves: ["CVE-2023-29374", "CVE-2023-36258", "CVE-2023-36188"] },
+          { pattern: /allow_dangerous_deserialization\s*=\s*True/g, name: "LangChain unsafe deserialization", cves: ["CVE-2024-21511"] },
+          { pattern: /load_chain|load_agent/g, name: "LangChain unsafe chain loading", cves: ["CVE-2023-44467"] }
+        ];
+        for (const file of ctx.config_files) {
+          for (const { pattern, name, cves } of KNOWN_VULNERABLE_PATTERNS) {
+            pattern.lastIndex = 0;
+            if (pattern.test(file.content)) {
+              findings.push((0, interface_1.createEnterpriseFinding)(this, {
+                id: `${this.id}-${findings.length}`,
+                title: `${name} pattern detected in ${file.path}`,
+                description: `Pattern associated with known critical vulnerabilities found. Related CVEs: ${cves.join(", ")}. These vulnerabilities enable arbitrary code execution via prompt injection chains.`,
+                recommendation: "Update to the latest framework version. Replace deprecated APIs with safe alternatives.",
+                location: { file: file.path },
+                cve: cves,
+                remediation_effort: "medium"
+              }));
+            }
+          }
+        }
+        return findings;
+      }
+    };
+    exports2.configInPublicRepo = {
+      id: "SF-SC-008",
+      name: "Agent Configuration Committed to Version Control",
+      description: "Settings files containing MCP configs, hooks, or credentials committed to repository.",
+      category: "supply_chain",
+      severity: "medium",
+      frameworks: "all",
+      compliance: COMPLIANCE_SC,
+      phase: "static",
+      evaluate(ctx) {
+        const findings = [];
+        const fs = require("fs");
+        const path = require("path");
+        const gitignorePath = path.join(ctx.root_dir, ".gitignore");
+        if (!fs.existsSync(gitignorePath))
+          return findings;
+        const gitignore = fs.readFileSync(gitignorePath, "utf-8");
+        const sensitiveFiles = [
+          ".claude/settings.local.json",
+          ".mcp.json",
+          ".env"
+        ];
+        for (const file of sensitiveFiles) {
+          if (!gitignore.includes(file) && !gitignore.includes(file.replace("/", ""))) {
+            const fullPath = path.join(ctx.root_dir, file);
+            if (fs.existsSync(fullPath)) {
+              findings.push((0, interface_1.createEnterpriseFinding)(this, {
+                id: `${this.id}-${findings.length}`,
+                title: `Sensitive file "${file}" may be committed to version control`,
+                description: `"${file}" exists but is not in .gitignore. Agent configuration files containing MCP server configs, local settings, or environment variables should not be committed to version control.`,
+                recommendation: `Add "${file}" to .gitignore. If already committed, rotate any exposed credentials and use git filter-branch or BFG to remove from history.`,
+                location: { file: ".gitignore" },
+                cwe: "CWE-540",
+                remediation_effort: "low"
+              }));
+            }
+          }
+        }
+        return findings;
+      }
+    };
+    exports2.langchainPassthrough = {
+      id: "SF-SC-010",
+      name: "LangChain: Unsanitized RunnablePassthrough to Tools",
+      description: "LangChain chains using RunnablePassthrough forward user input directly to downstream tools without intermediate validation, amplifying prompt injection risk.",
+      category: "supply_chain",
+      severity: "high",
+      frameworks: ["langchain"],
+      compliance: [
+        { framework: "OWASP_LLM_2025", reference: "LLM01", description: "Prompt Injection via passthrough" },
+        { framework: "OWASP_LLM_2025", reference: "LLM05", description: "Improper Output Handling in chain" },
+        { framework: "MITRE_ATLAS", reference: "AML.T0051", description: "LLM Prompt Injection" }
+      ],
+      phase: "static",
+      lifecycle: "experimental",
+      since: "0.2.0",
+      auto_fix: {
+        description: "Replace RunnablePassthrough() with a validation step that sanitizes user input before forwarding to tools.",
+        suggested_config: "# Replace:\n#   RunnablePassthrough()\n# With:\n#   RunnableLambda(validate_and_sanitize)"
+      },
+      known_false_positives: [
+        {
+          condition: "RunnablePassthrough used for metadata forwarding in internal pipelines with no user-facing input",
+          recommended_action: "Suppress with: # sentinelflow-ignore: SF-SC-010 -- Internal pipeline, no user input"
+        }
+      ],
+      framework_compat: [{ framework: "langchain", min_version: "0.2.0" }],
+      evaluate(ctx) {
+        const findings = [];
+        for (const file of ctx.config_files) {
+          if (!file.path.endsWith(".py"))
+            continue;
+          if (!file.content.includes("langchain") && !file.content.includes("langgraph"))
+            continue;
+          const passthroughPattern = /RunnablePassthrough\s*\(\s*\)/g;
+          let match;
+          while ((match = passthroughPattern.exec(file.content)) !== null) {
+            const surroundingLines = file.content.substring(Math.max(0, (match.index ?? 0) - 500), Math.min(file.content.length, (match.index ?? 0) + 500));
+            const hasToolBinding = /\.bind_tools\(|Tool\(|@tool|BaseTool|StructuredTool/.test(surroundingLines);
+            if (hasToolBinding) {
+              const line = file.content.substring(0, match.index ?? 0).split("\n").length;
+              findings.push((0, interface_1.createEnterpriseFinding)(this, {
+                id: `${this.id}-${findings.length}`,
+                title: `Unsanitized passthrough to tool-bound chain in ${file.path}`,
+                description: "RunnablePassthrough() forwards input directly to a chain that binds tools. User-controlled input reaches tool invocations without intermediate validation. This amplifies prompt injection risk \u2014 a malicious prompt can invoke tools with attacker-controlled arguments.",
+                recommendation: "Replace RunnablePassthrough() with a RunnableLambda that validates and sanitizes input before forwarding. At minimum, strip special characters and enforce schema validation on tool arguments. See https://sentinelflow.dev/rules/SF-SC-010",
+                location: { file: file.path, line, snippet: "RunnablePassthrough()" },
+                cwe: "CWE-1427",
+                cve: ["CVE-2025-68664"],
+                remediation_effort: "medium",
+                auto_fix: this.auto_fix
+              }));
+            }
+          }
+        }
+        return findings;
+      }
+    };
+    exports2.SUPPLY_CHAIN_RULES = [
+      exports2.mcpNoIntegrity,
+      exports2.toolDescriptionPoisoning,
+      exports2.mcpNoAuth,
+      exports2.frameworkCVE,
+      exports2.configInPublicRepo,
+      exports2.langchainPassthrough
+    ];
+  }
+});
+
+// packages/scanner/dist/rules/data-governance.js
+var require_data_governance = __commonJS({
+  "packages/scanner/dist/rules/data-governance.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.DATA_GOVERNANCE_RULES = exports2.unrestrrictedFileWrite = exports2.crossEnvironmentAccess = exports2.noDataClassification = void 0;
+    var interface_1 = require_interface();
+    var COMPLIANCE_DG = [
+      { framework: "GDPR", reference: "Article 25", description: "Data protection by design" },
+      { framework: "EU_AI_ACT", reference: "Article 10", description: "Data and data governance" },
+      { framework: "NIST_AI_RMF", reference: "MAP 3", description: "AI data governance" }
+    ];
+    exports2.noDataClassification = {
+      id: "SF-DG-002",
+      name: "No Data Classification on Agent Data Sources",
+      description: "Agent accesses data sources without classification metadata, making it impossible to enforce data flow policies.",
+      category: "data_governance",
+      severity: "medium",
+      frameworks: "all",
+      compliance: COMPLIANCE_DG,
+      phase: "static",
+      evaluate(ctx) {
+        return ctx.agents.filter((a) => a.data_sources.length > 0).filter((a) => a.data_sources.some((ds) => !ds.classification || ds.classification.length === 0)).map((agent) => (0, interface_1.createEnterpriseFinding)(this, {
+          id: `${this.id}-${agent.id}`,
+          title: `Agent "${agent.name}" accesses unclassified data sources`,
+          description: `Agent "${agent.name}" accesses ${agent.data_sources.filter((ds) => !ds.classification || ds.classification.length === 0).length} data source(s) without classification metadata. Without classification, data flow policies cannot be enforced \u2014 PII could flow from a confidential source to a public channel.`,
+          recommendation: "Add data classification metadata (pii, phi, financial, confidential, internal, public) to each data source in the agent configuration.",
+          agent_id: agent.id,
+          agent_name: agent.name,
+          framework: agent.framework,
+          remediation_effort: "medium"
+        }));
+      }
+    };
+    exports2.crossEnvironmentAccess = {
+      id: "SF-DG-006",
+      name: "Agent Bridges Production and Non-Production Environments",
+      description: "Agents with tool access spanning production and development environments can copy sensitive data across boundaries.",
+      category: "data_governance",
+      severity: "high",
+      frameworks: "all",
+      compliance: [
+        ...COMPLIANCE_DG,
+        { framework: "SOC2", reference: "CC6.1", description: "Logical access security" }
+      ],
+      phase: "static",
+      evaluate(ctx) {
+        const findings = [];
+        const prodIndicators = /\b(prod|production|live|main)\b/i;
+        const devIndicators = /\b(dev|development|staging|test|sandbox|local)\b/i;
+        for (const agent of ctx.agents) {
+          if (!agent.mcp_servers || agent.mcp_servers.length < 2)
+            continue;
+          const hasProd = agent.mcp_servers.some((s) => prodIndicators.test(s.name) || s.url && prodIndicators.test(s.url));
+          const hasDev = agent.mcp_servers.some((s) => devIndicators.test(s.name) || s.url && devIndicators.test(s.url));
+          if (hasProd && hasDev) {
+            findings.push((0, interface_1.createEnterpriseFinding)(this, {
+              id: `${this.id}-${agent.id}`,
+              title: `Agent "${agent.name}" bridges production and non-production environments`,
+              description: `Agent has MCP servers connecting to both production and development/staging environments. This creates a data path that bypasses environment isolation controls.`,
+              recommendation: "Separate agents by environment. Use distinct agent configurations for production and non-production, with no cross-environment tool access.",
+              agent_id: agent.id,
+              agent_name: agent.name,
+              framework: agent.framework,
+              remediation_effort: "medium"
+            }));
+          }
+        }
+        return findings;
+      }
+    };
+    exports2.unrestrrictedFileWrite = {
+      id: "SF-DG-003",
+      name: "Unrestricted File System Write Access",
+      description: "Agent can write to the file system without path restrictions, creating uncontrolled data copies.",
+      category: "data_governance",
+      severity: "critical",
+      frameworks: "all",
+      compliance: [
+        ...COMPLIANCE_DG,
+        { framework: "HIPAA", reference: "\xA7164.312(a)(1)", description: "Access control" }
+      ],
+      phase: "static",
+      evaluate(ctx) {
+        return ctx.agents.filter((a) => a.tools.some((t) => t.type === "file_write")).filter((a) => !a.file_system_access?.write_paths || a.file_system_access.write_paths.length === 0).map((agent) => (0, interface_1.createEnterpriseFinding)(this, {
+          id: `${this.id}-${agent.id}`,
+          title: `Agent "${agent.name}" has unrestricted file system write access`,
+          description: `Agent can write to any path with no restrictions. This enables overwriting configuration files, injecting code, creating unaudited data copies, or exfiltrating data to accessible filesystem locations.`,
+          recommendation: "Define explicit write_paths restricting writes to the project directory. Block .env, .git/, .claude/, and system configuration paths.",
+          agent_id: agent.id,
+          agent_name: agent.name,
+          framework: agent.framework,
+          location: agent.source_file ? { file: agent.source_file } : void 0,
+          cwe: "CWE-732",
+          remediation_effort: "low"
+        }));
+      }
+    };
+    exports2.DATA_GOVERNANCE_RULES = [
+      exports2.noDataClassification,
+      exports2.crossEnvironmentAccess,
+      exports2.unrestrrictedFileWrite
+    ];
+  }
+});
+
+// packages/scanner/dist/rules/cost-governance.js
+var require_cost_governance = __commonJS({
+  "packages/scanner/dist/rules/cost-governance.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.COST_GOVERNANCE_RULES = exports2.noCostAttribution = exports2.expensiveModelForSimpleTasks = exports2.noTimeout = exports2.noIterationLimit = exports2.noTokenBudget = void 0;
+    var interface_1 = require_interface();
+    var COMPLIANCE_CG = [
+      { framework: "OWASP_LLM_2025", reference: "LLM10", description: "Unbounded Consumption" },
+      { framework: "NIST_AI_RMF", reference: "MANAGE 2", description: "Resource management" }
+    ];
+    exports2.noTokenBudget = {
+      id: "SF-CG-001",
+      name: "No Token Budget Configured",
+      description: "Agent has no token or cost budget, allowing unlimited API consumption.",
+      category: "cost_governance",
+      severity: "medium",
+      frameworks: "all",
+      compliance: COMPLIANCE_CG,
+      phase: "static",
+      evaluate(ctx) {
+        return ctx.agents.filter((a) => !a.governance.token_budget).map((agent) => (0, interface_1.createEnterpriseFinding)(this, {
+          id: `${this.id}-${agent.id}`,
+          title: `Agent "${agent.name}" has no cost budget`,
+          description: `No token or cost budget defined. Runaway agent loops and unexpected usage spikes can result in thousands of dollars in API costs. Multiple documented incidents of AutoGPT instances accumulating $1,000+ in hours.`,
+          recommendation: "Define token_budget with monthly_limit and daily_limit in the agent's governance configuration.",
+          agent_id: agent.id,
+          agent_name: agent.name,
+          framework: agent.framework,
+          remediation_effort: "low"
+        }));
+      }
+    };
+    exports2.noIterationLimit = {
+      id: "SF-CG-002",
+      name: "No Maximum Iteration Limit on Agent Loops",
+      description: "Agent framework has no max_iterations or equivalent configured.",
+      category: "cost_governance",
+      severity: "high",
+      frameworks: ["langchain", "crewai", "autogen"],
+      compliance: COMPLIANCE_CG,
+      phase: "static",
+      evaluate(ctx) {
+        const findings = [];
+        const hasIterLimit = ctx.config_files.some((f) => f.content.includes("max_iterations") || f.content.includes("max_iter") || f.content.includes("maxIterations") || f.content.includes("max_turns") || f.content.includes("iteration_limit"));
+        if (!hasIterLimit && ctx.agents.some((a) => ["langchain", "crewai", "autogen"].includes(a.framework))) {
+          findings.push((0, interface_1.createEnterpriseFinding)(this, {
+            id: `${this.id}-global`,
+            title: "No iteration limit detected for agent execution loops",
+            description: "No max_iterations, max_turns, or equivalent configuration found. Without iteration limits, an agent in a reasoning loop can make unlimited API calls.",
+            recommendation: "Set max_iterations in your agent framework configuration. Recommended: 10-25 for simple tasks, 50-100 for complex multi-step tasks.",
+            remediation_effort: "low"
+          }));
+        }
+        return findings;
+      }
+    };
+    exports2.noTimeout = {
+      id: "SF-CG-003",
+      name: "No Circuit Breaker or Timeout Configured",
+      description: "Agent tasks have no wall-clock time limits or deadman's switch.",
+      category: "cost_governance",
+      severity: "medium",
+      frameworks: "all",
+      compliance: COMPLIANCE_CG,
+      phase: "static",
+      evaluate(ctx) {
+        const findings = [];
+        const hasTimeout = ctx.config_files.some((f) => f.content.includes("timeout") || f.content.includes("max_time") || f.content.includes("deadline") || f.content.includes("circuit_breaker"));
+        if (!hasTimeout && ctx.agents.length > 0) {
+          findings.push((0, interface_1.createEnterpriseFinding)(this, {
+            id: `${this.id}-global`,
+            title: "No timeout or circuit breaker configured for agent execution",
+            description: "No timeout, deadline, or circuit breaker configuration detected. Agent tasks could run indefinitely consuming resources.",
+            recommendation: "Configure timeouts for all agent tasks. Add hook-based deadman switches that require human confirmation after N minutes of continuous execution.",
+            remediation_effort: "low"
+          }));
+        }
+        return findings;
+      }
+    };
+    exports2.expensiveModelForSimpleTasks = {
+      id: "SF-CG-004",
+      name: "Expensive Model Used Without Routing Strategy",
+      description: "All agent tasks route to a single expensive model without tiered model routing.",
+      category: "cost_governance",
+      severity: "low",
+      frameworks: "all",
+      compliance: COMPLIANCE_CG,
+      phase: "static",
+      evaluate(ctx) {
+        const findings = [];
+        const expensiveModels = ["opus", "gpt-4", "gpt-4o", "claude-3-opus"];
+        for (const agent of ctx.agents) {
+          if (agent.model && expensiveModels.some((m) => agent.model.toLowerCase().includes(m))) {
+            if (!agent.model_routing || agent.model_routing.length === 0) {
+              findings.push((0, interface_1.createEnterpriseFinding)(this, {
+                id: `${this.id}-${agent.id}`,
+                title: `Agent "${agent.name}" uses expensive model "${agent.model}" with no routing`,
+                description: `All tasks route to ${agent.model} without tiered model routing. The cost difference between Opus/GPT-4 and Haiku/GPT-3.5 is 30-100x for simple tasks.`,
+                recommendation: "Implement tiered model routing: simple tasks \u2192 Haiku/Flash, moderate tasks \u2192 Sonnet, complex tasks \u2192 Opus.",
+                agent_id: agent.id,
+                agent_name: agent.name,
+                framework: agent.framework,
+                remediation_effort: "medium"
+              }));
+            }
+          }
+        }
+        return findings;
+      }
+    };
+    exports2.noCostAttribution = {
+      id: "SF-CG-007",
+      name: "No Cost Attribution or Monitoring",
+      description: "Agent API costs are not tagged by team, project, or task type.",
+      category: "cost_governance",
+      severity: "low",
+      frameworks: "all",
+      compliance: COMPLIANCE_CG,
+      phase: "static",
+      evaluate(ctx) {
+        const findings = [];
+        const hasCostTracking = ctx.config_files.some((f) => f.content.includes("cost") || f.content.includes("budget") || f.content.includes("billing") || f.content.includes("usage_tracking"));
+        if (!hasCostTracking && ctx.agents.length > 0) {
+          findings.push((0, interface_1.createEnterpriseFinding)(this, {
+            id: `${this.id}-global`,
+            title: "No cost attribution or monitoring infrastructure detected",
+            description: "No evidence of cost tracking, budget monitoring, or usage attribution found. Without attribution, cost overruns cannot be traced to specific agents or teams.",
+            recommendation: "Configure SentinelFlow's cost governance module or integrate with your cloud provider's cost management tools. Tag API calls by agent, team, and project.",
+            remediation_effort: "medium"
+          }));
+        }
+        return findings;
+      }
+    };
+    exports2.COST_GOVERNANCE_RULES = [
+      exports2.noTokenBudget,
+      exports2.noIterationLimit,
+      exports2.noTimeout,
+      exports2.expensiveModelForSimpleTasks,
+      exports2.noCostAttribution
+    ];
+  }
+});
+
+// packages/scanner/dist/rules/framework-config.js
+var require_framework_config = __commonJS({
+  "packages/scanner/dist/rules/framework-config.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.FRAMEWORK_CONFIG_RULES = exports2.cursorAlwaysApplyBroadGlob = exports2.codexFullAutoMode = exports2.noDescription = exports2.unrestrictedDelegation = exports2.unsafeDeserialization = exports2.gitHookBypass = exports2.wildcardBashPermissions = exports2.dangerouslySkipPermissions = void 0;
+    var interface_1 = require_interface();
+    var COMPLIANCE_FC = [
+      { framework: "OWASP_LLM_2025", reference: "LLM06", description: "Excessive Agency" },
+      { framework: "NIST_AI_RMF", reference: "GOVERN 1", description: "Governance policies" }
+    ];
+    exports2.dangerouslySkipPermissions = {
+      id: "SF-FC-001",
+      name: "Claude Code: Permission Checks Disabled",
+      description: "The --dangerously-skip-permissions flag disables all interactive permission checks, allowing unrestricted system access.",
+      category: "framework_config",
+      severity: "critical",
+      frameworks: ["claude-code"],
+      compliance: COMPLIANCE_FC,
+      phase: "static",
+      // ─── Lifecycle (Phase 1.5) ────────────────────────────────
+      lifecycle: "stable",
+      since: "0.1.0",
+      auto_fix: {
+        description: "Remove dangerouslySkipPermissions from settings.json and use granular tool allowlists instead.",
+        file_pattern: ".claude/settings.json",
+        find: '"dangerouslySkipPermissions": true',
+        replace: "",
+        suggested_config: '{\n  "allowedTools": [\n    "Read",\n    "Bash(npm test)",\n    "Bash(npm run build)",\n    "Bash(git diff)"\n  ]\n}'
+      },
+      known_false_positives: [
+        {
+          condition: "CI/CD sandboxed environment with no production access, no secrets, and ephemeral compute",
+          recommended_action: "Suppress with: # sentinelflow-ignore: SF-FC-001 -- CI sandbox per SEC-XXXX"
+        },
+        {
+          condition: "Documentation or example files that reference the flag without actually enabling it",
+          recommended_action: "Suppress with policy file: exclude docs/ and examples/ directories"
+        }
+      ],
+      framework_compat: [
+        { framework: "claude-code", min_version: "1.0.0" }
+      ],
+      evaluate(ctx) {
+        const findings = [];
+        for (const file of ctx.config_files) {
+          if (file.content.includes("dangerously-skip-permissions") || file.content.includes("dangerouslySkipPermissions")) {
+            const line = file.content.substring(0, file.content.indexOf("dangerously")).split("\n").length;
+            findings.push((0, interface_1.createEnterpriseFinding)(this, {
+              id: `${this.id}-${findings.length}`,
+              title: "--dangerously-skip-permissions detected",
+              description: "The --dangerously-skip-permissions flag removes all interactive approval gates. The agent can execute arbitrary bash commands, modify any file, and access any network resource without user confirmation. Only acceptable in fully sandboxed CI/CD environments with no access to production systems.",
+              recommendation: "Remove --dangerously-skip-permissions. Configure granular tool permissions in .claude/settings.json instead. Use PreToolUse hooks for approval workflows.",
+              location: { file: file.path, line },
+              cwe: "CWE-862",
+              remediation_effort: "low"
+            }));
+          }
+        }
+        return findings;
+      }
+    };
+    exports2.wildcardBashPermissions = {
+      id: "SF-FC-002",
+      name: "Claude Code: Wildcard Bash Permissions",
+      description: 'Configurations with "Bash(*)" remove all command-specific approval gates.',
+      category: "framework_config",
+      severity: "high",
+      frameworks: ["claude-code"],
+      compliance: COMPLIANCE_FC,
+      phase: "static",
+      evaluate(ctx) {
+        const findings = [];
+        for (const file of ctx.config_files) {
+          const patterns = [/Bash\(\*\)/g, /Bash\(true\)/gi, /"Bash"/g];
+          for (const pattern of patterns) {
+            pattern.lastIndex = 0;
+            let match;
+            while ((match = pattern.exec(file.content)) !== null) {
+              if (match[0] === '"Bash"' && file.content.includes("allowedTools")) {
+                const line = file.content.substring(0, match.index).split("\n").length;
+                findings.push((0, interface_1.createEnterpriseFinding)(this, {
+                  id: `${this.id}-${findings.length}`,
+                  title: `Unrestricted Bash access in ${file.path}`,
+                  description: 'Bash listed in allowedTools without command restrictions. This grants the agent ability to execute any shell command. Use granular permissions: "Bash(npm test)", "Bash(git diff)" instead of "Bash" or "Bash(*)".',
+                  recommendation: 'Replace unrestricted Bash access with specific command allowlists: "Bash(npm test)", "Bash(npm run build)", "Bash(git diff)".',
+                  location: { file: file.path, line, snippet: match[0] },
+                  remediation_effort: "low"
+                }));
+              }
+            }
+          }
+        }
+        return findings;
+      }
+    };
+    exports2.gitHookBypass = {
+      id: "SF-FC-003",
+      name: "Git Safety Bypass Patterns",
+      description: "Detects --no-verify, force push, and hook skip patterns that bypass git safety controls.",
+      category: "framework_config",
+      severity: "high",
+      frameworks: "all",
+      compliance: [
+        ...COMPLIANCE_FC,
+        { framework: "SOC2", reference: "CC8.1", description: "Change management" }
+      ],
+      phase: "static",
+      evaluate(ctx) {
+        const findings = [];
+        const GIT_BYPASS = [
+          { pattern: /--no-verify/g, name: "--no-verify flag", sev: "high" },
+          { pattern: /--force-push|git\s+push\s+.*(?:--force|-f)\b/g, name: "force push", sev: "high" },
+          { pattern: /GIT_HOOKS_SKIP|HUSKY\s*=\s*0/g, name: "hook skip env var", sev: "high" },
+          { pattern: /pre-commit\s+.*(?:disable|skip|uninstall)/g, name: "pre-commit disable", sev: "medium" }
+        ];
+        for (const file of ctx.config_files) {
+          for (const { pattern, name } of GIT_BYPASS) {
+            pattern.lastIndex = 0;
+            let match;
+            while ((match = pattern.exec(file.content)) !== null) {
+              const line = file.content.substring(0, match.index).split("\n").length;
+              findings.push((0, interface_1.createEnterpriseFinding)(this, {
+                id: `${this.id}-${findings.length}`,
+                title: `Git ${name} detected in ${file.path}`,
+                description: `${name} at line ${line} allows bypassing git hooks that prevent committing secrets, enforce formatting, and run tests.`,
+                recommendation: "Remove git hook bypass patterns. If agents need to commit, ensure they go through standard git hooks.",
+                location: { file: file.path, line, snippet: match[0] },
+                cwe: "CWE-693",
+                remediation_effort: "low"
+              }));
+            }
+          }
+        }
+        return findings;
+      }
+    };
+    exports2.unsafeDeserialization = {
+      id: "SF-FC-005",
+      name: "Unsafe Deserialization Enabled",
+      description: "Loading serialized agents/chains from untrusted sources with pickle format enables remote code execution.",
+      category: "framework_config",
+      severity: "critical",
+      frameworks: ["langchain", "custom"],
+      compliance: COMPLIANCE_FC,
+      phase: "static",
+      evaluate(ctx) {
+        const findings = [];
+        for (const file of ctx.config_files) {
+          const patterns = [
+            { pattern: /allow_dangerous_deserialization\s*=\s*True/g, name: "dangerous deserialization flag" },
+            { pattern: /pickle\.load|torch\.load|joblib\.load/g, name: "unsafe deserialization call" },
+            { pattern: /\.pkl\b|\.pickle\b|\.pt\b|\.pth\b/g, name: "pickle file reference" }
+          ];
+          for (const { pattern, name } of patterns) {
+            pattern.lastIndex = 0;
+            let match;
+            while ((match = pattern.exec(file.content)) !== null) {
+              const line = file.content.substring(0, match.index).split("\n").length;
+              findings.push((0, interface_1.createEnterpriseFinding)(this, {
+                id: `${this.id}-${findings.length}`,
+                title: `${name} in ${file.path}`,
+                description: `Unsafe deserialization at line ${line}. Pickle-format files enable arbitrary code execution during loading. JFrog found ~100 malicious models on Hugging Face using this exact vector.`,
+                recommendation: "Use safe serialization formats (safetensors, JSON, GGUF). Never load pickle files from untrusted sources. Set allow_dangerous_deserialization=False.",
+                location: { file: file.path, line, snippet: match[0] },
+                cwe: "CWE-502",
+                cve: ["CVE-2024-21511"],
+                remediation_effort: "medium"
+              }));
+            }
+          }
+        }
+        return findings;
+      }
+    };
+    exports2.unrestrictedDelegation = {
+      id: "SF-FC-006",
+      name: "Unrestricted Agent Delegation",
+      description: "Agent can delegate tasks to any other agent without restrictions (CrewAI allow_delegation=True default).",
+      category: "framework_config",
+      severity: "medium",
+      frameworks: ["crewai", "autogen", "custom"],
+      compliance: COMPLIANCE_FC,
+      phase: "static",
+      evaluate(ctx) {
+        const findings = [];
+        for (const file of ctx.config_files) {
+          if (file.content.includes("allow_delegation") && !file.content.includes("allow_delegation=False") && !file.content.includes("allow_delegation: false")) {
+            findings.push((0, interface_1.createEnterpriseFinding)(this, {
+              id: `${this.id}-${findings.length}`,
+              title: `Unrestricted delegation enabled in ${file.path}`,
+              description: "Agent delegation is enabled without restrictions. Any agent can delegate to any other agent, enabling privilege escalation and prompt injection propagation.",
+              recommendation: "Set allow_delegation=False by default. Enable selectively with explicit delegation targets and scope restrictions.",
+              location: { file: file.path },
+              remediation_effort: "low"
+            }));
+          }
+        }
+        return findings;
+      }
+    };
+    exports2.noDescription = {
+      id: "SF-FC-007",
+      name: "Agent Has No Description or Purpose",
+      description: "Agent lacks a description, making governance review and compliance documentation impossible.",
+      category: "framework_config",
+      severity: "low",
+      frameworks: "all",
+      compliance: [
+        { framework: "ISO_42001", reference: "A.6.2", description: "AI system documentation" },
+        { framework: "EU_AI_ACT", reference: "Article 11", description: "Technical documentation" }
+      ],
+      phase: "static",
+      evaluate(ctx) {
+        return ctx.agents.filter((a) => !a.description || a.description.trim() === "").map((agent) => (0, interface_1.createEnterpriseFinding)(this, {
+          id: `${this.id}-${agent.id}`,
+          title: `Agent "${agent.name}" has no description`,
+          description: "Agent lacks a purpose statement. For governance and EU AI Act compliance, every agent needs clear documentation of what it does.",
+          recommendation: "Add a description field to the agent definition.",
+          agent_id: agent.id,
+          agent_name: agent.name,
+          framework: agent.framework,
+          location: agent.source_file ? { file: agent.source_file } : void 0,
+          remediation_effort: "low"
+        }));
+      }
+    };
+    exports2.codexFullAutoMode = {
+      id: "SF-FC-008",
+      name: "Codex CLI: Full-Auto Mode Enabled",
+      description: "Codex CLI approval_mode is set to 'full-auto', granting the agent unrestricted code execution and file modification without human approval.",
+      category: "framework_config",
+      severity: "critical",
+      frameworks: ["codex"],
+      compliance: [
+        { framework: "OWASP_LLM_2025", reference: "LLM06", description: "Excessive Agency \u2014 no approval gates" },
+        { framework: "EU_AI_ACT", reference: "Article 14", description: "Human oversight requirement" },
+        { framework: "NIST_AI_RMF", reference: "MANAGE 2.4", description: "Override mechanisms absent" }
+      ],
+      phase: "static",
+      lifecycle: "stable",
+      since: "0.2.0",
+      auto_fix: {
+        description: "Change approval_mode from 'full-auto' to 'suggest' or 'auto-edit' in .codex/config.toml.",
+        find: 'approval_mode = "full-auto"',
+        replace: 'approval_mode = "suggest"',
+        suggested_config: 'model = "o4-mini"\napproval_mode = "suggest"'
+      },
+      known_false_positives: [
+        {
+          condition: "Sandboxed CI/CD environment with ephemeral compute and no production access",
+          recommended_action: "Suppress with: # sentinelflow-ignore: SF-FC-008 -- CI sandbox per SEC-XXXX"
+        }
+      ],
+      framework_compat: [{ framework: "codex", min_version: "0.1.0" }],
+      evaluate(ctx) {
+        const findings = [];
+        for (const file of ctx.config_files) {
+          if (!file.path.includes(".codex") && !file.path.endsWith("config.toml"))
+            continue;
+          const autoMatch = file.content.match(/approval_mode\s*=\s*["']full-auto["']/);
+          if (autoMatch) {
+            const line = file.content.substring(0, autoMatch.index ?? 0).split("\n").length;
+            findings.push((0, interface_1.createEnterpriseFinding)(this, {
+              id: `${this.id}-${findings.length}`,
+              title: "Codex CLI running in full-auto mode",
+              description: "The approval_mode is set to 'full-auto' in .codex/config.toml. This grants the Codex agent unrestricted ability to execute code, modify files, and run shell commands without any human confirmation. This is equivalent to Claude Code's --dangerously-skip-permissions flag.",
+              recommendation: 'Change approval_mode to "suggest" (safest) or "auto-edit" (allows file edits but requires approval for shell commands) in .codex/config.toml. See https://sentinelflow.dev/rules/SF-FC-008',
+              location: { file: file.path, line, snippet: 'approval_mode = "full-auto"' },
+              cwe: "CWE-862",
+              remediation_effort: "low",
+              auto_fix: this.auto_fix
+            }));
+          }
+        }
+        return findings;
+      }
+    };
+    exports2.cursorAlwaysApplyBroadGlob = {
+      id: "SF-FC-009",
+      name: "Cursor: AlwaysApply Rule with Broad Glob Pattern",
+      description: "A Cursor .mdc rule file uses alwaysApply: true with a broad glob pattern (e.g., '**/*'), silently injecting instructions into every agent interaction without user review.",
+      category: "framework_config",
+      severity: "high",
+      frameworks: ["cursor"],
+      compliance: [
+        { framework: "OWASP_LLM_2025", reference: "LLM01", description: "Prompt Injection via auto-applied rules" },
+        { framework: "OWASP_LLM_2025", reference: "LLM06", description: "Excessive Agency \u2014 unreviewed rule injection" },
+        { framework: "EU_AI_ACT", reference: "Article 14", description: "Human oversight bypassed by auto-apply" }
+      ],
+      phase: "static",
+      lifecycle: "stable",
+      since: "0.2.0",
+      auto_fix: {
+        description: "Change alwaysApply to false and use specific glob patterns instead of **/*.",
+        find: "alwaysApply: true",
+        replace: "alwaysApply: false"
+      },
+      known_false_positives: [
+        {
+          condition: "Project-wide coding standards (formatting, language preferences) that are intentionally global",
+          recommended_action: "Suppress with: # sentinelflow-ignore: SF-FC-009 -- Global coding standard, reviewed by team"
+        }
+      ],
+      framework_compat: [{ framework: "cursor" }],
+      evaluate(ctx) {
+        const findings = [];
+        for (const file of ctx.config_files) {
+          if (!file.path.endsWith(".mdc"))
+            continue;
+          const hasAlwaysApply = /alwaysApply:\s*true/i.test(file.content);
+          const hasBroadGlob = /globs:\s*["']?\*\*\/?\*["']?/i.test(file.content) || /globs:\s*["']?\*["']?\s*$/m.test(file.content);
+          if (hasAlwaysApply && hasBroadGlob) {
+            findings.push((0, interface_1.createEnterpriseFinding)(this, {
+              id: `${this.id}-${findings.length}`,
+              title: `Cursor rule auto-applies to all files: ${file.path}`,
+              description: "This .mdc rule uses alwaysApply: true with a glob pattern matching all files. The rule's instructions are silently injected into every Cursor interaction without user review. A malicious or overly broad rule here effectively becomes a persistent prompt injection vector \u2014 especially dangerous in shared repos.",
+              recommendation: "Set alwaysApply: false and use specific glob patterns (e.g., '**/*.ts' instead of '**/*'). Review the rule content for any tool access or behavioral instructions that should require explicit user activation. See https://sentinelflow.dev/rules/SF-FC-009",
+              location: { file: file.path, snippet: "alwaysApply: true" },
+              remediation_effort: "low",
+              auto_fix: this.auto_fix
+            }));
+          }
+        }
+        return findings;
+      }
+    };
+    exports2.FRAMEWORK_CONFIG_RULES = [
+      exports2.dangerouslySkipPermissions,
+      exports2.wildcardBashPermissions,
+      exports2.gitHookBypass,
+      exports2.unsafeDeserialization,
+      exports2.unrestrictedDelegation,
+      exports2.noDescription,
+      exports2.codexFullAutoMode,
+      exports2.cursorAlwaysApplyBroadGlob
+    ];
+  }
+});
+
+// packages/scanner/dist/rules/multi-agent.js
+var require_multi_agent = __commonJS({
+  "packages/scanner/dist/rules/multi-agent.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.MULTI_AGENT_RULES = exports2.multiFrameworkConfigDrift = exports2.crewaiHierarchicalNoLimits = exports2.noOutputValidationBetweenAgents = exports2.privilegeEscalationViaDelegate = exports2.noDelegationDepthLimit = void 0;
+    var interface_1 = require_interface();
+    var COMPLIANCE_MA = [
+      { framework: "OWASP_LLM_2025", reference: "LLM06", description: "Excessive Agency" },
+      { framework: "MITRE_ATLAS", reference: "AML.T0051.002", description: "Indirect prompt injection" },
+      { framework: "NIST_AI_RMF", reference: "MANAGE 1", description: "AI risk management" }
+    ];
+    exports2.noDelegationDepthLimit = {
+      id: "SF-MA-001",
+      name: "Delegation Chain Has No Depth Limit",
+      description: "Multi-agent delegation with no maximum hop count enables infinite loops and authorization erosion.",
+      category: "multi_agent",
+      severity: "high",
+      frameworks: "all",
+      compliance: COMPLIANCE_MA,
+      phase: "static",
+      evaluate(ctx) {
+        const findings = [];
+        const hasMultiAgent = ctx.agents.some((a) => a.delegates_to && a.delegates_to.length > 0) || ctx.agents.filter((a) => a.swarm_role !== "standalone").length > 1;
+        if (hasMultiAgent) {
+          const hasDepthLimit = ctx.config_files.some((f) => f.content.includes("max_depth") || f.content.includes("max_hops") || f.content.includes("delegation_limit") || f.content.includes("ttl"));
+          if (!hasDepthLimit) {
+            findings.push((0, interface_1.createEnterpriseFinding)(this, {
+              id: `${this.id}-global`,
+              title: "Multi-agent delegation chain has no depth limit",
+              description: "Multiple agents with delegation relationships detected but no maximum delegation depth configured. Each hop may lose authorization context, and unbounded chains enable infinite loops.",
+              recommendation: "Configure a maximum delegation depth (recommended: 3-5 hops). Implement TTL counters that decrement with each delegation step.",
+              remediation_effort: "medium"
+            }));
+          }
+        }
+        return findings;
+      }
+    };
+    exports2.privilegeEscalationViaDelegate = {
+      id: "SF-MA-003",
+      name: "Delegation to Higher-Privilege Agent",
+      description: "An agent delegates to another agent with broader tool access or data permissions.",
+      category: "multi_agent",
+      severity: "high",
+      frameworks: "all",
+      compliance: COMPLIANCE_MA,
+      phase: "static",
+      evaluate(ctx) {
+        const findings = [];
+        const agentMap = new Map(ctx.agents.map((a) => [a.id, a]));
+        for (const agent of ctx.agents) {
+          if (!agent.delegates_to)
+            continue;
+          for (const delegateId of agent.delegates_to) {
+            const delegate = agentMap.get(delegateId);
+            if (!delegate)
+              continue;
+            if (delegate.tools.length > agent.tools.length) {
+              const extraTools = delegate.tools.filter((dt) => !agent.tools.some((at) => at.name === dt.name));
+              if (extraTools.some((t) => t.risk_level === "high" || t.risk_level === "critical")) {
+                findings.push((0, interface_1.createEnterpriseFinding)(this, {
+                  id: `${this.id}-${agent.id}-${delegateId}`,
+                  title: `"${agent.name}" delegates to higher-privilege "${delegate.name}"`,
+                  description: `Agent "${agent.name}" can delegate to "${delegate.name}" which has access to high-risk tools not available to the delegating agent: ${extraTools.map((t) => t.name).join(", ")}. This is a confused deputy vulnerability.`,
+                  recommendation: "Ensure delegated agents have equal or lesser permissions than the delegator. Implement authorization checks that propagate the original user's scope.",
+                  agent_id: agent.id,
+                  agent_name: agent.name,
+                  cwe: "CWE-441",
+                  remediation_effort: "medium"
+                }));
+              }
+            }
+          }
+        }
+        return findings;
+      }
+    };
+    exports2.noOutputValidationBetweenAgents = {
+      id: "SF-MA-006",
+      name: "No Output Validation Between Agent Steps",
+      description: "In multi-agent workflows, one agent's output becomes the next agent's input without validation, enabling prompt injection cascades.",
+      category: "multi_agent",
+      severity: "medium",
+      frameworks: "all",
+      compliance: COMPLIANCE_MA,
+      phase: "static",
+      evaluate(ctx) {
+        const findings = [];
+        const multiAgentCount = ctx.agents.filter((a) => a.swarm_role !== "standalone").length;
+        if (multiAgentCount >= 2) {
+          const hasValidation = ctx.config_files.some((f) => f.content.includes("output_validator") || f.content.includes("output_parser") || f.content.includes("validate_output") || f.content.includes("schema_validation"));
+          if (!hasValidation) {
+            findings.push((0, interface_1.createEnterpriseFinding)(this, {
+              id: `${this.id}-global`,
+              title: `${multiAgentCount} agents in pipeline with no inter-agent output validation`,
+              description: "Multi-agent workflow detected but no output validation between agent steps. A prompt injection in one agent's output will propagate to downstream agents \u2014 the 'prompt infection' vector demonstrated in 2024 research.",
+              recommendation: "Add schema validation or output sanitization between each agent step. Use structured output formats (JSON Schema, Pydantic) rather than passing raw text.",
+              remediation_effort: "high"
+            }));
+          }
+        }
+        return findings;
+      }
+    };
+    exports2.crewaiHierarchicalNoLimits = {
+      id: "SF-MA-007",
+      name: "CrewAI: Hierarchical Process Without Delegation Limits",
+      description: "CrewAI crew uses hierarchical process with a manager agent that can delegate tasks to workers, who may further delegate \u2014 creating recursive chains without depth limits.",
+      category: "multi_agent",
+      severity: "high",
+      frameworks: ["crewai"],
+      compliance: [
+        { framework: "OWASP_LLM_2025", reference: "LLM06", description: "Excessive Agency via hierarchical delegation" },
+        { framework: "OWASP_LLM_2025", reference: "LLM10", description: "Unbounded Consumption from recursive delegation" },
+        { framework: "EU_AI_ACT", reference: "Article 9", description: "Risk management for multi-agent systems" }
+      ],
+      phase: "static",
+      lifecycle: "stable",
+      since: "0.2.0",
+      auto_fix: {
+        description: "Add max_delegation_depth or set allow_delegation: false on worker agents in crew.yaml.",
+        suggested_config: "researcher:\n  role: Senior Researcher\n  allow_delegation: false  # Prevent recursive delegation"
+      },
+      known_false_positives: [
+        {
+          condition: "Small crews (2-3 agents) where delegation is intentionally flat",
+          recommended_action: "Suppress with: # sentinelflow-ignore: SF-MA-007 -- Flat crew, 2 agents only"
+        }
+      ],
+      framework_compat: [{ framework: "crewai", min_version: "0.30.0" }],
+      evaluate(ctx) {
+        const findings = [];
+        for (const file of ctx.config_files) {
+          if (!file.path.match(/crew\.ya?ml$|agents\.ya?ml$/))
+            continue;
+          const hasHierarchical = /process:\s*["']?hierarchical["']?/i.test(file.content);
+          if (!hasHierarchical)
+            continue;
+          const delegatingAgents = ctx.agents.filter((a) => a.framework === "crewai" && a.delegates_to && a.delegates_to.length > 0);
+          if (delegatingAgents.length > 0) {
+            const line = file.content.substring(0, file.content.indexOf("hierarchical")).split("\n").length;
+            findings.push((0, interface_1.createEnterpriseFinding)(this, {
+              id: `${this.id}-${findings.length}`,
+              title: "CrewAI hierarchical process with unrestricted delegation",
+              description: `Crew uses hierarchical process with ${delegatingAgents.length} agent(s) that can delegate (${delegatingAgents.map((a) => a.name).join(", ")}). In hierarchical mode, the manager agent delegates to workers who may further delegate, creating recursive chains that consume tokens unboundedly and can escalate privileges through delegation.`,
+              recommendation: "Set allow_delegation: false on worker agents that should not sub-delegate. Only the manager agent should have delegation privileges in a hierarchical crew. See https://sentinelflow.dev/rules/SF-MA-007",
+              location: { file: file.path, line, snippet: "process: hierarchical" },
+              remediation_effort: "low",
+              auto_fix: this.auto_fix
+            }));
+          }
+        }
+        return findings;
+      }
+    };
+    exports2.multiFrameworkConfigDrift = {
+      id: "SF-MA-008",
+      name: "Multi-Framework: Permission Scope Divergence",
+      description: "Multiple agent frameworks configured in the same repository have divergent permission scopes \u2014 the least restrictive configuration determines actual risk.",
+      category: "multi_agent",
+      severity: "medium",
+      frameworks: "all",
+      compliance: [
+        { framework: "OWASP_LLM_2025", reference: "LLM06", description: "Excessive Agency via inconsistent permissions" },
+        { framework: "EU_AI_ACT", reference: "Article 15", description: "Consistent cybersecurity measures" },
+        { framework: "NIST_AI_RMF", reference: "GOVERN 1.1", description: "Uniform governance policies" }
+      ],
+      phase: "static",
+      lifecycle: "experimental",
+      since: "0.2.0",
+      known_false_positives: [
+        {
+          condition: "Intentionally different permission scopes for different frameworks (e.g., Cursor for review-only, Claude Code for development)",
+          recommended_action: "Suppress with: # sentinelflow-ignore: SF-MA-008 -- Intentional scope difference documented in SECURITY.md"
+        }
+      ],
+      evaluate(ctx) {
+        const findings = [];
+        const frameworkSet = new Set(ctx.agents.map((a) => a.framework));
+        if (frameworkSet.size < 2)
+          return findings;
+        const frameworkToolRisks = /* @__PURE__ */ new Map();
+        for (const agent of ctx.agents) {
+          if (!frameworkToolRisks.has(agent.framework)) {
+            frameworkToolRisks.set(agent.framework, /* @__PURE__ */ new Set());
+          }
+          const riskSet = frameworkToolRisks.get(agent.framework);
+          for (const tool of agent.tools) {
+            if (tool.risk_level === "high")
+              riskSet.add(tool.name);
+          }
+        }
+        const withHighRisk = [];
+        const withoutHighRisk = [];
+        for (const [fw, risks] of frameworkToolRisks) {
+          if (risks.size > 0)
+            withHighRisk.push(fw);
+          else
+            withoutHighRisk.push(fw);
+        }
+        if (withHighRisk.length > 0 && withoutHighRisk.length > 0) {
+          findings.push((0, interface_1.createEnterpriseFinding)(this, {
+            id: `${this.id}-0`,
+            title: "Permission scope divergence across frameworks",
+            description: `This project configures ${frameworkSet.size} agent frameworks with different permission levels. ${withHighRisk.join(", ")} grant(s) high-risk tool access (bash, shell, code execution) while ${withoutHighRisk.join(", ")} do(es) not. The least restrictive configuration determines the project's actual risk surface.`,
+            recommendation: "Align permission scopes across all configured frameworks to the principle of least privilege. If different scopes are intentional, document the rationale in SECURITY.md and suppress this finding. See https://sentinelflow.dev/rules/SF-MA-008",
+            remediation_effort: "medium"
+          }));
+        }
+        return findings;
+      }
+    };
+    exports2.MULTI_AGENT_RULES = [
+      exports2.noDelegationDepthLimit,
+      exports2.privilegeEscalationViaDelegate,
+      exports2.noOutputValidationBetweenAgents,
+      exports2.crewaiHierarchicalNoLimits,
+      exports2.multiFrameworkConfigDrift
+    ];
+  }
+});
+
+// packages/scanner/dist/rules/audit-logging.js
+var require_audit_logging = __commonJS({
+  "packages/scanner/dist/rules/audit-logging.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.AUDIT_LOGGING_RULES = exports2.sensitiveDataInLogs = exports2.noSIEMIntegration = exports2.noAuditLogging = void 0;
+    var interface_1 = require_interface();
+    var COMPLIANCE_AL = [
+      { framework: "EU_AI_ACT", reference: "Article 12", description: "Record-keeping / automatic logging" },
+      { framework: "SOC2", reference: "CC7.1", description: "Detection of configuration changes" },
+      { framework: "HIPAA", reference: "\xA7164.312(b)", description: "Audit controls" }
+    ];
+    exports2.noAuditLogging = {
+      id: "SF-AL-001",
+      name: "Agent Actions Not Logged",
+      description: "No evidence of audit logging for agent tool invocations, decisions, or data access.",
+      category: "audit_logging",
+      severity: "high",
+      frameworks: "all",
+      compliance: COMPLIANCE_AL,
+      phase: "static",
+      evaluate(ctx) {
+        const findings = [];
+        const hasLogging = ctx.config_files.some((f) => f.content.includes("log") || f.content.includes("audit") || f.content.includes("observe") || f.content.includes("trace") || f.content.includes("PostToolUse") || f.content.includes("sentinelflow") || f.content.includes("langfuse") || f.content.includes("langsmith") || f.content.includes("arize") || f.content.includes("helicone"));
+        if (!hasLogging && ctx.agents.length > 0) {
+          findings.push((0, interface_1.createEnterpriseFinding)(this, {
+            id: `${this.id}-global`,
+            title: "No audit logging detected for agent actions",
+            description: "No evidence of audit logging, observability tools, or PostToolUse hooks found. EU AI Act Article 12 requires automatic recording of events throughout an AI system's lifetime with minimum 6-month retention. Without logging, incident response and compliance auditing are impossible.",
+            recommendation: "Integrate an observability platform (SentinelFlow interceptors, Langfuse, LangSmith) or add PostToolUse hooks that log every tool invocation with agent identity, action type, input/output summary, and timestamp.",
+            remediation_effort: "medium"
+          }));
+        }
+        return findings;
+      }
+    };
+    exports2.noSIEMIntegration = {
+      id: "SF-AL-004",
+      name: "Agent Logs Not Integrated with SIEM",
+      description: "Agent audit logs should stream to centralized security monitoring for correlation with other security events.",
+      category: "audit_logging",
+      severity: "medium",
+      frameworks: "all",
+      compliance: [
+        ...COMPLIANCE_AL,
+        { framework: "SOC2", reference: "CC7.2", description: "Activity monitoring" }
+      ],
+      phase: "static",
+      evaluate(ctx) {
+        const findings = [];
+        const hasSIEM = ctx.config_files.some((f) => f.content.includes("sentinel") || f.content.includes("splunk") || f.content.includes("datadog") || f.content.includes("siem") || f.content.includes("elastic") || f.content.includes("chronicle"));
+        if (!hasSIEM && ctx.agents.length > 0) {
+          findings.push((0, interface_1.createEnterpriseFinding)(this, {
+            id: `${this.id}-global`,
+            title: "Agent logs not connected to SIEM/SOAR platform",
+            description: "No evidence of SIEM integration (Microsoft Sentinel, Splunk, Datadog, etc.). Isolated agent logs miss attack patterns spanning multiple systems.",
+            recommendation: "Stream agent telemetry to your centralized SIEM. SentinelFlow's interceptors support webhook output to Splunk, Datadog, and Microsoft Sentinel.",
+            remediation_effort: "medium"
+          }));
+        }
+        return findings;
+      }
+    };
+    exports2.sensitiveDataInLogs = {
+      id: "SF-AL-006",
+      name: "Sensitive Data May Appear in Agent Logs",
+      description: "Agent traces and conversation logs may contain PII, credentials, or classified data without redaction.",
+      category: "audit_logging",
+      severity: "medium",
+      frameworks: "all",
+      compliance: [
+        ...COMPLIANCE_AL,
+        { framework: "GDPR", reference: "Article 5(1)(c)", description: "Data minimisation" }
+      ],
+      phase: "static",
+      evaluate(ctx) {
+        const findings = [];
+        const hasLogRedaction = ctx.config_files.some((f) => f.content.includes("redact") || f.content.includes("sanitize") || f.content.includes("mask") || f.content.includes("scrub") || f.content.includes("pii_filter"));
+        const handlesData = ctx.agents.some((a) => a.data_classification?.some((dc) => ["pii", "phi", "financial"].includes(dc)) || a.data_sources.some((ds) => ds.classification?.some((c) => ["pii", "phi", "financial"].includes(c))));
+        if (!hasLogRedaction && handlesData) {
+          findings.push((0, interface_1.createEnterpriseFinding)(this, {
+            id: `${this.id}-global`,
+            title: "Agents handling sensitive data with no log redaction configured",
+            description: "Agents access PII/PHI/financial data but no log sanitization or PII redaction is configured. Agent traces may contain the sensitive data itself, creating uncontrolled data copies in log storage.",
+            recommendation: "Configure PII scrubbing in your logging pipeline. SentinelFlow interceptors include automatic PII detection and redaction in telemetry events.",
+            remediation_effort: "medium"
+          }));
+        }
+        return findings;
+      }
+    };
+    exports2.AUDIT_LOGGING_RULES = [
+      exports2.noAuditLogging,
+      exports2.noSIEMIntegration,
+      exports2.sensitiveDataInLogs
+    ];
+  }
+});
+
+// packages/scanner/dist/rules/compliance-docs.js
+var require_compliance_docs = __commonJS({
+  "packages/scanner/dist/rules/compliance-docs.js"(exports2) {
+    "use strict";
+    var __createBinding2 = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault2 = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar2 = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding2(result, mod, k[i]);
+        }
+        __setModuleDefault2(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.COMPLIANCE_DOCS_RULES = exports2.noIncidentResponsePlan = exports2.noHumanOversightDocs = exports2.noTechnicalDocumentation = exports2.noRiskAssessment = void 0;
+    var fs = __importStar2(require("fs"));
+    var path = __importStar2(require("path"));
+    var interface_1 = require_interface();
+    var COMPLIANCE_CD = [
+      { framework: "EU_AI_ACT", reference: "Articles 9-15", description: "High-risk AI system requirements" },
+      { framework: "ISO_42001", reference: "Clause 6-10", description: "AI management system requirements" },
+      { framework: "NIST_AI_RMF", reference: "GOVERN", description: "AI governance documentation" }
+    ];
+    exports2.noRiskAssessment = {
+      id: "SF-CD-001",
+      name: "No AI Risk Assessment Documented",
+      description: "EU AI Act Article 9 requires continuous risk assessment for high-risk AI systems.",
+      category: "compliance_docs",
+      severity: "medium",
+      frameworks: "all",
+      compliance: COMPLIANCE_CD,
+      phase: "static",
+      evaluate(ctx) {
+        const findings = [];
+        const riskDocPatterns = [
+          "risk_assessment",
+          "risk-assessment",
+          "ai_risk",
+          "risk_register",
+          "threat_model",
+          "threat-model",
+          "risk_analysis"
+        ];
+        const hasRiskDoc = ctx.config_files.some((f) => riskDocPatterns.some((p) => f.content.toLowerCase().includes(p)));
+        const riskFiles = ["RISK_ASSESSMENT.md", "risk-assessment.md", "AI_RISK.md", "threat-model.md"];
+        const hasRiskFile = riskFiles.some((f) => fs.existsSync(path.join(ctx.root_dir, f)));
+        if (!hasRiskDoc && !hasRiskFile && ctx.agents.length > 0) {
+          findings.push((0, interface_1.createEnterpriseFinding)(this, {
+            id: `${this.id}-global`,
+            title: "No AI risk assessment documentation found",
+            description: "No risk assessment, threat model, or risk register found for the AI agents in this project. EU AI Act Article 9 requires continuous risk assessment and management for high-risk AI systems. ISO 42001 Clause 6.1.2 requires AI-specific risk assessment. Enforcement deadline: August 2, 2026.",
+            recommendation: "Create a risk assessment document covering: agent capabilities, data access, potential failure modes, and mitigation measures. Use NIST AI RMF's MAP-MEASURE-MANAGE lifecycle as a framework.",
+            remediation_effort: "high"
+          }));
+        }
+        return findings;
+      }
+    };
+    exports2.noTechnicalDocumentation = {
+      id: "SF-CD-002",
+      name: "No Technical Documentation for AI System",
+      description: "EU AI Act Article 11 requires comprehensive technical documentation before deployment.",
+      category: "compliance_docs",
+      severity: "medium",
+      frameworks: "all",
+      compliance: COMPLIANCE_CD,
+      phase: "static",
+      evaluate(ctx) {
+        const findings = [];
+        const hasAgentsMd = fs.existsSync(path.join(ctx.root_dir, "AGENTS.md"));
+        const hasClaudeMd = fs.existsSync(path.join(ctx.root_dir, "CLAUDE.md"));
+        const hasArchDoc = ["ARCHITECTURE.md", "docs/architecture.md", "docs/ARCHITECTURE.md", "SYSTEM_DESIGN.md"].some((f) => fs.existsSync(path.join(ctx.root_dir, f)));
+        if (!hasAgentsMd && !hasArchDoc && ctx.agents.length > 0) {
+          findings.push((0, interface_1.createEnterpriseFinding)(this, {
+            id: `${this.id}-global`,
+            title: "No technical documentation found for the AI agent system",
+            description: "No AGENTS.md, ARCHITECTURE.md, or system design documentation found. EU AI Act Article 11 and Annex IV require comprehensive technical documentation including system architecture, design specifications, and cybersecurity measures BEFORE deployment to the market.",
+            recommendation: "Create AGENTS.md describing: system architecture, agent roles, tool access, data flows, security controls, and human oversight measures. SentinelFlow's /governance-scan command can generate a starting template.",
+            remediation_effort: "medium"
+          }));
+        }
+        return findings;
+      }
+    };
+    exports2.noHumanOversightDocs = {
+      id: "SF-CD-004",
+      name: "No Human Oversight Documentation",
+      description: "EU AI Act Article 14 requires documented human oversight measures including ability to intervene and override.",
+      category: "compliance_docs",
+      severity: "medium",
+      frameworks: "all",
+      compliance: [
+        ...COMPLIANCE_CD,
+        { framework: "EU_AI_ACT", reference: "Article 14", description: "Human oversight" }
+      ],
+      phase: "static",
+      evaluate(ctx) {
+        const findings = [];
+        const oversightTerms = [
+          "human_oversight",
+          "human-oversight",
+          "human_review",
+          "human-in-the-loop",
+          "hitl",
+          "approval_workflow",
+          "approval-workflow",
+          "kill_switch",
+          "emergency_stop"
+        ];
+        const hasOversight = ctx.config_files.some((f) => oversightTerms.some((t) => f.content.toLowerCase().includes(t)));
+        const hasHooks = ctx.config_files.some((f) => f.path.includes("hooks") && f.content.includes("PreToolUse"));
+        if (!hasOversight && !hasHooks && ctx.agents.length > 0) {
+          findings.push((0, interface_1.createEnterpriseFinding)(this, {
+            id: `${this.id}-global`,
+            title: "No human oversight measures documented or configured",
+            description: "No human oversight mechanisms (approval workflows, PreToolUse hooks, kill switches) or documentation found. EU AI Act Article 14 requires that high-risk AI systems include measures enabling human oversight, including the ability to understand, interpret, correctly use, and override the AI system.",
+            recommendation: "Configure PreToolUse hooks for high-impact actions. Document oversight procedures including: how operators can intervene, what actions require approval, and how to shut down agent operations in an emergency.",
+            remediation_effort: "medium"
+          }));
+        }
+        return findings;
+      }
+    };
+    exports2.noIncidentResponsePlan = {
+      id: "SF-CD-005",
+      name: "No AI Incident Response Plan",
+      description: "No dedicated playbook for AI-specific incidents (prompt injection breaches, agent manipulation, model compromise).",
+      category: "compliance_docs",
+      severity: "low",
+      frameworks: "all",
+      compliance: [
+        ...COMPLIANCE_CD,
+        { framework: "NIST_AI_RMF", reference: "MANAGE 4.1", description: "Incident response" },
+        { framework: "SOC2", reference: "CC7.3", description: "Incident response procedures" }
+      ],
+      phase: "static",
+      evaluate(ctx) {
+        const findings = [];
+        const irFiles = [
+          "INCIDENT_RESPONSE.md",
+          "incident-response.md",
+          "IR_PLAN.md",
+          "docs/incident-response.md",
+          "SECURITY.md"
+        ];
+        const hasIR = irFiles.some((f) => fs.existsSync(path.join(ctx.root_dir, f)));
+        const hasIRContent = ctx.config_files.some((f) => f.content.includes("incident_response") || f.content.includes("incident-response") || f.content.includes("security incident"));
+        if (!hasIR && !hasIRContent && ctx.agents.length > 0) {
+          findings.push((0, interface_1.createEnterpriseFinding)(this, {
+            id: `${this.id}-global`,
+            title: "No AI-specific incident response plan found",
+            description: "No incident response documentation for AI-specific threats found. Prompt injection breaches, agent manipulation, and model compromise require dedicated response playbooks beyond traditional IT incident response.",
+            recommendation: "Create an AI incident response plan covering: prompt injection detection and response, agent credential rotation, model rollback procedures, and communication templates for stakeholders.",
+            remediation_effort: "medium"
+          }));
+        }
+        return findings;
+      }
+    };
+    exports2.COMPLIANCE_DOCS_RULES = [
+      exports2.noRiskAssessment,
+      exports2.noTechnicalDocumentation,
+      exports2.noHumanOversightDocs,
+      exports2.noIncidentResponsePlan
+    ];
+  }
+});
+
+// packages/scanner/dist/rules/network-security.js
+var require_network_security = __commonJS({
+  "packages/scanner/dist/rules/network-security.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.NETWORK_SECURITY_RULES = exports2.unencryptedMCPTransport = exports2.noSandboxing = exports2.unrestrictedNetworkAccess = void 0;
+    var interface_1 = require_interface();
+    var COMPLIANCE_NS = [
+      { framework: "SOC2", reference: "CC6.6", description: "System boundaries and network security" },
+      { framework: "NIST_AI_RMF", reference: "GOVERN 6", description: "Infrastructure security" }
+    ];
+    exports2.unrestrictedNetworkAccess = {
+      id: "SF-NS-003",
+      name: "No Network Egress Filtering for Agent Environment",
+      description: "Agents that can make network requests have no domain restrictions, enabling data exfiltration.",
+      category: "network_security",
+      severity: "medium",
+      frameworks: "all",
+      compliance: [
+        ...COMPLIANCE_NS,
+        { framework: "HIPAA", reference: "\xA7164.312(e)(1)", description: "Transmission security" }
+      ],
+      phase: "static",
+      evaluate(ctx) {
+        return ctx.agents.filter((a) => a.tools.some((t) => t.type === "web_search" || t.type === "web_fetch" || t.type === "api_call")).filter((a) => !a.network_access || !a.network_access.allowed_domains && !a.network_access.blocked_domains).map((agent) => (0, interface_1.createEnterpriseFinding)(this, {
+          id: `${this.id}-${agent.id}`,
+          title: `Agent "${agent.name}" has unrestricted network egress`,
+          description: `Agent has network tools (${agent.tools.filter((t) => ["web_search", "web_fetch", "api_call"].includes(t.type)).map((t) => t.name).join(", ")}) with no domain allowlist or blocklist. An attacker exploiting prompt injection could exfiltrate data to any external endpoint.`,
+          recommendation: "Define network_access.allowed_domains restricting outbound connections to approved API endpoints. Block known data exfiltration services.",
+          agent_id: agent.id,
+          agent_name: agent.name,
+          framework: agent.framework,
+          location: agent.source_file ? { file: agent.source_file } : void 0,
+          cwe: "CWE-441",
+          remediation_effort: "medium"
+        }));
+      }
+    };
+    exports2.noSandboxing = {
+      id: "SF-NS-004",
+      name: "Code Execution Not Sandboxed",
+      description: "Agents executing code in the host process without containerization or VM-based sandboxing.",
+      category: "network_security",
+      severity: "high",
+      frameworks: "all",
+      compliance: COMPLIANCE_NS,
+      phase: "static",
+      evaluate(ctx) {
+        const findings = [];
+        const hasSandbox = ctx.config_files.some((f) => f.content.includes("docker") || f.content.includes("container") || f.content.includes("sandbox") || f.content.includes("isolat") || f.content.includes("vm") || f.content.includes("firecracker"));
+        const hasCodeExec = ctx.agents.some((a) => a.tools.some((t) => t.type === "bash" || t.type === "code_execution"));
+        if (hasCodeExec && !hasSandbox) {
+          findings.push((0, interface_1.createEnterpriseFinding)(this, {
+            id: `${this.id}-global`,
+            title: "Agent code execution with no sandboxing detected",
+            description: "Agents can execute code (bash/code_execution tools) but no containerization or sandboxing configuration was found. Code execution in the host process means a prompt injection \u2192 code execution chain has full system access.",
+            recommendation: "Run agent code execution in sandboxed environments: Docker containers, Azure Container Apps dynamic sessions, or VM-based sandboxes. At minimum, use Linux namespaces or chroot to restrict file system access.",
+            remediation_effort: "high"
+          }));
+        }
+        return findings;
+      }
+    };
+    exports2.unencryptedMCPTransport = {
+      id: "SF-NS-001",
+      name: "MCP Server Using Unencrypted Transport",
+      description: "MCP servers connected via HTTP (not HTTPS) or unencrypted WebSocket.",
+      category: "network_security",
+      severity: "high",
+      frameworks: "all",
+      compliance: [
+        ...COMPLIANCE_NS,
+        { framework: "HIPAA", reference: "\xA7164.312(e)(1)", description: "Transmission security" },
+        { framework: "SOC2", reference: "CC6.7", description: "Encryption in transit" }
+      ],
+      phase: "static",
+      evaluate(ctx) {
+        const findings = [];
+        for (const agent of ctx.agents) {
+          if (!agent.mcp_servers)
+            continue;
+          for (const server of agent.mcp_servers) {
+            if (server.url && server.url.startsWith("http://") && !server.url.includes("localhost") && !server.url.includes("127.0.0.1")) {
+              findings.push((0, interface_1.createEnterpriseFinding)(this, {
+                id: `${this.id}-${agent.id}-${server.name}`,
+                title: `MCP server "${server.name}" uses unencrypted HTTP`,
+                description: `MCP server "${server.name}" connects via ${server.url} (HTTP, not HTTPS). Tool definitions, agent data, and potentially credentials are transmitted in plaintext.`,
+                recommendation: "Switch to HTTPS for all non-local MCP server connections. Configure TLS 1.2+ with valid certificates.",
+                agent_id: agent.id,
+                agent_name: agent.name,
+                cwe: "CWE-319",
+                remediation_effort: "low"
+              }));
+            }
+          }
+        }
+        return findings;
+      }
+    };
+    exports2.NETWORK_SECURITY_RULES = [
+      exports2.unrestrictedNetworkAccess,
+      exports2.noSandboxing,
+      exports2.unencryptedMCPTransport
+    ];
+  }
+});
+
+// packages/scanner/dist/rules/index.js
+var require_rules = __commonJS({
+  "packages/scanner/dist/rules/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.createEnterpriseFinding = exports2.BUILT_IN_RULES = void 0;
+    exports2.getRuleById = getRuleById;
+    exports2.getRulesByCategory = getRulesByCategory;
+    exports2.getRulesBySeverity = getRulesBySeverity;
+    exports2.getRulesByFramework = getRulesByFramework;
+    exports2.getRulesByCompliance = getRulesByCompliance;
+    exports2.getRuleSummary = getRuleSummary;
+    var prompt_injection_1 = require_prompt_injection();
+    var access_control_1 = require_access_control();
+    var supply_chain_1 = require_supply_chain();
+    var data_governance_1 = require_data_governance();
+    var cost_governance_1 = require_cost_governance();
+    var framework_config_1 = require_framework_config();
+    var multi_agent_1 = require_multi_agent();
+    var audit_logging_1 = require_audit_logging();
+    var compliance_docs_1 = require_compliance_docs();
+    var network_security_1 = require_network_security();
+    exports2.BUILT_IN_RULES = [
+      ...prompt_injection_1.PROMPT_INJECTION_RULES,
+      // 4 rules
+      ...access_control_1.ACCESS_CONTROL_RULES,
+      // 5 rules
+      ...supply_chain_1.SUPPLY_CHAIN_RULES,
+      // 6 rules (+1: SC-010 LangChain passthrough)
+      ...data_governance_1.DATA_GOVERNANCE_RULES,
+      // 3 rules
+      ...cost_governance_1.COST_GOVERNANCE_RULES,
+      // 5 rules
+      ...framework_config_1.FRAMEWORK_CONFIG_RULES,
+      // 8 rules (+2: FC-008 Codex full-auto, FC-009 Cursor alwaysApply)
+      ...multi_agent_1.MULTI_AGENT_RULES,
+      // 5 rules (+2: MA-007 CrewAI hierarchical, MA-008 config drift)
+      ...audit_logging_1.AUDIT_LOGGING_RULES,
+      // 3 rules
+      ...compliance_docs_1.COMPLIANCE_DOCS_RULES,
+      // 4 rules
+      ...network_security_1.NETWORK_SECURITY_RULES
+      // 3 rules
+    ];
+    function getRuleById(id) {
+      return exports2.BUILT_IN_RULES.find((r) => r.id === id);
+    }
+    function getRulesByCategory(category) {
+      return exports2.BUILT_IN_RULES.filter((r) => r.category === category);
+    }
+    function getRulesBySeverity(severity) {
+      return exports2.BUILT_IN_RULES.filter((r) => r.severity === severity);
+    }
+    function getRulesByFramework(framework) {
+      return exports2.BUILT_IN_RULES.filter((r) => r.frameworks === "all" || r.frameworks.includes(framework));
+    }
+    function getRulesByCompliance(framework) {
+      return exports2.BUILT_IN_RULES.filter((r) => r.compliance.some((c) => c.framework === framework));
+    }
+    function getRuleSummary() {
+      const by_category = {};
+      const by_severity = {};
+      const by_compliance = {};
+      for (const rule of exports2.BUILT_IN_RULES) {
+        by_category[rule.category] = (by_category[rule.category] ?? 0) + 1;
+        by_severity[rule.severity] = (by_severity[rule.severity] ?? 0) + 1;
+        for (const mapping of rule.compliance) {
+          by_compliance[mapping.framework] = (by_compliance[mapping.framework] ?? 0) + 1;
+        }
+      }
+      return {
+        total: exports2.BUILT_IN_RULES.length,
+        by_category,
+        by_severity,
+        by_compliance
+      };
+    }
+    var interface_1 = require_interface();
+    Object.defineProperty(exports2, "createEnterpriseFinding", { enumerable: true, get: function() {
+      return interface_1.createEnterpriseFinding;
+    } });
+  }
+});
+
+// packages/scanner/dist/engine.js
+var require_engine = __commonJS({
+  "packages/scanner/dist/engine.js"(exports2) {
+    "use strict";
+    var __createBinding2 = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault2 = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar2 = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding2(result, mod, k[i]);
+        }
+        __setModuleDefault2(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.scan = scan;
+    var path = __importStar2(require("path"));
+    var core_1 = require_dist();
+    var parsers_1 = require_dist2();
+    var index_1 = require_rules();
+    var SEVERITY_ORDER = [
+      "critical",
+      "high",
+      "medium",
+      "low",
+      "info"
+    ];
+    async function scan(options) {
+      const startTime = Date.now();
+      const rootDir = path.resolve(options.rootDir);
+      const fs = await Promise.resolve().then(() => __importStar2(require("fs")));
+      if (!fs.existsSync(rootDir)) {
+        throw new Error(`Directory not found: ${rootDir}`);
+      }
+      if (!fs.statSync(rootDir).isDirectory()) {
+        throw new Error(`Not a directory: ${rootDir}`);
+      }
+      const parseResult = await (0, parsers_1.parseAll)(rootDir);
+      const detectedFrameworkSet = new Set(parseResult.agents.map((a) => a.framework));
+      const context = {
+        agents: parseResult.agents,
+        config_files: parseResult.config_files,
+        root_dir: rootDir
+      };
+      let rules = [...index_1.BUILT_IN_RULES];
+      if (options.rules && options.rules.length > 0) {
+        const requestedIds = new Set(options.rules);
+        rules = rules.filter((r) => requestedIds.has(r.id));
+        if (rules.length === 0) {
+          parseResult.warnings.push(`No matching rules found for IDs: ${options.rules.join(", ")}. Available rule IDs: ${index_1.BUILT_IN_RULES.map((r) => r.id).join(", ")}`);
+        }
+      }
+      if (options.minSeverity) {
+        const minIdx = SEVERITY_ORDER.indexOf(options.minSeverity);
+        if (minIdx === -1) {
+          parseResult.warnings.push(`Invalid severity: "${options.minSeverity}". Valid values: ${SEVERITY_ORDER.join(", ")}`);
+        } else {
+          rules = rules.filter((r) => {
+            const ruleIdx = SEVERITY_ORDER.indexOf(r.severity);
+            return ruleIdx <= minIdx;
+          });
+        }
+      }
+      const allFindings = [];
+      for (const rule of rules) {
+        if (rule.frameworks !== "all") {
+          const ruleFrameworks = new Set(rule.frameworks);
+          const hasApplicableFramework = [...detectedFrameworkSet].some((f) => ruleFrameworks.has(f));
+          if (!hasApplicableFramework) {
+            continue;
+          }
+        }
+        try {
+          const findings = rule.evaluate(context);
+          allFindings.push(...findings);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          parseResult.warnings.push(`Rule ${rule.id} (${rule.name}) failed: ${message}`);
+        }
+      }
+      allFindings.sort((a, b) => {
+        return SEVERITY_ORDER.indexOf(a.severity) - SEVERITY_ORDER.indexOf(b.severity);
+      });
+      const durationMs = Date.now() - startTime;
+      const report = (0, core_1.createScanReport)(rootDir, allFindings, parseResult.frameworks, parseResult.agents.length, durationMs);
+      if (options.updateRegistry !== false) {
+        try {
+          const registry2 = new core_1.LocalRegistry(rootDir);
+          await registry2.initialize();
+          for (const agent of parseResult.agents) {
+            const agentFindings = allFindings.filter((f) => f.agent_id === agent.id);
+            agent.governance.last_scan = (/* @__PURE__ */ new Date()).toISOString();
+            agent.governance.findings_count = {
+              critical: agentFindings.filter((f) => f.severity === "critical").length,
+              high: agentFindings.filter((f) => f.severity === "high").length,
+              medium: agentFindings.filter((f) => f.severity === "medium").length,
+              low: agentFindings.filter((f) => f.severity === "low").length,
+              info: agentFindings.filter((f) => f.severity === "info").length
+            };
+            if (agentFindings.some((f) => f.severity === "critical")) {
+              agent.governance.risk_level = "critical";
+            } else if (agentFindings.some((f) => f.severity === "high")) {
+              agent.governance.risk_level = "high";
+            } else if (agentFindings.some((f) => f.severity === "medium")) {
+              agent.governance.risk_level = "medium";
+            } else {
+              agent.governance.risk_level = "low";
+            }
+            await registry2.upsertAgent(agent);
+          }
+          await registry2.storeScanReport(report);
+          await registry2.close();
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          parseResult.warnings.push(`Failed to update registry: ${message}`);
+        }
+      }
+      return {
+        report,
+        agents: parseResult.agents,
+        frameworks: parseResult.frameworks,
+        warnings: parseResult.warnings
+      };
+    }
+  }
+});
+
+// packages/scanner/dist/reporter.js
+var require_reporter = __commonJS({
+  "packages/scanner/dist/reporter.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.formatTerminal = formatTerminal;
+    exports2.formatJSON = formatJSON;
+    exports2.formatSARIF = formatSARIF;
+    exports2.formatMarkdown = formatMarkdown;
+    var RESET = "\x1B[0m";
+    var BOLD = "\x1B[1m";
+    var DIM = "\x1B[2m";
+    var RED = "\x1B[31m";
+    var YELLOW = "\x1B[33m";
+    var GREEN = "\x1B[32m";
+    var CYAN = "\x1B[36m";
+    var WHITE = "\x1B[37m";
+    var BG_RED = "\x1B[41m";
+    var SEVERITY_COLORS = {
+      critical: `${BG_RED}${WHITE}${BOLD}`,
+      high: `${RED}${BOLD}`,
+      medium: `${YELLOW}`,
+      low: `${DIM}`,
+      info: `${DIM}`
+    };
+    var SEVERITY_LABELS = {
+      critical: "CRITICAL",
+      high: "HIGH",
+      medium: "MEDIUM",
+      low: "LOW",
+      info: "INFO"
+    };
+    function formatTerminal(result) {
+      const lines = [];
+      const { report, agents, frameworks } = result;
+      lines.push("");
+      lines.push(`  ${BOLD}${CYAN}SentinelFlow v0.2.0${RESET} ${DIM}\u2014 Agent Governance Scanner${RESET}`);
+      lines.push("");
+      lines.push(`  Scanning ${BOLD}${report.root_dir}${RESET}...`);
+      lines.push("");
+      lines.push(`  ${BOLD}Frameworks detected:${RESET}`);
+      if (frameworks.length === 0) {
+        lines.push(`    ${DIM}No agent frameworks found${RESET}`);
+      } else {
+        for (const fw of frameworks) {
+          lines.push(`    ${GREEN}\u2713${RESET} ${fw}`);
+        }
+      }
+      lines.push("");
+      lines.push(`  ${BOLD}Agents discovered:${RESET} ${agents.length}`);
+      for (let i = 0; i < agents.length; i++) {
+        const agent = agents[i];
+        if (!agent)
+          continue;
+        const isLast = i === agents.length - 1;
+        const prefix = isLast ? "\u2514\u2500\u2500" : "\u251C\u2500\u2500";
+        const role = agent.swarm_role !== "standalone" ? `, ${agent.swarm_role}` : "";
+        lines.push(`    ${DIM}${prefix}${RESET} ${BOLD}${agent.name}${RESET} ${DIM}(${agent.framework}${role})${RESET}`);
+      }
+      lines.push("");
+      const { summary } = report;
+      if (summary.total === 0) {
+        lines.push(`  ${GREEN}${BOLD}\u2713 No findings \u2014 all clear!${RESET}`);
+      } else {
+        const parts = [];
+        if (summary.critical > 0)
+          parts.push(`${RED}${BOLD}${summary.critical} critical${RESET}`);
+        if (summary.high > 0)
+          parts.push(`${RED}${summary.high} high${RESET}`);
+        if (summary.medium > 0)
+          parts.push(`${YELLOW}${summary.medium} medium${RESET}`);
+        if (summary.low > 0)
+          parts.push(`${DIM}${summary.low} low${RESET}`);
+        if (summary.info > 0)
+          parts.push(`${DIM}${summary.info} info${RESET}`);
+        lines.push(`  ${BOLD}Findings:${RESET} ${parts.join(", ")}`);
+        lines.push("");
+        for (const severity of ["critical", "high", "medium", "low"]) {
+          const findings = report.findings.filter((f) => f.severity === severity);
+          if (findings.length === 0)
+            continue;
+          const color = SEVERITY_COLORS[severity];
+          lines.push(`  ${color}${SEVERITY_LABELS[severity]}${RESET}`);
+          lines.push(`  ${DIM}\u250C${"\u2500".repeat(60)}\u2510${RESET}`);
+          for (const finding of findings) {
+            const location = finding.location ? `${finding.location.file}${finding.location.line ? `:${finding.location.line}` : ""}` : "";
+            lines.push(`  ${DIM}\u2502${RESET} ${BOLD}${finding.rule_id}${RESET}  ${finding.title}`);
+            if (location) {
+              lines.push(`  ${DIM}\u2502${RESET}          ${DIM}${location}${RESET}`);
+            }
+          }
+          lines.push(`  ${DIM}\u2514${"\u2500".repeat(60)}\u2518${RESET}`);
+          lines.push("");
+        }
+      }
+      lines.push(`  ${DIM}Scan completed in ${report.duration_ms}ms | 46 rules | ${agents.length} agents${RESET}`);
+      lines.push("");
+      return lines.join("\n");
+    }
+    function formatJSON(result) {
+      return JSON.stringify(result.report, null, 2);
+    }
+    function formatSARIF(result) {
+      const { report } = result;
+      const sarifReport = {
+        $schema: "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/main/sarif-2.1/schema/sarif-schema-2.1.0.json",
+        version: "2.1.0",
+        runs: [
+          {
+            tool: {
+              driver: {
+                name: "SentinelFlow",
+                version: "0.2.0",
+                informationUri: "https://github.com/Omsatyaswaroop29/sentinelflow",
+                rules: index_1.BUILT_IN_RULES.map((rule) => ({
+                  id: rule.id,
+                  name: rule.name,
+                  shortDescription: { text: rule.name },
+                  fullDescription: { text: rule.description },
+                  defaultConfiguration: {
+                    level: mapSeverityToSARIF(rule.severity)
+                  },
+                  properties: {
+                    tags: [rule.category]
+                  }
+                }))
+              }
+            },
+            results: report.findings.map((finding) => ({
+              ruleId: finding.rule_id,
+              level: mapSeverityToSARIF(finding.severity),
+              message: {
+                text: `${finding.title}
+
+${finding.description}
+
+Recommendation: ${finding.recommendation}`
+              },
+              locations: finding.location ? [
+                {
+                  physicalLocation: {
+                    artifactLocation: {
+                      uri: finding.location.file
+                    },
+                    region: finding.location.line ? {
+                      startLine: finding.location.line
+                    } : void 0
+                  }
+                }
+              ] : []
+            }))
+          }
+        ]
+      };
+      return JSON.stringify(sarifReport, null, 2);
+    }
+    function mapSeverityToSARIF(severity) {
+      switch (severity) {
+        case "critical":
+        case "high":
+          return "error";
+        case "medium":
+          return "warning";
+        case "low":
+          return "note";
+        default:
+          return "none";
+      }
+    }
+    var index_1 = require_rules();
+    function formatMarkdown(result) {
+      const { report, agents, frameworks } = result;
+      const lines = [];
+      lines.push("# SentinelFlow Governance Report");
+      lines.push("");
+      lines.push(`**Scanned:** ${report.root_dir}`);
+      lines.push(`**Date:** ${report.timestamp}`);
+      lines.push(`**Duration:** ${report.duration_ms}ms`);
+      lines.push(`**Frameworks:** ${frameworks.join(", ") || "None detected"}`);
+      lines.push(`**Agents discovered:** ${report.agents_discovered}`);
+      lines.push("");
+      lines.push("## Summary");
+      lines.push("");
+      lines.push(`| Severity | Count |`);
+      lines.push(`|----------|-------|`);
+      lines.push(`| Critical | ${report.summary.critical} |`);
+      lines.push(`| High | ${report.summary.high} |`);
+      lines.push(`| Medium | ${report.summary.medium} |`);
+      lines.push(`| Low | ${report.summary.low} |`);
+      lines.push(`| **Total** | **${report.summary.total}** |`);
+      lines.push("");
+      lines.push("## Agents");
+      lines.push("");
+      for (const agent of agents) {
+        lines.push(`- **${agent.name}** (${agent.framework}) \u2014 ${agent.swarm_role} \u2014 Risk: ${agent.governance.risk_level ?? "unassessed"}`);
+      }
+      lines.push("");
+      if (report.findings.length > 0) {
+        lines.push("## Findings");
+        lines.push("");
+        for (const severity of ["critical", "high", "medium", "low"]) {
+          const findings = report.findings.filter((f) => f.severity === severity);
+          if (findings.length === 0)
+            continue;
+          lines.push(`### ${severity.toUpperCase()}`);
+          lines.push("");
+          for (const f of findings) {
+            lines.push(`#### ${f.rule_id}: ${f.title}`);
+            lines.push("");
+            lines.push(f.description);
+            lines.push("");
+            lines.push(`**Recommendation:** ${f.recommendation}`);
+            if (f.location) {
+              lines.push(`**Location:** \`${f.location.file}${f.location.line ? `:${f.location.line}` : ""}\``);
+            }
+            lines.push("");
+          }
+        }
+      }
+      lines.push("## Coverage");
+      lines.push("");
+      lines.push(`Static analysis of ${agents.length} agent definition(s). The following require runtime context and are **not covered** by this scan:`);
+      lines.push("");
+      lines.push("- IAM roles and cloud permissions");
+      lines.push("- Secrets injected via Vault or environment variables");
+      lines.push("- Network policies and service mesh configuration");
+      lines.push("- Feature flags gating agent capabilities");
+      lines.push("");
+      lines.push("See [Framework Support Matrix](https://sentinelflow.dev/docs/framework-support) for full coverage details.");
+      lines.push("");
+      return lines.join("\n");
+    }
+  }
+});
+
+// packages/scanner/dist/suppression.js
+var require_suppression = __commonJS({
+  "packages/scanner/dist/suppression.js"(exports2) {
+    "use strict";
+    var __createBinding2 = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault2 = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar2 = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding2(result, mod, k[i]);
+        }
+        __setModuleDefault2(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.PRESETS = void 0;
+    exports2.parseInlineSuppressions = parseInlineSuppressions;
+    exports2.loadPolicyFile = loadPolicyFile;
+    exports2.applySuppressions = applySuppressions;
+    var fs = __importStar2(require("fs"));
+    var path = __importStar2(require("path"));
+    function parseInlineSuppressions(filePath, content) {
+      const suppressions = /* @__PURE__ */ new Map();
+      const pattern = /(?:#|\/\/)\s*sentinelflow-ignore:\s*(SF-[A-Z]+-\d+)\s*(?:--\s*(.+))?$/gm;
+      let match;
+      while ((match = pattern.exec(content)) !== null) {
+        const lineNum = content.substring(0, match.index).split("\n").length;
+        const ruleId = match[1];
+        const reason = match[2]?.trim() ?? "";
+        const key = `${filePath}:${lineNum}`;
+        suppressions.set(key, {
+          rule_id: ruleId,
+          reason,
+          source: "inline",
+          path_pattern: filePath
+        });
+      }
+      return suppressions;
+    }
+    var POLICY_FILENAMES = [
+      ".sentinelflow-policy.yaml",
+      ".sentinelflow-policy.yml",
+      ".sentinelflow.yaml",
+      ".sentinelflow.yml"
+    ];
+    function loadPolicyFile(rootDir) {
+      const warnings = [];
+      for (const filename of POLICY_FILENAMES) {
+        const filePath = path.join(rootDir, filename);
+        if (!fs.existsSync(filePath))
+          continue;
+        try {
+          const content = fs.readFileSync(filePath, "utf-8");
+          const policy = parseSimpleYAML(content);
+          return { policy, warnings };
+        } catch (error) {
+          warnings.push(`Failed to parse ${filename}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+      return { policy: null, warnings };
+    }
+    function parseSimpleYAML(content) {
+      const policy = { version: "v1" };
+      const versionMatch = content.match(/^version:\s*(.+)$/m);
+      if (versionMatch?.[1]) {
+        policy.version = versionMatch[1].trim();
+      }
+      const presetMatch = content.match(/^preset:\s*(.+)$/m);
+      if (presetMatch?.[1]) {
+        const preset = presetMatch[1].trim();
+        if (["strict", "standard", "monitor"].includes(preset)) {
+          policy.preset = preset;
+        }
+      }
+      const overridesBlock = content.match(/severity_overrides:\s*\n((?:\s+\S+.*\n)*)/);
+      if (overridesBlock?.[1]) {
+        policy.severity_overrides = {};
+        const lines = overridesBlock[1].split("\n");
+        for (const line of lines) {
+          const kvMatch = line.match(/^\s+(SF-[A-Z]+-\d+):\s*(.+)$/);
+          if (kvMatch?.[1] && kvMatch[2]) {
+            policy.severity_overrides[kvMatch[1]] = kvMatch[2].trim();
+          }
+        }
+      }
+      const excludeBlock = content.match(/exclude:\s*\n((?:\s+-\s+.+\n)*)/);
+      if (excludeBlock?.[1]) {
+        policy.exclude = [];
+        const lines = excludeBlock[1].split("\n");
+        for (const line of lines) {
+          const itemMatch = line.match(/^\s+-\s+"?([^"]+)"?\s*$/);
+          if (itemMatch?.[1]) {
+            policy.exclude.push(itemMatch[1]);
+          }
+        }
+      }
+      const ignoreBlock = content.match(/ignore:\s*\n([\s\S]*?)(?=\n\w|\n*$)/);
+      if (ignoreBlock?.[1]) {
+        policy.ignore = {};
+        const ruleBlocks = ignoreBlock[1].split(/\n\s{2}(SF-[A-Z]+-\d+):/);
+        for (let i = 1; i < ruleBlocks.length; i += 2) {
+          const ruleId = ruleBlocks[i];
+          const blockContent = ruleBlocks[i + 1] ?? "";
+          if (!ruleId)
+            continue;
+          const entries = [];
+          const entryChunks = blockContent.split(/\n\s{4}- /);
+          for (const chunk of entryChunks) {
+            if (!chunk.trim())
+              continue;
+            const entry = { reason: "" };
+            const pathMatch = chunk.match(/path:\s*"?([^"\n]+)"?/);
+            if (pathMatch?.[1])
+              entry.path = pathMatch[1].trim();
+            const reasonMatch = chunk.match(/reason:\s*"?([^"\n]+)"?/);
+            if (reasonMatch?.[1])
+              entry.reason = reasonMatch[1].trim();
+            const expiresMatch = chunk.match(/expires:\s*"?([^"\n]+)"?/);
+            if (expiresMatch?.[1])
+              entry.expires = expiresMatch[1].trim();
+            const approvedMatch = chunk.match(/approved_by:\s*"?([^"\n]+)"?/);
+            if (approvedMatch?.[1])
+              entry.approved_by = approvedMatch[1].trim();
+            const ticketMatch = chunk.match(/ticket:\s*"?([^"\n]+)"?/);
+            if (ticketMatch?.[1])
+              entry.ticket = ticketMatch[1].trim();
+            if (entry.reason)
+              entries.push(entry);
+          }
+          if (entries.length > 0) {
+            policy.ignore[ruleId] = entries;
+          }
+        }
+      }
+      return policy;
+    }
+    function applySuppressions(findings, configFiles, rootDir, options) {
+      const result = {
+        active: [],
+        suppressed: [],
+        expired_suppressions: [],
+        warnings: []
+      };
+      const { policy, warnings: policyWarnings } = loadPolicyFile(rootDir);
+      result.warnings.push(...policyWarnings);
+      const allInlineSuppressions = /* @__PURE__ */ new Map();
+      for (const file of configFiles) {
+        const fileSups = parseInlineSuppressions(file.path, file.content);
+        for (const [key, sup] of fileSups) {
+          allInlineSuppressions.set(key, sup);
+        }
+      }
+      for (const [location, sup] of allInlineSuppressions) {
+        if (!sup.reason) {
+          result.warnings.push(`Unjustified suppression at ${location}: "# sentinelflow-ignore: ${sup.rule_id}" requires a justification after "--". Example: # sentinelflow-ignore: ${sup.rule_id} -- Accepted risk per SEC-1234`);
+        }
+      }
+      const now = /* @__PURE__ */ new Date();
+      if (policy?.ignore) {
+        for (const [ruleId, entries] of Object.entries(policy.ignore)) {
+          for (const entry of entries) {
+            if (entry.expires) {
+              const expiryDate = new Date(entry.expires);
+              if (expiryDate < now) {
+                result.expired_suppressions.push({
+                  rule_id: ruleId,
+                  reason: entry.reason,
+                  source: "policy",
+                  path_pattern: entry.path,
+                  expires: entry.expires,
+                  approved_by: entry.approved_by,
+                  ticket: entry.ticket
+                });
+              }
+            }
+          }
+        }
+      }
+      for (const finding of findings) {
+        let suppression = null;
+        if (policy?.exclude && finding.location?.file) {
+          const relPath = path.relative(rootDir, finding.location.file);
+          for (const pattern of policy.exclude) {
+            if (matchGlob(relPath, pattern)) {
+              suppression = {
+                rule_id: finding.rule_id,
+                reason: `File excluded by policy: ${pattern}`,
+                source: "policy",
+                path_pattern: pattern
+              };
+              break;
+            }
+          }
+        }
+        if (!suppression && finding.location?.file && finding.location?.line) {
+          const key = `${finding.location.file}:${finding.location.line}`;
+          const inlineSup = allInlineSuppressions.get(key);
+          if (inlineSup && inlineSup.rule_id === finding.rule_id && inlineSup.reason) {
+            suppression = inlineSup;
+          }
+          const keyAbove = `${finding.location.file}:${finding.location.line - 1}`;
+          const inlineSupAbove = allInlineSuppressions.get(keyAbove);
+          if (!suppression && inlineSupAbove && inlineSupAbove.rule_id === finding.rule_id && inlineSupAbove.reason) {
+            suppression = inlineSupAbove;
+          }
+        }
+        if (!suppression && policy?.ignore) {
+          const policyEntries = policy.ignore[finding.rule_id];
+          if (policyEntries) {
+            for (const entry of policyEntries) {
+              if (entry.expires && new Date(entry.expires) < now) {
+                continue;
+              }
+              if (entry.path && finding.location?.file) {
+                const relPath = path.relative(rootDir, finding.location.file);
+                if (!matchGlob(relPath, entry.path)) {
+                  continue;
+                }
+              }
+              suppression = {
+                rule_id: finding.rule_id,
+                reason: entry.reason,
+                source: "policy",
+                path_pattern: entry.path,
+                expires: entry.expires,
+                approved_by: entry.approved_by,
+                ticket: entry.ticket
+              };
+              break;
+            }
+          }
+        }
+        if (policy?.severity_overrides?.[finding.rule_id]) {
+          const override = policy.severity_overrides[finding.rule_id];
+          if (["critical", "high", "medium", "low", "info"].includes(override)) {
+            finding.severity = override;
+          }
+        }
+        if (suppression) {
+          result.suppressed.push({ finding, suppression });
+        } else {
+          result.active.push(finding);
+        }
+      }
+      return result;
+    }
+    function matchGlob(filePath, pattern) {
+      const regexStr = pattern.replace(/\./g, "\\.").replace(/\*\*/g, "\xA7DOUBLESTAR\xA7").replace(/\*/g, "[^/]*").replace(/§DOUBLESTAR§/g, ".*");
+      const regex = new RegExp(`^${regexStr}$`);
+      return regex.test(filePath);
+    }
+    exports2.PRESETS = {
+      strict: {
+        exitOnSeverities: ["critical", "high", "medium"],
+        description: "Production governance. CI fails on medium and above."
+      },
+      standard: {
+        exitOnSeverities: ["critical", "high"],
+        description: "Active development. CI fails on high and above. (Default)"
+      },
+      monitor: {
+        exitOnSeverities: [],
+        description: "Adoption mode. All findings reported, CI never fails."
+      }
+    };
+  }
+});
+
+// packages/scanner/dist/index.js
+var require_dist3 = __commonJS({
+  "packages/scanner/dist/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.PRESETS = exports2.loadPolicyFile = exports2.parseInlineSuppressions = exports2.applySuppressions = exports2.getRulesByCategory = exports2.getRuleById = exports2.BUILT_IN_RULES = exports2.formatSARIF = exports2.formatMarkdown = exports2.formatJSON = exports2.formatTerminal = exports2.scan = void 0;
+    var engine_1 = require_engine();
+    Object.defineProperty(exports2, "scan", { enumerable: true, get: function() {
+      return engine_1.scan;
+    } });
+    var reporter_1 = require_reporter();
+    Object.defineProperty(exports2, "formatTerminal", { enumerable: true, get: function() {
+      return reporter_1.formatTerminal;
+    } });
+    Object.defineProperty(exports2, "formatJSON", { enumerable: true, get: function() {
+      return reporter_1.formatJSON;
+    } });
+    Object.defineProperty(exports2, "formatMarkdown", { enumerable: true, get: function() {
+      return reporter_1.formatMarkdown;
+    } });
+    Object.defineProperty(exports2, "formatSARIF", { enumerable: true, get: function() {
+      return reporter_1.formatSARIF;
+    } });
+    var index_1 = require_rules();
+    Object.defineProperty(exports2, "BUILT_IN_RULES", { enumerable: true, get: function() {
+      return index_1.BUILT_IN_RULES;
+    } });
+    Object.defineProperty(exports2, "getRuleById", { enumerable: true, get: function() {
+      return index_1.getRuleById;
+    } });
+    Object.defineProperty(exports2, "getRulesByCategory", { enumerable: true, get: function() {
+      return index_1.getRulesByCategory;
+    } });
+    var suppression_1 = require_suppression();
+    Object.defineProperty(exports2, "applySuppressions", { enumerable: true, get: function() {
+      return suppression_1.applySuppressions;
+    } });
+    Object.defineProperty(exports2, "parseInlineSuppressions", { enumerable: true, get: function() {
+      return suppression_1.parseInlineSuppressions;
+    } });
+    Object.defineProperty(exports2, "loadPolicyFile", { enumerable: true, get: function() {
+      return suppression_1.loadPolicyFile;
+    } });
+    Object.defineProperty(exports2, "PRESETS", { enumerable: true, get: function() {
+      return suppression_1.PRESETS;
+    } });
+  }
+});
+
+// packages/cli/dist/commands/scan.js
+var require_scan = __commonJS({
+  "packages/cli/dist/commands/scan.js"(exports2) {
+    "use strict";
+    var __createBinding2 = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault2 = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar2 = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding2(result, mod, k[i]);
+        }
+        __setModuleDefault2(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.scanCommand = scanCommand;
+    var fs = __importStar2(require("fs"));
+    var path = __importStar2(require("path"));
+    var scanner_1 = require_dist3();
+    var VALID_FORMATS = ["terminal", "json", "md", "sarif"];
+    var VALID_SEVERITIES = ["critical", "high", "medium", "low", "info"];
+    var VALID_PRESETS = ["strict", "standard", "monitor"];
+    async function scanCommand(targetPath, options) {
+      const rootDir = path.resolve(targetPath);
+      if (!fs.existsSync(rootDir)) {
+        console.error(`
+  \x1B[31mError:\x1B[0m Directory not found: ${rootDir}
+`);
+        process.exit(2);
+      }
+      if (!fs.statSync(rootDir).isDirectory()) {
+        console.error(`
+  \x1B[31mError:\x1B[0m Not a directory: ${rootDir}
+`);
+        process.exit(2);
+      }
+      const format = options.format;
+      if (!VALID_FORMATS.includes(format)) {
+        console.error(`
+  \x1B[31mError:\x1B[0m Invalid format "${options.format}". Valid formats: ${VALID_FORMATS.join(", ")}
+`);
+        process.exit(2);
+      }
+      if (options.minSeverity && !VALID_SEVERITIES.includes(options.minSeverity)) {
+        console.error(`
+  \x1B[31mError:\x1B[0m Invalid severity "${options.minSeverity}". Valid values: ${VALID_SEVERITIES.join(", ")}
+`);
+        process.exit(2);
+      }
+      const preset = options.preset ?? "standard";
+      if (!VALID_PRESETS.includes(preset)) {
+        console.error(`
+  \x1B[31mError:\x1B[0m Invalid preset "${options.preset}". Valid presets: ${VALID_PRESETS.join(", ")}
+`);
+        process.exit(2);
+      }
+      try {
+        const result = await (0, scanner_1.scan)({
+          rootDir,
+          minSeverity: options.minSeverity,
+          rules: options.rules?.split(",").map((r) => r.trim()),
+          updateRegistry: options.registry
+        });
+        if (result.frameworks.length === 0 && format === "terminal") {
+          console.log(`
+  \x1B[36m\x1B[1mSentinelFlow v0.2.0\x1B[0m \u2014 Agent Governance Scanner
+
+  Scanning ${rootDir}...
+
+  \x1B[33mNo agent frameworks detected.\x1B[0m
+
+  SentinelFlow scans for agents in:
+    \u2022 Claude Code  (.claude/ directory, CLAUDE.md, AGENTS.md)
+    \u2022 Cursor       (.cursor/ directory, .cursorrules)
+    \u2022 Codex        (.codex/ directory, .agents/)
+    \u2022 LangChain    (pyproject.toml with langchain dependency)
+    \u2022 CrewAI       (crew.yaml, agents.yaml)
+    \u2022 Kiro         (.kiro/ directory)
+
+  Run \x1B[1msentinelflow init\x1B[0m to set up governance for this project.
+`);
+          return;
+        }
+        const { policy, warnings: policyWarnings } = (0, scanner_1.loadPolicyFile)(rootDir);
+        const effectivePreset = options.preset ? preset : policy?.preset ?? "standard";
+        const suppressionResult = (0, scanner_1.applySuppressions)(result.report.findings, [], rootDir);
+        if (!options.showSuppressed) {
+          result.report.findings = suppressionResult.active;
+          result.report.summary = {
+            critical: result.report.findings.filter((f) => f.severity === "critical").length,
+            high: result.report.findings.filter((f) => f.severity === "high").length,
+            medium: result.report.findings.filter((f) => f.severity === "medium").length,
+            low: result.report.findings.filter((f) => f.severity === "low").length,
+            info: result.report.findings.filter((f) => f.severity === "info").length,
+            total: result.report.findings.length
+          };
+        }
+        switch (format) {
+          case "json":
+            console.log((0, scanner_1.formatJSON)(result));
+            break;
+          case "md":
+            console.log((0, scanner_1.formatMarkdown)(result));
+            break;
+          case "sarif":
+            console.log((0, scanner_1.formatSARIF)(result));
+            break;
+          case "terminal":
+          default:
+            console.log((0, scanner_1.formatTerminal)(result));
+            break;
+        }
+        if (format === "terminal" && suppressionResult.suppressed.length > 0) {
+          if (options.showSuppressed) {
+            console.log(`  \x1B[33mSuppressed findings (${suppressionResult.suppressed.length}):\x1B[0m`);
+            for (const { finding, suppression } of suppressionResult.suppressed) {
+              console.log(`    \x1B[2m${finding.rule_id}\x1B[0m ${finding.title}`);
+              console.log(`      Reason: ${suppression.reason}`);
+              if (suppression.expires)
+                console.log(`      Expires: ${suppression.expires}`);
+              if (suppression.ticket)
+                console.log(`      Ticket: ${suppression.ticket}`);
+            }
+            console.log("");
+          } else {
+            console.log(`  \x1B[2m${suppressionResult.suppressed.length} finding(s) suppressed. Use --show-suppressed to review.\x1B[0m`);
+            console.log("");
+          }
+        }
+        if (format === "terminal" && suppressionResult.expired_suppressions.length > 0) {
+          console.log(`  \x1B[33m\u26A0 ${suppressionResult.expired_suppressions.length} expired suppression(s):\x1B[0m`);
+          for (const exp of suppressionResult.expired_suppressions) {
+            console.log(`    ${exp.rule_id} \u2014 expired ${exp.expires} \u2014 ${exp.reason}`);
+          }
+          console.log("  \x1B[2mRemove expired entries from .sentinelflow-policy.yaml\x1B[0m");
+          console.log("");
+        }
+        if (format === "terminal") {
+          const agentCount = result.agents.length;
+          const configCount = result.report.findings.length;
+          console.log(`  \x1B[2m\u250C\u2500 Coverage \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510\x1B[0m`);
+          console.log(`  \x1B[2m\u2502 Static analysis of ${agentCount} agent definition(s).          \u2502\x1B[0m`);
+          console.log(`  \x1B[2m\u2502                                                    \u2502\x1B[0m`);
+          console.log(`  \x1B[2m\u2502 Not analyzed (requires runtime context):            \u2502\x1B[0m`);
+          console.log(`  \x1B[2m\u2502  \xB7 IAM roles and cloud permissions                  \u2502\x1B[0m`);
+          console.log(`  \x1B[2m\u2502  \xB7 Secrets injected via Vault / env variables       \u2502\x1B[0m`);
+          console.log(`  \x1B[2m\u2502  \xB7 Network policies and service mesh config         \u2502\x1B[0m`);
+          console.log(`  \x1B[2m\u2502  \xB7 Feature flags gating agent capabilities          \u2502\x1B[0m`);
+          console.log(`  \x1B[2m\u2502                                                    \u2502\x1B[0m`);
+          console.log(`  \x1B[2m\u2502 Preset: ${effectivePreset.padEnd(10)} Docs: sentinelflow.dev \u2502\x1B[0m`);
+          console.log(`  \x1B[2m\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518\x1B[0m`);
+          console.log("");
+        }
+        const allWarnings = [...result.warnings, ...policyWarnings];
+        if (allWarnings.length > 0 && format === "terminal") {
+          console.log("  \x1B[33mWarnings:\x1B[0m");
+          for (const warning of allWarnings) {
+            console.log(`    \x1B[33m\u26A0\x1B[0m ${warning}`);
+          }
+          console.log("");
+        }
+        const presetConfig = scanner_1.PRESETS[effectivePreset];
+        const { summary } = result.report;
+        const shouldFail = presetConfig.exitOnSeverities.some((sev) => {
+          switch (sev) {
+            case "critical":
+              return summary.critical > 0;
+            case "high":
+              return summary.high > 0;
+            case "medium":
+              return summary.medium > 0;
+            case "low":
+              return summary.low > 0;
+            default:
+              return false;
+          }
+        });
+        if (shouldFail) {
+          process.exit(1);
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`
+  \x1B[31mError:\x1B[0m ${message}
+`);
+        process.exit(2);
+      }
+    }
+  }
+});
+
+// packages/cli/dist/commands/init.js
+var require_init = __commonJS({
+  "packages/cli/dist/commands/init.js"(exports2) {
+    "use strict";
+    var __createBinding2 = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault2 = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar2 = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding2(result, mod, k[i]);
+        }
+        __setModuleDefault2(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.initCommand = initCommand;
+    var fs = __importStar2(require("fs"));
+    var path = __importStar2(require("path"));
+    var DEFAULT_MANIFEST = `# SentinelFlow Configuration
+# https://github.com/omswaroop/sentinelflow
+
+# Governance settings for this project
+governance:
+  # Who is responsible for AI agents in this project?
+  default_owner: ""
+  default_team: ""
+
+  # Minimum scan requirements
+  require_scan_before_commit: false
+  min_severity_to_block: "critical"
+
+  # Compliance standards to enforce
+  compliance:
+    # - eu-ai-act
+    # - soc2
+    # - hipaa
+    # - iso-42001
+
+# Scanner settings
+scanner:
+  # Rules to skip (by ID)
+  skip_rules: []
+
+  # Additional paths to scan for agent configs
+  include_paths: []
+
+  # Paths to exclude from scanning
+  exclude_paths:
+    - node_modules
+    - .git
+    - dist
+    - build
+
+# Registry settings
+registry:
+  # Where to store the registry (local = SQLite file)
+  backend: local
+
+  # SentinelFlow Cloud URL (for team sync, Phase 2+)
+  # cloud_url: https://api.sentinelflow.ai
+  # cloud_token: $SENTINELFLOW_TOKEN
+`;
+    async function initCommand(targetPath) {
+      const rootDir = path.resolve(targetPath);
+      const sfDir = path.join(rootDir, ".sentinelflow");
+      if (fs.existsSync(sfDir)) {
+        console.log("\n  SentinelFlow already initialized in this project.");
+        console.log(`  Config: ${sfDir}/config.yaml`);
+        console.log("  Run 'sentinelflow scan' to scan for agents.\n");
+        return;
+      }
+      fs.mkdirSync(sfDir, { recursive: true });
+      fs.mkdirSync(path.join(sfDir, "reports"), { recursive: true });
+      fs.writeFileSync(path.join(sfDir, "config.yaml"), DEFAULT_MANIFEST, "utf-8");
+      const gitignorePath = path.join(rootDir, ".gitignore");
+      if (fs.existsSync(gitignorePath)) {
+        const gitignore = fs.readFileSync(gitignorePath, "utf-8");
+        if (!gitignore.includes(".sentinelflow/registry")) {
+          fs.appendFileSync(gitignorePath, "\n# SentinelFlow local registry (config is committed, data is not)\n.sentinelflow/agents.json\n.sentinelflow/reports.json\n.sentinelflow/events.json\n.sentinelflow/registry.db\n");
+        }
+      }
+      console.log(`
+  \x1B[32m\u2713\x1B[0m SentinelFlow initialized!
+
+  Created:
+    ${sfDir}/config.yaml     \u2014 Governance configuration
+    ${sfDir}/reports/         \u2014 Scan report storage
+
+  Next steps:
+    1. Edit .sentinelflow/config.yaml to set your team info
+    2. Run \x1B[1msentinelflow scan\x1B[0m to discover agents
+    3. Review findings and register agents
+
+  Learn more: https://github.com/omswaroop/sentinelflow
+`);
+    }
+  }
+});
+
+// packages/cli/dist/index.js
+var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+  if (k2 === void 0) k2 = k;
+  var desc = Object.getOwnPropertyDescriptor(m, k);
+  if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+    desc = { enumerable: true, get: function() {
+      return m[k];
+    } };
+  }
+  Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+  if (k2 === void 0) k2 = k;
+  o[k2] = m[k];
+}));
+var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
+  Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+  o["default"] = v;
+});
+var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+  var ownKeys = function(o) {
+    ownKeys = Object.getOwnPropertyNames || function(o2) {
+      var ar = [];
+      for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+      return ar;
+    };
+    return ownKeys(o);
+  };
+  return function(mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) {
+      for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+    }
+    __setModuleDefault(result, mod);
+    return result;
+  };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var commander_1 = require("commander");
+var scan_1 = require_scan();
+var init_1 = require_init();
+var program = new commander_1.Command();
+program.name("sentinelflow").description("The vendor-neutral governance layer for enterprise AI agents").version("0.1.0");
+program.command("scan").description("Scan for AI agents and governance issues").argument("[path]", "Project directory to scan", ".").option("-f, --format <format>", "Output format: terminal, json, md, sarif", "terminal").option("--min-severity <severity>", "Minimum severity: critical, high, medium, low, info").option("--rules <rules>", "Comma-separated rule IDs to run").option("--preset <preset>", "Scan preset: strict, standard, monitor", "standard").option("--show-suppressed", "Show suppressed findings for audit review").option("--no-registry", "Skip updating the local registry").action(scan_1.scanCommand);
+program.command("init").description("Initialize SentinelFlow in the current project").argument("[path]", "Project directory", ".").action(init_1.initCommand);
+var registry = program.command("registry").description("Manage the agent registry");
+registry.command("list").description("List all registered agents").option("--framework <framework>", "Filter by framework").option("--status <status>", "Filter by governance status").option("--json", "Output as JSON").action(async (options) => {
+  const path = await Promise.resolve().then(() => __importStar(require("path")));
+  const { LocalRegistry } = await Promise.resolve().then(() => __importStar(require_dist()));
+  const reg = new LocalRegistry(process.cwd());
+  await reg.initialize();
+  const agents = await reg.listAgents({
+    framework: options.framework,
+    status: options.status
+  });
+  if (options.json) {
+    console.log(JSON.stringify(agents, null, 2));
+  } else {
+    if (agents.length === 0) {
+      console.log("\n  No agents registered. Run 'sentinelflow scan' first.\n");
+      return;
+    }
+    console.log(`
+  ${agents.length} agents registered:
+`);
+    for (const agent of agents) {
+      const risk = agent.governance.risk_level ?? "unassessed";
+      const status = agent.governance.status;
+      console.log(`    ${agent.name} (${agent.framework}) \u2014 ${status} \u2014 risk: ${risk}`);
+    }
+    console.log("");
+  }
+  await reg.close();
+});
+program.parse();