0xray 4.0.13 → 4.0.14

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

@@ -0,0 +1,40 @@
+/**
+ * 0xRay 4.0 suit temperament — how loudly the Autonomous Engine insists.
+ *
+ * v2 three-subsystem OS stays: Inference · External Governance · Autonomous Engine.
+ * This module does not replace thinDispatch or Codex. It only scales *ceremony*
+ * (spawn-plan deny, synthesis, confer) by host strength.
+ *
+ * Frontier (Grok 4.6 / Grok Build / Cursor cloud): engine available, spawn warns if no plan.
+ * Guided (OpenCode / Hermes / OpenClaw, including free models): full v2 ceremony.
+ * Missing config → guided (existing consumers unchanged).
+ */
+export type SuitHost = 'grok' | 'cursor' | 'hermes' | 'opencode' | 'openclaw' | 'generic';
+export type SuitProfile = 'frontier' | 'guided' | 'strict';
+export type SuitProfileOrAuto = 'auto' | SuitProfile;
+export type CeremonyLevel = 'full' | 'lite';
+export type SpawnPlanMode = 'deny' | 'warn' | 'off';
+export interface SuitTemperamentConfig {
+    /** auto = pick from host_defaults */
+    profile?: SuitProfileOrAuto;
+    host_defaults?: Partial<Record<SuitHost, SuitProfile>>;
+}
+export declare const DEFAULT_HOST_PROFILES: Record<SuitHost, SuitProfile>;
+export declare function loadSuitTemperamentRaw(projectRoot: string): SuitTemperamentConfig | undefined;
+export declare function resolveSuitProfile(raw: SuitTemperamentConfig | undefined, host: SuitHost): SuitProfile;
+/**
+ * Host-aware when known. Kernel/MCP (`generic`) uses last session-boot profile.
+ * A Hermes/OpenCode host ignores a leftover Grok boot (and vice versa).
+ */
+export declare function resolveRuntimeSuitProfile(projectRoot: string, host?: SuitHost): SuitProfile;
+/**
+ * Write station heat when this host/session has no live card yet.
+ * OpenClaw has no SessionStart — PreToolUse is the session boundary.
+ * Install/init cards without a session id are not a live session.
+ */
+export declare function maybeHeatHostStation(projectRoot: string, host: SuitHost, extra?: Record<string, unknown>): string | null;
+/** Merge temperament fields into session-boot.json for the host that just started. */
+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;

package/dist/nucleus/suit-temperament.js

