@guilz-dev/belay 0.3.0 → 0.4.0

package/dist/core/verdict/judge-cli.js

@@ -1,11 +1,31 @@
 import { spawn } from 'node:child_process';
 import { buildTier1Prompt, parseTier1Json, prescanInterpreterCode, } from './judge.js';
 import { scrubOutboundForJudge } from './judge-outbound.js';
+import { DEFAULT_JUDGE_RUNTIME_CONFIG } from './judge-runtime-config.js';
+import { transportFallbackToFailClosedReason } from './judge-session-guard.js';
+import { evaluateWithJudgeTransport } from './judge-transport.js';
+export class CliRunError extends Error {
+    kind;
+    exitCode;
+    stderr;
+    stdout;
+    command;
+    constructor(kind, message, details = {}) {
+        super(message);
+        this.name = 'CliRunError';
+        this.kind = kind;
+        this.exitCode = details.exitCode;
+        this.stderr = details.stderr;
+        this.stdout = details.stdout;
+        this.command = details.command;
+    }
+}
 const CLI_BINARIES = {
     codex: 'codex',
     cursor: 'cursor-agent',
     claude: 'claude',
 };
+const FORCE_KILL_GRACE_MS = 250;
 function failClosedVerdict(reason) {
     return {
         local_recoverable: false,
@@ -162,17 +182,67 @@ export function parseCliJudgeOutput(providerId, raw) {
     return parseCliJsonLines(raw);
 }
 async function runCliJson(invocation, timeoutMs) {
+    return runCliJsonWithTimeouts(invocation, { evalTimeoutMs: timeoutMs });
+}
+export async function runCliJsonWithTimeouts(invocation, budgets) {
     const { binary, args, stdin } = invocation;
+    const connectTimeoutMs = budgets.connectTimeoutMs ?? 0;
+    if (connectTimeoutMs > 0) {
+        await new Promise((resolve) => setTimeout(resolve, 0));
+    }
     return new Promise((resolve, reject) => {
         const child = spawn(binary, args, {
             stdio: ['pipe', 'pipe', 'pipe'],
         });
+        const command = [binary, ...args].join(' ');
         let stdout = '';
         let stderr = '';
-        const timer = setTimeout(() => {
-            child.kill('SIGTERM');
-            reject(new Error(`${binary} timed out`));
-        }, timeoutMs);
+        let settled = false;
+        let timer = null;
+        let forceKillTimer = null;
+        const cleanup = () => {
+            if (timer) {
+                clearTimeout(timer);
+            }
+            if (forceKillTimer) {
+                clearTimeout(forceKillTimer);
+            }
+        };
+        const rejectOnce = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            reject(error);
+        };
+        const resolveOnce = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            resolve(value);
+        };
+        timer = setTimeout(() => {
+            rejectOnce(new CliRunError('timeout', `${binary} timed out`, {
+                stderr: stderr.trim() || undefined,
+                stdout: stdout.trim() || undefined,
+                command,
+            }));
+            try {
+                child.kill('SIGTERM');
+            }
+            catch {
+                return;
+            }
+            forceKillTimer = setTimeout(() => {
+                try {
+                    child.kill('SIGKILL');
+                }
+                catch {
+                    // process already exited
+                }
+            }, FORCE_KILL_GRACE_MS);
+        }, budgets.evalTimeoutMs);
         child.stdout.on('data', (chunk) => {
             stdout += String(chunk);
         });
@@ -184,16 +254,23 @@ async function runCliJson(invocation, timeoutMs) {
         }
         child.stdin.end();
         child.on('error', (error) => {
-            clearTimeout(timer);
-            reject(error);
+            rejectOnce(new CliRunError('spawn_error', error instanceof Error ? error.message : String(error), {
+                command,
+            }));
         });
         child.on('close', (code) => {
-            clearTimeout(timer);
+            if (settled)
+                return;
             if (code === 0 && stdout.trim()) {
-                resolve(stdout.trim());
+                resolveOnce(stdout.trim());
                 return;
             }
-            reject(new Error(stderr.trim() || `${binary} exited with code ${code ?? 'unknown'}`));
+            rejectOnce(new CliRunError('exit_nonzero', stderr.trim() || `${binary} exited with code ${code ?? 'unknown'}`, {
+                exitCode: typeof code === 'number' ? code : undefined,
+                stderr: stderr.trim() || undefined,
+                stdout: stdout.trim() || undefined,
+                command,
+            }));
         });
     });
 }
