0xray 3.5.5 → 4.0.1

package/vendor/@0xray/repertoire/docs/MEMORY-ROUTING-PROVIDER.md

@@ -0,0 +1,54 @@
+# Implementing a Custom MemoryRoutingProvider
+
+0xRay loads memory routing providers dynamically. Repertoire is the reference implementation.
+
+## Contract
+
+Export from your package:
+
+```typescript
+export function createMemoryRoutingProvider(
+  config?: Record<string, unknown>
+): MemoryRoutingProvider
+```
+
+Interface (mirror of `xray/src/memory-routing/types.ts`):
+
+| Method | Purpose |
+|--------|---------|
+| `isAvailable()` | Whether provider data is reachable |
+| `buildRoutingContext(operation)` | Match signals/tags for an operation |
+| `enhanceAgentCapabilities(map)` | Add memory dimensions to agents |
+| `enrichTasks(tasks)` | Attach metadata before planning |
+| `buildInheritedContext(tasks)` | Context for AsideContext |
+| `selectAgent(...)` | Signal-aware agent selection |
+| `resolveThinDispatch(...)` | Adjust score + agent override |
+| `ingestFeedback?(entry)` | Close feedback loop |
+
+## 0xRay Configuration
+
+In `xray/features.json` or `.xray/features.json`:
+
+```json
+"memory_routing": {
+  "enabled": true,
+  "provider": "custom",
+  "module_path": "../your-provider/dist/memory-routing-provider.js",
+  "config": {}
+}
+```
+
+Set `provider: "null"` to disable without removing config.
+
+## Repertoire as Provider
+
+```json
+"memory_routing": {
+  "enabled": true,
+  "provider": "repertoire",
+  "module_path": "../repertoire/dist/provider/memory-routing-provider.js",
+  "config": {
+    "signalsPath": "../repertoire/data/curated_signals.json"
+  }
+}
+```

package/vendor/@0xray/repertoire/hermes-mcp.example.json

@@ -0,0 +1,20 @@
+{
+  "mcpServers": {
+    "repertoire": {
+      "command": "npx",
+      "args": ["-y", "@0xray/repertoire", "mcp"]
+    },
+    "xray-researcher": {
+      "command": "npx",
+      "args": ["-y", "0xray", "mcp", "researcher"]
+    },
+    "xray-architect-tools": {
+      "command": "npx",
+      "args": ["-y", "0xray", "mcp", "architect-tools"]
+    },
+    "xray-governance": {
+      "command": "npx",
+      "args": ["-y", "0xray", "mcp", "governance"]
+    }
+  }
+}

package/vendor/@0xray/repertoire/mcp-config.example.json

@@ -0,0 +1,11 @@
+{
+  "mcpServers": {
+    "repertoire": {
+      "command": "node",
+      "args": ["/absolute/path/to/repertoire/dist/mcp/server.js"],
+      "env": {
+        "CURATED_SIGNALS_PATH": "/absolute/path/to/repertoire/data/curated_signals.json"
+      }
+    }
+  }
+}

package/vendor/@0xray/repertoire/package.json

