@guilz-dev/belay 0.3.0 → 0.4.0

package/dist/cli.js

@@ -6,11 +6,14 @@ import { auditProject, formatAuditReport } from './commands/audit.js';
 import { doctorProject, formatDoctorReport } from './commands/doctor.js';
 import { dogfoodProject, formatDogfoodResult } from './commands/dogfood.js';
 import { explainCommand, formatExplainReport } from './commands/explain.js';
+import { formatHarvestReport, harvestApplyProject, harvestListProject } from './commands/harvest.js';
 import { formatMetricsReport, metricsProject } from './commands/metrics.js';
+import { formatQualityReport, qualityCheck } from './commands/quality.js';
 import { formatRecoverReport, recoverProject } from './commands/recover.js';
 import { formatReport, reportProject } from './commands/report.js';
 import { revokeApproval } from './commands/revoke.js';
 import { formatSimulateReport, simulateProject } from './commands/simulate.js';
+import { revokeStandingAllow } from './commands/standing-allow.js';
 import { formatStatusReport, statusProject } from './commands/status.js';
 import { loadConfigFile } from './config-io.js';
 import { rejectDeprecatedJudgeModelAuto } from './core/judge-model-policy.js';
@@ -154,6 +157,13 @@ function parseArgs(argv) {
             index += 1;
             continue;
         }