@@ -202,6 +279,10 @@ function createCliJudge(options) {
     const timeoutMs = options.timeoutMs ?? 25000;
     const providerId = options.providerId;
     const runCommand = options.runCliCommand ?? runCliJson;
+    const runtime = options.runtime ?? DEFAULT_JUDGE_RUNTIME_CONFIG;
+    const repoRoot = options.repoRoot ?? process.cwd();
+    const stateDir = options.stateDir ?? repoRoot;
+    const judgeMode = options.judgeMode ?? 'enforce';
     const judge = {
         lastTrace: initialTrace(options),
         async evaluate(input) {
@@ -233,27 +314,66 @@ function createCliJudge(options) {
             }
             const prompt = buildTier1Prompt(scrubbed.text);
             try {
-                const raw = await runCommand(buildCliInvocation(providerId, prompt, options.modelResolved), timeoutMs);
-                const parsed = parseCliJudgeOutput(providerId, raw);
-                if (!parsed) {
+                const transportResult = await evaluateWithJudgeTransport({
+                    prompt,
+                    context: {
+                        providerId,
+                        model: options.modelResolved,
+                        repoRoot: input.context.repoRoot || repoRoot,
+                        stateDir,
+                        judgeMode,
+                        runtime,
+                        judgeTimeoutMs: timeoutMs,
+                    },
+                }, { runCommand });
+                const traceTransport = transportResult.transport === 'session'
+                    ? `${providerId}-cli-session`
+                    : transport;
+                if (!transportResult.verdict) {
+                    const fallbackReason = transportResult.fallbackReason ??
+                        `${providerId}_cli_parse_error`;
                     judge.lastTrace = {
                         provider: 'fallback',
                         modelRequested: options.modelRequested,
                         modelResolved: options.modelResolved,
                         latencyMs: Date.now() - started,
-                        fallbackReason: `${providerId}_cli_parse_error`,
+                        fallbackReason,
+                        judgeFallbackReason: fallbackReason,
+                        judgeSessionUsed: transportResult.sessionUsed,
+                        judgeSessionReused: transportResult.sessionReused,
+                        judgeSessionRefHash: transportResult.sessionRefHash,
+                        judgeSessionResetReason: transportResult.sessionResetReason,
+                        judgeConnectMs: transportResult.connectMs,
+                        judgeEvalMs: transportResult.evalMs,
+                        judgeParseMs: transportResult.parseMs,
+                        judgeShadowCompared: transportResult.shadowCompared,
+                        judgeShadowMismatch: transportResult.shadowMismatch,
+                        judgeShadowMismatchRateWindow: transportResult.shadowMismatchRateWindow,
+                        judgeKillSwitchTriggered: transportResult.killSwitchTriggered,
                     };
-                    return failClosedVerdict(`${providerId}_cli_parse_error`);
+                    return failClosedVerdict(transportFallbackToFailClosedReason(providerId, fallbackReason));
                 }
                 judge.lastTrace = {
                     provider: traceProvider(options.providerId),
                     modelRequested: options.modelRequested,
                     modelResolved: options.modelResolved,
                     latencyMs: Date.now() - started,
-                    transport,
+                    transport: traceTransport,
                     outboundRedacted: true,
+                    judgeSessionUsed: transportResult.sessionUsed,
+                    judgeSessionReused: transportResult.sessionReused,
+                    judgeSessionRefHash: transportResult.sessionRefHash,
+                    judgeSessionResetReason: transportResult.sessionResetReason,
+                    judgeFallbackReason: transportResult.fallbackReason,
+                    judgeConnectMs: transportResult.connectMs,
+                    judgeEvalMs: transportResult.evalMs,
+                    judgeParseMs: transportResult.parseMs,
+                    judgeShadowCompared: transportResult.shadowCompared,
+                    judgeShadowMismatch: transportResult.shadowMismatch,
+                    judgeShadowMismatchRateWindow: transportResult.shadowMismatchRateWindow,
+                    judgeKillSwitchTriggered: transportResult.killSwitchTriggered,
                 };
-                return parsed;
+                return transportResult.verdict;
             }
             catch {
                 judge.lastTrace = {
@@ -262,6 +382,7 @@ function createCliJudge(options) {
                     modelResolved: options.modelResolved,
                     latencyMs: Date.now() - started,
                     fallbackReason: `${providerId}_cli_unavailable`,
+                    judgeFallbackReason: `${providerId}_cli_unavailable`,
                 };
                 return failClosedVerdict(`${providerId}_cli_unavailable`);
             }

package/dist/core/verdict/judge-factory.js

@@ -1,7 +1,7 @@
 import { readFile } from 'node:fs/promises';
 import { fileURLToPath } from 'node:url';
 import { repoLocalStateDirFor } from '../../config-io.js';
-import { normalizeJudgeProvider, scrubOptionsFromConfig } from '../config.js';
+import { belayStateDir, normalizeJudgeProvider, scrubOptionsFromConfig } from '../config.js';
 import { resolveJudgeCredential } from '../judge-api-key.js';
 import { hasValidCloudConsent, isCloudJudgeConfig } from '../judge-config.js';
 import { rejectDeprecatedJudgeModelAuto } from '../judge-model-policy.js';
@@ -63,7 +63,8 @@ function providerIdFromJudge(judge) {
     }
     return inferProviderIdFromConfig(judge);
 }
-function createCliJudgeForProvider(providerId, judgeConfig, config) {
+function createCliJudgeForProvider(providerId, judgeConfig, config, repoRoot) {
+    const resolvedRepoRoot = repoRoot ?? process.cwd();
     const { resolved } = resolveJudgeModel(judgeConfig);
     const options = {
         modelRequested: judgeConfig.model,
@@ -71,6 +72,10 @@ function createCliJudgeForProvider(providerId, judgeConfig, config) {
         timeoutMs: judgeConfig.timeoutMs,
         sensitivePaths: config.classifier.sensitivePaths,
         scrubOptions: scrubOptionsFromConfig(config),
+        runtime: judgeConfig.runtime,
+        repoRoot: resolvedRepoRoot,
+        stateDir: belayStateDir(config, repoLocalStateDirFor(resolvedRepoRoot, config)),
+        judgeMode: config.mode,
     };
     if (providerId === 'codex') {
         return createCodexCliJudge(options);
@@ -99,11 +104,12 @@ export function createJudgeFromConfig(config, options = {}) {
     const catalogSpec = getJudgeProviderSpec(providerId);
     const { resolved } = resolveJudgeModel(judgeConfig);
     const runtime = detectJudgeRuntimeCapabilities(providerId);
+    const repoRoot = options.repoRoot ?? process.cwd();
     if (provider === 'openai-compatible') {
         const endpoint = judgeConfig.endpoint?.trim();
         if (!endpoint && runtime.cliTransport) {
             if (providerId === 'codex' || providerId === 'cursor') {
-                return createCliJudgeForProvider(providerId, judgeConfig, config);
+                return createCliJudgeForProvider(providerId, judgeConfig, config, repoRoot);
             }
         }
         if (!endpoint) {
@@ -122,7 +128,6 @@ export function createJudgeFromConfig(config, options = {}) {
                 modelResolved: resolved,
             });
         }
-        const repoRoot = options.repoRoot ?? process.cwd();
         const repoLocalStateDir = repoLocalStateDirFor(repoRoot, config);
         return createOpenAiCompatibleJudge({
             endpoint,
@@ -156,6 +161,10 @@ export function createJudgeFromConfig(config, options = {}) {
                 timeoutMs: judgeConfig.timeoutMs,
                 sensitivePaths: config.classifier.sensitivePaths,
                 scrubOptions: scrubOptionsFromConfig(config),
+                runtime: judgeConfig.runtime,
+                repoRoot,
+                stateDir: belayStateDir(config, repoLocalStateDirFor(repoRoot, config)),
+                judgeMode: config.mode,
             });
         }
         return createFailClosedJudge({

package/dist/core/verdict/judge-provider-matrix.d.ts

@@ -0,0 +1,20 @@
+import type { JudgeProviderId } from './judge-catalog.js';
+export type JudgeSessionFailureMode = 'parse_error' | 'non_json_response' | 'timeout' | 'cli_nonzero_exit' | 'io_error' | 'version_mismatch' | 'unsupported_resume' | 'unsafe_option_rejected';
+export interface JudgeProviderSessionCapability {
+    providerId: Exclude<JudgeProviderId, 'ollama'>;
+    supportsSession: boolean;
+    resumeFlag: string | null;
+    createChatFlag: string | null;
+    readOnlyArgs: string[];
+    rejectedUnsafeOptions: string[];
+    failureModes: JudgeSessionFailureMode[];
+    notes: string;
+}
+export declare const JUDGE_PROVIDER_SESSION_MATRIX: Record<Exclude<JudgeProviderId, 'ollama'>, JudgeProviderSessionCapability>;
+export declare function providerSupportsSession(providerId: Exclude<JudgeProviderId, 'ollama'>, allowlist: JudgeProviderId[]): boolean;
+export declare function assertReadOnlyInvocationArgs(providerId: Exclude<JudgeProviderId, 'ollama'>, args: string[]): {
+    ok: true;
+} | {
+    ok: false;
+    reason: JudgeSessionFailureMode;
+};

package/dist/core/verdict/judge-provider-matrix.js

@@ -0,0 +1,66 @@
+export const JUDGE_PROVIDER_SESSION_MATRIX = {
+    cursor: {
+        providerId: 'cursor',
+        supportsSession: true,
+        resumeFlag: '--resume',
+        createChatFlag: null,
+        readOnlyArgs: ['--mode', 'ask', '--sandbox', 'enabled', '--trust'],
+        rejectedUnsafeOptions: ['--force', '--yolo', '--dangerously-skip-permissions'],
+        failureModes: [
+            'parse_error',
+            'non_json_response',
+            'timeout',
+            'cli_nonzero_exit',
+            'io_error',
+            'version_mismatch',
+        ],
+        notes: 'Pilot provider: ask mode + sandbox enabled; resume via --resume <chatId>.',
+    },
+    codex: {
+        providerId: 'codex',
+        supportsSession: false,
+        resumeFlag: null,
+        createChatFlag: null,
+        readOnlyArgs: ['--sandbox', 'read-only'],
+        rejectedUnsafeOptions: ['--dangerously-bypass-approvals-and-sandbox'],
+        failureModes: ['unsupported_resume', 'parse_error', 'timeout'],
+        notes: 'Session transport disabled by default; spawn read-only exec remains canonical.',
+    },
+    claude: {
+        providerId: 'claude',
+        supportsSession: false,
+        resumeFlag: '--continue',
+        createChatFlag: null,
+        readOnlyArgs: ['--permission-mode', 'plan', '--tools', '', '--bare'],
+        rejectedUnsafeOptions: ['--dangerously-skip-permissions'],
+        failureModes: ['unsupported_resume', 'parse_error', 'timeout'],
+        notes: 'Session transport gated behind allowlist after capability verification.',
+    },
+};
+export function providerSupportsSession(providerId, allowlist) {
+    const capability = JUDGE_PROVIDER_SESSION_MATRIX[providerId];
+    return capability.supportsSession && allowlist.includes(providerId);
+}
+export function assertReadOnlyInvocationArgs(providerId, args) {
+    const capability = JUDGE_PROVIDER_SESSION_MATRIX[providerId];
+    for (const unsafe of capability.rejectedUnsafeOptions) {
+        if (args.includes(unsafe)) {
+            return { ok: false, reason: 'unsafe_option_rejected' };
+        }
+    }
+    for (let index = 0; index < capability.readOnlyArgs.length; index += 2) {
+        const flag = capability.readOnlyArgs[index];
+        const value = capability.readOnlyArgs[index + 1];
+        if (!flag) {
+            continue;
+        }
+        const flagIndex = args.indexOf(flag);
+        if (flagIndex === -1) {
+            return { ok: false, reason: 'unsafe_option_rejected' };
+        }
+        if (value !== undefined && args[flagIndex + 1] !== value) {
+            return { ok: false, reason: 'unsafe_option_rejected' };
+        }
+    }
+    return { ok: true };
+}

package/dist/core/verdict/judge-runtime-config.d.ts

@@ -0,0 +1,42 @@
+import type { JudgeProviderId } from './judge-catalog.js';
+export interface BelayJudgeSessionConfig {
+    enabled: boolean;
+    maxTurns: number;
+    maxAgeMs: number;
+    maxIdleMs: number;
+    maxPromptBytes: number;
+    providerAllowlist: JudgeProviderId[];
+    connectTimeoutMs: number;
+    evalTimeoutMs: number | null;
+    parseTimeoutMs: number;
+    maxSessionsPerProvider: number;
+}
+export interface BelayJudgeShadowConfig {
+    enabled: boolean;
+    sampleRate: number;
+    sampleRateMax: number;
+    dailyRequestCap: number;
+    mismatchRateThreshold: number;
+    providerAllowlist: JudgeProviderId[];
+    windowSize: number;
+}
+export interface BelayJudgeRuntimeConfig {
+    session: BelayJudgeSessionConfig;
+    shadow: BelayJudgeShadowConfig;
+}
+export declare const JUDGE_LATENCY_SLO: {
+    /** Target: Tier1 p95 at least 40% below spawn baseline. */
+    readonly tier1P95ReductionTarget: 0.4;
+    /** Reference spawn baseline (ms) from dogfood measurement. */
+    readonly spawnBaselineP95Ms: 25000;
+    readonly spawnBaselineP50Ms: 1300;
+    readonly tier0BaselineP95Ms: 60;
+    /** Session path must not exceed spawn p95 when enabled. */
+    readonly sessionMaxP95Ms: 15000;
+};
+export declare const DEFAULT_JUDGE_SESSION_CONFIG: BelayJudgeSessionConfig;
+export declare const DEFAULT_JUDGE_SHADOW_CONFIG: BelayJudgeShadowConfig;
+export declare const DEFAULT_JUDGE_RUNTIME_CONFIG: BelayJudgeRuntimeConfig;
+export declare function normalizeJudgeRuntimeConfig(runtime: Partial<BelayJudgeRuntimeConfig> | undefined): BelayJudgeRuntimeConfig;
+export declare function normalizeJudgeSessionConfig(session: Partial<BelayJudgeSessionConfig> | undefined): BelayJudgeSessionConfig;
+export declare function resolveSessionEvalTimeoutMs(sessionConfig: BelayJudgeSessionConfig, judgeTimeoutMs: number): number;

package/dist/core/verdict/judge-runtime-config.js

@@ -0,0 +1,92 @@
+export const JUDGE_LATENCY_SLO = {
+    /** Target: Tier1 p95 at least 40% below spawn baseline. */
+    tier1P95ReductionTarget: 0.4,
+    /** Reference spawn baseline (ms) from dogfood measurement. */
+    spawnBaselineP95Ms: 25_000,
+    spawnBaselineP50Ms: 1_300,
+    tier0BaselineP95Ms: 60,
+    /** Session path must not exceed spawn p95 when enabled. */
+    sessionMaxP95Ms: 15_000,
+};
+export const DEFAULT_JUDGE_SESSION_CONFIG = {
+    enabled: false,
+    maxTurns: 32,
+    maxAgeMs: 30 * 60 * 1000,
+    maxIdleMs: 5 * 60 * 1000,
+    maxPromptBytes: 64 * 1024,
+    providerAllowlist: ['cursor'],
+    connectTimeoutMs: 5_000,
+    evalTimeoutMs: null,
+    parseTimeoutMs: 2_000,
+    maxSessionsPerProvider: 1,
+};
+export const DEFAULT_JUDGE_SHADOW_CONFIG = {
+    enabled: false,
+    sampleRate: 0.01,
+    sampleRateMax: 0.05,
+    dailyRequestCap: 500,
+    mismatchRateThreshold: 0.02,
+    providerAllowlist: ['cursor'],
+    windowSize: 100,
+};
+export const DEFAULT_JUDGE_RUNTIME_CONFIG = {
+    session: { ...DEFAULT_JUDGE_SESSION_CONFIG },
+    shadow: { ...DEFAULT_JUDGE_SHADOW_CONFIG },
+};
+const CLI_PROVIDER_IDS = ['codex', 'cursor', 'claude'];
+function normalizeProviderAllowlist(value, fallback) {
+    if (!Array.isArray(value)) {
+        return [...fallback];
+    }
+    const allowed = value
+        .map((entry) => String(entry).trim())
+        .filter((entry) => CLI_PROVIDER_IDS.includes(entry));
+    return allowed.length > 0 ? [...new Set(allowed)] : [...fallback];
+}
+function normalizePositiveInt(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0
+        ? Math.floor(value)
+        : fallback;
+}
+function normalizeRate(value, fallback, max) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) {
+        return fallback;
+    }
+    return Math.min(value, max);
+}
+export function normalizeJudgeRuntimeConfig(runtime) {
+    const session = runtime?.session ?? {};
+    const shadow = runtime?.shadow ?? {};
+    return {
+        session: normalizeJudgeSessionConfig(session),
+        shadow: {
+            enabled: shadow.enabled === true,
+            sampleRate: normalizeRate(shadow.sampleRate, DEFAULT_JUDGE_SHADOW_CONFIG.sampleRate, 1),
+            sampleRateMax: normalizeRate(shadow.sampleRateMax, DEFAULT_JUDGE_SHADOW_CONFIG.sampleRateMax, 1),
+            dailyRequestCap: normalizePositiveInt(shadow.dailyRequestCap, DEFAULT_JUDGE_SHADOW_CONFIG.dailyRequestCap),
+            mismatchRateThreshold: normalizeRate(shadow.mismatchRateThreshold, DEFAULT_JUDGE_SHADOW_CONFIG.mismatchRateThreshold, 1),
+            providerAllowlist: normalizeProviderAllowlist(shadow.providerAllowlist, DEFAULT_JUDGE_SHADOW_CONFIG.providerAllowlist),
+            windowSize: normalizePositiveInt(shadow.windowSize, DEFAULT_JUDGE_SHADOW_CONFIG.windowSize),
+        },
+    };
+}
+export function normalizeJudgeSessionConfig(session) {
+    const input = session ?? {};
+    return {
+        enabled: input.enabled === true,
+        maxTurns: normalizePositiveInt(input.maxTurns, DEFAULT_JUDGE_SESSION_CONFIG.maxTurns),
+        maxAgeMs: normalizePositiveInt(input.maxAgeMs, DEFAULT_JUDGE_SESSION_CONFIG.maxAgeMs),
+        maxIdleMs: normalizePositiveInt(input.maxIdleMs, DEFAULT_JUDGE_SESSION_CONFIG.maxIdleMs),
+        maxPromptBytes: normalizePositiveInt(input.maxPromptBytes, DEFAULT_JUDGE_SESSION_CONFIG.maxPromptBytes),
+        providerAllowlist: normalizeProviderAllowlist(input.providerAllowlist, DEFAULT_JUDGE_SESSION_CONFIG.providerAllowlist),
+        connectTimeoutMs: normalizePositiveInt(input.connectTimeoutMs, DEFAULT_JUDGE_SESSION_CONFIG.connectTimeoutMs),
+        evalTimeoutMs: typeof input.evalTimeoutMs === 'number' && input.evalTimeoutMs > 0
+            ? Math.floor(input.evalTimeoutMs)
+            : null,
+        parseTimeoutMs: normalizePositiveInt(input.parseTimeoutMs, DEFAULT_JUDGE_SESSION_CONFIG.parseTimeoutMs),
+        maxSessionsPerProvider: normalizePositiveInt(input.maxSessionsPerProvider, DEFAULT_JUDGE_SESSION_CONFIG.maxSessionsPerProvider),
+    };
+}
+export function resolveSessionEvalTimeoutMs(sessionConfig, judgeTimeoutMs) {
+    return sessionConfig.evalTimeoutMs ?? judgeTimeoutMs;
+}

package/dist/core/verdict/judge-session-broker.d.ts

@@ -0,0 +1,48 @@
+import type { JudgeProviderId } from './judge-catalog.js';
+import type { CliInvocation, CliJudgeRunCommand } from './judge-cli.js';
+import type { BelayJudgeSessionConfig } from './judge-runtime-config.js';
+import { type JudgeSessionBudget, type JudgeSessionKeyParts, type JudgeSessionResetReason } from './judge-session-guard.js';
+export type BrokerSessionState = 'idle' | 'busy';
+export interface BrokerSessionRecord {
+    keyParts: JudgeSessionKeyParts;
+    budget: JudgeSessionBudget;
+    state: BrokerSessionState;
+    providerResumeId?: string;
+    lastResetReason?: JudgeSessionResetReason;
+}
+export interface BrokerEvaluateRequest {
+    keyParts: JudgeSessionKeyParts;
+    invocation: CliInvocation;
+    promptBytes: number;
+}
+export interface BrokerEvaluateResult {
+    raw: string;
+    reused: boolean;
+    resetReason?: JudgeSessionResetReason;
+    providerResumeId?: string;
+}
+type RunCommand = CliJudgeRunCommand;
+export interface JudgeSessionBrokerOptions {
+    config: BelayJudgeSessionConfig;
+    runCommand: RunCommand;
+    extractResumeId?: (providerId: Exclude<JudgeProviderId, 'ollama'>, raw: string) => string | null;
+}
+export declare class JudgeSessionBroker {
+    private readonly sessions;
+    private readonly mutexes;
+    private readonly options;
+    constructor(options: JudgeSessionBrokerOptions);
+    listSessions(): BrokerSessionRecord[];
+    invalidateSession(sessionKey: string, reason: JudgeSessionResetReason): void;
+    stopAll(reason?: JudgeSessionResetReason): number;
+    evaluate(request: BrokerEvaluateRequest, timeoutMs: number): Promise<BrokerEvaluateResult>;
+    private evaluateExclusive;
+    private enforceProviderSessionCap;
+    private buildResumeInvocation;
+}
+export declare function extractProviderResumeId(providerId: Exclude<JudgeProviderId, 'ollama'>, raw: string): string | null;
+export declare function getRepoJudgeSessionBroker(repoRoot: string, options: JudgeSessionBrokerOptions): JudgeSessionBroker;
+export declare function stopRepoJudgeSessionBroker(repoRoot: string, reason?: JudgeSessionResetReason): number;
+export declare function resetJudgeSessionBrokersForTests(): void;
+export declare function listRepoJudgeSessionBrokers(): string[];
+export {};