@@ -0,0 +1,159 @@
+/**
+ * 0xRay 4.0 suit temperament — how loudly the Autonomous Engine insists.
+ *
+ * v2 three-subsystem OS stays: Inference · External Governance · Autonomous Engine.
+ * This module does not replace thinDispatch or Codex. It only scales *ceremony*
+ * (spawn-plan deny, synthesis, confer) by host strength.
+ *
+ * Frontier (Grok 4.6 / Grok Build / Cursor cloud): engine available, spawn warns if no plan.
+ * Guided (OpenCode / Hermes / OpenClaw, including free models): full v2 ceremony.
+ * Missing config → guided (existing consumers unchanged).
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { createRequire } from 'node:module';
+const requireCjs = createRequire(import.meta.url);
+const stationHeat = requireCjs('../integrations/hooks/station-hook-runtime.cjs');
+export const DEFAULT_HOST_PROFILES = {
+    grok: 'frontier',
+    cursor: 'frontier',
+    hermes: 'guided',
+    opencode: 'guided',
+    openclaw: 'guided',
+    generic: 'guided',
+};
+function isSuitProfile(value) {
+    return value === 'frontier' || value === 'guided' || value === 'strict';
+}
+export function loadSuitTemperamentRaw(projectRoot) {
+    const featuresPath = path.join(projectRoot, '.xray', 'features.json');
+    if (!fs.existsSync(featuresPath))
+        return undefined;
+    try {
+        const data = JSON.parse(fs.readFileSync(featuresPath, 'utf8'));
+        return data.suit_temperament;
+    }
+    catch {
+        return undefined;
+    }
+}
+function isSuitHost(value) {
+    return (value === 'grok' ||
+        value === 'cursor' ||
+        value === 'hermes' ||
+        value === 'opencode' ||
+        value === 'openclaw' ||
+        value === 'generic');
+}
+function readSessionBoot(projectRoot) {
+    try {
+        const bootPath = path.join(projectRoot, '.xray', 'state', 'session-boot.json');
+        if (!fs.existsSync(bootPath))
+            return null;
+        const boot = JSON.parse(fs.readFileSync(bootPath, 'utf8'));
+        return {
+            host: isSuitHost(boot.host) ? boot.host : null,
+            suit_profile: isSuitProfile(boot.suit_profile) ? boot.suit_profile : null,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function resolveSuitProfile(raw, host) {
+    // No key / empty object without profile → guided (existing consumers).
+    if (!raw || !raw.profile)
+        return 'guided';
+    if (raw.profile !== 'auto') {
+        return raw.profile;
+    }
+    const defaults = {
+        ...DEFAULT_HOST_PROFILES,
+        ...(raw.host_defaults ?? {}),
+    };
+    return defaults[host] ?? 'guided';
+}
+/**
+ * Host-aware when known. Kernel/MCP (`generic`) uses last session-boot profile.
+ * A Hermes/OpenCode host ignores a leftover Grok boot (and vice versa).
+ */
+export function resolveRuntimeSuitProfile(projectRoot, host = 'generic') {
+    const raw = loadSuitTemperamentRaw(projectRoot);
+    const boot = readSessionBoot(projectRoot);
+    if (raw?.profile === 'auto' && boot?.suit_profile) {
+        if (host === 'generic' || boot.host == null || boot.host === host) {
+            return boot.suit_profile;
+        }
+    }
+    return resolveSuitProfile(raw, host);
+}
+function concreteSessionId(value) {
+    return typeof value === 'string' && value.length > 0 ? value : null;
+}
+/**
+ * Write station heat when this host/session has no live card yet.
+ * OpenClaw has no SessionStart — PreToolUse is the session boundary.
+ * Install/init cards without a session id are not a live session.
+ */
+export function maybeHeatHostStation(projectRoot, host, extra = {}) {
+    const bootPath = path.join(projectRoot, '.xray', 'state', 'session-boot.json');
+    const cardPath = path.join(projectRoot, '.xray', 'state', 'STATION.md');
+    let existing = {};
+    if (fs.existsSync(bootPath)) {
+        try {
+            existing = JSON.parse(fs.readFileSync(bootPath, 'utf8'));
+        }
+        catch {
+            existing = {};
+        }
+    }
+    const sessionId = concreteSessionId(extra.sessionId);
+    const existingSessionId = concreteSessionId(existing.sessionId);
+    const sameHost = existing.host === host;
+    const sameSession = existingSessionId !== null && sessionId !== null && existingSessionId === sessionId;
+    if (sameHost && sameSession && fs.existsSync(cardPath)) {
+        return bootPath;
+    }
+    return writeSuitSessionBoot(projectRoot, host, extra);
+}
+/** Merge temperament fields into session-boot.json for the host that just started. */
+export function writeSuitSessionBoot(projectRoot, host, extra = {}) {
+    const profile = resolveSuitProfile(loadSuitTemperamentRaw(projectRoot), host);
+    const stateDir = path.join(projectRoot, '.xray', 'state');
+    fs.mkdirSync(stateDir, { recursive: true });
+    const bootPath = path.join(stateDir, 'session-boot.json');
+    let existing = {};
+    if (fs.existsSync(bootPath)) {
+        try {
+            existing = JSON.parse(fs.readFileSync(bootPath, 'utf8'));
+        }
+        catch {
+            existing = {};
+        }
+    }
+    const heat = stationHeat.applyStationHeat(projectRoot, host, extra, existing);
+    const payload = {
+        ...existing,
+        ...extra,
+        ...heat,
+        host,
+        suit_profile: profile,
+        ceremony: ceremonyForProfile(profile),
+        spawn_plan_mode: spawnPlanModeForProfile(profile),
+        timestamp: new Date().toISOString(),
+    };
+    fs.writeFileSync(bootPath, JSON.stringify(payload, null, 2));
+    stationHeat.writeStationMarkdown(projectRoot, payload);
+    return bootPath;
+}
+export function ceremonyForProfile(profile) {
+    return profile === 'frontier' ? 'lite' : 'full';
+}
+export function spawnPlanModeForProfile(profile) {
+    if (profile === 'frontier')
+        return 'warn';
+    return 'deny';
+}
+export function conferDefaultForProfile(profile) {
+    return profile !== 'frontier';
+}

