@guilz-dev/belay 0.1.1 → 0.3.0

package/dist/core/{v2 → verdict}/verdict.js

@@ -1,10 +1,9 @@
-import path from 'node:path';
-import { relativeWithinRepo } from '../path-utils.js';
+import { resolveMutationTarget } from '../path-utils.js';
 import { extractRedirectTargets, tokenizeShell } from '../shell-tokenizer.js';
-import { analyzePathTargets, cwdRelative, resolveTrustedPath } from './containment.js';
+import { analyzePathTargets, cwdRelative, isDestructiveHighStakesMutation, resolveTrustedPath, touchesProtectedRoot, } from './containment.js';
 import { classifyEgressTool } from './egress-classify.js';
 import { verdictFingerprint } from './fingerprint.js';
-import { prescanInterpreterCode, tier1RequiresAsk } from './judge.js';
+import { mutationPrescanRequiresAsk, prescanInterpreterCode, tier1RequiresAsk } from './judge.js';
 import { isRoutineLauncher, resolveLauncherRecipe } from './launcher-resolve.js';
 import { allowFromCustomOverride, askFromCustomExternal, customAllowMatch, customExternalMatch, } from './overrides.js';
 import { extractRecursiveScript, isBareInterpreter, isVariableIndirectHead, parseSegment, peelTransparentWrappers, redactCommand, segmentOpacity, splitTopLevelSegments, substitutionInners, } from './parser.js';
@@ -91,6 +90,7 @@ const LOCAL_ROUTINE_HEADS = new Set([
     'make',
     'cmake',
 ]);
+const BELAY_SELF_COMMANDS = new Set(['approve', 'revoke']);
 const FIND_DANGEROUS_FLAGS = new Set(['-delete', '-exec', '-execdir', '-ok', '-okdir']);
 function isFindDangerous(tokens) {
     return tokens.some((token) => FIND_DANGEROUS_FLAGS.has(token) || token.startsWith('-exec') || token.startsWith('-ok'));
@@ -256,8 +256,45 @@ function tier0ExternalMatch(key, head, tokens) {
     }
     return false;
 }
-function tier0HighStakesRm(tokens, context) {
+function isBelayJudgeSelfCommand(tokens) {
+    return (tokens[0] === 'belay' &&
+        tokens[1] === 'judge' &&
+        (tokens[2] === 'use' ||
+            tokens[2] === 'status' ||
+            tokens[2] === 'list' ||
+            tokens[2] === 'test' ||
+            tokens[2] === 'consent'));
+}
+function isBelayConfigSelfCommand(tokens) {
+    if (tokens[0] !== 'belay' || tokens[1] !== 'config') {
+        return false;
+    }
+    const sub = tokens[2];
+    if (!sub) {
+        return true;
+    }
+    if (sub === 'list' || sub === 'get' || sub === 'judge') {
+        return true;
+    }
+    if (sub === 'credential') {
+        return true;
+    }
+    if (sub === 'set' || sub === 'unset') {
+        const pathKey = tokens[3] ?? '';
+        return pathKey.startsWith('judge.');
+    }
+    return false;
+}
+function isBelaySelfCommand(tokens) {
     const head = tokens[0] ?? '';
+    const subcommand = tokens[1] ?? '';
+    return (head === 'belay' &&
+        (BELAY_SELF_COMMANDS.has(subcommand) ||
+            isBelayJudgeSelfCommand(tokens) ||
+            isBelayConfigSelfCommand(tokens)));
+}
+function tier0HighStakesRm(tokens, context) {
+    const head = (tokens[0] ?? '').split('/').pop() ?? '';
     if (head !== 'rm') {
         return null;
     }
@@ -280,31 +317,40 @@ function tier0HighStakesRm(tokens, context) {
             signals: ['missing_trusted_cwd', ...analysis.signals],
         });
     }
