0xray 3.0.12 → 3.0.14

package/dist/delegation/voting-coordinator.js

@@ -0,0 +1,375 @@
+/**
+ * Voting Coordinator
+ *
+ * Multi-agent voting system with:
+ * - Weighted confidence scoring based on agent expertise
+ * - Adaptive strategy selection
+ * - Historical learning and pattern detection
+ * - Integration with session coordinator
+ *
+ * @version 1.0.0
+ * @since 2026-04-16
+ */
+import * as crypto from "crypto";
+import { getAgentExpertiseLevel, getVotingWeight } from "./agent-expertise.js";
+import { selectVotingStrategy, adaptiveStrategySelector } from "./strategy-selector.js";
+import { WeightedVotingAggregator } from "./weighted-voting-aggregator.js";
+import { frameworkLogger } from "../core/framework-logger.js";
+const MAX_HISTORY_ENTRIES = 500;
+const VOTE_TIMEOUT_MS = 30000;
+const DEFAULT_CONFIG = {
+    enableHistoryTracking: true,
+    enableLearning: true,
+    minVotersForConsensus: 3,
+    consensusThreshold: 0.7,
+};
+export class VotingCoordinator {
+    stateManager;
+    sessionCoordinator;
+    activeVotingSessions = new Map();
+    votingHistory = [];
+    metrics;
+    config;
+    aggregator;
+    constructor(stateManager, sessionCoordinator, config = {}) {
+        this.stateManager = stateManager;
+        this.sessionCoordinator = sessionCoordinator ?? undefined;
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.aggregator = new WeightedVotingAggregator();
+        this.metrics = this.initializeMetrics();
+        this.loadHistory();
+    }
+    async initiateVoting(sessionId, topic, description, participants, context) {
+        const complexity = context?.complexity ?? 25;
+        const riskLevel = context?.riskLevel ?? "medium";
+        const hasSecurity = context?.hasSecurityConcerns ?? false;
+        const hasArch = context?.hasArchitecturalImpact ?? false;
+        const participantCount = context?.participantCount ?? participants.length;
+        const strategy = context
+            ? adaptiveStrategySelector.selectStrategyWithDefaults(complexity, riskLevel, hasSecurity, hasArch, participantCount)
+            : selectVotingStrategy(complexity, riskLevel, hasSecurity, hasArch, participants.length);
+        const votingSession = {
+            id: `vote_${Date.now()}_${crypto.randomBytes(4).toString("hex")}`,
+            sessionId,
+            topic,
+            description,
+            strategy,
+            complexity,
+            riskLevel,
+            participants,
+            votes: [],
+            createdAt: Date.now(),
+        };
+        this.activeVotingSessions.set(votingSession.id, votingSession);
+        frameworkLogger.log("VotingCoordinator", "voting-initiated", "info", {
+            sessionId: votingSession.id,
+            topic,
+            strategy,
+            participantCount: participants.length,
+        });
+        if (this.sessionCoordinator) {
+            this.sessionCoordinator.shareContext(sessionId, `vote:${votingSession.id}`, { topic, strategy, participants: [] }, "voting-coordinator");
+        }
+        return votingSession.id;
+    }
+    submitVote(voteId, agentName, vote, confidence, reasoning) {
+        const session = this.activeVotingSessions.get(voteId);
+        if (!session) {
+            frameworkLogger.log("VotingCoordinator", "vote-submission-failed", "warning", {
+                voteId,
+                reason: "Session not found",
+            });
+            return false;
+        }
+        if (!session.participants.includes(agentName)) {
+            frameworkLogger.log("VotingCoordinator", "vote-submission-failed", "warning", {
+                voteId,
+                agentName,
+                reason: "Agent not authorized",
+            });
+            return false;
+        }
+        const existingVoteIndex = session.votes.findIndex((v) => v.agentName === agentName);
+        const voteChoice = {
+            agentName,
+            vote,
+            confidence: Math.max(0, Math.min(1, confidence)),
+            reasoning,
+            timestamp: Date.now(),
+        };
+        if (existingVoteIndex >= 0) {
+            session.votes[existingVoteIndex] = voteChoice;
+        }
+        else {
+            session.votes.push(voteChoice);
+        }
+        this.metrics.totalVotes++;
+        if (this.sessionCoordinator) {
+            this.sessionCoordinator.shareContext(session.sessionId, `vote:${voteId}`, { topic: session.topic, strategy: session.strategy, votes: session.votes }, agentName);
+        }
+        frameworkLogger.log("VotingCoordinator", "vote-submitted", "info", {
+            voteId,
+            agentName,
+            vote,
+            confidence,
+        });
+        return true;
+    }
+    resolveVoting(voteId) {
+        const session = this.activeVotingSessions.get(voteId);
+        if (!session) {
+            return null;
+        }
+        if (session.votes.length === 0) {
+            frameworkLogger.log("VotingCoordinator", "resolve-failed", "error", {
+                voteId,
+                reason: "No votes cast",
+            });
+            return null;
+        }
+        let result;
+        switch (session.strategy) {
+            case "majority_vote":
+                result = this.resolveMajorityVote(session);
+                break;
+            case "consensus":
+                result = this.resolveConsensus(session);
+                break;
+            case "expert_priority":
+                result = this.resolveExpertPriority(session);
+                break;
+            default:
+                result = this.resolveMajorityVote(session);
+        }
+        session.result = result;
+        session.resolvedAt = Date.now();
+        this.recordVotingHistory(session, result);
+        this.metrics.successfulVotes++;
+        this.updateMetricsAfterVote(result);
+        this.activeVotingSessions.delete(voteId);
+        if (this.sessionCoordinator) {
+            this.sessionCoordinator.recordConflict(session.sessionId, session.participants, session.strategy, result.decision);
+        }
+        frameworkLogger.log("VotingCoordinator", "voting-resolved", "info", {
+            voteId,
+            strategy: session.strategy,
+            decision: result.decision,
+            confidence: result.confidence,
+        });
+        return result;
+    }
+    resolveConflict(request) {
+        const { sessionId, topic, description, agents, requiresSecurityVote, requiresArchitectureVote, complexity, riskLevel } = request;
+        const context = {
+            complexity,
+            riskLevel,
+            participantCount: agents.length,
+            hasSecurityConcerns: requiresSecurityVote,
+            hasArchitecturalImpact: requiresArchitectureVote,
+        };
+        const strategy = adaptiveStrategySelector.selectStrategy(context);
+        const votingId = this.initiateVoting(sessionId, topic, description, agents, context);
+        const response = {
+            resolved: true,
+            strategy,
+            confidence: 0,
+            details: `Conflict resolution initiated with strategy: ${strategy}`,
+            participatingAgents: agents,
+        };
+        return response;
+    }
+    getAggregator() {
+        return this.aggregator;
+    }
+    getVotingSession(voteId) {
+        return this.activeVotingSessions.get(voteId);
+    }
+    getActiveVotingSessions() {
+        return Array.from(this.activeVotingSessions.values());
+    }
+    getVotingHistory(sessionId, limit) {
+        let history = this.votingHistory;
+        if (sessionId) {
+            history = history.filter((entry) => entry.sessionId === sessionId);
+        }
+        if (limit) {
+            history = history.slice(-limit);
+        }
+        return history;
+    }
+    getMetrics() {
+        return { ...this.metrics };
+    }
+    resolveMajorityVote(session) {
+        const aggregated = this.aggregator.aggregateVotes(session.votes);
+        if (aggregated.length === 0) {
+            return {
+                decision: "",
+                confidence: 0,
+                strategy: "majority_vote",
+                voteCount: 0,
+                winningVotes: 0,
+                totalVoters: session.participants.length,
+                tied: false,
+                details: [],
+            };
+        }
+        const winner = aggregated[0];
+        const second = aggregated[1];
+        const tied = Boolean(second && Math.abs(winner.totalWeight - second.totalWeight) < 0.01);
+        const totalWeight = aggregated.reduce((sum, agg) => sum + agg.totalWeight, 0);
+        const confidence = totalWeight > 0 ? winner.totalWeight / totalWeight : 0;
+        const details = session.votes.map((vote) => ({
+            agentName: vote.agentName,
+            expertiseLevel: getAgentExpertiseLevel(vote.agentName),
+            vote: vote.vote,
+            weight: this.aggregator.calculateTotalVoteWeight(vote.agentName, vote.confidence),
+            contributed: vote.vote === winner.option,
+        }));
+        return {
+            decision: winner.option,
+            confidence,
+            strategy: "majority_vote",
+            voteCount: session.votes.length,
+            winningVotes: winner.contributingAgents.length,
+            totalVoters: session.participants.length,
+            tied,
+            details,
+        };
+    }
+    resolveConsensus(session) {
+        const aggregated = this.aggregator.aggregateVotes(session.votes);
+        if (aggregated.length === 0) {
+            return {
+                decision: "", confidence: 0, strategy: "consensus",
+                voteCount: 0, winningVotes: 0, totalVoters: session.participants.length,
+                tied: false, details: [],
+            };
+        }
+        const winner = aggregated[0];
+        const requiredVotes = Math.ceil(session.participants.length * this.config.consensusThreshold);
+        const hasConsensus = winner.contributingAgents.length >= requiredVotes;
+        if (hasConsensus) {
+            const winnerVotes = session.votes.filter((v) => v.vote === winner.option);
+            const avgConfidence = winnerVotes.reduce((s, v) => s + v.confidence, 0) / winnerVotes.length;
+            const expertiseSum = winnerVotes.reduce((s, v) => s + this.aggregator.calculateTotalVoteWeight(v.agentName, v.confidence), 0);
+            const totalWeight = winnerVotes.reduce((s, v) => s + getVotingWeight(v.agentName), 0);
+            const confidence = totalWeight > 0 ? avgConfidence * (expertiseSum / (totalWeight * 10)) : avgConfidence;
+            return {
+                decision: winner.option, confidence, strategy: "consensus",
+                voteCount: session.votes.length, winningVotes: winnerVotes.length,
+                totalVoters: session.participants.length, tied: false,
+                details: winnerVotes.map((v) => ({
+                    agentName: v.agentName, expertiseLevel: getAgentExpertiseLevel(v.agentName),
+                    vote: v.vote, weight: this.aggregator.calculateTotalVoteWeight(v.agentName, v.confidence),
+                    contributed: true,
+                })),
+            };
+        }
+        const second = aggregated[1];
+        const tied = Boolean(second && Math.abs(winner.totalWeight - second.totalWeight) < 0.01);
+        const winnerVotes = session.votes.filter((v) => v.vote === winner.option);
+        const avgConfidence = winnerVotes.length > 0 ? winnerVotes.reduce((s, v) => s + v.confidence, 0) / winnerVotes.length : 0;
+        return {
+            decision: winner.option, confidence: avgConfidence * 0.5, strategy: "consensus",
+            voteCount: session.votes.length, winningVotes: winnerVotes.length,
+            totalVoters: session.participants.length, tied,
+            details: winnerVotes.map((v) => ({
+                agentName: v.agentName, expertiseLevel: getAgentExpertiseLevel(v.agentName),
+                vote: v.vote, weight: this.aggregator.calculateTotalVoteWeight(v.agentName, v.confidence),
+                contributed: true,
+            })),
+        };
+    }
+    resolveExpertPriority(session) {
+        const experts = new Map();
+        for (const vote of session.votes) {
+            const expertise = getAgentExpertiseLevel(vote.agentName);
+            const existing = experts.get(vote.agentName);
+            if (!existing || expertise > existing.expertise) {
+                experts.set(vote.agentName, { expertise, vote });
+            }
+        }
+        const sortedByExpertise = Array.from(experts.values()).sort((a, b) => b.expertise - a.expertise);
+        const topExpert = sortedByExpertise[0];
+        const secondExpert = sortedByExpertise[1];
+        const tied = Boolean(secondExpert && topExpert && topExpert.expertise === secondExpert.expertise);
+        const details = session.votes.map((v) => ({
+            agentName: v.agentName,
+            expertiseLevel: getAgentExpertiseLevel(v.agentName),
+            vote: v.vote,
+            weight: getVotingWeight(v.agentName),
+            contributed: v.agentName === topExpert?.vote?.agentName,
+        }));
+        return {
+            decision: topExpert?.vote?.vote ?? "",
+            confidence: ((topExpert?.vote?.confidence ?? 0) * (topExpert?.expertise ?? 5)) / 10,
+            strategy: "expert_priority",
+            voteCount: session.votes.length,
+            winningVotes: topExpert ? 1 : 0,
+            totalVoters: session.participants.length,
+            tied,
+            details,
+        };
+    }
+    recordVotingHistory(session, result) {
+        if (!this.config.enableHistoryTracking)
+            return;
+        const entry = {
+            id: session.id,
+            sessionId: session.sessionId,
+            topic: session.topic,
+            voteCount: session.votes.length,
+            strategy: session.strategy,
+            decision: result.decision,
+            confidence: result.confidence,
+            participantCount: session.participants.length,
+            timestamp: session.createdAt,
+            resolvedAt: session.resolvedAt ?? Date.now(),
+        };
+        this.votingHistory.push(entry);
+        if (this.votingHistory.length > MAX_HISTORY_ENTRIES) {
+            this.votingHistory = this.votingHistory.slice(-MAX_HISTORY_ENTRIES);
+        }
+        this.stateManager.set("voting:history", this.votingHistory);
+    }
+    loadHistory() {
+        if (!this.config.enableHistoryTracking)
+            return;
+        try {
+            const history = this.stateManager.get("voting:history");
+            if (Array.isArray(history)) {
+                this.votingHistory = history;
+            }
+        }
+        catch (error) {
+            frameworkLogger.log("VotingCoordinator", "history-load-failed", "warning", { error });
+        }
+    }
+    initializeMetrics() {
+        return {
+            totalVotes: 0,
+            successfulVotes: 0,
+            failedVotes: 0,
+            averageConfidence: 0,
+            strategyUsage: {
+                majority_vote: 0,
+                consensus: 0,
+                expert_priority: 0,
+            },
+            agentParticipation: {},
+            averageVoterTurnout: 0,
+        };
+    }
+    updateMetricsAfterVote(result) {
+        this.metrics.strategyUsage[result.strategy]++;
+        if (result.confidence > 0) {
+            const total = this.metrics.successfulVotes;
+            this.metrics.averageConfidence =
+                (this.metrics.averageConfidence * (total - 1) + result.confidence) / total;
+        }
+    }
+}
+export const createVotingCoordinator = (stateManager, sessionCoordinator) => {
+    return new VotingCoordinator(stateManager, sessionCoordinator);
+};

