0xray 3.3.0 → 3.4.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/.opencode/enforcer-config.json

@@ -1,7 +1,5 @@
 {
-  "framework": "xray 2.0",
-  "version": "3.1.0",
-  "description": "Codex-compliant framework configuration for Credible UI project",
+  "description": "Codex-compliant framework configuration",
   "thresholds": {
     "bundleSize": {
       "maxSize": "3MB",
@@ -220,7 +218,6 @@
       }
     },
     "codex": {
-      "version": "3.1.0",
       "terms": [
         1,
         2,

package/dist/CHANGELOG.md

@@ -4,6 +4,28 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Conventional Commits](https://www.conventionalcommits.org/).
 
+## [3.4.1] - 2026-06-17
+
+### ✨ Features
+- Unified 4-platform bridge installer (`install-bridges.cjs`) runs on consumer `npm i 0xray` postinstall — OpenCode, Grok, Hermes, OpenClaw
+- All 7 MCP servers registered via `npx -y 0xray mcp <cmd>` (no brittle `dist/` paths)
+- `npx 0xray grok install` aligned with postinstall: 7 servers via npx, idempotent skill/MCP sync on re-run
+- Grok skills synced to both `~/.grok/plugins/0xray/skills/` and `~/.grok/skills/` (Grok Build / Cursor)
+
+### 🐛 Bug Fixes
+- `setup.cjs` consumer detection uses `isConsumerInstall()` — works for both `node_modules/0xray` and `node_modules/xray`
+- Hermes bridge honors `XRAY_ROOT` env and `xray-consumer-root.txt` marker for correct project root resolution
+
+## [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/analytics/routing-refiner.js

@@ -35,7 +35,6 @@ class RoutingRefiner {
         const optimizations = this.suggestMappingOptimizations(promptAnalysis, performanceReport);
         const warnings = this.generateWarnings(newMappings, optimizations);
         return {
-            version: "3.1.0",
             generatedAt: new Date(),
             summary: {
                 newMappings: newMappings.length,
@@ -247,7 +246,6 @@ class RoutingRefiner {
         lines.push("╚════════════════════════════════════════════════════════════╝");
         lines.push("");
         lines.push(`Generated: ${report.configurationUpdate.generatedAt.toISOString()}`);
-        lines.push(`Version: ${report.configurationUpdate.version}`);
         lines.push("");
         lines.push("=== Summary ===");
         lines.push(`New Mappings: ${report.configurationUpdate.summary.newMappings}`);

package/dist/core/boot-orchestrator.js

@@ -1,6 +1,7 @@
 /**
  * Boot Orchestrator (min documented consumer runtime compat shim from prior 0xRay releases; primary Xray paths + .xray fallbacks only; 1-line per Scope Rule).
  */
+import { readFileSync } from "fs";
 import { XrayContextLoader } from "./context-loader.js";
 import { XrayStateManager } from "../state/state-manager.js";
 import { ProcessorManager } from "../processors/processor-manager.js";
@@ -721,7 +722,14 @@ export class BootOrchestrator {
         try {
             // Consumer runtime compat shim from prior 0xRay releases (1-line min per Scope Rule; primary xray paths + .xray fallbacks)
             const xrayConfig = {
-                version: "3.1.0",
+                version: (() => {
+                    try {
+                        return JSON.parse(readFileSync(path.join(process.cwd(), "package.json"), "utf-8")).version;
+                    }
+                    catch {
+                        return "unknown";
+                    }
+                })(),
                 codex_enabled: true,
                 codex_version: "v1.7.5",
                 codex_terms: [

package/dist/core/features-config.js

@@ -285,7 +285,6 @@ export class FeaturesConfigLoader {
      */
     getDefaultConfig() {
         return {
-            version: "3.1.0",
             description: "0xRay Framework - Unified Feature Configuration",
             token_optimization: {
                 enabled: true,

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

@@ -18,9 +18,44 @@ import { frameworkLogger } from '../../core/framework-logger.js';
 import fs from 'fs';
 import path from 'path';
 import { execSync } from 'child_process';
+import { createRequire } from 'module';
 import { syncBuiltinSkills } from '../../cli/commands/skill-install.js';
 // ESM-compatible __dirname (this file is compiled to ESM)
 const __dirname = path.dirname(new URL(import.meta.url).pathname);
+const packageRoot = path.resolve(__dirname, '..', '..', '..');
+const requireCjs = createRequire(import.meta.url);
+const { resolveConsumerTargetDir } = requireCjs(path.join(packageRoot, 'scripts/node/install-bridges.cjs'));
+/** Canonical 7-server MCP surface — matches install-bridges.cjs and package .mcp.json */
+const XRAY_MCP_SERVERS = [
+    { name: 'xray-governance', mcpCmd: 'governance', env: { XRAY_FORCE_MCP_GOVERNANCE: 'true' } },
+    { name: 'xray-skills', mcpCmd: 'skills', env: {} },
+    { name: 'xray-orchestrator', mcpCmd: 'orchestrator', env: {} },
+    { name: 'xray-enforcer', mcpCmd: 'enforcer', env: {} },
+    { name: 'xray-researcher', mcpCmd: 'researcher', env: {} },
+    { name: 'xray-code-review', mcpCmd: 'code-review', env: {} },
+    { name: 'xray-architect-tools', mcpCmd: 'architect-tools', env: {} },
+];
+function registerGrokMcpServers(targetDir) {
+    try {
+        execSync('which grok', { stdio: 'ignore' });
+    }
+    catch {
+        console.log('[Grok] grok CLI not on PATH — plugin .mcp.json still configured');
+        return;
+    }
+    for (const s of XRAY_MCP_SERVERS) {
+        try {
+            const envEntries = { ...s.env, XRAY_ROOT: targetDir };
+            const envFlags = Object.entries(envEntries)
+                .map(([k, v]) => `--env "${k}=${v}"`)
+                .join(' ');
+            execSync(`grok mcp add ${s.name} --command npx --args "-y" "0xray" "mcp" "${s.mcpCmd}" ${envFlags}`, { stdio: 'pipe' });
+        }
+        catch {
+            // already registered or grok config conflict — non-blocking
+        }
+    }
+}
 export async function installForGrokCLI(options = {}) {
     frameworkLogger.log('grok-integration', 'install-start', 'info', { options });
     const home = process.env.HOME || process.env.USERPROFILE || '';
@@ -39,15 +74,18 @@ export async function installForGrokCLI(options = {}) {
         console.log(`[Grok] Dry run: Would copy plugin from ${sourceDir} → ${targetPluginDir}`);
         return;
     }
+    const targetDir = resolveConsumerTargetDir(packageRoot, process.cwd());
     try {
-        if (fs.existsSync(targetPluginDir) && !options.force) {
+        const pluginExists = fs.existsSync(targetPluginDir);
+        if (pluginExists && !options.force) {
             console.log('[Grok] 0xray Grok plugin is already installed.');
-            console.log('Use --force to reinstall.');
-            return;
+            console.log('Use --force to reinstall plugin files.');
+        }
+        else {
+            fs.cpSync(sourceDir, targetPluginDir, { recursive: true, force: true });
+            frameworkLogger.log('grok-integration', 'plugin-copied', 'info', { destination: targetPluginDir });
+            console.log(`\x1b[32m✓ Copied Grok plugin to ${targetPluginDir}\x1b[0m`);
         }
-        fs.cpSync(sourceDir, targetPluginDir, { recursive: true, force: true });
-        frameworkLogger.log('grok-integration', 'plugin-copied', 'info', { destination: targetPluginDir });
-        console.log(`\x1b[32m✓ Copied Grok plugin to ${targetPluginDir}\x1b[0m`);
         // Sync builtin skills to Grok plugin skills dir
         const grokSkillsDir = path.join(targetPluginDir, 'skills');
         const skillsCopied = syncBuiltinSkills(grokSkillsDir);
@@ -55,6 +93,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' });
@@ -64,25 +108,9 @@ export async function installForGrokCLI(options = {}) {
             console.log('\nPlease run this command to fully trust the plugin:');
             console.log(`  grok plugins trust "${targetPluginDir}"`);
         }
-        // Register MCP servers via grok mcp add (most reliable mechanism)
-        const govMcpPath = path.resolve(__dirname, '..', '..', '..', 'dist/mcps/governance.server.js');
-        const skillsMcpPath = path.resolve(__dirname, '..', '..', '..', 'dist/mcps/knowledge-skills/skill-invocation.server.js');
-        const orchMcpPath = path.resolve(__dirname, '..', '..', '..', 'dist/mcps/orchestrator.server.js');
-        const enforcerMcpPath = path.resolve(__dirname, '..', '..', '..', 'dist/mcps/enforcer-tools.server.js');
-        try {
-            execSync(`grok mcp add xray-governance --command node --args "${govMcpPath}" --env "XRAY_FORCE_MCP_GOVERNANCE=true" --env "XRAY_ROOT=${process.cwd()}"`, { stdio: 'pipe' });
-            execSync(`grok mcp add xray-skills --command node --args "${skillsMcpPath}" --env "XRAY_ROOT=${process.cwd()}"`, { stdio: 'pipe' });
-            execSync(`grok mcp add xray-orchestrator --command node --args "${orchMcpPath}" --env "XRAY_ROOT=${process.cwd()}"`, { stdio: 'pipe' });
-            execSync(`grok mcp add xray-enforcer --command node --args "${enforcerMcpPath}" --env "XRAY_ROOT=${process.cwd()}"`, { stdio: 'pipe' });
-            console.log('\x1b[32m✓ Registered xray MCP servers with Grok CLI\x1b[0m');
-        }
-        catch {
-            console.log('\nCould not auto-register MCP servers. Run manually:');
-            console.log(`  grok mcp add xray-governance --command node --args "${govMcpPath}"`);
-            console.log(`  grok mcp add xray-skills --command node --args "${skillsMcpPath}"`);
-            console.log(`  grok mcp add xray-orchestrator --command node --args "${orchMcpPath}"`);
-            console.log(`  grok mcp add xray-enforcer --command node --args "${enforcerMcpPath}"`);
-        }
+        // Register MCP servers via grok mcp add (npx -y 0xray mcp — matches install-bridges)
+        registerGrokMcpServers(targetDir);
+        console.log('\x1b[32m✓ Registered 7 xray MCP servers with Grok CLI (npx)\x1b[0m');
         console.log('\n✅ 0xRay is now installed as a first-class Grok CLI plugin!');
         console.log('Restart Grok or run `grok` to load the new hooks and MCP servers.');
     }

package/dist/integrations/hermes-agent/bridge.mjs

@@ -53,9 +53,19 @@ let frameworkLoadAttempted = false;
 
 // ── Project root detection ───────────────────────────────────
 function findProjectRoot() {
-  const envHome = process.env.XRAY_HOME;
+  const envHome = process.env.XRAY_HOME || process.env.XRAY_ROOT;
   if (envHome && existsSync(join(envHome, "package.json"))) return envHome;
 
+  const consumerMarker = join(__dirname, "xray-consumer-root.txt");
+  if (existsSync(consumerMarker)) {
+    try {
+      const marked = readFileSync(consumerMarker, "utf-8").trim();
+      if (marked && existsSync(join(marked, "package.json"))) return marked;
+    } catch {
+      // fall through
+    }
+  }
+
   const candidates = [
     process.cwd(),
     join(homedir(), "dev", "xray"),

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/registry.json

@@ -1,5 +1,4 @@
 {
-  "version": "3.1.0",
   "description": "0xRay Community MCPs Registry - curated API-focused MCP servers",
   "sources": [
     {

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/dist/orchestrator/universal-registry-bridge.js

@@ -113,7 +113,7 @@ export class UniversalRegistryBridge {
                 currentAgent = {
                     name: nameMatch[1].trim(),
                     description: "",
-                    version: "3.1.0",
+                    version: "",
                 };
                 inAgent = true;
                 continue;