+        if (token === '--live-probe') {
+            if (command !== 'judge') {
+                throw new Error('--live-probe is only valid for judge test.');
+            }
+            options.judgeLiveProbe = true;
+            continue;
+        }
         if (token === '--json') {
             options.json = true;
             continue;
@@ -178,6 +188,24 @@ function parseArgs(argv) {
             index += 1;
             continue;
         }
+        if (token === '--outcome') {
+            const next = rest[index + 1];
+            if (!next || !['provably-benign', 'accepted-benign', 'reject'].includes(next)) {
+                throw new Error('--outcome requires provably-benign, accepted-benign, or reject.');
+            }
+            options.harvestOutcome = next;
+            index += 1;
+            continue;
+        }
+        if (token === '--corpus') {
+            const next = rest[index + 1];
+            if (!next) {
+                throw new Error('--corpus requires a path.');
+            }
+            options.corpusPath = next;
+            index += 1;
+            continue;
+        }
         if (token === '--kind') {
             const next = rest[index + 1];
             if (!next) {
@@ -252,11 +280,18 @@ function parseArgs(argv) {
             index += 1;
             continue;
         }
+        if (token === '--replay') {
+            if (command !== 'approve') {
+                throw new Error('--replay is only valid for approve.');
+            }
+            options.approveReplay = true;
+            continue;
+        }
         if (token === '--scope') {
             const next = rest[index + 1];
             if (command === 'approve') {
-                if (!next || !['once', 'domain', 'path'].includes(next)) {
-                    throw new Error('--scope requires once, domain, or path.');
+                if (!next || !['once', 'domain', 'path', 'workspace-root'].includes(next)) {
+                    throw new Error('--scope requires once, domain, path, or workspace-root.');
                 }
                 options.approveScope = next;
             }
@@ -315,6 +350,9 @@ function parseArgs(argv) {
             if (command === 'recover') {
                 options.recoverCommand = next;
             }
+            else if (command === 'harvest') {
+                options.harvestCommand = next;
+            }
             else {
                 options.explainCommand = next;
             }
@@ -367,16 +405,31 @@ function parseArgs(argv) {
             }
             throw new Error('sandbox requires subcommand: status');
         }
+        if (command === 'standing-allow' && !options.standingAllowSubcommand) {
+            if (token === 'revoke') {
+                options.standingAllowSubcommand = token;
+                continue;
+            }
+            throw new Error('standing-allow requires subcommand: revoke');
+        }
+        if (command === 'harvest' && !options.harvestSubcommand) {
+            if (token === 'list' || token === 'apply') {
+                options.harvestSubcommand = token;
+                continue;
+            }
+            throw new Error('harvest requires subcommand: list or apply');
+        }
         if (command === 'judge' && !options.judgeSubcommand) {
             if (token === 'status' ||
                 token === 'list' ||
                 token === 'use' ||
                 token === 'test' ||
+                token === 'bench' ||
                 token === 'consent') {
                 options.judgeSubcommand = token;
                 continue;
             }
-            throw new Error('judge requires subcommand: status, list, use, test, or consent');
+            throw new Error('judge requires subcommand: status, list, use, test, bench, or consent');
         }
         if (command === 'config' && !options.configSubcommand) {
             if (token === 'list' ||
@@ -458,6 +511,7 @@ Usage:
   ${c} dogfood [--target <dir>] [--adapter cursor|claude|codex] [--enforce] [--force]
   ${c} doctor [--target <dir>] [--adapter cursor|claude|codex] [--json] [--fix] [--dry-run]
   ${c} metrics [--target <dir>] [--json]
+  ${c} quality [--target <dir>] [--corpus <path>] [--json]
   ${c} report [--target <dir>] [--since <iso>] [--until <iso>] [--limit <n>] [--json]
   ${c} recover [--target <dir>] [--since <iso>] [--fingerprint <fp>] [--command "<text>"] [--limit <n>] [--json]
     (--limit picks the Nth recover candidate after priority ranking: local_mutation first, then recency; 1 = highest priority, default 1)
@@ -467,11 +521,15 @@ Usage:
   ${c} explain [--target <dir>] [--cwd <dir>] [--kind shell|tool|subagent] [--tool <name>] [--payload-json <json>] [--command <text>] [--json] [-- <command>]
   ${c} egress <start|stop|status|env> [--target <dir>] [--json]
   ${c} sandbox status [--target <dir>] [--json]
-  ${c} judge <status|list|use|test|consent> [--target <dir>] [--json]
+  ${c} judge <status|list|use|test|bench|consent> [--target <dir>] [--json]
+  ${c} judge test [--target <dir>] [--json] [--live-probe]
   ${c} judge use <ollama|codex|claude|cursor> [--model <id>] [--endpoint <url>] [--timeout <ms>] [--accept-cloud] [--cloud-consent-approval-id <id>] [--credential project|apiKey] [--key-stdin] [--key-env <NAME>]
   ${c} judge consent <ollama|codex|claude|cursor> [--endpoint <url>]
-  ${c} approve <approval-id> [--scope once|domain|path] [--path <path>] [--token <signed-token>] [--target <dir>]
+  ${c} approve <approval-id> [--replay] [--scope once|domain|path|workspace-root] [--path <path>] [--token <signed-token>] [--target <dir>]
   ${c} revoke <approval-id> [--target <dir>]
+  ${c} standing-allow revoke --fingerprint <fp> [--kind shell|tool|subagent] [--target <dir>]
+  ${c} harvest list [--target <dir>] [--since <iso>] [--until <iso>] [--json]
+  ${c} harvest apply --command "<text>" --outcome provably-benign|accepted-benign|reject [--reason <r>] [--corpus <path>] [--target <dir>]
 `);
 }
 async function main() {
@@ -545,6 +603,9 @@ async function main() {
             if (!options.judgeSubcommand) {
                 throw new Error('judge requires subcommand: status, list, use, or test');
             }
+            if (options.judgeLiveProbe && options.judgeSubcommand !== 'test') {
+                throw new Error('--live-probe is only valid for judge test.');
+            }
             const result = await runJudgeCommand({
                 targetDir: options.targetDir,
                 json: options.json,
@@ -558,6 +619,7 @@ async function main() {
                 credentialMode: options.credentialMode,
                 keyStdin: options.keyStdin,
                 keyEnv: options.keyEnv,
+                liveProbe: options.judgeLiveProbe,
             });
             if (options.json && typeof result === 'object') {
                 process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
@@ -679,6 +741,21 @@ async function main() {
             }
             return;
         }
+        if (command === 'quality') {
+            const report = await qualityCheck({
+                targetDir: options.targetDir,
+                corpusDir: options.corpusPath,
+                json: options.json,
+            });
+            if (options.json) {
+                process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+            }
+            else {
+                process.stdout.write(`${formatQualityReport(report)}\n`);
+            }
+            process.exitCode = report.ok ? 0 : 1;
+            return;
+        }
         if (command === 'report') {
             const report = await reportProject({
                 targetDir: options.targetDir,
@@ -695,6 +772,42 @@ async function main() {
             }
             return;
         }
+        if (command === 'harvest') {
+            if (options.harvestSubcommand === 'list') {
+                const report = await harvestListProject({
+                    targetDir: options.targetDir,
+                    since: options.since,
+                    until: options.until,
+                    json: options.json,
+                });
+                if (options.json) {
+                    process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+                }
+                else {
+                    process.stdout.write(`${formatHarvestReport(report)}\n`);
+                }
+                return;
+            }
+            if (options.harvestSubcommand === 'apply') {
+                if (!options.harvestCommand) {
+                    throw new Error('harvest apply requires --command.');
+                }
+                if (!options.harvestOutcome) {
+                    throw new Error('harvest apply requires --outcome.');
+                }
+                const result = await harvestApplyProject({
+                    targetDir: options.targetDir,
+                    command: options.harvestCommand,
+                    outcome: options.harvestOutcome,
+                    reason: options.reason,
+                    corpusPath: options.corpusPath,
+                });
+                process.stdout.write(`${result.message}\n`);
+                process.exitCode = result.ok ? 0 : 1;
+                return;
+            }
+            throw new Error('harvest requires subcommand: list or apply');
+        }
         if (command === 'recover') {
             const report = await recoverProject({
                 targetDir: options.targetDir,
@@ -804,6 +917,7 @@ async function main() {
                 token: options.approvalToken,
                 scope: options.approveScope,
                 scopePath: options.approvePath,
+                replay: options.approveReplay,
             });
             process.stdout.write(`${result.message}\n`);
             process.exitCode = result.ok ? 0 : 1;
@@ -821,6 +935,24 @@ async function main() {
             process.exitCode = result.ok ? 0 : 1;
             return;
         }
+        if (command === 'standing-allow') {
+            if (options.standingAllowSubcommand === 'revoke') {
+                if (!options.fingerprint) {
+                    throw new Error('standing-allow revoke requires --fingerprint.');
+                }
+                const result = await revokeStandingAllow({
+                    targetDir: options.targetDir,
+                    fingerprint: options.fingerprint,
+                    kind: options.kind === 'tool' || options.kind === 'subagent' || options.kind === 'shell'
+                        ? options.kind
+                        : undefined,
+                });
+                process.stdout.write(`${result.message}\n`);
+                process.exitCode = result.ok ? 0 : 1;
+                return;
+            }
+            throw new Error('standing-allow requires subcommand: revoke');
+        }
         throw new Error(`Unknown command: ${command}`);
     }
     catch (error) {

package/dist/commands/approve.d.ts

@@ -7,6 +7,7 @@ export interface ApproveOptions {
     token?: string;
     scope?: ApproveScope;
     scopePath?: string;
+    replay?: boolean;
 }
 export declare function approvePending(options: ApproveOptions): Promise<{
     ok: boolean;

package/dist/commands/approve.js

@@ -1,6 +1,7 @@
 import path from 'node:path';
-import { approvedApprovalsPath, loadApprovalState, loadConfigFile, pendingApprovalsPath, saveApprovalState, } from '../config-io.js';
-import { recordApproval } from '../core/approval-service.js';
+import { loadApprovalState, loadConfigFile } from '../config-io.js';
+import { canAutoReplay, getExecutionLeaseMs, replayShellCommand } from '../core/approval-replay.js';
+import { consumeApprovedAfterCliReplay, createGateApprovalStore, recordApproval, } from '../core/approval-service.js';
 import { JUDGE_CLOUD_CONSENT_REASON } from '../core/capability/reasons.js';
 import { recordCapabilityApproval } from '../core/capability-approval.js';
 import { recordEgressApproval } from '../core/egress-approval.js';
@@ -32,11 +33,11 @@ export async function approvePending(options) {
         });
         return { ok: result.ok, message: result.message };
     }
-    if (options.scope === 'path') {
+    if (options.scope === 'path' || options.scope === 'workspace-root') {
         const result = await recordCapabilityApproval({
             approvalId: options.approvalId,
             config,
-            scope: 'path',
+            scope: options.scope,
             scopePath: options.scopePath,
             token: options.token,
             requireSignedToken: config.approvalSigning.required,
@@ -44,33 +45,51 @@ export async function approvePending(options) {
         });
         return { ok: result.ok, message: result.message };
     }
+    const approvalStore = createGateApprovalStore(repoRoot, config);
     const result = await recordApproval({
         approvalId: options.approvalId,
         config,
         token: options.token,
         requireSignedToken: config.approvalSigning.required,
-        store: {
-            async loadPending() {
-                const filePath = pendingApprovalsPath(repoRoot, config);
-                return {
-                    filePath,
-                    state: await loadApprovalState(repoRoot, 'pending-approvals.json', config),
-                };
-            },
-            async loadApproved() {
-                const filePath = approvedApprovalsPath(repoRoot, config);
-                return {
-                    filePath,
-                    state: await loadApprovalState(repoRoot, 'approved-approvals.json', config),
-                };
-            },
-            async writePending(_filePath, state) {
-                await saveApprovalState(repoRoot, 'pending-approvals.json', state, config);
-            },
-            async writeApproved(_filePath, state) {
-                await saveApprovalState(repoRoot, 'approved-approvals.json', state, config);
-            },
-        },
+        store: approvalStore,
     });
+    if (!result.ok) {
+        return { ok: result.ok, message: result.message };
+    }
+    if (options.replay) {
+        const approval = result.approval;
+        if (!approval) {
+            return { ok: false, message: 'Approval recorded but replay envelope is missing.' };
+        }
+        if (!canAutoReplay(config, approval.kind)) {
+            return {
+                ok: false,
+                message: 'Replay is not enabled for this approval kind. Retry the original action manually or enable approval.autoReplayScopes.',
+            };
+        }
+        if (approval.kind !== 'shell' || !approval.input) {
+            return {
+                ok: false,
+                message: 'CLI replay is only supported for shell approvals. Retry the original tool or subagent action manually.',
+            };
+        }
+        const replayResult = await replayShellCommand(approval.input, approval.cwd ?? repoRoot, getExecutionLeaseMs(config));
+        const output = [replayResult.stdout, replayResult.stderr].filter(Boolean).join('\n').trim();
+        if (replayResult.exitCode === 0) {
+            await consumeApprovedAfterCliReplay({
+                approvalId: options.approvalId,
+                store: approvalStore,
+            });
+            return {
+                ok: true,
+                message: `Belay replay succeeded for ${options.approvalId}. Do not retry via hooks; the one-shot grant was consumed.${output ? `\n${output}` : ''}`,
+            };
+        }
+        const timeoutNote = replayResult.timedOut ? ' Replay timed out.' : '';
+        return {
+            ok: false,
+            message: `Belay replay failed for ${options.approvalId} (exit ${replayResult.exitCode}).${timeoutNote} Approval remains active for one hook retry.${output ? `\n${output}` : ''}`,
+        };
+    }
     return { ok: result.ok, message: result.message };
 }

package/dist/commands/config.js

@@ -8,11 +8,13 @@ import { clearJudgeCredentialStore, writeJudgeCredentialStore } from '../core/cr
 import { refreshIntegrityIfPinned } from '../core/integrity.js';
 import { defaultJudgeProviderForAdapter, hasValidCloudConsent, isCloudJudgeConfig, resolveJudgeUsePatch, } from '../core/judge-config.js';
 import { rejectDeprecatedJudgeModelAuto } from '../core/judge-model-policy.js';
+import { resolveJudgeTransport } from '../core/judge-runtime-detection.js';
 import { isJudgeProviderId, JUDGE_PROVIDER_IDS, normalizeLegacyProviderId, } from '../core/verdict/judge-catalog.js';
 import { initProject } from '../installer.js';
 import { isBelayFloorInstalled } from './health-snapshot.js';
 import { judgeStatus } from './judge.js';
 import { readKeyFromStdin } from './stdin-key.js';
+import { confirmPrompt, intro, isInteractiveTTY, selectPrompt } from './tui.js';
 export const BELAY_CONFIG_SUBCOMMANDS = [
     'list',
     'get',
@@ -106,7 +108,9 @@ function listJudgeFields(judge) {
     return entries;
 }
 function warnCloudConsentIfNeeded(judge) {
-    if (isCloudJudgeConfig(judge) && !hasValidCloudConsent(judge)) {
+    if (isCloudJudgeConfig(judge) &&
+        resolveJudgeTransport(judge) === 'http' &&
+        !hasValidCloudConsent(judge)) {
         process.stderr.write('Warning: Cloud judge saved without recorded consent. Tier1 cloud judge will fail closed until consent is granted (belay judge consent + belay approve, or TTY --accept-cloud-judge).\n');
     }
 }
@@ -285,46 +289,112 @@ export async function runBelayConfigCredential(options) {
     }
     throw new Error('credential requires action: mode, set, or clear.');
 }
-async function collectCloudJudgeWizardAnswers(ask, judgeProviderId) {
+function formatSelectPrompt(options) {
+    const values = options.choices.map((choice) => choice.value).join(' | ');
+    return `${options.message} [${values}] (${options.defaultValue}): `;
+}
+function formatConfirmPrompt(message, defaultValue) {
+    return `${message} [y | n] (${defaultValue ? 'y' : 'n'}): `;
+}
+function parseSelectAnswer(raw, options) {
+    const normalized = raw.trim().toLowerCase();
+    if (!normalized) {
+        return options.defaultValue;
+    }
+    const found = options.choices.find((choice) => {
+        if (choice.value.toLowerCase() === normalized) {
+            return true;
+        }
+        return choice.label?.trim().toLowerCase() === normalized;
+    });
+    if (!found) {
+        throw new Error(`Invalid choice for ${options.message}: ${raw}`);
+    }
+    return found.value;
+}
+async function askTextLazy(message) {
+    const rl = readline.createInterface({ input, output });
+    try {
+        return (await rl.question(message)).trimEnd();
+    }
+    finally {
+        rl.close();
+    }
+}
+function createTestPrompter(prompts) {
+    let index = 0;
+    const nextPrompt = (message) => {
+        if (index >= prompts.length) {
+            throw new Error(`unexpected config prompt: ${message}`);
+        }
+        return prompts[index++];
+    };
+    return {
+        askText: async (message) => nextPrompt(message),
+        askSelect: async (options, parseRaw) => {
+            const raw = nextPrompt(formatSelectPrompt(options));
+            return parseRaw ? parseRaw(raw, options) : parseSelectAnswer(raw, options);
+        },
+        askConfirm: async (message, defaultValue) => parseYesNo(nextPrompt(formatConfirmPrompt(message, defaultValue)), defaultValue),
+    };
+}
+function createReadlinePrompter() {
+    return {
+        askText: askTextLazy,
+        askSelect: async (options, parseRaw) => {
+            const raw = await askTextLazy(formatSelectPrompt(options));
+            return parseRaw ? parseRaw(raw, options) : parseSelectAnswer(raw, options);
+        },
+        askConfirm: async (message, defaultValue) => parseYesNo(await askTextLazy(formatConfirmPrompt(message, defaultValue)), defaultValue),
+    };
+}
+function createTuiPrompter() {
+    return {
+        askText: askTextLazy,
+        askSelect: selectPrompt,
+        askConfirm: confirmPrompt,
+    };
+}
+async function withConfigWizardPrompter(options, fn) {
+    if (options.prompts) {
+        return fn(createTestPrompter(options.prompts));
+    }
+    if (isInteractiveTTY()) {
+        return fn(createTuiPrompter());
+    }
+    return fn(createReadlinePrompter());
+}
+function writeConfigWizardBanner(options, title) {
+    if (options.skipBanner) {
+        return;
+    }
+    if (isInteractiveTTY()) {
+        intro(title);
+        return;
+    }
+    output.write(`${title}\n`);
+}
+async function collectCloudJudgeWizardAnswers(prompter, judgeProviderId) {
     if (judgeProviderId === 'ollama') {
         return { acceptCloud: false };
     }
-    const judgeCredentialMode = parseYesNo(await ask('Use project env for credentials? [y=project | n=apiKey] (y): '), true)
+    const judgeCredentialMode = (await prompter.askConfirm('Use project env for credentials?', true))
         ? 'project'
         : 'apiKey';
-    const optionalEndpoint = (await ask('Judge endpoint URL (optional): ')).trim();
+    const optionalEndpoint = (await prompter.askText('Judge endpoint URL (optional): ')).trim();
     const judgeEndpoint = optionalEndpoint || undefined;
     if (judgeCredentialMode === 'apiKey') {
-        const key = await ask('Paste API key (hidden input not available in all shells): ');
+        const key = await prompter.askText('Paste API key (hidden input not available in all shells): ');
         if (key.trim()) {
             process.env.BELAY_CONFIG_WIZARD_JUDGE_KEY = key.trim();
         }
     }
     let acceptCloud = false;
     if (judgeEndpoint) {
-        acceptCloud = parseYesNo(await ask('Accept cloud judge egress (redacted commands leave the repo)? [y | n] (n): '), false);
+        acceptCloud = await prompter.askConfirm('Accept cloud judge egress (redacted commands leave the repo)?', false);
     }
     return { judgeCredentialMode, judgeEndpoint, acceptCloud };
 }
-async function withConfigPrompter(fn, prompts) {
-    if (prompts) {
-        let index = 0;
-        const ask = async (message) => {
-            if (index >= prompts.length) {
-                throw new Error(`unexpected config prompt: ${message}`);
-            }
-            return prompts[index++];
-        };
-        return fn(ask);
-    }
-    const rl = readline.createInterface({ input, output });
-    try {
-        return await fn((message) => rl.question(message));
-    }
-    finally {
-        rl.close();
-    }
-}
 export async function resolveBelayConfigInteractiveMode(repoRoot) {
     try {
         return (await isBelayFloorInstalled({ targetDir: repoRoot })) ? 'judge-only' : 'full';
@@ -333,16 +403,26 @@ export async function resolveBelayConfigInteractiveMode(repoRoot) {
         return 'full';
     }
 }
-async function runBelayConfigFullWithPrompter(ask, options) {
-    if (!options.skipBanner) {
-        output.write('belay config\n');
-    }
-    const adapter = parseAdapter(await ask('Adapter [cursor | claude | codex] (cursor): '));
-    const scope = parseScope(await ask('Install scope [project | global] (project): '));
-    const withSkill = parseYesNo(await ask('Install SKILL.md and slash commands? [y | n] (y): '), true);
+async function runBelayConfigFullWithWizard(prompter, options) {
+    writeConfigWizardBanner(options, 'belay config');
+    const adapter = await prompter.askSelect({
+        message: 'Adapter',
+        defaultValue: 'cursor',
+        choices: [{ value: 'cursor' }, { value: 'claude' }, { value: 'codex' }],
+    });
+    const scope = await prompter.askSelect({
+        message: 'Install scope',
+        defaultValue: 'project',
+        choices: [{ value: 'project' }, { value: 'global' }],
+    });
+    const withSkill = await prompter.askConfirm('Install SKILL.md and slash commands?', true);
     const defaultJudgeProviderId = defaultJudgeProviderForAdapter(adapter);
-    const judgeProviderId = parseJudgeProviderId(await ask(`Judge provider [${JUDGE_PROVIDER_IDS.join(' | ')}] (${defaultJudgeProviderId}): `), defaultJudgeProviderId);
-    const { judgeCredentialMode, judgeEndpoint, acceptCloud } = await collectCloudJudgeWizardAnswers(ask, judgeProviderId);
+    const judgeProviderId = await prompter.askSelect({
+        message: 'Judge provider',
+        defaultValue: defaultJudgeProviderId,
+        choices: JUDGE_PROVIDER_IDS.map((providerId) => ({ value: providerId })),
+    }, (raw, selectOptions) => parseJudgeProviderId(raw, selectOptions.defaultValue));
+    const { judgeCredentialMode, judgeEndpoint, acceptCloud } = await collectCloudJudgeWizardAnswers(prompter, judgeProviderId);
     const initOptions = buildInitOptionsFromConfigAnswers({
         adapter,
         scope,
@@ -362,19 +442,22 @@ async function runBelayConfigFullWithPrompter(ask, options) {
     }
     return result;
 }
-async function runBelayConfigJudgeOnlyWithPrompter(ask, options, repoRoot, config, adapter) {
-    if (!options.skipBanner) {
-        output.write('belay config (judge only)\n');
-    }
+async function runBelayConfigJudgeOnlyWithWizard(prompter, options, repoRoot, config, adapter) {
+    writeConfigWizardBanner(options, 'belay config (judge only)');
     const defaultJudgeProviderId = defaultJudgeProviderForAdapter(adapter);
-    const judgeProviderId = parseJudgeProviderId(await ask(`Judge provider [${JUDGE_PROVIDER_IDS.join(' | ')}] (${defaultJudgeProviderId}): `), defaultJudgeProviderId);
-    const { judgeCredentialMode, judgeEndpoint, acceptCloud } = await collectCloudJudgeWizardAnswers(ask, judgeProviderId);
+    const judgeProviderId = await prompter.askSelect({
+        message: 'Judge provider',
+        defaultValue: defaultJudgeProviderId,
+        choices: JUDGE_PROVIDER_IDS.map((providerId) => ({ value: providerId })),
+    }, (raw, selectOptions) => parseJudgeProviderId(raw, selectOptions.defaultValue));
+    const { judgeCredentialMode, judgeEndpoint, acceptCloud } = await collectCloudJudgeWizardAnswers(prompter, judgeProviderId);
     const patch = resolveJudgeUsePatch(config.judge, {
         providerId: judgeProviderId,
         endpoint: judgeEndpoint,
         credentialMode: judgeCredentialMode,
         acceptCloud: acceptCloud && Boolean(judgeEndpoint),
-        interactiveTTY: true,
+        // `prompts` is a scripted stand-in for interactive responses in tests.
+        interactiveTTY: isInteractiveTTY() || Boolean(options.prompts),
         interactiveConsentApproved: acceptCloud && Boolean(judgeEndpoint),
     });
     if (patch.errors.length > 0) {
@@ -399,13 +482,13 @@ async function runBelayConfigJudgeOnlyWithPrompter(ask, options, repoRoot, confi
     return { repoRoot, adapter };
 }
 export async function runBelayConfigFullInteractive(options = {}) {
-    return withConfigPrompter((ask) => runBelayConfigFullWithPrompter(ask, options), options.prompts);
+    return withConfigWizardPrompter(options, (prompter) => runBelayConfigFullWithWizard(prompter, options));
 }
 export async function runBelayConfigJudgeOnlyInteractive(options = {}) {
     const repoRoot = path.resolve(options.targetDir ?? process.cwd());
     const config = await loadConfigFile(repoRoot);
     const adapter = resolveAdapterName(config);
-    return withConfigPrompter((ask) => runBelayConfigJudgeOnlyWithPrompter(ask, options, repoRoot, config, adapter), options.prompts);
+    return withConfigWizardPrompter(options, (prompter) => runBelayConfigJudgeOnlyWithWizard(prompter, options, repoRoot, config, adapter));
 }
 export async function runBelayConfigInteractive(options = {}) {
     const repoRoot = path.resolve(options.targetDir ?? process.cwd());
@@ -427,16 +510,16 @@ export async function runBelayConfigInteractive(options = {}) {
                 skipBanner: true,
             });
         }
-        return withConfigPrompter(async (ask) => {
-            output.write('belay config\n');
-            const judgeOnly = parseYesNo(await ask('Configure judge only? [Y/n]: '), true);
-            if (judgeOnly) {
-                const config = await loadConfigFile(repoRoot);
-                const adapter = resolveAdapterName(config);
-                return runBelayConfigJudgeOnlyWithPrompter(ask, { ...options, skipBanner: true }, repoRoot, config, adapter);
+        return withConfigWizardPrompter(options, async (prompter) => {
+            writeConfigWizardBanner(options, 'belay config');
+            const judgeOnly = await prompter.askConfirm('Configure judge only?', true);
+            if (!judgeOnly) {
+                return runBelayConfigFullWithWizard(prompter, { ...options, skipBanner: true });
             }
-            return runBelayConfigFullWithPrompter(ask, { ...options, skipBanner: true });
-        }, options.prompts);
+            const config = await loadConfigFile(repoRoot);
+            const adapter = resolveAdapterName(config);
+            return runBelayConfigJudgeOnlyWithWizard(prompter, { ...options, skipBanner: true }, repoRoot, config, adapter);
+        });
     }
     return runBelayConfigFullInteractive(options);
 }

package/dist/commands/doctor.js

@@ -10,7 +10,7 @@ import { approvedApprovalsPath, belayStateDir, detectAdapterName, loadLayeredCon
 import { detectFenceDrift, summarizeAuditVisibility } from '../core/audit-summary.js';
 import { defaultControlPlaneDir } from '../core/config.js';
 import { verifyIntegrityManifest } from '../core/integrity.js';
-import { diagnoseJudge } from '../core/judge-doctor.js';
+import { diagnoseJudge, stopJudgeSessionBrokers } from '../core/judge-doctor.js';
 import { getManagedHookEntries } from '../defaults.js';
 import { resolveNodeBinary } from '../node-resolution.js';
 import { egressStatus } from '../services/egress-service.js';
@@ -239,6 +239,16 @@ export async function doctorProject(options = {}) {
         else {
             notes.push('No orphan approval cleanup actions were needed.');
         }
+        const judgeStateDir = belayStateDir(loadedConfig, repoLocalDir);
+        if (options.dryRun !== true) {
+            const stoppedBrokers = await stopJudgeSessionBrokers(repoRoot, judgeStateDir);
+            if (stoppedBrokers > 0) {
+                notes.push(`Stopped judge session broker artifacts for ${repoRoot}.`);
+            }
+        }
+        else {
+            notes.push('Dry run: would stop judge session broker and clear kill switch if present.');
+        }
     }
     let dogfood = null;
     if (loadedConfig) {