@@ -0,0 +1,124 @@
+{
+  "name": "@0xray/repertoire",
+  "version": "0.2.0",
+  "description": "Factory memory organ for 0xRay — seed primitives, memory routing, extra MCP",
+  "type": "module",
+  "license": "MIT",
+  "readme": "README.md",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/0xRayAI/repertoire.git"
+  },
+  "homepage": "https://github.com/0xRayAI/repertoire#readme",
+  "bugs": {
+    "url": "https://github.com/0xRayAI/repertoire/issues"
+  },
+  "keywords": [
+    "0xray",
+    "repertoire",
+    "mcp",
+    "memory-routing",
+    "orchestration",
+    "groover",
+    "agent",
+    "governance"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json",
+    "./provider/memory-routing-provider": {
+      "types": "./dist/provider/memory-routing-provider.d.ts",
+      "import": "./dist/provider/memory-routing-provider.js"
+    }
+  },
+  "bin": {
+    "repertoire-mcp": "./dist/mcp/server.js",
+    "repertoire-verify-suit": "./scripts/verify-grok-suit.mjs"
+  },
+  "files": [
+    "dist/",
+    "scripts/verify-grok-suit.mjs",
+    "scripts/verify-synthesis-dogfood.mjs",
+    "scripts/run-live-synthesis-checkpoint.mjs",
+    "scripts/suit-bridge-shared.mjs",
+    "scripts/confirm-suit-harness.mjs",
+    "scripts/confirm-suit-all.mjs",
+    "scripts/verify-hermes-suit.mjs",
+    "scripts/verify-opencode-suit.mjs",
+    "scripts/verify-openclaw-suit.mjs",
+    "data/curated_signals.json",
+    "schemas/",
+    "skills/repertoire-trap-handling/",
+    "docs/MEMORY-ROUTING-PROVIDER.md",
+    "hermes-mcp.example.json",
+    "mcp-config.example.json",
+    "AGENTS.md",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build && npm test && node scripts/consumer-install-smoke.mjs",
+    "pack:check": "npm run build && node scripts/consumer-install-smoke.mjs && npm pack --dry-run",
+    "ingest": "node --import tsx scripts/ingest.ts",
+    "health:repertoire": "node --import tsx scripts/repertoire-health.ts",
+    "signals:hygiene": "node --import tsx scripts/signals-hygiene.ts",
+    "enrich": "node --import tsx scripts/enrich-repertoire.ts",
+    "ingest:moltbook-agents": "node --import tsx scripts/ingest-moltbook-agents.ts",
+    "meta-inference": "node --import tsx scripts/run-meta-inference.ts",
+    "pipeline": "node --import tsx scripts/run-pipeline.ts",
+    "feedback-cycle": "node --import tsx scripts/run-feedback-cycle.ts",
+    "query": "node --import tsx scripts/query-signals.ts",
+    "mcp": "node dist/mcp/server.js",
+    "test": "vitest run",
+    "test:e2e": "vitest run scripts/e2e-confidence-loop.test.ts",
+    "test:mcp": "npm run build && vitest run scripts/test-mcp-stdio.test.ts",
+    "test:trap-routing": "npm run build && vitest run --config vitest.trap-routing.config.ts",
+    "verify:suit": "npm run build && node scripts/verify-grok-suit.mjs",
+    "verify:synthesis-dogfood": "npm run build && node scripts/verify-synthesis-dogfood.mjs",
+    "synthesis:live": "node scripts/run-live-synthesis-checkpoint.mjs",
+    "verify:grok-delegation-gate": "node node_modules/0xray/scripts/mjs/verify-grok-delegation-gate.mjs",
+    "confirm:suit": "npm run verify:suit && npm run verify:synthesis-dogfood && node scripts/confirm-suit-harness.mjs && npm run test:trap-routing",
+    "verify:suit:all": "npm run build && node scripts/confirm-suit-all.mjs",
+    "confirm:suit:all": "npm run build && node scripts/confirm-suit-all.mjs --install --grok-harness && npm run test:trap-routing",
+    "confirm:suit:full": "npm run build && node scripts/confirm-suit-all.mjs --install --grok-harness --pipeline-audit && npm run test:trap-routing",
+    "verify:pipeline-facets": "npm run build --prefix node_modules/0xray 2>/dev/null || npm run build && node node_modules/0xray/scripts/mjs/verify-pipeline-facets.mjs",
+    "install:bridges": "npx 0xray grok install --force && npx 0xray hermes install --force && npx 0xray opencode install --force && npx 0xray openclaw install --force",
+    "verify:hermes": "node scripts/verify-hermes-suit.mjs",
+    "verify:opencode": "node scripts/verify-opencode-suit.mjs",
+    "verify:openclaw": "node scripts/verify-openclaw-suit.mjs",
+    "confirm:hermes": "npm run build && npx 0xray hermes install --force && npm run verify:hermes",
+    "confirm:opencode": "npm run build && npx 0xray opencode install --force && npm run verify:opencode",
+    "confirm:openclaw": "npm run build && npx 0xray openclaw install --force && npm run verify:openclaw",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0"
+  },
+  "peerDependencies": {
+    "0xray": ">=3.5.5"
+  },
+  "peerDependenciesMeta": {
+    "0xray": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "0xray": "file:../xray",
+    "@types/node": "^22.15.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.6.0",
+    "vitest": "^4.1.8"
+  }
+}

package/vendor/@0xray/repertoire/schemas/curated-signal.schema.json