-    if (analysis.isHighStakes) {
-        return askVerdict({
-            location: analysis.location,
-            opacity: 'transparent',
-            effect: 'local_mutation',
-            confidence: 'deterministic',
-            reason: 'high_stakes_path',
-            signals: ['high_stakes_path', ...analysis.signals],
-        });
-    }
     for (const target of targets) {
-        if (target === '~' || target.startsWith('~/') || target.startsWith('/')) {
-            const resolved = path.resolve(target === '~' || target.startsWith('~/') ? (process.env.HOME ?? '/') : context.cwd, target);
-            const relative = relativeWithinRepo(context.repoRoot, resolved);
-            if (relative === null) {
-                return askVerdict({
-                    location: 'repo_outside',
-                    opacity: 'transparent',
-                    effect: 'local_mutation',
-                    confidence: 'deterministic',
-                    reason: 'repo_outside_mutation',
-                    signals: ['repo_outside_mutation'],
-                });
+        const normalized = target.replace(/^['"]|['"]$/g, '');
+        if (normalized === '~' || normalized === '$HOME' || normalized.startsWith('~/')) {
+            return askVerdict({
+                location: 'repo_outside',
+                opacity: 'transparent',
+                effect: 'local_mutation',
+                confidence: 'deterministic',
+                reason: 'high_stakes_path',
+                signals: ['catastrophic_home_deletion', ...analysis.signals],
+            });
+        }
+    }
+    if (analysis.isHighStakes && analysis.signals.includes('high_stakes_path')) {
+        let destructiveHighStakes = false;
+        for (const target of targets) {
+            const resolved = resolveTrustedPath(target, context.cwd, context.trustedCwd) ??
+                resolveMutationTarget(target, context.cwd);
+            if (resolved &&
+                isDestructiveHighStakesMutation(head, resolved, context.repoRoot, context.sensitivePaths, context.protectedArtifactRoots)) {
+                destructiveHighStakes = true;
+                break;
             }
         }
+        if (destructiveHighStakes) {
+            return askVerdict({
+                location: analysis.location,
+                opacity: 'transparent',
+                effect: 'local_mutation',
+                confidence: 'deterministic',
+                reason: 'high_stakes_path',
+                signals: ['high_stakes_path', ...analysis.signals],
+            });
+        }
     }
     return null;
 }
@@ -488,6 +534,16 @@ async function evaluateSegment(command, context, depth) {
     if (rmVerdict) {
         return rmVerdict;
     }
+    if (isBelaySelfCommand(peeled)) {
+        return allowVerdict({
+            location: 'unknown',
+            opacity: 'transparent',
+            effect: 'local_mutation',
+            confidence: 'deterministic',
+            reason: 'belay_control_plane_command',
+            signals: ['belay_control_plane_command', segment.head],
+        });
+    }
     let effect = 'unknown';
     if (READ_ONLY_KEYS.has(segment.key) || READ_ONLY_KEYS.has(segment.head)) {
         effect = 'read_only';
@@ -499,6 +555,9 @@ async function evaluateSegment(command, context, depth) {
         effect = 'local_mutation';
     }
     const pathArgs = extractPathArgs(peeled);
+    if (extractRedirectTargets(peeled).length > 0 && effect === 'read_only') {
+        effect = 'local_mutation';
+    }
     const pathAnalysis = analyzePathTargets({
         targets: pathArgs,
         cwd: context.cwd,
@@ -529,15 +588,45 @@ async function evaluateSegment(command, context, depth) {
             });
         }
     }
-    if (pathAnalysis.isHighStakes) {
-        return askVerdict({
-            location: pathAnalysis.location,
-            opacity: 'transparent',
-            effect: 'local_mutation',
-            confidence: 'deterministic',
-            reason: 'high_stakes_path',
-            signals: pathAnalysis.signals,
-        });
+    if ((effect === 'local_mutation' || effect === 'unknown') &&
+        context.protectedArtifactRoots &&
+        context.protectedArtifactRoots.length > 0) {
+        for (const target of pathArgs) {
+            const resolved = resolveTrustedPath(target, context.cwd, context.trustedCwd) ??
+                resolveMutationTarget(target, context.cwd);
+            if (resolved && touchesProtectedRoot(resolved, context.protectedArtifactRoots)) {
+                return askVerdict({
+                    location: pathAnalysis.location,
+                    opacity: 'transparent',
+                    effect: 'local_mutation',
+                    confidence: 'deterministic',
+                    reason: 'high_stakes_path',
+                    signals: ['high_stakes_path', 'control_plane_path'],
+                });
+            }
+        }
+    }
+    if (effect === 'local_mutation' || effect === 'unknown') {
+        let destructiveHighStakes = false;
+        for (const target of pathArgs) {
+            const resolved = resolveTrustedPath(target, context.cwd, context.trustedCwd) ??
+                resolveMutationTarget(target, context.cwd);
+            if (resolved &&
+                isDestructiveHighStakesMutation(segment.head, resolved, context.repoRoot, context.sensitivePaths, context.protectedArtifactRoots)) {
+                destructiveHighStakes = true;
+                break;
+            }
+        }
+        if (destructiveHighStakes) {
+            return askVerdict({
+                location: pathAnalysis.location,
+                opacity: 'transparent',
+                effect: 'local_mutation',
+                confidence: 'deterministic',
+                reason: 'high_stakes_path',
+                signals: pathAnalysis.signals,
+            });
+        }
     }
     if (segment.head === 'find' && isFindDangerous(peeled)) {
         return askVerdict({
@@ -549,15 +638,15 @@ async function evaluateSegment(command, context, depth) {
             signals: ['find_dangerous_action'],
         });
     }
-    if (pathAnalysis.location === 'repo_outside' || pathAnalysis.location === 'mixed') {
-        const outsideEffect = effect === 'read_only' ? 'read_only' : effect === 'unknown' ? 'local_mutation' : effect;
-        return askVerdict({
+    if (effect === 'read_only' &&
+        (pathAnalysis.location === 'repo_outside' || pathAnalysis.location === 'mixed')) {
+        return allowVerdict({
             location: pathAnalysis.location,
-            opacity: 'transparent',
-            effect: outsideEffect,
+            opacity,
+            effect: 'read_only',
             confidence: 'deterministic',
-            reason: 'repo_outside_mutation',
-            signals: ['repo_outside_mutation', ...pathAnalysis.signals],
+            reason: 'read_only',
+            signals: ['read_only', ...pathAnalysis.signals],
         });
     }
     if (pathAnalysis.location === 'unknown' &&
@@ -572,7 +661,34 @@ async function evaluateSegment(command, context, depth) {
             signals: ['unknown_location_mutation'],
         });
     }
-    const needsTier1 = effect === 'unknown' || TIER0_EXTERNAL_HEADS.has(segment.head) || egressClass === 'ambiguous';
+    const outsideMutation = pathAnalysis.location === 'repo_outside' || pathAnalysis.location === 'mixed';
+    const mutationPrescan = (effect === 'local_mutation' || effect === 'unknown') && pathArgs.length > 0
+        ? mutationPrescanRequiresAsk({
+            targets: pathArgs,
+            cwd: context.cwd,
+            repoRoot: context.repoRoot,
+            trustedCwd: context.trustedCwd,
+            sensitivePaths: context.sensitivePaths,
+        })
+        : null;
+    if (mutationPrescan) {
+        return askVerdict({
+            location: pathAnalysis.location === 'unknown'
+                ? 'unknown'
+                : pathAnalysis.location === 'repo_outside' || pathAnalysis.location === 'mixed'
+                    ? pathAnalysis.location
+                    : 'repo_local',
+            opacity,
+            effect: 'local_mutation',
+            confidence: 'deterministic',
+            reason: 'tier1_catastrophic',
+            signals: ['tier1_catastrophic', mutationPrescan.reason],
+        });
+    }
+    const needsTier1 = effect === 'unknown' ||
+        TIER0_EXTERNAL_HEADS.has(segment.head) ||
+        egressClass === 'ambiguous' ||
+        (outsideMutation && effect !== 'read_only');
     let tier1Trace;
     if (needsTier1) {
         const tier1Text = recursiveScript ?? command;
@@ -584,9 +700,13 @@ async function evaluateSegment(command, context, depth) {
         tier1Trace = context.judge.lastTrace;
         if (tier1RequiresAsk(tier1)) {
             return askVerdict({
-                location: pathAnalysis.location === 'unknown' ? 'unknown' : 'repo_local',
+                location: pathAnalysis.location === 'unknown'
+                    ? 'unknown'
+                    : pathAnalysis.location === 'repo_outside' || pathAnalysis.location === 'mixed'
+                        ? pathAnalysis.location
+                        : 'repo_local',
                 opacity,
-                effect: tier1.external_change ? 'remote_mutation' : effect,
+                effect: !tier1.local_recoverable ? 'remote_mutation' : effect,
                 confidence: 'llm',
                 reason: 'tier1_catastrophic',
                 signals: ['tier1_catastrophic', tier1.reason],
@@ -594,6 +714,16 @@ async function evaluateSegment(command, context, depth) {
             });
         }
     }
+    if (outsideMutation && effect !== 'read_only') {
+        return withJudgeTrace(allowVerdict({
+            location: pathAnalysis.location,
+            opacity,
+            effect: 'local_mutation',
+            confidence: tier1Trace ? 'llm' : 'deterministic',
+            reason: 'repo_outside_local_mutation',
+            signals: ['repo_outside_local_mutation', ...pathAnalysis.signals],
+        }), tier1Trace);
+    }
     if (pathAnalysis.location === 'repo_local' &&
         (effect === 'read_only' || effect === 'local_mutation') &&
         opacity !== 'opaque') {

package/dist/corpus/evaluate.js

@@ -2,8 +2,8 @@ import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { classifierOptionsFromConfig, DEFAULT_CONFIG_V3 } from '../core/config.js';
-import { classifyShell } from '../core/v2/adapter.js';
-import { createDeterministicJudgeStub } from '../core/v2/judge.js';
+import { classifyShell } from '../core/verdict/adapter.js';
+import { createDeterministicJudgeStub } from '../core/verdict/judge.js';
 export function assessmentsDiverge(predicted, observed) {
     return (predicted.reversibility !== observed.reversibility ||
         predicted.external !== observed.external ||

package/dist/installer.js

@@ -7,9 +7,10 @@ import { resolveScopedPaths } from './adapters/layouts/scope.js';
 import { getAdapter } from './adapters/registry.js';
 import { dogfoodProject } from './commands/dogfood.js';
 import { detectAdapterName, loadConfigFile, mergeAndWriteConfig, writeConfigFile, } from './config-io.js';
-import { isFreshConfigInput, mergeConfig, normalizeConfig } from './core/config.js';
+import { appendCliAuditEvent } from './core/audit-io.js';
+import { isFreshConfigInput, mergeConfig, normalizeConfig, } from './core/config.js';
 import { runtimeIntegrityFiles, writeIntegrityManifest } from './core/integrity.js';
-import { resolveInitJudgeConfig } from './core/judge-config.js';
+import { hasValidCloudConsent, isCloudJudgeConfig, migrateImplicitLocalJudgeIfNeeded, resolveInitJudgeConfig, } from './core/judge-config.js';
 import { bootstrapStateFiles, writeSkillArtifacts } from './installer/bootstrap.js';
 import { writeRuntimeArtifacts } from './installer/runtime-artifacts.js';
 import { applyInstallScope, resolveOperationScope } from './installer/scope-config.js';
@@ -104,31 +105,62 @@ function resolveAdapterName(options, repoRoot) {
     }
     return 'cursor';
 }
-async function applyInitJudgeConfig(repoRoot, adapterName, options) {
-    if (options.skipJudgeWrite) {
+async function auditJudgeMigrationIfNeeded(repoRoot, adapterName, before, after, by) {
+    if (before.providerId === after.providerId && before.provider === after.provider) {
         return;
     }
-    const layout = getAdapter(adapterName).layout;
-    const configPath = layout.configPath(repoRoot);
-    let existingConfig = {};
-    if (await pathExists(configPath)) {
-        existingConfig = JSON.parse(await readFile(configPath, 'utf8'));
+    const config = await loadConfigFile(repoRoot, adapterName);
+    await appendCliAuditEvent(repoRoot, config, {
+        event: 'judge_provider_changed',
+        from: { providerId: before.providerId, provider: before.provider },
+        to: { providerId: after.providerId, provider: after.provider },
+        by,
+    });
+}
+async function applyInitJudgeConfig(repoRoot, adapterName, options, isFreshBeforeInstall) {
+    if (options.skipJudgeWrite) {
+        return;
     }
-    const isFresh = isFreshConfigInput(existingConfig);
     const mergedConfig = await loadConfigFile(repoRoot, adapterName);
-    const hasExplicitJudgeFlags = options.judgeProfile || options.judgeProvider || options.judgeModel || options.judgeEndpoint;
+    const hasExplicitJudgeFlags = options.judgeProfile ||
+        options.judgeProvider ||
+        options.judgeProviderId ||
+        options.judgeModel ||
+        options.judgeEndpoint;
     const judge = resolveInitJudgeConfig({
-        isFresh,
+        isFresh: isFreshBeforeInstall,
         hasExplicitJudgeFlags: Boolean(hasExplicitJudgeFlags),
         judgeProfile: options.judgeProfile,
         judgeProvider: options.judgeProvider,
+        judgeProviderId: options.judgeProviderId,
         judgeModel: options.judgeModel,
         judgeEndpoint: options.judgeEndpoint,
         acceptCloudJudge: options.acceptCloudJudge,
+        interactiveConsent: Boolean(options.acceptCloudJudge && process.stdin.isTTY),
+        cloudConsentApprovalId: options.cloudConsentApprovalId,
         existingJudge: mergedConfig.judge,
+        adapter: adapterName,
     });
-    const configWithJudge = normalizeConfig({ ...mergedConfig, version: 4, judge });
+    const migrated = options.migrateJudgeDefault === true
+        ? migrateImplicitLocalJudgeIfNeeded(mergedConfig.judge, adapterName)
+        : null;
+    let finalJudge = migrated ?? judge;
+    if (options.judgeCredentialMode) {
+        finalJudge = {
+            ...finalJudge,
+            credential: options.judgeCredentialMode === 'apiKey'
+                ? { mode: 'apiKey', ref: 'store:judge' }
+                : { mode: 'project' },
+        };
+    }
+    const configWithJudge = normalizeConfig({ ...mergedConfig, version: 4, judge: finalJudge });
+    if (isCloudJudgeConfig(configWithJudge.judge) && !hasValidCloudConsent(configWithJudge.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');
+    }
     await writeConfigFile(repoRoot, configWithJudge, adapterName);
+    if (migrated) {
+        await auditJudgeMigrationIfNeeded(repoRoot, adapterName, mergedConfig.judge, finalJudge, options.migrateJudgeDefault ? 'belay init --migrate-judge-default' : 'belay init');
+    }
 }
 async function refreshIntegrityManifest(repoRoot, adapterName) {
     const layout = getAdapter(adapterName).layout;
@@ -141,8 +173,19 @@ export async function initProject(options = {}) {
     const repoRoot = path.resolve(options.targetDir ?? process.cwd());
     const adapterName = resolveAdapterName(options, repoRoot);
     const adapter = getAdapter(adapterName);
+    const configPath = adapter.layout.configPath(repoRoot);
+    let isFreshBeforeInstall = true;
+    if (await pathExists(configPath)) {
+        try {
+            const raw = await readFile(configPath, 'utf8');
+            isFreshBeforeInstall = isFreshConfigInput(JSON.parse(raw));
+        }
+        catch {
+            isFreshBeforeInstall = false;
+        }
+    }
     const result = await adapter.install(repoRoot, options);
-    await applyInitJudgeConfig(repoRoot, adapterName, options);
+    await applyInitJudgeConfig(repoRoot, adapterName, options, isFreshBeforeInstall);
     if (options.preset) {
         const existing = await loadConfigFile(repoRoot, adapterName);
         const presetConfig = mergeConfig(applyConfigPreset(options.preset));
@@ -164,6 +207,15 @@ export async function upgradeProject(options = {}) {
     const repoRoot = path.resolve(options.targetDir ?? process.cwd());
     const adapterName = resolveAdapterName(options, repoRoot);
     await getAdapter(adapterName).upgrade(repoRoot, options);
+    if (options.migrateJudgeDefault === true) {
+        const mergedConfig = await loadConfigFile(repoRoot, adapterName);
+        const migrated = migrateImplicitLocalJudgeIfNeeded(mergedConfig.judge, adapterName);
+        if (migrated) {
+            const configWithJudge = normalizeConfig({ ...mergedConfig, version: 4, judge: migrated });
+            await writeConfigFile(repoRoot, configWithJudge, adapterName);
+            await auditJudgeMigrationIfNeeded(repoRoot, adapterName, mergedConfig.judge, migrated, 'belay upgrade --migrate-judge-default');
+        }
+    }
     await refreshIntegrityManifest(repoRoot, adapterName);
     return { repoRoot, adapter: adapterName };
 }

package/dist/types.d.ts

@@ -20,20 +20,27 @@ export interface InitOptions {
     adapter?: AdapterName;
     scope?: InstallScope;
     preset?: import('./presets.js').ConfigPresetName;
-    judgeProfile?: 'local-ollama';
+    judgeProfile?: 'local-ollama' | 'cursor' | 'claude' | 'codex';
     judgeProvider?: 'ollama' | 'openai-compatible' | 'cursor';
+    judgeProviderId?: 'ollama' | 'codex' | 'claude' | 'cursor' | 'local' | 'openai';
     judgeModel?: string;
     judgeEndpoint?: string;
+    judgeCredentialMode?: 'project' | 'apiKey';
     /** Acknowledge cloud judge egress + redaction limits (R19). Required for openai-compatible provider. */
     acceptCloudJudge?: boolean;
+    cloudConsentApprovalId?: string;
     /** When true, skip writing judge config (used when user declines cloud consent). */
     skipJudgeWrite?: boolean;
+    /** Opt-in: migrate implicit factory-default ollama judge to host default provider. */
+    migrateJudgeDefault?: boolean;
 }
 export interface UpgradeOptions {
     targetDir?: string;
     withSkill?: boolean;
     adapter?: AdapterName;
     scope?: InstallScope;
+    /** Opt-in: migrate implicit factory-default ollama judge to host default provider. */
+    migrateJudgeDefault?: boolean;
 }
 export interface DoctorOptions {
     targetDir?: string;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const PACKAGE_VERSION = "0.1.1";
+export declare const PACKAGE_VERSION = "0.3.0";

package/dist/version.js

@@ -1,2 +1,2 @@
 // Generated by scripts/sync-version.mjs — do not edit.
-export const PACKAGE_VERSION = '0.1.1';
+export const PACKAGE_VERSION = '0.3.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@guilz-dev/belay",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "Belay-style approval and audit gating for agent runtimes.",
   "type": "module",
   "license": "MIT",
@@ -54,6 +54,7 @@
     "lint": "biome check src package.json README.md CHANGELOG.md CONTRIBUTING.md SECURITY.md tsconfig.json tsconfig.build.json vitest.config.ts scripts docs",
     "typecheck": "tsc --noEmit",
     "test": "pnpm build && vitest run",
+    "test:structural": "pnpm build && vitest run src/__tests__/verdict/structural-suite.test.ts",
     "test:stable": "pnpm build && vitest run && vitest run && vitest run",
     "corpus": "pnpm build && node scripts/corpus.mjs"
   },

package/skills/belay/SKILL.md

@@ -29,10 +29,10 @@ you to the CLI. It does not classify commands itself.
 
 ## Prerequisites
 
-Run `npx @guilz-dev/belay init` in the project root before relying on enforcement.
-If you only installed this skill via `npx skills add`, approval instructions are
-available, but the runtime gate is not installed yet. Run `belay doctor` to
-check whether hooks are present.
+`npx skills add` installs this skill only — the runtime gate is **not installed**
+until hooks are configured. Run `belay config` in the project root for interactive
+setup (or `npx @guilz-dev/belay init` for non-interactive install). Run
+`belay doctor` to check whether hooks are present.
 
 ## When belay blocks an action
 
@@ -48,16 +48,17 @@ For recovery advice after a block, use `/belay recover` or `belay recover`.
 
 ## Install or repair
 
-- Full install: `npx @guilz-dev/belay init --with-skill`
-- Interactive wizard: `npx @guilz-dev/belay init-wizard`
+- Interactive setup: `belay config`
+- Non-interactive install: `npx @guilz-dev/belay init --with-skill`
 - Health check: `belay doctor`
 
-Do not run init or doctor implicitly from this skill — only when the user asks.
+Do not run init, config, or doctor implicitly from this skill — only when the user asks.
 
 ## CLI mapping
 
 | User intent | Command |
 | --- | --- |
+| Set up or change judge settings | `belay config` |
 | Why was this blocked? | `belay explain --command "..."` |
 | Explain latest pending ask | `belay explain` |
 | Status / dogfood / audit visibility | `belay status` |

package/dist/commands/init-wizard.d.ts

@@ -1,16 +0,0 @@
-import type { AdapterName, InitOptions } from '../types.js';
-export interface WizardAnswers {
-    adapter: AdapterName;
-    scope: 'project' | 'global';
-    withSkill: boolean;
-    dogfood: boolean;
-}
-export declare function buildInitOptionsFromWizard(answers: WizardAnswers, targetDir?: string): InitOptions;
-export declare function runInitWizard(options?: {
-    targetDir?: string;
-}): Promise<{
-    repoRoot: string;
-    withSkill: boolean;
-    dogfood: boolean;
-    adapter: import("../adapters/layouts/types.js").AdapterName;
-}>;

package/dist/commands/init-wizard.js

@@ -1,50 +0,0 @@
-import { stdin as input, stdout as output } from 'node:process';
-import readline from 'node:readline/promises';
-import { initProject } from '../installer.js';
-function parseAdapter(value) {
-    const normalized = (value ?? 'cursor').trim().toLowerCase();
-    if (normalized === 'claude' || normalized === 'codex' || normalized === 'cursor') {
-        return normalized;
-    }
-    throw new Error(`Unknown adapter: ${value ?? '(empty)'}`);
-}
-function parseScope(value) {
-    const normalized = (value ?? 'project').trim().toLowerCase();
-    if (normalized === 'global' || normalized === 'project') {
-        return normalized;
-    }
-    throw new Error(`Unknown scope: ${value ?? '(empty)'}`);
-}
-function parseYesNo(value, defaultValue) {
-    const normalized = (value ?? (defaultValue ? 'y' : 'n')).trim().toLowerCase();
-    if (['y', 'yes', 'true', '1'].includes(normalized)) {
-        return true;
-    }
-    if (['n', 'no', 'false', '0'].includes(normalized)) {
-        return false;
-    }
-    return defaultValue;
-}
-export function buildInitOptionsFromWizard(answers, targetDir) {
-    return {
-        targetDir,
-        adapter: answers.adapter,
-        scope: answers.scope,
-        withSkill: answers.withSkill,
-        dogfood: answers.dogfood,
-    };
-}
-export async function runInitWizard(options = {}) {
-    const rl = readline.createInterface({ input, output });
-    try {
-        output.write('belay init wizard\n');
-        const adapter = parseAdapter(await rl.question('Adapter (cursor/claude/codex) [cursor]: '));
-        const scope = parseScope(await rl.question('Install scope (project/global) [project]: '));
-        const withSkill = parseYesNo(await rl.question('Install SKILL.md and slash commands? (y/n) [y]: '), true);
-        const dogfood = parseYesNo(await rl.question('Start in audit dogfood mode? (y/n) [n]: '), false);
-        return initProject(buildInitOptionsFromWizard({ adapter, scope, withSkill, dogfood }, options.targetDir));
-    }
-    finally {
-        rl.close();
-    }
-}