package/dist/nucleus/synthesis-completion.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Post-checkpoint side effects — meta-inference refresh + repertoire feedback.
+ */
+import type { PersistedLeadDevPlan } from './lead-dev-plan-persistence.js';
+import type { SynthesisCheckpointState } from './synthesis.js';
+export declare function runSynthesisCheckpointSideEffects(projectRoot: string, sessionId: string, plan: PersistedLeadDevPlan | null, completedState: SynthesisCheckpointState): Promise<void>;

package/dist/nucleus/synthesis-completion.js

@@ -0,0 +1,29 @@
+/**
+ * Post-checkpoint side effects — meta-inference refresh + repertoire feedback.
+ */
+import { getMemoryRoutingProvider } from '../memory-routing/index.js';
+import { getSynthesisConsultTodos, isSynthesisRealignmentPlan } from './lead-dev-plan-persistence.js';
+export async function runSynthesisCheckpointSideEffects(projectRoot, sessionId, plan, completedState) {
+    try {
+        const provider = await getMemoryRoutingProvider();
+        if (provider.refreshMetaInference) {
+            await provider.refreshMetaInference().catch(() => undefined);
+        }
+        if (provider.ingestFeedback && plan && isSynthesisRealignmentPlan(plan)) {
+            const consultTodos = getSynthesisConsultTodos(plan);
+            provider.ingestFeedback({
+                timestamp: new Date().toISOString(),
+                sessionId,
+                taskId: `synthesis-checkpoint-${completedState.synthesisCount}`,
+                assignedAgent: 'orchestrator',
+                memorySignals: ['synthesis', ...consultTodos.map((t) => t.subagent)],
+                complexity: 30,
+                success: true,
+                durationMs: 0,
+            });
+        }
+    }
+    catch {
+        // non-blocking — checkpoint already cleared
+    }
+}

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

