@guilz-dev/belay 0.4.0 → 0.6.0

package/dist/cli.js

@@ -12,6 +12,7 @@ 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 { formatSessionStatusReport, sessionStartProject, sessionStatusProject, } from './commands/session.js';
 import { formatSimulateReport, simulateProject } from './commands/simulate.js';
 import { revokeStandingAllow } from './commands/standing-allow.js';
 import { formatStatusReport, statusProject } from './commands/status.js';
@@ -381,7 +382,13 @@ function parseArgs(argv) {
             return { command: 'help', options };
         }
         if (token === '--') {
-            options.explainCommand = rest.slice(index + 1).join(' ');
+            const remainder = rest.slice(index + 1).join(' ');
+            if (command === 'session' && options.sessionSubcommand === 'start') {
+                options.sessionAgentCommand = remainder;
+            }
+            else {
+                options.explainCommand = remainder;
+            }
             break;
         }
         if (command === 'audit' && !options.auditSubcommand) {
@@ -405,6 +412,13 @@ function parseArgs(argv) {
             }
             throw new Error('sandbox requires subcommand: status');
         }
+        if (command === 'session' && !options.sessionSubcommand) {
+            if (token === 'start' || token === 'status') {
+                options.sessionSubcommand = token;
+                continue;
+            }
+            throw new Error('session requires subcommand: start or status');
+        }
         if (command === 'standing-allow' && !options.standingAllowSubcommand) {
             if (token === 'revoke') {
                 options.standingAllowSubcommand = token;
@@ -521,6 +535,8 @@ 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} session <start|status> [--target <dir>] [--json]
+  ${c} session start [--target <dir>] [-- <agent command>]
   ${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>]
@@ -907,6 +923,32 @@ async function main() {
             process.exitCode = report.issues.length > 0 && report.sandboxEnabled ? 1 : 0;
             return;
         }
+        if (command === 'session') {
+            if (!options.sessionSubcommand) {
+                throw new Error('session requires subcommand: start or status');
+            }
+            if (options.sessionSubcommand === 'start') {
+                const result = await sessionStartProject({
+                    targetDir: options.targetDir,
+                    agentCommand: options.sessionAgentCommand,
+                });
+                process.stdout.write(`${result.message}\n`);
+                process.exitCode = result.ok ? 0 : 1;
+                return;
+            }
+            const report = await sessionStatusProject({
+                targetDir: options.targetDir,
+                json: options.json,
+            });
+            if (options.json) {
+                process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+            }
+            else {
+                process.stdout.write(`${formatSessionStatusReport(report)}\n`);
+            }
+            process.exitCode = report.ok ? 0 : 1;
+            return;
+        }
         if (command === 'approve') {
             if (!options.approvalId) {
                 throw new Error('approve requires an approval ID.');

package/dist/commands/classify-for-report.js

@@ -36,7 +36,7 @@ export async function classifyForReport(params) {
         if (!params.command && !params.payload) {
             throw new Error('classify-for-report requires command or payload for subagent classification.');
         }
-        result = classifySubagent(payload, repoRoot, classifierOptions);
+        result = classifySubagent(payload, repoRoot, classifierOptions, config);
         input = params.command ?? JSON.stringify(payload);
     }
     else if (kind === 'tool') {

package/dist/commands/config.d.ts

@@ -1,5 +1,6 @@
 import { type JudgeProviderId } from '../core/verdict/judge-catalog.js';
 import type { AdapterName, InitOptions } from '../types.js';
+import { type SelectOptions } from './tui.js';
 export declare const BELAY_CONFIG_SUBCOMMANDS: readonly ["list", "get", "set", "unset", "credential", "judge"];
 export type BelayConfigSubcommand = (typeof BELAY_CONFIG_SUBCOMMANDS)[number];
 export interface BelayConfigOptions {
@@ -39,6 +40,13 @@ export interface BelayConfigInteractiveOptions {
     /** Suppress the interactive header when nested under runBelayConfigInteractive */
     skipBanner?: boolean;
 }
+export declare const JUDGE_CREDENTIAL_MODE_PROMPT = "Judge API key source";
+export declare const JUDGE_CREDENTIAL_STORE_KEY_PROMPT = "Paste API key to store locally (visible input; prefer belay config credential set --key-stdin): ";
+export declare const JUDGE_TRANSPORT_MODE_PROMPT = "How should Belay reach the judge?";
+export declare const JUDGE_HTTP_ENDPOINT_PROMPT = "Judge HTTP API URL:";
+export type JudgeTransportWizardMode = 'cli' | 'http';
+export declare function buildJudgeTransportSelectOptions(judgeProviderId: JudgeProviderId): SelectOptions<JudgeTransportWizardMode>;
+export declare function buildJudgeCredentialModeSelectOptions(judgeProviderId: JudgeProviderId): SelectOptions<'project' | 'apiKey'>;
 export declare function resolveBelayConfigInteractiveMode(repoRoot: string): Promise<'full' | 'judge-only'>;
 export declare function runBelayConfigFullInteractive(options?: BelayConfigInteractiveOptions): Promise<{
     repoRoot: string;

package/dist/commands/config.js

@@ -8,8 +8,9 @@ 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 { detectJudgeRuntimeCapabilities, resolveJudgeTransport, } from '../core/judge-runtime-detection.js';
+import { getJudgeProviderSpec, isJudgeProviderId, JUDGE_PROVIDER_IDS, normalizeLegacyProviderId, } from '../core/verdict/judge-catalog.js';
+import { normalizeJudgeRuntimeConfig } from '../core/verdict/judge-runtime-config.js';
 import { initProject } from '../installer.js';
 import { isBelayFloorInstalled } from './health-snapshot.js';
 import { judgeStatus } from './judge.js';
@@ -31,6 +32,8 @@ const JUDGE_CONFIG_PATHS = [
     'judge.timeoutMs',
     'judge.credential.mode',
     'judge.credential.ref',
+    'judge.runtime.session.enabled',
+    'judge.runtime.shadow.enabled',
 ];
 export function parseAdapter(value) {
     const normalized = (value?.trim() || 'cursor').toLowerCase();
@@ -98,6 +101,12 @@ function getJudgeField(judge, pathKey) {
         return judge.credential?.mode ?? null;
     if (pathKey === 'judge.credential.ref')
         return judge.credential?.ref ?? null;
+    if (pathKey === 'judge.runtime.session.enabled') {
+        return normalizeJudgeRuntimeConfig(judge.runtime).session.enabled;
+    }
+    if (pathKey === 'judge.runtime.shadow.enabled') {
+        return normalizeJudgeRuntimeConfig(judge.runtime).shadow.enabled;
+    }
     throw new Error(`Unknown judge config path: ${pathKey}`);
 }
 function listJudgeFields(judge) {
@@ -181,6 +190,36 @@ async function applyJudgeSet(repoRoot, config, pathKey, rawValue) {
         await persistJudge(repoRoot, config, judge, adapter);
         return judge;
     }
+    if (pathKey === 'judge.runtime.session.enabled') {
+        if (value !== 'true' && value !== 'false') {
+            throw new Error('judge.runtime.session.enabled must be true or false.');
+        }
+        const runtime = normalizeJudgeRuntimeConfig(config.judge.runtime);
+        const judge = normalizeJudgeConfig({
+            ...config.judge,
+            runtime: {
+                ...runtime,
+                session: { ...runtime.session, enabled: value === 'true' },
+            },
+        });
+        await persistJudge(repoRoot, config, judge, adapter);
+        return judge;
+    }
+    if (pathKey === 'judge.runtime.shadow.enabled') {
+        if (value !== 'true' && value !== 'false') {
+            throw new Error('judge.runtime.shadow.enabled must be true or false.');
+        }
+        const runtime = normalizeJudgeRuntimeConfig(config.judge.runtime);
+        const judge = normalizeJudgeConfig({
+            ...config.judge,
+            runtime: {
+                ...runtime,
+                shadow: { ...runtime.shadow, enabled: value === 'true' },
+            },
+        });
+        await persistJudge(repoRoot, config, judge, adapter);
+        return judge;
+    }
     throw new Error(`Unknown judge config path: ${pathKey}`);
 }
 async function applyJudgeUnset(repoRoot, config, pathKey) {
@@ -289,7 +328,75 @@ export async function runBelayConfigCredential(options) {
     }
     throw new Error('credential requires action: mode, set, or clear.');
 }
+export const JUDGE_CREDENTIAL_MODE_PROMPT = 'Judge API key source';
+export const JUDGE_CREDENTIAL_STORE_KEY_PROMPT = 'Paste API key to store locally (visible input; prefer belay config credential set --key-stdin): ';
+export const JUDGE_TRANSPORT_MODE_PROMPT = 'How should Belay reach the judge?';
+export const JUDGE_HTTP_ENDPOINT_PROMPT = 'Judge HTTP API URL:';
+const CLOUD_CLI_LABELS = {
+    codex: 'Codex CLI',
+    claude: 'Claude CLI',
+    cursor: 'Cursor CLI',
+};
+export function buildJudgeTransportSelectOptions(judgeProviderId) {
+    const cliLabel = CLOUD_CLI_LABELS[judgeProviderId];
+    const runtime = detectJudgeRuntimeCapabilities(judgeProviderId);
+    const cliHint = runtime.cliTransport
+        ? 'Uses your logged-in host session; no URL needed.'
+        : 'Host CLI not found on PATH — install it or choose custom HTTP API.';
+    return {
+        message: JUDGE_TRANSPORT_MODE_PROMPT,
+        defaultValue: 'cli',
+        choices: [
+            {
+                value: 'cli',
+                label: `Use ${cliLabel} (recommended)`,
+                hint: cliHint,
+            },
+            {
+                value: 'http',
+                label: 'Custom HTTP API endpoint',
+                hint: 'Requires a provider API URL and cloud egress consent.',
+            },
+        ],
+    };
+}
+export function buildJudgeCredentialModeSelectOptions(judgeProviderId) {
+    const spec = getJudgeProviderSpec(judgeProviderId);
+    const providerEnvVars = spec?.apiKeyEnvVars.filter((name) => name !== 'BELAY_JUDGE_API_KEY') ?? [];
+    const envNames = providerEnvVars.length > 0
+        ? ['BELAY_JUDGE_API_KEY', ...providerEnvVars].join(', ')
+        : 'BELAY_JUDGE_API_KEY';
+    const projectHint = providerEnvVars.length > 0
+        ? `Uses ${envNames} from the shell; does not read .env files. Or host CLI login when available.`
+        : 'Uses BELAY_JUDGE_API_KEY from the shell; does not read .env files.';
+    return {
+        message: JUDGE_CREDENTIAL_MODE_PROMPT,
+        defaultValue: 'project',
+        choices: [
+            {
+                value: 'project',
+                label: 'Environment variables or host CLI',
+                hint: projectHint,
+            },
+            {
+                value: 'apiKey',
+                label: 'Store in Belay credential store',
+                hint: 'Saved to credentials.json (mode 0600) on the next step.',
+            },
+        ],
+    };
+}
 function formatSelectPrompt(options) {
+    const hasDetails = options.choices.some((choice) => choice.hint || choice.label);
+    if (hasDetails) {
+        const lines = options.choices.map((choice) => {
+            const label = choice.label ?? choice.value;
+            const hint = choice.hint ? ` — ${choice.hint}` : '';
+            return `  ${choice.value}: ${label}${hint}`;
+        });
+        const values = options.choices.map((choice) => choice.value).join(' | ');
+        return `${options.message}\n${lines.join('\n')}\n[${values}] (${options.defaultValue}): `;
+    }
     const values = options.choices.map((choice) => choice.value).join(' | ');
     return `${options.message} [${values}] (${options.defaultValue}): `;
 }
@@ -374,20 +481,36 @@ function writeConfigWizardBanner(options, title) {
     }
     output.write(`${title}\n`);
 }
+async function askJudgeHttpEndpoint(prompter) {
+    while (true) {
+        const endpoint = (await prompter.askText(JUDGE_HTTP_ENDPOINT_PROMPT)).trim();
+        if (endpoint) {
+            return endpoint;
+        }
+        process.stderr.write('Warning: HTTP endpoint URL is required when using custom HTTP API. Paste a URL or re-run belay config and choose host CLI.\n');
+    }
+}
+async function askJudgeCredentialStoreKey(prompter) {
+    while (true) {
+        const key = (await prompter.askText(JUDGE_CREDENTIAL_STORE_KEY_PROMPT)).trim();
+        if (key) {
+            return key;
+        }
+        process.stderr.write('Warning: API key cannot be empty. Paste a key or re-run belay config and choose environment variables.\n');
+    }
+}
 async function collectCloudJudgeWizardAnswers(prompter, judgeProviderId) {
     if (judgeProviderId === 'ollama') {
         return { acceptCloud: false };
     }
-    const judgeCredentialMode = (await prompter.askConfirm('Use project env for credentials?', true))
-        ? 'project'
-        : 'apiKey';
-    const optionalEndpoint = (await prompter.askText('Judge endpoint URL (optional): ')).trim();
-    const judgeEndpoint = optionalEndpoint || undefined;
+    const judgeCredentialMode = await prompter.askSelect(buildJudgeCredentialModeSelectOptions(judgeProviderId));
+    const transportMode = await prompter.askSelect(buildJudgeTransportSelectOptions(judgeProviderId));
+    let judgeEndpoint;
+    if (transportMode === 'http') {
+        judgeEndpoint = await askJudgeHttpEndpoint(prompter);
+    }
     if (judgeCredentialMode === 'apiKey') {
-        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();
-        }
+        process.env.BELAY_CONFIG_WIZARD_JUDGE_KEY = await askJudgeCredentialStoreKey(prompter);
     }
     let acceptCloud = false;
     if (judgeEndpoint) {

package/dist/commands/doctor.js

@@ -8,9 +8,12 @@ import { resolveScopedPaths } from '../adapters/layouts/scope.js';
 import { cleanupOrphanApprovalState } from '../cleanup-orphans.js';
 import { approvedApprovalsPath, belayStateDir, detectAdapterName, loadLayeredConfig, pendingApprovalsPath, repoLocalStateDirFor, } from '../config-io.js';
 import { detectFenceDrift, summarizeAuditVisibility } from '../core/audit-summary.js';
+import { inspectBoundaryAttestationFile } from '../core/capability/boundary-attestation-sign.js';
+import { boundaryAttestationPath, boundarySessionStatus, } from '../core/capability/boundary-session.js';
 import { defaultControlPlaneDir } from '../core/config.js';
 import { verifyIntegrityManifest } from '../core/integrity.js';
 import { diagnoseJudge, stopJudgeSessionBrokers } from '../core/judge-doctor.js';
+import { resolveJudgeTransport } from '../core/judge-runtime-detection.js';
 import { getManagedHookEntries } from '../defaults.js';
 import { resolveNodeBinary } from '../node-resolution.js';
 import { egressStatus } from '../services/egress-service.js';
@@ -78,7 +81,9 @@ export async function doctorProject(options = {}) {
             if (loadedConfig.version !== 4) {
                 warnings.push(`Config version is ${loadedConfig.version}; expected 4. Run belay upgrade to migrate.`);
             }
-            const judgeDoctor = await diagnoseJudge(loadedConfig);
+            const transport = resolveJudgeTransport(loadedConfig.judge);
+            const shouldProbe = transport.endsWith('-cli');
+            const judgeDoctor = await diagnoseJudge(loadedConfig, repoRoot, { liveProbe: shouldProbe });
             issues.push(...judgeDoctor.issues);
             warnings.push(...judgeDoctor.warnings);
             notes.push(...judgeDoctor.notes);
@@ -294,6 +299,36 @@ export async function doctorProject(options = {}) {
             for (const issue of sandbox.issues) {
                 warnings.push(issue);
             }
+            for (const advisory of sandbox.advisories) {
+                warnings.push(advisory);
+            }
+        }
+        const boundaryDriver = loadedConfig.capability?.boundaryDriver ??
+            (loadedConfig.sandbox.runtime === 'container' ? 'container' : null);
+        if (loadedConfig.capability || boundaryDriver === 'container') {
+            const attestationPath = boundaryAttestationPath(repoRoot, loadedConfig);
+            const attestationFormat = await inspectBoundaryAttestationFile(attestationPath);
+            if (attestationFormat === 'legacy') {
+                warnings.push('Boundary attestation uses an unsigned legacy format. Run belay session start to re-sign it.');
+            }
+            else if (attestationFormat === 'invalid') {
+                warnings.push('Boundary attestation file is present but invalid. Run belay session start to regenerate it.');
+            }
+        }
+        if (boundaryDriver === 'container') {
+            const session = await boundarySessionStatus({ repoRoot, config: loadedConfig });
+            if (!session.attestation) {
+                warnings.push('Container boundary driver is configured but no attestation was found. Run belay session start.');
+            }
+            else if (!session.fresh) {
+                warnings.push('Boundary attestation is stale or expired. Run belay session start to refresh.');
+            }
+            else if (session.attestation.probeSignals.includes('repo-mount-ro-default')) {
+                notes.push('Container boundary defaults to read-only directory mounts; predicted writes use read-write mounts for the working directory only.');
+            }
+            else if (session.attestation.probeSignals.includes('repo-mount-rw')) {
+                notes.push('Container boundary mounts the working directory read-write (repo-mount-rw). Policy grants scope widening; paths outside the mount are not container-enforced.');
+            }
         }
         if (loadedConfig.egress.enabled) {
             const egress = await egressStatus({ targetDir: repoRoot });

package/dist/commands/explain.js

@@ -1,6 +1,7 @@
 import path from 'node:path';
 import { loadApprovalState, loadConfigFile } from '../config-io.js';
 import { compactApprovals } from '../core/approval.js';
+import { extractJudgeFallbackReason, formatJudgeRecoveryHint, inferProviderIdFromFallbackReason, isJudgeInfrastructureFailure, } from '../core/judge-fallback-hints.js';
 import { classifyForReport } from './classify-for-report.js';
 export async function explainCommand(options) {
     const repoRoot = path.resolve(options.targetDir ?? process.cwd());
@@ -134,5 +135,14 @@ export function formatExplainReport(report) {
             ? 'Observed assessment: measured in an isolated git worktree at gate time. Observed-safe commands are applied once and the hook denies re-execution (transactional_already_applied).'
             : 'Observed assessment: not applicable (transactional path not eligible).',
     ];
-    return `${lines.join('\n')}\n`;
+    const recoveryLines = [];
+    if (isJudgeInfrastructureFailure(result)) {
+        const fallbackReason = extractJudgeFallbackReason(result);
+        const providerId = inferProviderIdFromFallbackReason(fallbackReason);
+        const recoveryHint = formatJudgeRecoveryHint(providerId, fallbackReason);
+        if (recoveryHint) {
+            recoveryLines.push('', 'Recovery:', `  ${recoveryHint}`, '  Then verify: belay judge test --live-probe');
+        }
+    }
+    return `${[...lines, ...recoveryLines].join('\n')}\n`;
 }

package/dist/commands/judge.js

@@ -63,10 +63,11 @@ export async function judgeStatus(options = {}) {
     });
     const { resolved } = resolveJudgeModel(judge);
     const transport = resolveJudgeTransport(judge);
+    const effectiveTransport = transport === 'cursor-cli' && judge.runtime?.session.enabled ? 'cursor-acp' : transport;
     const lines = [
         `Judge providerId : ${judge.providerId ?? '(inferred)'}`,
         `Judge driver     : ${judge.provider}`,
-        `Transport        : ${transport}`,
+        `Transport        : ${effectiveTransport}`,
         `Endpoint         : ${judge.endpoint ?? '(none)'}`,
         `Model            : ${resolved} (requested: ${judge.model})`,
         `Credential       : ${credential.mode} (${credential.sourceKind})${credential.source ? ` → ${credential.source}` : ''} ${credential.key ? '✓ set' : '✗ missing'}`,
@@ -82,7 +83,7 @@ export async function judgeStatus(options = {}) {
             endpoint: judge.endpoint,
             model: judge.model,
             modelResolved: resolved,
-            transport,
+            transport: effectiveTransport,
             credential,
             cloudConsent: judge.cloudConsent ?? null,
             cloudJudgeActive: isCloudJudgeConfig(judge) && hasValidCloudConsent(judge),

package/dist/commands/session.d.ts

@@ -0,0 +1,20 @@
+import { boundarySessionStatus } from '../core/capability/boundary-session.js';
+export declare function sessionStartProject(params: {
+    targetDir?: string;
+    agentCommand?: string;
+}): Promise<{
+    ok: boolean;
+    message: string;
+    attestationPath?: string;
+    exitCode?: number | null;
+}>;
+export declare function sessionStatusProject(params: {
+    targetDir?: string;
+    json?: boolean;
+}): Promise<{
+    ok: boolean;
+    attestationPath: string;
+    fresh: boolean;
+    attestation: Awaited<ReturnType<typeof boundarySessionStatus>>['attestation'];
+}>;
+export declare function formatSessionStatusReport(report: Awaited<ReturnType<typeof sessionStatusProject>>): string;

package/dist/commands/session.js

@@ -0,0 +1,51 @@
+import path from 'node:path';
+import process from 'node:process';
+import { loadConfigFile } from '../config-io.js';
+import { boundarySessionStatus, runBoundaryAgentCommand, startBoundarySession, } from '../core/capability/boundary-session.js';
+export async function sessionStartProject(params) {
+    const repoRoot = path.resolve(params.targetDir ?? process.cwd());
+    const config = await loadConfigFile(repoRoot);
+    const started = await startBoundarySession({ repoRoot, config });
+    if (!params.agentCommand) {
+        return {
+            ok: true,
+            message: `Boundary session started (${started.attestation.driver}); attestation written to ${path.relative(repoRoot, started.attestationPath)}.`,
+            attestationPath: started.attestationPath,
+        };
+    }
+    const run = await runBoundaryAgentCommand({
+        repoRoot,
+        config,
+        command: params.agentCommand,
+    });
+    const exitCode = run.exitCode ?? 1;
+    return {
+        ok: exitCode === 0,
+        message: `Boundary session started (${started.attestation.driver}); agent exited with code ${exitCode}.`,
+        attestationPath: started.attestationPath,
+        exitCode,
+    };
+}
+export async function sessionStatusProject(params) {
+    const repoRoot = path.resolve(params.targetDir ?? process.cwd());
+    const config = await loadConfigFile(repoRoot);
+    const status = await boundarySessionStatus({ repoRoot, config });
+    return {
+        ok: status.fresh,
+        attestationPath: status.attestationPath,
+        fresh: status.fresh,
+        attestation: status.attestation,
+    };
+}
+export function formatSessionStatusReport(report) {
+    if (!report.attestation) {
+        return `No boundary attestation at ${report.attestationPath}. Run belay session start.`;
+    }
+    return [
+        `Attestation: ${report.attestationPath}`,
+        `Driver: ${report.attestation.driver}`,
+        `Fresh: ${report.fresh ? 'yes' : 'no'}`,
+        `Expires: ${report.attestation.expiresAt}`,
+        `Materializes grants: ${report.attestation.materializesGrants ? 'yes' : 'no'}`,
+    ].join('\n');
+}

package/dist/config-io.js

@@ -49,6 +49,42 @@ const APPROVAL_STATE_FILES = ['pending-approvals.json', 'approved-approvals.json
 function approvalFilesExist(dir) {
     return APPROVAL_STATE_FILES.some((fileName) => existsSync(path.join(dir, fileName)));
 }
+async function isCorruptApprovalStateFile(filePath) {
+    const raw = await readFile(filePath, 'utf8');
+    try {
+        JSON.parse(raw);
+        return false;
+    }
+    catch (error) {
+        return error instanceof SyntaxError;
+    }
+}
+function normalizeApprovalStateFile(parsed) {
+    const version = parsed.version === 3 ? 3 : parsed.version === 2 ? 2 : 1;
+    return {
+        version,
+        revision: typeof parsed.revision === 'number' ? parsed.revision : undefined,
+        approvals: Array.isArray(parsed.approvals) ? parsed.approvals : [],
+    };
+}
+/** Gate reads: corrupt JSON is treated as empty state (fail-closed). */
+async function readApprovalStateFileForGate(filePath) {
+    const raw = await readFile(filePath, 'utf8');
+    try {
+        return normalizeApprovalStateFile(JSON.parse(raw));
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            return { version: 1, approvals: [] };
+        }
+        throw error;
+    }
+}
+/** Migration reads: corrupt JSON must not be treated as empty. */
+async function readApprovalStateFileStrict(filePath) {
+    const raw = await readFile(filePath, 'utf8');
+    return normalizeApprovalStateFile(JSON.parse(raw));
+}
 async function repoLocalApprovalsEmpty(repoRoot, config) {
     const repoLocalDir = repoLocalStateDirFor(repoRoot, config);
     if (!approvalFilesExist(repoLocalDir)) {
@@ -59,21 +95,16 @@ async function repoLocalApprovalsEmpty(repoRoot, config) {
         if (!existsSync(filePath)) {
             continue;
         }
-        const state = await readApprovalStateFile(filePath);
+        if (await isCorruptApprovalStateFile(filePath)) {
+            return false;
+        }
+        const state = await readApprovalStateFileForGate(filePath);
         if (state.approvals.length > 0) {
             return false;
         }
     }
     return true;
 }
-async function readApprovalStateFile(filePath) {
-    const raw = await readFile(filePath, 'utf8');
-    const parsed = JSON.parse(raw);
-    return {
-        version: parsed.version === 2 ? 2 : 1,
-        approvals: Array.isArray(parsed.approvals) ? parsed.approvals : [],
-    };
-}
 async function writeApprovalStateFile(filePath, state) {
     await mkdir(path.dirname(filePath), { recursive: true, mode: 0o700 });
     await writeFile(filePath, `${JSON.stringify(compactApprovals(state), null, 2)}\n`, {
@@ -91,12 +122,18 @@ async function migrateApprovalFilesBetween(sourceDir, targetDir) {
             continue;
         }
         if (!existsSync(to)) {
+            if (await isCorruptApprovalStateFile(from)) {
+                continue;
+            }
             await copyFile(from, to);
             await chmod(to, 0o600);
             continue;
         }
-        const targetState = await readApprovalStateFile(to);
-        const sourceState = await readApprovalStateFile(from);
+        if ((await isCorruptApprovalStateFile(from)) || (await isCorruptApprovalStateFile(to))) {
+            continue;
+        }
+        const targetState = await readApprovalStateFileStrict(to);
+        const sourceState = await readApprovalStateFileStrict(from);
         await writeApprovalStateFile(to, mergeApprovalStates(targetState, sourceState));
     }
 }
@@ -172,7 +209,7 @@ export async function loadApprovalState(repoRoot, fileName, config) {
     if (!existsSync(filePath)) {
         return { version: 1, approvals: [] };
     }
-    return readApprovalStateFile(filePath);
+    return readApprovalStateFileForGate(filePath);
 }
 export async function saveApprovalState(repoRoot, fileName, state, config) {
     const filePath = fileName === 'pending-approvals.json'

package/dist/conformance/guarantee-posture.d.ts

@@ -0,0 +1,21 @@
+import type { BoundaryAttestation } from '../core/capability/attestation.js';
+import type { BelayConfigV4 } from '../core/config.js';
+import type { LayerProfileId } from './types.js';
+export interface GuaranteePosture {
+    configuredProfile: LayerProfileId;
+    attestedProfile: LayerProfileId;
+    attestationFresh: boolean;
+    l1FullConfigured: boolean;
+    l1FullAttested: boolean;
+    postureMismatch: boolean;
+}
+export declare function resolveConfiguredProfile(config: BelayConfigV4, egressProxyRunning: boolean): LayerProfileId;
+export declare function resolveAttestedProfile(params: {
+    attestation: BoundaryAttestation | null;
+    l1FullConfigured: boolean;
+}): LayerProfileId;
+export declare function evaluateGuaranteePosture(params: {
+    config: BelayConfigV4;
+    attestation: BoundaryAttestation | null;
+    egressProxyRunning: boolean;
+}): GuaranteePosture;

package/dist/conformance/guarantee-posture.js

@@ -0,0 +1,46 @@
+import { isAttestationFresh } from '../core/capability/attestation.js';
+import { evaluateL1FullStatus } from '../core/capability/broker.js';
+export function resolveConfiguredProfile(config, egressProxyRunning) {
+    const l1Full = evaluateL1FullStatus({ config, egressProxyRunning });
+    if (l1Full.active) {
+        return 'l1-full';
+    }
+    if (config.egress.enabled) {
+        return 'l1-partial-egress';
+    }
+    if (config.policy.transactional.enabled) {
+        return 'l1-l2-transactional';
+    }
+    return 'l3-l4-only';
+}
+export function resolveAttestedProfile(params) {
+    if (!params.attestation || !isAttestationFresh(params.attestation)) {
+        return 'l3-l4-only';
+    }
+    if (params.l1FullConfigured &&
+        params.attestation.deniesUngrantedEffects &&
+        params.attestation.materializesGrants) {
+        return 'l1-full';
+    }
+    return 'l3-l4-only';
+}
+export function evaluateGuaranteePosture(params) {
+    const l1Full = evaluateL1FullStatus({
+        config: params.config,
+        egressProxyRunning: params.egressProxyRunning,
+    });
+    const configuredProfile = resolveConfiguredProfile(params.config, params.egressProxyRunning);
+    const attestedProfile = resolveAttestedProfile({
+        attestation: params.attestation,
+        l1FullConfigured: l1Full.active,
+    });
+    return {
+        configuredProfile,
+        attestedProfile,
+        attestationFresh: params.attestation ? isAttestationFresh(params.attestation) : false,
+        l1FullConfigured: l1Full.active,
+        l1FullAttested: attestedProfile === 'l1-full' &&
+            Boolean(params.attestation?.deniesUngrantedEffects && params.attestation.materializesGrants),
+        postureMismatch: configuredProfile === 'l1-full' && attestedProfile !== 'l1-full',
+    };
+}

package/dist/conformance/guarantee-table.d.ts

@@ -1,4 +1,5 @@
 import type { LayerConformanceScenario, LayerProfileId } from './types.js';
+export { evaluateGuaranteePosture, type GuaranteePosture } from './guarantee-posture.js';
 export type { LayerConformanceScenario, LayerProfileId } from './types.js';
 export interface GuaranteeTableRow {
     profile: LayerProfileId;