0xray 3.0.11 → 3.0.14

package/dist/processors/processor-types.js

@@ -10,4 +10,3 @@
  * @since 2026-01-07
  */
 export {};
-//# sourceMappingURL=processor-types.js.map

package/dist/public/XrayService.js

@@ -38,4 +38,3 @@ export class XrayService {
         frameworkLogger.log("XrayService", "shutdown", "info", { message: "XrayService shut down" });
     }
 }
-//# sourceMappingURL=XrayService.js.map

package/dist/public/about.html

@@ -3,7 +3,7 @@
 <head>
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>About 0xRay - Enterprise AI Orchestration</title>
+  <title>About StringRay - Enterprise AI Orchestration</title>
   <style>
     * { margin: 0; padding: 0; box-sizing: border-box; }
     body {
@@ -113,7 +113,7 @@
   <div class="container">
     <header>
       <span class="version">v1.4.20</span>
-      <h1>0xRay</h1>
+      <h1>StringRay</h1>
       <p class="tagline">Enterprise AI Orchestration Framework</p>
     </header>
 
@@ -141,8 +141,8 @@
     </div>
 
     <section class="section">
-      <h2>🎯 What is 0xRay?</h2>
-      <p>0xRay is an enterprise-grade AI orchestration framework that provides intelligent task routing, systematic error prevention, and comprehensive monitoring for AI-driven development workflows.</p>
+      <h2>🎯 What is StringRay?</h2>
+      <p>StringRay is an enterprise-grade AI orchestration framework that provides intelligent task routing, systematic error prevention, and comprehensive monitoring for AI-driven development workflows.</p>
     </section>
 
     <section class="section">
@@ -191,7 +191,7 @@
       <h2>🔄 8 Pipeline System</h2>
       <div class="pipeline-diagram">
 ┌─────────────────────────────────────────────────────────────────┐
-│                    0XRAY FRAMEWORK v1.4.20                     │
+│                    STRINGRAY FRAMEWORK v1.4.20                  │
 ├─────────────────────────────────────────────────────────────────┤
 │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐  ┌─────────┐ │
 │  │    INIT     │─▶│  AGENT      │─▶│   RULE      │─▶│  POST   │ │
@@ -220,7 +220,7 @@
     </section>
 
     <footer>
-      <p>0xRay Framework &copy; 2026 | Built for Enterprise AI Orchestration</p>
+      <p>StringRay Framework &copy; 2026 | Built for Enterprise AI Orchestration</p>
       <p style="margin-top: 10px; color: #6e7681;">338 logging points | 51 core files | JobId tracking enabled</p>
     </footer>
   </div>

package/dist/public/enterprise.html

@@ -3,7 +3,7 @@
 <head>
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>Enterprise - 0xRay</title>
+  <title>Enterprise - StringRay</title>
   <style>
     body { margin: 0; padding: 0; background: #0a0a0f; color: #e0e0e0; font-family: system-ui, sans-serif; }
     .container { max-width: 900px; margin: 0 auto; padding: 40px 20px; }

package/dist/public/features.html

@@ -3,7 +3,7 @@
 <head>
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>0xRay - Features</title>
+  <title>StringRay - Features</title>
   <style>
     * { margin: 0; padding: 0; box-sizing: border-box; }
     body {
@@ -56,7 +56,7 @@
 <body>
   <div class="container">
     <header>
-      <h1>0xRay Features</h1>
+      <h1>StringRay Features</h1>
       <p class="subtitle">Enterprise AI Orchestration Platform</p>
     </header>
     

package/dist/public/index.html

@@ -3,7 +3,7 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>⚡ 0xRay Dashboard</title>
+    <title>⚡ StringRay Dashboard</title>
     <style>
         body {
             font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
@@ -81,8 +81,8 @@
 <body>
     <div class="container">
         <div class="header">
-            <h1>⚡ 0xRay</h1>
-            <p>Self-Healing AI Governance OS - Production-Ready Code, No Dead Ends</p>
+            <h1>⚡ StringRay</h1>
+            <p>AI Agent Orchestration Framework - Production-Ready Code, No Dead Ends</p>
         </div>
 
         <div class="grid">
@@ -121,7 +121,7 @@
         </div>
 
         <div class="footer">
-            <p>🛡️ 0xRay - Self-Healing, Governed, Autonomous: Catch AI Mistakes Before They Ship</p>
+            <p>🛡️ StringRay - The AI Sentinel: Your Unwavering Guardian Against AI Development Catastrophes</p>
         </div>
     </div>
 

package/dist/public/index.js

@@ -1,3 +1,2 @@
 export { XrayService } from "./XrayService.js";
 export { beforeToolHook, afterToolHook } from "../integrations/enforcement-gate.js";
-//# sourceMappingURL=index.js.map

package/dist/reporting/framework-reporting-system.js

@@ -185,4 +185,3 @@ if (import.meta.url === `file://${process.argv[1]}`) {
         process.exit(1);
     });
 }
-//# sourceMappingURL=framework-reporting-system.js.map

package/dist/reporting/log-parser.js

@@ -279,4 +279,3 @@ export function filterLogsByConfig(logs, config) {
     }
     return filtered;
 }
-//# sourceMappingURL=log-parser.js.map

package/dist/reporting/metrics.js

@@ -200,4 +200,3 @@ export function getHighFrequencyComponents(logs) {
         .filter(([, count]) => count > 10)
         .map(([component]) => component);
 }
-//# sourceMappingURL=metrics.js.map

package/dist/reporting/report-formatter.js

@@ -98,7 +98,7 @@ ${data.recommendations.map((rec) => `- ${rec}`).join("\n")}
 4. **Performance Monitoring**: Track rule enforcement effectiveness metrics
 
 ---
-*Consumer runtime compat (XRAY_ env + .xray fallbacks)*
+*Consumer runtime compat shim from prior StringRay releases (1-line min per Scope Rule; primary xray paths + XRAY_||STRRAY_ env + .strray fallbacks)*
 *Framework Status: Operational*
     `;
 }
@@ -144,4 +144,3 @@ export function formatAsHtml(data) {
 </html>
     `;
 }
