0xray 3.3.0 → 3.3.1

package/.opencode/codex.codex

@@ -1,5 +1,5 @@
 {
-  "version": "3.3.0",
+  "version": "3.3.1",
   "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/dist/CHANGELOG.md

@@ -4,6 +4,16 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Conventional Commits](https://www.conventionalcommits.org/).
 
+## [3.3.0] - 2026-06-18
+
+### 🔄 Changes
+
+### 🔎 Other Changes
+- Wire orchestrator confidence gate into execution planning (d7910b610)
+- tweet: v3.3.0 release tweet — Pluggable Memory Routing (7fb6c9f70)
+
+---
+
 ## [3.2.0] - 2026-06-17
 
 ### 🔄 Changes

package/dist/integrations/grok/grok-cli.js

@@ -55,6 +55,12 @@ export async function installForGrokCLI(options = {}) {
             console.log(`\x1b[32m✓ Synced ${skillsCopied} builtin skills to Grok plugin\x1b[0m`);
         }
         frameworkLogger.log('grok-integration', 'skills-synced', 'info', { count: skillsCopied });
+        // Grok Build / Cursor also reads ~/.grok/skills/ for agent_skills
+        const globalSkillsDir = path.join(home, '.grok', 'skills');
+        const globalCopied = syncBuiltinSkills(globalSkillsDir);
+        if (globalCopied > 0) {
+            console.log(`\x1b[32m✓ Synced ${globalCopied} builtin skills to ~/.grok/skills/\x1b[0m`);
+        }
         // Attempt auto-trust (best effort)
         try {
             execSync(`grok plugins trust "${targetPluginDir}"`, { stdio: 'ignore' });

package/dist/mcps/index.js

@@ -40,6 +40,7 @@ export const MCP_SERVERS = [
     { serverName: "refactoring-strategies", sourceFile: "mcps/knowledge-skills/refactoring-strategies.server.ts", type: "knowledge-skill", registered: true, description: "Refactoring strategies" },
     { serverName: "security-audit", sourceFile: "mcps/knowledge-skills/security-audit.server.ts", type: "knowledge-skill", registered: true, description: "Security auditing" },
     { serverName: "seo-consultant", sourceFile: "mcps/knowledge-skills/seo-consultant.server.ts", type: "knowledge-skill", registered: false, description: "SEO consulting" },
+    { serverName: "storyteller", sourceFile: "mcps/knowledge-skills/storyteller.server.ts", type: "knowledge-skill", registered: false, description: "Reflections, sagas, and technical narratives" },
     { serverName: "session-management", sourceFile: "mcps/knowledge-skills/session-management.server.ts", type: "knowledge-skill", registered: true, description: "Session management" },
     { serverName: "skill-invocation", sourceFile: "mcps/knowledge-skills/skill-invocation.server.ts", type: "knowledge-skill", registered: true, description: "Skill invocation" },
     { serverName: "strategist", sourceFile: "mcps/knowledge-skills/strategist.server.ts", type: "knowledge-skill", registered: false, description: "Strategic planning" },

package/dist/mcps/knowledge-skills/skill-invocation.server.js

@@ -87,7 +87,7 @@ class SkillInvocationServer extends XrayKnowledgeSkillBase {
             "strategist", "skill-invocation",
         ];
         const knowledgeSkills = [
-            "architecture-patterns", "strategist", "tech-writer",
+            "architecture-patterns", "strategist", "tech-writer", "storyteller",
             "seo-consultant", "content-creator", "growth-strategist",
             "bug-triage-specialist", "log-monitor",
             "mobile-development", "git-workflow", "session-management",
@@ -132,6 +132,7 @@ class SkillInvocationServer extends XrayKnowledgeSkillBase {
             "tech-writer": "documentation-generation",
             "frontend-ui-ux-engineer": "ui-ux-design",
             "frontend-engineer": "project-analysis",
+            "storyteller": "storyteller",
         };
         const resolvedSkill = skillAliases[skillName] || skillName;
         const availableServers = [
@@ -147,7 +148,7 @@ class SkillInvocationServer extends XrayKnowledgeSkillBase {
             "git-workflow", "content-creator", "ui-ux-design",
             "multimodal-looker", "refactoring-strategies",
             "project-analysis", "testing-best-practices",
-            "architecture-patterns",
+            "architecture-patterns", "storyteller",
         ];
         if (!availableServers.includes(resolvedSkill)) {
             return {

package/dist/mcps/knowledge-skills/storyteller.server.js

@@ -0,0 +1,167 @@
+/**
+ * Storyteller MCP Server
+ *
+ * Returns storyteller SKILL.md guidance plus a session-aware writing prompt.
+ * The host LLM writes the story; this server supplies the contract.
+ */
+import { execSync } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { XrayKnowledgeSkillBase } from '../shared/knowledge-skill-base.js';
+const STORY_TYPES = ['reflection', 'saga', 'journey', 'narrative'];
+function resolveSkillMd() {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        join(here, '../../../skills/storyteller/SKILL.md'),
+        join(here, '../../skills/storyteller/SKILL.md'),
+        join(process.cwd(), 'node_modules/0xray/dist/skills/storyteller/SKILL.md'),
+        join(process.cwd(), 'node_modules/xray/dist/skills/storyteller/SKILL.md'),
+    ];
+    for (const path of candidates) {
+        if (existsSync(path)) {
+            return readFileSync(path, 'utf-8');
+        }
+    }
+    return '# Storyteller\n\nWrite warmly candid technical reflections with scene-first openings.';
+}
+function getStoryMeta(storyType) {
+    const defaults = {
+        reflection: {
+            location: 'docs/reflections/',
+            min_words: 2000,
+            ideal_words: 5000,
+            framework: 'three_act_structure',
+        },
+        saga: {
+            location: 'docs/reflections/deep/',
+            min_words: 5000,
+            ideal_words: 15000,
+            framework: 'hero_journey',
+        },
+        journey: {
+            location: 'docs/reflections/deep/',
+            min_words: 1500,
+            ideal_words: 4000,
+            framework: 'three_act_structure',
+        },
+        narrative: {
+            location: 'docs/reflections/',
+            min_words: 1000,
+            ideal_words: 3000,
+            framework: 'three_act_structure',
+        },
+    };
+    return defaults[storyType];
+}
+function gitContext() {
+    try {
+        const commits = execSync('git log --oneline -20 2>/dev/null', { encoding: 'utf-8' });
+        const files = execSync('git diff --name-only HEAD~10 2>/dev/null || git ls-files 2>/dev/null | head -50', { encoding: 'utf-8' });
+        return `Recent commits:\n${commits}\n\nRecent files:\n${files}`;
+    }
+    catch {
+        return 'No git context available in this workspace.';
+    }
+}
+function buildPrompt(storyType, title, meta, extraContext) {
+    const contextBlock = extraContext
+        ? `\n## Provided context\n${JSON.stringify(extraContext, null, 2)}\n`
+        : '';
+    return `Write a ${storyType} titled "${title}".
+
+## Requirements
+- Framework: ${meta.framework}
+- Target length: ${meta.ideal_words} words (minimum: ${meta.min_words})
+- Save to: ${meta.location}
+- Follow storyteller SKILL.md voice (warmly candid, scene-first, no executive summary)
+- Include Key Takeaways and What Next sections
+
+## Session / repo context
+${gitContext()}
+${contextBlock}
+
+Write the complete ${storyType} now.`;
+}
+function writeStoryTool(storyType, args) {
+    const meta = getStoryMeta(storyType);
+    if (args.framework)
+        meta.framework = args.framework;
+    const title = args.title ??
+        `${storyType.charAt(0).toUpperCase() + storyType.slice(1)} - ${new Date().toISOString().split('T')[0]}`;
+    const skillMd = resolveSkillMd();
+    const prompt = buildPrompt(storyType, title, meta, args.context);
+    const slug = title
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '');
+    const filename = `${storyType}-${slug}-${new Date().toISOString().split('T')[0]}.md`;
+    const outputPath = args.output ?? join(meta.location, filename);
+    const outputDir = join(process.cwd(), dirname(outputPath));
+    if (!existsSync(outputDir))
+        mkdirSync(outputDir, { recursive: true });
+    const fullPath = join(process.cwd(), outputPath);
+    const frontmatter = `---
+story_type: ${storyType}
+title: "${title}"
+framework: ${meta.framework}
+target_words: ${meta.ideal_words}
+---
+
+`;
+    writeFileSync(fullPath, `${frontmatter}\n${prompt}\n`, 'utf-8');
+    return {
+        content: [
+            {
+                type: 'text',
+                text: [
+                    `Storyteller ${storyType} brief prepared.`,
+                    `Output template: ${outputPath}`,
+                    '',
+                    '--- SKILL (excerpt) ---',
+                    skillMd.slice(0, 4000),
+                    skillMd.length > 4000 ? '\n...(truncated; full SKILL.md on disk)' : '',
+                    '',
+                    '--- WRITING PROMPT ---',
+                    prompt,
+                    '',
+                    'Host LLM: write the full story into the output path using the prompt above.',
+                ].join('\n'),
+            },
+        ],
+    };
+}
+class StorytellerServer extends XrayKnowledgeSkillBase {
+    constructor() {
+        super('storyteller', '1.0.0');
+        const writeSchema = {
+            type: 'object',
+            properties: {
+                title: { type: 'string', description: 'Story title' },
+                context: { type: 'object', description: 'Session context (commits, changes, notes)' },
+                framework: { type: 'string', description: 'Storytelling framework override' },
+                output: { type: 'string', description: 'Relative output path' },
+            },
+        };
+        this.tools = STORY_TYPES.map((storyType) => ({
+            name: `write_${storyType}`,
+            description: `Prepare ${storyType} story brief using storyteller SKILL.md`,
+            inputSchema: writeSchema,
+        }));
+        this.handlers = {
+            write_reflection: async (args) => writeStoryTool('reflection', args),
+            write_saga: async (args) => writeStoryTool('saga', args),
+            write_journey: async (args) => writeStoryTool('journey', args),
+            write_narrative: async (args) => writeStoryTool('narrative', args),
+        };
+        this.setupToolHandlers();
+    }
+}
+if (import.meta.url === `file://${fileURLToPath(import.meta.url)}`) {
+    const server = new StorytellerServer();
+    server.run().catch((error) => {
+        process.stderr.write(`FATAL: ${String(error)}\n`);
+        process.exit(1);
+    });
+}
+export { StorytellerServer };

package/dist/mcps/orchestrator/execution/execution-planner.js

@@ -159,12 +159,15 @@ export class ExecutionPlanner {
      */
     assignTasksToAgents(tasks, agentAssignments) {
         for (const task of tasks) {
-            const complexity = task.estimatedComplexity || 30;
+            const complexity = this.calculateTaskComplexity(task);
             const requiredCaps = [
                 task.type,
                 ...(task.metadata?.memorySignals ?? []),
             ];
-            const agent = this.capabilitiesManager.selectAgentForTask(requiredCaps, complexity, task.description) || 'orchestrator';
+            const operationDescription = task.metadata?.memoryHighConfidenceTrap
+                ? `${task.description} TYPE: ontological-trap`
+                : task.description;
+            const agent = this.capabilitiesManager.selectAgentForTask(requiredCaps, complexity, operationDescription) || 'orchestrator';
             if (!agentAssignments.has(agent)) {
                 agentAssignments.set(agent, []);
             }
@@ -264,6 +267,15 @@ export class ExecutionPlanner {
         if (task.dependencies) {
             complexity += task.dependencies.length * 5;
         }
+        if (task.metadata?.memoryComplexityBoost !== undefined) {
+            complexity += task.metadata.memoryComplexityBoost;
+        }
+        else {
+            const provider = getProvider();
+            if (provider.id !== 'null' && provider.getTaskConfidence) {
+                complexity += provider.getTaskConfidence(toMemoryTask(task)).complexityBoost;
+            }
+        }
         return Math.min(Math.max(Math.round(complexity), 1), 100);
     }
     /**

package/dist/mcps/researcher-confidence.js

@@ -0,0 +1,92 @@
+import { frameworkLogger } from '../core/framework-logger.js';
+import { getMemoryRoutingProviderSync } from '../memory-routing/index.js';
+const TRAP_LANGUAGE = /TYPE:\s*ontological-trap|ontological[- ]trap/i;
+const DEFAULT_MIN_CONFIDENCE_GATE = 0.55;
+export function shouldQueryRepertoireConfidence(description, proposalType = '') {
+    const text = `${description} ${proposalType}`.trim();
+    return TRAP_LANGUAGE.test(text);
+}
+export function hasHighConfidencePrimitiveMatch(routingContext, minConfidence = DEFAULT_MIN_CONFIDENCE_GATE) {
+    const confidences = routingContext.signalConfidences ?? {};
+    return Object.values(confidences).some((confidence) => confidence >= minConfidence);
+}
+function buildTaskText(proposalTitle, proposalDescription, proposalType) {
+    return [proposalTitle, proposalDescription, proposalType].filter(Boolean).join('\n');
+}
+/**
+ * Resolve Repertoire task confidence for researcher proposal analysis.
+ * Triggered by ontological-trap language or high-confidence primitive matches.
+ */
+export function resolveResearcherMemoryContext(input) {
+    const proposalTitle = input.proposalTitle ?? '';
+    const proposalDescription = input.proposalDescription ?? '';
+    const proposalType = input.proposalType ?? '';
+    const taskText = buildTaskText(proposalTitle, proposalDescription, proposalType);
+    const provider = getMemoryRoutingProviderSync();
+    if (provider.id === 'null' || !provider.getTaskConfidence) {
+        return null;
+    }
+    const trapLanguageDetected = shouldQueryRepertoireConfidence(proposalDescription, proposalType);
+    const routingContext = provider.buildRoutingContext(taskText);
+    const primitiveMatchDetected = hasHighConfidencePrimitiveMatch(routingContext);
+    if (!trapLanguageDetected && !primitiveMatchDetected) {
+        return null;
+    }
+    const confidence = provider.getTaskConfidence({
+        id: 'researcher-proposal',
+        description: taskText,
+        type: proposalType || 'governance',
+    });
+    const matchedSignals = confidence.matchedSignals.length > 0
+        ? confidence.matchedSignals
+        : routingContext.matchedSignals;
+    const context = {
+        providerId: provider.id,
+        confidence,
+        matchedSignals,
+        recommendedAgent: confidence.recommendedAgent,
+        triggeredBy: trapLanguageDetected ? 'trap-language' : 'high-confidence-primitives',
+    };
+    if (confidence.highConfidenceTrapPresent) {
+        frameworkLogger.log('mcps/researcher', 'repertoire-trap-detected', 'info', {
+            providerId: provider.id,
+            matchedSignals,
+            complexityBoost: confidence.complexityBoost,
+            recommendedAgent: confidence.recommendedAgent,
+            triggeredBy: context.triggeredBy,
+        });
+    }
+    return context;
+}
+export function buildMemoryRoutingEvidence(context) {
+    const { confidence, matchedSignals, recommendedAgent } = context;
+    const signalSummary = confidence.signals
+        .map((entry) => `${entry.name} (${entry.confidence.toFixed(2)})`)
+        .join(', ');
+    const lines = [
+        `Repertoire memory routing (${context.providerId}, trigger: ${context.triggeredBy})`,
+        `Matched signals: ${matchedSignals.join(', ') || 'none'}`,
+        `Signal confidences: ${signalSummary || 'none'}`,
+        `High-confidence trap present: ${confidence.highConfidenceTrapPresent}`,
+        `Complexity boost: ${confidence.complexityBoost}`,
+    ];
+    if (recommendedAgent) {
+        lines.push(`Recommended agent for trap handling: ${recommendedAgent}`);
+    }
+    return lines;
+}
+export function formatMemoryRoutingBlock(context) {
+    const { confidence, matchedSignals, recommendedAgent } = context;
+    const lines = [
+        'MEMORY_ROUTING:',
+        `  provider: ${context.providerId}`,
+        `  trigger: ${context.triggeredBy}`,
+        `  matchedSignals: ${matchedSignals.join(', ') || 'none'}`,
+        `  highConfidenceTrapPresent: ${confidence.highConfidenceTrapPresent}`,
+        `  complexityBoost: ${confidence.complexityBoost}`,
+    ];
+    if (recommendedAgent) {
+        lines.push(`  recommendedAgent: ${recommendedAgent}`);
+    }
+    return lines.join('\n');
+}

package/dist/mcps/researcher.server.js

@@ -11,6 +11,7 @@ import * as fs from "fs";
 import * as path from "path";
 import { frameworkLogger } from "../core/framework-logger.js";
 import { tryLLMGovernance } from "../governance/llm-governance-provider.js";
+import { buildMemoryRoutingEvidence, formatMemoryRoutingBlock, resolveResearcherMemoryContext, } from "./researcher-confidence.js";
 import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
 class XrayLibrarianServer extends XrayKnowledgeSkillBase {
     constructor() {
@@ -377,13 +378,28 @@ class XrayLibrarianServer extends XrayKnowledgeSkillBase {
      */
     async analyzeProposal(args) {
         const { proposalTitle = "", proposalDescription = "", evidence = [], proposalType = "" } = args || {};
-        const vote = await tryLLMGovernance("researcher", proposalTitle || "", proposalDescription || "", evidence || [], proposalType || "");
+        const memoryContext = resolveResearcherMemoryContext({
+            proposalTitle,
+            proposalDescription,
+            proposalType,
+        });
+        const enrichedEvidence = [...(evidence || [])];
+        if (memoryContext?.confidence.highConfidenceTrapPresent) {
+            enrichedEvidence.push(...buildMemoryRoutingEvidence(memoryContext));
+        }
+        const vote = await tryLLMGovernance("researcher", proposalTitle || "", proposalDescription || "", enrichedEvidence, proposalType || "");
+        const memoryRoutingBlock = memoryContext?.confidence.highConfidenceTrapPresent
+            ? `\n${formatMemoryRoutingBlock(memoryContext)}`
+            : "";
         if (!vote) {
+            const abstainReason = memoryContext?.confidence.highConfidenceTrapPresent
+                ? "No LLM governance provider configured. Repertoire detected a high-confidence ontological trap — route to the recommended agent before proceeding."
+                : "No LLM governance provider configured. Set XRAY_GOVERNANCE_LLM_ENABLED=true + XRAY_LLM_ENDPOINT, or install Hermes and run: hermes auth add xai-oauth --no-browser";
             return {
                 content: [
                     {
                         type: "text",
-                        text: "DECISION: abstain\nCONFIDENCE: 0.50\nREASONING: No LLM governance provider configured. Set XRAY_GOVERNANCE_LLM_ENABLED=true + XRAY_LLM_ENDPOINT, or install Hermes and run: hermes auth add xai-oauth --no-browser",
+                        text: `DECISION: abstain\nCONFIDENCE: 0.50\nREASONING: ${abstainReason}${memoryRoutingBlock}`,
                     },
                 ],
             };
@@ -392,7 +408,7 @@ class XrayLibrarianServer extends XrayKnowledgeSkillBase {
             content: [
                 {
                     type: "text",
-                    text: `DECISION: ${vote.decision}\nCONFIDENCE: ${vote.confidence.toFixed(2)}\nREASONING: ${vote.reasoning}`,
+                    text: `DECISION: ${vote.decision}\nCONFIDENCE: ${vote.confidence.toFixed(2)}\nREASONING: ${vote.reasoning}${memoryRoutingBlock}`,
                 },
             ],
         };

package/dist/memory-routing/null-provider.js

@@ -45,6 +45,18 @@ export class NullMemoryRoutingProvider {
             context: { ...EMPTY_CONTEXT },
         };
     }
+    getTaskConfidence() {
+        return {
+            signals: [],
+            matchedSignals: [],
+            avgConfidence: 0,
+            maxConfidence: 0,
+            highConfidenceTrapPresent: false,
+            ontologicalTrapDetected: false,
+            complexityBoost: 0,
+            recommendedAgent: null,
+        };
+    }
 }
 export function createMemoryRoutingProvider() {
     return new NullMemoryRoutingProvider();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "0xray",
-  "version": "3.3.0",
+  "version": "3.3.1",
   "description": "Multi-agent orchestration and Codex governance for OpenCode, Hermes, Grok Build, and OpenClaw",
   "readme": "README.md",
   "license": "MIT",