@guilz-dev/belay 0.2.0 → 0.4.0

package/dist/commands/quality.js

@@ -0,0 +1,105 @@
+import path from 'node:path';
+import { loadConfigFile } from '../config-io.js';
+import { computeAuditMetrics } from '../core/audit-metrics.js';
+import { runCorpusEvaluation } from '../corpus/evaluate.js';
+import { passesHardGates } from '../corpus/gates.js';
+import { loadAuditRecords } from './audit.js';
+import { harvestReportFromRecords } from './harvest.js';
+export const QUALITY_REPORT_SCHEMA_VERSION = 1;
+export async function qualityCheck(options = {}) {
+    const repoRoot = path.resolve(options.targetDir ?? process.cwd());
+    const config = await loadConfigFile(repoRoot);
+    const corpusDir = path.resolve(repoRoot, options.corpusDir ?? 'corpus');
+    const corpusMetrics = await runCorpusEvaluation(corpusDir);
+    const hardGatesOk = passesHardGates(corpusMetrics.gates);
+    const auditRecords = await loadAuditRecords(repoRoot);
+    const metrics = computeAuditMetrics(auditRecords, {
+        auditLogPath: config.audit.logPath,
+        mode: config.mode,
+        unknownLocalEffect: config.policy.unknownLocalEffect,
+    });
+    const harvest = harvestReportFromRecords(auditRecords, {
+        allowPatterns: config.overrides.allow,
+    });
+    const notes = [
+        'Overall ok reflects corpus hard gates only; audit and harvest signals are advisory.',
+        'Recursive quality loop: corpus hard gates are the FN/FP safety boundary.',
+        'Harvest candidates and audit metrics inform review — approvals are not ground truth.',
+        'Simulate (`belay simulate`) is triage only; it does not replace `pnpm corpus`.',
+    ];
+    if (!hardGatesOk) {
+        notes.push('Corpus hard gates failed — fix must-ask misses and provably-benign blocks before tuning friction.');
+    }
+    if (metrics.availabilityAsks.total > 0) {
+        notes.push(`${metrics.availabilityAsks.total} availability-caused ask(s) — tune judge/cwd infrastructure before corpus promotion.`);
+    }
+    if (harvest.availabilityQueue.length > 0) {
+        notes.push(`${harvest.availabilityQueue.length} shell pattern(s) in the availability queue — do not harvest into corpus.`);
+    }
+    const ok = hardGatesOk;
+    return {
+        schemaVersion: QUALITY_REPORT_SCHEMA_VERSION,
+        ok,
+        corpus: {
+            path: path.relative(repoRoot, corpusDir) || corpusDir,
+            passesHardGates: hardGatesOk,
+            totalCases: corpusMetrics.total,
+            categoryCounts: corpusMetrics.categoryCounts,
+            provenanceCounts: corpusMetrics.provenanceCounts,
+            mustAskMisses: corpusMetrics.gates.mustAsk.mismatches,
+            provablyBenignBlocks: corpusMetrics.gates.provablyBenign.mismatches,
+            acceptedBenignMismatches: corpusMetrics.gates.acceptedBenign.mismatches,
+            accuracy: corpusMetrics.accuracy,
+        },
+        audit: {
+            logPath: config.audit.logPath,
+            gateEvents: metrics.gateEvents,
+            classifierWouldBlockRate: metrics.classifierWouldBlockRate,
+            availabilityAsks: metrics.availabilityAsks.total,
+            readyForEnforce: metrics.dogfood.readyForEnforce,
+            repeatedFingerprintPatterns: metrics.repeatedFingerprintAsks.length,
+        },
+        harvest: {
+            scope: 'shell',
+            benignCandidates: harvest.candidates.length,
+            availabilityQueue: harvest.availabilityQueue.length,
+        },
+        notes,
+    };
+}
+export function formatQualityReport(report) {
+    const lines = [
+        'belay quality — recursive quality loop status',
+        `Schema: v${report.schemaVersion}`,
+        `Overall: ${report.ok ? 'OK' : 'ATTENTION NEEDED'}`,
+        '',
+        'Corpus hard gates:',
+        `  path: ${report.corpus.path}`,
+        `  passes: ${report.corpus.passesHardGates ? 'yes' : 'no'}`,
+        `  total cases: ${report.corpus.totalCases}`,
+        `  categories: must-ask=${report.corpus.categoryCounts['must-ask']} provably-benign=${report.corpus.categoryCounts['provably-benign']} accepted-benign=${report.corpus.categoryCounts['accepted-benign']}`,
+        `  provenance: manual=${report.corpus.provenanceCounts.manual} mutation=${report.corpus.provenanceCounts.mutation} harvest=${report.corpus.provenanceCounts.harvest} redteam=${report.corpus.provenanceCounts.redteam} unspecified=${report.corpus.provenanceCounts.unspecified}`,
+        `  must-ask misses: ${report.corpus.mustAskMisses}`,
+        `  provably-benign blocks: ${report.corpus.provablyBenignBlocks}`,
+        `  accepted-benign mismatches (soft): ${report.corpus.acceptedBenignMismatches}`,
+        `  accuracy: ${(report.corpus.accuracy * 100).toFixed(1)}%`,
+        '',
+        'Audit metrics:',
+        `  log: ${report.audit.logPath}`,
+        `  gate events: ${report.audit.gateEvents}`,
+        `  classifier would-block rate: ${(report.audit.classifierWouldBlockRate * 100).toFixed(1)}%`,
+        `  availability asks: ${report.audit.availabilityAsks}`,
+        `  ready for enforce: ${report.audit.readyForEnforce ? 'yes' : 'no'}`,
+        `  repeated fingerprint patterns: ${report.audit.repeatedFingerprintPatterns}`,
+        '',
+        'Harvest (shell only):',
+        `  benign candidates: ${report.harvest.benignCandidates}`,
+        `  availability queue: ${report.harvest.availabilityQueue}`,
+        '',
+        'Notes:',
+    ];
+    for (const note of report.notes) {
+        lines.push(`- ${note}`);
+    }
+    return lines.join('\n');
+}

