0xray 4.0.13 → 4.0.14

package/dist/nucleus/confer.js

@@ -0,0 +1,322 @@
+/**
+ * Confer — mandatory 3-agent quorum SSOT (researcher / architect-tools / code-review).
+ * Triggered automatically at synthesis checkpoint; records consult receipts + plan todos.
+ */
+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 { isSynthesisCheckpointDue } from './synthesis.js';
+import { conferDefaultForProfile, resolveRuntimeSuitProfile } from './suit-temperament.js';
+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 };
+}
+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 };
+    }
+    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 };
+        }
+        return {
+            enabled: raw.enabled !== false && orch.confer_on_synthesis !== false,
+            on_synthesis: raw.on_synthesis !== false && orch.confer_on_synthesis !== false,
+        };
+    }
+    catch {
+        return conferDefaultForProfile(profile)
+            ? defaultConferConfig()
+            : { enabled: false, on_synthesis: false };
+    }
+}
+export function isConferEnabled(projectRoot = process.cwd()) {
+    return loadConferConfig(projectRoot).enabled;
+}
+export function loadConferCheckpoint(projectRoot = process.cwd()) {
+    const statePath = conferCheckpointPath(projectRoot);
+    if (!fs.existsSync(statePath))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(statePath, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function saveConferCheckpoint(state, projectRoot = process.cwd()) {
+    const statePath = conferCheckpointPath(projectRoot);
+    fs.mkdirSync(path.dirname(statePath), { recursive: true });
+    fs.writeFileSync(statePath, JSON.stringify(state, null, 2));
+    return statePath;
+}
+export function triggerConferCheckpoint(sessionId, dueReason, projectRoot = process.cwd()) {
+    const state = {
+        version: STATE_VERSION,
+        sessionId,
+        triggeredAt: new Date().toISOString(),
+        dueReason,
+        status: 'pending',
+        completedAgents: [],
+    };
+    saveConferCheckpoint(state, projectRoot);
+    return state;
+}
+export function isConferPending(projectRoot = process.cwd(), sessionId) {
+    const plan = loadPersistedLeadDevPlan(projectRoot);
+    if (!plan || !isSynthesisRealignmentPlan(plan))
+        return false;
+    if (areSynthesisConsultTodosComplete(plan))
+        return false;
+    if (sessionId && isSynthesisCheckpointDue(projectRoot, sessionId))
+        return true;
+    const state = loadConferCheckpoint(projectRoot);
+    if (!state || state.status === 'completed')
+        return false;
+    if (sessionId && state.sessionId !== sessionId)
+        return false;
+    return true;
+}
+export function buildConferPrompt(subagent, todoTask, collocatedText, dueReason) {
+    const reasonLine = dueReason ? `Due: ${dueReason}\n\n` : '';
+    return `${reasonLine}## Confer quorum — ${subagent}
+
+${todoTask}
+
+Review the collocated synthesis context and return a structured verdict.
+
+**Required in your response:**
+- Verdict: PASS | CONDITIONAL | FAIL
+- Top risks (bulleted)
+- Hardening note / recommendations
+
+---
+
+${collocatedText}`;
+}
+/** Map confer subagent → MCP server + tool. */
+export function conferAgentMcpTarget(subagent) {
+    switch (subagent) {
+        case 'architect-tools':
+            return {
+                server: 'architect-tools',
+                tool: 'architecture-assessment',
+                args: (prompt, projectRoot) => ({
+                    projectRoot,
+                    assessmentType: 'comprehensive',
+                    focusMetrics: ['complexity', 'coupling', 'cohesion', 'testability', 'scalability'],
+                    conferPrompt: prompt,
+                }),
+            };
+        case 'researcher':
+            return {
+                server: 'researcher',
+                tool: 'analyze_proposal',
+                args: (prompt) => ({
+                    proposalTitle: 'Synthesis confer — researcher',
+                    proposalDescription: prompt,
+                    proposalType: 'synthesis-confer',
+                    evidence: [],
+                }),
+            };
+        case 'code-review':
+        default:
+            return {
+                server: 'code-review',
+                tool: 'analyze_proposal',
+                args: (prompt) => ({
+                    proposalTitle: 'Synthesis confer — code-review',
+                    proposalDescription: prompt,
+                    proposalType: 'synthesis-confer',
+                    evidence: [],
+                }),
+            };
+    }
+}
+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');
+    const target = conferAgentMcpTarget(subagent);
+    const args = target.args(prompt, projectRoot);
+    const result = await mcpClientManager.callServerTool(target.server, target.tool, args);
+    const text = extractMcpText(result);
+    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)`);
+    }
+    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') {
+        todoCompleted = updatePlanTodoStatus(todoId, 'completed', projectRoot);
+    }
+    return {
+        todoId,
+        subagent,
+        outputText,
+        receiptRecorded: receipt != null,
+        todoCompleted,
+        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 async function runConferQuorum(projectRoot = process.cwd(), sessionId, options = {}) {
+    const cfg = loadConferConfig(projectRoot);
+    if (!cfg.enabled || !cfg.on_synthesis) {
+        return {
+            status: 'skipped',
+            agents: [],
+            message: 'Confer disabled in features.json',
+        };
+    }
+    const plan = loadPersistedLeadDevPlan(projectRoot);
+    if (!plan || !isSynthesisRealignmentPlan(plan)) {
+        return {
+            status: 'skipped',
+            agents: [],
+            message: 'No synthesis realignment plan — confer not applicable',
+        };
+    }
+    if (areSynthesisConsultTodosComplete(plan)) {
+        return {
+            status: 'completed',
+            agents: [],
+            message: 'Confer already complete — all consult todos finished',
+        };
+    }
+    const state = triggerConferCheckpoint(sessionId, options.dueReason ?? null, projectRoot);
+    state.status = 'in_progress';
+    saveConferCheckpoint(state, projectRoot);
+    const collocated = options.collocatedText?.trim() ||
+        '# Synthesis confer\n\nReview checkpoint context and realign plan.';
+    const agents = [];
+    for (const todo of getSynthesisConsultTodos(plan)) {
+        if (todo.status === 'completed')
+            continue;
+        try {
+            let agentResult;
+            if (options.fixture) {
+                agentResult = writeFixtureConferReceipt(todo.id, todo.subagent, sessionId, projectRoot);
+            }
+            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);
+            }
+            agents.push(agentResult);
+            if (agentResult.receiptRecorded && agentResult.todoCompleted) {
+                state.completedAgents.push(todo.subagent);
+                saveConferCheckpoint(state, projectRoot);
+            }
+            else {
+                state.status = 'failed';
+                state.lastError = `Receipt or todo completion failed for ${todo.id}`;
+                saveConferCheckpoint(state, projectRoot);
+                return {
+                    status: 'partial',
+                    agents,
+                    message: state.lastError,
+                };
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            state.status = 'failed';
+            state.lastError = message;
+            saveConferCheckpoint(state, projectRoot);
+            agents.push({
+                todoId: todo.id,
+                subagent: todo.subagent,
+                outputText: '',
+                receiptRecorded: false,
+                todoCompleted: false,
+                verdict: null,
+                error: message,
+            });
+            return { status: 'failed', agents, message };
+        }
+    }
+    const refreshed = loadPersistedLeadDevPlan(projectRoot);
+    const done = refreshed &&
+        isSynthesisRealignmentPlan(refreshed) &&
+        areSynthesisConsultTodosComplete(refreshed);
+    state.status = done ? 'completed' : 'failed';
+    if (!done)
+        state.lastError = 'Consult todos remain after confer loop';
+    saveConferCheckpoint(state, projectRoot);
+    return {
+        status: done ? 'completed' : 'partial',
+        agents,
+        message: done
+            ? 'Confer quorum complete — researcher, architect-tools, code-review consulted'
+            : (state.lastError ?? 'Confer incomplete'),
+    };
+}
+const CONFER_AGENT_EMOJI = {
+    researcher: '🔍',
+    'architect-tools': '🏗️',
+    'code-review': '✅',
+    'code-reviewer': '✅',
+    architect: '🏗️',
+    strategist: '🎯',
+};
+function conferAgentEmoji(subagent) {
+    return CONFER_AGENT_EMOJI[subagent] ?? '🤖';
+}
+export function formatConferQuorumReport(result) {
+    if (result.status === 'skipped') {
+        return `ℹ️ Confer skipped: ${result.message}`;
+    }
+    const lines = [
+        `## Confer quorum — ${result.status.toUpperCase()}`,
+        result.message,
+        '',
+    ];
+    for (const agent of result.agents) {
+        const emoji = conferAgentEmoji(agent.subagent);
+        lines.push(`- ${emoji} **${agent.todoId}** (${agent.subagent}): verdict=${agent.verdict ?? 'n/a'} receipt=${agent.receiptRecorded} todo=${agent.todoCompleted}${agent.error ? ` error=${agent.error}` : ''}`);
+    }
+    const plan = loadPersistedLeadDevPlan();
+    const next = plan ? getNextRequiredTodo(plan) : null;
+    if (next) {
+        lines.push('', `**Next todo:** ${next.id} (${next.subagent})`);
+    }
+    return lines.join('\n');
+}