@@ -0,0 +1,68 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://repertoire.0xray.ai/schemas/curated-signal.schema.json",
+  "title": "CuratedSignal",
+  "type": "object",
+  "required": [
+    "name",
+    "definition",
+    "tags",
+    "priority",
+    "evaluation_criteria",
+    "validation_experiment",
+    "master_index_integration",
+    "implementation_notes"
+  ],
+  "properties": {
+    "name": {
+      "type": "string",
+      "pattern": "^[a-z0-9][a-z0-9_-]*$",
+      "description": "Kebab-case primitive identifier"
+    },
+    "definition": {
+      "type": "string",
+      "minLength": 10
+    },
+    "example_inference_snippet": {
+      "type": "string"
+    },
+    "tags": {
+      "type": "array",
+      "items": { "type": "string" },
+      "minItems": 1
+    },
+    "batches": {
+      "type": "array",
+      "items": { "type": "integer", "minimum": 1 }
+    },
+    "first_seen": {
+      "type": "string",
+      "format": "date"
+    },
+    "status": {
+      "type": "string",
+      "enum": ["proposed", "validated", "integrated", "deprecated"]
+    },
+    "priority": {
+      "type": "string",
+      "enum": ["high", "medium", "low"]
+    },
+    "evaluation_criteria": {
+      "type": "string",
+      "minLength": 10
+    },
+    "validation_experiment": {
+      "type": "string",
+      "minLength": 10
+    },
+    "master_index_integration": {
+      "type": "string",
+      "minLength": 10
+    },
+    "implementation_notes": {
+      "type": "string",
+      "minLength": 10
+    }
+  },
+  "additionalProperties": false
+}

package/vendor/@0xray/repertoire/schemas/inference-log.schema.json

@@ -0,0 +1,82 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://repertoire.0xray.ai/schemas/inference-log.schema.json",
+  "title": "InferenceLogEntry",
+  "type": "object",
+  "required": ["timestamp", "source", "inference"],
+  "properties": {
+    "timestamp": {
+      "type": "string",
+      "format": "date-time"
+    },
+    "source": {
+      "type": "string",
+      "enum": ["groover", "xray", "dynamo", "orchestrator"]
+    },
+    "post_id": { "type": "string" },
+    "post_title": { "type": "string" },
+    "comment_id": { "type": "string" },
+    "session_id": { "type": "string" },
+    "inference": {
+      "type": "string",
+      "minLength": 1
+    },
+    "public_reply": { "type": "string" },
+    "inference_type": {
+      "type": "string",
+      "enum": [
+        "theoretical",
+        "temporal-drift",
+        "practical-workflow",
+        "ontological-trap",
+        "provenance-failure"
+      ]
+    },
+    "matched_primitives": {
+      "type": "array",
+      "items": { "type": "string" }
+    },
+    "match_confidence": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "number",
+        "minimum": 0,
+        "maximum": 1
+      }
+    },
+    "governance_forced": {
+      "type": "boolean"
+    },
+    "dynamo_result": {
+      "type": "object",
+      "properties": {
+        "result": {
+          "oneOf": [
+            { "type": "null" },
+            {
+              "type": "object",
+              "properties": {
+                "recommendation": {
+                  "type": "string",
+                  "enum": ["PASS", "NEEDS_REVISION", "REJECT"]
+                },
+                "resonanceScore": { "type": "number", "minimum": 0, "maximum": 1 }
+              }
+            }
+          ]
+        },
+        "matchedPrimitives": {
+          "type": "array",
+          "items": { "type": "string" }
+        },
+        "error": { "type": "string" },
+        "status": { "type": "integer" }
+      }
+    },
+    "repertoire_signals": {
+      "type": "array",
+      "items": { "type": "string" }
+    }
+  },
+  "additionalProperties": true
+}

package/vendor/@0xray/repertoire/scripts/confirm-suit-all.mjs