package/dist/commands/simulate.d.ts

@@ -9,6 +9,7 @@ export declare function simulateProject(options: SimulateOptions): Promise<{
     changedCount: number;
     allowToDenyCount: number;
     denyToAllowCount: number;
+    missingSnapshotCount: number;
     diffs: import("../core/reclassify.js").ReclassifyDiff[];
 }>;
 export declare function formatSimulateReport(report: Awaited<ReturnType<typeof simulateProject>>): string;

package/dist/commands/simulate.js

@@ -4,7 +4,7 @@ import path from 'node:path';
 import { loadConfigFile } from '../config-io.js';
 import { parseAuditNdjson, toAuditRecord } from '../core/audit-metrics.js';
 import { mergeConfig } from '../core/config.js';
-import { diffReclassification } from '../core/reclassify.js';
+import { countMissingActionSnapshots, diffReclassification } from '../core/reclassify.js';
 export async function simulateProject(options) {
     const repoRoot = path.resolve(options.targetDir ?? process.cwd());
     const currentConfig = await loadConfigFile(repoRoot);
@@ -22,6 +22,7 @@ export async function simulateProject(options) {
         raw = '';
     }
     const records = parseAuditNdjson(raw).map(toAuditRecord);
+    const missingSnapshotCount = countMissingActionSnapshots(records);
     const diffs = (await Promise.all(records.map((record) => diffReclassification(record, candidateConfig, repoRoot)))).filter((diff) => diff !== null);
     const allowToDeny = diffs.filter((diff) => (diff.previousVerdict === 'allow' || diff.previousVerdict === 'allow_flagged') &&
         diff.nextVerdict === 'deny_pending_approval');
@@ -33,20 +34,24 @@ export async function simulateProject(options) {
         changedCount: diffs.length,
         allowToDenyCount: allowToDeny.length,
         denyToAllowCount: denyToAllow.length,
+        missingSnapshotCount,
         diffs,
     };
 }
 export function formatSimulateReport(report) {
     const lines = [
         `simulate ${report.candidateConfigPath}`,
+        'Triage only — corpus hard gates (`pnpm corpus`), not simulate counts, are the safety boundary.',
         `Records scanned: ${report.totalRecords}`,
+        `Missing action snapshots: ${report.missingSnapshotCount}`,
         `Verdict changes: ${report.changedCount}`,
         `allow/flagged → deny: ${report.allowToDenyCount}`,
         `deny → allow/flagged: ${report.denyToAllowCount}`,
         '',
     ];
     for (const diff of report.diffs.slice(0, 30)) {
-        lines.push(`- ${diff.summary ?? diff.fingerprint}: ${diff.previousVerdict}/${diff.previousReason} → ${diff.nextVerdict}/${diff.nextReason}`);
+        const context = diff.replayCwd && diff.replayKind ? ` [${diff.replayKind} cwd=${diff.replayCwd}]` : '';
+        lines.push(`- ${diff.summary ?? diff.fingerprint}${context}: ${diff.previousVerdict}/${diff.previousReason} → ${diff.nextVerdict}/${diff.nextReason}`);
     }
     if (report.diffs.length > 30) {
         lines.push(`... ${report.diffs.length - 30} more`);

package/dist/commands/standing-allow.d.ts

@@ -0,0 +1,10 @@
+import type { GatedActionKind } from '../core/gate-contract.js';
+export interface RevokeStandingAllowOptions {
+    targetDir?: string;
+    fingerprint: string;
+    kind?: GatedActionKind;
+}
+export declare function revokeStandingAllow(options: RevokeStandingAllowOptions): Promise<{
+    ok: boolean;
+    message: string;
+}>;

package/dist/commands/standing-allow.js

@@ -0,0 +1,26 @@
+import path from 'node:path';
+import { loadConfigFile, repoLocalStateDirFor } from '../config-io.js';
+import { loadStandingAllow, revokeStandingAllowEntry, saveStandingAllow, standingAllowFile, } from '../core/standing-allow.js';
+export async function revokeStandingAllow(options) {
+    const repoRoot = path.resolve(options.targetDir ?? process.cwd());
+    const config = await loadConfigFile(repoRoot);
+    const filePath = standingAllowFile(config, repoLocalStateDirFor(repoRoot, config));
+    const state = await loadStandingAllow(filePath);
+    const kind = options.kind ?? 'shell';
+    const { state: next, removed } = revokeStandingAllowEntry(state, {
+        kind,
+        fingerprint: options.fingerprint,
+        repoRoot,
+    });
+    if (!removed) {
+        return {
+            ok: false,
+            message: `Standing-allow entry not found for ${kind} fingerprint ${options.fingerprint}.`,
+        };
+    }
+    await saveStandingAllow(filePath, next);
+    return {
+        ok: true,
+        message: `Revoked standing-allow for ${kind} fingerprint ${options.fingerprint}.`,
+    };
+}

package/dist/commands/status.js

@@ -39,9 +39,9 @@ export function formatStatusReport(report) {
         ...(health.additionalRiskSignals.length > 0
             ? [`Additional risk signals: ${health.additionalRiskSignals.join('; ')}`]
             : []),
-        ...(health.skillOnly
+        ...(!health.floorInstalled
             ? [
-                'Skill-only mode: yes — hooks are missing or incomplete. Run `npx @guilz-dev/belay init` to install the enforcement floor.',
+                'Enforcement floor missing or incomplete. Run `belay config` for interactive setup, or `npx @guilz-dev/belay init` for non-interactive install.',
             ]
             : []),
         `Approval state: ${report.approvalStateDir}`,

package/dist/commands/stdin-key.d.ts

@@ -0,0 +1 @@
+export declare function readKeyFromStdin(): Promise<string>;

package/dist/commands/stdin-key.js

@@ -0,0 +1,8 @@
+import { stdin as input } from 'node:process';
+export async function readKeyFromStdin() {
+    const chunks = [];
+    for await (const chunk of input) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks).toString('utf8').trim();
+}

package/dist/commands/tui.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Zero-dependency terminal UI helpers for the interactive `belay config` wizard.
+ *
+ * Everything here is built on Node's built-in `readline`/`tty` only — no runtime
+ * dependencies — so it stays aligned with belay's zero-dependency posture.
+ *
+ * This module is intentionally TTY-only. Callers are responsible for non-TTY
+ * fallback behavior.
+ */
+export declare const c: {
+    bold: (s: string) => string;
+    dim: (s: string) => string;
+    italic: (s: string) => string;
+    underline: (s: string) => string;
+    inverse: (s: string) => string;
+    cyan: (s: string) => string;
+    green: (s: string) => string;
+    yellow: (s: string) => string;
+    red: (s: string) => string;
+    gray: (s: string) => string;
+};
+/** A select wizard only makes sense when both stdin and stdout are real TTYs. */
+export declare function isInteractiveTTY(): boolean;
+/** Top banner shown once at the start of the wizard. */
+export declare function intro(title: string, subtitle?: string): void;
+/** Closing line shown once at the end of the wizard. */
+export declare function outro(message: string): void;
+/** Collapsed one-line summary of an answered question. */
+export declare function summary(label: string, value: string): void;
+export interface SelectChoice<T extends string> {
+    value: T;
+    /** Visible label; defaults to `value`. */
+    label?: string;
+    /** Dim hint shown to the right of the focused row. */
+    hint?: string;
+}
+export interface SelectOptions<T extends string> {
+    message: string;
+    choices: SelectChoice<T>[];
+    defaultValue: T;
+}
+/**
+ * Interactive single-choice prompt driven by arrow keys (or j/k). Resolves with
+ * the selected choice value. Must only be called in an interactive TTY.
+ */
+export declare function selectPrompt<T extends string>(opts: SelectOptions<T>): Promise<T>;
+/** Interactive yes/no prompt rendered as a two-row arrow-key selection. */
+export declare function confirmPrompt(message: string, defaultValue: boolean): Promise<boolean>;

package/dist/commands/tui.js

@@ -0,0 +1,150 @@
+/**
+ * Zero-dependency terminal UI helpers for the interactive `belay config` wizard.
+ *
+ * Everything here is built on Node's built-in `readline`/`tty` only — no runtime
+ * dependencies — so it stays aligned with belay's zero-dependency posture.
+ *
+ * This module is intentionally TTY-only. Callers are responsible for non-TTY
+ * fallback behavior.
+ */
+import { stdin as input, stdout as output } from 'node:process';
+import readline from 'node:readline';
+const isColorEnabled = () => isInteractiveTTY() && !process.env.NO_COLOR && process.env.TERM !== 'dumb';
+const symbol = (pretty, plain) => (isColorEnabled() ? pretty : plain);
+const wrap = (open, close) => (s) => isColorEnabled() ? `\x1b[${open}m${s}\x1b[${close}m` : s;
+export const c = {
+    bold: wrap(1, 22),
+    dim: wrap(2, 22),
+    italic: wrap(3, 23),
+    underline: wrap(4, 24),
+    inverse: wrap(7, 27),
+    cyan: wrap(36, 39),
+    green: wrap(32, 39),
+    yellow: wrap(33, 39),
+    red: wrap(31, 39),
+    gray: wrap(90, 39),
+};
+/** A select wizard only makes sense when both stdin and stdout are real TTYs. */
+export function isInteractiveTTY() {
+    return Boolean(input.isTTY && output.isTTY);
+}
+const symPointer = () => symbol('❯', '>');
+const symCheck = () => symbol('✓', 'v');
+const symBar = () => symbol('│', '|');
+const symQuestion = () => '?';
+/** Top banner shown once at the start of the wizard. */
+export function intro(title, subtitle) {
+    output.write('\n');
+    output.write(`${c.green(symBar())} ${c.bold(title)}\n`);
+    if (subtitle) {
+        output.write(`${c.green(symBar())} ${c.dim(subtitle)}\n`);
+    }
+    output.write(`${c.green(symBar())}\n`);
+}
+/** Closing line shown once at the end of the wizard. */
+export function outro(message) {
+    output.write(`${c.green(symBar())}\n`);
+    output.write(`${c.green(symCheck())} ${message}\n\n`);
+}
+/** Collapsed one-line summary of an answered question. */
+export function summary(label, value) {
+    output.write(`${c.green(symCheck())} ${c.dim(label)}  ${c.cyan(value)}\n`);
+}
+/**
+ * Interactive single-choice prompt driven by arrow keys (or j/k). Resolves with
+ * the selected choice value. Must only be called in an interactive TTY.
+ */
+export function selectPrompt(opts) {
+    if (!isInteractiveTTY()) {
+        throw new Error('selectPrompt requires an interactive TTY.');
+    }
+    const { message, choices } = opts;
+    if (choices.length === 0) {
+        throw new Error('selectPrompt requires at least one choice.');
+    }
+    const startIndex = Math.max(0, choices.findIndex((ch) => ch.value === opts.defaultValue));
+    return new Promise((resolve, reject) => {
+        let index = startIndex;
+        let rendered = 0;
+        const lineFor = (ch, active) => {
+            const label = ch.label ?? ch.value;
+            if (active) {
+                const hint = ch.hint ? ` ${c.dim(ch.hint)}` : '';
+                return `${c.cyan(symPointer())} ${c.cyan(c.underline(label))}${hint}`;
+            }
+            return `  ${c.dim(label)}`;
+        };
+        const clearRendered = () => {
+            if (rendered > 0) {
+                output.write(`\x1b[${rendered}A`);
+            }
+            output.write('\x1b[J');
+        };
+        const render = () => {
+            clearRendered();
+            const lines = [
+                `${c.green(symQuestion())} ${c.bold(message)}`,
+                ...choices.map((ch, i) => lineFor(ch, i === index)),
+            ];
+            output.write(`${lines.join('\n')}\n`);
+            rendered = lines.length;
+        };
+        const cleanup = () => {
+            input.off('keypress', onKey);
+            if (input.isTTY && typeof input.setRawMode === 'function') {
+                input.setRawMode(false);
+            }
+            input.pause();
+            output.write('\x1b[?25h'); // show cursor
+        };
+        const finish = () => {
+            clearRendered();
+            cleanup();
+            const chosen = choices[index];
+            summary(message, chosen.label ?? chosen.value);
+            resolve(chosen.value);
+        };
+        const onKey = (_str, key) => {
+            if (!key)
+                return;
+            if (key.ctrl && key.name === 'c') {
+                clearRendered();
+                cleanup();
+                output.write('\n');
+                reject(new Error('Cancelled.'));
+                return;
+            }
+            if (key.name === 'up' || key.name === 'k') {
+                index = (index - 1 + choices.length) % choices.length;
+                render();
+            }
+            else if (key.name === 'down' || key.name === 'j') {
+                index = (index + 1) % choices.length;
+                render();
+            }
+            else if (key.name === 'return' || key.name === 'enter') {
+                finish();
+            }
+        };
+        readline.emitKeypressEvents(input);
+        if (input.isTTY && typeof input.setRawMode === 'function') {
+            input.setRawMode(true);
+        }
+        input.resume();
+        output.write('\x1b[?25l'); // hide cursor
+        input.on('keypress', onKey);
+        render();
+    });
+}
+/** Interactive yes/no prompt rendered as a two-row arrow-key selection. */
+export async function confirmPrompt(message, defaultValue) {
+    const value = await selectPrompt({
+        message,
+        defaultValue: defaultValue ? 'yes' : 'no',
+        choices: [
+            { value: 'yes', label: 'Yes' },
+            { value: 'no', label: 'No' },
+        ],
+    });
+    return value === 'yes';
+}

package/dist/config-io.js

@@ -1,5 +1,5 @@
 import { existsSync } from 'node:fs';
-import { copyFile, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { chmod, copyFile, mkdir, readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { getAdapterLayout } from './adapters/layouts/index.js';
 import { compactApprovals, isExpired, mergeApprovalStates } from './core/approval.js';
@@ -42,7 +42,7 @@ export function approvedApprovalsPath(repoRoot, config) {
 export { belayStateDir };
 export async function ensureBelayStateDir(config, repoRoot) {
     const stateDir = belayStateDir(config, repoLocalStateDirFor(repoRoot, config));
-    await mkdir(stateDir, { recursive: true });
+    await mkdir(stateDir, { recursive: true, mode: 0o700 });
     return stateDir;
 }
 const APPROVAL_STATE_FILES = ['pending-approvals.json', 'approved-approvals.json'];
@@ -75,11 +75,15 @@ async function readApprovalStateFile(filePath) {
     };
 }
 async function writeApprovalStateFile(filePath, state) {
-    await mkdir(path.dirname(filePath), { recursive: true });
-    await writeFile(filePath, `${JSON.stringify(compactApprovals(state), null, 2)}\n`, 'utf8');
+    await mkdir(path.dirname(filePath), { recursive: true, mode: 0o700 });
+    await writeFile(filePath, `${JSON.stringify(compactApprovals(state), null, 2)}\n`, {
+        encoding: 'utf8',
+        mode: 0o600,
+    });
+    await chmod(filePath, 0o600);
 }
 async function migrateApprovalFilesBetween(sourceDir, targetDir) {
-    await mkdir(targetDir, { recursive: true });
+    await mkdir(targetDir, { recursive: true, mode: 0o700 });
     for (const fileName of APPROVAL_STATE_FILES) {
         const from = path.join(sourceDir, fileName);
         const to = path.join(targetDir, fileName);
@@ -88,6 +92,7 @@ async function migrateApprovalFilesBetween(sourceDir, targetDir) {
         }
         if (!existsSync(to)) {
             await copyFile(from, to);
+            await chmod(to, 0o600);
             continue;
         }
         const targetState = await readApprovalStateFile(to);

package/dist/conformance/guarantee-table.js

@@ -86,10 +86,22 @@ export const GUARANTEE_SCENARIOS = {
             reason: 'external_effect',
         },
         {
+            // L1-full only: shell + tool paths use classifyGatedAction + brokerFsScope.
             id: 'l1f-deny-outside-repo',
             command: 'echo hi > ../../outside.txt',
             permission: 'deny',
             reason: 'outside_repo_redirect',
         },
+        {
+            id: 'l1f-deny-outside-repo-write',
+            kind: 'tool',
+            command: '',
+            toolPayload: {
+                tool_name: 'Write',
+                tool_input: { path: '../../outside.txt', contents: 'hi' },
+            },
+            permission: 'deny',
+            reason: 'outside_repo_mutation',
+        },
     ],
 };

package/dist/conformance/types.d.ts

@@ -3,4 +3,6 @@ export interface LayerConformanceScenario {
     command: string;
     permission: 'allow' | 'deny';
     reason?: string;
+    kind?: 'shell' | 'tool';
+    toolPayload?: Record<string, unknown>;
 }

package/dist/core/approval-replay-cli.d.ts

@@ -0,0 +1,7 @@
+export declare const DEFAULT_CLI_REPLAY_TIMEOUT_MS = 300000;
+export declare function replayShellCommand(command: string, cwd: string, timeoutMs?: number): Promise<{
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+    timedOut?: boolean;
+}>;

package/dist/core/approval-replay-cli.js

@@ -0,0 +1,36 @@
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+export const DEFAULT_CLI_REPLAY_TIMEOUT_MS = 300_000;
+export async function replayShellCommand(command, cwd, timeoutMs = DEFAULT_CLI_REPLAY_TIMEOUT_MS) {
+    const resolvedCwd = path.resolve(cwd);
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, {
+            cwd: resolvedCwd,
+            shell: true,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: { ...process.env },
+        });
+        const stdout = [];
+        const stderr = [];
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill('SIGTERM');
+        }, timeoutMs);
+        child.stdout?.on('data', (chunk) => stdout.push(Buffer.from(chunk)));
+        child.stderr?.on('data', (chunk) => stderr.push(Buffer.from(chunk)));
+        child.on('error', (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            resolve({
+                exitCode: timedOut ? 124 : (code ?? 1),
+                stdout: Buffer.concat(stdout).toString('utf8'),
+                stderr: Buffer.concat(stderr).toString('utf8'),
+                ...(timedOut ? { timedOut: true } : {}),
+            });
+        });
+    });
+}

