0xray 4.0.40 → 4.0.42

package/dist/integrations/hooks/station-hook-runtime.cjs

@@ -20,7 +20,10 @@ const {
 const { join, resolve } = require("path");
 
 const HOOKS_DIR = __dirname;
-const { plateStockLine, recallPlate, stampPlateIfMissing } = require("./plates.cjs");
+const { ensureWornPlate, plateStockLine, recallPlate } = require("./plates.cjs");
+const { rememberSessionNote, retainProjectNotes } = require("./session-note-index.cjs");
+const { formatCascadePointer, readWakeCascade } = require("./wake-cascade.cjs");
+const { formatSleevePointer, readSleeve, runFoundryMill } = require("./sleeve.cjs");
 
 const INTENT_MAX = 240;
 
@@ -111,6 +114,12 @@ function isStockTicket(value) {
   return !text || text === "(none)" || text === "(none yet)";
 }
 
+function readStationHostToken(root) {
+  const md = readExistingStationMarkdown(root);
+  const match = md.match(/^Host:\s*(\S+)/m);
+  return match ? match[1] : "";
+}
+
 function readStationTicketField(root, field) {
   const md = readExistingStationMarkdown(root);
   const re = field === "Plan" ? /^Plan:\s*(.*)$/im : /^Intent:\s*(.*)$/im;
@@ -136,9 +145,20 @@ function resolveHeatIntent(root, extra, existing) {
   const pickup = clipIntent(readNotesPickup(root));
   const bootIntent = typeof existing.intent === "string" ? clipIntent(existing.intent) : null;
   const cardIsBootEcho = Boolean(card && bootIntent && card === bootIntent);
-  const hook = String(extra.hookEvent || extra.source || "");
-  const keepsTicket = /user_prompt|compact/i.test(hook);
-  const compact = /compact/i.test(hook);
+  const named = String(extra.hookEvent || "");
+  const channel = String(extra.hookEvent || extra.source || "");
+  const keepsTicket = /user_prompt|compact/i.test(channel);
+  const compact = /compact/i.test(channel);
+  let receipt = null;
+  try {
+    receipt = readSleeve(root);
+  } catch {
+    receipt = null;
+  }
+  // A proved receipt keeps the ticket. A new session must not restate it.
+  if (receipt && receipt.on && card && /^(session_start|session-start)$/i.test(named)) {
+    return { intent: card, rematch: false, kept: true };
+  }
   // A chat sentence or a compact summary does not replace a ticket already on disk.
   if (incoming && !(keepsTicket && (card || pickup))) {
     return { intent: incoming, rematch: true };
@@ -520,6 +540,7 @@ function stampNotesPickup(root, line) {
     : body
       ? `${marker}\n\n${body.replace(/^\n+/, "")}`
       : `${marker}\n`;
+  rememberSessionNote(root, text, { source: "NOTES.md", slot: "pickup" });
   if (next === body) return text;
   mkdirSync(join(root, ".xray", "state"), { recursive: true });
   writeFileSync(dest, next.endsWith("\n") ? next : `${next}\n`);
@@ -973,6 +994,7 @@ function buildRepertoireResume(root) {
 }
 
 function applyStationHeat(root, host, extra = {}, existing = {}) {
+  retainProjectNotes(root);
   const mr = readMemoryRoutingConfig(root);
   const memoryOff = isExplicitMemoryRoutingOptOut(mr);
   const promptHook = isPromptHook(extra);
@@ -1005,6 +1027,8 @@ function applyStationHeat(root, host, extra = {}, existing = {}) {
       ? existing.hotSwap
       : null;
   const hotSwap = nextSwap || keptSwap;
+  const priorIntent = readStationTicketField(root, "Intent");
+  const priorHost = readStationHostToken(root);
   const resolved = resolveHeatIntent(root, extra, existing);
   const intent = resolved.intent;
   const rematch = resolved.rematch;
@@ -1018,7 +1042,10 @@ function applyStationHeat(root, host, extra = {}, existing = {}) {
   }
   const matchText = clipIntent([intent, pickup, approaches].filter(Boolean).join(" "));
   const git = readGitBrief(root);
-  const planLine = resolveHeatPlan(root, extra, existing);
+  let planLine = resolveHeatPlan(root, extra, existing);
+  if (priorIntent && intent && intent !== priorIntent && !(extra.plan || extra.planLine)) {
+    planLine = null;
+  }
   // A passed string is the previous card. Count the project file after this wake.
   const repertoireResume = buildRepertoireResume(root);
   const swapBit = hotSwap ? `hot-swap ${hotSwap.from} → ${hotSwap.to}` : `host ${host}`;
@@ -1056,11 +1083,20 @@ function applyStationHeat(root, host, extra = {}, existing = {}) {
   if (!matchedSignals.length && priorWorking) {
     matchedSignals = stationSafeSignals(priorWorking.matchedSignals);
   }
+  if (resolved.kept) {
+    matchedSignals = preferLawHits(priorWorking && priorWorking.matchedSignals, 8);
+  }
   const compactHold = retainCompactFields(existing, extra);
   const nextHook = compactHold.hookEvent || extra.hookEvent || extra.source || null;
   const workingSnapshot = {
     host,
     intent,
+    priorIntent: priorIntent || null,
+    priorHost: priorHost || null,
+    priorWorkingIntent: priorWorking && typeof priorWorking.intent === "string" ? priorWorking.intent : null,
+    priorWorkingHost: priorWorking && typeof priorWorking.host === "string"
+      ? (priorWorking.host.split(/\s+/)[0] || null)
+      : null,
     git,
     hotSwap,
     memoryRouting: repertoireResume.startsWith("Repertoire: on") ? "on" : "off",
@@ -1074,6 +1110,13 @@ function applyStationHeat(root, host, extra = {}, existing = {}) {
   const growReceipt = workingGrowSnapshot(grow);
   if (growReceipt) workingSnapshot.grow = growReceipt;
   if (matchedSignals.length) workingSnapshot.matchedSignals = matchedSignals.slice(0, 8);
+  const cascade = readWakeCascade(root, { laws: matchedSignals });
+  workingSnapshot.cascade = {
+    plane: cascade.plane,
+    laws: cascade.laws,
+    notes: cascade.notes.length,
+  };
+  const cascadeLine = formatCascadePointer(cascade);
   const opProcNames = readOpProcNames(root);
   if (opProcNames.length) workingSnapshot.opProcNames = opProcNames;
   const pickupChanged = Boolean(pickup && (!priorWorking || priorWorking.pickup !== pickup));
@@ -1106,8 +1149,10 @@ function applyStationHeat(root, host, extra = {}, existing = {}) {
     repertoireResume,
     workingLine,
     stationLine,
+    cascadeLine,
     ...(notesLine ? { notesLine } : {}),
     ...compactHold,
+    arrivedHook: extra && extra.hookEvent ? String(extra.hookEvent) : "",
   };
 }
 
@@ -1122,7 +1167,12 @@ const STOCK_STATION_PREFIXES = [
   "working:",
   "plate:",
   "library:",
+  "cascade:",
+  "sleeve:",
   "notes:",
+  "plane:",
+  "judgement:",
+  "payments:",
 ];
 
 /** Stock design map. Exact lines so a later heat does not preserve a second copy. */
@@ -1318,6 +1368,11 @@ function formatStationMarkdown(fields) {
   const plateLine = plateStockLine(fields.intent);
   if (plateLine) lines.push(plateLine);
   lines.push("Library: record-map — .agents/skills/record-map/SKILL.md");
+  if (fields.cascadeLine) lines.push(fields.cascadeLine);
+  if (fields.sleeveLine) lines.push(fields.sleeveLine);
+  lines.push(`Plane: ${fields.plane || "(none)"}`);
+  lines.push(`Judgement: ${fields.judgement || "start"}`);
+  lines.push(`Payments: ${fields.payments === "on" ? "on" : "off"}`);
   if (fields.notesLine) lines.push(fields.notesLine);
   lines.push("");
   lines.push(...DESIGN_MAP_LINES);
@@ -1338,19 +1393,160 @@ function readExistingStationMarkdown(root) {
   }
 }
 
+
+
+function ticketIsPayment(intent) {
+  return /\b(pay|payment|payments|x402|invoice)\b/i.test(String(intent || ""));
+}
+
+function readHeldPlane(root) {
+  try {
+    const data = JSON.parse(readFileSync(join(root, ".xray", "state", "goggles-plane.json"), "utf8"));
+    return data && typeof data.plane === "string" ? data.plane : "";
+  } catch {
+    return "";
+  }
+}
+
+function missKey(proved) {
+  const missing = proved && Array.isArray(proved.missing) ? proved.missing.slice() : [];
+  const rows = proved && Array.isArray(proved.stitches) ? proved.stitches : [];
+  const at = {};
+  for (const row of rows) {
+    if (!row || !missing.includes(row.name)) continue;
+    at[row.name] = Array.isArray(row.at) ? row.at.slice() : [];
+  }
+  return JSON.stringify({ missing, at });
+}
+
+function judgementLine(order, saved, proved) {
+  const wake = order && order.wake ? order.wake : "start";
+  if (wake === "repair") {
+    const prior = saved && Number.isFinite(saved.retries) ? saved.retries : 0;
+    const key = missKey(proved);
+    if (saved && saved.missKey === key && prior > 0) return `retry ${prior}`;
+    const next = prior + 1;
+    if (saved) {
+      saved.retries = next;
+      saved.missKey = key;
+    }
+    return `retry ${next}`;
+  }
+  if (saved) {
+    saved.retries = 0;
+    delete saved.missKey;
+  }
+  if (wake === "continue" || wake === "stop" || wake === "start") return wake;
+  return "start";
+}
+
+function isMissPlan(line) {
+  return typeof line === "string" && line.startsWith("The work is ");
+}
+
+function missWork(missing) {
+  const words = { loop: "the ticket", domain: "the plate", state: "the record", foundry: "the mill" };
+  const parts = (Array.isArray(missing) ? missing : []).map((name) => words[name]).filter(Boolean);
+  if (parts.length === 1) return `The work is ${parts[0]}.`;
+  if (parts.length > 1) {
+    const last = parts[parts.length - 1];
+    return `The work is ${parts.slice(0, -1).join(", ")} and ${last}.`;
+  }
+  return "The work is the suit.";
+}
+
+function wakeOrder(saved, proved, fields) {
+  const missing = proved && Array.isArray(proved.missing) ? proved.missing : [];
+  const sameJob = Boolean(saved && saved.priorIntent && saved.intent === saved.priorIntent);
+  const suitMiss = missing.some((name) => name === "domain" || name === "foundry" || name === "state");
+  if (proved && proved.on) {
+    const paused = saved && typeof saved.pausedPlan === "string" ? saved.pausedPlan : "";
+    if (isMissPlan(fields && fields.planLine) && saved && Object.prototype.hasOwnProperty.call(saved, "pausedPlan")) {
+      return { wake: "continue", planLine: paused, pausedPlan: undefined };
+    }
+    return { wake: "continue", pausedPlan: undefined };
+  }
+  if (!saved || !saved.priorIntent) return { wake: "start" };
+  if (saved.intent && saved.priorIntent && saved.intent !== saved.priorIntent) {
+    return { wake: "stop", pausedPlan: undefined };
+  }
+  if (sameJob && !missing.includes("loop") && suitMiss) {
+    const current = fields && fields.planLine ? String(fields.planLine) : "";
+    const paused = isMissPlan(current)
+      ? (typeof saved.pausedPlan === "string" ? saved.pausedPlan : "")
+      : current;
+    return { wake: "repair", planLine: missWork(missing), pausedPlan: paused };
+  }
+  return { wake: "start" };
+}
+
 function writeStationMarkdown(root, fields) {
   try {
     const dir = join(root, ".xray", "state");
     mkdirSync(dir, { recursive: true });
+    const arrivedKnown = Boolean(fields && Object.prototype.hasOwnProperty.call(fields, "arrivedHook"));
+    const wake = arrivedKnown
+      ? String(fields.arrivedHook || "")
+      : String((fields && fields.hookEvent) || "");
+    if (/^(session_start|session-start|pre_compact|post_compact)$/i.test(wake)) {
+      try {
+        runFoundryMill(root);
+      } catch {
+        /* the card still writes when the mill does not */
+      }
+    }
+    const dest = stationMarkdownPath(root);
+    const base = { ...(fields || {}) };
+    delete base.sleeveLine;
+    writeFileSync(dest, mergeStationMarkdown(formatStationMarkdown(base), readExistingStationMarkdown(root)));
+    // Solar phase is not this judgement. The moral overlay cannot pass alone.
+    fields.plane = readHeldPlane(root);
+    fields.payments = ticketIsPayment(fields.intent) ? "on" : "off";
+    let sleeveLine = "Sleeve: off loop, domain, state, foundry";
+    try {
+      const proved = readSleeve(root);
+      sleeveLine = formatSleevePointer(proved);
+      const workingPath = join(root, ".xray", "state", "repertoire-working.json");
+      if (existsSync(workingPath)) {
+        const saved = JSON.parse(readFileSync(workingPath, "utf8"));
+        if (saved && typeof saved === "object") {
+          const order = wakeOrder(saved, proved, fields);
+          fields.wake = order.wake;
+          if (Object.prototype.hasOwnProperty.call(order, "planLine")) {
+            fields.planLine = order.planLine;
+          }
+          fields.judgement = judgementLine(order, saved, proved);
+          saved.wake = order.wake;
+          saved.retries = saved.retries || 0;
+          saved.judgement = fields.judgement;
+          saved.plane = fields.plane;
+          saved.payments = fields.payments;
+          if (order.pausedPlan !== undefined) saved.pausedPlan = order.pausedPlan;
+          else delete saved.pausedPlan;
+          saved.sleeve = {
+            on: proved.on,
+            missing: proved.missing,
+            stitches: proved.stitches,
+          };
+          writeFileSync(workingPath, `${JSON.stringify(saved)}\n`);
+        }
+      }
+    } catch {
+      /* the card still writes; the sleeve stays off */
+    }
+    writeFileSync(
+      dest,
+      mergeStationMarkdown(
+        formatStationMarkdown({ ...(fields || {}), sleeveLine }),
+        readExistingStationMarkdown(root),
+      ),
+    );
     try {
       const plate = recallPlate(fields && fields.intent);
-      if (plate) stampPlateIfMissing(root, plate.id);
+      if (plate) ensureWornPlate(root, plate.id);
     } catch {
       /* a missing plate doc must not block the card */
     }
-    const dest = stationMarkdownPath(root);
-    const next = mergeStationMarkdown(formatStationMarkdown(fields), readExistingStationMarkdown(root));
-    writeFileSync(dest, next);
     return dest;
   } catch {
     return null;

package/dist/integrations/hooks/wake-cascade.cjs

@@ -0,0 +1,102 @@
+/**
+ * One wake hands the lens, the ticket, the laws, and the current notes.
+ * Goggles names plane record-map.
+ * The station module writes STATION.md and NOTES.md.
+ * Repertoire keeps the law list.
+ * The current session-note index sits beside that list.
+ * The card carries the count. A memory look carries the current lines.
+ */
+const { existsSync, readFileSync } = require("fs");
+const { join } = require("path");
+const { shortSessionIndex } = require("./session-note-index.cjs");
+
+const CASCADE_PLANE = "record-map";
+const MEMORY_PLANES = ["record-map", "station-card", "notes-page", "memory-recall"];
+
+function isCascadePlane(id) {
+  return MEMORY_PLANES.includes(String(id || ""));
+}
+
+function clipNames(names) {
+  if (!Array.isArray(names)) return [];
+  const out = [];
+  for (const raw of names) {
+    const name = String(raw || "").trim();
+    if (!name || out.includes(name)) continue;
+    out.push(name);
+    if (out.length >= 8) break;
+  }
+  return out;
+}
+
+function lawNamesFromWorking(root) {
+  const file = join(root, ".xray", "state", "repertoire-working.json");
+  if (!existsSync(file)) return [];
+  try {
+    const data = JSON.parse(readFileSync(file, "utf8"));
+    return clipNames(data && data.matchedSignals);
+  } catch {
+    return [];
+  }
+}
+
+function currentNotes(root) {
+  try {
+    return shortSessionIndex(root).map((note) => {
+      const row = { id: note.id, text: note.text };
+      if (note.slot) row.slot = note.slot;
+      return row;
+    });
+  } catch {
+    return [];
+  }
+}
+
+/** Laws come from this wake when passed. Otherwise the working file. Notes are current lines only. */
+function readWakeCascade(root, opts = {}) {
+  const laws = Array.isArray(opts.laws) ? clipNames(opts.laws) : lawNamesFromWorking(root);
+  return {
+    plane: CASCADE_PLANE,
+    station: ".xray/state/STATION.md",
+    notesPage: ".xray/state/NOTES.md",
+    index: ".xray/state/repertoire/session-notes.json",
+    laws,
+    notes: currentNotes(root),
+  };
+}
+
+function formatCascadePointer(cascade) {
+  const count = cascade && Array.isArray(cascade.notes) ? cascade.notes.length : 0;
+  const plane = cascade && cascade.plane ? cascade.plane : CASCADE_PLANE;
+  return `Cascade: ${plane} · notes ${count} current`;
+}
+
+function formatCascadeReading(cascade) {
+  const plane = cascade && cascade.plane ? cascade.plane : CASCADE_PLANE;
+  const laws = cascade && Array.isArray(cascade.laws) && cascade.laws.length
+    ? cascade.laws.join(", ")
+    : "(none yet)";
+  const notes = cascade && Array.isArray(cascade.notes) ? cascade.notes : [];
+  const lines = [
+    `Cascade: ${plane}`,
+    `Station: ${cascade && cascade.station ? cascade.station : ".xray/state/STATION.md"}`,
+    `Notes page: ${cascade && cascade.notesPage ? cascade.notesPage : ".xray/state/NOTES.md"}`,
+    `Index: ${cascade && cascade.index ? cascade.index : ".xray/state/repertoire/session-notes.json"}`,
+    `Laws: ${laws}`,
+    `Notes: ${notes.length} current`,
+  ];
+  for (const note of notes) {
+    const slot = note.slot ? `${note.slot} ` : "";
+    lines.push(`- ${note.id} ${slot}${note.text}`);
+  }
+  return lines.join("\n");
+}
+
+module.exports = {
+  CASCADE_PLANE,
+  MEMORY_PLANES,
+  isCascadePlane,
+  readWakeCascade,
+  formatCascadePointer,
+  formatCascadeReading,
+};

package/dist/integrations/hooks/wake-cascade.mjs

@@ -0,0 +1,16 @@
+/**
+ * ESM face for wake-cascade.cjs.
+ */
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+
+const require = createRequire(import.meta.url);
+const impl = require(join(dirname(fileURLToPath(import.meta.url)), "wake-cascade.cjs"));
+
+export const CASCADE_PLANE = impl.CASCADE_PLANE;
+export const MEMORY_PLANES = impl.MEMORY_PLANES;
+export const isCascadePlane = impl.isCascadePlane;
+export const readWakeCascade = impl.readWakeCascade;
+export const formatCascadePointer = impl.formatCascadePointer;
+export const formatCascadeReading = impl.formatCascadeReading;

package/dist/integrations/openclaw/plugin/xray-pre-tool/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xray-pre-tool",
-  "version": "4.0.40",
+  "version": "4.0.42",
   "private": true,
   "type": "module",
   "description": "0xRay constitution + temperament PreToolUse for OpenClaw",

package/dist/mcps/architect-tools.server.d.ts

@@ -5,6 +5,12 @@
  * Provides contextual analysis capabilities via MCP protocol
  */
 import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+import { type GovernanceVote } from "../governance/llm-governance-provider.js";
+import { type ArchitectureAssessment } from "../architect/architect-tools.js";
+export type ConferModelVerdict = "PASS" | "CONDITIONAL" | "FAIL" | "UNREVIEWED";
+/** A confer verdict counts only when a model vote exists. Metrics alone are UNREVIEWED. */
+export declare function conferVerdictFromModelVote(vote: Pick<GovernanceVote, "decision"> | null): ConferModelVerdict;
+export declare function formatArchitectureAssessmentConferText(conferPrompt: string, assessment: ArchitectureAssessment, verdict?: ConferModelVerdict): string;
 export declare function renderArchitectureAssessment(args: Record<string, unknown> | undefined): Promise<{
     content: Array<{
         type: "text";

package/dist/mcps/architect-tools.server.js

@@ -8,7 +8,24 @@ import { CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
 import * as fs from "fs";
 import { frameworkLogger } from "../core/framework-logger.js";
-import { contextAnalysis as architectContextAnalysis, codebaseStructure as architectCodebaseStructure, dependencyAnalysis as architectDependencyAnalysis, architectureAssessment as architectArchitectureAssessment, formatConferArchitectureText, } from "../architect/architect-tools.js";
+import { contextAnalysis as architectContextAnalysis, codebaseStructure as architectCodebaseStructure, dependencyAnalysis as architectDependencyAnalysis, architectureAssessment as architectArchitectureAssessment, } from "../architect/architect-tools.js";
+/** A confer verdict counts only when a model vote exists. Metrics alone are UNREVIEWED. */
+export function conferVerdictFromModelVote(vote) {
+    if (!vote)
+        return "UNREVIEWED";
+    if (vote.decision === "reject")
+        return "FAIL";
+    if (vote.decision === "approve")
+        return "PASS";
+    return "CONDITIONAL";
+}
+export function formatArchitectureAssessmentConferText(conferPrompt, assessment, verdict = "UNREVIEWED") {
+    const assessmentJson = JSON.stringify(assessment, null, 2);
+    const trimmed = conferPrompt.trim();
+    if (!trimmed)
+        return assessmentJson;
+    return `${trimmed}\n\n## Architecture assessment\n${assessmentJson}\n\nVerdict: ${verdict}\nTop risks: review assessment metrics above\nHardening: address high-complexity or coupling findings before resuming`;
+}
 export async function renderArchitectureAssessment(args) {
     const projectRoot = typeof args?.projectRoot === "string" ? args.projectRoot : "";
     const assessmentType = args?.assessmentType === "quick" || args?.assessmentType === "comprehensive"
@@ -21,7 +38,7 @@ export async function renderArchitectureAssessment(args) {
         content: [
             {
                 type: "text",
-                text: formatConferArchitectureText(conferPrompt, result),
+                text: formatArchitectureAssessmentConferText(conferPrompt, result, "UNREVIEWED"),
             },
         ],
     };

package/dist/mcps/config/server-config-registry.js

@@ -10,6 +10,8 @@ import { frameworkLogger } from '../../core/framework-logger.js';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 import fs from 'fs';
+/** Must outlast the 120s governance model call so a real approve can return. */
+const GOVERNANCE_MODEL_TIMEOUT_MS = 150_000;
 /**
  * Registry for managing MCP server configurations
  */
@@ -85,14 +87,14 @@ export class ServerConfigRegistry {
             serverName: 'code-review',
             command: 'node',
             args: [`${basePath}/knowledge-skills/code-review.server.js`],
-            timeout: 30000,
+            timeout: GOVERNANCE_MODEL_TIMEOUT_MS,
         });
         // Security Audit Server
         this.register({
             serverName: 'security-audit',
             command: 'node',
             args: [`${basePath}/knowledge-skills/security-audit.server.js`],
-            timeout: 45000,
+            timeout: GOVERNANCE_MODEL_TIMEOUT_MS,
         });
         // Performance Optimization Server
         this.register({
@@ -113,7 +115,7 @@ export class ServerConfigRegistry {
             serverName: 'researcher',
             command: 'node',
             args: [`${basePath}/researcher.server.js`],
-            timeout: 60000,
+            timeout: GOVERNANCE_MODEL_TIMEOUT_MS,
         });
         // Governance Service (meta-MCP that orchestrates the three skill servers + required external Dynamo)
         this.register({
@@ -176,7 +178,7 @@ export class ServerConfigRegistry {
             serverName: 'architect',
             command: 'node',
             args: [`${basePath}/architect-tools.server.js`],
-            timeout: 45000,
+            timeout: GOVERNANCE_MODEL_TIMEOUT_MS,
         });
         // Bug Triage Specialist Server
         this.register({
@@ -198,14 +200,14 @@ export class ServerConfigRegistry {
             serverName: 'code-reviewer',
             command: 'node',
             args: [`${basePath}/knowledge-skills/code-review.server.js`],
-            timeout: 30000,
+            timeout: GOVERNANCE_MODEL_TIMEOUT_MS,
         });
         // Security Auditor (alias for security-audit)
         this.register({
             serverName: 'security-auditor',
             command: 'node',
             args: [`${basePath}/knowledge-skills/security-audit.server.js`],
-            timeout: 45000,
+            timeout: GOVERNANCE_MODEL_TIMEOUT_MS,
         });
         // Refactorer Server
         this.register({

package/dist/mcps/governance.server.d.ts

@@ -24,6 +24,7 @@ declare class GovernanceServer extends XrayKnowledgeSkillBase {
     private armRequiredDynamo;
     private handleGovernProposals;
     private handleGovernReflection;
+    private handleRecordConferReceipt;
     private handleGetActiveCodex;
     private parseCodexTermsFromReflection;
     private initializeGovernance;

package/dist/mcps/governance.server.js

@@ -20,6 +20,7 @@ import { featuresConfigLoader } from "../core/features-config.js";
 import * as fs from "fs";
 import { fileURLToPath } from "url";
 import { randomUUID } from "crypto";
+import { applyConferConsultResult } from "../nucleus/confer.js";
 import { getGovernanceService } from "../governance/governance-service.js";
 import { getCodexPolicyService } from "../governance/codex-policy.service.js";
 import { initializeGovernanceIntegration } from "../integrations/governance/index.js";
@@ -95,6 +96,23 @@ class GovernanceServer extends XrayKnowledgeSkillBase {
                     required: [],
                 },
             },
+            {
+                name: "record_confer_receipt",
+                description: "Record a confer verdict written by the wearing TUI. " +
+                    "The TUI already called the seat's MCP server. This tool stores the receipt. " +
+                    "Only Verdict: PASS completes the consult todo.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        todoId: { type: "string", description: "Consult todo id, such as s.1" },
+                        subagent: { type: "string", description: "researcher, architect-tools, or code-review" },
+                        sessionId: { type: "string", description: "Plan session id" },
+                        outputText: { type: "string", description: "Host verdict text, including a Verdict line" },
+                        projectRoot: { type: "string", description: "Checkout root. Defaults to XRAY_ROOT or the process cwd." },
+                    },
+                    required: ["todoId", "subagent", "sessionId", "outputText"],
+                },
+            },
             {
                 name: "get_active_codex",
                 description: "Get the currently active Codex (SSOT) — returns metadata about the loaded codex terms, " +
@@ -117,6 +135,7 @@ class GovernanceServer extends XrayKnowledgeSkillBase {
             "govern_proposals": async (args) => this.handleGovernProposals(this.validateGovernProposalsArgs(args)),
             "govern_reflection": async (args) => this.handleGovernReflection(this.validateGovernReflectionArgs(args)),
             "get_active_codex": async (args) => this.handleGetActiveCodex(args),
+            "record_confer_receipt": async (args) => this.handleRecordConferReceipt(args),
         };
         this.setupToolHandlers();
     }
@@ -163,6 +182,8 @@ class GovernanceServer extends XrayKnowledgeSkillBase {
                         return await this.handleGovernReflection(this.validateGovernReflectionArgs(args));
                     case "get_active_codex":
                         return await this.handleGetActiveCodex(args);
+                    case "record_confer_receipt":
+                        return await this.handleRecordConferReceipt(args);
                     default:
                         throw new Error(`Unknown tool: ${name}`);
                 }
@@ -272,6 +293,31 @@ class GovernanceServer extends XrayKnowledgeSkillBase {
             options: { require_external: true },
         });
     }
+    async handleRecordConferReceipt(args) {
+        if (!args || typeof args !== "object") {
+            throw new Error("record_confer_receipt requires an object argument");
+        }
+        const obj = args;
+        const todoId = typeof obj.todoId === "string" ? obj.todoId.trim() : "";
+        const subagent = typeof obj.subagent === "string" ? obj.subagent.trim() : "";
+        const sessionId = typeof obj.sessionId === "string" ? obj.sessionId.trim() : "";
+        const outputText = typeof obj.outputText === "string" ? obj.outputText : "";
+        if (!todoId || !subagent || !sessionId || !outputText.trim()) {
+            throw new Error("record_confer_receipt requires todoId, subagent, sessionId, and outputText");
+        }
+        const projectRoot = typeof obj.projectRoot === "string" && obj.projectRoot.trim()
+            ? obj.projectRoot
+            : process.env.XRAY_ROOT || process.cwd();
+        const result = applyConferConsultResult(todoId, subagent, sessionId, outputText, projectRoot);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(result),
+                },
+            ],
+        };
+    }
     async handleGetActiveCodex(args) {
         const includeRaw = args?.includeRaw === true;
         const snapshot = await getCodexPolicyService().getCurrentCodex(includeRaw);

package/dist/mcps/knowledge-skills/code-review.server.js

@@ -9,6 +9,7 @@ import * as fs from "fs";
 import * as path from "path";
 import { isGovernanceLlmConfigured, tryLLMGovernance, } from "../../governance/llm-governance-provider.js";
 import { formatGovernanceVoteText, localConferVote } from "../../governance/local-confer.js";
+import { buildHostConferEvidence } from "../../nucleus/confer-host.js";
 class XrayCodeReviewServer extends XrayKnowledgeSkillBase {
     constructor() {
         super("code-review", "3.1.0");
@@ -316,6 +317,12 @@ class XrayCodeReviewServer extends XrayKnowledgeSkillBase {
      */
     async analyzeProposal(args) {
         const { proposalTitle = "", proposalDescription = "", evidence = [], proposalType = "" } = args;
+        if (proposalType === "synthesis-confer") {
+            const packet = [proposalTitle, proposalDescription, ...(evidence || [])].filter(Boolean).join("\n\n");
+            return {
+                content: [{ type: "text", text: buildHostConferEvidence("code-review", packet) }],
+            };
+        }
         const vote = (await tryLLMGovernance("code-review", proposalTitle, proposalDescription, evidence, proposalType)) ??
             localConferVote({
                 role: "code-review",