strray-ai 1.22.44 → 1.22.45

package/.opencode/plugin/strray-codex-injection.js

@@ -1,21 +1,30 @@
 /**
- * StrRay Codex Injection Plugin for OpenCode
+ * 0xRay Codex Injection Plugin for OpenCode
  *
  * This plugin automatically injects the Universal Development Codex v1.2.0
  * into the system prompt for all AI agents, ensuring codex terms are
  * consistently enforced across the entire development session.
  *
  * @version 1.0.0
- * @author StrRay Framework
+ * @author 0xRay Framework
  */
 import * as fs from "fs";
 import * as path from "path";
 import { spawn } from "child_process";
-// Dynamic imports for config-paths and framework-logger
-// Uses candidate-based resolution to work from both dist/plugin/ and .opencode/plugin/
-let _resolveCodexPath;
-let _resolveStateDir;
-let _frameworkLogger;
+// ---------------------------------------------------------------------------
+// Dynamic module holders (loaded via candidate-based resolution)
+// ---------------------------------------------------------------------------
+let _resolveCodexPath = null;
+let _resolveStateDir = null;
+let _frameworkLogger = null;
+let _systemPromptGenerator = null;
+let _ProcessorManager = null;
+let _StrRayStateManager = null;
+let _featuresConfigLoader = null;
+let _detectTaskType = null;
+// ---------------------------------------------------------------------------
+// Module loaders (candidate-based resolution for dev, dist, and consumer paths)
+// ---------------------------------------------------------------------------
 async function loadFrameworkLogger() {
     if (_frameworkLogger)
         return _frameworkLogger;
@@ -34,7 +43,6 @@ async function loadFrameworkLogger() {
             // try next candidate
         }
     }
-    // Fallback: no-op logger so plugin doesn't crash
     _frameworkLogger = {
         log: (_module, _event, _status, _data) => { },
     };
@@ -62,63 +70,59 @@ async function loadConfigPaths() {
     const logger = await loadFrameworkLogger();
     logger.log("strray-codex-plugin", "config-paths-load-failed", "warning", { warning: "Failed to load config-paths module from any location" });
 }
