0xray 4.0.41 → 4.0.42

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;

package/dist/nucleus/confer.js

@@ -6,45 +6,41 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { MANDATORY_MAJOR_CONSULTS } from './autonomy-kernel.js';
 import { areSynthesisConsultTodosComplete, getNextRequiredTodo, getSynthesisConsultTodos, isSynthesisRealignmentPlan, loadPersistedLeadDevPlan, updatePlanTodoStatus, } from './lead-dev-plan-persistence.js';
-import { buildReceiptFromConsultOutput, tryRecordSynthesisConsultReceipt, parseConsultVerdictFromText, } from './synthesis-consult-receipt.js';
+import { buildReceiptFromConsultOutput, consultVerdictBlocksCompletion, loadSynthesisConsultReceipt, tryRecordSynthesisConsultReceipt, parseConsultVerdictFromText, } from './synthesis-consult-receipt.js';
+import { formatGovernanceVoteText, localConferVote } from '../governance/local-confer.js';
 import { isSynthesisCheckpointDue } from './synthesis.js';
-import { conferDefaultForProfile, resolveRuntimeSuitProfile } from './suit-temperament.js';
+import { InProcessConferHost, SessionConferHost, } from './confer-host.js';
+export { InProcessConferHost, SessionConferHost };
 export const CONFER_AGENTS = [...MANDATORY_MAJOR_CONSULTS];
 const STATE_VERSION = 1;
 export function conferCheckpointPath(projectRoot = process.cwd()) {
     return path.join(projectRoot, '.xray', 'state', 'confer-checkpoint.json');
 }
 export function defaultConferConfig() {
-    return { enabled: true, on_synthesis: true };
+    return { enabled: false, on_synthesis: false };
 }
