0xray 3.5.5 → 4.0.0

package/vendor/@0xray/repertoire/scripts/verify-hermes-suit.mjs

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+/**
+ * Verify Hermes suit bridge for this consumer repo.
+ * Run: node scripts/verify-hermes-suit.mjs
+ */
+import { execSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import {
+  HERMES_CONFIG_PATH,
+  HERMES_PLUGIN_DIR,
+  REPERTOIRE_MCP,
+  XRAY_MCP_SERVERS,
+  ensureConsumerRootMarker,
+} from './suit-bridge-shared.mjs';
+
+const root = resolve(import.meta.dirname, '..');
+ensureConsumerRootMarker(
+  join(HERMES_PLUGIN_DIR, 'xray-consumer-root.txt'),
+  'npx 0xray hermes install --force',
+);
+let failed = 0;
+
+function pass(name, detail = '') {
+  console.log(`✅ ${name}${detail ? ` — ${detail}` : ''}`);
+}
+
+function fail(name, detail = '') {
+  failed++;
+  console.error(`❌ ${name}${detail ? ` — ${detail}` : ''}`);
+}
+
+// 1. Hermes CLI
+try {
+  const hermesPath = execSync('which hermes', { encoding: 'utf8' }).trim();
+  pass('hermes cli', hermesPath);
+} catch {
+  fail('hermes cli', 'not on PATH');
+}
+
+// 2. Plugin installed
+const pluginYaml = join(HERMES_PLUGIN_DIR, 'plugin.yaml');
+existsSync(pluginYaml) ? pass('xray-hermes plugin', HERMES_PLUGIN_DIR) : fail('xray-hermes plugin', 'run: npx 0xray hermes install --force');
+
+// 3. Consumer root marker
+const markerPath = join(HERMES_PLUGIN_DIR, 'xray-consumer-root.txt');
+if (existsSync(markerPath)) {
+  const marked = readFileSync(markerPath, 'utf8').trim();
+  marked === root ? pass('consumer root marker', root) : fail('consumer root marker', `got ${marked}`);
+} else {
+  fail('consumer root marker', 'missing');
+}
+
+// 4. Plugin enabled
+try {
+  const plugins = execSync('hermes plugins list 2>&1', { encoding: 'utf8' })
+    .replace(/\x1b\[[0-9;]*m/g, '');
+  const enabledLine = plugins.split('\n').find((line) => /│\s*0xray-hermes\b/.test(line));
+  if (enabledLine?.includes('enabled') && !enabledLine.includes('not enabled')) {
+    pass('0xray-hermes plugin enabled');
+  } else {
+    fail('0xray-hermes plugin enabled', 'run: hermes plugins enable 0xray-hermes');
+  }
+} catch (e) {
+  fail('0xray-hermes plugin enabled', e.message?.slice(0, 120));
+}
+
+// 5. Plugin .mcp.json
+try {
+  const pluginMcp = JSON.parse(readFileSync(join(HERMES_PLUGIN_DIR, '.mcp.json'), 'utf8'));
+  const names = Object.keys(pluginMcp.mcpServers ?? {});
+  const xrayCount = names.filter((n) => n.startsWith('xray-')).length;
+  if (xrayCount === 7) pass('plugin .mcp.json xray servers', '7/7');
+  else fail('plugin .mcp.json xray servers', `${xrayCount}/7`);
+} catch (e) {
+  fail('plugin .mcp.json', e.message);
+}
+
+// 6. Hermes config mcp_servers
+try {
+  const listScript = join(root, 'scripts', 'list-hermes-mcp-servers.py');
+  const out = execSync(`python3 "${listScript}" "${HERMES_CONFIG_PATH}"`, { encoding: 'utf8' });
+  const { names } = JSON.parse(out.trim());
+  const xrayCount = names.filter((n) => n.startsWith('xray-')).length;
+  if (xrayCount === 7) pass('config.yaml mcp_servers xray', '7/7');
+  else fail('config.yaml mcp_servers xray', `${xrayCount}/7`);
+  names.includes(REPERTOIRE_MCP.name)
+    ? pass('config.yaml mcp_servers repertoire')
+    : fail('config.yaml mcp_servers repertoire', 'missing');
+} catch (e) {
+  fail('config.yaml mcp_servers', e.message?.slice(0, 160));
+}
+
+// 7. Bridge health
+try {
+  const out = execSync(
+    `printf '%s' '{"command":"health"}' | node "${join(HERMES_PLUGIN_DIR, 'bridge.mjs')}" --cwd "${root}"`,
+    { encoding: 'utf8', cwd: root, env: { ...process.env, XRAY_ROOT: root } },
+  );
+  const health = JSON.parse(out.trim());
+  if (health.framework === 'loaded') pass('bridge health', 'framework loaded');
+  else fail('bridge health', JSON.stringify(health).slice(0, 120));
+  if (health.projectRoot === root) pass('bridge projectRoot', root);
+  else fail('bridge projectRoot', `got ${health.projectRoot}`);
+} catch (e) {
+  fail('bridge health', e.message?.slice(0, 160));
+}
+
+// 8. .xray contract (shared with Grok)
+for (const f of ['codex.json', 'features.json', 'config.json']) {
+  existsSync(join(root, '.xray', f)) ? pass(`.xray/${f}`) : fail(`.xray/${f}`, 'missing');
+}
+
+// 9. MCP enforcer stdio (same surface Hermes mcp_servers uses)
+try {
+  const init = JSON.stringify({
+    jsonrpc: '2.0',
+    id: 1,
+    method: 'initialize',
+    params: {
+      protocolVersion: '2024-11-05',
+      capabilities: {},
+      clientInfo: { name: 'verify-hermes-suit', version: '1.0' },
+    },
+  });
+  const out = execSync(
+    `printf '%s\\n' '${init.replace(/'/g, "'\\''")}' | timeout 12 npx 0xray mcp enforcer 2>/dev/null | head -1`,
+    { cwd: root, encoding: 'utf8', shell: '/bin/bash' },
+  );
+  if (out.includes('serverInfo')) pass('MCP enforcer stdio probe');
+  else fail('MCP enforcer stdio probe', out.slice(0, 120));
+} catch (e) {
+  fail('MCP enforcer stdio probe', e.message?.slice(0, 160));
+}
+
+// 10. Plugin tool surface (plugin.yaml — live session loads on restart)
+try {
+  const pluginYaml = readFileSync(join(HERMES_PLUGIN_DIR, 'plugin.yaml'), 'utf8');
+  const pluginTools = ['xray_validate', 'xray_codex_check', 'xray_health', 'xray_hooks'];
+  const found = pluginTools.filter((t) => pluginYaml.includes(t));
+  if (found.length === pluginTools.length) pass('plugin tools (plugin.yaml)', pluginTools.join(', '));
+  else fail('plugin tools (plugin.yaml)', `found ${found.length}/4`);
+} catch (e) {
+  fail('plugin tools (plugin.yaml)', e.message?.slice(0, 120));
+}
+
+// 11. Delegation gate fixture (0xray@3.5.1+)
+const hermesGateScript = join(root, 'node_modules/0xray/scripts/mjs/verify-hermes-delegation-gate.mjs');
+if (existsSync(hermesGateScript)) {
+  try {
+    execSync(`node "${hermesGateScript}"`, { cwd: root, stdio: 'pipe', encoding: 'utf8' });
+    pass('Hermes delegation gate fixture', '4/4');
+  } catch (e) {
+    const detail = (e.stdout || e.stderr || e.message || '').split('\n').slice(-3).join(' ').slice(0, 160);
+    fail('Hermes delegation gate fixture', detail);
+  }
+} else {
+  fail('Hermes delegation gate fixture', 'missing script — npm install 0xray@^3.5.1');
+}
+
+console.log('\n' + (failed === 0 ? '🎉 Hermes suit wearable.' : `⚠️  ${failed} Hermes check(s) failed.`));
+process.exit(failed === 0 ? 0 : 1);

package/vendor/@0xray/repertoire/scripts/verify-openclaw-suit.mjs

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+/**
+ * Verify OpenClaw suit bridge for this consumer repo (native 0xray install).
+ */
+import { execSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { REPERTOIRE_MCP, XRAY_MCP_SERVERS, ensureConsumerRootMarker } from './suit-bridge-shared.mjs';
+
+const root = resolve(import.meta.dirname, '..');
+const OPENCLAW_STATE = join(homedir(), '.openclaw');
+ensureConsumerRootMarker(
+  join(OPENCLAW_STATE, 'xray-consumer-root.txt'),
+  'npx 0xray openclaw install --force',
+);
+const OPENCLAW_CONFIG = join(OPENCLAW_STATE, 'openclaw.json');
+let failed = 0;
+
+function pass(name, detail = '') {
+  console.log(`✅ ${name}${detail ? ` — ${detail}` : ''}`);
+}
+
+function fail(name, detail = '') {
+  failed++;
+  console.error(`❌ ${name}${detail ? ` — ${detail}` : ''}`);
+}
+
+// 1. OpenClaw CLI
+try {
+  const openclawPath = execSync('which openclaw', { encoding: 'utf8' }).trim();
+  pass('openclaw cli', openclawPath);
+} catch {
+  fail('openclaw cli', 'not on PATH');
+}
+
+// 2. Consumer integration config
+const consumerConfig = join(root, '.xray', 'config', 'openclaw.json');
+existsSync(consumerConfig)
+  ? pass('consumer openclaw.json', consumerConfig)
+  : fail('consumer openclaw.json', 'run npx 0xray openclaw install');
+
+// 3. Consumer root marker
+const markerPath = join(OPENCLAW_STATE, 'xray-consumer-root.txt');
+if (existsSync(markerPath)) {
+  const marked = readFileSync(markerPath, 'utf8').trim();
+  marked === root ? pass('consumer root marker', root) : fail('consumer root marker', `got ${marked}`);
+} else {
+  fail('consumer root marker', 'missing');
+}
+
+// 4. xray-orchestrator skill synced
+const orchestratorSkill = join(OPENCLAW_STATE, 'skills', 'xray-orchestrator', 'SKILL.md');
+existsSync(orchestratorSkill)
+  ? pass('xray-orchestrator skill', orchestratorSkill)
+  : fail('xray-orchestrator skill', 'missing');
+
+// 5. openclaw mcp list
+try {
+  const listed = execSync('openclaw mcp list 2>&1', { encoding: 'utf8', timeout: 20000 });
+  const xrayListed = XRAY_MCP_SERVERS.filter((s) => listed.includes(s.name));
+  if (xrayListed.length === 7) pass('openclaw mcp list xray', '7/7');
+  else fail('openclaw mcp list xray', `${xrayListed.length}/7`);
+  listed.includes(REPERTOIRE_MCP.name)
+    ? pass('openclaw mcp list repertoire')
+    : fail('openclaw mcp list repertoire', 'not listed');
+} catch (e) {
+  fail('openclaw mcp list', e.message?.slice(0, 160));
+}
+
+// 6. openclaw.json mcp.servers block
+try {
+  const config = JSON.parse(readFileSync(OPENCLAW_CONFIG, 'utf8'));
+  const servers = config.mcp?.servers ?? {};
+  const xrayCount = Object.keys(servers).filter((n) => n.startsWith('xray-')).length;
+  if (xrayCount === 7) pass('openclaw.json mcp.servers xray', '7/7');
+  else fail('openclaw.json mcp.servers xray', `${xrayCount}/7`);
+  if (servers[REPERTOIRE_MCP.name]) pass('openclaw.json mcp.servers repertoire');
+  else fail('openclaw.json mcp.servers repertoire', 'missing');
+  if (servers['xray-enforcer']?.env?.XRAY_ROOT === root) {
+    pass('openclaw mcp XRAY_ROOT', root);
+  } else {
+    fail('openclaw mcp XRAY_ROOT', `got ${servers['xray-enforcer']?.env?.XRAY_ROOT}`);
+  }
+} catch (e) {
+  fail('openclaw.json mcp.servers', e.message?.slice(0, 160));
+}
+
+// 7. .xray contract
+for (const f of ['codex.json', 'features.json', 'config.json']) {
+  existsSync(join(root, '.xray', f)) ? pass(`.xray/${f}`) : fail(`.xray/${f}`, 'missing');
+}
+
+// 8. MCP stdio probe
+try {
+  const init = JSON.stringify({
+    jsonrpc: '2.0',
+    id: 1,
+    method: 'initialize',
+    params: {
+      protocolVersion: '2024-11-05',
+      capabilities: {},
+      clientInfo: { name: 'verify-openclaw-suit', version: '1.0' },
+    },
+  });
+  const out = execSync(
+    `printf '%s\\n' '${init.replace(/'/g, "'\\''")}' | timeout 12 npx 0xray mcp enforcer 2>/dev/null | head -1`,
+    { cwd: root, encoding: 'utf8', shell: '/bin/bash' },
+  );
+  if (out.includes('serverInfo')) pass('MCP enforcer stdio probe');
+  else fail('MCP enforcer stdio probe', out.slice(0, 120));
+} catch (e) {
+  fail('MCP enforcer stdio probe', e.message?.slice(0, 160));
+}
+
+// 9. npx 0xray health
+try {
+  execSync('npx 0xray health', { cwd: root, stdio: 'pipe', encoding: 'utf8' });
+  pass('npx 0xray health');
+} catch {
+  fail('npx 0xray health');
+}
+
+console.log('\n' + (failed === 0 ? '🎉 OpenClaw suit wearable.' : `⚠️  ${failed} OpenClaw check(s) failed.`));
+process.exit(failed === 0 ? 0 : 1);

package/vendor/@0xray/repertoire/scripts/verify-opencode-suit.mjs

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+/**
+ * Verify OpenCode suit bridge for this consumer repo.
+ * Run: node scripts/verify-opencode-suit.mjs
+ */
+import { execSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { REPERTOIRE_MCP, XRAY_MCP_SERVERS } from './suit-bridge-shared.mjs';
+
+const root = resolve(import.meta.dirname, '..');
+let failed = 0;
+
+function pass(name, detail = '') {
+  console.log(`✅ ${name}${detail ? ` — ${detail}` : ''}`);
+}
+
+function fail(name, detail = '') {
+  failed++;
+  console.error(`❌ ${name}${detail ? ` — ${detail}` : ''}`);
+}
+
+// 1. OpenCode CLI
+try {
+  const opencodePath = execSync('which opencode', { encoding: 'utf8' }).trim();
+  pass('opencode cli', opencodePath);
+} catch {
+  fail('opencode cli', 'not on PATH');
+}
+
+// 2. Bridge artifacts
+const pluginPath = join(root, '.opencode', 'plugin', 'xray-codex-injection.js');
+existsSync(pluginPath) ? pass('codex injection plugin', pluginPath) : fail('codex injection plugin', 'run: npx 0xray opencode install --force');
+
+const skillsDir = join(root, '.opencode', 'skills', 'orchestrator', 'SKILL.md');
+existsSync(skillsDir) ? pass('orchestrator skill synced') : fail('orchestrator skill synced', 'missing');
+
+// 3. opencode.json MCP entries
+try {
+  const config = JSON.parse(readFileSync(join(root, 'opencode.json'), 'utf8'));
+  const mcp = config.mcp ?? {};
+  const xrayEntries = XRAY_MCP_SERVERS.filter((s) => {
+    const entry = mcp[s.name];
+    return entry?.type === 'local' && entry?.enabled === true && Array.isArray(entry.command);
+  });
+  if (xrayEntries.length === 7) pass('opencode.json xray mcp', '7/7 enabled local');
+  else fail('opencode.json xray mcp', `${xrayEntries.length}/7`);
+
+  const rep = mcp[REPERTOIRE_MCP.name];
+  if (rep?.enabled === true && rep?.type === 'local') pass('opencode.json repertoire mcp');
+  else fail('opencode.json repertoire mcp', 'missing or disabled');
+} catch (e) {
+  fail('opencode.json mcp', e.message);
+}
+
+// 4. Plugin loaded in resolved config
+try {
+  const debug = execSync('opencode debug config 2>&1', { cwd: root, encoding: 'utf8', timeout: 15000 });
+  if (debug.includes('xray-codex-injection.js')) pass('plugin in resolved config');
+  else fail('plugin in resolved config', 'xray-codex-injection.js not found');
+} catch (e) {
+  fail('opencode debug config', e.message?.slice(0, 160));
+}
+
+// 5. opencode mcp list (runtime registry)
+try {
+  const listed = execSync('opencode mcp list 2>&1', { cwd: root, encoding: 'utf8', timeout: 20000 });
+  const xrayListed = XRAY_MCP_SERVERS.filter((s) => listed.includes(s.name));
+  if (xrayListed.length === 7) pass('opencode mcp list xray', '7/7');
+  else fail('opencode mcp list xray', `${xrayListed.length}/7 — ${listed.slice(0, 200)}`);
+  listed.includes(REPERTOIRE_MCP.name)
+    ? pass('opencode mcp list repertoire')
+    : fail('opencode mcp list repertoire', 'not listed');
+} catch (e) {
+  fail('opencode mcp list', e.message?.slice(0, 160));
+}
+
+// 6. Skills discoverable via OpenCode CLI (output can exceed 64KB — pipe to rg)
+try {
+  execSync('opencode debug skill 2>&1 | rg -q "orchestrator/SKILL.md"', {
+    cwd: root,
+    encoding: 'utf8',
+    timeout: 20000,
+    shell: '/bin/bash',
+  });
+  pass('opencode skills', 'orchestrator present');
+} catch (e) {
+  fail('opencode skills', e.message?.slice(0, 160));
+}
+
+// 7. .xray contract
+for (const f of ['codex.json', 'features.json', 'config.json']) {
+  existsSync(join(root, '.xray', f)) ? pass(`.xray/${f}`) : fail(`.xray/${f}`, 'missing');
+}
+
+// 8. MCP stdio probe
+try {
+  const init = JSON.stringify({
+    jsonrpc: '2.0',
+    id: 1,
+    method: 'initialize',
+    params: {
+      protocolVersion: '2024-11-05',
+      capabilities: {},
+      clientInfo: { name: 'verify-opencode-suit', version: '1.0' },
+    },
+  });
+  const out = execSync(
+    `printf '%s\\n' '${init.replace(/'/g, "'\\''")}' | timeout 12 npx 0xray mcp skills 2>/dev/null | head -1`,
+    { cwd: root, encoding: 'utf8', shell: '/bin/bash' },
+  );
+  if (out.includes('serverInfo')) pass('MCP skills stdio probe');
+  else fail('MCP skills stdio probe', out.slice(0, 120));
+} catch (e) {
+  fail('MCP skills stdio probe', e.message?.slice(0, 160));
+}
+
+// 9. npx 0xray health from consumer
+try {
+  execSync('npx 0xray health', { cwd: root, stdio: 'pipe', encoding: 'utf8' });
+  pass('npx 0xray health');
+} catch {
+  fail('npx 0xray health');
+}
+
+console.log('\n' + (failed === 0 ? '🎉 OpenCode suit wearable.' : `⚠️  ${failed} OpenCode check(s) failed.`));
+process.exit(failed === 0 ? 0 : 1);

package/vendor/@0xray/repertoire/scripts/verify-synthesis-dogfood.mjs

@@ -0,0 +1,207 @@
+#!/usr/bin/env node
+/**
+ * Dogfood synthesis on repertoire core — provider + xray nucleus + live Grok hook.
+ * Run: npm run build && node scripts/verify-synthesis-dogfood.mjs
+ */
+import { execSync } from 'node:child_process';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const root = join(__dirname, '..');
+const xrayRoot = join(root, 'node_modules/0xray');
+
+let failed = 0;
+function pass(n, d = '') {
+  console.log(`✅ ${n}${d ? ` — ${d}` : ''}`);
+}
+function fail(n, d = '') {
+  failed++;
+  console.error(`❌ ${n}${d ? ` — ${d}` : ''}`);
+}
+
+const sessionId = 'repertoire-dogfood';
+
+async function main() {
+  if (!existsSync(join(root, 'dist/provider/memory-routing-provider.js'))) {
+    fail('build', 'run npm run build first');
+    process.exit(1);
+  }
+
+  try {
+    execSync('npm run health:repertoire', { cwd: root, stdio: 'pipe', env: { ...process.env, REPERTOIRE_EXPECTED_SIGNALS: '145' } });
+    pass('health:repertoire', '145 signals drift gate');
+  } catch (e) {
+    fail('health:repertoire', e.stderr?.toString() || e.message);
+  }
+
+  const features = JSON.parse(readFileSync(join(root, '.xray/features.json'), 'utf8'));
+  if (!features.synthesis?.enabled) fail('synthesis.enabled in features.json');
+  else pass('synthesis.enabled in features.json');
+  if (!features.memory_routing?.enabled) fail('memory_routing.enabled');
+  else pass('memory_routing.enabled', features.memory_routing.provider);
+
+  const { createMemoryRoutingProvider } = await import(
+    join(root, 'dist/provider/memory-routing-provider.js')
+  );
+  const provider = createMemoryRoutingProvider(features.memory_routing.config ?? {});
+  if (typeof provider.buildSynthesisContext !== 'function') {
+    fail('provider.buildSynthesisContext');
+  } else {
+    const ctx = provider.buildSynthesisContext({
+      projectRoot: root,
+      dueReason: 'gate_threshold',
+    });
+    if (ctx && typeof ctx === 'object') pass('provider.buildSynthesisContext', 'non-null');
+    else fail('provider.buildSynthesisContext', 'null');
+  }
+
+  if (typeof provider.refreshMetaInference === 'function') {
+    try {
+      const { refreshed } = await provider.refreshMetaInference();
+      pass('provider.refreshMetaInference', String(refreshed));
+    } catch (e) {
+      fail('provider.refreshMetaInference', e.message);
+    }
+  } else {
+    fail('provider.refreshMetaInference missing');
+  }
+
+  if (typeof provider.ingestFeedback === 'function') {
+    try {
+      const result = provider.ingestFeedback({
+        timestamp: new Date().toISOString(),
+        sessionId,
+        taskId: 'dogfood-1',
+        assignedAgent: 'researcher',
+        memorySignals: ['synthesis-checkpoint'],
+        complexity: 20,
+        success: true,
+        durationMs: 1200,
+      });
+      if (result?.logPath) pass('provider.ingestFeedback', result.logPath);
+      else fail('provider.ingestFeedback', 'no logPath');
+    } catch (e) {
+      fail('provider.ingestFeedback', e.message);
+    }
+  }
+
+  const { recordExecutionSlice, isSynthesisCheckpointDue, loadSynthesisCheckpointState } =
+    await import(join(xrayRoot, 'dist/nucleus/synthesis.js'));
+  const { evaluatePreToolGate, loadDelegationGateFeatures } = await import(
+    join(xrayRoot, 'dist/integrations/hooks/delegation-gate-runtime.mjs'),
+  );
+  const { prepareSynthesisCollocatedContext } = await import(
+    join(xrayRoot, 'dist/nucleus/synthesis-context.js'),
+  );
+
+  const tmp = mkdtempSync(join(tmpdir(), 'repertoire-synth-dogfood-'));
+  mkdirSync(join(tmp, '.xray', 'state'), { recursive: true });
+  const dogFeatures = {
+    ...features,
+    synthesis: { ...features.synthesis, every_n_gates: 1, every_n_turns: 0, every_n_todos_completed: 0 },
+    memory_routing: {
+      ...features.memory_routing,
+      module_path: join(root, 'dist/provider/memory-routing-provider.js'),
+    },
+  };
+  writeFileSync(join(tmp, '.xray/features.json'), JSON.stringify(dogFeatures, null, 2));
+
+  try {
+    recordExecutionSlice('gate', { projectRoot: tmp, sessionId });
+    if (isSynthesisCheckpointDue(tmp, sessionId)) pass('nucleus gate slice → synthesis due');
+    else fail('nucleus synthesis due');
+
+    const gateFeatures = loadDelegationGateFeatures(tmp);
+    const deny = evaluatePreToolGate(
+      'search_replace',
+      { path: 'src/a.ts', new_string: 'x' },
+      { projectRoot: tmp, sessionId, features: gateFeatures, host: 'grok' },
+    );
+    if (!deny.allow && deny.gate === 'synthesis-checkpoint') {
+      pass('evaluatePreToolGate denies write when due');
+    } else {
+      fail('evaluatePreToolGate deny', JSON.stringify(deny));
+    }
+
+    const collation = await prepareSynthesisCollocatedContext(root, 'gate_threshold');
+    if (
+      collation?.collatedText &&
+      !collation.collatedText.includes('Enable memory_routing with Repertoire')
+    ) {
+      pass('prepareSynthesisCollocatedContext', 'repertoire collation');
+    } else {
+      fail('prepareSynthesisCollocatedContext', JSON.stringify(collation));
+    }
+
+    const cleared = loadSynthesisCheckpointState(tmp);
+    if (cleared?.synthesisDue) pass('checkpoint still due before consult completion');
+    else fail('checkpoint state');
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+
+  const preToolHook = join(xrayRoot, 'dist/integrations/grok/hooks/pre-tool-use.js');
+  const hookTmp = mkdtempSync(join(tmpdir(), 'repertoire-grok-hook-'));
+  mkdirSync(join(hookTmp, '.xray', 'state'), { recursive: true });
+  writeFileSync(
+    join(hookTmp, '.xray', 'features.json'),
+    JSON.stringify({
+      synthesis: { enabled: true, every_n_gates: 12, every_n_turns: 0, every_n_todos_completed: 0 },
+      multi_agent_orchestration: { enabled: true, lead_dev_mode: true },
+    }),
+  );
+  const now = new Date().toISOString();
+  writeFileSync(
+    join(hookTmp, '.xray', 'state', 'synthesis-checkpoint.json'),
+    JSON.stringify({
+      version: 1,
+      sessionId,
+      slicesSinceLastSynthesis: { gates: 12, turns: 0, todosCompleted: 0 },
+      lifetimeSlices: { gates: 12, turns: 0, todosCompleted: 0 },
+      synthesisDue: true,
+      dueReason: 'gate_threshold',
+      lastSynthesisAt: null,
+      lastSliceAt: now,
+      synthesisCount: 0,
+    }),
+  );
+  try {
+    const payload = JSON.stringify({
+      toolName: 'search_replace',
+      workspaceRoot: hookTmp,
+      sessionId,
+      toolInput: { path: 'src/a.ts', new_string: 'x' },
+    });
+    const out = execSync(
+      `printf '%s' '${payload.replace(/'/g, "'\\''")}' | node "${preToolHook}"`,
+      {
+        encoding: 'utf8',
+        env: { ...process.env, GROK_WORKSPACE_ROOT: hookTmp, GROK_SESSION_ID: sessionId },
+      },
+    );
+    const parsed = JSON.parse(out.trim());
+    if (parsed.decision === 'deny' && parsed.gate === 'synthesis-checkpoint') {
+      pass('live Grok pre-tool-use denies write when due');
+    } else {
+      fail('live Grok hook', JSON.stringify(parsed));
+    }
+  } finally {
+    rmSync(hookTmp, { recursive: true, force: true });
+  }
+
+  console.log(
+    '\n' +
+      (failed === 0
+        ? '🎉 Synthesis dogfood passed on repertoire core.'
+        : `⚠️  ${failed} dogfood check(s) failed.`),
+  );
+  process.exit(failed === 0 ? 0 : 1);
+}
+
+main().catch((e) => {
+  console.error(e);
+  process.exit(1);
+});