0xray 3.5.5 → 4.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);
+});

package/vendor/@0xray/repertoire/skills/repertoire-trap-handling/SKILL.md

@@ -0,0 +1,206 @@
+---
+name: repertoire-trap-handling
+description: Query Repertoire MCP tools before governance on ontological-trap tasks. Routes high-confidence traps to architect and injects matched signals as evidence.
+author: 0xRay / Repertoire
+version: 1.0.0
+schema_version: "1.0"
+tags: [repertoire, ontological-trap, governance, memory-routing, architect]
+capabilities:
+  - evaluate_trap_confidence
+  - search_primitives
+  - route_trap_tasks
+dependencies:
+  - repertoire-mcp
+
+metadata:
+  hermes:
+    tags: [Repertoire, OntologicalTrap, Governance, MCP, Architect]
+    related_skills: [researcher, security-audit, architect-tools]
+  opencode:
+    tags: [repertoire, trap, governance]
+---
+
+# Repertoire Trap Handling
+
+Use this skill when a task or proposal may involve an **ontological trap** — cases where attestation, closure, or verdict language masks an ongoing validation obligation at a trust boundary.
+
+Repertoire maintains a curated primitive registry (`curated_signals.json`) fed by **enriched Groover logs** (`matched_primitives` + `match_confidence`). The MCP surface is the **primary contract** for LLM agents running in Hermes, OpenCode, Claude Code, or similar hosts.
+
+## When to Activate
+
+Trigger this skill when **any** of the following are true:
+
+- Task or proposal text contains `TYPE: ontological-trap`
+- Description mentions ontological-trap primitives (e.g. `attestation-as-map`, consumer-boundary revalidation)
+- User asks for governance, architecture review, or researcher analysis on attestation / closure / verdict semantics
+- You are about to call `analyze_proposal` on a trap-adjacent inference
+
+Do **not** skip Repertoire on trap-classified work. In-process 0xRay routing may not be available in your host process.
+
+## Required MCP Server
+
+Register `repertoire-mcp` in your host config (see `mcp-config.example.json` in the repertoire repo):
+
+```json
+{
+  "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"
+      }
+    }
+  }
+}
+```
+
+Build first: `cd repertoire && npm run build`
+
+Optional companion servers for governance follow-through:
+
+- `xray-researcher` — `analyze_proposal` from a codebase/history perspective
+- `xray-architect-tools` — architecture-level trap remediation
+- `xray-code-review` / `xray-governance` — committee votes
+
+## Workflow
+
+### Step 1 — Evaluate task confidence
+
+Call `repertoire__get_task_confidence` with the full task or proposal text.
+
+```
+repertoire__get_task_confidence({
+  description: "<title + description + relevant context>",
+  type: "governance",
+  taskId: "<optional-id>"
+})
+```
+
+**Example description:**
+
+```
+TYPE: ontological-trap
+Attestation-as-map requires consumer-side revalidation at the trust boundary.
+```
+
+### Step 2 — Interpret the response
+
+The tool returns JSON `TaskConfidenceContext`. Key fields:
+
+| Field | Meaning |
+|-------|---------|
+| `highConfidenceTrapPresent` | Trap detected **and** at least one trap signal has confidence ≥ 0.55 |
+| `ontologicalTrapDetected` | Trap language or tags matched (may be true without high confidence) |
+| `matchedSignals` | Primitive names that passed the confidence gate |
+| `signals` | `{ name, confidence, source }` details |
+| `complexityBoost` | Suggested complexity increase for routing (orchestrator use) |
+| `recommendedAgent` | `"architect"` when `highConfidenceTrapPresent`; otherwise `null` |
+| `minConfidenceGate` | Threshold used (default `0.55`) |
+
+### Step 3 — Act on high-confidence traps
+
+If `highConfidenceTrapPresent === true`:
+
+1. **Route preference:** Prefer `architect` (or `recommendedAgent` if set). Trap-capable agents: `architect`, `security-auditor`, `researcher`.
+2. **Evidence:** Include `matchedSignals` and per-signal confidences in your reasoning and any governance evidence array.
+3. **Complexity:** Treat the task as elevated complexity (`complexityBoost` is advisory for orchestrator routing).
+4. **Do not flatten the trap:** Avoid approving language that treats attestation as a terminating verdict when the registry says consumer revalidation is required.
+
+If `ontologicalTrapDetected === true` but `highConfidenceTrapPresent === false`:
+
+- Proceed with caution; registry may lack enriched observations yet.
+- Note that confidence is below the promotion gate — do not treat as validated memory.
+
+### Step 4 — Optional primitive search
+
+For additional registry context:
+
+```
+repertoire__search_primitives({
+  query: "attestation-as-map ontological-trap",
+  minConfidence: 0.55,
+  limit: 5
+})
+```
+
+Use results for definitions, tags, `observationCount`, and `confidence` in your analysis. Only signals with `observation_stats` appear — no text-score fallbacks.
+
+### Step 5 — Governance / analysis
+
+Proceed with your governance or analysis tools, **referencing Repertoire explicitly**:
+
+```
+repertoire__get_task_confidence → highConfidenceTrapPresent: true
+matchedSignals: attestation-as-map (0.90)
+recommendedAgent: architect
+→ calling xray-researcher analyze_proposal with signals as evidence
+```
+
+**Researcher example:**
+
+```
+xray-researcher.analyze_proposal({
+  proposalTitle: "Attestation boundary review",
+  proposalDescription: "TYPE: ontological-trap ...",
+  proposalType: "governance",
+  evidence: [
+    "Repertoire: attestation-as-map (confidence 0.90)",
+    "Repertoire recommendedAgent: architect",
+    "Repertoire complexityBoost: 19"
+  ]
+})
+```
+
+When the researcher response includes a `MEMORY_ROUTING:` block, preserve it in summaries — it is the auditable signal trail.
+
+### Step 6 — Feedback (orchestrated runs only)
+
+After task completion in an orchestrated session, record outcomes:
+
+```
+repertoire__ingest_feedback({
+  sessionId: "<session>",
+  taskId: "<task>",
+  assignedAgent: "architect",
+  memorySignals: ["attestation-as-map"],
+  complexity: 45,
+  success: true,
+  durationMs: 12000
+})
+```
+
+## Decision Checklist
+
+Before finalizing a trap-classified governance vote:
+
+- [ ] Called `repertoire__get_task_confidence`
+- [ ] Checked `highConfidenceTrapPresent`
+- [ ] If true: noted `matchedSignals`, `recommendedAgent`, `complexityBoost`
+- [ ] Included Repertoire evidence in reasoning
+- [ ] Routed to architect (or trap-capable agent) when recommended
+- [ ] Did not treat low-confidence trap detection as validated memory
+
+## Example: Full trap flow
+
+**User task:** Review a proposal that closes an attestation loop without consumer revalidation.
+
+**Agent actions:**
+
+1. `repertoire__get_task_confidence({ description: "TYPE: ontological-trap attestation-as-map ...", type: "governance" })`
+2. Response: `highConfidenceTrapPresent: true`, `matchedSignals: ["attestation-as-map"]`, `recommendedAgent: "architect"`
+3. `repertoire__search_primitives({ query: "attestation-as-map", minConfidence: 0.55 })` — read definition
+4. Invoke `architect` or `xray-researcher analyze_proposal` with Repertoire evidence
+5. Vote/recommend **reject** or **request revision** if proposal treats attestation as final without consumer boundary checks
+
+## What This Skill Does Not Do
+
+- **In-process MemoryRoutingProvider** — used by 0xRay `ExecutionPlanner` / `thinDispatch` inside the orchestrator process only. LLM hosts should use MCP tools.
+- **Legacy log ingest** — unstructured Groover logs without `match_confidence` are skipped; empty registry → low confidence is expected until enriched logs land.
+- **Replace architect judgment** — Repertoire supplies signal-backed context; the LLM still reasons and votes.
+
+## Related Documentation
+
+- [ARCHITECTURE.md](../../ARCHITECTURE.md) — deployment model, internal vs MCP surfaces
+- [mcp-config.example.json](../../mcp-config.example.json) — MCP server registration
+- [docs/MEMORY-ROUTING-PROVIDER.md](../../docs/MEMORY-ROUTING-PROVIDER.md) — in-process provider (0xRay orchestrator only)