@@ -0,0 +1,32 @@
+/**
+ * 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 interface SynthesisConsultReceipt {
+    sessionId: string;
+    subagent: string;
+    verdict: SynthesisConsultVerdict;
+    topRisks: string[];
+    hardeningNote: string;
+    todoId?: string;
+    recordedAt?: 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;
+export declare function validateSynthesisConsultReceipt(receipt: SynthesisConsultReceipt, todoId: string, expected?: {
+    sessionId?: string | null;
+    subagent?: string;
+}): boolean;
+export declare function hasValidSynthesisConsultReceipt(todoId: string, projectRoot?: string, expected?: {
+    sessionId?: string | null;
+    subagent?: string;
+}): boolean;
+export declare function parseConsultVerdictFromText(text: string): SynthesisConsultVerdict | null;
+export declare function extractTopRisksFromText(text: string, max?: number): string[];
+export declare function extractHardeningNoteFromText(text: string, maxChars?: number): string;
+export declare function coerceToolOutputText(output: unknown): string;
+export declare function buildReceiptFromConsultOutput(todoId: string, subagent: string, sessionId: string, outputText: string): SynthesisConsultReceipt | null;
+export declare function tryRecordSynthesisConsultReceipt(todoId: string, subagent: string, sessionId: string, output: unknown, projectRoot?: string): SynthesisConsultReceipt | null;

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

@@ -0,0 +1,171 @@
+/**
+ * Synthesis consult receipt SSOT — outcome-based completion for s.N todos.
+ * Receipts live at `.xray/state/synthesis-consult-{todoId}.json`.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+const CONSULT_TODO_PATTERN = /^s\.\d+$/;
+export function isSynthesisConsultTodoId(todoId) {
+    return CONSULT_TODO_PATTERN.test(todoId);
+}
+export function synthesisConsultReceiptPath(todoId, projectRoot = process.cwd()) {
+    return path.join(projectRoot, '.xray', 'state', `synthesis-consult-${todoId}.json`);
+}
+export function loadSynthesisConsultReceipt(todoId, projectRoot = process.cwd()) {
+    const receiptPath = synthesisConsultReceiptPath(todoId, projectRoot);
+    if (!fs.existsSync(receiptPath))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(receiptPath, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function writeSynthesisConsultReceipt(todoId, receipt, projectRoot = process.cwd()) {
+    const receiptPath = synthesisConsultReceiptPath(todoId, projectRoot);
+    fs.mkdirSync(path.dirname(receiptPath), { recursive: true });
+    const payload = {
+        ...receipt,
+        todoId,
+        recordedAt: receipt.recordedAt ?? new Date().toISOString(),
+    };
+    fs.writeFileSync(receiptPath, JSON.stringify(payload, null, 2));
+    return receiptPath;
+}
+function normalizeSubagent(agent) {
+    const key = agent.toLowerCase().trim();
+    const aliases = {
+        'bug-triage-specialist': 'bug-triage',
+        'code-reviewer': 'code-review',
+    };
+    return aliases[key] ?? key;
+}
+function subagentsAlign(expected, actual) {
+    const e = normalizeSubagent(expected);
+    const a = normalizeSubagent(actual);
+    return e === a || e.includes(a) || a.includes(e);
+}
+function isValidVerdict(value) {
+    return value === 'PASS' || value === 'CONDITIONAL' || value === 'FAIL';
+}
+export function validateSynthesisConsultReceipt(receipt, todoId, expected) {
+    if (!receipt.sessionId || !receipt.subagent || !isValidVerdict(receipt.verdict)) {
+        return false;
+    }
+    if (!Array.isArray(receipt.topRisks))
+        return false;
+    if (typeof receipt.hardeningNote !== 'string')
+        return false;
+    if (expected?.sessionId && receipt.sessionId !== expected.sessionId)
+        return false;
+    if (expected?.subagent && !subagentsAlign(expected.subagent, receipt.subagent)) {
+        return false;
+    }
+    if (receipt.todoId && receipt.todoId !== todoId)
+        return false;
+    return true;
+}
+export function hasValidSynthesisConsultReceipt(todoId, projectRoot = process.cwd(), expected) {
+    const receipt = loadSynthesisConsultReceipt(todoId, projectRoot);
+    if (!receipt)
+        return false;
+    return validateSynthesisConsultReceipt(receipt, todoId, expected);
+}
+export function parseConsultVerdictFromText(text) {
+    const normalized = text.toUpperCase();
+    const decisionMatch = text.match(/\bDECISION:\s*(\w+)/i);
+    if (decisionMatch) {
+        const decision = decisionMatch[1].toLowerCase();
+        if (decision === 'approve' || decision === 'approved' || decision === 'pass') {
+            return 'PASS';
+        }
+        if (decision === 'reject' || decision === 'rejected' || decision === 'fail') {
+            return 'FAIL';
+        }
+        if (decision === 'abstain' ||
+            decision === 'needs_revision' ||
+            decision === 'conditional' ||
+            decision === 'revise') {
+            return 'CONDITIONAL';
+        }
+    }
+    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) {
+    const risks = [];
+    const lines = text.split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        if (/^(?:[-*•]|\d+\.)\s*(?:risk|top\s*risk)/i.test(trimmed)) {
+            risks.push(trimmed.replace(/^[-*•\d.]+\s*/i, '').slice(0, 240));
+        }
+        else if (/^risk\s*:/i.test(trimmed)) {
+            risks.push(trimmed.replace(/^risk\s*:\s*/i, '').slice(0, 240));
+        }
+        if (risks.length >= max)
+            break;
+    }
+    return risks;
+}
+export function extractHardeningNoteFromText(text, maxChars = 500) {
+    const match = text.match(/(?:hardening|recommend(?:ation)?s?)\s*[:\n]([\s\S]{0,800})/i);
+    if (match?.[1])
+        return match[1].trim().slice(0, maxChars);
+    const lines = text.split('\n').filter((l) => l.trim().length > 0);
+    return lines.slice(-3).join(' ').slice(0, maxChars);
+}
+export function coerceToolOutputText(output) {
+    if (typeof output === 'string')
+        return output;
+    if (output == null)
+        return '';
+    if (typeof output === 'object') {
+        const obj = output;
+        if (typeof obj.text === 'string')
+            return obj.text;
+        if (typeof obj.content === 'string')
+            return obj.content;
+        if (typeof obj.message === 'string')
+            return obj.message;
+        try {
+            return JSON.stringify(output);
+        }
+        catch {
+            return String(output);
+        }
+    }
+    return String(output);
+}
+export function buildReceiptFromConsultOutput(todoId, subagent, sessionId, outputText) {
+    const text = outputText.trim();
+    if (!text)
+        return null;
+    const verdict = parseConsultVerdictFromText(text);
+    if (!verdict)
+        return null;
+    return {
+        sessionId,
+        subagent,
+        verdict,
+        topRisks: extractTopRisksFromText(text),
+        hardeningNote: extractHardeningNoteFromText(text),
+        todoId,
+    };
+}
+export function tryRecordSynthesisConsultReceipt(todoId, subagent, sessionId, output, projectRoot = process.cwd()) {
+    const receipt = buildReceiptFromConsultOutput(todoId, subagent, sessionId, coerceToolOutputText(output));
+    if (!receipt || !validateSynthesisConsultReceipt(receipt, todoId, { sessionId, subagent })) {
+        return null;
+    }
+    writeSynthesisConsultReceipt(todoId, receipt, projectRoot);
+    return receipt;
+}

