strray-ai 1.15.18 → 1.15.20

package/.opencode/codex.codex

@@ -1,5 +1,5 @@
 {
-  "version": "1.15.18",
+  "version": "1.15.19",
   "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.15.18",
+  "version": "1.15.19",
   "description": "Codex-compliant framework configuration for Credible UI project",
   "thresholds": {
     "bundleSize": {
@@ -220,7 +220,7 @@
       }
     },
     "codex": {
-      "version": "1.15.18",
+      "version": "1.15.19",
       "terms": [
         1,
         2,

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

@@ -11,7 +11,27 @@
 import * as fs from "fs";
 import * as path from "path";
 import { spawn } from "child_process";
-import { frameworkLogger } from "../core/framework-logger.js";
+// frameworkLogger — dynamically loaded (works from both dist/plugin/ and .opencode/plugins/)
+let frameworkLogger;
+async function loadFrameworkLogger() {
+    if (frameworkLogger)
+        return;
+    const candidates = [
+        "../../dist/core/framework-logger.js",
+        "../core/framework-logger.js",
+    ];
+    for (const p of candidates) {
+        try {
+            frameworkLogger = (await import(p)).frameworkLogger;
+            return;
+        }
+        catch (_) {
+            // try next candidate
+        }
+    }
+    // Fallback noop logger — plugin works without structured logging
+    frameworkLogger = { log: () => { } };
+}
 // Dynamic imports for config-paths (works from both dist/plugin/ and .opencode/plugins/)
 let _resolveCodexPath;
 let _resolveStateDir;
@@ -34,6 +54,7 @@ async function loadConfigPaths() {
             // try next candidate
         }
     }
+    await loadFrameworkLogger();
     frameworkLogger.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 */
@@ -63,6 +84,7 @@ async function importSystemPromptGenerator() {
                 // try next candidate
             }
         }
+        await loadFrameworkLogger();
         frameworkLogger.log("strray-codex-plugin", "system-prompt-generator-load-failed", "warning", { warning: "Failed to load lean system prompt generator, using fallback" });
     }
 }
