@guilz-dev/belay 0.3.0 → 0.6.0

package/dist/core/verdict/git-classifier.js

@@ -0,0 +1,533 @@
+import path from 'node:path';
+import { extractRedirectTargets } from '../shell-tokenizer.js';
+const GIT_BRANCH_MUTATION_FLAGS = new Set([
+    '--copy',
+    '--create-reflog',
+    '--delete',
+    '--edit-description',
+    '--force',
+    '--move',
+    '--no-create-reflog',
+    '--no-track',
+    '--recurse-submodules',
+    '--set-upstream-to',
+    '--track',
+    '--unset-upstream',
+]);
+const GIT_BRANCH_LIST_FLAGS = new Set([
+    '--abbrev',
+    '--all',
+    '--column',
+    '--color',
+    '--contains',
+    '--format',
+    '--ignore-case',
+    '--list',
+    '--merged',
+    '--no-abbrev',
+    '--no-column',
+    '--no-color',
+    '--no-contains',
+    '--no-merged',
+    '--points-at',
+    '--remotes',
+    '--show-current',
+    '--sort',
+    '--verbose',
+]);
+const GIT_BRANCH_MUTATION_SHORT_FLAGS = new Set(['c', 'C', 'd', 'D', 'f', 'm', 'M', 't', 'u']);
+const GIT_BRANCH_LIST_SHORT_FLAGS = new Set(['a', 'i', 'l', 'r', 'v']);
+const READ_ONLY_SUBCOMMANDS = new Set([
+    'status',
+    'diff',
+    'log',
+    'show',
+    'rev-parse',
+    'describe',
+    'show-ref',
+    'reflog',
+    'ls-files',
+    'ls-tree',
+    'cat-file',
+    'verify-commit',
+    'whatchanged',
+    'shortlog',
+    'help',
+    'version',
+]);
+const READ_ONLY_COMPOUND_SUBCOMMANDS = new Set(['worktree list', 'stash list', 'stash show']);
+const LOCAL_MUTATION_SUBCOMMANDS = new Set([
+    'add',
+    'commit',
+    'mv',
+    'revert',
+    'merge',
+    'cherry-pick',
+    'am',
+    'apply',
+    'format-patch',
+]);
+const REMOTE_SUBCOMMANDS = new Set(['fetch', 'pull']);
+const LOCAL_MUTATION_COMPOUND_SUBCOMMANDS = new Set([
+    'worktree add',
+    'stash push',
+    'stash apply',
+    'stash pop',
+    'stash drop',
+    'stash branch',
+]);
+const FILE_OPERAND_SUBCOMMANDS = new Set([
+    'add',
+    'rm',
+    'mv',
+    'checkout',
+    'restore',
+    'clean',
+    'apply',
+    'cherry-pick',
+    'merge',
+    'show',
+    'diff',
+    'grep',
+    'ls-files',
+]);
+const COMPOUND_SUBCOMMAND_HEADS = new Set(['worktree', 'stash', 'tag']);
+/** Positional args before `--` are refs/revisions, not worktree paths. */
+const REF_ONLY_WITHOUT_TERMINATOR = new Set(['checkout', 'show', 'log']);
+function isGitExecutable(token) {
+    return path.basename(token) === 'git';
+}
+function takesValue(flag) {
+    return (flag === '-C' ||
+        flag === '-c' ||
+        flag === '--git-dir' ||
+        flag === '--work-tree' ||
+        flag === '--exec-path' ||
+        flag === '--paginate' ||
+        flag === '--config-env' ||
+        flag.startsWith('-C') ||
+        flag.startsWith('-c') ||
+        flag.startsWith('--git-dir=') ||
+        flag.startsWith('--work-tree='));
+}
+function peelGlobalOptions(tokens, baseCwd) {
+    let effectiveCwd = baseCwd;
+    let gitDir;
+    let workTree;
+    const rest = [];
+    let index = 1;
+    while (index < tokens.length) {
+        const token = tokens[index];
+        if (!token) {
+            index += 1;
+            continue;
+        }
+        if (token === '--') {
+            rest.push(...tokens.slice(index));
+            break;
+        }
+        if (token === '--no-pager' || token === '--no-replace-objects') {
+            index += 1;
+            continue;
+        }
+        if (token === '-C' || token === '--work-tree' || token === '--git-dir' || token === '-c') {
+            const value = tokens[index + 1];
+            if (token === '-C' && value) {
+                effectiveCwd = path.resolve(baseCwd, value);
+            }
+            else if (token === '--work-tree' && value) {
+                workTree = value;
+            }
+            else if (token === '--git-dir' && value) {
+                gitDir = value;
+            }
+            index += value ? 2 : 1;
+            continue;
+        }
+        if (token.startsWith('-C') && token.length > 2) {
+            effectiveCwd = path.resolve(baseCwd, token.slice(2));
+            index += 1;
+            continue;
+        }
+        if (token.startsWith('--work-tree=')) {
+            workTree = token.slice('--work-tree='.length);
+            index += 1;
+            continue;
+        }
+        if (token.startsWith('--git-dir=')) {
+            gitDir = token.slice('--git-dir='.length);
+            index += 1;
+            continue;
+        }
+        if (token.startsWith('-c') || token.startsWith('--config')) {
+            index += token.includes('=') ? 1 : tokens[index + 1] ? 2 : 1;
+            continue;
+        }
+        if (token.startsWith('-')) {
+            if (takesValue(token) && !token.includes('=')) {
+                index += 2;
+            }
+            else {
+                index += 1;
+            }
+            continue;
+        }
+        rest.push(...tokens.slice(index));
+        break;
+    }
+    return { rest, effectiveCwd, gitDir, workTree };
+}
+function resolveSubcommand(rest) {
+    const head = rest[0] ?? '';
+    const second = rest[1] ?? '';
+    if (COMPOUND_SUBCOMMAND_HEADS.has(head) && second && !second.startsWith('-')) {
+        return { subcommand: `${head} ${second}`, args: rest.slice(2) };
+    }
+    return { subcommand: head, args: rest.slice(1) };
+}
+export function normalizeGitInvocation(tokens, baseCwd) {
+    if (!isGitExecutable(tokens[0] ?? '')) {
+        return null;
+    }
+    const peeled = peelGlobalOptions(tokens, baseCwd);
+    const { subcommand, args } = resolveSubcommand(peeled.rest);
+    if (!subcommand) {
+        return null;
+    }
+    return {
+        subcommand,
+        args,
+        effectiveCwd: peeled.effectiveCwd !== baseCwd ? peeled.effectiveCwd : undefined,
+        gitDir: peeled.gitDir,
+        workTree: peeled.workTree,
+    };
+}
+function hasGitBranchLongFlag(tokens, flags) {
+    return tokens.some((token) => {
+        const [name] = token.split('=', 1);
+        return name ? flags.has(name) : false;
+    });
+}
+function hasGitBranchShortFlag(tokens, flags) {
+    return tokens.some((token) => {
+        if (!/^-[^-]+$/.test(token)) {
+            return false;
+        }
+        return [...token.slice(1)].some((flag) => flags.has(flag));
+    });
+}
+function gitBranchEffect(args) {
+    const optionTerminator = args.indexOf('--');
+    const optionArgs = optionTerminator >= 0 ? args.slice(0, optionTerminator) : args;
+    if (hasGitBranchLongFlag(optionArgs, GIT_BRANCH_MUTATION_FLAGS) ||
+        hasGitBranchShortFlag(optionArgs, GIT_BRANCH_MUTATION_SHORT_FLAGS)) {
+        return 'local_mutation';
+    }
+    if (hasGitBranchLongFlag(optionArgs, GIT_BRANCH_LIST_FLAGS) ||
+        hasGitBranchShortFlag(optionArgs, GIT_BRANCH_LIST_SHORT_FLAGS)) {
+        return 'read_only';
+    }
+    const positionalArgs = args.filter((token, index) => (optionTerminator >= 0 && index > optionTerminator) ||
+        (token !== '--' && !token.startsWith('-')));
+    return positionalArgs.length === 0 ? 'read_only' : 'local_mutation';
+}
+function hasFlag(args, ...flags) {
+    return args.some((token) => flags.includes(token) || flags.some((flag) => token.startsWith(`${flag}=`)));
+}
+function isDryRunClean(args) {
+    return hasFlag(args, '-n', '--dry-run', '--dry-run=');
+}
+function isHardReset(args) {
+    return hasFlag(args, '--hard');
+}
+function extractMessageSkippedIndices(args) {
+    const skipped = new Set();
+    for (let index = 0; index < args.length; index += 1) {
+        const token = args[index];
+        if (!token) {
+            continue;
+        }
+        if (token === '-m' || token === '--message' || token === '-F' || token === '--file') {
+            skipped.add(index);
+            if (args[index + 1]) {
+                skipped.add(index + 1);
+                index += 1;
+            }
+            continue;
+        }
+        if (token.startsWith('-m') && token.length > 2) {
+            skipped.add(index);
+        }
+        if (token.startsWith('--message=')) {
+            skipped.add(index);
+        }
+        if (token.startsWith('--set-upstream-to=')) {
+            skipped.add(index);
+        }
+        if (token === '--set-upstream-to' && args[index + 1]) {
+            skipped.add(index);
+            skipped.add(index + 1);
+            index += 1;
+        }
+    }
+    return skipped;
+}
+function looksLikeFileOperand(token) {
+    if (!token || token === '--' || token.startsWith('-')) {
+        return false;
+    }
+    if (token.includes('/') || token.includes('\\')) {
+        return true;
+    }
+    if (token.startsWith('.')) {
+        return true;
+    }
+    return token.includes('.');
+}
+function looksLikeDiffPathOperand(token) {
+    if (!looksLikeFileOperand(token)) {
+        return false;
+    }
+    if (token.startsWith('.') || path.isAbsolute(token)) {
+        return true;
+    }
+    return token.includes('.');
+}
+function resolveGitWorkTree(baseCwd, effectiveCwd, workTree, gitDir) {
+    const resolveBase = effectiveCwd ?? baseCwd;
+    if (workTree) {
+        return path.resolve(resolveBase, workTree);
+    }
+    if (gitDir) {
+        const resolvedGitDir = path.resolve(resolveBase, gitDir);
+        if (path.basename(resolvedGitDir) === '.git') {
+            return path.dirname(resolvedGitDir);
+        }
+    }
+    return undefined;
+}
+function extractGitFileOperands(subcommand, args) {
+    const baseSubcommand = subcommand.split(' ')[0] ?? subcommand;
+    if (!FILE_OPERAND_SUBCOMMANDS.has(baseSubcommand) &&
+        subcommand !== 'checkout' &&
+        subcommand !== 'restore') {
+        return [];
+    }
+    const redirects = extractRedirectTargets(['git', baseSubcommand, ...args]);
+    const skipped = extractMessageSkippedIndices(args);
+    const optionTerminator = args.indexOf('--');
+    const operands = [...redirects];
+    if (REF_ONLY_WITHOUT_TERMINATOR.has(subcommand) && optionTerminator < 0) {
+        return operands;
+    }
+    for (let index = 0; index < args.length; index += 1) {
+        if (skipped.has(index)) {
+            continue;
+        }
+        const token = args[index];
+        if (!token || token.startsWith('-') || token === '--') {
+            continue;
+        }
+        if (optionTerminator >= 0 && index < optionTerminator) {
+            continue;
+        }
+        if (subcommand === 'branch' ||
+            subcommand === 'push' ||
+            subcommand === 'fetch' ||
+            subcommand === 'pull') {
+            continue;
+        }
+        if (baseSubcommand === 'diff' && optionTerminator < 0) {
+            if (looksLikeDiffPathOperand(token)) {
+                operands.push(token);
+            }
+            continue;
+        }
+        if (looksLikeFileOperand(token) || baseSubcommand === 'add' || baseSubcommand === 'rm') {
+            operands.push(token);
+        }
+    }
+    return operands;
+}
+function classifyDestructiveGit(subcommand, args) {
+    if (subcommand === 'reset' && isHardReset(args)) {
+        return {
+            reason: 'git_history_destructive',
+            signals: ['git_history_destructive', 'git.reset.hard'],
+        };
+    }
+    if (subcommand === 'clean' && !isDryRunClean(args)) {
+        return { reason: 'git_history_destructive', signals: ['git_history_destructive', 'git.clean'] };
+    }
+    if (subcommand === 'stash clear') {
+        return {
+            reason: 'git_history_destructive',
+            signals: ['git_history_destructive', 'git.stash.clear'],
+        };
+    }
+    if (subcommand === 'worktree remove' && hasFlag(args, '--force')) {
+        return {
+            reason: 'git_history_destructive',
+            signals: ['git_history_destructive', 'git.worktree.remove.force'],
+        };
+    }
+    if (subcommand === 'restore' && hasFlag(args, '--worktree', '-W')) {
+        return {
+            reason: 'git_history_destructive',
+            signals: ['git_history_destructive', 'git.restore.worktree'],
+        };
+    }
+    return null;
+}
+export function isGitReadOnlyInvocation(tokens, baseCwd) {
+    const semantics = classifyGitCommand(tokens, baseCwd);
+    return semantics?.isReadOnly === true;
+}
+export function classifyGitCommand(tokens, baseCwd) {
+    const normalized = normalizeGitInvocation(tokens, baseCwd);
+    if (!normalized) {
+        return null;
+    }
+    const { subcommand, args, effectiveCwd, gitDir, workTree } = normalized;
+    const normalizedKey = `git ${subcommand}`;
+    const gitWorkTree = resolveGitWorkTree(baseCwd, effectiveCwd, workTree, gitDir);
+    const effectiveGitDir = gitDir ? path.resolve(effectiveCwd ?? baseCwd, gitDir) : undefined;
+    const scopeTargets = [effectiveCwd, gitWorkTree, effectiveGitDir].filter((target, index, targets) => Boolean(target) && targets.indexOf(target) === index);
+    const pathTargets = extractGitFileOperands(subcommand, args);
+    const signals = [`git.${subcommand.replaceAll(' ', '.')}`];
+    const destructive = classifyDestructiveGit(subcommand, args);
+    if (destructive) {
+        return {
+            effect: 'local_mutation',
+            pathTargets,
+            scopeTargets,
+            signals: [...signals, ...destructive.signals],
+            requiresAsk: destructive,
+            effectiveCwd,
+            gitWorkTree,
+            normalizedKey,
+            isReadOnly: false,
+        };
+    }
+    if (subcommand === 'push') {
+        return {
+            effect: 'remote_mutation',
+            pathTargets,
+            scopeTargets,
+            signals: [...signals, 'git.push'],
+            effectiveCwd,
+            gitWorkTree,
+            normalizedKey,
+            isReadOnly: false,
+        };
+    }
+    if (REMOTE_SUBCOMMANDS.has(subcommand)) {
+        return {
+            effect: 'remote_mutation',
+            pathTargets: [],
+            scopeTargets,
+            signals: [...signals, 'git.remote'],
+            egressClass: 'ambiguous',
+            effectiveCwd,
+            gitWorkTree,
+            normalizedKey,
+            isReadOnly: false,
+        };
+    }
+    if (subcommand === 'branch') {
+        const effect = gitBranchEffect(args);
+        return {
+            effect,
+            pathTargets: [],
+            scopeTargets,
+            signals,
+            effectiveCwd,
+            gitWorkTree,
+            normalizedKey,
+            isReadOnly: effect === 'read_only',
+        };
+    }
+    if (subcommand === 'checkout') {
+        return {
+            effect: 'local_mutation',
+            pathTargets,
+            scopeTargets,
+            signals,
+            effectiveCwd,
+            gitWorkTree,
+            normalizedKey,
+            isReadOnly: false,
+        };
+    }
+    if (subcommand === 'clean' && isDryRunClean(args)) {
+        return {
+            effect: 'read_only',
+            pathTargets: [],
+            scopeTargets,
+            signals,
+            effectiveCwd,
+            gitWorkTree,
+            normalizedKey,
+            isReadOnly: true,
+        };
+    }
+    if (subcommand === 'reset' && !isHardReset(args)) {
+        return {
+            effect: 'local_mutation',
+            pathTargets: [],
+            scopeTargets,
+            signals,
+            effectiveCwd,
+            gitWorkTree,
+            normalizedKey,
+            isReadOnly: false,
+        };
+    }
+    if (subcommand === 'tag' && hasFlag(args, '--list', '-l')) {
+        return {
+            effect: 'read_only',
+            pathTargets: [],
+            scopeTargets,
+            signals,
+            effectiveCwd,
+            gitWorkTree,
+            normalizedKey,
+            isReadOnly: true,
+        };
+    }
+    if (READ_ONLY_SUBCOMMANDS.has(subcommand) || READ_ONLY_COMPOUND_SUBCOMMANDS.has(subcommand)) {
+        return {
+            effect: 'read_only',
+            pathTargets: subcommand === 'show' || subcommand === 'diff' ? pathTargets : [],
+            scopeTargets,
+            signals,
+            effectiveCwd,
+            gitWorkTree,
+            normalizedKey,
+            isReadOnly: true,
+        };
+    }
+    if (LOCAL_MUTATION_SUBCOMMANDS.has(subcommand) ||
+        LOCAL_MUTATION_COMPOUND_SUBCOMMANDS.has(subcommand)) {
+        return {
+            effect: 'local_mutation',
+            pathTargets: subcommand === 'commit' ? [] : pathTargets,
+            scopeTargets,
+            signals,
+            effectiveCwd,
+            gitWorkTree,
+            normalizedKey,
+            isReadOnly: false,
+        };
+    }
+    return {
+        effect: 'unknown',
+        pathTargets,
+        scopeTargets,
+        signals,
+        effectiveCwd,
+        gitWorkTree,
+        normalizedKey,
+        isReadOnly: false,
+    };
+}