package/dist/nucleus/synthesis-context.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Collocated context for synthesis Aside — delegates to memory routing provider SSOT.
+ */
+export interface SynthesisCollocatedContext {
+    primitive: 'synthesis';
+    dueReason: string | null;
+    collatedText: string;
+    matchedSignals?: Array<{
+        name: string;
+        definition: string;
+        priority: string;
+    }>;
+    codexTermCount?: number;
+    codexExcerpt?: string;
+    planExcerpt?: string;
+    synthesisExcerpt?: string;
+}
+export declare function buildSynthesisCollocatedContext(projectRoot?: string, dueReason?: string | null): Promise<SynthesisCollocatedContext>;
+/** Refresh meta-inference before collation so synthesis.md is current for reflect. */
+export declare function prepareSynthesisCollocatedContext(projectRoot?: string, dueReason?: string | null): Promise<SynthesisCollocatedContext>;
+export declare function isAnalyzeComplexitySuccess(content: Array<{
+    type: string;
+    text: string;
+}>): boolean;
+export declare function appendSynthesisContextToResponse(content: Array<{
+    type: string;
+    text: string;
+}>, collatedText: string): Array<{
+    type: string;
+    text: string;
+}>;

package/dist/nucleus/synthesis-context.js

@@ -0,0 +1,86 @@
+/**
+ * Collocated context for synthesis Aside — delegates to memory routing provider SSOT.
+ */
+import { getMemoryRoutingProvider } from '../memory-routing/index.js';
+function fallbackContext(dueReason) {
+    const lines = [
+        '# Synthesis checkpoint',
+        dueReason ? `Due: ${dueReason}` : '',
+        '(Enable memory_routing with Repertoire for full signal + codex + plan collation)',
+    ].filter(Boolean);
+    return {
+        primitive: 'synthesis',
+        dueReason,
+        collatedText: lines.join('\n\n'),
+    };
+}
+function normalizeProviderContext(raw, dueReason) {
+    const collatedText = typeof raw.collatedText === 'string' && raw.collatedText.trim()
+        ? dueReason && !raw.collatedText.includes('Due:')
+            ? `# Synthesis checkpoint\n\nDue: ${dueReason}\n\n${raw.collatedText}`
+            : raw.collatedText
+        : fallbackContext(dueReason).collatedText;
+    const matchedSignals = Array.isArray(raw.matchedSignals)
+        ? raw.matchedSignals
+        : undefined;
+    return {
+        primitive: 'synthesis',
+        dueReason,
+        collatedText,
+        ...(matchedSignals ? { matchedSignals } : {}),
+        ...(typeof raw.codexTermCount === 'number' ? { codexTermCount: raw.codexTermCount } : {}),
+        ...(typeof raw.codexExcerpt === 'string' ? { codexExcerpt: raw.codexExcerpt } : {}),
+        ...(typeof raw.planExcerpt === 'string' ? { planExcerpt: raw.planExcerpt } : {}),
+        ...(typeof raw.synthesisExcerpt === 'string'
+            ? { synthesisExcerpt: raw.synthesisExcerpt }
+            : {}),
+    };
+}
+export async function buildSynthesisCollocatedContext(projectRoot = process.cwd(), dueReason = null) {
+    try {
+        const provider = await getMemoryRoutingProvider();
+        if (provider.isAvailable() && provider.buildSynthesisContext) {
+            const raw = provider.buildSynthesisContext({ projectRoot, dueReason });
+            if (raw)
+                return normalizeProviderContext(raw, dueReason);
+        }
+    }
+    catch {
+        // fall through to minimal fallback
+    }
+    return fallbackContext(dueReason);
+}
+/** Refresh meta-inference before collation so synthesis.md is current for reflect. */
+export async function prepareSynthesisCollocatedContext(projectRoot = process.cwd(), dueReason = null) {
+    try {
+        const provider = await getMemoryRoutingProvider();
+        if (provider.refreshMetaInference) {
+            await provider.refreshMetaInference().catch(() => undefined);
+        }
+    }
+    catch {
+        // non-blocking — collation still proceeds
+    }
+    return buildSynthesisCollocatedContext(projectRoot, dueReason);
+}
+export function isAnalyzeComplexitySuccess(content) {
+    const text = content.map((c) => c.text).join('\n');
+    return !text.includes('❌') && !/^error handling tool/i.test(text);
+}
+export function appendSynthesisContextToResponse(content, collatedText) {
+    if (!collatedText.trim())
+        return content;
+    const synthesisSection = `
+
+---
+
+## Synthesis checkpoint — collocated context
+
+${collatedText}
+
+**Next:** Confer quorum runs automatically via analyze-complexity (researcher → architect-tools → code-review). If confer partial-fails, spawn Task for the next consult todo (s.1–s.3). Checkpoint clears when all consult todos complete.`;
+    if (content.length === 0) {
+        return [{ type: 'text', text: synthesisSection.trim() }];
+    }
+    return content.map((block, index) => index === 0 ? { ...block, text: `${block.text}${synthesisSection}` } : block);
+}