@@ -379,6 +401,59 @@ function formatCodexContext(contexts) {
  * 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 */
+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" },
+    multiedit: { agent: "code-reviewer", skill: "multiedit" },
+    bash: { agent: "testing-lead", skill: "execution" },
+    search: { agent: "researcher", skill: "search" },
+    read: { agent: "researcher", skill: "read" },
+    glob: { agent: "researcher", skill: "glob" },
+    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) {
+        if (/(npm|yarn|pnpm)\s+test|jest|vitest|mocha|pytest/.test(cmd))
+            return "testing";
+        if (/(npm|yarn|pnpm)\s+run|npx|cargo|go run|make\s/.test(cmd))
+            return "build";
+        if (/audit|security|snyk|owasp|bandit/.test(cmd))
+            return "security";
+        if (/eslint|prettier|black|ruff|lint|format/.test(cmd))
+            return "lint";
+        if (/git\s/.test(cmd))
+            return "git";
+        if (/(npm|yarn|pnpm)\s+install|pip install|cargo add/.test(cmd))
+            return "install";
+        if (/grep|rg |find |ls |cat |head |tail /.test(cmd))
+            return "search";
+    }
+    if (tool === "write")
+        return "write";
+    if (tool === "edit" || tool === "multiedit")
+        return "edit";
+    if (tool === "read")
+        return "read";
+    if (tool === "search" || tool === "grep" || tool === "glob")
+        return "search";
+    return "unknown";
+}
 export default async function strrayCodexPlugin(input) {
     const { directory: inputDirectory } = input;
     const directory = inputDirectory || process.cwd();
@@ -575,6 +650,37 @@ export default async function strrayCodexPlugin(input) {
             const logger = await getOrCreateLogger(directory);
             await loadStrRayComponents();
             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];
+                const taskType = classifyTaskType(tool, args);
+                const rawDesc = args?.content
+                    ? String(args.content).slice(0, 150)
+                    : args?.filePath
+                        ? String(args.filePath)
+                        : args?.command
+                            ? String(args.command).slice(0, 150)
+                            : tool;
+                const description = `[${taskType}] ${rawDesc}`;
+                const outcomeFields = {
+                    taskId: `opencode-${_openCodeToolCallCount}`,
+                    taskDescription: description,
+                    routedAgent: mapping?.agent ?? "direct",
+                    routedSkill: mapping?.skill ?? tool,
+                    confidence: mapping ? 0.8 : 0.5,
+                    success: result?.error == null,
+                    routingMethod: mapping ? "keyword" : "default",
+                };
+                if (taskType !== "unknown")
+                    outcomeFields.taskType = taskType;
+                routingOutcomeTracker.recordOutcome(outcomeFields);
+            }
+            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
@@ -640,6 +746,26 @@ export default async function strrayCodexPlugin(input) {
                     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;
+                try {
+                    const { inferenceTuner } = await import("../services/inference-tuner.js");
+                    inferenceTuner
+                        .runTuningCycle()
+                        .then(() => {
+                        logger.log(`🔄 Inference tuning cycle completed (call #${_openCodeToolCallCount})`);
+                    })
+                        .catch((err) => {
+                        logger.log(`⚠️ Inference tuning cycle skipped: ${err instanceof Error ? err.message : String(err)}`);
+                    });
+                }
+                catch {
+                    // Tuner not available in this environment — skip silently
+                }
+            }
         },
         config: async (_config) => {
             const logger = await getOrCreateLogger(directory);

package/.opencode/strray/codex.json

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

package/.opencode/strray/config.json

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

package/.opencode/strray/features.json

@@ -1,6 +1,6 @@
 {
   "$schema": "./features.schema.json",
-  "version": "1.15.18",
+  "version": "1.15.19",
   "description": "StringRay Framework - Unified Feature Configuration",
   "token_optimization": {
     "enabled": true,

package/.opencode/strray/integrations.json

@@ -4,19 +4,19 @@
     "openclaw": {
       "enabled": false,
       "type": "external-service",
-      "version": "1.15.18",
+      "version": "1.15.19",
       "config": {}
     },
     "python-bridge": {
       "enabled": false,
       "type": "protocol-bridge",
-      "version": "1.15.18",
+      "version": "1.15.19",
       "config": {}
     },
     "react": {
       "enabled": false,
       "type": "framework-adapter",
-      "version": "1.15.18",
+      "version": "1.15.19",
       "config": {}
     }
   }

package/.strray/agents_template.md

@@ -0,0 +1,109 @@
+# StringRay AI v1.15.1 – Agent Context & Universal Development Codex
+
+**Framework Version**: 1.14.1  
+**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)
+
+1. **Full File Reading Before Edit**  
+   ALWAYS read the ENTIRE file using the `read` tool before ANY edit, refactor, or write.  
+   Understand complete structure, imports, dependencies, and context.  
+   Partial/contextual edits are strictly forbidden.
+
+2. **Verify Changes Actually Applied**  
+   After every edit/write: use `read` to confirm the exact changes are present.  
+   Check for regressions and unintended modifications.  
+   NEVER declare success without observable verification.
+
+3. **Command & Tool Output Review**  
+   Immediately review ALL command/tool outputs.  
+   Identify errors, warnings, or anomalies.  
+   Add TODO for course correction if issues found.  
+   Do not proceed until critical problems are resolved.
+
+4. **No False Success Claims**  
+   Only report "completed", "edited", or "fixed" after verification steps confirm success.  
+   Prohibited: assuming success, subjective "looks correct", skipping checks for "trivial" changes.
+
+5. **Surgical & Progressive Fixes**  
+   Fix root causes minimally – no patches, stubs, or over-engineering.  
+   All code must be production-ready from first commit.
+
+6. **Error & Loop Prevention**  
+   Resolve all errors before continuing (90%+ runtime prevention target).  
+   Every loop/async must have clear termination/timeout.
+
+7. **Type Safety & Immutability First**  
+   No `any`, `@ts-ignore`. Prefer immutable patterns and early returns/guards.
+
+8. **DRY, YAGNI, Separation of Concerns**  
+   No duplication. No unnecessary features. One responsibility per module/function.
+
+9. **Test & Performance Awareness**  
+   >85% behavioral coverage target. Respect bundle <2MB, FCP <2s budgets.
+
+10. **Security & Input Validation**  
+    Validate/sanitize all inputs. Security by design.
+
+## Core Codex Terms (Top 20 – Enforced)
+
+1. Progressive production-ready code  
+2. No patches/stubs/bridge code  
+3. Avoid over-engineering  
+4. Fit-for-purpose prod-level code  
+5. Surgical root-cause fixes  
+6. Batched introspection cycles  
+7. Resolve all errors (90% prevention)  
+8. Prevent infinite loops/timeouts  
+9. Shared global state / single source of truth  
+10. Type safety first (no `any`)  
+11. Early returns & guard clauses  
+12. Error boundaries & graceful degradation  
+13. Immutability preferred  
+14. Separation of concerns  
+15. DRY – eliminate duplication  
+16. YAGNI – no speculative features  
+17. Meaningful, self-documenting names  
+18. Small, focused functions (<30 lines ideal)  
+19. Consistent style (linter enforced)  
+20. Test coverage >85% (behavioral focus)
+
+## Agent Capabilities Matrix
+
+| Agent                     | Role                              | Complexity | Key Tools                              | Strategy          |
+|---------------------------|-----------------------------------|------------|----------------------------------------|-------------------|
+| enforcer                  | Codex & error prevention          | All        | read, grep, lsp_*, bash                | Block violations  |
+| 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     |
+| 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
+
+Score = (files×2 + change/10 + deps×3 + duration/10) × operation_weight × risk_mult  
+- 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:  
+- ≤15 → single agent  
+- 16–50 → multi-agent possible  
+- 51+ → orchestrator-led
+
+## Operational Guidelines
+
+- Evaluate complexity before execution  
+- Always verify: read full file → apply change → read again → confirm no regressions  
+- Use `call_omo_agent` or `task()` for delegation  
+- Log JobId for traceability  
+- 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.
+
+(End of file - total 105 lines)