0xray 3.3.0 → 3.3.1

package/src/mcps/knowledge-skills/storyteller.server.ts

@@ -0,0 +1,206 @@
+/**
+ * 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'] as const;
+type StoryType = (typeof STORY_TYPES)[number];
+
+interface WriteStoryArgs {
+  title?: string;
+  context?: Record<string, unknown>;
+  framework?: string;
+  output?: string;
+}
+
+function resolveSkillMd(): string {
+  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: StoryType) {
+  const defaults: Record<
+    StoryType,
+    { location: string; min_words: number; ideal_words: number; framework: string }
+  > = {
+    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(): string {
+  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: StoryType,
+  title: string,
+  meta: ReturnType<typeof getStoryMeta>,
+  extraContext?: Record<string, unknown>,
+): string {
+  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: StoryType, args: WriteStoryArgs) {
+  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' as const,
+        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' as const,
+      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 as WriteStoryArgs),
+      write_saga: async (args) => writeStoryTool('saga', args as WriteStoryArgs),
+      write_journey: async (args) => writeStoryTool('journey', args as WriteStoryArgs),
+      write_narrative: async (args) => writeStoryTool('narrative', args as WriteStoryArgs),
+    };
+
+    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/src/mcps/orchestrator/execution/execution-planner.ts

@@ -213,15 +213,18 @@ export class ExecutionPlanner {
     agentAssignments: Map<string, OrchestrationTask[]>
   ): void {
     for (const task of tasks) {
-      const complexity = task.estimatedComplexity || 30;
+      const complexity = this.calculateTaskComplexity(task);
       const requiredCaps = [
         task.type,
         ...(task.metadata?.memorySignals ?? []),
       ];
+      const operationDescription = task.metadata?.memoryHighConfidenceTrap
+        ? `${task.description} TYPE: ontological-trap`
+        : task.description;
       const agent = this.capabilitiesManager.selectAgentForTask(
         requiredCaps,
         complexity,
-        task.description,
+        operationDescription,
       ) || 'orchestrator';
 
       if (!agentAssignments.has(agent)) {
@@ -346,6 +349,15 @@ export class ExecutionPlanner {
       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/src/mcps/orchestrator/types.ts

@@ -19,6 +19,10 @@ export interface OrchestrationTaskMetadata {
   synthesisContext?: string;
   ontologicalTrapDetected?: boolean;
   memoryProviderId?: string;
+  memorySignalConfidences?: Record<string, number>;
+  memoryAvgConfidence?: number;
+  memoryHighConfidenceTrap?: boolean;
+  memoryComplexityBoost?: number;
 }
 
 export interface OrchestrationTask {

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.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
   ],