0xray 3.5.4 → 4.0.0

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);

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

@@ -0,0 +1,220 @@
+#!/usr/bin/env node
+/**
+ * Grok Build harness confirmation protocol (Layers 2a/2c + 2b checklist).
+ *
+ * Invoked by:
+ *   npm run confirm:suit          — full Grok confirm (Layer 1 via verify:suit + this harness + trap test)
+ *   npm run confirm:suit:all      — all 4 bridges + this harness for Grok deep probes
+ *
+ * Layer 1: filesystem + CLI (verify-grok-suit.mjs) — run separately or via confirm:suit
+ * Layer 2a: stdio MCP probes (repertoire memory routing — bypasses harness prefix bug)
+ * Layer 2b: harness MCP probes (agent runs CallMcpTool live — documented below)
+ */
+import { spawn } from 'node:child_process';
+import { execSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve, join } from 'node:path';
+import { readInstalledXrayVersion } from './suit-bridge-shared.mjs';
+
+const root = resolve(import.meta.dirname, '..');
+const skipLayer1 = process.argv.includes('--skip-layer1');
+
+function resolveResearcherServerPath() {
+  const sibling = resolve(root, '../xray/dist/mcps/researcher.server.js');
+  if (existsSync(sibling)) return sibling;
+  return resolve(root, 'node_modules/0xray/dist/mcps/researcher.server.js');
+}
+
+const TRAP_PROBE_DESCRIPTION =
+  'TYPE: ontological-trap attestation-as-map consumer-boundary revalidation required';
+
+function mcpStdioProbe({ serverPath, toolName, args, timeoutMs = 4000 }) {
+  return new Promise((resolveProbe, rejectProbe) => {
+    const messages = [
+      {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'initialize',
+        params: {
+          protocolVersion: '2024-11-05',
+          capabilities: {},
+          clientInfo: { name: 'confirm-suit-harness', version: '1.0' },
+        },
+      },
+      {
+        jsonrpc: '2.0',
+        id: 2,
+        method: 'tools/call',
+        params: { name: toolName, arguments: args },
+      },
+    ];
+
+    const proc = spawn('node', [serverPath], { cwd: root, stdio: ['pipe', 'pipe', 'pipe'] });
+    let out = '';
+    proc.stdout.on('data', (chunk) => {
+      out += chunk.toString();
+    });
+    proc.stderr.on('data', (chunk) => {
+      out += chunk.toString();
+    });
+
+    const timer = setTimeout(() => {
+      proc.kill();
+      rejectProbe(new Error(`timeout after ${timeoutMs}ms`));
+    }, timeoutMs);
+
+    proc.on('close', (code) => {
+      clearTimeout(timer);
+      if (code !== null && code !== 0 && !out.includes('"result"')) {
+        rejectProbe(new Error(`exit ${code}: ${out.slice(0, 200)}`));
+        return;
+      }
+      resolveProbe(out);
+    });
+
+    for (const msg of messages) {
+      proc.stdin.write(`${JSON.stringify(msg)}\n`);
+    }
+    setTimeout(() => proc.kill('SIGTERM'), timeoutMs - 200);
+  });
+}
+
+console.log('═══ 0xRay Suit Confirmation Protocol ═══\n');
+
+// ── Layer 1 ──────────────────────────────────────────────────────────────────
+let layer1Ok = skipLayer1;
+if (skipLayer1) {
+  console.log('Layer 1 — Skipped (--skip-layer1; already verified by confirm-suit-all)\n');
+} else {
+  console.log('Layer 1 — Local install (automated)\n');
+  try {
+    execSync('node scripts/verify-grok-suit.mjs', { cwd: root, stdio: 'inherit' });
+    layer1Ok = true;
+  } catch {
+    console.error('\n❌ Layer 1 FAILED — fix before harness probes\n');
+    process.exit(1);
+  }
+}
+
+// ── Layer 2a — stdio probes ──────────────────────────────────────────────────
+console.log('\nLayer 2a — Stdio MCP probes (automated)\n');
+const layer2a = [];
+
+const repertoireServer = resolve(root, 'dist/mcp/server.js');
+if (!existsSync(repertoireServer)) {
+  console.error('❌ repertoire stdio — dist/mcp/server.js missing (run npm run build)');
+  layer2a.push({ name: 'repertoire stdio', ok: false });
+} else {
+  try {
+    const out = await mcpStdioProbe({
+      serverPath: repertoireServer,
+      toolName: 'get_task_confidence',
+      args: { description: 'Confirm 0xRay suit worn after reboot' },
+    });
+    const ok =
+      out.includes('repertoire__get_task_confidence') ||
+      out.includes('recommendedAgent') ||
+      out.includes('highConfidenceTrapPresent');
+    layer2a.push({ name: 'repertoire__get_task_confidence (stdio)', ok });
+    console.log(ok ? '✅ repertoire__get_task_confidence (stdio)' : '❌ repertoire stdio — unexpected response');
+  } catch (e) {
+    layer2a.push({ name: 'repertoire stdio', ok: false });
+    console.error(`❌ repertoire stdio — ${e.message}`);
+  }
+}
+
+// ── Layer 2c — researcher trap routing (MCP subprocess) ───────────────────
+console.log('\nLayer 2c — Researcher trap routing e2e (automated)\n');
+const layer2c = [];
+
+const researcherServer = resolveResearcherServerPath();
+if (!existsSync(researcherServer)) {
+  console.error('❌ researcher stdio — server missing');
+  layer2c.push({ name: 'researcher trap routing', ok: false });
+} else {
+  try {
+    let ok = false;
+    let lastOut = '';
+    for (let attempt = 0; attempt < 6 && !ok; attempt++) {
+      if (attempt > 0) await new Promise((r) => setTimeout(r, 500));
+      lastOut = await mcpStdioProbe({
+        serverPath: researcherServer,
+        toolName: 'analyze_proposal',
+        args: {
+          proposalTitle: 'Trap governance review',
+          proposalDescription: TRAP_PROBE_DESCRIPTION,
+          proposalType: 'governance',
+        },
+        timeoutMs: 8000,
+      });
+      ok =
+        lastOut.includes('MEMORY_ROUTING:') &&
+        lastOut.includes('recommendedAgent: architect') &&
+        lastOut.includes('attestation-as-map');
+    }
+    layer2c.push({ name: 'analyze_proposal trap routing (stdio)', ok });
+    console.log(
+      ok
+        ? '✅ analyze_proposal trap routing (stdio)'
+        : '❌ researcher trap routing — silent no-op (MEMORY_ROUTING missing)',
+    );
+    if (!ok) {
+      console.error(`   Response snippet: ${lastOut.slice(0, 240)}`);
+    }
+  } catch (e) {
+    layer2c.push({ name: 'researcher trap routing', ok: false });
+    console.error(`❌ researcher trap routing — ${e.message}`);
+  }
+}
+
+// ── Layer 2b — harness checklist (agent-verified) ──────────────────────────
+console.log('\nLayer 2b — Harness MCP probes (agent CallMcpTool after reboot)\n');
+const harnessProbes = [
+  { server: 'xray-enforcer', tool: 'get-enforcement-status', key: 'totalRules' },
+  { server: 'xray-enforcer', tool: 'codex-enforcement', key: 'termsValidated', args: { operation: 'suit-probe' } },
+  { server: 'xray-skills', tool: 'list-skills', key: 'Skills' },
+  { server: 'xray-orchestrator', tool: 'analyze-complexity', key: 'Complexity', args: { tasks: [{ description: 'suit probe', type: 'verification' }] } },
+  { server: 'xray-governance', tool: 'get_active_codex', key: 'term_count' },
+  { server: 'xray-researcher', tool: 'get_documentation', key: 'Documentation', args: { target: 'RepertoireService' } },
+  { server: 'xray-architect-tools', tool: 'context-analysis', key: 'codebaseStructure', args: { query: 'suit probe' } },
+  { server: 'xray-code-review', tool: 'check_best_practices', key: 'Compliance', args: { filePath: `${root}/src/mcp/server.ts`, language: 'typescript' } },
+  { server: 'Dynamo', tool: 'get_docs', key: 'docs' },
+  {
+    server: 'repertoire',
+    tool: 'get_task_confidence',
+    key: 'harness-broken',
+    note: 'harness double-prefixes repertoire__ — use Layer 2a stdio instead',
+  },
+];
+
+for (const p of harnessProbes) {
+  const note = p.note ? ` (${p.note})` : '';
+  console.log(`  □ ${p.server} → ${p.tool}${note}`);
+}
+
+// ── Layer 3 — verdict ────────────────────────────────────────────────────────
+const layer2aOk = layer2a.every((c) => c.ok);
+const layer2cOk = layer2c.every((c) => c.ok);
+console.log(`
+Layer 3 — Suit worn verdict (automated portion)
+  Layer 1: ${layer1Ok ? 'GREEN' : 'RED'}
+  Layer 2a repertoire stdio: ${layer2aOk ? 'GREEN' : 'RED'}
+  Layer 2c researcher trap routing: ${layer2cOk ? 'GREEN' : 'RED'}
+
+  FULL    = Layer 1 + 2a + 2c green + all Layer 2b harness probes respond
+  PARTIAL = Layer 1 green + core harness MCPs live (enforcer, skills, orchestrator, governance, Dynamo)
+  BROKEN  = Layer 1 fails OR core MCPs unreachable
+
+Harness note: repertoire tools are registered as repertoire__* — Grok harness prepends
+server name again (repertoire__repertoire__*). Memory routing works via stdio (Layer 2a/2c).
+
+Version: npm 0xray@${readInstalledXrayVersion()} from node_modules (no npm link)
+`);
+
+if (layer1Ok && layer2aOk && layer2cOk) {
+  console.log('✅ Automated checks PASS — agent should confirm Layer 2b harness probes for FULL verdict.');
+  process.exit(0);
+}
+
+console.error('❌ Automated checks FAILED — suit not ready.');
+process.exit(1);