package/xray/codex.json

@@ -1,6 +1,6 @@
 {
   "version": "3.1.0",
-  "lastUpdated": "2026-06-05",
+  "lastUpdated": "2026-08-24",
   "errorPreventionTarget": 0.998,
   "terms": {
     "1": {
@@ -546,6 +546,14 @@
       "category": "process",
       "zeroTolerance": false,
       "enforcementLevel": "high"
+    },
+    "69": {
+      "number": 69,
+      "title": "No New MCP, Skill, or Handler Surface",
+      "description": "Do not add parallel APIs. Rewire existing MCP servers, skills, and orchestrator handlers. PreToolUse denies creating new src/mcps/*.server.ts, src/skills/*/SKILL.md, or orchestrator *-handler files. Existing files may be rewritten.",
+      "category": "process",
+      "zeroTolerance": true,
+      "enforcementLevel": "blocking"
     }
   },
   "interweaves": [
@@ -589,10 +597,11 @@
     "No type errors or any usage": true,
     "Agent spawns go through governor": true,
     "Subagent spawning prevented": true,
-    "PostProcessor validation passes": true
+    "PostProcessor validation passes": true,
+    "No new MCP/skill/handler surface": true
   },
   "frameworkAlignment": {
     "OpenCode": "v1.1.1",
-    "0xRay": "v2.0.0"
+    "0xRay": "v4.0.0"
   }
 }