package/dist/core/verdict/judge-audit.d.ts

@@ -1,2 +1,3 @@
 import type { JudgeTrace } from './types.js';
+export declare function hashJudgeSessionRef(value: string): string;
 export declare function judgeTraceAuditFields(trace?: JudgeTrace): Record<string, unknown>;

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

@@ -1,3 +1,7 @@
+import { createHash } from 'node:crypto';
+export function hashJudgeSessionRef(value) {
+    return createHash('sha256').update(value).digest('hex').slice(0, 16);
+}
 export function judgeTraceAuditFields(trace) {
     if (!trace) {
         return {};
@@ -7,9 +11,37 @@ export function judgeTraceAuditFields(trace) {
         judgeModelRequested: trace.modelRequested,
         judgeModelResolved: trace.modelResolved,
         judgeLatencyMs: trace.latencyMs,
+        ...(trace.transport ? { judgeTransport: trace.transport } : {}),
         ...(trace.outboundRedacted !== undefined
             ? { judgeOutboundRedacted: trace.outboundRedacted }
             : {}),
-        ...(trace.fallbackReason ? { judgeFallbackReason: trace.fallbackReason } : {}),
+        ...(trace.judgeFallbackReason
+            ? { judgeFallbackReason: trace.judgeFallbackReason }
+            : trace.fallbackReason
+                ? { judgeFallbackReason: trace.fallbackReason }
+                : {}),
+        ...(trace.judgeSessionUsed !== undefined ? { judgeSessionUsed: trace.judgeSessionUsed } : {}),
+        ...(trace.judgeSessionReused !== undefined
+            ? { judgeSessionReused: trace.judgeSessionReused }
+            : {}),
+        ...(trace.judgeSessionRefHash ? { judgeSessionRefHash: trace.judgeSessionRefHash } : {}),
+        ...(trace.judgeSessionResetReason
+            ? { judgeSessionResetReason: trace.judgeSessionResetReason }
+            : {}),
+        ...(trace.judgeConnectMs !== undefined ? { judgeConnectMs: trace.judgeConnectMs } : {}),
+        ...(trace.judgeEvalMs !== undefined ? { judgeEvalMs: trace.judgeEvalMs } : {}),
+        ...(trace.judgeParseMs !== undefined ? { judgeParseMs: trace.judgeParseMs } : {}),
+        ...(trace.judgeShadowCompared !== undefined
+            ? { judgeShadowCompared: trace.judgeShadowCompared }
+            : {}),
+        ...(trace.judgeShadowMismatch !== undefined
+            ? { judgeShadowMismatch: trace.judgeShadowMismatch }
+            : {}),
+        ...(trace.judgeShadowMismatchRateWindow !== undefined
+            ? { judgeShadowMismatchRateWindow: trace.judgeShadowMismatchRateWindow }
+            : {}),
+        ...(trace.judgeKillSwitchTriggered !== undefined
+            ? { judgeKillSwitchTriggered: trace.judgeKillSwitchTriggered }
+            : {}),
     };
 }

package/dist/core/verdict/judge-baseline.d.ts

@@ -0,0 +1,20 @@
+import { JUDGE_LATENCY_SLO } from './judge-runtime-config.js';
+export type JudgeLatencyPhase = 'tier0' | 'gate' | 'tier1_spawn' | 'tier1_session' | 'tier1_connect' | 'tier1_eval' | 'tier1_parse';
+export interface JudgeLatencySample {
+    phase: JudgeLatencyPhase;
+    latencyMs: number;
+    at: number;
+}
+export interface JudgeLatencyPercentiles {
+    p50: number;
+    p95: number;
+    count: number;
+}
+export declare function resetJudgeLatencySamples(): void;
+export declare function recordJudgeLatency(phase: JudgeLatencyPhase, latencyMs: number, at?: number): void;
+export declare function judgeLatencyPercentiles(phase: JudgeLatencyPhase): JudgeLatencyPercentiles;
+export declare function judgeLatencySloReport(): {
+    slo: typeof JUDGE_LATENCY_SLO;
+    measured: Record<JudgeLatencyPhase, JudgeLatencyPercentiles>;
+    sessionMeetsTarget: boolean;
+};

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

@@ -0,0 +1,49 @@
+import { JUDGE_LATENCY_SLO } from './judge-runtime-config.js';
+const samples = [];
+const MAX_SAMPLES = 2_000;
+export function resetJudgeLatencySamples() {
+    samples.length = 0;
+}
+export function recordJudgeLatency(phase, latencyMs, at = Date.now()) {
+    if (!Number.isFinite(latencyMs) || latencyMs < 0) {
+        return;
+    }
+    samples.push({ phase, latencyMs, at });
+    if (samples.length > MAX_SAMPLES) {
+        samples.splice(0, samples.length - MAX_SAMPLES);
+    }
+}
+function percentile(values, p) {
+    if (values.length === 0) {
+        return 0;
+    }
+    const sorted = [...values].sort((a, b) => a - b);
+    const index = Math.min(sorted.length - 1, Math.ceil((p / 100) * sorted.length) - 1);
+    return sorted[Math.max(0, index)] ?? 0;
+}
+export function judgeLatencyPercentiles(phase) {
+    const values = samples
+        .filter((sample) => sample.phase === phase)
+        .map((sample) => sample.latencyMs);
+    return {
+        p50: percentile(values, 50),
+        p95: percentile(values, 95),
+        count: values.length,
+    };
+}
+export function judgeLatencySloReport() {
+    const measured = {
+        tier0: judgeLatencyPercentiles('tier0'),
+        gate: judgeLatencyPercentiles('gate'),
+        tier1_spawn: judgeLatencyPercentiles('tier1_spawn'),
+        tier1_session: judgeLatencyPercentiles('tier1_session'),
+        tier1_connect: judgeLatencyPercentiles('tier1_connect'),
+        tier1_eval: judgeLatencyPercentiles('tier1_eval'),
+        tier1_parse: judgeLatencyPercentiles('tier1_parse'),
+    };
+    const spawnP95 = measured.tier1_spawn.count > 0 ? measured.tier1_spawn.p95 : JUDGE_LATENCY_SLO.spawnBaselineP95Ms;
+    const sessionP95 = measured.tier1_session.count > 0 ? measured.tier1_session.p95 : spawnP95;
+    const targetP95 = spawnP95 * (1 - JUDGE_LATENCY_SLO.tier1P95ReductionTarget);
+    const sessionMeetsTarget = sessionP95 <= targetP95 && sessionP95 <= JUDGE_LATENCY_SLO.sessionMaxP95Ms;
+    return { slo: JUDGE_LATENCY_SLO, measured, sessionMeetsTarget };
+}

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

@@ -0,0 +1,42 @@
+import type { CliJudgeRunCommand } from './judge-cli.js';
+import type { BelayJudgeSessionConfig } from './judge-runtime-config.js';
+import { type BrokerEvaluateRequest, type BrokerEvaluateResult, JudgeSessionBroker, stopRepoJudgeSessionBroker } from './judge-session-broker.js';
+import type { JudgeSessionResetReason } from './judge-session-guard.js';
+export declare const JUDGE_BROKER_SOCKET = "judge-broker.sock";
+export declare const JUDGE_BROKER_STATUS = "judge-broker.json";
+export declare const JUDGE_BROKER_PID = "judge-broker.pid";
+export declare const JUDGE_BROKER_SESSION = "judge-broker-session.json";
+export interface JudgeBrokerStatus {
+    pid: number;
+    repoRoot: string;
+    socketPath: string;
+    startedAt: string;
+}
+export interface JudgeBrokerPaths {
+    stateDir: string;
+    socketPath: string;
+    statusPath: string;
+    pidPath: string;
+    sessionConfigPath: string;
+}
+export declare function judgeBrokerPaths(stateDir: string): JudgeBrokerPaths;
+export declare function ensureJudgeBrokerDaemon(stateDir: string, repoRoot: string, sessionConfig: BelayJudgeSessionConfig): Promise<JudgeBrokerPaths>;
+export declare function cleanupJudgeBrokerArtifacts(paths: JudgeBrokerPaths): Promise<void>;
+export declare function stopJudgeBrokerDaemon(stateDir: string): Promise<number>;
+export declare function evaluateViaJudgeBroker(options: {
+    stateDir: string;
+    repoRoot: string;
+    sessionConfig: BelayJudgeSessionConfig;
+    request: BrokerEvaluateRequest;
+    timeoutMs: number;
+    runCommand?: CliJudgeRunCommand;
+}): Promise<BrokerEvaluateResult>;
+export declare function resetJudgeBrokerForTests(): void;
+export declare function invalidateJudgeSession(options: {
+    stateDir: string;
+    repoRoot: string;
+    sessionConfig: BelayJudgeSessionConfig;
+    sessionKey: string;
+    reason: JudgeSessionResetReason;
+}): Promise<void>;
+export { JudgeSessionBroker, stopRepoJudgeSessionBroker };