0xray 3.2.0 → 3.3.1

package/src/mcps/researcher-confidence.ts

@@ -0,0 +1,144 @@
+import { frameworkLogger } from '../core/framework-logger.js';
+import { getMemoryRoutingProviderSync } from '../memory-routing/index.js';
+import type {
+  MemoryRoutingContext,
+  MemoryTaskConfidence,
+} from '../memory-routing/types.js';
+
+const TRAP_LANGUAGE = /TYPE:\s*ontological-trap|ontological[- ]trap/i;
+const DEFAULT_MIN_CONFIDENCE_GATE = 0.55;
+
+export interface ResearcherMemoryContext {
+  providerId: string;
+  confidence: MemoryTaskConfidence;
+  matchedSignals: string[];
+  recommendedAgent: string | null;
+  triggeredBy: 'trap-language' | 'high-confidence-primitives';
+}
+
+export function shouldQueryRepertoireConfidence(
+  description: string,
+  proposalType = '',
+): boolean {
+  const text = `${description} ${proposalType}`.trim();
+  return TRAP_LANGUAGE.test(text);
+}
+
+export function hasHighConfidencePrimitiveMatch(
+  routingContext: MemoryRoutingContext,
+  minConfidence = DEFAULT_MIN_CONFIDENCE_GATE,
+): boolean {
+  const confidences = routingContext.signalConfidences ?? {};
+  return Object.values(confidences).some((confidence) => confidence >= minConfidence);
+}
+
+function buildTaskText(
+  proposalTitle: string,
+  proposalDescription: string,
+  proposalType: string,
+): string {
+  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: {
+  proposalTitle?: string;
+  proposalDescription?: string;
+  proposalType?: string;
+}): ResearcherMemoryContext | null {
+  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: ResearcherMemoryContext = {
+    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: ResearcherMemoryContext,
+): string[] {
+  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: ResearcherMemoryContext): string {
+  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/src/mcps/researcher.server.ts

@@ -13,6 +13,11 @@ 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";
 
 interface SearchResult {
@@ -452,20 +457,40 @@ class XrayLibrarianServer extends XrayKnowledgeSkillBase {
   async analyzeProposal(args: AnalyzeProposalArgs): Promise<CallToolResult> {
     const { proposalTitle = "", proposalDescription = "", evidence = [], proposalType = "" } = args || {};
 
+    const memoryContext = resolveResearcherMemoryContext({
+      proposalTitle,
+      proposalDescription,
+      proposalType,
+    });
+
+    const enrichedEvidence = [...(evidence || [])];
+    if (memoryContext?.confidence.highConfidenceTrapPresent) {
+      enrichedEvidence.push(...buildMemoryRoutingEvidence(memoryContext));
+    }
+
     const vote = await tryLLMGovernance(
       "researcher",
       proposalTitle || "",
       proposalDescription || "",
-      evidence || [],
+      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}`,
           },
         ],
       };
@@ -475,7 +500,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/src/opencode/codex.codex

@@ -1,5 +1,5 @@
 {
-  "version": "3.2.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
   ],