package/xray/features.json

@@ -1,7 +1,17 @@
 {
   "$schema": "./features.schema.json",
-  "version": "3.4.3",
+  "version": "4.0.1",
   "description": "0xRay Framework - Unified Feature Configuration",
+  "suit_temperament": {
+    "profile": "auto",
+    "host_defaults": {
+      "grok": "frontier",
+      "hermes": "guided",
+      "opencode": "guided",
+      "openclaw": "guided",
+      "generic": "guided"
+    }
+  },
   "token_optimization": {
     "enabled": true,
     "max_context_tokens": 20000,
@@ -37,11 +47,19 @@
     "auto_consult_major_work": true,
     "no_new_surface": true,
     "auto_chain_delegations": true,
+    "plan_stale_hours": 8,
+    "plan_archive_marker_hours": 24,
     "user_asides": {
       "enabled": true,
       "auto_provision_worktree": false
     }
   },
+  "grok_postprocessor_light": true,
+  "inference_session_capture": {
+    "enabled": true,
+    "min_commits": 3,
+    "lookback_commits": 20
+  },
   "autonomous_reporting": {
     "enabled": true,
     "interval_minutes": 60,
@@ -140,10 +158,14 @@
     "min_success_rate": 0.7
   },
   "memory_routing": {
-    "enabled": false,
-    "provider": "null",
-    "module_path": "",
-    "config": {}
+    "enabled": true,
+    "provider": "repertoire",
+    "module_path": "node_modules/@0xray/repertoire/dist/provider/memory-routing-provider.js",
+    "config": {
+      "signalsPath": "node_modules/@0xray/repertoire/data/curated_signals.json",
+      "statePath": ".xray/state/repertoire/inference-state.json",
+      "feedbackDir": ".xray/state/repertoire/feedback"
+    }
   },
   "synthesis": {
     "enabled": false,
@@ -160,4 +182,4 @@
       "onChain": false
     }
   }
-}
+}

package/xray/features.schema.json

@@ -84,6 +84,37 @@
         }
       }
     },
+    "grok_postprocessor_light": {
+      "type": "boolean",
+      "description": "Opt-in lightweight postprocessor marker + activity.log on Grok write tools"
+    },
+    "inference_session_capture": {
+      "type": "object",
+      "description": "git post-commit → captureSessionInference when commit threshold is met",
+      "properties": {
+        "enabled": { "type": "boolean" },
+        "min_commits": { "type": "integer", "minimum": 1 },
+        "lookback_commits": { "type": "integer", "minimum": 1 }
+      }
+    },
+    "suit_temperament": {
+      "type": "object",
+      "description": "0xRay 4.0 — constitution always on; ceremony scales by host. Missing key = guided (existing consumers unchanged).",
+      "properties": {
+        "profile": {
+          "type": "string",
+          "enum": ["auto", "frontier", "guided", "strict"],
+          "description": "auto = host_defaults (grok→frontier, hermes/opencode/openclaw→guided)"
+        },
+        "host_defaults": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "string",
+            "enum": ["frontier", "guided", "strict"]
+          }
+        }
+      }
+    },
     "synthesis": {
       "type": "object",
       "properties": {