@guilz-dev/belay 0.1.0

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

@@ -0,0 +1,75 @@
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { normalizeJudgeProvider, scrubOptionsFromConfig } from '../config.js';
+import { createDeterministicJudgeStub, createFailClosedJudge, createOllamaJudge, createOpenAiCompatibleJudge, } from './judge.js';
+const FIXTURE_MODELS_URL = new URL('../../../fixtures/judge-models.json', import.meta.url);
+let cachedPinnedModels = null;
+export function resetPinnedJudgeModelsCache() {
+    cachedPinnedModels = null;
+}
+export async function loadPinnedJudgeModels() {
+    if (cachedPinnedModels) {
+        return cachedPinnedModels;
+    }
+    try {
+        const raw = await readFile(fileURLToPath(FIXTURE_MODELS_URL), 'utf8');
+        cachedPinnedModels = JSON.parse(raw);
+        return cachedPinnedModels;
+    }
+    catch {
+        cachedPinnedModels = {
+            'openai-compatible': { autoResolved: 'composer-2.5' },
+            ollama: { ciPin: 'gemma4:e2b' },
+        };
+        return cachedPinnedModels;
+    }
+}
+export function resolveCloudModel(requested, pinned) {
+    if (requested === 'auto') {
+        const envResolved = process.env.BELAY_JUDGE_MODEL_RESOLVED?.trim();
+        return {
+            requested,
+            resolved: envResolved || pinned.autoResolved,
+        };
+    }
+    return { requested, resolved: requested };
+}
+/** @deprecated Use resolveCloudModel */
+export const resolveCursorModel = resolveCloudModel;
+export function createJudgeFromConfig(config, options = {}) {
+    const judgeConfig = config.judge;
+    const provider = normalizeJudgeProvider(judgeConfig.provider);
+    if (provider === 'openai-compatible') {
+        const endpoint = judgeConfig.endpoint?.trim();
+        if (!endpoint) {
+            return createFailClosedJudge({
+                reason: 'openai_compatible_endpoint_missing',
+                fallbackReason: 'missing_endpoint',
+                modelRequested: judgeConfig.model,
+                modelResolved: judgeConfig.model,
+            });
+        }
+        const pinned = options.pinnedModels ?? { autoResolved: 'composer-2.5' };
+        const { resolved } = resolveCloudModel(judgeConfig.model, pinned);
+        return createOpenAiCompatibleJudge({
+            endpoint,
+            modelRequested: judgeConfig.model,
+            modelResolved: resolved,
+            timeoutMs: judgeConfig.timeoutMs,
+            sensitivePaths: config.classifier.sensitivePaths,
+            scrubOptions: scrubOptionsFromConfig(config),
+        });
+    }
+    if (provider === 'ollama') {
+        return createOllamaJudge({
+            model: judgeConfig.model,
+            baseUrl: judgeConfig.endpoint ?? 'http://127.0.0.1:11434',
+            timeoutMs: judgeConfig.timeoutMs,
+            keepAlive: judgeConfig.keepAlive,
+        });
+    }
+    return createDeterministicJudgeStub();
+}
+export function judgeConfigSummary(judge) {
+    return `${judge.provider}/${judge.model}`;
+}

package/dist/core/v2/judge-outbound.d.ts

@@ -0,0 +1,12 @@
+import type { ScrubOptions } from '../types.js';
+export interface OutboundScrubOptions {
+    sensitivePaths: string[];
+    scrubOptions: ScrubOptions;
+}
+export declare function scrubOutboundForJudge(text: string, options: OutboundScrubOptions): {
+    ok: true;
+    text: string;
+} | {
+    ok: false;
+    reason: string;
+};

package/dist/core/v2/judge-outbound.js