-/** Convenience wrapper — must be awaited before use */
-async function resolveCodexPath(...args) {
+async function resolveCodexPath(root) {
     await loadConfigPaths();
-    return _resolveCodexPath(...args);
+    if (!_resolveCodexPath)
+        throw new Error("resolveCodexPath not available after loading");
+    return _resolveCodexPath(root);
 }
-async function resolveStateDir(...args) {
+async function resolveStateDir(root) {
     await loadConfigPaths();
-    return _resolveStateDir(...args);
+    if (!_resolveStateDir)
+        throw new Error("resolveStateDir not available after loading");
+    return _resolveStateDir(root);
 }
-// Import lean system prompt generator
-let SystemPromptGenerator;
 async function importSystemPromptGenerator() {
-    if (!SystemPromptGenerator) {
-        const candidates = [
-            "../core/system-prompt-generator.js",
-            "../../dist/core/system-prompt-generator.js",
-            "../../node_modules/strray-ai/dist/core/system-prompt-generator.js",
-        ];
-        for (const p of candidates) {
-            try {
-                const module = await import(p);
-                SystemPromptGenerator = module.generateLeanSystemPrompt;
-                return;
-            }
-            catch (_) {
-                // try next candidate
-            }
+    if (_systemPromptGenerator)
+        return;
+    const candidates = [
+        "../core/system-prompt-generator.js",
+        "../../dist/core/system-prompt-generator.js",
+        "../../node_modules/strray-ai/dist/core/system-prompt-generator.js",
+    ];
+    for (const p of candidates) {
+        try {
+            const module = await import(p);
+            _systemPromptGenerator = module.generateLeanSystemPrompt;
+            return;
+        }
+        catch (_) {
+            // try next candidate
         }
-        const logger = await loadFrameworkLogger();
-        logger.log("strray-codex-plugin", "system-prompt-generator-load-failed", "warning", { warning: "Failed to load lean system prompt generator, using fallback" });
     }
+    const logger = await loadFrameworkLogger();
+    logger.log("strray-codex-plugin", "system-prompt-generator-load-failed", "warning", { warning: "Failed to load lean system prompt generator, using fallback" });
 }
-let ProcessorManager;
-let StrRayStateManager;
-let featuresConfigLoader;
-let detectTaskType;
-async function loadStrRayComponents() {
-    if (ProcessorManager && StrRayStateManager && featuresConfigLoader)
+async function loadStringRayComponents() {
+    if (_ProcessorManager && _StrRayStateManager && _featuresConfigLoader)
         return;
     const logger = await getOrCreateLogger(process.cwd());
-    // Try local dist first (for development)
     try {
         logger.log(`🔄 Attempting to load from ../../dist/`);
         const procModule = await import("../../dist/processors/processor-manager.js");
         const stateModule = await import("../../dist/state/state-manager.js");
         const featuresModule = await import("../../dist/core/features-config.js");
-        ProcessorManager = procModule.ProcessorManager;
-        StrRayStateManager = stateModule.StrRayStateManager;
-        featuresConfigLoader = featuresModule.featuresConfigLoader;
-        detectTaskType = featuresModule.detectTaskType;
+        _ProcessorManager = procModule.ProcessorManager;
+        _StrRayStateManager = stateModule.StrRayStateManager;
+        _featuresConfigLoader = featuresModule.featuresConfigLoader;
+        _detectTaskType = featuresModule.detectTaskType;
         logger.log(`✅ Loaded from ../../dist/`);
         return;
     }
     catch (e) {
-        logger.error(`❌ Failed to load from ../../dist/: ${e?.message || e}`);
+        const message = e instanceof Error ? e.message : String(e);
+        logger.log(`❌ Failed to load from ../../dist/: ${message}`);
     }
-    // Try node_modules (for consumer installation)
     const pluginPaths = ["strray-ai", "strray-framework"];
     for (const pluginPath of pluginPaths) {
         try {
@@ -126,28 +130,29 @@ async function loadStrRayComponents() {
             const pm = await import(`../../node_modules/${pluginPath}/dist/processors/processor-manager.js`);
             const sm = await import(`../../node_modules/${pluginPath}/dist/state/state-manager.js`);
             const fm = await import(`../../node_modules/${pluginPath}/dist/core/features-config.js`);
-            ProcessorManager = pm.ProcessorManager;
-            StrRayStateManager = sm.StrRayStateManager;
-            featuresConfigLoader = fm.featuresConfigLoader;
-            detectTaskType = fm.detectTaskType;
+            _ProcessorManager = pm.ProcessorManager;
+            _StrRayStateManager = sm.StrRayStateManager;
+            _featuresConfigLoader = fm.featuresConfigLoader;
+            _detectTaskType = fm.detectTaskType;
             logger.log(`✅ Loaded from ../../node_modules/${pluginPath}/dist/`);
             return;
         }
         catch (e) {
-            logger.error(`❌ Failed to load from ../../node_modules/${pluginPath}/dist/: ${e?.message || e}`);
-            continue;
+            const message = e instanceof Error ? e.message : String(e);
+            logger.log(`❌ Failed to load from ../../node_modules/${pluginPath}/dist/: ${message}`);
         }
     }
 }
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
 function spawnPromise(command, args, cwd) {
     return new Promise((resolve, reject) => {
         const child = spawn(command, args, {
             cwd,
-            stdio: ["ignore", "inherit", "pipe"], // Original working stdio - stdout to terminal (ASCII visible)
+            stdio: ["ignore", "inherit", "pipe"],
         });
-        let stdout = "";
         let stderr = "";
-        // Capture stderr only (stdout goes to inherit/terminal)
         if (child.stderr) {
             child.stderr.on("data", (data) => {
                 stderr += data.toString();
@@ -155,7 +160,7 @@ function spawnPromise(command, args, cwd) {
         }
         child.on("close", (code) => {
             if (code === 0) {
-                resolve({ stdout, stderr });
+                resolve({ stdout: "", stderr });
             }
             else {
                 reject(new Error(`Process exited with code ${code}: ${stderr}`));
@@ -182,7 +187,7 @@ class PluginLogger {
             const logEntry = `[${timestamp}] ${message}\n`;
             await fs.promises.appendFile(this.logPath, logEntry, "utf-8");
         }
-        catch (error) {
+        catch {
             // Silent fail - logging failure should not break plugin
         }
     }
@@ -210,9 +215,6 @@ async function getOrCreateLogger(directory) {
     })();
     return loggerInitPromise;
 }
-/**
- * Get the current framework version from package.json
- */
 function getFrameworkVersion() {
     try {
         const packageJsonPath = path.join(process.cwd(), "package.json");
@@ -223,12 +225,9 @@ function getFrameworkVersion() {
         return "1.4.6";
     }
 }
-/**
- * Get lean framework identity message (token-efficient version)
- */
 function getFrameworkIdentity() {
     const version = getFrameworkVersion();
-    return `StringRay Framework v${version} - AI Orchestration
+    return `0xRay Framework v${version} - AI Orchestration
 
 🔧 Core: enforcer, architect, orchestrator, code-reviewer, refactorer, testing-lead
 📚 Codex: 5 Essential Terms (99.6% Error Prevention Target)
@@ -237,18 +236,15 @@ function getFrameworkIdentity() {
 📖 Documentation: config dir (codex, config, agents docs) — resolved via config-paths
 `;
 }
-/**
- * Run Enforcer quality gate check before operations
- * Now delegates to RuleEnforcer for proper rule enforcement
- */
+// ---------------------------------------------------------------------------
+// Enforcer quality gate
+// ---------------------------------------------------------------------------
 async function runEnforcerQualityGate(input, logger) {
     const violations = [];
     const { tool, args } = input;
     try {
-        // Lazy load RuleEnforcer to avoid circular dependencies
         const { RuleEnforcer } = await import("../enforcement/rule-enforcer.js");
         const ruleEnforcer = new RuleEnforcer();
-        // Build validation context from the input
         const context = {
             operation: tool === "write" ? "write" : tool === "edit" ? "edit" : "read",
         };
@@ -258,25 +254,20 @@ async function runEnforcerQualityGate(input, logger) {
         if (args?.content) {
             context.newCode = args.content;
         }
-        // Use RuleEnforcer.validateOperation() instead of hardcoded rules
         const report = await ruleEnforcer.validateOperation(tool, context);
-        // Collect blocking violations from errors and failed results
         const blockingViolations = [];
         const allViolations = [];
-        // Check errors (these are blocking by nature)
         if (report.errors && report.errors.length > 0) {
             for (const error of report.errors) {
                 allViolations.push(error);
-                blockingViolations.push(error); // All errors are blocking
+                blockingViolations.push(error);
             }
         }
-        // Check failed results - only block on error severity, not warnings
         if (report.results) {
             for (const result of report.results) {
                 if (!result.passed) {
                     const isBlocking = result.severity === "error" || result.severity === "blocking" || result.severity === "high";
                     allViolations.push(result.message);
-                    // Only block on error/blocking/high severity, allow warnings
                     if (isBlocking) {
                         blockingViolations.push(result.message);
                     }
@@ -303,9 +294,7 @@ async function runEnforcerQualityGate(input, logger) {
         return { passed, violations };
     }
     catch (error) {
-        // If RuleEnforcer fails to load or run, fall back to minimal checks
         logger.log(`Warning: RuleEnforcer unavailable, using fallback checks: ${error instanceof Error ? error.message : String(error)}`);
-        // Fallback: minimal hardcoded checks (the old logic, as safety net)
         if (tool === "write" && args?.filePath) {
             const filePath = args.filePath;
             if (filePath.endsWith(".ts") &&
@@ -337,24 +326,13 @@ async function runEnforcerQualityGate(input, logger) {
         return { passed, violations };
     }
 }
-/**
- * Global codex context cache (loaded once)
- */
 let cachedCodexContexts = null;
-/**
- * Codex file locations resolved through the standard priority chain.
- * Falls back to additional OpenCode-specific files not covered by the resolver.
- */
 async function getCodexFileLocations(directory) {
     const root = directory || process.cwd();
     const resolved = await resolveCodexPath(root);
-    // Add OpenCode-specific fallbacks not in the standard chain
     resolved.push(path.join(root, ".opencode", "codex.codex"), path.join(root, ".strray", "agents_template.md"), path.join(root, ".opencode", "strray", "agents_template.md"), path.join(root, "AGENTS.md"));
     return resolved;
 }
-/**
- * Read file content safely
- */
 function readFileContent(filePath) {
     try {
         return fs.readFileSync(filePath, "utf-8");
@@ -365,11 +343,7 @@ function readFileContent(filePath) {
         return null;
     }
 }
-/**
- * Extract codex metadata from content
- */
 function extractCodexMetadata(content) {
-    // Try JSON format first (codex.json)
     if (content.trim().startsWith("{")) {
         try {
             const parsed = JSON.parse(content);
@@ -382,16 +356,12 @@ function extractCodexMetadata(content) {
             // Not valid JSON, try markdown format
         }
     }
-    // Markdown format (AGENTS.md, agents_template.md via config-paths resolver)
     const versionMatch = content.match(/\*\*Version\*\*:\s*(\d+\.\d+\.\d+)/);
-    const version = versionMatch && versionMatch[1] ? versionMatch[1] : "1.6.0";
+    const version = versionMatch?.[1] ?? "1.6.0";
     const termMatches = content.match(/####\s*\d+\.\s/g);
     const termCount = termMatches ? termMatches.length : 0;
     return { version, termCount };
 }
-/**
- * Create codex context entry
- */
 function createCodexContextEntry(filePath, content) {
     const metadata = extractCodexMetadata(content);
     return {
@@ -406,9 +376,6 @@ function createCodexContextEntry(filePath, content) {
         },
     };
 }
-/**
- * Load codex context (cached globally, loaded once)
- */
 async function loadCodexContext(directory) {
     if (cachedCodexContexts) {
         return cachedCodexContexts;
@@ -431,34 +398,22 @@ async function loadCodexContext(directory) {
     }
     return codexContexts;
 }
-/**
- * Format codex context for injection
- */
 function formatCodexContext(contexts) {
     if (contexts.length === 0) {
         return "";
     }
     const parts = [];
     for (const context of contexts) {
-        parts.push(`# StrRay Codex Context v${context.metadata.version}`, `Source: ${context.source}`, `Terms Loaded: ${context.metadata.termCount}`, `Loaded At: ${context.metadata.loadedAt}`, "", context.content, "", "---", "");
+        parts.push(`# 0xRay Codex Context v${context.metadata.version}`, `Source: ${context.source}`, `Terms Loaded: ${context.metadata.termCount}`, `Loaded At: ${context.metadata.loadedAt}`, "", context.content, "", "---", "");
     }
     return parts.join("\n");
 }
-/**
- * Main plugin function
- *
- * This plugin hooks into experimental.chat.system.transform event
- * to inject codex terms into system prompt before it's sent to LLM.
- */
-/** Inference tuning: run every N tool calls */
+// ---------------------------------------------------------------------------
+// Analytics and task classification
+// ---------------------------------------------------------------------------
 const INFERENCE_TUNE_INTERVAL = 100;
 let _openCodeToolCallCount = 0;
 let _lastTuneToolCallCount = 0;
-/**
- * Map tool names to agent/skill identifiers for outcome tracking.
- * This lets the analytics pipeline correlate tool usage patterns
- * with agent routing effectiveness.
- */
 const TOOL_AGENT_MAP = {
     write: { agent: "code-reviewer", skill: "write" },
     edit: { agent: "code-reviewer", skill: "edit" },
@@ -470,11 +425,6 @@ const TOOL_AGENT_MAP = {
     grep: { agent: "researcher", skill: "search" },
     ls: { agent: "researcher", skill: "list" },
 };
-/**
- * Classify a tool call into a meaningful task type for analytics.
- * Mirrors _classify_task_type in the Hermes plugin so both plugins
- * produce comparable outcome data for the inference tuner.
- */
 function classifyTaskType(tool, args) {
     const cmd = String(args?.command ?? "").toLowerCase().trim();
     if (tool === "bash" && cmd) {
@@ -503,36 +453,104 @@ function classifyTaskType(tool, args) {
         return "search";
     return "unknown";
 }
+// ---------------------------------------------------------------------------
+// Shared helpers extracted from duplicated plugin logic
+// ---------------------------------------------------------------------------
+function isWriteEditOperation(tool) {
+    return tool === "write" || tool === "edit" || tool === "multiedit";
+}
+function isPublishOperation(tool) {
+    return tool === "publish" || tool === "release" || tool === "npm-publish" || tool === "strray-release";
+}
+function resolveAgentName(input) {
+    const globalAgent = globalThis.currentAgent;
+    if (globalAgent?.agentType)
+        return globalAgent.agentType;
+    if (globalAgent?.type)
+        return globalAgent.type;
+    if (input?.agentType)
+        return input.agentType;
+    return "orchestrator";
+}
+function registerAllProcessors(pm) {
+    pm.registerProcessor({ name: "preValidate", type: "pre", priority: 10, enabled: true });
+    pm.registerProcessor({ name: "codexCompliance", type: "pre", priority: 20, enabled: true });
+    pm.registerProcessor({ name: "versionCompliance", type: "pre", priority: 25, enabled: true });
+    pm.registerProcessor({ name: "testAutoCreation", type: "post", priority: 5, enabled: true });
+    pm.registerProcessor({ name: "testExecution", type: "post", priority: 10, enabled: true });
+    pm.registerProcessor({ name: "coverageAnalysis", type: "post", priority: 20, enabled: true });
+}
+function registerAfterPostProcessors(pm) {
+    pm.registerProcessor({ name: "testAutoCreation", type: "post", priority: 50, enabled: true });
+    pm.registerProcessor({ name: "testExecution", type: "post", priority: 10, enabled: true });
+    pm.registerProcessor({ name: "coverageAnalysis", type: "post", priority: 20, enabled: true });
+}
+function logPreProcessorResults(results, logger) {
+    logger.log(`📊 Pre-processor result: ${results.success ? "SUCCESS" : "FAILED"} (${results.results.length} processors)`);
+    if (!results.success) {
+        const failures = results.results.filter((r) => !r.success);
+        for (const f of failures) {
+            logger.error(`❌ Pre-processor ${f.processorName} failed: ${f.error}`);
+        }
+    }
+    else {
+        for (const r of results.results) {
+            logger.log(`✅ Pre-processor ${r.processorName}: ${r.success ? "OK" : "FAILED"}`);
+        }
+    }
+}
+function logPostProcessorResults(results, logger) {
+    const allSuccess = results.every((r) => r.success);
+    logger.log(`📊 Post-processor result: ${allSuccess ? "SUCCESS" : "FAILED"} (${results.length} processors)`);
+    for (const r of results) {
+        if (r.success) {
+            logger.log(`✅ Post-processor ${r.processorName}: OK`);
+        }
+        else {
+            logger.error(`❌ Post-processor ${r.processorName} failed: ${r.error}`);
+        }
+    }
+}
+function logTestAutoCreationResult(results, logger) {
+    const testAutoResult = results.find((r) => r.processorName === "testAutoCreation");
+    if (testAutoResult) {
+        const data = testAutoResult.data;
+        if (testAutoResult.success && data?.testCreated && data?.testFile) {
+            logger.log(`✅ TEST AUTO-CREATION: Created ${data.testFile}`);
+        }
+        else if (!testAutoResult.success) {
+            logger.log(`ℹ️ TEST AUTO-CREATION: ${testAutoResult.error ?? "skipped - no new files"}`);
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Main plugin function
+// ---------------------------------------------------------------------------
 export default async function strrayCodexPlugin(input) {
     const { directory: inputDirectory } = input;
     const directory = inputDirectory || process.cwd();
     return {
         "experimental.chat.system.transform": async (_input, output) => {
             try {
-                // Use lean system prompt generator for token efficiency
                 await importSystemPromptGenerator();
                 let leanPrompt = getFrameworkIdentity();
-                // Use lean generator if available, otherwise fall back to minimal logic
-                if (SystemPromptGenerator) {
-                    leanPrompt = await SystemPromptGenerator({
+                if (_systemPromptGenerator) {
+                    leanPrompt = await _systemPromptGenerator({
                         showWelcomeBanner: true,
-                        showCodexContext: false, // Disabled for token efficiency
+                        showCodexContext: false,
                         enableTokenOptimization: true,
-                        maxTokenBudget: 3000, // Conservative token budget
+                        maxTokenBudget: 8192,
                         showCriticalTermsOnly: true,
-                        showEssentialLinks: true
+                        showEssentialLinks: true,
                     });
                 }
                 if (output.system && Array.isArray(output.system)) {
-                    // Replace verbose system prompt with lean version
                     output.system = [leanPrompt];
                 }
             }
             catch (error) {
-                // Critical failure - log error but don't break the plugin
                 const logger = await getOrCreateLogger(directory);
                 logger.error("System prompt injection failed:", error);
-                // Fallback to minimal prompt
                 const fallback = getFrameworkIdentity();
                 if (output.system && Array.isArray(output.system)) {
                     output.system = [fallback];
@@ -543,13 +561,15 @@ export default async function strrayCodexPlugin(input) {
             const logger = await getOrCreateLogger(directory);
             logger.log(`🚀 TOOL EXECUTE BEFORE HOOK FIRED: ${input.tool}`);
             logger.log(`📥 Full input: ${JSON.stringify(input)}`);
-            await loadStrRayComponents();
-            if (featuresConfigLoader && detectTaskType) {
+            await loadStringRayComponents();
+            if (_featuresConfigLoader && _detectTaskType) {
                 try {
-                    const config = featuresConfigLoader.loadConfig();
+                    const config = _featuresConfigLoader.loadConfig();
                     if (config.model_routing?.enabled) {
-                        const taskType = detectTaskType(input.tool);
-                        const routing = config.model_routing.task_routing?.[taskType];
+                        const taskType = _detectTaskType(input.tool);
+                        const routing = taskType !== "unknown"
+                            ? config.model_routing.task_routing?.[taskType]
+                            : undefined;
                         if (routing?.model) {
                             output.model = routing.model;
                             logger.log(`Model routed: ${input.tool} → ${taskType} → ${routing.model}`);
@@ -561,122 +581,61 @@ export default async function strrayCodexPlugin(input) {
                 }
             }
             const { tool, args } = input;
-            // ENFORCER QUALITY GATE CHECK - Block on violations
             const qualityGateResult = await runEnforcerQualityGate(input, logger);
             if (!qualityGateResult.passed) {
                 logger.error(`🚫 Quality gate failed: ${qualityGateResult.violations.join(", ")}`);
                 throw new Error(`ENFORCER BLOCKED: ${qualityGateResult.violations.join("; ")}`);
             }
             logger.log(`✅ Quality gate passed for ${tool}`);
-            if (["write", "edit", "multiedit"].includes(tool)) {
-                if (!ProcessorManager || !StrRayStateManager) {
+            if (isWriteEditOperation(tool)) {
+                if (!_ProcessorManager || !_StrRayStateManager) {
                     logger.error("ProcessorManager or StrRayStateManager not loaded");
                     return;
                 }
-                // PHASE 1: Connect to booted framework or boot if needed
                 let stateManager;
                 let processorManager;
-                // Check if framework is already booted (global state exists)
                 const globalState = globalThis.strRayStateManager;
                 if (globalState) {
-                    logger.log("🔗 Connecting to booted StrRay framework");
+                    logger.log("🔗 Connecting to booted 0xRay framework");
                     stateManager = globalState;
                 }
                 else {
-                    logger.log("🚀 StrRay framework not booted, initializing...");
-                    // Create new state manager (framework not booted yet)
-                    stateManager = new StrRayStateManager(await resolveStateDir(directory));
-                    // Store globally for future use
+                    logger.log("🚀 0xRay framework not booted, initializing...");
+                    stateManager = new _StrRayStateManager(await resolveStateDir(directory));
                     globalThis.strRayStateManager = stateManager;
                 }
-                // Get processor manager from state
-                processorManager = stateManager.get("processor:manager");
+                processorManager = stateManager.get("processor:manager") ?? null;
                 if (!processorManager) {
                     logger.log("⚙️ Creating and registering processors...");
-                    processorManager = new ProcessorManager(stateManager);
-                    // Register the same processors as boot-orchestrator
-                    processorManager.registerProcessor({
-                        name: "preValidate",
-                        type: "pre",
-                        priority: 10,
-                        enabled: true,
-                    });
-                    processorManager.registerProcessor({
-                        name: "codexCompliance",
-                        type: "pre",
-                        priority: 20,
-                        enabled: true,
-                    });
-                    processorManager.registerProcessor({
-                        name: "versionCompliance",
-                        type: "pre",
-                        priority: 25,
-                        enabled: true,
-                    });
-                    processorManager.registerProcessor({
-                        name: "testAutoCreation",
-                        type: "post",
-                        priority: 5, // FIX: Run BEFORE testExecution so tests exist when we run them
-                        enabled: true,
-                    });
-                    processorManager.registerProcessor({
-                        name: "testExecution",
-                        type: "post",
-                        priority: 10,
-                        enabled: true,
-                    });
-                    processorManager.registerProcessor({
-                        name: "coverageAnalysis",
-                        type: "post",
-                        priority: 20,
-                        enabled: true,
-                    });
-                    // Store for future use
+                    processorManager = new _ProcessorManager(stateManager);
+                    registerAllProcessors(processorManager);
                     stateManager.set("processor:manager", processorManager);
                     logger.log("✅ Processors registered successfully");
                 }
                 else {
                     logger.log("✅ Using existing processor manager");
                 }
-                // PHASE 2: Execute pre-processors with detailed logging
                 try {
                     logger.log(`▶️ Executing pre-processors for ${tool}...`);
-                    const result = await processorManager.executePreProcessors({
+                    const preProcessorInput = {
                         tool,
-                        args,
+                        args: args,
                         context: {
                             directory,
                             operation: "tool_execution",
                             filePath: args?.filePath,
                         },
-                    });
-                    logger.log(`📊 Pre-processor result: ${result.success ? "SUCCESS" : "FAILED"} (${result.results?.length || 0} processors)`);
-                    if (!result.success) {
-                        const failures = result.results?.filter((r) => !r.success) || [];
-                        failures.forEach((f) => {
-                            logger.error(`❌ Pre-processor ${f.processorName} failed: ${f.error}`);
-                        });
-                    }
-                    else {
-                        result.results?.forEach((r) => {
-                            logger.log(`✅ Pre-processor ${r.processorName}: ${r.success ? "OK" : "FAILED"}`);
-                        });
-                    }
+                    };
+                    const result = await processorManager.executePreProcessors(preProcessorInput);
+                    logPreProcessorResults(result, logger);
                 }
                 catch (error) {
                     logger.error(`💥 Pre-processor execution error`, error);
                 }
-                // PHASE 3: Execute post-processors after tool completion
                 try {
                     logger.log(`▶️ Executing post-processors for ${tool}...`);
                     logger.log(`📝 Post-processor args: ${JSON.stringify(args)}`);
-                    // Determine operation type and enrich context with metadata for processors
-                    const isPublishOperation = tool === "publish" || tool === "release" || tool === "npm-publish" || tool === "strray-release";
-                    // Get agent info from session state if available
-                    const agentName = global.currentAgent?.agentType ||
-                        global.currentAgent?.type ||
-                        input.agentType ||
-                        "orchestrator";
+                    const agentName = resolveAgentName(input);
                     const postProcessorContext = {
                         directory,
                         operation: tool,
@@ -684,7 +643,7 @@ export default async function strrayCodexPlugin(input) {
                         success: true,
                         agentName,
                         metadata: {
-                            isPublishing: isPublishOperation,
+                            isPublishing: isPublishOperation(tool),
                             hook: "tool_execution",
                             toolName: tool,
                             timestamp: Date.now(),
@@ -692,32 +651,17 @@ export default async function strrayCodexPlugin(input) {
                         },
                     };
                     const postResults = await processorManager.executePostProcessors(tool, postProcessorContext, []);
-                    // postResults is an array of ProcessorResult
-                    const allSuccess = postResults.every((r) => r.success);
-                    logger.log(`📊 Post-processor result: ${allSuccess ? "SUCCESS" : "FAILED"} (${postResults.length} processors)`);
-                    // Log each post-processor result for debugging
-                    for (const r of postResults) {
-                        if (r.success) {
-                            logger.log(`✅ Post-processor ${r.processorName}: OK`);
-                        }
-                        else {
-                            logger.error(`❌ Post-processor ${r.processorName} failed: ${r.error}`);
-                        }
-                    }
+                    logPostProcessorResults(postResults, logger);
                 }
                 catch (error) {
                     logger.error(`💥 Post-processor execution error`, error);
                 }
             }
         },
-        // Execute POST-processors AFTER tool completes (this is the correct place!)
         "tool.execute.after": async (input, _output) => {
             const logger = await getOrCreateLogger(directory);
-            await loadStrRayComponents();
+            await loadStringRayComponents();
             const { tool, args, result } = input;
-            // Record routing outcome for analytics pipeline.
-            // This feeds the inference tuner with real tool usage data so it
-            // can refine keyword mappings and improve predictive analytics.
             try {
                 const { routingOutcomeTracker } = await import("../delegation/analytics/outcome-tracker.js");
                 const mapping = TOOL_AGENT_MAP[tool];
@@ -746,82 +690,37 @@ export default async function strrayCodexPlugin(input) {
             catch {
                 // Outcome tracker not available — skip silently
             }
-            // Debug: log full input
             logger.log(`📥 After hook input: ${JSON.stringify({ tool, hasArgs: !!args, args, hasResult: !!result }).slice(0, 200)}`);
-            // Run post-processors for write/edit operations AFTER tool completes
-            if (["write", "edit", "multiedit"].includes(tool)) {
-                if (!ProcessorManager || !StrRayStateManager)
+            if (isWriteEditOperation(tool)) {
+                if (!_ProcessorManager || !_StrRayStateManager)
                     return;
-                const stateManager = new StrRayStateManager(await resolveStateDir(directory));
-                const processorManager = new ProcessorManager(stateManager);
-                // Register post-processors
-                processorManager.registerProcessor({
-                    name: "testAutoCreation",
-                    type: "post",
-                    priority: 50,
-                    enabled: true,
-                });
-                processorManager.registerProcessor({
-                    name: "testExecution",
-                    type: "post",
-                    priority: 10,
-                    enabled: true,
-                });
-                processorManager.registerProcessor({
-                    name: "coverageAnalysis",
-                    type: "post",
-                    priority: 20,
-                    enabled: true,
-                });
+                const stateManager = new _StrRayStateManager(await resolveStateDir(directory));
+                const processorManager = new _ProcessorManager(stateManager);
+                registerAfterPostProcessors(processorManager);
                 try {
-                    // Execute post-processors AFTER tool - with actual filePath for testAutoCreation
                     logger.log(`📝 Post-processor tool: ${tool}`);
                     logger.log(`📝 Post-processor args: ${JSON.stringify(args)}`);
                     logger.log(`📝 Post-processor directory: ${directory}`);
-                    // Determine operation type and enrich context with metadata for processors
-                    const isPublishOperation = tool === "publish" || tool === "release" || tool === "npm-publish" || tool === "strray-release";
                     const postProcessorContext = {
                         directory,
                         operation: tool,
                         filePath: args?.filePath,
                         success: result?.success !== false,
                         metadata: {
-                            isPublishing: isPublishOperation,
+                            isPublishing: isPublishOperation(tool),
                             hook: "tool_execution",
                             toolName: tool,
                             timestamp: Date.now(),
                         },
                     };
                     const postResults = await processorManager.executePostProcessors(tool, postProcessorContext, []);
-                    // postResults is an array of ProcessorResult
-                    const allSuccess = postResults.every((r) => r.success);
-                    logger.log(`📊 Post-processor result: ${allSuccess ? "SUCCESS" : "FAILED"} (${postResults.length} processors)`);
-                    // Log each post-processor result for debugging
-                    for (const r of postResults) {
-                        if (r.success) {
-                            logger.log(`✅ Post-processor ${r.processorName}: OK`);
-                        }
-                        else {
-                            logger.error(`❌ Post-processor ${r.processorName} failed: ${r.error}`);
-                        }
-                    }
-                    // Log testAutoCreation results specifically
-                    const testAutoResult = postResults.find((r) => r.processorName === "testAutoCreation");
-                    if (testAutoResult) {
-                        if (testAutoResult.success && testAutoResult.testCreated) {
-                            logger.log(`✅ TEST AUTO-CREATION: Created ${testAutoResult.testFile}`);
-                        }
-                        else if (!testAutoResult.success) {
-                            logger.log(`ℹ️ TEST AUTO-CREATION: ${testAutoResult.message || "skipped - no new files"}`);
-                        }
-                    }
+                    logPostProcessorResults(postResults, logger);
+                    logTestAutoCreationResult(postResults, logger);
                 }
                 catch (error) {
                     logger.error(`💥 Post-processor error`, error);
                 }
             }
-            // Auto inference tuning: every INFERENCE_TUNE_INTERVAL tool calls,
-            // run a single tuning cycle to close the feedback loop.
             _openCodeToolCallCount++;
             if (_openCodeToolCallCount - _lastTuneToolCallCount >= INFERENCE_TUNE_INTERVAL) {
                 _lastTuneToolCallCount = _openCodeToolCallCount;
@@ -841,17 +740,71 @@ export default async function strrayCodexPlugin(input) {
                 }
             }
         },
+        "chat.message": async (input, output) => {
+            const logger = await getOrCreateLogger(directory);
+            if (!output.parts) {
+                return;
+            }
+            const textContent = input.parts?.find(p => p.type === "text")?.text ?? "";
+            if (!textContent) {
+                return;
+            }
+            const agentMentionRegex = /@(\w+)(?:\s+(.+?))?(?=$|\n\n|\r\r)/g;
+            let match;
+            let hasAgentMention = false;
+            let transformedText = textContent;
+            const knownAgents = {
+                "architect": "architect",
+                "strategist": "strategist",
+                "testing-lead": "testing-lead",
+                "bug-triage-specialist": "bug-triage-specialist",
+                "code-reviewer": "code-reviewer",
+                "security-auditor": "security-auditor",
+                "refactorer": "refactorer",
+                "researcher": "researcher",
+                "code-analyzer": "code-analyzer",
+                "frontend-engineer": "frontend-engineer",
+                "frontend-ui-ux-engineer": "frontend-ui-ux-engineer",
+                "backend-engineer": "backend-engineer",
+                "database-engineer": "database-engineer",
+                "devops-engineer": "devops-engineer",
+                "performance-engineer": "performance-engineer",
+                "mobile-developer": "mobile-developer",
+                "content-creator": "content-creator",
+                "growth-strategist": "growth-strategist",
+                "seo-consultant": "seo-consultant",
+                "tech-writer": "tech-writer",
+                "multimodal-looker": "multimodal-looker",
+                "log-monitor": "log-monitor",
+            };
+            while ((match = agentMentionRegex.exec(textContent)) !== null) {
+                const agentName = match[1].toLowerCase().replace(/-/g, "");
+                const taskPart = match[2]?.trim() ?? "";
+                if (knownAgents[agentName]) {
+                    hasAgentMention = true;
+                    const canonicalAgent = knownAgents[agentName];
+                    logger.log(`🎯 Agent mention detected: @${canonicalAgent}`);
+                    const prefix = `\n[DELEGATE TO AGENT: ${canonicalAgent}]\n`;
+                    transformedText = prefix + (taskPart || textContent.replace(`@${match[1]}`, "").trim());
+                    break;
+                }
+            }
+            if (hasAgentMention) {
+                const textPart = output.parts.find(p => p.type === "text");
+                if (textPart) {
+                    textPart.text = transformedText;
+                    logger.log(`✅ Transformed prompt for agent routing`);
+                }
+            }
+        },
         config: async (_config) => {
-            // Guard: only run init.sh once per startup session
-            // OpenCode may fire the config hook multiple times in fresh contexts
-            // where globalThis is reset, so we use a TTL lockfile
             const lockFile = path.join(directory, ".opencode", "logs", ".strray-init.lock");
             const now = Date.now();
             try {
                 if (fs.existsSync(lockFile)) {
                     const stat = fs.statSync(lockFile);
                     if (now - stat.mtimeMs < 15000) {
-                        return; // already ran within 15s window
+                        return;
                     }
                 }
                 fs.writeFileSync(lockFile, String(now));
@@ -860,10 +813,7 @@ export default async function strrayCodexPlugin(input) {
                 // lock check failed — proceed anyway
             }
             const logger = await getOrCreateLogger(directory);
-            logger.log("🔧 Plugin config hook triggered - initializing StrRay integration");
-            // Initialize StrRay framework
-            // Primary: project .opencode/init.sh (copied by postinstall)
-            // Fallback: package .opencode/init.sh (works when postinstall skips for Hermes consumers)
+            logger.log("🔧 Plugin config hook triggered - initializing 0xRay integration");
             let initScriptPath = path.join(directory, ".opencode", "init.sh");
             const pkgInitPath = path.join(directory, "node_modules", "strray-ai", ".opencode", "init.sh");
             if (!fs.existsSync(initScriptPath) && fs.existsSync(pkgInitPath)) {
@@ -876,7 +826,7 @@ export default async function strrayCodexPlugin(input) {
                         logger.error(`Framework init error: ${stderr}`);
                     }
                     else {
-                        logger.log("✅ StrRay Framework initialized successfully");
+                        logger.log("✅ 0xRay Framework initialized successfully");
                     }
                 }
                 catch (error) {