strray-ai 1.13.4 → 1.14.0

package/.opencode/AGENTS-consumer.md

@@ -108,12 +108,13 @@ StringRay uses **two reflection folders** for different purposes:
 
 The `@storyteller` agent supports multiple story types:
 
-| Type | Description | Invoke |
-|------|-------------|--------|
-| `reflection` | Technical deep reflections on development process | `@storyteller write a reflection about X` |
-| `saga` | Long-form technical saga spanning multiple sessions | `@storyteller write a saga about X` |
-| `journey` | Investigation/learning journey | `@storyteller write a journey about X` |
-| `narrative` | Technical narrative - telling the story of code | `@storyteller write a narrative about X` |
+| Type | Description | Template Path | Invoke |
+|------|-------------|---------------|--------|
+| `reflection` | Technical deep reflections on development process | `docs/reflections/TEMPLATE.md` | `@storyteller write a reflection about X` |
+| `saga` | Long-form technical saga spanning multiple sessions | `docs/reflections/deep/SAGA_TEMPLATE.md` | `@storyteller write a saga about X` |
+| `journey` | Investigation/learning journey | `docs/reflections/JOURNEY_TEMPLATE.md` | `@storyteller write a journey about X` |
+| `narrative` | Technical narrative - telling the story of code | `docs/reflections/NARRATIVE_TEMPLATE.md` | `@storyteller write a narrative about X` |
+| `deep reflection` | Extended narrative with emotional journey | `docs/reflections/deep/TEMPLATE.md` | `@storyteller write a deep reflection about X` |
 
 **Example:**
 ```
@@ -139,10 +140,10 @@ The `@storyteller` agent supports multiple story types:
 
 StringRay automatically routes tasks based on complexity:
 
-- **Simple (≤20)**: Single agent
-- **Moderate (21-35)**: Single agent with tools
-- **Complex (36-75)**: Multi-agent coordination  
-- **Enterprise (>75)**: Orchestrator-led team
+- **Simple (≤15)**: Single agent
+- **Moderate (≤25)**: Single agent with tools
+- **Complex (≤50)**: Multi-agent coordination  
+- **Enterprise (>50)**: Orchestrator-led team
 
 ## CLI Commands
 
@@ -155,6 +156,7 @@ npx strray-ai capabilities # Show all features
 npx strray-ai report        # Generate reports
 npx strray-ai analytics    # Pattern analytics
 npx strray-ai calibrate    # Calibrate complexity
+npm run test:pipelines     # Pipeline integration tests
 ```
 
 ## Features.json Configuration