package/dist/nucleus/synthesis.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Synthesis — periodic reflect & realign checkpoint SSOT.
+ * Slice counter + feature flag + `.xray/state/synthesis-checkpoint.json`.
+ * PR2 wires pre-tool gate deny via delegation-gate.ts.
+ */
+export declare const SYNTHESIS_PRIMITIVE = "synthesis";
+export type ExecutionSliceKind = 'gate' | 'turn' | 'todo_completed';
+export interface SynthesisConfig {
+    enabled: boolean;
+    every_n_gates: number;
+    every_n_turns: number;
+    every_n_todos_completed: number;
+}
+export interface SynthesisSliceCounters {
+    gates: number;
+    turns: number;
+    todosCompleted: number;
+}
+export interface SynthesisCheckpointState {
+    version: 1;
+    sessionId: string;
+    slicesSinceLastSynthesis: SynthesisSliceCounters;
+    lifetimeSlices: SynthesisSliceCounters;
+    synthesisDue: boolean;
+    dueReason: string | null;
+    lastSynthesisAt: string | null;
+    lastSliceAt: string;
+    synthesisCount: number;
+}
+export interface RecordSliceResult {
+    state: SynthesisCheckpointState;
+    becameDue: boolean;
+    dueReason: string | null;
+}
+export interface SynthesisDueEvaluation {
+    due: boolean;
+    reason: string | null;
+}
+export declare function synthesisCheckpointPath(projectRoot?: string): string;
+export declare function defaultSynthesisConfig(): SynthesisConfig;
+export declare function loadSynthesisConfig(projectRoot?: string): SynthesisConfig;
+export declare function createInitialSynthesisState(sessionId: string): SynthesisCheckpointState;
+export declare function loadSynthesisCheckpointState(projectRoot?: string): SynthesisCheckpointState | null;
+export declare function saveSynthesisCheckpointState(state: SynthesisCheckpointState, projectRoot?: string): string;
+export declare function evaluateSynthesisDue(counters: SynthesisSliceCounters, config: SynthesisConfig): SynthesisDueEvaluation;
+export declare function recordExecutionSlice(kind: ExecutionSliceKind, ctx: {
+    projectRoot?: string;
+    sessionId: string | null;
+}): RecordSliceResult | null;
+export declare function completeSynthesisCheckpoint(projectRoot?: string, sessionId?: string | null): SynthesisCheckpointState | null;
+export declare function isSynthesisCheckpointDue(projectRoot?: string, sessionId?: string | null): boolean;
+export declare function getSynthesisDueReason(projectRoot?: string, sessionId?: string | null): string | null;
+/** Session bound to an active synthesis checkpoint (for MCP when host omits sessionId). */
+export declare function getSynthesisCheckpointSessionId(projectRoot?: string): string | null;