package/dist/delegation/voting-types.js

@@ -8,4 +8,3 @@
  * @since 2026-04-16
  */
 export {};
-//# sourceMappingURL=voting-types.js.map

package/dist/delegation/weighted-voting-aggregator.js

@@ -192,4 +192,3 @@ export function createDetailedVotingResult(votes, aggregator) {
     }));
     return { aggregated, winner, confidence, details };
 }
-//# sourceMappingURL=weighted-voting-aggregator.js.map

package/dist/enforcement/core/index.js

@@ -17,4 +17,3 @@ export { RuleHierarchy } from './rule-hierarchy.js';
 export { RuleExecutor } from './rule-executor.js';
 // Violation fix delegation
 export { ViolationFixer } from './violation-fixer.js';
-//# sourceMappingURL=index.js.map

package/dist/enforcement/core/rule-executor.js

@@ -363,4 +363,3 @@ export class RuleExecutor {
         }
     }
 }
-//# sourceMappingURL=rule-executor.js.map

package/dist/enforcement/core/rule-hierarchy.js

@@ -257,4 +257,3 @@ export class RuleHierarchy {
         return Array.from(rules);
     }
 }
-//# sourceMappingURL=rule-hierarchy.js.map

package/dist/enforcement/core/rule-registry.js

@@ -238,4 +238,3 @@ export class RuleRegistry {
         this.rules.clear();
     }
 }