+/** Fixture PASS is a test harness. Live orchestrate-task and XRAY_CONFER_FIXTURE cannot reach it. */
+export const CONFER_FIXTURE_UNREACHABLE = 'Confer fixture is unreachable outside tests';
+export function conferFixtureAllowed() {
+    return process.env.NODE_ENV === 'test' || Boolean(process.env.VITEST);
+}
+/** A suit profile does not enable Confer. Missing confer key stays off, including strict. */
 export function loadConferConfig(projectRoot = process.cwd()) {
     const featuresPath = path.join(projectRoot, '.xray', 'features.json');
-    const profile = resolveRuntimeSuitProfile(projectRoot);
-    if (profile === 'strict') {
-        return { enabled: true, on_synthesis: true };
-    }
-    if (!fs.existsSync(featuresPath)) {
-        return conferDefaultForProfile(profile)
-            ? defaultConferConfig()
-            : { enabled: false, on_synthesis: false };
-    }
+    if (!fs.existsSync(featuresPath))
+        return defaultConferConfig();
     try {
         const data = JSON.parse(fs.readFileSync(featuresPath, 'utf8'));
         const orch = data.multi_agent_orchestration ?? {};
         const raw = orch.confer ?? {};
-        if (profile === 'frontier') {
-            const optedIn = raw.enabled === true || orch.confer_on_synthesis === true;
-            return { enabled: optedIn, on_synthesis: optedIn };
-        }
+        const optedIn = raw.enabled === true || orch.confer_on_synthesis === true;
         return {
-            enabled: raw.enabled !== false && orch.confer_on_synthesis !== false,
-            on_synthesis: raw.on_synthesis !== false && orch.confer_on_synthesis !== false,
+            enabled: optedIn,
+            on_synthesis: optedIn && raw.on_synthesis !== false,
         };
     }
     catch {
-        return conferDefaultForProfile(profile)
-            ? defaultConferConfig()
-            : { enabled: false, on_synthesis: false };
+        return defaultConferConfig();
     }
 }
 export function isConferEnabled(projectRoot = process.cwd()) {
@@ -116,7 +112,7 @@ export function conferAgentMcpTarget(subagent) {
     switch (subagent) {
         case 'architect-tools':
             return {
-                server: 'architect-tools',
+                server: 'xray-architect-tools',
                 tool: 'architecture-assessment',
                 args: (prompt, projectRoot) => ({
                     projectRoot,
@@ -127,7 +123,7 @@ export function conferAgentMcpTarget(subagent) {
             };
         case 'researcher':
             return {
-                server: 'researcher',
+                server: 'xray-researcher',
                 tool: 'analyze_proposal',
                 args: (prompt) => ({
                     proposalTitle: 'Synthesis confer — researcher',
@@ -139,7 +135,7 @@ export function conferAgentMcpTarget(subagent) {
         case 'code-review':
         default:
             return {
-                server: 'code-review',
+                server: 'xray-code-review',
                 tool: 'analyze_proposal',
                 args: (prompt) => ({
                     proposalTitle: 'Synthesis confer — code-review',
@@ -150,38 +146,37 @@ export function conferAgentMcpTarget(subagent) {
             };
     }
 }
-function extractMcpText(result) {
-    const content = result?.content;
-    if (Array.isArray(content)) {
-        return content.map((c) => c.text ?? '').join('\n');
-    }
-    if (typeof result === 'string')
-        return result;
-    try {
-        return JSON.stringify(result);
-    }
-    catch {
-        return String(result);
-    }
-}
-export async function invokeConferAgent(subagent, prompt, projectRoot = process.cwd()) {
-    const { mcpClientManager } = await import('../mcps/mcp-client.js');
+function conferHostSeat(subagent, prompt, projectRoot, sessionId, todoId, dueReason) {
     const target = conferAgentMcpTarget(subagent);
-    const args = target.args(prompt, projectRoot);
-    const result = await mcpClientManager.callServerTool(target.server, target.tool, args);
-    const text = extractMcpText(result);
+    return {
+        todoId,
+        subagent,
+        server: target.server,
+        tool: target.tool,
+        args: target.args(prompt, projectRoot),
+        sessionId,
+        prompt,
+        dueReason,
+    };
+}
+export async function invokeConferAgent(subagent, prompt, projectRoot = process.cwd(), host = new SessionConferHost(), sessionId = '', todoId = subagent, dueReason = null) {
+    const call = await host.call(conferHostSeat(subagent, prompt, projectRoot, sessionId, todoId, dueReason), projectRoot);
+    if (call.status === 'pending') {
+        throw new Error(`Confer ask pending for ${subagent} at ${call.askPath}`);
+    }
+    const text = call.text;
     if (!text.trim()) {
         throw new Error(`Empty confer response from ${subagent}`);
     }
     if (!parseConsultVerdictFromText(text)) {
-        throw new Error(`Confer response from ${subagent} missing parseable verdict (expected Verdict: PASS|CONDITIONAL|FAIL or DECISION: approve|reject|abstain)`);
+        throw new Error(`Confer response from ${subagent} missing parseable verdict (expected an explicit Verdict: PASS|CONDITIONAL|FAIL|UNREVIEWED line, or DECISION: approve|reject|abstain)`);
     }
     return text;
 }
 export function applyConferConsultResult(todoId, subagent, sessionId, outputText, projectRoot = process.cwd()) {
     const receipt = tryRecordSynthesisConsultReceipt(todoId, subagent, sessionId, outputText, projectRoot);
     let todoCompleted = false;
-    if (receipt && receipt.verdict !== 'FAIL') {
+    if (receipt && !consultVerdictBlocksCompletion(receipt.verdict)) {
         todoCompleted = updatePlanTodoStatus(todoId, 'completed', projectRoot);
     }
     return {
@@ -193,11 +188,24 @@ export function applyConferConsultResult(todoId, subagent, sessionId, outputText
         verdict: receipt?.verdict ?? buildReceiptFromConsultOutput(todoId, subagent, sessionId, outputText)?.verdict ?? null,
     };
 }
-export function writeFixtureConferReceipt(todoId, subagent, sessionId, projectRoot = process.cwd()) {
-    const output = `Verdict: PASS\nTop risks: none\nHardening: confer fixture quorum for ${subagent}`;
-    return applyConferConsultResult(todoId, subagent, sessionId, output, projectRoot);
+export function buildFixtureConferOutput(subagent, verdict = 'PASS', noLlm = false) {
+    if (noLlm) {
+        const role = subagent === 'code-review' ? 'code-review' : 'researcher';
+        return formatGovernanceVoteText(localConferVote({ role, llmConfigured: false }));
+    }
+    return `Verdict: ${verdict}\nTop risks: none\nHardening: confer fixture quorum for ${subagent}`;
+}
+export function writeFixtureConferReceipt(todoId, subagent, sessionId, projectRoot = process.cwd(), verdict = 'PASS', noLlm = false) {
+    return applyConferConsultResult(todoId, subagent, sessionId, buildFixtureConferOutput(subagent, verdict, noLlm), projectRoot);
 }
 export async function runConferQuorum(projectRoot = process.cwd(), sessionId, options = {}) {
+    if (options.fixture && !conferFixtureAllowed()) {
+        return {
+            status: 'failed',
+            agents: [],
+            message: CONFER_FIXTURE_UNREACHABLE,
+        };
+    }
     const cfg = loadConferConfig(projectRoot);
     if (!cfg.enabled || !cfg.on_synthesis) {
         return {
@@ -214,7 +222,7 @@ export async function runConferQuorum(projectRoot = process.cwd(), sessionId, op
             message: 'No synthesis realignment plan — confer not applicable',
         };
     }
-    if (areSynthesisConsultTodosComplete(plan)) {
+    if (areSynthesisConsultTodosComplete(plan) && consultReceiptsAreRealApproves(plan, sessionId, projectRoot)) {
         return {
             status: 'completed',
             agents: [],
@@ -228,17 +236,36 @@ export async function runConferQuorum(projectRoot = process.cwd(), sessionId, op
         '# Synthesis confer\n\nReview checkpoint context and realign plan.';
     const agents = [];
     for (const todo of getSynthesisConsultTodos(plan)) {
-        if (todo.status === 'completed')
+        if (todo.status === 'completed' && consultReceiptIsRealPass(todo.id, sessionId, plan, projectRoot)) {
             continue;
+        }
+        if (todo.status === 'completed') {
+            updatePlanTodoStatus(todo.id, 'pending', projectRoot);
+        }
         try {
             let agentResult;
             if (options.fixture) {
-                agentResult = writeFixtureConferReceipt(todo.id, todo.subagent, sessionId, projectRoot);
+                agentResult =
+                    options.fixtureOutput !== undefined
+                        ? applyConferConsultResult(todo.id, todo.subagent, sessionId, options.fixtureOutput, projectRoot)
+                        : writeFixtureConferReceipt(todo.id, todo.subagent, sessionId, projectRoot, options.fixtureVerdict ?? 'PASS', options.fixtureNoLlm === true);
             }
             else {
                 const prompt = buildConferPrompt(todo.subagent, todo.task, collocated, options.dueReason ?? null);
-                const outputText = await invokeConferAgent(todo.subagent, prompt, projectRoot);
-                agentResult = applyConferConsultResult(todo.id, todo.subagent, sessionId, outputText, projectRoot);
+                const host = options.host ?? new SessionConferHost();
+                const call = await host.call(conferHostSeat(todo.subagent, prompt, projectRoot, sessionId, todo.id, options.dueReason ?? null), projectRoot);
+                if (call.status === 'pending') {
+                    agents.push({
+                        todoId: todo.id,
+                        subagent: todo.subagent,
+                        outputText: '',
+                        receiptRecorded: false,
+                        todoCompleted: false,
+                        verdict: null,
+                    });
+                    continue;
+                }
+                agentResult = applyConferConsultResult(todo.id, todo.subagent, sessionId, call.text, projectRoot);
             }
             agents.push(agentResult);
             if (agentResult.receiptRecorded && agentResult.todoCompleted) {
@@ -247,7 +274,9 @@ export async function runConferQuorum(projectRoot = process.cwd(), sessionId, op
             }
             else {
                 state.status = 'failed';
-                state.lastError = `Receipt or todo completion failed for ${todo.id}`;
+                state.lastError = consultVerdictBlocksCompletion(agentResult.verdict)
+                    ? `${agentResult.verdict} blocks ${todo.id}`
+                    : `Receipt or todo completion failed for ${todo.id}`;
                 saveConferCheckpoint(state, projectRoot);
                 return {
                     status: 'partial',
@@ -273,10 +302,21 @@ export async function runConferQuorum(projectRoot = process.cwd(), sessionId, op
             return { status: 'failed', agents, message };
         }
     }
+    if (agents.some((agent) => agent.verdict === null && !agent.receiptRecorded && !agent.error)) {
+        state.status = 'pending';
+        delete state.lastError;
+        saveConferCheckpoint(state, projectRoot);
+        return {
+            status: 'pending',
+            agents,
+            message: 'Confer asks written. The wearing TUI calls its MCP servers and records each verdict.',
+        };
+    }
     const refreshed = loadPersistedLeadDevPlan(projectRoot);
     const done = refreshed &&
         isSynthesisRealignmentPlan(refreshed) &&
-        areSynthesisConsultTodosComplete(refreshed);
+        areSynthesisConsultTodosComplete(refreshed) &&
+        consultReceiptsAreRealApproves(refreshed, sessionId, projectRoot);
     state.status = done ? 'completed' : 'failed';
     if (!done)
         state.lastError = 'Consult todos remain after confer loop';
@@ -289,6 +329,22 @@ export async function runConferQuorum(projectRoot = process.cwd(), sessionId, op
             : (state.lastError ?? 'Confer incomplete'),
     };
 }
+function consultReceiptIsRealPass(todoId, sessionId, plan, projectRoot) {
+    const receipt = loadSynthesisConsultReceipt(todoId, projectRoot);
+    if (receipt?.verdict !== 'PASS')
+        return false;
+    if (sessionId && receipt.sessionId !== sessionId)
+        return false;
+    if (plan.consultCycleId && receipt.cycleId !== plan.consultCycleId)
+        return false;
+    return true;
+}
+function consultReceiptsAreRealApproves(plan, sessionId, projectRoot) {
+    const todos = getSynthesisConsultTodos(plan);
+    if (todos.length === 0)
+        return false;
+    return todos.every((todo) => consultReceiptIsRealPass(todo.id, sessionId, plan, projectRoot));
+}
 const CONFER_AGENT_EMOJI = {
     researcher: '🔍',
     'architect-tools': '🏗️',

package/dist/nucleus/lead-dev-plan-persistence.js

@@ -7,7 +7,7 @@ import * as path from 'path';
 import { SYNTHESIS_REALIGNMENT_PHASE_ID } from './autonomy-kernel.js';
 import { DEFAULT_PENDING_TTL_MS } from './pending-delegations.js';
 import { completeSynthesisCheckpoint, getSynthesisCheckpointSessionId, isSynthesisCheckpointDue, recordExecutionSlice, } from './synthesis.js';
-import { hasValidSynthesisConsultReceipt, isSynthesisConsultTodoId, loadSynthesisConsultReceipt, } from './synthesis-consult-receipt.js';
+import { consultVerdictBlocksCompletion, hasValidSynthesisConsultReceipt, isSynthesisConsultTodoId, loadSynthesisConsultReceipt, } from './synthesis-consult-receipt.js';
 import { resolveSpawnPlan } from './spawn-plan-resolution.js';
 import { isAsideActiveForSession, isUserAsideTodoId, isUserAsidesEnabled, parseAsideIdFromTodoId, findAsideContainingTodo, updateUserAsideTodoStatus, } from './user-aside.js';
 export const DEFAULT_PLAN_STALE_MS = 8 * 60 * 60 * 1000;
@@ -259,11 +259,13 @@ export function updatePlanTodoStatus(todoId, status, projectRoot = process.cwd()
             receiptExpected.sessionId = plan.sessionId;
         if (targetTodo?.subagent)
             receiptExpected.subagent = targetTodo.subagent;
+        if (plan.consultCycleId)
+            receiptExpected.cycleId = plan.consultCycleId;
         if (!hasValidSynthesisConsultReceipt(todoId, projectRoot, receiptExpected)) {
             return false;
         }
         const receipt = loadSynthesisConsultReceipt(todoId, projectRoot);
-        if (receipt?.verdict === 'FAIL') {
+        if (consultVerdictBlocksCompletion(receipt?.verdict)) {
             return false;
         }
     }

package/dist/nucleus/suit-temperament.d.ts

@@ -32,4 +32,4 @@ export declare function maybeHeatHostStation(projectRoot: string, host: SuitHost
 export declare function writeSuitSessionBoot(projectRoot: string, host: SuitHost, extra?: Record<string, unknown>): string;
 export declare function ceremonyForProfile(profile: SuitProfile): CeremonyLevel;
 export declare function spawnPlanModeForProfile(profile: SuitProfile): SpawnPlanMode;
-export declare function conferDefaultForProfile(profile: SuitProfile): boolean;
+export declare function conferDefaultForProfile(_profile: SuitProfile): boolean;

package/dist/nucleus/suit-temperament.js

@@ -170,6 +170,6 @@ export function spawnPlanModeForProfile(profile) {
         return 'warn';
     return 'deny';
 }
-export function conferDefaultForProfile(profile) {
-    return profile !== 'frontier';
+export function conferDefaultForProfile(_profile) {
+    return false;
 }

package/dist/nucleus/synthesis-consult-receipt.d.ts

@@ -2,7 +2,7 @@
  * Synthesis consult receipt SSOT — outcome-based completion for s.N todos.
  * Receipts live at `.xray/state/synthesis-consult-{todoId}.json`.
  */
-export type SynthesisConsultVerdict = 'PASS' | 'CONDITIONAL' | 'FAIL';
+export type SynthesisConsultVerdict = 'PASS' | 'CONDITIONAL' | 'FAIL' | 'UNREVIEWED';
 export interface SynthesisConsultReceipt {
     sessionId: string;
     subagent: string;
@@ -11,18 +11,24 @@ export interface SynthesisConsultReceipt {
     hardeningNote: string;
     todoId?: string;
     recordedAt?: string;
+    /** Synthesis plan generation this receipt belongs to. A previous cycle's PASS cannot clear the next s.N. */
+    cycleId?: string;
 }
 export declare function isSynthesisConsultTodoId(todoId: string): boolean;
 export declare function synthesisConsultReceiptPath(todoId: string, projectRoot?: string): string;
 export declare function loadSynthesisConsultReceipt(todoId: string, projectRoot?: string): SynthesisConsultReceipt | null;
 export declare function writeSynthesisConsultReceipt(todoId: string, receipt: SynthesisConsultReceipt, projectRoot?: string): string;
+/** Only a real approve (PASS) completes a consult todo. */
+export declare function consultVerdictBlocksCompletion(verdict: SynthesisConsultVerdict | null | undefined): boolean;
 export declare function validateSynthesisConsultReceipt(receipt: SynthesisConsultReceipt, todoId: string, expected?: {
     sessionId?: string | null;
     subagent?: string;
+    cycleId?: string;
 }): boolean;
 export declare function hasValidSynthesisConsultReceipt(todoId: string, projectRoot?: string, expected?: {
     sessionId?: string | null;
     subagent?: string;
+    cycleId?: string;
 }): boolean;
 export declare function parseConsultVerdictFromText(text: string): SynthesisConsultVerdict | null;
 export declare function extractTopRisksFromText(text: string, max?: number): string[];

package/dist/nucleus/synthesis-consult-receipt.js

@@ -25,14 +25,30 @@ export function loadSynthesisConsultReceipt(todoId, projectRoot = process.cwd())
 export function writeSynthesisConsultReceipt(todoId, receipt, projectRoot = process.cwd()) {
     const receiptPath = synthesisConsultReceiptPath(todoId, projectRoot);
     fs.mkdirSync(path.dirname(receiptPath), { recursive: true });
+    const cycleId = receipt.cycleId ?? readPlanConsultCycleId(projectRoot);
     const payload = {
         ...receipt,
         todoId,
         recordedAt: receipt.recordedAt ?? new Date().toISOString(),
+        ...(cycleId ? { cycleId } : {}),
     };
     fs.writeFileSync(receiptPath, JSON.stringify(payload, null, 2));
     return receiptPath;
 }
+function readPlanConsultCycleId(projectRoot) {
+    const planPath = path.join(projectRoot, '.xray', 'state', 'lead-dev-plan.json');
+    if (!fs.existsSync(planPath))
+        return undefined;
+    try {
+        const data = JSON.parse(fs.readFileSync(planPath, 'utf8'));
+        return typeof data.consultCycleId === 'string' && data.consultCycleId.trim()
+            ? data.consultCycleId
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 function normalizeSubagent(agent) {
     const key = agent.toLowerCase().trim();
     const aliases = {
@@ -47,7 +63,11 @@ function subagentsAlign(expected, actual) {
     return e === a || e.includes(a) || a.includes(e);
 }
 function isValidVerdict(value) {
-    return value === 'PASS' || value === 'CONDITIONAL' || value === 'FAIL';
+    return value === 'PASS' || value === 'CONDITIONAL' || value === 'FAIL' || value === 'UNREVIEWED';
+}
+/** Only a real approve (PASS) completes a consult todo. */
+export function consultVerdictBlocksCompletion(verdict) {
+    return verdict !== 'PASS';
 }
 export function validateSynthesisConsultReceipt(receipt, todoId, expected) {
     if (!receipt.sessionId || !receipt.subagent || !isValidVerdict(receipt.verdict)) {
@@ -62,6 +82,8 @@ export function validateSynthesisConsultReceipt(receipt, todoId, expected) {
     if (expected?.subagent && !subagentsAlign(expected.subagent, receipt.subagent)) {
         return false;
     }
+    if (expected?.cycleId && receipt.cycleId !== expected.cycleId)
+        return false;
     if (receipt.todoId && receipt.todoId !== todoId)
         return false;
     return true;
@@ -72,52 +94,81 @@ export function hasValidSynthesisConsultReceipt(todoId, projectRoot = process.cw
         return false;
     return validateSynthesisConsultReceipt(receipt, todoId, expected);
 }
-function verdictFromToken(token) {
-    const value = token.toLowerCase();
-    if (value === 'approve' || value === 'approved' || value === 'pass')
-        return 'PASS';
-    if (value === 'reject' || value === 'rejected' || value === 'fail')
-        return 'FAIL';
-    if (value === 'abstain' ||
-        value === 'needs_revision' ||
-        value === 'conditional' ||
-        value === 'revise') {
+const EXPLICIT_VERDICT_LINE = /^Verdict:\s*(PASS|CONDITIONAL|FAIL|UNREVIEWED)\s*$/i;
+const VERDICT_OPTION_ECHO = /\bPASS\s*\|\s*CONDITIONAL\s*\|\s*FAIL\b/i;
+const DECISION_LINE = /^DECISION:\s*(approve|reject|abstain|approved|rejected|pass|fail|needs_revision|conditional|revise)\s*$/i;
+function lineWithoutBullet(rawLine) {
+    return rawLine.trim().replace(/^[-*•]\s*/, '');
+}
+function splitAtReasoning(text) {
+    const lines = text.split('\n');
+    const idx = lines.findIndex((rawLine) => /^REASONING:/i.test(lineWithoutBullet(rawLine)));
+    if (idx < 0)
+        return { header: text, reasoning: null };
+    return {
+        header: lines.slice(0, idx).join('\n'),
+        reasoning: lines.slice(idx).join('\n'),
+    };
+}
+/** Abstain because no governance model ran. A bare DECISION: abstain stays CONDITIONAL. */
+function isAbstainWithoutModel(text) {
+    return /nested LLM not configured|did not produce a vote|returned no vote/i.test(text);
+}
+/** First exact DECISION line before REASONING. A menu or a line inside the reasoning body is not a vote. */
+function firstHeaderDecision(text) {
+    const { header } = splitAtReasoning(text);
+    for (const rawLine of header.split('\n')) {
+        const match = lineWithoutBullet(rawLine).match(DECISION_LINE);
+        const decision = match?.[1]?.toLowerCase();
+        if (!decision)
+            continue;
+        if (decision === 'approve' || decision === 'approved' || decision === 'pass')
+            return 'PASS';
+        if (decision === 'reject' || decision === 'rejected' || decision === 'fail')
+            return 'FAIL';
+        if (decision === 'abstain' && isAbstainWithoutModel(text))
+            return 'UNREVIEWED';
         return 'CONDITIONAL';
     }
     return null;
 }
-/** The last single Verdict or DECISION line wins. A menu line that lists every word does not. */
-function lastExplicitVerdict(text) {
-    let found = null;
-    for (const line of text.split(/\r?\n/)) {
-        const trimmed = line.trim().replace(/^[-*•]\s*/, '');
-        const match = trimmed.match(/^(?:Verdict|DECISION):\s*(\w+)/i);
-        const token = match?.[1];
-        if (!token || trimmed.includes('|'))
+function hasAmbiguousVerdictLine(text) {
+    for (const rawLine of text.split('\n')) {
+        const line = lineWithoutBullet(rawLine);
+        if (!/^Verdict:/i.test(line))
+            continue;
+        if (EXPLICIT_VERDICT_LINE.test(line))
             continue;
-        const verdict = verdictFromToken(token);
-        if (verdict)
-            found = verdict;
+        return true;
+    }
+    return false;
+}
+function lastExplicitVerdictLine(text) {
+    let found = null;
+    for (const rawLine of text.split('\n')) {
+        const match = lineWithoutBullet(rawLine).match(EXPLICIT_VERDICT_LINE);
+        if (match?.[1])
+            found = match[1].toUpperCase();
     }
     return found;
 }
 export function parseConsultVerdictFromText(text) {
-    const explicit = lastExplicitVerdict(text);
+    const decision = firstHeaderDecision(text);
+    if (decision)
+        return decision;
+    // Verdict lines inside REASONING are model text, not the vote.
+    const { header, reasoning } = splitAtReasoning(text);
+    const scanTarget = reasoning === null ? text : header;
+    const explicit = lastExplicitVerdictLine(scanTarget);
     if (explicit)
         return explicit;
-    const decisionToken = text.match(/\bDECISION:\s*(\w+)/i)?.[1];
-    if (decisionToken) {
-        const mapped = verdictFromToken(decisionToken);
-        if (mapped)
-            return mapped;
+    if (!text.trim())
+        return null;
+    if (hasAmbiguousVerdictLine(text) || VERDICT_OPTION_ECHO.test(text))
+        return 'UNREVIEWED';
+    if (/\b(?:PASS|FAIL|CONDITIONAL|UNREVIEWED|SHIP|APPROVE|REJECT)\b/i.test(text)) {
+        return 'UNREVIEWED';
     }
-    const normalized = text.toUpperCase();
-    if (/\bCONDITIONAL(\s+PASS)?\b/.test(normalized))
-        return 'CONDITIONAL';
-    if (/\b(?:PASS|SHIP|APPROVE)\b/.test(normalized))
-        return 'PASS';
-    if (/\b(?:FAIL|REJECT)\b/.test(normalized))
-        return 'FAIL';
     return null;
 }
 export function extractTopRisksFromText(text, max = 5) {

package/dist/reporting/framework-reporting-system.js

@@ -1,8 +1,7 @@
 import { frameworkLogger } from "../core/framework-logger.js";
 import * as fs from "fs";
 import * as path from "path";
-import { fileURLToPath } from "node:url";
-import { getComprehensiveLogs, filterLogsByConfig, frameworkLogToParsedEntry, } from "./log-parser.js";
+import { getComprehensiveLogs, filterLogsByConfig, frameworkLogToParsedEntry, activityLogPath, } from "./log-parser.js";
 import { calculateTimeRange, calculateMetrics, calculatePeakActivity, calculateHealthScore, generateInsights, generateRecommendations, generateAlerts, } from "./metrics.js";
 import { formatReport } from "./report-formatter.js";
 export class FrameworkReportingSystem {
@@ -106,9 +105,7 @@ const report = await reportingSystem.generateCustomReport('${template.name}');
     }
     // Same activity.log path readCurrentLogFile rebuilds from size and mtime.
     activityLogFile() {
-        const currentFilePath = fileURLToPath(import.meta.url);
-        const projectRoot = path.resolve(path.dirname(currentFilePath), "../../");
-        return path.join(projectRoot, "logs", "framework", "activity.log");
+        return activityLogPath();
     }
     currentLogStamp() {
         try {