0xray 4.0.41 → 4.1.0

package/dist/monitoring/{nudge-watchdog.d.ts → nudge-monitor.d.ts}

@@ -1,5 +1,5 @@
 /**
- * Nudge Watchdog - Detects and breaks stuck AI patterns
+ * Nudge Monitor - Detects and breaks stuck AI patterns
  *
  * Monitors agent actions and detects common failure patterns:
  * - think-loop: AI keeps outputting thinking tags but no progress
@@ -8,7 +8,7 @@
  * - tool-loop: Same tool called with similar args repeatedly
  * - repair-failure: Processor indicates fix but error persists
  *
- * @module monitoring/nudge-watchdog
+ * @module monitoring/nudge-monitor
  */
 import { EventEmitter } from "events";
 export interface NudgeConfig {
@@ -33,7 +33,16 @@ export interface NudgeAction {
     suggestion: string;
     priority: number;
 }
-declare class NudgeWatchdog extends EventEmitter {
+/** Old config key from before the rename to nudge_monitor; still read as a deprecated alias. */
+export declare const LEGACY_NUDGE_CONFIG_KEY = "nudge_watchdog";
+/**
+ * features.nudge_monitor, or the deprecated features.nudge_watchdog when nudge_monitor is unset (the new key wins
+ * when both are set). Using the old key logs a one-time deprecation warning.
+ */
+export declare function resolveNudgeConfig(features: Record<string, unknown> | undefined | null, warn?: (message: string) => void): Record<string, unknown> | undefined;
+/** Test hook: let the one-time deprecation warning fire again. */
+export declare function resetLegacyNudgeWarning(): void;
+declare class NudgeMonitor extends EventEmitter {
     private config;
     private patterns;
     private lastNudgeTime;
@@ -75,13 +84,13 @@ declare class NudgeWatchdog extends EventEmitter {
     };
     private log;
 }
-export declare const nudgeWatchdog: NudgeWatchdog;
+export declare const nudgeMonitor: NudgeMonitor;
 export declare function recordThinkTag(): void;
 export declare function recordCodeChange(): void;
 export declare function recordToolCall(tool: string, args: string): void;
 export declare function recordFixAttempt(filePath: string, error: string): void;
 export declare function recordExplanation(): void;
 export declare function getNudgeSuggestion(type: NudgeType, context?: Record<string, unknown>): string;
-export declare function getNudgeWatchdog(): NudgeWatchdog;
+export declare function getNudgeMonitor(): NudgeMonitor;
 export declare function recordProcessorFix(filePath: string, fixed: boolean, errorPersisted: boolean): void;
 export {};

package/dist/monitoring/{nudge-watchdog.js → nudge-monitor.js}

@@ -1,5 +1,5 @@
 /**
- * Nudge Watchdog - Detects and breaks stuck AI patterns
+ * Nudge Monitor - Detects and breaks stuck AI patterns
  *
  * Monitors agent actions and detects common failure patterns:
  * - think-loop: AI keeps outputting thinking tags but no progress
@@ -8,7 +8,7 @@
  * - tool-loop: Same tool called with similar args repeatedly
  * - repair-failure: Processor indicates fix but error persists
  *
- * @module monitoring/nudge-watchdog
+ * @module monitoring/nudge-monitor
  */
 import { EventEmitter } from "events";
 import { frameworkLogger } from "../core/framework-logger.js";
@@ -53,7 +53,32 @@ const NUDGE_MESSAGES = {
         priority: 5,
     },
 };
-class NudgeWatchdog extends EventEmitter {
+/** Old config key from before the rename to nudge_monitor; still read as a deprecated alias. */
+export const LEGACY_NUDGE_CONFIG_KEY = "nudge_watchdog";
+let legacyKeyWarned = false;
+/**
+ * features.nudge_monitor, or the deprecated features.nudge_watchdog when nudge_monitor is unset (the new key wins
+ * when both are set). Using the old key logs a one-time deprecation warning.
+ */
+export function resolveNudgeConfig(features, warn = (m) => frameworkLogger.log("nudge-monitor", "deprecated-config-key", "warning", { message: m })) {
+    const current = features?.nudge_monitor;
+    if (current !== undefined && current !== null)
+        return current;
+    const legacy = features?.[LEGACY_NUDGE_CONFIG_KEY];
+    if (legacy !== undefined && legacy !== null) {
+        if (!legacyKeyWarned) {
+            legacyKeyWarned = true;
+            warn(`features.${LEGACY_NUDGE_CONFIG_KEY} is deprecated; rename it to features.nudge_monitor`);
+        }
+        return legacy;
+    }
+    return undefined;
+}
+/** Test hook: let the one-time deprecation warning fire again. */
+export function resetLegacyNudgeWarning() {
+    legacyKeyWarned = false;
+}
+class NudgeMonitor extends EventEmitter {
     config;
     patterns = new Map();
     lastNudgeTime = 0;
@@ -73,7 +98,7 @@ class NudgeWatchdog extends EventEmitter {
     loadConfigFromFeatures() {
         try {
             const features = featuresConfigLoader.loadConfig();
-            const nudgeConfig = features?.nudge_watchdog;
+            const nudgeConfig = resolveNudgeConfig(features);
             if (nudgeConfig) {
                 this.config = { ...this.config, ...nudgeConfig };
             }
@@ -86,10 +111,10 @@ class NudgeWatchdog extends EventEmitter {
         if (!this.config.enabled) {
             return;
         }
-        this.log("nudge-watchdog", "started", "info", { config: this.config });
+        this.log("nudge-monitor", "started", "info", { config: this.config });
     }
     stop() {
-        this.log("nudge-watchdog", "stopped", "info");
+        this.log("nudge-monitor", "stopped", "info");
     }
     recordThinkTag() {
         const now = Date.now();
@@ -256,7 +281,7 @@ class NudgeWatchdog extends EventEmitter {
         if (!action)
             return null;
         this.emit("nudge", action);
-        this.log("nudge-watchdog", "nudge-triggered", "warning", {
+        this.log("nudge-monitor", "nudge-triggered", "warning", {
             type: action.type,
             message: action.message,
             suggestion: action.suggestion,
@@ -328,28 +353,28 @@ class NudgeWatchdog extends EventEmitter {
         }
     }
 }
-export const nudgeWatchdog = new NudgeWatchdog();
+export const nudgeMonitor = new NudgeMonitor();
 export function recordThinkTag() {
-    nudgeWatchdog.recordThinkTag();
+    nudgeMonitor.recordThinkTag();
 }
 export function recordCodeChange() {
-    nudgeWatchdog.recordCodeChange();
+    nudgeMonitor.recordCodeChange();
 }
 export function recordToolCall(tool, args) {
-    nudgeWatchdog.recordToolCall(tool, args);
+    nudgeMonitor.recordToolCall(tool, args);
 }
 export function recordFixAttempt(filePath, error) {
-    nudgeWatchdog.recordFixAttempt(filePath, error);
+    nudgeMonitor.recordFixAttempt(filePath, error);
 }
 export function recordExplanation() {
-    nudgeWatchdog.recordExplanation();
+    nudgeMonitor.recordExplanation();
 }
 export function getNudgeSuggestion(type, context) {
-    return nudgeWatchdog.getNudgeSuggestion(type, context);
+    return nudgeMonitor.getNudgeSuggestion(type, context);
 }
-export function getNudgeWatchdog() {
-    return nudgeWatchdog;
+export function getNudgeMonitor() {
+    return nudgeMonitor;
 }
 export function recordProcessorFix(filePath, fixed, errorPersisted) {
-    nudgeWatchdog.recordProcessorFix(filePath, fixed, errorPersisted);
+    nudgeMonitor.recordProcessorFix(filePath, fixed, errorPersisted);
 }

package/dist/nucleus/autonomy-kernel.d.ts

@@ -38,6 +38,8 @@ export interface LeadDevPlan {
         fullSuiteGate: boolean;
         hint: string;
     };
+    /** New id each synthesis plan. Receipts from an older id cannot complete s.1–s.3. */
+    consultCycleId?: string;
 }
 export declare function isLeadDevModeActive(): boolean;
 export declare function routeSubagent(taskType: string): SubagentRoute;

package/dist/nucleus/autonomy-kernel.js

@@ -2,11 +2,11 @@
  * Lead-dev plan builder — internal implementation for orchestrator + hooks.
  * Config: features.json → multi_agent_orchestration (lead_dev_mode), NOT a separate surface.
  */
+import { randomUUID } from 'node:crypto';
 import * as fs from 'fs';
 import * as path from 'path';
 import { featuresConfigLoader } from '../core/features-config.js';
 import { scoreComplexity } from './thin-dispatch.js';
-import { conferDefaultForProfile, resolveRuntimeSuitProfile } from './suit-temperament.js';
 export const LEAD_DEV_RULES = [
     'Phased plan + detailed todos; assign best subagent; monitor output; iterate fully',
     'Lead dev takes helm — loop test fix until complete; no permission pings',
@@ -33,6 +33,19 @@ const TASK_TYPE_ROUTES = {
     security: 'security-audit',
     governance: 'enforcer',
 };
+function conferExplicitlyEnabled(projectRoot) {
+    const featuresPath = path.join(projectRoot, '.xray', 'features.json');
+    if (!fs.existsSync(featuresPath))
+        return false;
+    try {
+        const data = JSON.parse(fs.readFileSync(featuresPath, 'utf8'));
+        const orch = data.multi_agent_orchestration ?? {};
+        return orch.confer?.enabled === true || orch.confer_on_synthesis === true;
+    }
+    catch {
+        return false;
+    }
+}
 function orchestrationConfig() {
     try {
         return featuresConfigLoader.loadConfig().multi_agent_orchestration;
@@ -80,12 +93,7 @@ export function buildSynthesisCheckpointPlan(dueReason, projectRoot = process.cw
     if (!isLeadDevModeActive())
         return null;
     const cfg = orchestrationConfig();
-    const profile = resolveRuntimeSuitProfile(projectRoot);
-    const autoConsult = profile === 'frontier'
-        ? cfg.confer?.enabled === true || cfg.confer_on_synthesis === true
-        : profile === 'strict'
-            ? true
-            : cfg.auto_consult_major_work !== false;
+    const autoConsult = conferExplicitlyEnabled(projectRoot);
     const mandatoryConsults = autoConsult ? [...MANDATORY_MAJOR_CONSULTS] : [];
     if (mandatoryConsults.length === 0)
         return null;
@@ -118,13 +126,13 @@ export function buildSynthesisCheckpointPlan(dueReason, projectRoot = process.cw
             fullSuiteGate: false,
             hint: 'Synthesis checkpoint — consult mandatory agents before resuming gated work',
         },
+        consultCycleId: randomUUID(),
     };
 }
 export function buildLeadDevPlan(description, taskTypes = ['implement'], taskInputs = [], mcpOverallComplexity, projectRoot = process.cwd()) {
     if (!isLeadDevModeActive())
         return null;
     const cfg = orchestrationConfig();
-    const profile = resolveRuntimeSuitProfile(projectRoot);
     const threshold = cfg.phased_plan_threshold ?? 25;
     const score = scoreComplexity(description, { taskTypes });
     const mcpScore = mcpOverallComplexity !== undefined && Number.isFinite(mcpOverallComplexity)
@@ -132,11 +140,7 @@ export function buildLeadDevPlan(description, taskTypes = ['implement'], taskInp
         : 0;
     const complexity = Math.max(score.score, mcpScore);
     const requiresPhasedPlan = complexity > threshold || taskInputs.length > 1;
-    const autoConsult = profile === 'frontier'
-        ? cfg.confer?.enabled === true || cfg.confer_on_synthesis === true
-        : profile === 'strict' || conferDefaultForProfile(profile)
-            ? cfg.auto_consult_major_work !== false
-            : false;
+    const autoConsult = conferExplicitlyEnabled(projectRoot);
     const mandatoryConsults = autoConsult && requiresPhasedPlan ? [...MANDATORY_MAJOR_CONSULTS] : [];
     const phases = requiresPhasedPlan
         ? [

package/dist/nucleus/confer-host.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Confer host port. The wearing TUI already spawned the MCP servers.
+ * This port writes the ask or returns the host's answer. It does not spawn a server.
+ */
+export interface ConferHostSeat {
+    todoId: string;
+    subagent: string;
+    server: string;
+    tool: string;
+    args: Record<string, unknown>;
+    sessionId: string;
+    prompt: string;
+    dueReason: string | null;
+}
+export type ConferHostCall = {
+    status: 'pending';
+    askPath: string;
+} | {
+    status: 'answered';
+    text: string;
+};
+export interface ConferHostPort {
+    call(seat: ConferHostSeat, projectRoot: string): Promise<ConferHostCall>;
+}
+export declare function conferAskPath(todoId: string, projectRoot: string): string;
+/** Evidence for the host model. The schema line is not a vote. */
+export declare function buildHostConferEvidence(role: string, evidence: string): string;
+export declare class SessionConferHost implements ConferHostPort {
+    call(seat: ConferHostSeat, projectRoot: string): Promise<ConferHostCall>;
+}
+export declare class InProcessConferHost implements ConferHostPort {
+    private readonly answers;
+    constructor(answers: Record<string, string>);
+    call(seat: ConferHostSeat): Promise<ConferHostCall>;
+}

package/dist/nucleus/confer-host.js

@@ -0,0 +1,55 @@
+/**
+ * Confer host port. The wearing TUI already spawned the MCP servers.
+ * This port writes the ask or returns the host's answer. It does not spawn a server.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+export function conferAskPath(todoId, projectRoot) {
+    return path.join(projectRoot, '.xray', 'state', `confer-ask-${todoId}.json`);
+}
+/** Evidence for the host model. The schema line is not a vote. */
+export function buildHostConferEvidence(role, evidence) {
+    const body = evidence.trim();
+    return [
+        `## Confer evidence — ${role}`,
+        '',
+        body || 'No local evidence. The wearing TUI has the confer ask.',
+        '',
+        'The wearing TUI writes the verdict on its own line after this evidence.',
+        '',
+        'Verdict: PASS | CONDITIONAL | FAIL',
+        '- Top risks (bulleted)',
+        '- Hardening note / recommendations',
+    ].join('\n');
+}
+export class SessionConferHost {
+    async call(seat, projectRoot) {
+        const askPath = conferAskPath(seat.todoId, projectRoot);
+        fs.mkdirSync(path.dirname(askPath), { recursive: true });
+        const payload = {
+            todoId: seat.todoId,
+            subagent: seat.subagent,
+            server: seat.server,
+            tool: seat.tool,
+            args: seat.args,
+            sessionId: seat.sessionId,
+            prompt: seat.prompt,
+            dueReason: seat.dueReason,
+        };
+        fs.writeFileSync(askPath, `${JSON.stringify(payload, null, 2)}\n`);
+        return { status: 'pending', askPath };
+    }
+}
+export class InProcessConferHost {
+    answers;
+    constructor(answers) {
+        this.answers = answers;
+    }
+    async call(seat) {
+        const text = this.answers[seat.todoId] ?? this.answers[seat.subagent];
+        if (text === undefined) {
+            return { status: 'pending', askPath: '' };
+        }
+        return { status: 'answered', text };
+    }
+}

package/dist/nucleus/confer.d.ts

@@ -3,6 +3,9 @@
  * Triggered automatically at synthesis checkpoint; records consult receipts + plan todos.
  */
 import { type SynthesisConsultReceipt } from './synthesis-consult-receipt.js';
+import { InProcessConferHost, SessionConferHost, type ConferHostPort, type ConferHostSeat } from './confer-host.js';
+export { InProcessConferHost, SessionConferHost };
+export type { ConferHostPort, ConferHostSeat };
 export declare const CONFER_AGENTS: readonly ["researcher", "architect-tools", "code-review"];
 export interface ConferConfig {
     enabled: boolean;
@@ -27,12 +30,16 @@ export interface ConferAgentResult {
     error?: string;
 }
 export interface ConferQuorumResult {
-    status: 'completed' | 'partial' | 'skipped' | 'failed';
+    status: 'completed' | 'partial' | 'skipped' | 'failed' | 'pending';
     agents: ConferAgentResult[];
     message: string;
 }
 export declare function conferCheckpointPath(projectRoot?: string): string;
 export declare function defaultConferConfig(): ConferConfig;
+/** Fixture PASS is a test harness. Live orchestrate-task and XRAY_CONFER_FIXTURE cannot reach it. */
+export declare const CONFER_FIXTURE_UNREACHABLE = "Confer fixture is unreachable outside tests";
+export declare function conferFixtureAllowed(): boolean;
+/** A suit profile does not enable Confer. Missing confer key stays off, including strict. */
 export declare function loadConferConfig(projectRoot?: string): ConferConfig;
 export declare function isConferEnabled(projectRoot?: string): boolean;
 export declare function loadConferCheckpoint(projectRoot?: string): ConferCheckpointState | null;
@@ -46,12 +53,21 @@ export declare function conferAgentMcpTarget(subagent: string): {
     tool: string;
     args: (prompt: string, projectRoot: string) => Record<string, unknown>;
 };
-export declare function invokeConferAgent(subagent: string, prompt: string, projectRoot?: string): Promise<string>;
+export declare function invokeConferAgent(subagent: string, prompt: string, projectRoot?: string, host?: ConferHostPort, sessionId?: string, todoId?: string, dueReason?: string | null): Promise<string>;
 export declare function applyConferConsultResult(todoId: string, subagent: string, sessionId: string, outputText: string, projectRoot?: string): ConferAgentResult;
-export declare function writeFixtureConferReceipt(todoId: string, subagent: string, sessionId: string, projectRoot?: string): ConferAgentResult;
+export declare function buildFixtureConferOutput(subagent: string, verdict?: SynthesisConsultReceipt['verdict'], noLlm?: boolean): string;
+export declare function writeFixtureConferReceipt(todoId: string, subagent: string, sessionId: string, projectRoot?: string, verdict?: SynthesisConsultReceipt['verdict'], noLlm?: boolean): ConferAgentResult;
 export declare function runConferQuorum(projectRoot: string | undefined, sessionId: string, options?: {
     collocatedText?: string;
     dueReason?: string | null;
     fixture?: boolean;
+    /** Used only when fixture is true. Defaults to PASS. FAIL and UNREVIEWED do not complete the todo. */
+    fixtureVerdict?: SynthesisConsultReceipt['verdict'];
+    /** Fixture text is the real no-model localConferVote (UNREVIEWED), not a hardcoded PASS. */
+    fixtureNoLlm?: boolean;
+    /** Used only when fixture is true. Replaces the generated fixture text for every consult. */
+    fixtureOutput?: string;
+    /** Live path. Default writes an ask for the wearing TUI and does not spawn a server. */
+    host?: ConferHostPort;
 }): Promise<ConferQuorumResult>;
 export declare function formatConferQuorumReport(result: ConferQuorumResult): string;