@@ -0,0 +1,73 @@
+import { matchesSensitivePath } from '../glob.js';
+import { scrubString } from '../scrub.js';
+const PATH_LIKE = /(?:^|[\s"'`=])(~\/[^\s"'`]+|\/[^\s"'`]+|\.\/[^\s"'`]+|\.\.\/[^\s"'`]+|[A-Za-z]:\\[^\s"'`]+)/g;
+const REDACTED_PLACEHOLDER = /^(?:<redacted>|\[REDACTED\]|<secret>|<high-entropy>|<approval-id>)$/i;
+const URL_CREDENTIALS_PATTERN = /\b[A-Za-z][A-Za-z0-9+.-]*:\/\/([^/\s:@]+):([^@\s/]+)@/gi;
+const GENERIC_AUTH_HEADER_PATTERN = /\b(?:Authorization|X-Api-Key|X-Auth-Token|Private-Token):\s*([^\s]+)/gi;
+function hasResidualBearerToken(text) {
+    for (const match of text.matchAll(/\bBearer\s+(\S+)/gi)) {
+        const token = match[1] ?? '';
+        if (!REDACTED_PLACEHOLDER.test(token)) {
+            return true;
+        }
+    }
+    return false;
+}
+function hasResidualApiKey(text) {
+    return /\bsk-(?![^\s]*<redacted>)[A-Za-z0-9_-]{4,}/i.test(text);
+}
+function hasResidualUrlCredentials(text) {
+    for (const match of text.matchAll(URL_CREDENTIALS_PATTERN)) {
+        const username = (match[1] ?? '').replace(/^['"]|['"]$/g, '');
+        const password = (match[2] ?? '').replace(/^['"]|['"]$/g, '');
+        if (!REDACTED_PLACEHOLDER.test(username) || !REDACTED_PLACEHOLDER.test(password)) {
+            return true;
+        }
+    }
+    return false;
+}
+function hasResidualAuthHeader(text) {
+    for (const match of text.matchAll(GENERIC_AUTH_HEADER_PATTERN)) {
+        const token = (match[1] ?? '').replace(/^['"]|['"]$/g, '');
+        if (!REDACTED_PLACEHOLDER.test(token)) {
+            return true;
+        }
+    }
+    return false;
+}
+function redactSensitivePathToken(token, sensitivePaths) {
+    const trimmed = token.replace(/^['"`]+|['"`]+$/g, '');
+    const normalized = trimmed.replaceAll('\\', '/');
+    if (!matchesSensitivePath(normalized, sensitivePaths)) {
+        return token;
+    }
+    const segments = normalized.split('/');
+    const basename = segments.at(-1) ?? normalized;
+    if (segments.length > 1) {
+        return token.replace(basename, '[REDACTED]');
+    }
+    return '[REDACTED]';
+}
+export function scrubOutboundForJudge(text, options) {
+    try {
+        let scrubbed = scrubString(text, {
+            ...options.scrubOptions,
+            maskHighEntropyStrings: options.scrubOptions.maskHighEntropyStrings !== false,
+        });
+        scrubbed = scrubbed.replace(PATH_LIKE, (match, pathToken) => {
+            const redacted = redactSensitivePathToken(pathToken, options.sensitivePaths);
+            return match.replace(pathToken, redacted);
+        });
+        if (hasResidualApiKey(scrubbed) ||
+            hasResidualBearerToken(scrubbed) ||
+            hasResidualUrlCredentials(scrubbed) ||
+            hasResidualAuthHeader(scrubbed)) {
+            return { ok: false, reason: 'residual_secret_detected' };
+        }
+        return { ok: true, text: scrubbed };
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : 'scrub_failed';
+        return { ok: false, reason };
+    }
+}

package/dist/core/v2/judge.d.ts

@@ -0,0 +1,47 @@
+import type { ScrubOptions } from '../types.js';
+import type { Tier1Judge, Tier1Verdict } from './types.js';
+export interface Tier1JudgeTrace {
+    provider: 'openai-compatible' | 'ollama' | 'fallback';
+    modelRequested: string;
+    modelResolved: string;
+    latencyMs: number;
+    outboundRedacted?: boolean;
+    fallbackReason?: string;
+}
+export interface TracedTier1Judge extends Tier1Judge {
+    lastTrace?: Tier1JudgeTrace;
+}
+export declare function prescanInterpreterCode(code: string): Tier1Verdict | null;
+/** Conservative stub: Tier1 defers to Tier0; returns safe negatives for structural suite. */
+export declare function createDeterministicJudgeStub(): TracedTier1Judge;
+/** Fail-closed judge for when Tier1 is required but unavailable. */
+export declare function createFailClosedJudge(options?: {
+    reason?: string;
+    fallbackReason?: string;
+    modelRequested?: string;
+    modelResolved?: string;
+}): TracedTier1Judge;
+export interface OllamaJudgeOptions {
+    model?: string;
+    baseUrl?: string;
+    timeoutMs?: number;
+    keepAlive?: string | null;
+    fetchImpl?: typeof fetch;
+}
+export declare function createOllamaJudge(options?: OllamaJudgeOptions): TracedTier1Judge;
+export interface OpenAiCompatibleJudgeOptions {
+    endpoint: string;
+    modelRequested: string;
+    modelResolved: string;
+    timeoutMs: number;
+    apiKey?: string;
+    sensitivePaths: string[];
+    scrubOptions: ScrubOptions;
+    fetchImpl?: typeof fetch;
+}
+export declare function createOpenAiCompatibleJudge(options: OpenAiCompatibleJudgeOptions): TracedTier1Judge;
+/** @deprecated Use createOpenAiCompatibleJudge */
+export declare const createCursorJudge: typeof createOpenAiCompatibleJudge;
+export interface CursorJudgeOptions extends OpenAiCompatibleJudgeOptions {
+}
+export declare function tier1RequiresAsk(verdict: Tier1Verdict): boolean;

package/dist/core/v2/judge.js

@@ -0,0 +1,264 @@
+import { scrubOutboundForJudge } from './judge-outbound.js';
+const SECRET_PATTERNS = [/\.env\b/i, /\.pem\b/i, /id_rsa\b/i, /credentials/i, /secrets?\b/i];
+const DESTRUCTIVE_VERBS = /\b(rm|rmtree|unlink|delete|truncate|shred|destroy|drop)\b/i;
+const GIT_PATTERNS = /\.git\b/i;
+const TIER1_PROMPT = `Answer ONLY with JSON: {"external_change":boolean,"destroys_outside_repo":boolean,"destroys_history_or_secrets":boolean,"reason":string}
+Default all three booleans to true when unsure. reason should be a short snake_case label.
+
+external_change: CREATE/MODIFY/DELETE on database, network endpoint, cloud, remote git, registry, queue. READ/QUERY/GET is NOT a change.
+destroys_outside_repo: DELETE/OVERWRITE files OUTSIDE the current repository working tree.
+destroys_history_or_secrets: DELETE/OVERWRITE .git directory OR secret/credential files (.env, *.pem, id_rsa, credentials).
+
+Command/code:
+`;
+function failClosedVerdict(reason) {
+    return {
+        external_change: true,
+        destroys_outside_repo: true,
+        destroys_history_or_secrets: true,
+        reason,
+    };
+}
+function parseTier1Json(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.external_change !== 'boolean' ||
+            typeof parsed.destroys_outside_repo !== 'boolean' ||
+            typeof parsed.destroys_history_or_secrets !== 'boolean') {
+            return null;
+        }
+        return {
+            external_change: parsed.external_change !== false,
+            destroys_outside_repo: parsed.destroys_outside_repo !== false,
+            destroys_history_or_secrets: parsed.destroys_history_or_secrets !== false,
+            reason: typeof parsed.reason === 'string' ? parsed.reason : 'tier1_llm',
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function prescanInterpreterCode(code) {
+    const normalized = code.replaceAll('\\', '/');
+    const hitsSecret = SECRET_PATTERNS.some((pattern) => pattern.test(normalized));
+    const hitsGit = GIT_PATTERNS.test(normalized);
+    const hitsDestructive = DESTRUCTIVE_VERBS.test(normalized);
+    if ((hitsSecret || hitsGit) && hitsDestructive) {
+        return {
+            external_change: false,
+            destroys_outside_repo: false,
+            destroys_history_or_secrets: true,
+            reason: 'prescan_destructive_secret',
+        };
+    }
+    return null;
+}
+/** Conservative stub: Tier1 defers to Tier0; returns safe negatives for structural suite. */
+export function createDeterministicJudgeStub() {
+    return {
+        evaluate() {
+            return Promise.resolve({
+                external_change: false,
+                destroys_outside_repo: false,
+                destroys_history_or_secrets: false,
+                reason: 'deterministic_stub',
+            });
+        },
+    };
+}
+/** Fail-closed judge for when Tier1 is required but unavailable. */
+export function createFailClosedJudge(options) {
+    const reason = options?.reason ?? 'fail_closed';
+    const judge = {
+        evaluate() {
+            const started = Date.now();
+            if (options?.fallbackReason) {
+                judge.lastTrace = {
+                    provider: 'fallback',
+                    modelRequested: options.modelRequested ?? 'unknown',
+                    modelResolved: options.modelResolved ?? 'unknown',
+                    latencyMs: Date.now() - started,
+                    fallbackReason: options.fallbackReason,
+                };
+            }
+            return Promise.resolve(failClosedVerdict(reason));
+        },
+    };
+    return judge;
+}
+export function createOllamaJudge(options = {}) {
+    const model = options.model ?? 'gemma4:e2b';
+    const baseUrl = (options.baseUrl ?? 'http://127.0.0.1:11434').replace(/\/$/, '');
+    const timeoutMs = options.timeoutMs ?? 25000;
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const judge = {
+        async evaluate(input) {
+            const started = Date.now();
+            const prescan = input.innerCode ? prescanInterpreterCode(input.innerCode) : null;
+            if (prescan?.destroys_history_or_secrets) {
+                judge.lastTrace = {
+                    provider: 'ollama',
+                    modelRequested: model,
+                    modelResolved: model,
+                    latencyMs: Date.now() - started,
+                };
+                return prescan;
+            }
+            const body = `${TIER1_PROMPT}${input.text}`;
+            try {
+                const response = await fetchImpl(`${baseUrl}/api/generate`, {
+                    method: 'POST',
+                    headers: { 'content-type': 'application/json' },
+                    body: JSON.stringify({
+                        model,
+                        prompt: body,
+                        stream: false,
+                        format: 'json',
+                        keep_alive: options.keepAlive ?? undefined,
+                    }),
+                    signal: AbortSignal.timeout(timeoutMs),
+                });
+                if (!response.ok) {
+                    judge.lastTrace = {
+                        provider: 'fallback',
+                        modelRequested: model,
+                        modelResolved: model,
+                        latencyMs: Date.now() - started,
+                        fallbackReason: `ollama_http_${response.status}`,
+                    };
+                    return failClosedVerdict('ollama_unavailable');
+                }
+                const payload = (await response.json());
+                const parsed = parseTier1Json(payload.response ?? '{}');
+                if (!parsed) {
+                    judge.lastTrace = {
+                        provider: 'fallback',
+                        modelRequested: model,
+                        modelResolved: model,
+                        latencyMs: Date.now() - started,
+                        fallbackReason: 'ollama_parse_error',
+                    };
+                    return failClosedVerdict('ollama_parse_error');
+                }
+                judge.lastTrace = {
+                    provider: 'ollama',
+                    modelRequested: model,
+                    modelResolved: model,
+                    latencyMs: Date.now() - started,
+                };
+                return parsed;
+            }
+            catch (error) {
+                judge.lastTrace = {
+                    provider: 'fallback',
+                    modelRequested: model,
+                    modelResolved: model,
+                    latencyMs: Date.now() - started,
+                    fallbackReason: error instanceof Error ? error.message : 'ollama_error',
+                };
+                return failClosedVerdict('ollama_unavailable');
+            }
+        },
+    };
+    return judge;
+}
+export function createOpenAiCompatibleJudge(options) {
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const apiBase = options.endpoint.replace(/\/$/, '');
+    const judge = {
+        async evaluate(input) {
+            const started = Date.now();
+            const prescan = input.innerCode ? prescanInterpreterCode(input.innerCode) : null;
+            if (prescan?.destroys_history_or_secrets) {
+                judge.lastTrace = {
+                    provider: 'openai-compatible',
+                    modelRequested: options.modelRequested,
+                    modelResolved: options.modelResolved,
+                    latencyMs: Date.now() - started,
+                };
+                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 { resolveJudgeApiKey } = await import('../judge-api-key.js');
+            const resolvedKey = resolveJudgeApiKey();
+            const apiKey = options.apiKey ?? resolvedKey.key;
+            if (!apiKey) {
+                judge.lastTrace = {
+                    provider: 'fallback',
+                    modelRequested: options.modelRequested,
+                    modelResolved: options.modelResolved,
+                    latencyMs: Date.now() - started,
+                    fallbackReason: 'missing_api_key',
+                };
+                return failClosedVerdict('openai_compatible_auth_error');
+            }
+            const prompt = `${TIER1_PROMPT}${scrubbed.text}`;
+            try {
+                const response = await fetchImpl(`${apiBase}/chat/completions`, {
+                    method: 'POST',
+                    headers: {
+                        'content-type': 'application/json',
+                        authorization: `Bearer ${apiKey}`,
+                    },
+                    body: JSON.stringify({
+                        model: options.modelResolved,
+                        messages: [{ role: 'user', content: prompt }],
+                        response_format: { type: 'json_object' },
+                    }),
+                    signal: AbortSignal.timeout(options.timeoutMs),
+                });
+                if (!response.ok) {
+                    judge.lastTrace = {
+                        provider: 'fallback',
+                        modelRequested: options.modelRequested,
+                        modelResolved: options.modelResolved,
+                        latencyMs: Date.now() - started,
+                        fallbackReason: `openai_compatible_http_${response.status}`,
+                    };
+                    return failClosedVerdict('openai_compatible_unavailable');
+                }
+                const payload = (await response.json());
+                const content = payload.choices?.[0]?.message?.content ?? '{}';
+                const parsed = parseTier1Json(content);
+                judge.lastTrace = {
+                    provider: parsed ? 'openai-compatible' : 'fallback',
+                    modelRequested: options.modelRequested,
+                    modelResolved: options.modelResolved,
+                    latencyMs: Date.now() - started,
+                    outboundRedacted: true,
+                    fallbackReason: parsed ? undefined : 'openai_compatible_parse_error',
+                };
+                return parsed ?? failClosedVerdict('openai_compatible_parse_error');
+            }
+            catch (error) {
+                judge.lastTrace = {
+                    provider: 'fallback',
+                    modelRequested: options.modelRequested,
+                    modelResolved: options.modelResolved,
+                    latencyMs: Date.now() - started,
+                    fallbackReason: error instanceof Error ? error.message : 'openai_compatible_error',
+                };
+                return failClosedVerdict('openai_compatible_unavailable');
+            }
+        },
+    };
+    return judge;
+}
+/** @deprecated Use createOpenAiCompatibleJudge */
+export const createCursorJudge = createOpenAiCompatibleJudge;
+export function tier1RequiresAsk(verdict) {
+    return (verdict.external_change || verdict.destroys_outside_repo || verdict.destroys_history_or_secrets);
+}

package/dist/core/v2/launcher-resolve.d.ts

@@ -0,0 +1,12 @@
+export interface LauncherResolution {
+    recipes: string[];
+    opaque: boolean;
+    reason: string;
+}
+export declare function resolveLauncherRecipe(params: {
+    tokens: string[];
+    cwd: string;
+    repoRoot: string;
+    depth: number;
+}): LauncherResolution | null;
+export declare function isRoutineLauncher(tokens: string[]): boolean;

package/dist/core/v2/launcher-resolve.js

@@ -0,0 +1,190 @@
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+const MAX_RESOLVE_DEPTH = 8;
+function readPackageJson(dir) {
+    const packagePath = path.join(dir, 'package.json');
+    if (!existsSync(packagePath)) {
+        return null;
+    }
+    try {
+        return JSON.parse(readFileSync(packagePath, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function findPackageJson(startDir, stopDir) {
+    let current = path.resolve(startDir);
+    const stop = path.resolve(stopDir);
+    while (true) {
+        const packagePath = path.join(current, 'package.json');
+        if (existsSync(packagePath)) {
+            return packagePath;
+        }
+        if (current === stop || current === path.dirname(current)) {
+            return existsSync(packagePath) ? packagePath : null;
+        }
+        const parent = path.dirname(current);
+        if (!parent.startsWith(stop) && parent !== current) {
+            // still allow walking up until repo root parent
+        }
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+    return null;
+}
+function launcherTokens(tokens) {
+    const dashIndex = tokens.indexOf('--');
+    return dashIndex === -1 ? tokens : tokens.slice(0, dashIndex);
+}
+function forwardedArgs(tokens) {
+    const dashIndex = tokens.indexOf('--');
+    if (dashIndex === -1) {
+        return [];
+    }
+    return tokens.slice(dashIndex + 1);
+}
+function npmScriptName(tokens) {
+    const launcher = launcherTokens(tokens);
+    if (launcher[0] === 'npm' && launcher[1] === 'test') {
+        return 'test';
+    }
+    if (launcher[0] === 'npm' && launcher[1] === 'run' && launcher[2]) {
+        return launcher[2];
+    }
+    if (launcher[0] === 'pnpm' && launcher[1] === 'run' && launcher[2]) {
+        return launcher[2];
+    }
+    if (launcher[0] === 'npm' && launcher[1] && launcher[1] !== 'run' && launcher[1] !== 'install') {
+        return null;
+    }
+    return null;
+}
+function applyForwardedArgs(recipe, extra) {
+    if (extra.length === 0) {
+        return recipe.trim();
+    }
+    return `${recipe.trim()} ${extra.join(' ')}`.trim();
+}
+function resolveNpmRecipe(cwd, repoRoot, scriptName, extraArgs) {
+    const packagePath = findPackageJson(cwd, repoRoot) ?? findPackageJson(cwd, cwd);
+    if (!packagePath) {
+        if (/deploy|publish|release|ship|prod/i.test(scriptName)) {
+            return { recipes: [], opaque: true, reason: 'external_script' };
+        }
+        return { recipes: [], opaque: true, reason: 'package_json_missing' };
+    }
+    const pkg = readPackageJson(path.dirname(packagePath));
+    const scripts = pkg?.scripts;
+    if (!scripts || typeof scripts !== 'object') {
+        return { recipes: [], opaque: true, reason: 'package_scripts_missing' };
+    }
+    const recipe = scripts[scriptName];
+    if (!recipe || typeof recipe !== 'string') {
+        if (/deploy|publish|release|ship|prod/i.test(scriptName)) {
+            return { recipes: [], opaque: true, reason: 'external_script' };
+        }
+        return { recipes: [], opaque: true, reason: 'npm_script_undefined' };
+    }
+    if (/\$\(/.test(recipe) || /\$\{/.test(recipe)) {
+        return { recipes: [], opaque: true, reason: 'npm_script_dynamic' };
+    }
+    return {
+        recipes: [applyForwardedArgs(recipe, extraArgs)],
+        opaque: false,
+        reason: 'npm_script_resolved',
+    };
+}
+function parseMakefileRecipes(makefilePath) {
+    const recipes = new Map();
+    try {
+        const content = readFileSync(makefilePath, 'utf8');
+        const lines = content.split('\n');
+        let currentTarget = null;
+        let recipeLines = [];
+        const flush = () => {
+            if (currentTarget && recipeLines.length > 0) {
+                recipes.set(currentTarget, recipeLines.map((line) => line.trim()).filter((line) => line.length > 0));
+            }
+            currentTarget = null;
+            recipeLines = [];
+        };
+        for (const line of lines) {
+            if (line.trim().startsWith('#')) {
+                continue;
+            }
+            const targetMatch = /^([A-Za-z0-9_.-]+)\s*:(?!=)/.exec(line);
+            if (targetMatch) {
+                flush();
+                currentTarget = targetMatch[1] ?? null;
+                const inline = line.slice(targetMatch[0].length).trim();
+                if (inline && !inline.startsWith('#')) {
+                    recipeLines.push(inline);
+                }
+                continue;
+            }
+            if (currentTarget && /^\t/.test(line)) {
+                recipeLines.push(line.trim());
+            }
+        }
+        flush();
+    }
+    catch {
+        return recipes;
+    }
+    return recipes;
+}
+function resolveMakeRecipe(cwd, repoRoot, target) {
+    const candidates = ['Makefile', 'makefile', 'GNUmakefile'];
+    let makefilePath = null;
+    let searchDir = path.resolve(cwd);
+    const stop = path.resolve(repoRoot);
+    while (true) {
+        for (const name of candidates) {
+            const candidate = path.join(searchDir, name);
+            if (existsSync(candidate)) {
+                makefilePath = candidate;
+                break;
+            }
+        }
+        if (makefilePath || searchDir === stop || searchDir === path.dirname(searchDir)) {
+            break;
+        }
+        searchDir = path.dirname(searchDir);
+    }
+    if (!makefilePath) {
+        return { recipes: [], opaque: true, reason: 'unknown_local_effect' };
+    }
+    const recipes = parseMakefileRecipes(makefilePath);
+    const recipeLines = recipes.get(target);
+    if (!recipeLines || recipeLines.length === 0) {
+        return { recipes: [], opaque: true, reason: 'make_target_undefined' };
+    }
+    for (const line of recipeLines) {
+        if (/\$\(/.test(line) || /\$\{/.test(line)) {
+            return { recipes: [], opaque: true, reason: 'make_recipe_dynamic' };
+        }
+    }
+    return { recipes: recipeLines, opaque: false, reason: 'make_recipe_resolved' };
+}
+export function resolveLauncherRecipe(params) {
+    if (params.depth >= MAX_RESOLVE_DEPTH) {
+        return { recipes: [], opaque: true, reason: 'launcher_depth_exceeded' };
+    }
+    const tokens = params.tokens;
+    const scriptName = npmScriptName(tokens);
+    if (scriptName) {
+        return resolveNpmRecipe(params.cwd, params.repoRoot, scriptName, forwardedArgs(tokens));
+    }
+    if (tokens[0] === 'make' && tokens[1] && !tokens[1].startsWith('-')) {
+        return resolveMakeRecipe(params.cwd, params.repoRoot, tokens[1]);
+    }
+    return null;
+}
+export function isRoutineLauncher(tokens) {
+    return ((tokens[0] === 'npm' && (tokens[1] === 'run' || tokens[1] === 'test')) ||
+        tokens[0] === 'pnpm' ||
+        tokens[0] === 'make');
+}

package/dist/core/v2/overrides.d.ts

@@ -0,0 +1,7 @@
+import type { ParsedSegment } from './parser.js';
+import type { InternalSegmentVerdict, VerdictContext } from './types.js';
+export declare function matchesCustomPatterns(command: string, segment: ParsedSegment, patterns: string[] | undefined): boolean;
+export declare function customAllowMatch(command: string, segment: ParsedSegment, context: VerdictContext): boolean;
+export declare function customExternalMatch(command: string, segment: ParsedSegment, context: VerdictContext): boolean;
+export declare function allowFromCustomOverride(opacity: InternalSegmentVerdict['opacity']): InternalSegmentVerdict;
+export declare function askFromCustomExternal(opacity: InternalSegmentVerdict['opacity']): InternalSegmentVerdict;