@guilz-dev/belay 0.2.0 → 0.3.0

package/dist/core/verdict/containment.js

@@ -1,6 +1,8 @@
 import path from 'node:path';
 import { matchesSensitivePath } from '../glob.js';
 import { canonicalPath, pathWithinRoot, relativeWithinRepo, resolveMutationTarget, } from '../path-utils.js';
+import { isOutsideRepoSecretCredentialPath } from './persistent-paths.js';
+export { isOutsideRepoSecretCredentialPath, isPersistentAgentPath } from './persistent-paths.js';
 function expandHome(token) {
     if (token === '~' || token.startsWith('~/')) {
         const home = process.env.HOME ?? process.env.USERPROFILE ?? '';
@@ -46,12 +48,40 @@ export function isHighStakesPath(resolvedPath, repoRoot, sensitivePaths, protect
         return true;
     }
     const relative = relativeWithinRepo(repoRoot, resolvedPath);
-    const checkPath = relative ?? resolvedPath;
-    if (matchesSensitivePath(checkPath.replaceAll('\\', '/'), sensitivePaths)) {
+    if (relative !== null && matchesSensitivePath(relative.replaceAll('\\', '/'), sensitivePaths)) {
+        return true;
+    }
+    if (relative === null && isOutsideRepoSecretCredentialPath(resolvedPath)) {
         return true;
     }
     return protectedRoots.some((root) => pathWithinRoot(root, resolvedPath));
 }
+const DESTRUCTIVE_MUTATION_HEADS = new Set([
+    'rm',
+    'shred',
+    'truncate',
+    'dd',
+    'chmod',
+    'chown',
+    'mv',
+    'cp',
+]);
+/** ADR-002 M3: destructive shell head on git/sensitive path (not broad category ask). */
+export function isDestructiveMutationHead(head) {
+    return DESTRUCTIVE_MUTATION_HEADS.has(head);
+}
+export function touchesProtectedRoot(resolvedPath, protectedRoots) {
+    return protectedRoots.some((root) => pathWithinRoot(root, resolvedPath) || root === resolvedPath);
+}
+export function isDestructiveHighStakesMutation(head, resolvedPath, repoRoot, sensitivePaths, protectedRoots = []) {
+    if (touchesProtectedRoot(resolvedPath, protectedRoots)) {
+        return true;
+    }
+    if (!isDestructiveMutationHead(head)) {
+        return false;
+    }
+    return isHighStakesPath(resolvedPath, repoRoot, sensitivePaths, []);
+}
 export function analyzePathTargets(params) {
     const signals = [];
     if (!params.trustedCwd || !params.cwd) {

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

@@ -0,0 +1,40 @@
+import type { BelayJudgeConfig, JudgeProvider } from '../config.js';
+export type JudgeProviderId = 'ollama' | 'codex' | 'claude' | 'cursor';
+/** Read-time aliases for legacy configs; never written on fresh init. */
+export declare const LEGACY_PROVIDER_ID_ALIASES: Record<string, JudgeProviderId>;
+/** Removed catalog ids; load emits a warning and best-effort canonical mapping. */
+export declare const REMOVED_JUDGE_PROVIDER_IDS: readonly ["openrouter", "custom"];
+export declare function isRemovedProviderId(id: string): boolean;
+export declare function warnRemovedProviderId(id: string): void;
+export interface JudgeProviderSpec {
+    id: JudgeProviderId;
+    driver: JudgeProvider;
+    defaultEndpoint: string | null;
+    defaultModel: string;
+    apiKeyEnvVars: string[];
+    isCloud: boolean;
+}
+export declare const JUDGE_CATALOG: Record<JudgeProviderId, JudgeProviderSpec>;
+export declare const JUDGE_PROVIDER_IDS: JudgeProviderId[];
+export declare function normalizeLegacyProviderId(id: string): JudgeProviderId | null;
+export declare function getJudgeProviderSpec(id: string): JudgeProviderSpec | null;
+export declare function isJudgeProviderId(value: string): boolean;
+export declare function inferProviderIdFromConfig(judge: Partial<BelayJudgeConfig>): JudgeProviderId;
+export interface ResolveJudgeFromCatalogInput {
+    providerId: JudgeProviderId | string;
+    model?: string;
+    endpoint?: string | null;
+    timeoutMs?: number;
+    keepAlive?: string | null;
+}
+export declare function resolveJudgeFromCatalog(input: ResolveJudgeFromCatalogInput): BelayJudgeConfig;
+export interface JudgeProviderCapabilities {
+    requiresConsent: boolean;
+    requiresEndpoint: boolean;
+    credentialPolicy: Array<'project' | 'apiKey'>;
+}
+export declare function catalogRequiresEndpoint(providerId: JudgeProviderId | string, opts?: {
+    transport?: string;
+}): boolean;
+export declare function getJudgeProviderCapabilities(providerId: JudgeProviderId | string): JudgeProviderCapabilities | null;
+export declare function isCloudProviderId(providerId: JudgeProviderId | string | undefined): boolean;

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

@@ -0,0 +1,148 @@
+/** Read-time aliases for legacy configs; never written on fresh init. */
+export const LEGACY_PROVIDER_ID_ALIASES = {
+    local: 'ollama',
+    openai: 'codex',
+};
+/** Removed catalog ids; load emits a warning and best-effort canonical mapping. */
+export const REMOVED_JUDGE_PROVIDER_IDS = ['openrouter', 'custom'];
+export function isRemovedProviderId(id) {
+    return REMOVED_JUDGE_PROVIDER_IDS.includes(id);
+}
+export function warnRemovedProviderId(id) {
+    process.stderr.write(`Warning: judge.providerId "${id}" was removed; migrate with belay config set judge.providerId <ollama|codex|claude|cursor>.\n`);
+}
+export const JUDGE_CATALOG = {
+    ollama: {
+        id: 'ollama',
+        driver: 'ollama',
+        defaultEndpoint: 'http://localhost:11434',
+        defaultModel: 'gemma4:e2b',
+        apiKeyEnvVars: [],
+        isCloud: false,
+    },
+    codex: {
+        id: 'codex',
+        driver: 'openai-compatible',
+        defaultEndpoint: null,
+        defaultModel: 'gpt-5.3-codex-high',
+        apiKeyEnvVars: ['OPENAI_API_KEY', 'BELAY_JUDGE_API_KEY'],
+        isCloud: true,
+    },
+    claude: {
+        id: 'claude',
+        driver: 'anthropic',
+        defaultEndpoint: null,
+        defaultModel: 'claude-sonnet-4-6',
+        apiKeyEnvVars: ['ANTHROPIC_API_KEY', 'BELAY_JUDGE_API_KEY'],
+        isCloud: true,
+    },
+    cursor: {
+        id: 'cursor',
+        driver: 'openai-compatible',
+        defaultEndpoint: null,
+        defaultModel: 'composer-2.5',
+        apiKeyEnvVars: ['CURSOR_API_KEY', 'BELAY_JUDGE_API_KEY'],
+        isCloud: true,
+    },
+};
+export const JUDGE_PROVIDER_IDS = Object.keys(JUDGE_CATALOG);
+export function normalizeLegacyProviderId(id) {
+    if (id in JUDGE_CATALOG) {
+        return id;
+    }
+    return LEGACY_PROVIDER_ID_ALIASES[id] ?? null;
+}
+export function getJudgeProviderSpec(id) {
+    const normalized = normalizeLegacyProviderId(id);
+    if (!normalized) {
+        return null;
+    }
+    return JUDGE_CATALOG[normalized];
+}
+export function isJudgeProviderId(value) {
+    return normalizeLegacyProviderId(value) !== null;
+}
+export function inferProviderIdFromConfig(judge) {
+    if (judge.providerId) {
+        const normalized = normalizeLegacyProviderId(judge.providerId);
+        if (normalized) {
+            return normalized;
+        }
+    }
+    if (judge.provider === 'ollama') {
+        return 'ollama';
+    }
+    if (judge.provider === 'anthropic') {
+        return 'claude';
+    }
+    const endpoint = judge.endpoint?.trim().toLowerCase() ?? '';
+    if (endpoint.includes('openrouter.ai')) {
+        return 'codex';
+    }
+    if (endpoint.includes('api.openai.com')) {
+        return 'codex';
+    }
+    if (endpoint) {
+        return 'codex';
+    }
+    if (judge.provider === 'openai-compatible') {
+        const model = judge.model?.trim().toLowerCase() ?? '';
+        if (model.includes('composer')) {
+            return 'cursor';
+        }
+    }
+    return 'codex';
+}
+export function resolveJudgeFromCatalog(input) {
+    const providerId = normalizeLegacyProviderId(String(input.providerId));
+    if (!providerId) {
+        throw new Error(`Unknown judge provider id: ${input.providerId}`);
+    }
+    const spec = JUDGE_CATALOG[providerId];
+    const model = input.model?.trim() || spec.defaultModel;
+    const endpoint = input.endpoint !== undefined ? input.endpoint?.trim() || null : spec.defaultEndpoint;
+    return {
+        provider: spec.driver,
+        providerId: spec.id,
+        model,
+        endpoint,
+        timeoutMs: input.timeoutMs ?? (spec.isCloud ? 8000 : 25000),
+        keepAlive: spec.driver === 'ollama' ? (input.keepAlive ?? '30m') : null,
+    };
+}
+export function catalogRequiresEndpoint(providerId, opts) {
+    const normalized = normalizeLegacyProviderId(String(providerId));
+    if (!normalized || normalized === 'ollama') {
+        return false;
+    }
+    const transport = opts?.transport;
+    if (!transport) {
+        return false;
+    }
+    if (transport.endsWith('-cli') || transport === 'ollama-http') {
+        return false;
+    }
+    return transport === 'http';
+}
+export function getJudgeProviderCapabilities(providerId) {
+    const normalized = normalizeLegacyProviderId(String(providerId));
+    if (!normalized) {
+        return null;
+    }
+    const spec = JUDGE_CATALOG[normalized];
+    return {
+        requiresConsent: spec.isCloud,
+        requiresEndpoint: catalogRequiresEndpoint(normalized, { transport: 'http' }),
+        credentialPolicy: ['project', 'apiKey'],
+    };
+}
+export function isCloudProviderId(providerId) {
+    if (!providerId) {
+        return false;
+    }
+    const normalized = normalizeLegacyProviderId(providerId);
+    if (!normalized) {
+        return false;
+    }
+    return JUDGE_CATALOG[normalized].isCloud;
+}

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

@@ -0,0 +1,23 @@
+import type { ScrubOptions } from '../types.js';
+import { parseTier1Json, type TracedTier1Judge } from './judge.js';
+import type { JudgeProviderId } from './judge-catalog.js';
+export interface CliJudgeOptions {
+    providerId: JudgeProviderId;
+    modelRequested: string;
+    modelResolved: string;
+    timeoutMs?: number;
+    sensitivePaths: string[];
+    scrubOptions: ScrubOptions;
+    runCliCommand?: CliJudgeRunCommand;
+}
+export interface CliInvocation {
+    binary: string;
+    args: string[];
+    stdin?: string;
+}
+export type CliJudgeRunCommand = (invocation: CliInvocation, timeoutMs: number) => Promise<string>;
+export declare function buildCliInvocation(providerId: Exclude<JudgeProviderId, 'ollama'>, prompt: string, model: string): CliInvocation;
+export declare function parseCliJudgeOutput(providerId: Exclude<JudgeProviderId, 'ollama'>, raw: string): ReturnType<typeof parseTier1Json>;
+export declare function createCodexCliJudge(options: Omit<CliJudgeOptions, 'providerId'>): TracedTier1Judge;
+export declare function createCursorCliJudge(options: Omit<CliJudgeOptions, 'providerId'>): TracedTier1Judge;
+export declare function createClaudeCliJudge(options: Omit<CliJudgeOptions, 'providerId'>): TracedTier1Judge;

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

@@ -0,0 +1,280 @@
+import { spawn } from 'node:child_process';
+import { buildTier1Prompt, parseTier1Json, prescanInterpreterCode, } from './judge.js';
+import { scrubOutboundForJudge } from './judge-outbound.js';
+const CLI_BINARIES = {
+    codex: 'codex',
+    cursor: 'cursor-agent',
+    claude: 'claude',
+};
+function failClosedVerdict(reason) {
+    return {
+        local_recoverable: false,
+        destroys_outside_repo: true,
+        destroys_history_or_secrets: true,
+        external_change: true,
+        reason,
+    };
+}
+function transportForProvider(providerId) {
+    return `${providerId}-cli`;
+}
+function traceProvider(providerId) {
+    if (providerId === 'claude') {
+        return 'anthropic';
+    }
+    return 'openai-compatible';
+}
+function initialTrace(options) {
+    return {
+        provider: traceProvider(options.providerId),
+        modelRequested: options.modelRequested,
+        modelResolved: options.modelResolved,
+        latencyMs: 0,
+        transport: transportForProvider(options.providerId),
+    };
+}
+export function buildCliInvocation(providerId, prompt, model) {
+    if (providerId === 'codex') {
+        return {
+            binary: CLI_BINARIES[providerId],
+            args: [
+                'exec',
+                '--json',
+                '--skip-git-repo-check',
+                '--sandbox',
+                'read-only',
+                '--model',
+                model,
+                '-',
+            ],
+            stdin: prompt,
+        };
+    }
+    if (providerId === 'cursor') {
+        return {
+            binary: CLI_BINARIES[providerId],
+            args: [
+                '--print',
+                '--output-format',
+                'json',
+                '--mode',
+                'ask',
+                '--sandbox',
+                'enabled',
+                '--trust',
+                '--model',
+                model,
+                prompt,
+            ],
+        };
+    }
+    return {
+        binary: CLI_BINARIES[providerId],
+        args: [
+            '-p',
+            '--output-format',
+            'json',
+            '--permission-mode',
+            'plan',
+            '--tools',
+            '',
+            '--bare',
+            '--model',
+            model,
+        ],
+        stdin: prompt,
+    };
+}
+function tryParseJson(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function extractVerdictFromJsonValue(value) {
+    if (typeof value === 'string') {
+        return parseTier1Json(value.trim());
+    }
+    if (Array.isArray(value)) {
+        for (let index = value.length - 1; index >= 0; index -= 1) {
+            const verdict = extractVerdictFromJsonValue(value[index]);
+            if (verdict) {
+                return verdict;
+            }
+        }
+        return null;
+    }
+    if (!value || typeof value !== 'object') {
+        return null;
+    }
+    const record = value;
+    for (const key of ['result', 'content', 'text', 'message', 'output_text', 'final']) {
+        if (!(key in record)) {
+            continue;
+        }
+        const verdict = extractVerdictFromJsonValue(record[key]);
+        if (verdict) {
+            return verdict;
+        }
+    }
+    for (const candidate of Object.values(record).reverse()) {
+        const verdict = extractVerdictFromJsonValue(candidate);
+        if (verdict) {
+            return verdict;
+        }
+    }
+    return null;
+}
+function parseCliJsonLines(raw) {
+    const lines = raw
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+        const parsed = tryParseJson(lines[index] ?? '');
+        if (!parsed) {
+            continue;
+        }
+        const verdict = extractVerdictFromJsonValue(parsed);
+        if (verdict) {
+            return verdict;
+        }
+    }
+    return null;
+}
+export function parseCliJudgeOutput(providerId, raw) {
+    const direct = parseTier1Json(raw);
+    if (direct) {
+        return direct;
+    }
+    const parsed = tryParseJson(raw);
+    if (parsed) {
+        const envelopeVerdict = extractVerdictFromJsonValue(parsed);
+        if (envelopeVerdict) {
+            return envelopeVerdict;
+        }
+    }
+    if (providerId === 'codex') {
+        return parseCliJsonLines(raw);
+    }
+    return parseCliJsonLines(raw);
+}
+async function runCliJson(invocation, timeoutMs) {
+    const { binary, args, stdin } = invocation;
+    return new Promise((resolve, reject) => {
+        const child = spawn(binary, args, {
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        const timer = setTimeout(() => {
+            child.kill('SIGTERM');
+            reject(new Error(`${binary} timed out`));
+        }, timeoutMs);
+        child.stdout.on('data', (chunk) => {
+            stdout += String(chunk);
+        });
+        child.stderr.on('data', (chunk) => {
+            stderr += String(chunk);
+        });
+        if (stdin !== undefined) {
+            child.stdin.write(stdin);
+        }
+        child.stdin.end();
+        child.on('error', (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            if (code === 0 && stdout.trim()) {
+                resolve(stdout.trim());
+                return;
+            }
+            reject(new Error(stderr.trim() || `${binary} exited with code ${code ?? 'unknown'}`));
+        });
+    });
+}
+function createCliJudge(options) {
+    const transport = transportForProvider(options.providerId);
+    const timeoutMs = options.timeoutMs ?? 25000;
+    const providerId = options.providerId;
+    const runCommand = options.runCliCommand ?? runCliJson;
+    const judge = {
+        lastTrace: initialTrace(options),
+        async evaluate(input) {
+            const started = Date.now();
+            const prescan = input.innerCode ? prescanInterpreterCode(input.innerCode) : null;
+            if (prescan?.destroys_history_or_secrets) {
+                judge.lastTrace = {
+                    provider: traceProvider(options.providerId),
+                    modelRequested: options.modelRequested,
+                    modelResolved: options.modelResolved,
+                    latencyMs: Date.now() - started,
+                    transport,
+                };
+                return prescan;
+            }
+            const scrubbed = scrubOutboundForJudge(input.text, {
+                sensitivePaths: options.sensitivePaths,
+                scrubOptions: options.scrubOptions,
+            });
+            if (!scrubbed.ok) {
+                judge.lastTrace = {
+                    provider: 'fallback',
+                    modelRequested: options.modelRequested,
+                    modelResolved: options.modelResolved,
+                    latencyMs: Date.now() - started,
+                    fallbackReason: scrubbed.reason,
+                };
+                return failClosedVerdict('outbound_scrub_failed');
+            }
+            const prompt = buildTier1Prompt(scrubbed.text);
+            try {
+                const raw = await runCommand(buildCliInvocation(providerId, prompt, options.modelResolved), timeoutMs);
+                const parsed = parseCliJudgeOutput(providerId, raw);
+                if (!parsed) {
+                    judge.lastTrace = {
+                        provider: 'fallback',
+                        modelRequested: options.modelRequested,
+                        modelResolved: options.modelResolved,
+                        latencyMs: Date.now() - started,
+                        fallbackReason: `${providerId}_cli_parse_error`,
+                    };
+                    return failClosedVerdict(`${providerId}_cli_parse_error`);
+                }
+                judge.lastTrace = {
+                    provider: traceProvider(options.providerId),
+                    modelRequested: options.modelRequested,
+                    modelResolved: options.modelResolved,
+                    latencyMs: Date.now() - started,
+                    transport,
+                    outboundRedacted: true,
+                };
+                return parsed;
+            }
+            catch {
+                judge.lastTrace = {
+                    provider: 'fallback',
+                    modelRequested: options.modelRequested,
+                    modelResolved: options.modelResolved,
+                    latencyMs: Date.now() - started,
+                    fallbackReason: `${providerId}_cli_unavailable`,
+                };
+                return failClosedVerdict(`${providerId}_cli_unavailable`);
+            }
+        },
+    };
+    return judge;
+}
+export function createCodexCliJudge(options) {
+    return createCliJudge({ ...options, providerId: 'codex' });
+}
+export function createCursorCliJudge(options) {
+    return createCliJudge({ ...options, providerId: 'cursor' });
+}
+export function createClaudeCliJudge(options) {
+    return createCliJudge({ ...options, providerId: 'claude' });
+}

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

@@ -9,17 +9,28 @@ export declare function loadPinnedJudgeModels(): Promise<{
         ciPin: string;
     };
 }>;
-export declare function resolveCloudModel(requested: string, pinned: {
+export declare function resolveJudgeModel(judge: BelayJudgeConfig): {
+    requested: string;
+    resolved: string;
+};
+/** @deprecated Use resolveJudgeModel */
+export declare const resolveCloudModel: (requested: string, _pinned: {
+    autoResolved: string;
+}) => {
+    requested: string;
+    resolved: string;
+};
+/** @deprecated Use resolveJudgeModel */
+export declare const resolveCursorModel: (requested: string, _pinned: {
     autoResolved: string;
-}): {
+}) => {
     requested: string;
     resolved: string;
 };
-/** @deprecated Use resolveCloudModel */
-export declare const resolveCursorModel: typeof resolveCloudModel;
 export declare function createJudgeFromConfig(config: BelayConfigV4, options?: {
     pinnedModels?: {
         autoResolved: string;
     };
+    repoRoot?: string;
 }): TracedTier1Judge;
 export declare function judgeConfigSummary(judge: BelayJudgeConfig): string;