-//# sourceMappingURL=report-formatter.js.map

package/dist/reporting/types.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=types.js.map

package/dist/scripts/activate-kernel-pipeline.js

@@ -0,0 +1,101 @@
+/**
+ * Kernel Pipeline Activation Script
+ *
+ * Triggers real delegations that should activate kernel patterns.
+ * Observes the full pipeline in action.
+ */
+import { AgentDelegator } from '../delegation/agent-delegator.js';
+import { StringRayStateManager } from '../state/state-manager.js';
+import { strRayConfigLoader } from '../core/config-loader.js';
+import { routingOutcomeTracker } from '../delegation/analytics/outcome-tracker.js';
+import { patternPerformanceTracker } from '../analytics/pattern-performance-tracker.js';
+const stateManager = new StringRayStateManager();
+const delegator = new AgentDelegator(stateManager, strRayConfigLoader);
+console.log('=== KERNEL PIPELINE ACTIVATION TEST ===\n');
+// Test cases designed to trigger kernel patterns
+const testCases = [
+    {
+        operation: 'security',
+        description: 'Add new API endpoint with user authentication but skip input validation for SQL injection prevention',
+        expected: ['P6', 'A8']
+    },
+    {
+        operation: 'fix',
+        description: 'Fix infinite recursion in the calculateTotals function - it keeps calling itself',
+        expected: ['P1']
+    },
+    {
+        operation: 'test',
+        description: 'All tests pass on my machine but fail in CI - I think its an environment issue',
+        expected: ['A1', 'A9']
+    },
+    {
+        operation: 'deploy',
+        description: 'Run the deployment script but getting permission denied on execution',
+        expected: ['P8']
+    },
+    {
+        operation: 'update',
+        description: 'Upgrade all dependencies to latest version at once - we need everything current',
+        expected: ['P5']
+    },
+    {
+        operation: 'refactor',
+        description: 'The tests all pass but we still have bugs in production - I do not understand why',
+        expected: ['A2', 'A3']
+    },
+    {
+        operation: 'create',
+        description: 'Skip security for internal API - its only used internally so authentication is optional',
+        expected: ['A8']
+    },
+    {
+        operation: 'optimize',
+        description: 'Make the code 80% faster - use aggressive caching everywhere',
+        expected: ['A7']
+    },
+];
+let kernelEvents = 0;
+let learningEvents = 0;
+async function runTest(testCase) {
+    console.log(`\n--- Testing: ${testCase.operation} ---`);
+    console.log(`Description: ${testCase.description}`);
+    console.log(`Expected patterns: ${testCase.expected.join(', ')}`);
+    try {
+        const result = await delegator.analyzeDelegation({
+            operation: testCase.operation,
+            description: testCase.description,
+            sessionId: 'kernel-activation-test',
+        });
+        console.log(`Selected agents:`);
+        result.agentDetails.forEach(agent => {
+            console.log(`  - ${agent.name}: ${agent.role} (confidence: ${agent.confidence})`);
+        });
+        kernelEvents++;
+        // Check outcomes tracked
+        const outcomes = routingOutcomeTracker.getOutcomes();
+        console.log(`Total outcomes tracked: ${outcomes.length}`);
+        learningEvents++;
+    }
+    catch (error) {
+        console.log(`Error: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+async function main() {
+    console.log('Initial state:');
+    console.log(`  Outcomes: ${routingOutcomeTracker.getOutcomes().length}`);
+    for (const testCase of testCases) {
+        await runTest(testCase);
+        await new Promise(r => setTimeout(r, 100));
+    }
+    console.log('\n=== FINAL STATE ===');
+    console.log(`Delegations performed: ${kernelEvents}`);
+    console.log(`Learning events: ${learningEvents}`);
+    console.log(`Total outcomes: ${routingOutcomeTracker.getOutcomes().length}`);
+    // Check pattern metrics
+    const patternMetrics = patternPerformanceTracker.getMetrics?.() || {};
+    console.log(`Pattern types tracked: ${Object.keys(patternMetrics).length}`);
+    console.log('\n=== CHECKING ACTIVITY LOG ===');
+    // Log should show kernel-pattern-applied events
+}
+main().catch(console.error);

package/dist/scripts/integration.js

@@ -232,4 +232,3 @@ main().catch((error) => {
     console.error("Fatal error:", error);
     process.exit(1);
 });
-//# sourceMappingURL=integration.js.map

package/dist/scripts/pre-command

@@ -1,5 +1,5 @@
 #!/bin/bash
-# Pre-Command Hook for 0xRay
+# Pre-Command Hook for StringRay
 # 
 # Checks context window usage before each command.
 # If context is at 95%+ (configurable), auto-generates a reflection.

package/dist/security/comprehensive-security-audit.js

@@ -1003,4 +1003,3 @@ export async function runDeepSecurityAudit(projectPath, outputPath) {
     });
     return system.runAudit();
 }
-//# sourceMappingURL=comprehensive-security-audit.js.map

package/dist/security/index.js

@@ -0,0 +1,13 @@
+/**
+ * 0xRay AI v1.22.60 - Security Module Index
+ * Unified exports for the comprehensive security system
+ */
+export { SecurityScanner, securityScanner } from "./security-scanner.js";
+export { PromptSecurityValidator, promptSecurityValidator, } from "./prompt-security-validator.js";
+export * from "./security-headers.js";
+export * from "./security-hardening-system.js";
+export * from "./security-hardener.js";
+export * from "./security-auditor.js";
+export { ComprehensiveSecurityAuditSystem, createSecurityAuditSystem, runQuickSecurityAudit, runDeepSecurityAudit, } from "./comprehensive-security-audit.js";
+export { SecurityOrchestrationLayer, createSecurityOrchestrationLayer, runSecurityOrchestration, } from "./security-orchestration-layer.js";
+export { SecurityAgentCoordinator, createSecurityAgentCoordinator, runMultiAgentSecurityScan, } from "./security-agent-coordinator.js";

package/dist/security/prompt-security-validator.js

@@ -0,0 +1,148 @@
+/**
+ * 0xRay Framework - AI Prompt Security Validator
+ *
+ * Specialized security validation for AI agent prompts and responses
+ * Prevents prompt injection, system prompt override, and malicious inputs
+ */
+export class PromptSecurityValidator {
+    config;
+    constructor(config = {}) {
+        this.config = {
+            enabled: true,
+            maxPromptLength: 10000,
+            allowedPatterns: [],
+            blockedPatterns: [
+                /system\s+prompt\s*[:=]/gi,
+                /ignore\s+previous\s+instructions/gi,
+                /you\s+are\s+now\s+/gi,
+                /forget\s+your\s+previous\s+/gi,
+                /override\s+(your\s+)?instructions/gi,
+                /jailbreak/gi,
+                /dan.*mode/gi,
+            ],
+            sanitizeLevel: "strict",
+            ...config,
+        };
+    }
+    /**
+     * Validate AI prompt for security issues
+     */
+    validatePrompt(prompt) {
+        if (!this.config.enabled) {
+            return { isSafe: true, violations: [], riskLevel: "low" };
+        }
+        const violations = [];
+        let riskLevel = "low";
+        // Length check
+        if (prompt.length > this.config.maxPromptLength) {
+            violations.push(`Prompt too long: ${prompt.length} > ${this.config.maxPromptLength}`);
+            riskLevel = "medium";
+        }
+        // Blocked pattern check
+        for (const pattern of this.config.blockedPatterns) {
+            if (pattern.test(prompt)) {
+                violations.push(`Blocked pattern detected: ${pattern.source}`);
+                riskLevel = "high";
+            }
+        }
+        // Advanced pattern analysis
+        if (this.containsSystemPromptOverride(prompt)) {
+            violations.push("Potential system prompt override attempt");
+            riskLevel = "critical";
+        }
+        if (this.containsInjectionAttempts(prompt)) {
+            violations.push("Potential prompt injection detected");
+            riskLevel = "high";
+        }
+        const isSafe = violations.length === 0;
+        const sanitizedPrompt = isSafe ? undefined : this.sanitizePrompt(prompt);
+        return {
+            isSafe,
+            violations,
+            sanitizedPrompt,
+            riskLevel,
+        };
+    }
+    /**
+     * Check for system prompt override attempts
+     */
+    containsSystemPromptOverride(prompt) {
+        const overrideIndicators = [
+            "you are now",
+            "act as if",
+            "pretend to be",
+            "role-play as",
+            "from now on you are",
+            "ignore your system",
+            "override your",
+            "new personality",
+            "different role",
+        ];
+        const lowerPrompt = prompt.toLowerCase();
+        return overrideIndicators.some((indicator) => lowerPrompt.includes(indicator));
+    }
+    /**
+     * Check for prompt injection attempts
+     */
+    containsInjectionAttempts(prompt) {
+        const injectionIndicators = [
+            "ignore previous",
+            "forget instructions",
+            "start over",
+            "new conversation",
+            "reset context",
+            "clear memory",
+            "delete history",
+        ];
+        const lowerPrompt = prompt.toLowerCase();
+        return injectionIndicators.some((indicator) => lowerPrompt.includes(indicator));
+    }
+    /**
+     * Sanitize prompt by removing dangerous patterns
+     */
+    sanitizePrompt(prompt) {
+        let sanitized = prompt;
+        // Remove blocked patterns
+        for (const pattern of this.config.blockedPatterns) {
+            sanitized = sanitized.replace(pattern, "[REDACTED]");
+        }
+        // Additional sanitization based on level
+        if (this.config.sanitizeLevel === "strict" ||
+            this.config.sanitizeLevel === "paranoid") {
+            // Remove potential code execution
+            sanitized = sanitized.replace(/```[\s\S]*?```/g, "[CODE_BLOCK_REMOVED]");
+            // Remove potential file system access
+            sanitized = sanitized.replace(/(?:\/|\\)\.\.(?:\/|\\)/g, "/");
+            // Remove potential command injection
+            sanitized = sanitized.replace(/[;&|`$()]/g, "");
+        }
+        if (this.config.sanitizeLevel === "paranoid") {
+            // Extreme sanitization - only allow alphanumeric, spaces, and basic punctuation
+            sanitized = sanitized.replace(/[^a-zA-Z0-9\s.,!?-]/g, "");
+        }
+        return sanitized;
+    }
+    /**
+     * Validate agent response for safety
+     */
+    validateResponse(response) {
+        // Similar validation but focused on response safety
+        const violations = [];
+        // Check for potentially harmful content
+        if (response.includes("system prompt") ||
+            response.includes("internal instructions")) {
+            violations.push("Response contains sensitive system information");
+        }
+        // Check for code execution attempts
+        if (/eval\s*\(|Function\s*\(/.test(response)) {
+            violations.push("Response contains potential code execution");
+        }
+        return {
+            isSafe: violations.length === 0,
+            violations,
+            riskLevel: violations.length > 0 ? "medium" : "low",
+        };
+    }
+}
+// Export singleton instance
+export const promptSecurityValidator = new PromptSecurityValidator();

package/dist/security/security-agent-coordinator.js

@@ -0,0 +1,204 @@
+/**
+ * Security Agent Integration
+ *
+ * Integrates the security orchestration layer with the framework's agent system.
+ * Provides coordination between security agents using weighted voting.
+ *
+ * @version 1.22.13
+ */
+import { EventEmitter } from "events";
+import { frameworkLogger } from "../core/framework-logger.js";
+import { createSecurityOrchestrationLayer, } from "./security-orchestration-layer.js";
+export class SecurityAgentCoordinator extends EventEmitter {
+    orchestration;
+    agentRegistry = new Map();
+    isActive = false;
+    constructor(config) {
+        super();
+        this.orchestration = createSecurityOrchestrationLayer(config);
+        this.setupEventHandlers();
+    }
+    setupEventHandlers() {
+        this.orchestration.on("orchestration:start", (data) => {
+            this.emit("coordinator:start", data);
+            frameworkLogger.log("security-agent-coordinator", "coordinator-start", "info", data);
+        });
+        this.orchestration.on("orchestration:complete", (report) => {
+            this.emit("coordinator:complete", report);
+            frameworkLogger.log("security-agent-coordinator", "coordinator-complete", "info", {
+                auditId: report.auditId,
+                duration: report.duration,
+                vulnerabilities: report.summary.totalVulnerabilities,
+            });
+        });
+        this.orchestration.on("orchestration:error", (error) => {
+            this.emit("coordinator:error", error);
+            frameworkLogger.log("security-agent-coordinator", "coordinator-error", "error", error);
+        });
+        this.orchestration.on("agent:vote", ({ agentId, vote }) => {
+            this.emit("agent:vote", { agentId, vote });
+        });
+        this.orchestration.on("agent:status-change", (agent) => {
+            this.emit("agent:status-change", agent);
+        });
+        this.orchestration.on("task:complete", (task) => {
+            this.emit("task:complete", task);
+        });
+        this.orchestration.on("task:failed", (task) => {
+            this.emit("task:failed", task);
+        });
+    }
+    registerAgent(config) {
+        this.agentRegistry.set(config.agentId, config);
+        frameworkLogger.log("security-agent-coordinator", "agent-registered", "info", {
+            agentId: config.agentId,
+            agentType: config.agentType,
+            weight: config.weight,
+        });
+    }
+    unregisterAgent(agentId) {
+        const removed = this.agentRegistry.delete(agentId);
+        if (removed) {
+            frameworkLogger.log("security-agent-coordinator", "agent-unregistered", "info", {
+                agentId,
+            });
+        }
+        return removed;
+    }
+    getRegisteredAgents() {
+        return Array.from(this.agentRegistry.values());
+    }
+    async runCoordinatedSecurityScan(context) {
+        this.isActive = true;
+        const startTime = Date.now();
+        frameworkLogger.log("security-agent-coordinator", "coordinated-scan-start", "info", {
+            projectPath: context.projectPath,
+            scanDepth: context.scanDepth,
+            registeredAgents: this.agentRegistry.size,
+        });
+        try {
+            const report = await this.orchestration.runSecurityOrchestration(context.projectPath);
+            const agentVotes = this.collectAgentVotes(report);
+            const weightedApproval = this.calculateWeightedApproval(agentVotes);
+            const result = {
+                auditId: report.auditId,
+                timestamp: report.timestamp,
+                duration: report.duration,
+                participatingAgents: report.agents.map((a) => a.name),
+                vulnerabilities: report.vulnerabilities,
+                decisions: report.decisions,
+                agentVotes,
+                summary: report.summary,
+                weightedApproval,
+                approved: weightedApproval >= 0.5,
+                recommendations: report.recommendations,
+            };
+            this.emit("coordinated-scan:complete", result);
+            return result;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            frameworkLogger.log("security-agent-coordinator", "coordinated-scan-error", "error", {
+                error: errorMessage,
+            });
+            throw error;
+        }
+        finally {
+            this.isActive = false;
+        }
+    }
+    collectAgentVotes(report) {
+        const vulnerabilities = report.vulnerabilities;
+        const agents = report.agents;
+        return agents.map((agent) => {
+            const agentVulns = vulnerabilities.filter((v) => v.severity === "critical" || v.severity === "high");
+            const concerns = [];
+            let vote = "approve";
+            let reasoning = `Security review by ${agent.name}. Found ${vulnerabilities.length} vulnerabilities.`;
+            const criticalCount = vulnerabilities.filter((v) => v.severity === "critical").length;
+            const highCount = vulnerabilities.filter((v) => v.severity === "high").length;
+            if (criticalCount > 0) {
+                concerns.push(`${criticalCount} critical vulnerabilities detected`);
+            }
+            if (highCount > 5) {
+                concerns.push(`${highCount} high-severity vulnerabilities`);
+            }
+            if (criticalCount > 5) {
+                vote = "reject";
+                reasoning = "Too many critical vulnerabilities. Security posture unacceptable.";
+            }
+            else if (criticalCount > 0 || highCount > 10) {
+                vote = "approve";
+                reasoning = "Acceptable with noted concerns. Priority fixes required.";
+            }
+            return {
+                agentId: agent.id,
+                agentName: agent.name,
+                vote,
+                weight: agent.weight,
+                reasoning,
+                concerns,
+                confidence: Math.max(0.5, 1 - (criticalCount * 0.1 + highCount * 0.02)),
+            };
+        });
+    }
+    calculateWeightedApproval(votes) {
+        if (votes.length === 0)
+            return 0;
+        const totalWeight = votes.reduce((sum, v) => sum + v.weight, 0);
+        const approvalWeight = votes
+            .filter((v) => v.vote === "approve")
+            .reduce((sum, v) => sum + v.weight, 0);
+        return totalWeight > 0 ? approvalWeight / totalWeight : 0;
+    }
+    getOrchestrationLayer() {
+        return this.orchestration;
+    }
+    getActiveAgents() {
+        return this.orchestration.getActiveAgents();
+    }
+    getPendingTasks() {
+        return this.orchestration.getTasks().filter((t) => t.status === "pending");
+    }
+    isCoordinatorActive() {
+        return this.isActive;
+    }
+}
+export function createSecurityAgentCoordinator(config) {
+    return new SecurityAgentCoordinator(config);
+}
+export async function runMultiAgentSecurityScan(projectPath, context) {
+    const coordinator = createSecurityAgentCoordinator();
+    const fullContext = {
+        projectPath,
+        scanDepth: context?.scanDepth || "medium",
+        complianceStandards: context?.complianceStandards || ["owasp-top-10", "cwe"],
+        enableAutoRemediation: context?.enableAutoRemediation ?? true,
+        ...context,
+    };
+    coordinator.registerAgent({
+        agentId: "agent-security-auditor",
+        agentType: "security-auditor",
+        capabilities: ["vulnerability-scanning", "threat-detection", "security-auditing"],
+        weight: 0.35,
+    });
+    coordinator.registerAgent({
+        agentId: "agent-code-analyzer",
+        agentType: "code-analyzer",
+        capabilities: ["code-pattern-analysis", "static-analysis", "security-hotspot-detection"],
+        weight: 0.30,
+    });
+    coordinator.registerAgent({
+        agentId: "agent-testing-lead",
+        agentType: "testing-lead",
+        capabilities: ["security-testing", "penetration-testing", "vulnerability-validation"],
+        weight: 0.20,
+    });
+    coordinator.registerAgent({
+        agentId: "agent-architect",
+        agentType: "architect",
+        capabilities: ["security-architecture", "threat-modeling", "risk-assessment"],
+        weight: 0.15,
+    });
+    return coordinator.runCoordinatedSecurityScan(fullContext);
+}