@@ -649,4 +651,4 @@ npx strray-ai --version
 - [Troubleshooting](https://github.com/htafolla/stringray/blob/master/docs/TROUBLESHOOTING.md)
 
 ---
-**Version**: 1.7.8 | [GitHub](https://github.com/htafolla/stringray)
+**Version**: 1.14.0 | [GitHub](https://github.com/htafolla/stringray)

package/.opencode/codex.codex

@@ -1,5 +1,5 @@
 {
-  "version": "1.10.0",
+  "version": "1.14.0",
   "terms": [
     1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60
   ],

package/.opencode/enforcer-config.json

@@ -1,6 +1,6 @@
 {
   "framework": "StringRay 1.0.0",
-  "version": "1.10.0",
+  "version": "1.14.0",
   "description": "Codex-compliant framework configuration for Credible UI project",
   "thresholds": {
     "bundleSize": {
@@ -220,7 +220,7 @@
       }
     },
     "codex": {
-      "version": "1.10.0",
+      "version": "1.14.0",
       "terms": [
         1,
         2,

package/.opencode/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencode/OpenCode",
-  "version": "1.10.0",
+  "version": "1.14.0",
   "description": "OpenCode framework configuration",
   "main": "OpenCode.json",
   "scripts": {

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

@@ -146,6 +146,88 @@ function extractTaskDescription(input) {
     }
     return null;
 }
+/**
+ * Extract action words from command for better routing
+ * Maps verbs/intents to skill categories
+ */
+function extractActionWords(command) {
+    if (!command || command.length < 3)
+        return null;
+    // Strip quotes and escape sequences for cleaner matching
+    const cleanCommand = command.replace(/["']/g, ' ').replace(/\\./g, ' ');
+    // Action word -> skill mapping (ordered by priority)
+    const actionMap = [
+        // Review patterns - check first since user likely wants to review content
+        { pattern: /\b(review|check|audit|examine|inspect|assess|evaluate)\b/i, skill: "code-review" },
+        // Analyze patterns  
+        { pattern: /\b(analyze|investigate|study)\b/i, skill: "code-analyzer" },
+        // Fix patterns
+        { pattern: /\b(fix|debug|resolve|troubleshoot|repair)\b/i, skill: "bug-triage" },
+        // Create patterns
+        { pattern: /\b(create|write|generate|build|make|add)\b/i, skill: "content-creator" },
+        // Test patterns
+        { pattern: /\b(test|validate|verify)\b/i, skill: "testing" },
+        // Design patterns
+        { pattern: /\b(design|plan|architect)\b/i, skill: "architecture" },
+        // Optimize patterns
+        { pattern: /\b(optimize|improve|enhance|speed)\b/i, skill: "performance" },
+        // Security patterns
+        { pattern: /\b(scan|secure|vulnerability)\b/i, skill: "security" },
+        // Refactor patterns
+        { pattern: /\b(refactor|clean|restructure)\b/i, skill: "refactoring" },
+    ];
+    // Search for action words anywhere in the command
+    for (const { pattern } of actionMap) {
+        const match = cleanCommand.match(pattern);
+        if (match) {
+            // Return the matched word plus context after it
+            const word = match[0];
+            const idx = cleanCommand.toLowerCase().indexOf(word.toLowerCase());
+            const after = cleanCommand.slice(idx + word.length, Math.min(idx + word.length + 25, cleanCommand.length)).trim();
+            return `${word} ${after}`.trim().slice(0, 40);
+        }
+    }
+    // If no action word found, return null to use default routing
+    return null;
+}
+/**
+ * Estimate complexity score based on message content
+ * Higher complexity = orchestrator routing
+ * Lower complexity = code-reviewer routing
+ */
+function estimateComplexity(message) {
+    const text = message.toLowerCase();
+    // High complexity indicators
+    const highComplexityKeywords = [
+        "architecture", "system", "design", "complex", "multiple",
+        "integrate", "database", "migration", "refactor",
+        "performance", "optimize", "security", "audit",
+        "orchestrate", "coordinate", "workflow"
+    ];
+    // Low complexity indicators  
+    const lowComplexityKeywords = [
+        "review", "check", "simple", "quick", "fix",
+        "small", "typo", "format", "lint", "test"
+    ];
+    let score = 50; // default medium
+    // Check message length
+    if (message.length > 200)
+        score += 10;
+    if (message.length > 500)
+        score += 15;
+    // Check for high complexity keywords
+    for (const keyword of highComplexityKeywords) {
+        if (text.includes(keyword))
+            score += 8;
+    }
+    // Check for low complexity keywords
+    for (const keyword of lowComplexityKeywords) {
+        if (text.includes(keyword))
+            score -= 5;
+    }
+    // Clamp to 0-100
+    return Math.max(0, Math.min(100, score));
+}
 async function loadTaskSkillRouter() {
     if (taskSkillRouterInstance) {
         return; // Already loaded
@@ -402,34 +484,7 @@ export default async function strrayCodexPlugin(input) {
                         showEssentialLinks: true
                     });
                 }
-                // ============================================================
-                // PROMPT-LEVEL ROUTING: Route user prompts to best agent
-                // ============================================================
-                const userPrompt = String(_input.prompt || _input.message || _input.content || "");
-                if (userPrompt && userPrompt.length > 0) {
-                    try {
-                        await loadTaskSkillRouter();
-                        if (taskSkillRouterInstance) {
-                            const routingResult = taskSkillRouterInstance.routeTask(userPrompt, {
-                                source: "prompt",
-                            });
-                            if (routingResult && routingResult.agent) {
-                                const logger = await getOrCreateLogger(directory);
-                                logger.log(`🎯 Prompt routed: "${userPrompt.slice(0, 50)}${userPrompt.length > 50 ? "..." : ""}" → ${routingResult.agent} (confidence: ${routingResult.confidence})`);
-                                // Add routing context to system prompt
-                                leanPrompt += `\n\n🎯 Recommended Agent: @${routingResult.agent}\n`;
-                                leanPrompt += `📊 Confidence: ${Math.round(routingResult.confidence * 100)}%\n`;
-                                if (routingResult.context?.complexity > 50) {
-                                    leanPrompt += `⚠️ High complexity detected - consider using @orchestrator\n`;
-                                }
-                            }
-                        }
-                    }
-                    catch (e) {
-                        const logger = await getOrCreateLogger(directory);
-                        logger.error("Prompt routing error:", e);
-                    }
-                }
+                // Routing is handled in chat.message hook - this hook only does system prompt injection
                 if (output.system && Array.isArray(output.system)) {
                     output.system = [leanPrompt];
                 }
@@ -465,31 +520,43 @@ export default async function strrayCodexPlugin(input) {
                 }
             }
             const { tool, args } = input;
-            // ============================================================
-            // TASK ROUTING: Analyze task and route to best agent
-            // Enabled in v1.10.5 - provides analytics data
-            // ============================================================
-            const taskDescription = extractTaskDescription(input);
-            if (taskDescription && featuresConfigLoader) {
+            // Extract action words from command for better tool routing
+            const command = args?.command ? String(args.command) : "";
+            let taskDescription = null;
+            if (command) {
+                const actionWords = extractActionWords(command);
+                if (actionWords) {
+                    taskDescription = actionWords;
+                    logger.log(`📝 Action words extracted: "${actionWords}"`);
+                }
+            }
+            // Also try to extract from content if no command
+            if (!taskDescription) {
+                taskDescription = extractTaskDescription(input);
+            }
+            // Route tool commands based on extracted action words
+            if (taskDescription) {
                 try {
                     await loadTaskSkillRouter();
                     if (taskSkillRouterInstance) {
                         const routingResult = taskSkillRouterInstance.routeTask(taskDescription, {
-                            toolName: tool,
+                            source: "tool_command",
+                            complexity: estimateComplexity(taskDescription),
                         });
                         if (routingResult && routingResult.agent) {
-                            logger.log(`🎯 Task routed: "${taskDescription.slice(0, 50)}..." → ${routingResult.agent} (confidence: ${routingResult.confidence})`);
-                            // Store routing result for downstream processing
-                            output._strrayRouting = routingResult;
-                            // If complexity is high, log a warning
-                            if (routingResult.context?.complexity > 50) {
-                                logger.log(`⚠️ High complexity task detected (${routingResult.context.complexity}) - consider multi-agent orchestration`);
-                            }
+                            logger.log(`🎯 Tool routed: ${tool} → @${routingResult.agent} (${Math.round(routingResult.confidence * 100)}%)`);
+                            // Log routing for analytics
+                            logToolActivity(directory, "routing", tool, {
+                                taskDescription,
+                                agent: routingResult.agent,
+                                confidence: routingResult.confidence
+                            });
                         }
                     }
                 }
                 catch (e) {
-                    logger.error("Task routing error:", e);
+                    // Silent fail - routing should not break tool execution
+                    logger.log(`📝 Tool routing skipped: ${e}`);
                 }
             }
             // ENFORCER QUALITY GATE CHECK - Block on violations
@@ -715,46 +782,100 @@ export default async function strrayCodexPlugin(input) {
         },
         /**
          * chat.message - Intercept user messages for routing
-         * This hook fires when the user's message is received
+         * Output contains message and parts with user content
          */
         "chat.message": async (input, output) => {
             const logger = await getOrCreateLogger(directory);
-            // Get user message
-            const userContent = String(input.content || input.message || input.prompt || "");
-            if (!userContent || userContent.length === 0) {
+            // DEBUG: Log ALL output
+            const debugLogPath = path.join(process.cwd(), "logs", "framework", "routing-debug.log");
+            fs.appendFileSync(debugLogPath, `\n[${new Date().toISOString()}] === chat.message HOOK FIRED ===\n`);
+            fs.appendFileSync(debugLogPath, `OUTPUT KEYS: ${JSON.stringify(Object.keys(output || {}))}\n`);
+            fs.appendFileSync(debugLogPath, `MESSAGE: ${JSON.stringify(output?.message)}\n`);
+            fs.appendFileSync(debugLogPath, `PARTS: ${JSON.stringify(output?.parts)}\n`);
+            // Extract user message from parts (TextPart has type="text" and text field)
+            let userMessage = "";
+            if (output?.parts && Array.isArray(output.parts)) {
+                for (const part of output.parts) {
+                    if (part?.type === "text" && part?.text) {
+                        userMessage = part.text;
+                        break;
+                    }
+                }
+            }
+            fs.appendFileSync(debugLogPath, `userMessage: "${userMessage.slice(0, 100)}"\n`);
+            if (!userMessage || userMessage.length === 0) {
+                fs.appendFileSync(debugLogPath, `SKIP: No user text found\n`);
                 return;
             }
-            logger.log(`👤 User message received: "${userContent.slice(0, 50)}${userContent.length > 50 ? "..." : ""}"`);
+            logger.log(`👤 User message: "${userMessage.slice(0, 50)}..."`);
             try {
                 await loadTaskSkillRouter();
                 if (taskSkillRouterInstance) {
-                    // Route based on user content
-                    const routingResult = taskSkillRouterInstance.routeTask(userContent, {
-                        source: "user_message",
+                    // Get complexity score for tiebreaking
+                    let complexityScore = 50; // default medium
+                    try {
+                        if (featuresConfigLoader) {
+                            const config = featuresConfigLoader.loadConfig();
+                            if (config.model_routing?.complexity?.enabled) {
+                                // Estimate complexity based on message length and keywords
+                                complexityScore = estimateComplexity(userMessage);
+                            }
+                        }
+                    }
+                    catch (e) {
+                        // Silent fail for complexity estimation
+                    }
+                    fs.appendFileSync(debugLogPath, `Complexity estimated: ${complexityScore}\n`);
+                    // Route with complexity context
+                    const routingResult = taskSkillRouterInstance.routeTask(userMessage, {
+                        source: "chat_message",
+                        complexity: complexityScore,
                     });
+                    fs.appendFileSync(debugLogPath, `Routing result: ${JSON.stringify(routingResult)}\n`);
                     if (routingResult && routingResult.agent) {
-                        logger.log(`🎯 User message routed to: @${routingResult.agent} (confidence: ${Math.round(routingResult.confidence * 100)}%)`);
-                        // Add routing hint to user's message
-                        const routingHint = `[Suggested Agent: @${routingResult.agent}]\n`;
-                        // Modify output to include routing hint
-                        if (output.content !== undefined) {
-                            output.content = routingHint + output.content;
+                        // Apply weighted confidence scoring
+                        let finalConfidence = routingResult.confidence;
+                        let routingMethod = "keyword";
+                        // If keyword confidence is low, use complexity-based routing
+                        if (routingResult.confidence < 0.7 && complexityScore > 50) {
+                            // High complexity tasks get orchestrator boost
+                            if (complexityScore > 70) {
+                                routingResult.agent = "orchestrator";
+                                finalConfidence = Math.min(0.85, routingResult.confidence + 0.15);
+                                routingMethod = "complexity";
+                            }
                         }
-                        else if (output.message !== undefined) {
-                            output.message = routingHint + output.message;
+                        // If low complexity and low confidence, boost code-reviewer
+                        if (routingResult.confidence < 0.6 && complexityScore < 30) {
+                            routingResult.agent = "code-reviewer";
+                            finalConfidence = Math.min(0.75, routingResult.confidence + 0.15);
+                            routingMethod = "complexity";
+                        }
+                        logger.log(`🎯 Routed to: @${routingResult.agent} (${Math.round(finalConfidence * 100)}%) via ${routingMethod}`);
+                        fs.appendFileSync(debugLogPath, `Final agent: ${routingResult.agent}, confidence: ${finalConfidence}, method: ${routingMethod}\n`);
+                        // Store routing in session for later use
+                        const sessionRoutingPath = path.join(process.cwd(), "logs", "framework", "session-routing.json");
+                        try {
+                            fs.appendFileSync(sessionRoutingPath, JSON.stringify({
+                                timestamp: new Date().toISOString(),
+                                message: userMessage.slice(0, 100),
+                                agent: routingResult.agent,
+                                confidence: finalConfidence,
+                                method: routingMethod,
+                                complexity: complexityScore,
+                            }) + "\n");
+                        }
+                        catch (e) {
+                            // Silent fail for session routing logging
                         }
-                        // Log routing outcome
-                        logToolActivity(directory, "routing", "user_message", {
-                            agent: routingResult.agent,
-                            confidence: routingResult.confidence,
-                            skill: routingResult.skill,
-                        });
                     }
                 }
             }
             catch (e) {
-                logger.error("User message routing error:", e);
+                logger.error("Chat message routing error:", e);
+                fs.appendFileSync(debugLogPath, `ERROR: ${e}\n`);
             }
+            fs.appendFileSync(debugLogPath, `=== END chat.message ===\n`);
         },
         config: async (_config) => {
             const logger = await getOrCreateLogger(directory);

package/.opencode/skills/inference-improve/SKILL.md

@@ -0,0 +1,90 @@
+---
+name: inference-improve
+description: Autonomous inference improvement through collaborative agent analysis
+author: StrRay Framework
+version: 1.0.0
+tags: [inference, improvement, autonomous, learning]
+---
+
+# Inference Improvement Skill
+
+## Purpose
+
+Coordinates a collaborative agent workflow to improve routing inference by analyzing logs, reflections, and reports.
+
+## Trigger Phrases
+
+- "improve inference"
+- "analyze routing patterns"
+- "autonomous improvement"
+- "learn from logs"
+- "coalesce insights"
+
+## Agent Workflow
+
+### Phase 1: Data Gathering (Researcher)
+```
+@researcher gather all recent logs, reflections, and reports
+- Read logs/framework/activity.log
+- Read logs/framework/routing-outcomes.json  
+- Read docs/reflections/*.md
+- Read logs/reports/session-*.md
+- Read logs/reports/job-*.md
+```
+
+### Phase 2: Pattern Analysis (Code-Analyzer)
+```
+@code-analyzer analyze gathered data
+- Identify routing success/failure patterns
+- Detect weak keyword matches
+- Find confidence distribution issues
+- Locate emerging patterns
+```
+
+### Phase 3: Design Improvements (Architect)
+```
+@architect design routing improvements
+- Propose new keyword mappings
+- Suggest confidence adjustments
+- Recommend complexity thresholds
+- Design new routing patterns
+```
+
+### Phase 4: Review & Refine (Code-Reviewer)
+```
+@code-reviewer review proposed changes
+- Validate quality of proposals
+- Refine suggestions
+- Ensure no regressions
+- Prioritize changes
+```
+
+### Phase 5: Validate & Apply (Enforcer)
+```
+@enforcer validate and apply changes
+- Codex compliance check
+- Verify changes are safe
+- Apply to routing-mappings.json
+- Log improvements
+```
+
+## Output
+
+Produces actionable improvements:
+1. Updated `routing-mappings.json`
+2. New insights report
+3. Confidence adjustments
+4. Pattern additions/removals
+
+## Configuration
+
+```json
+{
+  "inference_improvement": {
+    "enabled": true,
+    "autonomous": true,
+    "interval_hours": 24,
+    "min_confidence": 0.7
+  }
+}
+```

package/.opencode/strray/agents_template.md

@@ -1,8 +1,8 @@
-# StringRay AI v1.3.4 – Agent Context & Universal Development Codex
+# StringRay AI v1.14.0 – Agent Context & Universal Development Codex
 
-**Framework Version**: 1.3.4  
-**Codex Version**: 1.1.1 (condensed)  
-**Last Updated**: 2026-01-24  
+**Framework Version**: 1.14.0  
+**Codex Version**: 1.7.5 (condensed)  
+**Last Updated**: 2026-03-23  
 **Purpose**: Systematic error prevention and production-ready AI-assisted development
 
 ## 🎯 CRITICAL RULES – ZERO TOLERANCE (MANDATORY)
@@ -75,13 +75,15 @@
 | Agent                     | Role                              | Complexity | Key Tools                              | Strategy          |
 |---------------------------|-----------------------------------|------------|----------------------------------------|-------------------|
 | enforcer                  | Codex & error prevention          | All        | read, grep, lsp_*, bash                | Block violations  |
-| architect                 | Design & decisions                | High       | read, grep, lsp_*, background_task     | Expert priority   |
 | orchestrator              | Workflow coordination             | Enterprise | read, grep, call_omo_agent, session_*  | Consensus         |
+| architect                 | Design & decisions                | High       | read, grep, lsp_*, background_task     | Expert priority   |
 | bug-triage-specialist     | Error investigation & fixes       | Debug      | read, grep, ast_grep_*                 | Majority vote     |
 | code-reviewer             | Quality & standards               | Changes    | read, grep, lsp_diagnostics            | Expert priority   |
 | security-auditor          | Vulnerabilities & compliance      | Security   | read, grep, grep_app_searchGitHub      | Block critical    |
 | refactorer                | Debt & consolidation              | Refactor   | read, grep, lsp_rename, ast_grep_*     | Majority vote     |
-| test-architect            | Testing strategy & coverage       | Tests      | read, grep, lsp_*                      | Expert priority   |
+| testing-lead              | Testing strategy & coverage       | Tests      | read, grep, lsp_*                      | Expert priority   |
+| storyteller               | Narrative deep reflections       | Narrative  | read, grep, write                      | Expert priority   |
+| researcher                | Codebase exploration              | Research   | read, grep, codesearch, websearch       | Expert priority   |
 
 ## Complexity Routing Summary
 
@@ -89,9 +91,9 @@ Score = (files×2 + change/10 + deps×3 + duration/10) × operation_weight × ri
 - Operation weights: debug 2.0, refactor 1.8, analyze 1.5, modify 1.2, others 1.0  
 - Risk multipliers: critical 1.6, high 1.3, medium 1.0, low 0.8  
 Thresholds:  
-- ≤25 → single agent  
-- 26–95 → multi-agent possible  
-- 96+ → orchestrator-led
+- ≤15 → single agent  
+- 16–50 → multi-agent possible  
+- 51+ → orchestrator-led
 
 ## Operational Guidelines
 
@@ -102,4 +104,6 @@ Thresholds:
 - Enforce codex compliance on every operation
 
 **Codex Enforcement**: All actions validated against these rules. Violations block progress until resolved.  
-**Target**: 99.6% systematic error prevention through verification-first behavior.
+**Target**: 99.6% systematic error prevention through verification-first behavior.
+
+(End of file - total 105 lines)

package/.opencode/strray/codex.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.10.0",
+  "version": "1.14.0",
   "lastUpdated": "2026-03-09",
   "errorPreventionTarget": 0.996,
   "terms": {

package/.opencode/strray/config.json

@@ -1,6 +1,6 @@
 {
   "$schema": "./config.schema.json",
-  "version": "1.10.0",
+  "version": "1.14.0",
   "description": "StringRay Framework - Token Management & Performance Configuration",
   
   "token_management": {

package/.opencode/strray/features.json

@@ -1,6 +1,6 @@
 {
   "$schema": "./features.schema.json",
-  "version": "1.10.0",
+  "version": "1.14.0",
   "description": "StringRay Framework - Unified Feature Configuration",
   "token_optimization": {
     "enabled": true,
@@ -115,5 +115,18 @@
     "moderate": 25,
     "complex": 50,
     "enterprise": 100
+  },
+  "analytics": {
+    "enabled": true,
+    "default_limit": 500,
+    "min_samples_for_calibration": 3,
+    "track_complexity_accuracy": true,
+    "track_agent_performance": true
+  },
+  "pattern_learning": {
+    "enabled": true,
+    "learning_interval_ms": 300000,
+    "auto_apply_threshold": 0.9,
+    "min_success_rate": 0.7
   }
 }