package/dist/nucleus/default-plugins.d.ts

@@ -0,0 +1,17 @@
+/**
+ * DefaultPlugins — Phase 2C: centralized bootstrap for all knowledge-skill
+ * servers as SkillToolPlugin registrations.
+ *
+ * Exports registerDefaultPlugins() which is called once at boot to register
+ * all 24 knowledge-skill MCP servers (plus the researcher) as in-process
+ * plugin tools, making them dispatchable without MCP transport.
+ */
+export interface DefaultPluginsResult {
+    registered: number;
+    failed: string[];
+}
+/**
+ * Register all knowledge-skill servers as SkillToolPlugins.
+ * Called once at boot. Returns counts of registered and failed servers.
+ */
+export declare function registerDefaultPlugins(): Promise<DefaultPluginsResult>;

package/dist/nucleus/default-plugins.js

@@ -0,0 +1,173 @@
+/**
+ * DefaultPlugins — Phase 2C: centralized bootstrap for all knowledge-skill
+ * servers as SkillToolPlugin registrations.
+ *
+ * Exports registerDefaultPlugins() which is called once at boot to register
+ * all 24 knowledge-skill MCP servers (plus the researcher) as in-process
+ * plugin tools, making them dispatchable without MCP transport.
+ */
+import { frameworkLogger } from '../core/framework-logger.js';
+import { pluginRegistry } from './plugin-registry.js';
+// Note: handlers are extracted directly from the SDK's Server internal
+// _requestHandlers Map (keyed by method literal) instead of patching
+// Server.prototype.setRequestHandler. This avoids global prototype mutation
+// while preserving access to the same tool/handler metadata.
+// ── Named exports (17 servers) ──────────────────────────────────────────────
+import { XrayCodeReviewServer } from '../mcps/knowledge-skills/code-review.server.js';
+import { XraySecurityAuditServer } from '../mcps/knowledge-skills/security-audit.server.js';
+import { SkillInvocationServer } from '../mcps/knowledge-skills/skill-invocation.server.js';
+import { XrayDocumentationGenerationServer } from '../mcps/knowledge-skills/tech-writer.server.js';
+import { XrayDatabaseDesignServer } from '../mcps/knowledge-skills/database-design.server.js';
+import { XrayPerformanceOptimizationServer } from '../mcps/knowledge-skills/performance-optimization.server.js';
+import { XrayUIUXDesignServer } from '../mcps/knowledge-skills/ui-ux-design.server.js';
+import { XrayDevOpsDeploymentServer } from '../mcps/knowledge-skills/devops-deployment.server.js';
+import { SEOSpecialistServer } from '../mcps/knowledge-skills/seo-consultant.server.js';
+import { MultimodalLookerServer } from '../mcps/knowledge-skills/multimodal-looker.server.js';
+import { XrayRefactoringStrategiesServer } from '../mcps/knowledge-skills/refactoring-strategies.server.js';
+import { BugTriageSpecialistServer } from '../mcps/knowledge-skills/bug-triage-specialist.server.js';
+import { LogMonitorServer } from '../mcps/knowledge-skills/log-monitor.server.js';
+import { XrayMobileDevelopmentServer } from '../mcps/knowledge-skills/mobile-development.server.js';
+import { MarketingExpertServer } from '../mcps/knowledge-skills/growth-strategist.server.js';
+import { SEOCopywriterServer } from '../mcps/knowledge-skills/content-creator.server.js';
+import { StrategistServer } from '../mcps/knowledge-skills/strategist.server.js';
+// ── Researcher (standalone, outside knowledge-skills) ──────────────────────
+import { XrayLibrarianServer } from '../mcps/researcher.server.js';
+// ── Default exports (7 servers) ─────────────────────────────────────────────
+import XrayTestingStrategyServer from '../mcps/knowledge-skills/testing-strategy.server.js';
+import ProjectAnalysisServer from '../mcps/knowledge-skills/project-analysis.server.js';
+import CodeAnalyzerServer from '../mcps/knowledge-skills/code-analyzer.server.js';
+import SessionManagementServer from '../mcps/knowledge-skills/session-management.server.js';
+import XrayApiDesignServer from '../mcps/knowledge-skills/api-design.server.js';
+import XrayGitWorkflowServer from '../mcps/knowledge-skills/git-workflow.server.js';
+import XrayArchitecturePatternsServer from '../mcps/knowledge-skills/architecture-patterns.server.js';
+// ── Named exports (additional servers) ──────────────────────────────────────
+import { XrayTestingBestPracticesServer } from '../mcps/knowledge-skills/testing-best-practices.server.js';
+async function toServerDescriptor(instance, serverName) {
+    const srv = instance;
+    const tools = srv.tools ?? [];
+    const handlers = srv.handlers ?? {};
+    // Read handlers from SDK's internal _requestHandlers Map (keyed by method literal)
+    const mcp = srv.server;
+    const requestHandlers = mcp?._requestHandlers;
+    const listHandler = requestHandlers?.get('tools/list');
+    const callHandler = requestHandlers?.get('tools/call');
+    if (tools.length === 0 && listHandler) {
+        try {
+            const listResult = await listHandler({ method: 'tools/list', params: {} }, {});
+            if (listResult?.tools?.length) {
+                return {
+                    name: serverName,
+                    tools: listResult.tools,
+                    callTool: async (toolName, args) => {
+                        if (!callHandler) {
+                            throw new Error(`Unknown tool '${toolName}' on server '${serverName}'`);
+                        }
+                        const result = await callHandler({ method: 'tools/call', params: { name: toolName, arguments: args } }, {});
+                        return result;
+                    },
+                };
+            }
+        }
+        catch {
+            // fall through to default
+        }
+    }
+    return {
+        name: serverName,
+        tools,
+        callTool: async (toolName, args) => {
+            const handler = handlers[toolName];
+            if (!handler) {
+                throw new Error(`Unknown tool '${toolName}' on server '${serverName}'`);
+            }
+            return handler(args);
+        },
+    };
+}
+async function registerOne(label, create, serverName) {
+    try {
+        const instance = create();
+        const descriptor = await toServerDescriptor(instance, serverName);
+        pluginRegistry.registerServer(descriptor);
+        frameworkLogger.log('default-plugins', `register-${label}`, 'info', { serverName });
+        return true;
+    }
+    catch (error) {
+        frameworkLogger.log('default-plugins', `register-${label}`, 'error', {
+            serverName,
+            error: String(error),
+        });
+        return false;
+    }
+}
+// ── Batches ─────────────────────────────────────────────────────────────────
+async function registerBatch(tag, servers) {
+    let count = 0;
+    for (const s of servers) {
+        if (await registerOne(s.label, s.create, s.serverName)) {
+            count++;
+        }
+    }
+    frameworkLogger.log('default-plugins', `batch-${tag}`, 'info', {
+        registered: count,
+        total: servers.length,
+    });
+    return count;
+}
+/**
+ * Register all knowledge-skill servers as SkillToolPlugins.
+ * Called once at boot. Returns counts of registered and failed servers.
+ */
+export async function registerDefaultPlugins() {
+    const failed = [];
+    // ── Batch 1: Governance-critical (priority) ──
+    const batch1Count = await registerBatch('governance', [
+        { label: 'code-review', create: () => new XrayCodeReviewServer(), serverName: 'code-review' },
+        { label: 'security-audit', create: () => new XraySecurityAuditServer(), serverName: 'security-audit' },
+        { label: 'researcher', create: () => new XrayLibrarianServer(), serverName: 'researcher' },
+    ]);
+    // ── Batch 2: Design & Architecture ──
+    const batch2Count = await registerBatch('design-architecture', [
+        { label: 'api-design', create: () => new XrayApiDesignServer(), serverName: 'api-design' },
+        { label: 'architecture-patterns', create: () => new XrayArchitecturePatternsServer(), serverName: 'architecture-patterns' },
+        { label: 'database-design', create: () => new XrayDatabaseDesignServer(), serverName: 'database-design' },
+        { label: 'mobile-development', create: () => new XrayMobileDevelopmentServer(), serverName: 'mobile-development' },
+        { label: 'ui-ux-design', create: () => new XrayUIUXDesignServer(), serverName: 'ui-ux-design' },
+    ]);
+    // ── Batch 3: Analysis & Quality ──
+    const batch3Count = await registerBatch('analysis-quality', [
+        { label: 'code-analyzer', create: () => new CodeAnalyzerServer(), serverName: 'code-analyzer' },
+        { label: 'performance-optimization', create: () => new XrayPerformanceOptimizationServer(), serverName: 'performance-optimization' },
+        { label: 'project-analysis', create: () => new ProjectAnalysisServer(), serverName: 'project-analysis' },
+        { label: 'refactoring-strategies', create: () => new XrayRefactoringStrategiesServer(), serverName: 'refactoring-strategies' },
+        { label: 'testing-strategy', create: () => new XrayTestingStrategyServer(), serverName: 'testing-strategy' },
+    ]);
+    // ── Batch 4: Operations & Workflow ──
+    const batch4Count = await registerBatch('operations-workflow', [
+        { label: 'devops-deployment', create: () => new XrayDevOpsDeploymentServer(), serverName: 'devops-deployment' },
+        { label: 'git-workflow', create: () => new XrayGitWorkflowServer(), serverName: 'git-workflow' },
+        { label: 'log-monitor', create: () => new LogMonitorServer(), serverName: 'log-monitor' },
+        { label: 'session-management', create: () => new SessionManagementServer(), serverName: 'session-management' },
+        { label: 'strategist', create: () => new StrategistServer(), serverName: 'strategist' },
+    ]);
+    // ── Batch 5: Content & Growth ──
+    const batch5Count = await registerBatch('content-growth', [
+        { label: 'content-creator', create: () => new SEOCopywriterServer(), serverName: 'content-creator' },
+        { label: 'growth-strategist', create: () => new MarketingExpertServer(), serverName: 'growth-strategist' },
+        { label: 'multimodal-looker', create: () => new MultimodalLookerServer(), serverName: 'multimodal-looker' },
+        { label: 'seo-consultant', create: () => new SEOSpecialistServer(), serverName: 'seo-consultant' },
+        { label: 'documentation-generation', create: () => new XrayDocumentationGenerationServer(), serverName: 'documentation-generation' },
+    ]);
+    // ── Batch 6: Specialized ──
+    const batch6Count = await registerBatch('specialized', [
+        { label: 'bug-triage-specialist', create: () => new BugTriageSpecialistServer(), serverName: 'bug-triage-specialist' },
+        { label: 'skill-invocation', create: () => new SkillInvocationServer(), serverName: 'skill-invocation' },
+        { label: 'testing-best-practices', create: () => new XrayTestingBestPracticesServer(), serverName: 'testing-best-practices' },
+    ]);
+    const registered = batch1Count + batch2Count + batch3Count + batch4Count + batch5Count + batch6Count;
+    frameworkLogger.log('default-plugins', 'register-default-plugins-complete', 'info', {
+        registered,
+        failedCount: failed.length,
+    });
+    return { registered, failed };
+}