-//# sourceMappingURL=rule-registry.js.map

package/dist/enforcement/core/violation-fixer.js

@@ -649,4 +649,3 @@ export class ViolationFixer {
         });
     }
 }
-//# sourceMappingURL=violation-fixer.js.map

package/dist/enforcement/enforcer-tools.js

@@ -5,15 +5,137 @@
 import { ruleEnforcer, } from "./rule-enforcer.js";
 import { frameworkLogger } from "../core/framework-logger.js";
 import { AgentDelegator } from "../delegation/agent-delegator.js";
-import { XrayStateManager } from "../state/state-manager.js";
+import { StringRayStateManager } from "../state/state-manager.js";
 import { strRayConfigLoader } from "../core/config-loader.js";
-import { ROUTING_MAPPINGS } from "../config/routing-mappings.js";
 import * as fs from "fs";
 import * as path from "path";
 // Minimum confidence to auto-delegate to another agent
 const DELEGATION_CONFIDENCE_THRESHOLD = 0.50;
 // Agents that enforcer should NOT delegate to (enforcer handles these itself)
 const ENFORCER_HANDLES = new Set(["code-reviewer"]);
+// Community skills are OPTIONAL - they may not be installed
+// These mappings have lower confidence (0.55-0.7) since skills may not be available
+// The system will fall back gracefully if the skill isn't installed
+const ROUTING_MAPPINGS = [
+    // Core built-in skills (high confidence)
+    { keywords: ["write", "file", "create"], skill: "code-review", agent: "code-reviewer", confidence: 0.9 },
+    { keywords: ["review", "audit", "assess", "evaluate", "check", "inspect", "quality", "validate", "code-review"], skill: "code-review", agent: "code-reviewer", confidence: 0.9 },
+    { keywords: ["test", "testing", "jest", "coverage", "unit", "e2e", "cypress", "spec", "verify"], skill: "testing-best-practices", agent: "testing-lead", confidence: 0.95 },
+    { keywords: ["fix", "debug", "triage", "broken", "error", "crash", "bug", "issue", "resolve"], skill: "bug-triage", agent: "bug-triage-specialist", confidence: 0.92 },
+    { keywords: ["security", "vulnerability", "threat", "scan", "risk", "exploit", "secure", "pentest"], skill: "security-audit", agent: "security-auditor", confidence: 0.95 },
+    { keywords: ["refactor", "cleanup", "improve", "restructure", "modernize", "debt"], skill: "refactoring-strategies", agent: "refactorer", confidence: 0.92 },
+    { keywords: ["performance", "optimize", "bottleneck", "benchmark", "profile", "speed"], skill: "performance-optimization", agent: "performance-engineer", confidence: 0.93 },
+    { keywords: ["frontend", "react", "vue", "angular", "ui", "ux", "interface", "component"], skill: "frontend-development", agent: "frontend-engineer", confidence: 0.95 },
+    { keywords: ["backend", "api", "server", "microservice", "endpoint"], skill: "backend-development", agent: "backend-engineer", confidence: 0.95 },
+    { keywords: ["docs", "documentation", "readme", "wiki", "guide", "manual"], skill: "documentation-generation", agent: "tech-writer", confidence: 0.9 },
+    { keywords: ["database", "db", "sql", "schema", "migration", "query"], skill: "database-design", agent: "database-engineer", confidence: 0.95 },
+    { keywords: ["deploy", "ci/cd", "pipeline", "docker", "kubernetes", "infrastructure"], skill: "devops-deployment", agent: "devops-engineer", confidence: 0.94 },
+    { keywords: ["mobile", "ios", "android", "react-native", "flutter"], skill: "mobile-development", agent: "mobile-developer", confidence: 0.95 },
+    { keywords: ["enforce", "compliance", "rule", "standard", "codex", "block", "prevent"], skill: "code-review", agent: "code-reviewer", confidence: 0.95 },
+    { keywords: ["design", "architect", "plan", "system", "model", "pattern", "architecture"], skill: "architecture-patterns", agent: "architect", confidence: 0.95 },
+    { keywords: ["codebase", "explore", "research", "discover", "implementation"], skill: "git-workflow", agent: "researcher", confidence: 0.88 },
+    // Additional built-in skill mappings
+    { keywords: ["api", "rest", "graphql", "openapi", "endpoint", "swagger"], skill: "api-design", agent: "backend-engineer", confidence: 0.9 },
+    { keywords: ["strategy", "roadmap", "planning", "technical", "decision", "architecture"], skill: "architecture-patterns", agent: "strategist", confidence: 0.88 },
+    { keywords: ["reflection", "story", "narrative", "saga", "journey", "document"], skill: "storyteller", agent: "tech-writer", confidence: 0.85 },
+    { keywords: ["analyze", "metrics", "complexity", "maintainability", "quality"], skill: "code-analyzer", agent: "code-analyzer", confidence: 0.9 },
+    { keywords: ["growth", "marketing", "conversion", "acquisition", "user-acquisition"], skill: "growth-strategist", agent: "growth-strategist", confidence: 0.9 },
+    { keywords: ["seo", "search", "organic", "traffic", "keywords", "ranking"], skill: "seo-consultant", agent: "seo-consultant", confidence: 0.92 },
+    { keywords: ["content", "copy", "blog", "marketing", "social"], skill: "content-creator", agent: "content-creator", confidence: 0.88 },
+    { keywords: ["format", "lint", "prettier", "eslint", "style", "formatting"], skill: "auto-format", agent: "code-reviewer", confidence: 0.85 },
+    { keywords: ["project", "structure", "health", "dependencies", "architecture"], skill: "project-analysis", agent: "architect", confidence: 0.88 },
+    { keywords: ["compliance", "audit", "standards", "framework", "validation"], skill: "framework-compliance-audit", agent: "code-reviewer", confidence: 0.9 },
+    { keywords: ["session", "state", "persistence", "storage", "cache"], skill: "session-management", agent: "backend-engineer", confidence: 0.85 },
+    { keywords: ["image", "visual", "pdf", "diagram", "multimedia", "media"], skill: "multimodal-looker", agent: "multimodal-looker", confidence: 0.92 },
+    { keywords: ["testing", "strategy", "coverage", "test-plan"], skill: "testing-strategy", agent: "testing-lead", confidence: 0.92 },
+    { keywords: ["inference", "model", "llm", "tuning", "optimization"], skill: "inference-improve", agent: "performance-engineer", confidence: 0.88 },
+    { keywords: ["orchestrate", "boot", "initialize", "startup", "bootstrap"], skill: "boot-orchestrator", agent: "architect", confidence: 0.9 },
+    // Additional unmapped skills
+    { keywords: ["tool", "utility", "helper", "instrument"], skill: "architect-tools", agent: "architect", confidence: 0.85 },
+    { keywords: ["design", "visual", "style", "theme", "css", "accessibility"], skill: "ui-ux-design", agent: "frontend-ui-ux-engineer", confidence: 0.9 },
+    { keywords: ["agent", "multi-agent", "coordination", "hermes", "communication"], skill: "hermes-agent", agent: "architect", confidence: 0.88 },
+    { keywords: ["log", "diagnostic", "trace", "monitor", "watch"], skill: "log-monitor", agent: "log-monitor", confidence: 0.9 },
+    { keywords: ["health", "diagnostic", "model-health", "validate-llm"], skill: "model-health-check", agent: "performance-engineer", confidence: 0.88 },
+    { keywords: ["analyze", "profiling", "memory", "cpu", "latency"], skill: "performance-analysis", agent: "performance-engineer", confidence: 0.9 },
+    { keywords: ["pipeline", "stream", "etl", "batch", "process"], skill: "processor-pipeline", agent: "backend-engineer", confidence: 0.88 },
+    { keywords: ["vulnerability", "cve", "sast", "dast", "dependency-check"], skill: "security-scan", agent: "security-auditor", confidence: 0.92 },
+    { keywords: ["state", "store", "redux", "context", "persistence"], skill: "state-manager", agent: "backend-engineer", confidence: 0.88 },
+    // ============================================================
+    // Community Skills (optional, lower confidence)
+    // These skills are from antigravity and may not be installed
+    // ============================================================
+    // UI/UX Design & Themes (antigravity)
+    { keywords: ["theme", "design-system", "color", "font", "typography", "palette"], skill: "antigravity--theme-factory", agent: "frontend-ui-ux-engineer", confidence: 0.6 },
+    { keywords: ["hig", "salesforce design", "lightning design", "slds"], skill: "antigravity--hig-components-system", agent: "frontend-ui-ux-engineer", confidence: 0.65 },
+    { keywords: ["slide", "deck", "presentation", "powerpoint"], skill: "antigravity--theme-factory", agent: "content-creator", confidence: 0.55 },
+    // SEO (antigravity)
+    { keywords: ["seo technical", "crawl", "indexability", "core web vitals", "sitemap"], skill: "antigravity--seo-technical", agent: "seo-consultant", confidence: 0.7 },
+    { keywords: ["seo structure", "content hierarchy", "schema", "internal linking"], skill: "antigravity--seo-structure-architect", agent: "seo-consultant", confidence: 0.7 },
+    { keywords: ["seo snippet", "meta description", "title tag"], skill: "antigravity--seo-snippet-hunter", agent: "seo-consultant", confidence: 0.7 },
+    { keywords: ["seo hreflang", "international seo", "multilingual"], skill: "antigravity--seo-hreflang", agent: "seo-consultant", confidence: 0.65 },
+    // Security (antigravity)
+    { keywords: ["backend security", "secure coding", "input validation", "authentication"], skill: "antigravity--backend-security-coder", agent: "security-auditor", confidence: 0.7 },
+    { keywords: ["mobile security", "ios security", "android security"], skill: "antigravity--mobile-security-coder", agent: "security-auditor", confidence: 0.65 },
+    { keywords: ["security audit", "vulnerability assessment", "penetration test"], skill: "security-audit", agent: "security-auditor", confidence: 0.75 },
+    // Vector/AI Databases (antigravity)
+    { keywords: ["vector", "embeddings", "similarity search", "pinecone", "qdrant", "chroma"], skill: "antigravity--vector-database-engineer", agent: "database-engineer", confidence: 0.65 },
+    { keywords: ["similarity search", "approximate nearest neighbor"], skill: "antigravity--similarity-search-patterns", agent: "database-engineer", confidence: 0.65 },
+    // Frameworks & Libraries (antigravity)
+    { keywords: ["svelte", "sveltekit", "svelte.js"], skill: "antigravity--sveltekit", agent: "frontend-engineer", confidence: 0.65 },
+    { keywords: ["trpc", "typescript rpc", "tRPC"], skill: "antigravity--trpc-fullstack", agent: "backend-engineer", confidence: 0.65 },
+    { keywords: ["vercel ai", "ai sdk", "vapi"], skill: "antigravity--vercel-ai-sdk-expert", agent: "backend-engineer", confidence: 0.65 },
+    { keywords: ["threejs", "3d web", "webgl", "3d graphics"], skill: "antigravity--threejs-loaders", agent: "frontend-engineer", confidence: 0.6 },
+    { keywords: ["comfyui", "ai image generation", "stable diffusion"], skill: "antigravity--comfyui-gateway", agent: "multimodal-looker", confidence: 0.6 },
+    // Mobile (antigravity)
+    { keywords: ["swiftui", "ios development"], skill: "antigravity--swiftui-liquid-glass", agent: "mobile-developer", confidence: 0.7 },
+    { keywords: ["ios performance", "swift optimization"], skill: "antigravity--swiftui-performance-audit", agent: "mobile-developer", confidence: 0.65 },
+    { keywords: ["react native", "rn"], skill: "mobile-development", agent: "mobile-developer", confidence: 0.7 },
+    // Backend/Golang (antigravity)
+    { keywords: ["golang", "go", "gopher"], skill: "antigravity--golang-pro", agent: "backend-engineer", confidence: 0.65 },
+    { keywords: ["temporal", "workflow", " durable execution"], skill: "antigravity--temporal-golang-pro", agent: "backend-engineer", confidence: 0.65 },
+    { keywords: ["python async", "asyncio", "uvloop"], skill: "antigravity--async-python-patterns", agent: "backend-engineer", confidence: 0.65 },
+    { keywords: ["pydantic", "data validation", "python models"], skill: "antigravity--pydantic-models-py", agent: "backend-engineer", confidence: 0.65 },
+    { keywords: ["scala", "spark", "big data"], skill: "antigravity--scala-pro", agent: "backend-engineer", confidence: 0.6 },
+    { keywords: ["dotnet", "c#", ".net"], skill: "antigravity--dotnet-backend-patterns", agent: "backend-engineer", confidence: 0.6 },
+    // Cloud/Azure (antigravity)
+    { keywords: ["azure", "azd", "azure deploy"], skill: "antigravity--azd-deployment", agent: "devops-engineer", confidence: 0.65 },
+    { keywords: ["azure storage", "file share"], skill: "antigravity--azure-storage-file-share-ts", agent: "devops-engineer", confidence: 0.6 },
+    { keywords: ["azure service bus", "messaging"], skill: "antigravity--azure-servicebus-py", agent: "devops-engineer", confidence: 0.6 },
+    // Automation/Bots (antigravity)
+    { keywords: ["discord bot", "discord automation"], skill: "antigravity--discord-bot-architect", agent: "backend-engineer", confidence: 0.6 },
+    { keywords: ["n8n", "workflow automation"], skill: "antigravity--n8n-expression-syntax", agent: "devops-engineer", confidence: 0.6 },
+    { keywords: ["linkedin automation", "social posting"], skill: "antigravity--linkedin-automation", agent: "growth-strategist", confidence: 0.55 },
+    { keywords: ["reddit automation"], skill: "antigravity--reddit-automation", agent: "growth-strategist", confidence: 0.55 },
+    { keywords: ["freshdesk", "customer support automation"], skill: "antigravity--freshdesk-automation", agent: "devops-engineer", confidence: 0.55 },
+    { keywords: ["pagerduty", "incident management"], skill: "antigravity--pagerduty-automation", agent: "devops-engineer", confidence: 0.55 },
+    // AI/ML (antigravity)
+    { keywords: ["local llm", "ollama", "llama", "local model"], skill: "antigravity--local-llm-expert", agent: "performance-engineer", confidence: 0.65 },
+    { keywords: ["agent", "mcp", "model context protocol"], skill: "antigravity--agent-memory-mcp", agent: "architect", confidence: 0.65 },
+    { keywords: ["agent evaluation", "agent testing"], skill: "antigravity--agent-evaluation", agent: "testing-lead", confidence: 0.65 },
+    { keywords: ["ai agent", "autonomous agent"], skill: "antigravity--ai-agent-development", agent: "backend-engineer", confidence: 0.65 },
+    // Content/Marketing (antigravity)
+    { keywords: ["marketing content", "ad creative", "campaign"], skill: "antigravity--marketing-ideas", agent: "content-creator", confidence: 0.6 },
+    { keywords: ["conversion", "cro", "optimization"], skill: "antigravity--onboarding-cro", agent: "growth-strategist", confidence: 0.6 },
+    // Documentation & Code Quality (antigravity)
+    { keywords: ["code documentation", "code explain", "explain code"], skill: "antigravity--code-documentation-code-explain", agent: "tech-writer", confidence: 0.65 },
+    { keywords: ["code refactoring", "clean code"], skill: "antigravity--code-refactoring-refactor-clean", agent: "refactorer", confidence: 0.65 },
+    { keywords: ["code review checklist"], skill: "antigravity--code-review-checklist", agent: "code-reviewer", confidence: 0.7 },
+    // Microservices & Architecture (antigravity)
+    { keywords: ["microservices", "service mesh", "distributed systems"], skill: "antigravity--microservices-patterns", agent: "architect", confidence: 0.65 },
+    { keywords: ["architecture decision", "adr", "decision records"], skill: "antigravity--architecture-decision-records", agent: "architect", confidence: 0.65 },
+    // Context/Memory Management (antigravity)
+    { keywords: ["context management", "context compression", "token optimization"], skill: "antigravity--context-compression", agent: "performance-engineer", confidence: 0.65 },
+    { keywords: ["context guardian", "memory safety"], skill: "antigravity--context-guardian", agent: "performance-engineer", confidence: 0.6 },
+    { keywords: ["context fundamentals"], skill: "antigravity--context-fundamentals", agent: "performance-engineer", confidence: 0.6 },
+    // Specialized Skills
+    { keywords: ["interview", "technical interview", "coding interview"], skill: "antigravity--interview-coach", agent: "growth-strategist", confidence: 0.6 },
+    { keywords: ["i18n", "localization", "translation"], skill: "antigravity--i18n-localization", agent: "frontend-engineer", confidence: 0.6 },
+    { keywords: ["accessibility", "a11y", "wcag"], skill: "antigravity--accessibility-compliance-accessibility-audit", agent: "frontend-ui-ux-engineer", confidence: 0.7 },
+    { keywords: ["pwa", "progressive web app"], skill: "antigravity--progressive-web-app", agent: "frontend-engineer", confidence: 0.6 },
+    { keywords: ["data migration", "sql migration"], skill: "antigravity--database-migrations-sql-migrations", agent: "database-engineer", confidence: 0.65 },
+    // Requesting Code Review (superpowers)
+    { keywords: ["request code review", "pr review", "pull request"], skill: "superpowers--requesting-code-review", agent: "code-reviewer", confidence: 0.7 },
+];
 export function getTaskRoutingRecommendation(taskDescription) {
     const desc = taskDescription.toLowerCase();
     for (const mapping of ROUTING_MAPPINGS) {
@@ -203,7 +325,7 @@ async function executeReleaseWorkflow(operation, context, jobId, routing) {
 async function delegateToAgent(agentName, operation, context, jobId) {
     try {
         // Create a minimal state manager and config loader for the delegator
-        const stateManager = new XrayStateManager();
+        const stateManager = new StringRayStateManager();
         // Create the delegator
         const delegator = new AgentDelegator(stateManager, strRayConfigLoader);
         // Build task description for the delegated agent
@@ -785,4 +907,3 @@ export const enforcerTools = {
     getEnforcementStatus,
     runPreCommitValidation,
 };
-//# sourceMappingURL=enforcer-tools.js.map

package/dist/enforcement/index.js

@@ -39,4 +39,3 @@ CodexLoader, AgentTriageLoader, ProcessorLoader, AgentsMdValidationLoader,
 LoaderOrchestrator, } from "./loaders/index.js";
 // Enforcer tools (if any exports exist)
 export * as enforcerTools from "./enforcer-tools.js";
-//# sourceMappingURL=index.js.map

package/dist/enforcement/loaders/agent-triage-loader.js

@@ -220,4 +220,3 @@ export class AgentTriageLoader extends BaseLoader {
         };
     }
 }
-//# sourceMappingURL=agent-triage-loader.js.map

package/dist/enforcement/loaders/agents-md-validation-loader.js

@@ -130,7 +130,7 @@ export class AgentsMdValidationLoader extends BaseLoader {
                     passed: false,
                     message: "AGENTS.md not found in project root",
                     suggestions: [
-                        "Create AGENTS.md using template from xray/agents_template.md",
+                        "Create AGENTS.md using template from docs/AGENTS_TEMPLATE.md",
                         "Run: node scripts/node/enforce-agents-md.js --generate",
                         "See AGENTS.md for agent triage rules and codex compliance",
                     ],
@@ -233,7 +233,7 @@ export class AgentsMdValidationLoader extends BaseLoader {
                     message: `AGENTS.md missing required sections: ${missingSections.join(", ")}`,
                     suggestions: [
                         "Add missing sections to AGENTS.md",
-                        "Reference xray/agents_template.md for structure",
+                        "Reference docs/AGENTS_TEMPLATE.md for structure",
                     ],
                 };
             }
@@ -250,4 +250,3 @@ export class AgentsMdValidationLoader extends BaseLoader {
         }
     }
 }
-//# sourceMappingURL=agents-md-validation-loader.js.map

package/dist/enforcement/loaders/base-loader.js

@@ -84,4 +84,3 @@ export class BaseLoader {
         return fs.promises.stat(filePath);
     }
 }
-//# sourceMappingURL=base-loader.js.map

package/dist/enforcement/loaders/codex-loader.js

@@ -30,13 +30,13 @@ export class CodexLoader extends BaseLoader {
     name = "codex";
     /**
      * Path to the codex.json file.
-      * Uses the standard config-paths resolver which checks .xray/, .opencode/xray/, etc.
+     * Uses the standard config-paths resolver which checks .strray/, .opencode/strray/, etc.
      */
     get codexPath() {
         const candidates = resolveCodexPath();
         const found = candidates.find((p) => existsSync(p));
         // Fallback to primary path even if not found yet
-        return found ?? candidates[0] ?? this.resolvePath("xray/codex.json");
+        return found ?? candidates[0] ?? this.resolvePath(".opencode/strray/codex.json");
     }
     /**
      * Check if codex.json exists.
@@ -394,4 +394,3 @@ export class CodexLoader extends BaseLoader {
         };
     }
 }
-//# sourceMappingURL=codex-loader.js.map