@@ -0,0 +1,253 @@
+#!/usr/bin/env node
+/**
+ * Unified 0xRay suit wear matrix — all 4 plugin environments.
+ *
+ * Usage:
+ *   node scripts/confirm-suit-all.mjs              # verify all bridges (no install)
+ *   node scripts/confirm-suit-all.mjs --install    # native 0xray install + verify
+ *   node scripts/confirm-suit-all.mjs --grok-harness  # include Grok Layer 2a/2c harness
+ *   node scripts/confirm-suit-all.mjs --only=hermes,opencode
+ *
+ * npm scripts:
+ *   verify:suit:all   — matrix verify only
+ *   confirm:suit:all  — build + install all + verify + Grok harness + trap-routing test
+ */
+import { execSync, spawnSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve, join } from 'node:path';
+import { HERMES_PLUGIN_DIR, readInstalledXrayVersion } from './suit-bridge-shared.mjs';
+
+const root = resolve(import.meta.dirname, '..');
+const args = process.argv.slice(2);
+
+const flags = {
+  install: args.includes('--install'),
+  grokHarness: args.includes('--grok-harness'),
+  verifyOnly: args.includes('--verify-only'),
+  pipelineAudit: args.includes('--pipeline-audit'),
+};
+const onlyArg = args.find((a) => a.startsWith('--only='));
+const onlySet = onlyArg
+  ? new Set(onlyArg.slice('--only='.length).split(',').map((s) => s.trim().toLowerCase()))
+  : null;
+
+/** Hermes last — consumer root marker must win over any stale npx-cache path. */
+const BRIDGES = [
+  {
+    id: 'grok',
+    label: 'Grok Build',
+    cli: null,
+    installCmd: 'npx 0xray grok install --force',
+    verifyScript: 'verify-grok-suit.mjs',
+    harnessScript: 'confirm-suit-harness.mjs',
+  },
+  {
+    id: 'opencode',
+    label: 'OpenCode',
+    cli: 'opencode',
+    installCmd: 'npx 0xray opencode install --force',
+    verifyScript: 'verify-opencode-suit.mjs',
+  },
+  {
+    id: 'openclaw',
+    label: 'OpenClaw',
+    cli: 'openclaw',
+    installCmd: 'npx 0xray openclaw install --force',
+    verifyScript: 'verify-openclaw-suit.mjs',
+  },
+  {
+    id: 'hermes',
+    label: 'Hermes',
+    cli: 'hermes',
+    installCmd: 'npx 0xray hermes install --force',
+    verifyScript: 'verify-hermes-suit.mjs',
+  },
+];
+
+function ensureHermesConsumerRoot() {
+  const markerPath = join(HERMES_PLUGIN_DIR, 'xray-consumer-root.txt');
+  if (!existsSync(markerPath)) return;
+  const marked = readFileSync(markerPath, 'utf8').trim();
+  if (marked === root) return;
+  if (!cliAvailable('hermes')) return;
+  console.log(`⚠  Hermes consumer root drift (${marked}) — re-running hermes install\n`);
+  runInstall('npx 0xray hermes install --force');
+}
+
+function bridgeEnabled(bridge) {
+  return !onlySet || onlySet.has(bridge.id);
+}
+
+function cliAvailable(cmd) {
+  if (!cmd) return true;
+  try {
+    execSync(`which ${cmd}`, { encoding: 'utf8', stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function runScript(scriptName, { inheritOutput = true } = {}) {
+  const scriptPath = join(root, 'scripts', scriptName);
+  if (!existsSync(scriptPath)) {
+    return { ok: false, status: 'error', detail: `${scriptName} missing` };
+  }
+  const result = spawnSync('node', [scriptPath], {
+    cwd: root,
+    encoding: 'utf8',
+    stdio: inheritOutput ? 'inherit' : ['inherit', 'pipe', 'pipe'],
+  });
+  const combined = `${result.stdout ?? ''}${result.stderr ?? ''}`;
+  const failCount = (combined.match(/❌/g) ?? []).length;
+  return {
+    ok: result.status === 0,
+    status: result.status === 0 ? 'green' : 'red',
+    detail: result.status === 0 ? 'wearable' : `${failCount || 1} check(s) failed`,
+    exitCode: result.status ?? 1,
+  };
+}
+
+function runInstall(cmd) {
+  try {
+    execSync(cmd, { cwd: root, stdio: 'inherit' });
+    return { ok: true };
+  } catch (e) {
+    return { ok: false, detail: e.message?.slice(0, 120) ?? 'install failed' };
+  }
+}
+
+console.log('═══ 0xRay Suit Wear Matrix (4 plugin environments) ═══\n');
+console.log(`0xray@${readInstalledXrayVersion()} · consumer ${root}\n`);
+
+if (flags.install) {
+  console.log('Phase 0 — Native bridge install (--install)\n');
+  for (const bridge of BRIDGES) {
+    if (!bridgeEnabled(bridge)) continue;
+    if (bridge.cli && !cliAvailable(bridge.cli)) {
+      console.log(`⏭  ${bridge.label} install skipped — ${bridge.cli} not on PATH`);
+      continue;
+    }
+    console.log(`→ ${bridge.installCmd}`);
+    const install = runInstall(bridge.installCmd);
+    if (!install.ok) {
+      console.error(`❌ ${bridge.label} install failed — ${install.detail}`);
+    }
+  }
+  ensureHermesConsumerRoot();
+  console.log('');
+}
+
+const matrix = [];
+
+console.log('Phase 1 — Per-bridge verification\n');
+for (const bridge of BRIDGES) {
+  if (!bridgeEnabled(bridge)) continue;
+
+  if (bridge.cli && !cliAvailable(bridge.cli)) {
+    matrix.push({
+      id: bridge.id,
+      label: bridge.label,
+      status: 'skip',
+      detail: `${bridge.cli} not on PATH`,
+    });
+    console.log(`⏭  ${bridge.label} — skipped (${bridge.cli} not installed)\n`);
+    continue;
+  }
+
+  console.log(`── ${bridge.label} (${bridge.verifyScript}) ──\n`);
+  const verify = runScript(bridge.verifyScript);
+  matrix.push({
+    id: bridge.id,
+    label: bridge.label,
+    status: verify.status,
+    detail: verify.detail,
+  });
+  console.log('');
+}
+
+let grokHarnessOk = null;
+if (flags.grokHarness && bridgeEnabled(BRIDGES[0])) {
+  console.log('Phase 2 — Grok harness (Layer 2a + 2c stdio probes)\n');
+  const harnessResult = spawnSync(
+    'node',
+    [join(root, 'scripts', 'confirm-suit-harness.mjs'), '--skip-layer1'],
+    { cwd: root, encoding: 'utf8', stdio: 'inherit' },
+  );
+  const harness = {
+    ok: harnessResult.status === 0,
+    detail: harnessResult.status === 0 ? 'automated probes pass' : 'harness probe(s) failed',
+  };
+  grokHarnessOk = harness.ok;
+  if (!harness.ok) {
+    matrix.push({
+      id: 'grok-harness',
+      label: 'Grok harness (2a/2c)',
+      status: 'red',
+      detail: harness.detail,
+    });
+  } else {
+    matrix.push({
+      id: 'grok-harness',
+      label: 'Grok harness (2a/2c)',
+      status: 'green',
+      detail: 'automated probes pass',
+    });
+  }
+  console.log('');
+}
+
+// ── Wear matrix verdict ─────────────────────────────────────────────────────
+console.log('Suit wear matrix\n');
+const statusIcon = { green: '✅', red: '❌', skip: '⏭ ' };
+for (const row of matrix) {
+  const icon = statusIcon[row.status] ?? '?';
+  console.log(`  ${icon} ${row.label.padEnd(22)} ${row.detail}`);
+}
+
+const verified = matrix.filter((r) => r.status !== 'skip');
+const allGreen = verified.length > 0 && verified.every((r) => r.status === 'green');
+const anyRed = verified.some((r) => r.status === 'red');
+const skipped = matrix.filter((r) => r.status === 'skip').length;
+
+console.log(`
+Summary
+  Green:   ${verified.filter((r) => r.status === 'green').length}/${verified.length}
+  Skipped: ${skipped} (CLI not on PATH)
+  0xray:   ${readInstalledXrayVersion()}
+
+Verdict
+  FULL    = all enabled bridges green${flags.grokHarness ? ' + Grok harness green' : ''}
+  PARTIAL = Grok green + ≥1 other bridge red/skipped
+  BROKEN  = Grok red OR core MCP surface unreachable
+
+Grok Layer 2b (harness CallMcpTool) is agent-verified after reboot — see confirm-suit-harness.mjs.
+`);
+
+if (anyRed) {
+  console.error('❌ Suit wear matrix FAILED — fix red bridges before operating.');
+  process.exit(1);
+}
+
+if (flags.grokHarness && grokHarnessOk === false) {
+  console.error('❌ Grok harness FAILED — memory routing / stdio probes not ready.');
+  process.exit(1);
+}
+
+if (flags.pipelineAudit) {
+  console.log('Phase 3 — Pipeline facet verify\n');
+  const pipelineScript = join(root, 'node_modules', '0xray', 'scripts', 'mjs', 'verify-pipeline-facets.mjs');
+  const pipelineResult = spawnSync('node', [pipelineScript], {
+    cwd: root,
+    encoding: 'utf8',
+    stdio: 'inherit',
+  });
+  if (pipelineResult.status !== 0) {
+    console.error('❌ Pipeline facet verify FAILED');
+    process.exit(1);
+  }
+  console.log('');
+}
+
+console.log('✅ Suit wear matrix PASS — all verified bridges wearable.');
+process.exit(0);