package/dist/nucleus/delegation-gate.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Multi-host delegation gate SSOT — pending-delegations + spawn todo enforcement.
+ * Grok / Hermes / OpenCode adapters call evaluatePreToolGate via delegation-gate-runtime.
+ * Constitution (11/29/69 + destructive shell) lives here. Grok may still extra-block Codex 2/7.
+ */
+import { type PendingDelegation } from './pending-delegations.js';
+export { getActivePendingDelegations } from './pending-delegations.js';
+import { updatePlanTodoStatus, type SpawnToolInput } from './lead-dev-plan-persistence.js';
+import { writeSuitSessionBoot, maybeHeatHostStation, type CeremonyLevel, type SpawnPlanMode, type SuitHost, type SuitProfile } from './suit-temperament.js';
+export { writeSuitSessionBoot, maybeHeatHostStation };
+export { extractSpawnCwd, validateAsideWorktreeCwd, provisionGitWorktree } from './aside-worktree.js';
+export { validateSpawnMatchesTodo, updatePlanTodoStatus, savePersistedLeadDevPlan, archiveStaleLeadDevPlan, findRecentStalePlanArchive, } from './lead-dev-plan-persistence.js';
+export { buildReceiptFromConsultOutput, hasValidSynthesisConsultReceipt, isSynthesisConsultTodoId, loadSynthesisConsultReceipt, parseConsultVerdictFromText, tryRecordSynthesisConsultReceipt, writeSynthesisConsultReceipt, type SynthesisConsultReceipt, type SynthesisConsultVerdict, } from './synthesis-consult-receipt.js';
+export declare const updatePlanTodoStatusInPlace: typeof updatePlanTodoStatus;
+export type DelegationGateHost = SuitHost;
+export interface DelegationGateFeatures {
+    lead_dev_mode: boolean;
+    auto_chain_delegations: boolean;
+    /** v3 — deny (guided/strict), warn (frontier), off */
+    spawn_plan_mode?: SpawnPlanMode;
+    ceremony?: CeremonyLevel;
+    suit_profile?: SuitProfile;
+    no_new_surface?: boolean;
+}
+export interface ToolGateInput {
+    prompt?: string;
+    description?: string;
+    task?: string;
+    subagent_type?: string;
+    agent?: string;
+    delegationId?: string;
+    delegation_id?: string;
+    planTodoId?: string;
+    command?: string;
+    path?: string;
+    file_path?: string;
+    filePath?: string;
+    toolName?: string;
+    tool?: string;
+    name?: string;
+    server?: string;
+    mcpServer?: string;
+    arguments?: Record<string, unknown>;
+    args?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface PreToolGateContext {
+    projectRoot: string;
+    sessionId: string | null;
+    features: DelegationGateFeatures;
+    host?: DelegationGateHost;
+    hookEvent?: string;
+}
+export interface PreToolGateDeny {
+    allow: false;
+    reason: string;
+    gate: string;
+    hint?: Record<string, unknown>;
+    pendingCount?: number;
+    delegationId?: string;
+}
+export interface PreToolGateAllow {
+    allow: true;
+    reason?: string;
+    gate?: string;
+    hint?: Record<string, unknown>;
+}
+export type PreToolGateResult = PreToolGateAllow | PreToolGateDeny;
+export interface PostToolSpawnResult {
+    satisfied: PendingDelegation[];
+    clearedAll: boolean;
+    expectedTodoId?: string | null;
+    receiptRecorded?: boolean;
+    todoCompleted?: boolean;
+}
+export interface PostToolSpawnOptions {
+    toolOutput?: unknown;
+    sessionId?: string | null;
+}
+export declare function loadDelegationGateFeatures(projectRoot?: string, host?: DelegationGateHost): DelegationGateFeatures;
+export declare function normalizeHostToolInput(toolInput: ToolGateInput): SpawnToolInput & {
+    command?: string;
+};
+export declare function isSubagentTool(toolName: string): boolean;
+export declare function isShellTool(toolName: string): boolean;
+export declare function isWriteTool(toolName: string, host?: DelegationGateHost): boolean;
+export declare function isReadOnlyTool(toolName: string): boolean;
+/** Spawn plan missing — applies before auto_chain opt-out for subagent tools. */
+export declare function evaluateSpawnPlanGate(toolName: string, toolInput: ToolGateInput, ctx: PreToolGateContext): PreToolGateResult;
+/** Block writes / spawns / shell while synthesis checkpoint is due. */
+export declare function evaluateSynthesisGate(toolName: string, toolInput: ToolGateInput, ctx: PreToolGateContext): PreToolGateResult;
+/** Block writes / unrelated work while pending delegations exist. */
+export declare function evaluatePendingDelegationGate(toolName: string, toolInput: ToolGateInput, ctx: PreToolGateContext): PreToolGateResult;
+/** Codex 11 / 29 / 69 + destructive shell — always on, all hosts that call this SSOT. */
+export declare function evaluateConstitutionGate(toolName: string, toolInput: ToolGateInput, ctx: PreToolGateContext): PreToolGateResult;
+export declare function evaluatePreToolGate(toolName: string, toolInput: ToolGateInput, ctx: PreToolGateContext): PreToolGateResult;
+export declare function evaluatePostToolSpawn(toolName: string, toolInput: ToolGateInput, projectRoot: string, options?: PostToolSpawnOptions): PostToolSpawnResult;
+export declare function isOrchestrateToolEvent(toolName: string, toolInput?: ToolGateInput): boolean;
+/** Back-compat shims for Grok hook-utils and tests. */
+export declare function checkPendingDelegationGate(toolName: string, toolInput: ToolGateInput, features: DelegationGateFeatures, projectRoot: string, sessionId: string | null): PreToolGateDeny | null;
+export declare function checkSubagentGate(toolName: string, features: DelegationGateFeatures, projectRoot: string, sessionId: string | null, toolInput?: ToolGateInput): PreToolGateDeny | null;
+export declare function satisfyDelegationsFromToolInput(toolInput: ToolGateInput, projectRoot: string): {
+    satisfied: PendingDelegation[];
+    clearedAll: boolean;
+};