package/dist/core/approval-replay.d.ts

@@ -0,0 +1,45 @@
+import type { ApprovalFlow, BelayConfigV4 } from './config.js';
+import type { ApprovalRecord } from './types.js';
+export type { ApprovalFlow } from './config.js';
+export type ReplayAdapterId = 'cursor' | 'claude' | 'codex';
+export { DEFAULT_CLI_REPLAY_TIMEOUT_MS, replayShellCommand } from './approval-replay-cli.js';
+export interface ApprovalReplayHint {
+    kind: 'shell' | 'tool' | 'subagent';
+    input: string;
+    cwd?: string;
+    toolName?: string;
+    fingerprint: string;
+    approvalId: string;
+    autoReplay: boolean;
+    fallbackToTwoStep: boolean;
+}
+export interface ReplayEnvelopeInput {
+    kind: ApprovalRecord['kind'];
+    cwd?: string;
+    toolName?: string;
+    command?: string;
+    input?: string;
+    inputKind?: 'shell' | 'tool' | 'subagent';
+    payload?: Record<string, unknown>;
+    fingerprint: string;
+    repoRoot: string;
+}
+export interface ReplayActionContext {
+    kind: ApprovalRecord['kind'];
+    cwd?: string;
+    toolName?: string;
+    command?: string;
+    payload?: Record<string, unknown>;
+    fingerprint: string;
+    repoRoot: string;
+}
+export declare function replayPayloadHash(kind: ApprovalRecord['kind'], payload: Record<string, unknown> | undefined, repoRoot: string): string | undefined;
+export declare function getExecutionLeaseMs(config: BelayConfigV4): number;
+export declare function approvalFlow(config: BelayConfigV4): ApprovalFlow;
+export declare function buildReplayEnvelopeFields(input: ReplayEnvelopeInput): Partial<ApprovalRecord>;
+export declare function hasReplayEnvelope(approval: ApprovalRecord): boolean;
+export declare function validateReplayEnvelope(approval: ApprovalRecord, action: ReplayActionContext): boolean;
+export declare function canAutoReplay(config: BelayConfigV4, kind: ApprovalRecord['kind'], adapter?: ReplayAdapterId): boolean;
+export declare function buildRetryInstructionForConfig(config: BelayConfigV4, tokenPrefix: string, approvalId: string): string;
+export declare function buildApprovalRecordedMessage(config: BelayConfigV4, approval: ApprovalRecord, adapter?: ReplayAdapterId): string;
+export declare function buildReplayHint(config: BelayConfigV4, approval: ApprovalRecord, adapter?: ReplayAdapterId): ApprovalReplayHint | null;