@guilz-dev/belay 0.9.2 → 0.9.4

package/dist/installer/runtime-artifacts.js

@@ -1,23 +1,53 @@
-import { chmod, mkdir, writeFile } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
+import { chmod, mkdir, realpath, rename, rm, writeFile } from 'node:fs/promises';
 import path from 'node:path';
-import { buildRunnerScript, buildWindowsRunnerScript } from '../node-resolution.js';
-import { renderAuditHook, renderBeforeSubmitHook, renderRuntimeCore, renderShellGateHook, renderToolGateHook, } from '../templates.js';
+import { buildRunnerScript, buildWindowsPowerShellRunnerScript, buildWindowsRunnerScript, } from '../node-resolution.js';
+import { renderAuditHook, renderBeforeSubmitHook, renderCursorDispatcher, renderRuntimeCore, renderShellGateHook, renderToolGateHook, } from '../templates.js';
 async function writeFileMaybeExecutable(filePath, content, executable = false) {
     await mkdir(path.dirname(filePath), { recursive: true });
-    await writeFile(filePath, content, 'utf8');
-    if (executable) {
-        await chmod(filePath, 0o755);
+    const temporaryPath = path.join(path.dirname(filePath), `.${path.basename(filePath)}.${process.pid}.${randomUUID()}.tmp`);
+    try {
+        await writeFile(temporaryPath, content, { encoding: 'utf8', flag: 'wx' });
+        if (executable) {
+            await chmod(temporaryPath, 0o755);
+        }
+        await rename(temporaryPath, filePath);
+    }
+    finally {
+        await rm(temporaryPath, { force: true });
     }
 }
 export async function writeRuntimeArtifacts(adapterName, paths) {
     const { hooksDir, runtimeDir } = paths;
+    const cursorOrigin = adapterName === 'cursor'
+        ? paths.scope === 'global'
+            ? { scope: 'global' }
+            : { scope: 'project', repoRoot: await realpath(paths.repoRoot) }
+        : undefined;
+    const artifacts = {
+        auditHook: renderAuditHook(adapterName, cursorOrigin),
+        beforeSubmitHook: renderBeforeSubmitHook(adapterName, cursorOrigin),
+        core: await renderRuntimeCore(adapterName),
+        dispatcher: adapterName === 'cursor' ? await renderCursorDispatcher() : undefined,
+        runner: buildRunnerScript(process.execPath),
+        runnerCmd: buildWindowsRunnerScript(process.execPath),
+        runnerPowerShell: adapterName === 'cursor' ? buildWindowsPowerShellRunnerScript(process.execPath) : undefined,
+        shellGateHook: renderShellGateHook(adapterName, cursorOrigin),
+        toolGateHook: renderToolGateHook(adapterName, cursorOrigin),
+    };
     await mkdir(hooksDir, { recursive: true });
     await mkdir(runtimeDir, { recursive: true });
-    await writeFileMaybeExecutable(path.join(hooksDir, 'belay-before-submit.mjs'), renderBeforeSubmitHook());
-    await writeFileMaybeExecutable(path.join(hooksDir, 'belay-shell-gate.mjs'), renderShellGateHook());
-    await writeFileMaybeExecutable(path.join(hooksDir, 'belay-tool-gate.mjs'), renderToolGateHook());
-    await writeFileMaybeExecutable(path.join(hooksDir, 'belay-audit.mjs'), renderAuditHook());
-    await writeFileMaybeExecutable(path.join(runtimeDir, 'core.mjs'), await renderRuntimeCore(adapterName));
-    await writeFileMaybeExecutable(path.join(hooksDir, 'belay-runner'), buildRunnerScript(process.execPath), true);
-    await writeFileMaybeExecutable(path.join(hooksDir, 'belay-runner.cmd'), buildWindowsRunnerScript(process.execPath));
+    await writeFileMaybeExecutable(path.join(runtimeDir, 'core.mjs'), artifacts.core);
+    if (artifacts.dispatcher !== undefined) {
+        await writeFileMaybeExecutable(path.join(runtimeDir, 'dispatcher.mjs'), artifacts.dispatcher);
+    }
+    await writeFileMaybeExecutable(path.join(hooksDir, 'belay-runner'), artifacts.runner, true);
+    await writeFileMaybeExecutable(path.join(hooksDir, 'belay-runner.cmd'), artifacts.runnerCmd);
+    if (artifacts.runnerPowerShell !== undefined) {
+        await writeFileMaybeExecutable(path.join(hooksDir, 'belay-runner.ps1'), artifacts.runnerPowerShell);
+    }
+    await writeFileMaybeExecutable(path.join(hooksDir, 'belay-before-submit.mjs'), artifacts.beforeSubmitHook);
+    await writeFileMaybeExecutable(path.join(hooksDir, 'belay-shell-gate.mjs'), artifacts.shellGateHook);
+    await writeFileMaybeExecutable(path.join(hooksDir, 'belay-tool-gate.mjs'), artifacts.toolGateHook);
+    await writeFileMaybeExecutable(path.join(hooksDir, 'belay-audit.mjs'), artifacts.auditHook);
 }

package/dist/installer/scope-config.d.ts

@@ -1,8 +1,8 @@
 import { type ScopedPaths } from '../adapters/layouts/scope.js';
 import type { AdapterName } from '../adapters/layouts/types.js';
 import type { BelayConfigV4 } from '../core/config.js';
-import type { InitOptions, UpgradeOptions } from '../types.js';
+import type { InitOptions, UninstallOptions, UpgradeOptions } from '../types.js';
 export type OperationScope = 'project' | 'global';
-export declare function resolveOperationScope(repoRoot: string, adapter: AdapterName, options?: InitOptions | UpgradeOptions): Promise<OperationScope>;
+export declare function resolveOperationScope(repoRoot: string, adapter: AdapterName, options?: InitOptions | UpgradeOptions | UninstallOptions): Promise<OperationScope>;
 export declare function applyInstallScope(repoRoot: string, adapter: AdapterName, scope: OperationScope, config?: BelayConfigV4): Promise<BelayConfigV4>;
 export declare function pathsForOperation(adapter: AdapterName, scope: OperationScope, repoRoot: string): ScopedPaths;

package/dist/installer.d.ts

@@ -1,5 +1,5 @@
 import type { AdapterName } from './adapters/layouts/types.js';
-import type { HooksFile, InitOptions, UpgradeOptions } from './types.js';
+import type { HooksFile, InitOptions, UninstallOptions, UpgradeOptions } from './types.js';
 export type { InstallScope } from './adapters/layouts/scope.js';
 export declare function loadHooksFile(hooksPath: string): Promise<HooksFile>;
 export declare function mergeHooksFile(current: HooksFile, platform?: NodeJS.Platform, hooksDir?: string, repoRoot?: string): HooksFile;
@@ -10,6 +10,10 @@ export declare function initCursorProject(options?: InitOptions): Promise<{
 export declare function upgradeCursorProject(options?: UpgradeOptions): Promise<{
     repoRoot: string;
 }>;
+export declare function uninstallCursorProject(options?: UninstallOptions): Promise<{
+    repoRoot: string;
+    scope: 'project' | 'global';
+}>;
 export declare function initProject(options?: InitOptions): Promise<{
     repoRoot: string;
     withSkill: boolean;
@@ -20,3 +24,8 @@ export declare function upgradeProject(options?: UpgradeOptions): Promise<{
     repoRoot: string;
     adapter: AdapterName;
 }>;
+export declare function uninstallProject(options?: UninstallOptions): Promise<{
+    repoRoot: string;
+    adapter: AdapterName;
+    scope: 'project' | 'global';
+}>;

package/dist/installer.js

@@ -1,7 +1,7 @@
 import { existsSync } from 'node:fs';
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
 import path from 'node:path';
-import { mergeCursorHooksFile } from './adapters/cursor/hooks.js';
+import { hasManagedCursorHookEntries, mergeCursorHooksFile, stripCursorHooksFile, } from './adapters/cursor/hooks.js';
 import { cursorLayout } from './adapters/layouts/cursor.js';
 import { resolveScopedPaths } from './adapters/layouts/scope.js';
 import { getAdapter } from './adapters/registry.js';
@@ -13,7 +13,7 @@ import { isFreshConfigInput, mergeConfig, normalizeConfig, } from './core/config
 import { runtimeIntegrityFiles, writeIntegrityManifest } from './core/integrity.js';
 import { hasValidCloudConsent, isCloudJudgeConfig, migrateImplicitLocalJudgeIfNeeded, resolveInitJudgeConfig, } from './core/judge-config.js';
 import { resolveJudgeTransport } from './core/judge-runtime-detection.js';
-import { bootstrapStateFiles, writeSkillArtifacts } from './installer/bootstrap.js';
+import { bootstrapStateFiles, CURSOR_COMMAND_ARTIFACTS, writeSkillArtifacts, } from './installer/bootstrap.js';
 import { writeRuntimeArtifacts } from './installer/runtime-artifacts.js';
 import { applyInstallScope, resolveOperationScope } from './installer/scope-config.js';
 import { applyConfigPreset } from './presets.js';
@@ -64,7 +64,6 @@ export async function initCursorProject(options = {}) {
     const mergedHooks = mergeCursorHooksFile(hooksFile, process.platform, paths.hooksDir, repoRoot);
     await ensureDir(paths.hooksDir);
     const config = await mergeAndWriteConfig(repoRoot, 'cursor');
-    await applyInstallScope(repoRoot, 'cursor', scope, config);
     await writeRuntimeArtifacts('cursor', paths);
     await bootstrapStateFiles(repoRoot, config, paths);
     if (withSkill) {
@@ -72,8 +71,12 @@ export async function initCursorProject(options = {}) {
     }
     await mkdir(path.dirname(paths.hooksSettingsPath), { recursive: true });
     await writeFile(paths.hooksSettingsPath, `${JSON.stringify(mergedHooks, null, 2)}\n`, 'utf8');
+    const installedConfig = await applyInstallScope(repoRoot, 'cursor', scope, config);
+    if (scope === 'global') {
+        await cleanupStaleProjectCursorInstall(repoRoot);
+    }
     await writeIntegrityManifest(repoRoot, cursorLayout, runtimeIntegrityFiles(cursorLayout, paths));
-    await archiveLegacyAuditLogIfNeeded(repoRoot, config);
+    await archiveLegacyAuditLogIfNeeded(repoRoot, installedConfig);
     return { repoRoot, withSkill };
 }
 export async function upgradeCursorProject(options = {}) {
@@ -81,19 +84,83 @@ export async function upgradeCursorProject(options = {}) {
     const scope = await resolveOperationScope(repoRoot, 'cursor', options);
     const paths = resolveScopedPaths(cursorLayout, scope, repoRoot);
     const config = await mergeAndWriteConfig(repoRoot, 'cursor');
-    await applyInstallScope(repoRoot, 'cursor', scope, config);
     await writeRuntimeArtifacts('cursor', paths);
     const hooksFile = await loadHooksFile(paths.hooksSettingsPath);
     const merged = mergeCursorHooksFile(hooksFile, process.platform, paths.hooksDir, repoRoot);
     await mkdir(path.dirname(paths.hooksSettingsPath), { recursive: true });
     await writeFile(paths.hooksSettingsPath, `${JSON.stringify(merged, null, 2)}\n`, 'utf8');
+    if (scope === 'project') {
+        const globalPaths = resolveScopedPaths(cursorLayout, 'global', repoRoot);
+        if (existsSync(globalPaths.hooksSettingsPath)) {
+            const globalHooks = await loadHooksFile(globalPaths.hooksSettingsPath);
+            if (hasManagedCursorHookEntries(globalHooks, process.platform, globalPaths.hooksDir, repoRoot)) {
+                await writeRuntimeArtifacts('cursor', globalPaths);
+                const mergedGlobal = mergeCursorHooksFile(globalHooks, process.platform, globalPaths.hooksDir, repoRoot);
+                await writeFile(globalPaths.hooksSettingsPath, `${JSON.stringify(mergedGlobal, null, 2)}\n`, 'utf8');
+            }
+        }
+    }
     if (options.withSkill) {
         await writeSkillArtifacts('cursor', paths);
     }
+    const installedConfig = await applyInstallScope(repoRoot, 'cursor', scope, config);
+    if (scope === 'global') {
+        await cleanupStaleProjectCursorInstall(repoRoot);
+    }
     await writeIntegrityManifest(repoRoot, cursorLayout, runtimeIntegrityFiles(cursorLayout, paths));
-    await archiveLegacyAuditLogIfNeeded(repoRoot, config);
+    await archiveLegacyAuditLogIfNeeded(repoRoot, installedConfig);
     return { repoRoot };
 }
+const BELAY_HOOK_ARTIFACTS = [
+    'belay-before-submit.mjs',
+    'belay-shell-gate.mjs',
+    'belay-tool-gate.mjs',
+    'belay-audit.mjs',
+    'belay-runner',
+    'belay-runner.cmd',
+    'belay-runner.ps1',
+];
+async function removeBelayHookArtifacts(paths) {
+    for (const fileName of BELAY_HOOK_ARTIFACTS) {
+        await rm(path.join(paths.hooksDir, fileName), { force: true });
+    }
+    for (const fileName of ['core.mjs', 'dispatcher.mjs']) {
+        await rm(path.join(paths.runtimeDir, fileName), { force: true });
+    }
+    await rm(path.join(paths.skillsDir, 'SKILL.md'), { force: true });
+    if (paths.commandsDir) {
+        for (const fileName of CURSOR_COMMAND_ARTIFACTS) {
+            await rm(path.join(paths.commandsDir, fileName), { force: true });
+        }
+    }
+}
+async function cleanupStaleProjectCursorInstall(repoRoot) {
+    const projectPaths = resolveScopedPaths(cursorLayout, 'project', repoRoot);
+    if (!existsSync(projectPaths.hooksSettingsPath)) {
+        return;
+    }
+    const projectHooks = await loadHooksFile(projectPaths.hooksSettingsPath);
+    if (!hasManagedCursorHookEntries(projectHooks, process.platform, projectPaths.hooksDir, repoRoot)) {
+        return;
+    }
+    const stripped = stripCursorHooksFile(projectHooks, process.platform, projectPaths.hooksDir, repoRoot);
+    await writeFile(projectPaths.hooksSettingsPath, `${JSON.stringify(stripped, null, 2)}\n`, 'utf8');
+    await removeBelayHookArtifacts(projectPaths);
+}
+export async function uninstallCursorProject(options = {}) {
+    const repoRoot = path.resolve(options.targetDir ?? process.cwd());
+    const scope = await resolveOperationScope(repoRoot, 'cursor', options);
+    const paths = resolveScopedPaths(cursorLayout, scope, repoRoot);
+    const hooksSettingsExisted = existsSync(paths.hooksSettingsPath);
+    const hooksFile = await loadHooksFile(paths.hooksSettingsPath);
+    const stripped = stripCursorHooksFile(hooksFile, process.platform, paths.hooksDir, repoRoot);
+    if (hooksSettingsExisted) {
+        await mkdir(path.dirname(paths.hooksSettingsPath), { recursive: true });
+        await writeFile(paths.hooksSettingsPath, `${JSON.stringify(stripped, null, 2)}\n`, 'utf8');
+    }
+    await removeBelayHookArtifacts(paths);
+    return { repoRoot, scope };
+}
 function resolveAdapterName(options, repoRoot) {
     if (options.adapter === 'claude') {
         return 'claude';
@@ -225,3 +292,12 @@ export async function upgradeProject(options = {}) {
     await refreshIntegrityManifest(repoRoot, adapterName);
     return { repoRoot, adapter: adapterName };
 }
+export async function uninstallProject(options = {}) {
+    const repoRoot = path.resolve(options.targetDir ?? process.cwd());
+    const adapterName = resolveAdapterName(options, repoRoot);
+    if (adapterName !== 'cursor') {
+        throw new Error(`belay uninstall is only supported for Cursor adapter today. Use --adapter cursor or uninstall hooks manually for ${adapterName}.`);
+    }
+    const result = await uninstallCursorProject({ ...options, targetDir: repoRoot });
+    return { repoRoot: result.repoRoot, adapter: adapterName, scope: result.scope };
+}

package/dist/node-resolution.d.ts

@@ -6,3 +6,4 @@ export interface NodeResolutionResult {
 export declare function resolveNodeBinary(): NodeResolutionResult;
 export declare function buildRunnerScript(defaultNodePath: string): string;
 export declare function buildWindowsRunnerScript(defaultNodePath: string): string;
+export declare function buildWindowsPowerShellRunnerScript(defaultNodePath: string): string;

package/dist/node-resolution.js

@@ -235,3 +235,64 @@ echo {}
 exit /b 0
 `;
 }
+export function buildWindowsPowerShellRunnerScript(defaultNodePath) {
+    const encodedDefault = Buffer.from(defaultNodePath, 'utf8').toString('base64');
+    return `$ErrorActionPreference = 'Stop'
+
+$DefaultNode = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${encodedDefault}'))
+$HookName = if ($args.Count -gt 0) { [string] $args[0] } else { '' }
+$HookArguments = if ($args.Count -gt 1) { @($args[1..($args.Count - 1)]) } else { @() }
+
+function Resolve-Node {
+  if ($DefaultNode -and (Test-Path -LiteralPath $DefaultNode -PathType Leaf)) {
+    return $DefaultNode
+  }
+
+  $PathNode = Get-Command node.exe -CommandType Application -ErrorAction SilentlyContinue
+  if ($null -ne $PathNode) {
+    return $PathNode.Source
+  }
+
+  if ($env:USERPROFILE) {
+    $NvmRoot = Join-Path $env:USERPROFILE '.nvm'
+    if (Test-Path -LiteralPath $NvmRoot -PathType Container) {
+      foreach ($VersionDirectory in Get-ChildItem -LiteralPath $NvmRoot -Directory | Sort-Object Name -Descending) {
+        $Candidate = Join-Path $VersionDirectory.FullName 'node.exe'
+        if (Test-Path -LiteralPath $Candidate -PathType Leaf) {
+          return $Candidate
+        }
+      }
+    }
+  }
+
+  return $null
+}
+
+function Fail-Audit {
+  [Console]::Error.WriteLine('belay: unable to resolve Node for audit hook')
+  [Console]::Out.WriteLine('{}')
+  exit 0
+}
+
+if (-not $HookName) {
+  Fail-Audit
+}
+
+$NodeBin = Resolve-Node
+if (-not $NodeBin) {
+  if ($HookName -eq 'belay-before-submit') {
+    [Console]::Out.WriteLine('{"continue":false,"user_message":"belay could not resolve Node. Install or expose Node, run belay doctor, then retry."}')
+    exit 0
+  }
+  if ($HookName -in @('belay-shell-gate', 'belay-tool-gate')) {
+    [Console]::Out.WriteLine('{"permission":"deny","user_message":"belay could not resolve Node. Install or expose Node, run belay doctor, then retry."}')
+    exit 0
+  }
+  Fail-Audit
+}
+
+$ScriptPath = Join-Path $PSScriptRoot "$HookName.mjs"
+& $NodeBin $ScriptPath @HookArguments
+exit $LASTEXITCODE
+`;
+}

package/dist/templates.d.ts

@@ -1,7 +1,10 @@
+import type { CursorHookOrigin } from './adapters/cursor/hook-router.js';
+import type { AdapterName } from './adapters/layouts/types.js';
 import type { BelayConfigV3 } from './core/config.js';
 export declare function renderConfig(config: BelayConfigV3): string;
-export declare function renderBeforeSubmitHook(): string;
-export declare function renderShellGateHook(): string;
-export declare function renderToolGateHook(): string;
-export declare function renderAuditHook(): string;
+export declare function renderBeforeSubmitHook(adapter: AdapterName, cursorOrigin?: CursorHookOrigin): string;
+export declare function renderShellGateHook(adapter: AdapterName, cursorOrigin?: CursorHookOrigin): string;
+export declare function renderToolGateHook(adapter: AdapterName, cursorOrigin?: CursorHookOrigin): string;
+export declare function renderAuditHook(adapter: AdapterName, cursorOrigin?: CursorHookOrigin): string;
+export declare function renderCursorDispatcher(): Promise<string>;
 export declare function renderRuntimeCore(adapter?: 'cursor' | 'claude' | 'codex'): Promise<string>;

package/dist/templates.js

@@ -1,6 +1,7 @@
 import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { CURSOR_DISPATCHER_GENERATION_HEADER } from './adapters/cursor/dispatcher-generation.js';
 import { hashValue } from './core/fingerprint.js';
 import { PACKAGE_VERSION } from './version.js';
 function inlineJson(value) {
@@ -9,26 +10,54 @@ function inlineJson(value) {
 export function renderConfig(config) {
     return `${inlineJson(config)}\n`;
 }
-export function renderBeforeSubmitHook() {
+function requireCursorOrigin(origin) {
+    if (!origin) {
+        throw new Error('Cursor hook origin is required when rendering dispatcher shims.');
+    }
+    return origin;
+}
+function renderCursorDispatchHook(origin, kind, eventName) {
+    return `import { dispatchCursorHook } from '../belay/runtime/dispatcher.mjs'
+
+await dispatchCursorHook({
+  origin: ${JSON.stringify(origin)},
+  kind: ${JSON.stringify(kind)},
+  eventName: ${eventName},
+})
+`;
+}
+export function renderBeforeSubmitHook(adapter, cursorOrigin) {
+    if (adapter === 'cursor') {
+        return renderCursorDispatchHook(requireCursorOrigin(cursorOrigin), 'before-submit', JSON.stringify('beforeSubmitPrompt'));
+    }
     return `import { runBeforeSubmitPromptHook } from '../belay/runtime/core.mjs'
 
 await runBeforeSubmitPromptHook()
 `;
 }
-export function renderShellGateHook() {
+export function renderShellGateHook(adapter, cursorOrigin) {
+    if (adapter === 'cursor') {
+        return renderCursorDispatchHook(requireCursorOrigin(cursorOrigin), 'shell-gate', JSON.stringify('beforeShellExecution'));
+    }
     return `import { runShellGateHook } from '../belay/runtime/core.mjs'
 
 await runShellGateHook()
 `;
 }
-export function renderToolGateHook() {
+export function renderToolGateHook(adapter, cursorOrigin) {
+    if (adapter === 'cursor') {
+        return renderCursorDispatchHook(requireCursorOrigin(cursorOrigin), 'tool-gate', "process.argv[2] ?? 'preToolUse'");
+    }
     return `import { runToolGateHook } from '../belay/runtime/core.mjs'
 
 const eventName = process.argv[2] ?? 'preToolUse'
 await runToolGateHook(eventName)
 `;
 }
-export function renderAuditHook() {
+export function renderAuditHook(adapter, cursorOrigin) {
+    if (adapter === 'cursor') {
+        return renderCursorDispatchHook(requireCursorOrigin(cursorOrigin), 'audit', "process.argv[2] ?? 'postToolUse'");
+    }
     return `import { runAuditHook } from '../belay/runtime/core.mjs'
 
 const eventName = process.argv[2] ?? 'postToolUse'
@@ -44,6 +73,15 @@ async function readRuntimeBundle(adapter = 'cursor') {
         throw new Error('Runtime bundle missing. Run pnpm build before belay init or upgrade.');
     }
 }
+export async function renderCursorDispatcher() {
+    const bundlePath = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'dist', 'bundle', 'cursor-dispatcher.mjs');
+    try {
+        return `${CURSOR_DISPATCHER_GENERATION_HEADER}${await readFile(bundlePath, 'utf8')}`;
+    }
+    catch {
+        throw new Error('Runtime bundle missing. Run pnpm build before belay init or upgrade.');
+    }
+}
 export async function renderRuntimeCore(adapter = 'cursor') {
     const bundle = await readRuntimeBundle(adapter);
     const withoutStamp = bundle

package/dist/types.d.ts

@@ -1,12 +1,13 @@
 export type { BelayConfig, BelayConfigV1, BelayConfigV2, BelayConfigV3, BelayControlPlaneConfig, BelayEgressConfig, BelayOverridesConfig, BelayPolicyConfig, BelayRedactionConfig, BelaySandboxConfig, BelayTransactionalConfig, UnknownLocalEffectPolicy, } from './core/config.js';
 export type { ApprovalRecord, ApprovalStateFile, Assessment, BelayMode, ClassifyResult, HookVerdict, } from './core/types.js';
 import type { InstallScope } from './adapters/layouts/scope.js';
-import type { RecentAskEntry } from './core/audit-summary.js';
+import type { RecentAskEntry, RecentHostDenialEntry } from './core/audit-summary.js';
 import type { BelayEgressConfig, BelayOverridesConfig, BelayPolicyConfig, BelaySandboxConfig } from './core/config.js';
 import type { ApprovalRecord, ClassifyResult } from './core/types.js';
 export interface HookEntry {
     command: string;
     matcher?: string;
+    failClosed?: boolean;
 }
 export interface HooksFile {
     version: number;
@@ -42,6 +43,32 @@ export interface UpgradeOptions {
     /** Opt-in: migrate implicit factory-default ollama judge to host default provider. */
     migrateJudgeDefault?: boolean;
 }
+export interface UninstallOptions {
+    targetDir?: string;
+    adapter?: AdapterName;
+    scope?: InstallScope;
+}
+export interface WhereOptions {
+    targetDir?: string;
+    adapter?: AdapterName;
+    scope?: InstallScope;
+    json?: boolean;
+}
+export interface WhereReport {
+    cwd: string;
+    repoRoot: string;
+    adapter: AdapterName;
+    installScope: 'project' | 'global';
+    configPresent: boolean;
+    cliExecutable?: string;
+    cliPackageRoot: string;
+    configPath: string;
+    hooksSettingsPath: string;
+    hooksDir: string;
+    runtimeDir: string;
+    skillsDir: string;
+    commandsDir?: string;
+}
 export interface DoctorOptions {
     targetDir?: string;
     fix?: boolean;
@@ -88,6 +115,10 @@ export interface StatusOptions {
 export interface HealthSnapshotOptions {
     targetDir?: string;
     adapter?: AdapterName;
+    /** Override the host home directory when inspecting adapter-level execution settings. */
+    homeDir?: string;
+    /** Override Cursor config-path environment variables for deterministic host inspection. */
+    cursorConfigEnv?: Partial<Pick<NodeJS.ProcessEnv, 'CURSOR_CONFIG_DIR' | 'XDG_CONFIG_HOME'>>;
 }
 export interface HealthSnapshot {
     repoRoot: string;
@@ -172,6 +203,9 @@ export interface AuditVisibilityReport {
     allowCount: number;
     silentPassRate: number;
     recentAsks: RecentAskEntry[];
+    hostDeniedAfterAllowCount?: number;
+    recentHostDenials?: RecentHostDenialEntry[];
+    unrecognizedHostFailureCount?: number;
     warnings: string[];
     notes: string[];
 }

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const PACKAGE_VERSION = "0.9.2";
+export declare const PACKAGE_VERSION = "0.9.4";

package/dist/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@guilz-dev/belay",
-  "version": "0.9.2",
+  "version": "0.9.4",
   "description": "Belay-style approval and audit gating for agent runtimes.",
   "type": "module",
   "license": "MIT",
@@ -57,10 +57,13 @@
     "typecheck": "tsc --noEmit",
     "test": "pnpm build && vitest run",
     "test:structural": "pnpm build && vitest run src/__tests__/verdict/structural-suite.test.ts",
-    "test:docker": "pnpm build && vitest run src/__tests__/capability/boundary-container-isolation.test.ts src/__tests__/capability/boundary-driver-container.test.ts",
+    "test:docker": "pnpm build && vitest run --config vitest.live.config.ts src/__tests__/capability/boundary-container-isolation.test.ts src/__tests__/capability/boundary-container-workspace-mount.test.ts src/__tests__/capability/boundary-driver-container.test.ts src/__tests__/contained-execution-docker.integration.test.ts",
+    "test:llm": "pnpm build && vitest run --config vitest.live.config.ts src/__tests__/verdict/llm/judge-accuracy.test.ts",
     "test:stable": "pnpm build && vitest run && vitest run && vitest run",
     "corpus": "pnpm build && node scripts/corpus.mjs",
     "probe:adversarial": "pnpm build && node scripts/adversarial-probe.mjs",
+    "probe:cursor-shell-rewrite": "node scripts/cursor-shell-rewrite-probe.mjs",
+    "probe:native-seatbelt-boundary": "node scripts/native-seatbelt-boundary-probe.mjs --live",
     "probe:coverage": "pnpm build && node scripts/coverage-probe.mjs",
     "probe:coverage:repeat": "pnpm build && node scripts/coverage-probe.mjs --repeat 3",
     "corpus:ratchet": "pnpm build && node scripts/corpus-ratchet.mjs"

package/skills/belay/SKILL.md

@@ -54,6 +54,11 @@ To restore the legacy two-step UX (approve, then always retry manually), set
 For why it was blocked, use `/belay why <command>` or `belay explain --command "<command>"`.
 For the latest pending ask, use `/belay explain` or `belay explain`.
 
+If `belay status` or `belay report` shows `Host denied after Belay allow`, the denial came from
+the editor/agent host after Belay returned allow. There is no Belay approval ID to approve. Keep
+host protection in Belay audit mode and approve only the exact host prompt when execution is
+intended.
+
 **Do not use command allowlists** (`overrides.allow`) or legacy standing-allow records
 (shell, tool, or subagent) to fix blocks; none of them change runtime authorization.
 Improve EffectPlan semantics, approve once with `/belay-approve`, or use an exact

package/skills/belay/belay-report.md

@@ -1,7 +1,10 @@
-Show audit visibility: ask/flag/allow counts, silent-pass rate, and recent asks.
+Show audit visibility: ask/flag/allow counts, silent-pass rate, recent asks, and host
+`permission_denied` failures correlated to a preceding Belay allow.
 
 ```bash
 belay report
 ```
 
 For full install health plus audit summary, use `belay status`.
+
+`Host denied after Belay allow` is host-policy telemetry, not a pending Belay approval.