@guilz-dev/belay 0.9.3 → 0.10.0

package/dist/defaults.js

@@ -1,62 +1,42 @@
 import path from 'node:path';
 import { cursorLayout } from './adapters/layouts/cursor.js';
-import { buildRunnerInvocation } from './adapters/layouts/scope.js';
+import { buildAbsoluteRunnerInvocation, buildLegacyAbsoluteRunnerInvocation, buildLegacyBarePowerShellRunnerInvocation, buildLegacyQuotedAbsoluteRunnerInvocation, buildRunnerInvocation, } from './adapters/layouts/scope.js';
 import { DEFAULT_CONFIG_V3 } from './core/config.js';
 export { PACKAGE_NAME } from './branding.js';
 export const DEFAULT_CONFIG = DEFAULT_CONFIG_V3;
-function runnerCommand(platform, hooksDir, repoRoot, hookScript, ...args) {
-    return buildRunnerInvocation(platform, hooksDir, repoRoot, hookScript, ...args);
+function runnerCommand(platform, hooksDir, _repoRoot, hookScript, runnerPathMode, ...args) {
+    if (runnerPathMode === 'absolute') {
+        return buildAbsoluteRunnerInvocation(platform, hooksDir, hookScript, ...args);
+    }
+    if (runnerPathMode === 'legacy-absolute') {
+        return buildLegacyAbsoluteRunnerInvocation(platform, hooksDir, hookScript, ...args);
+    }
+    if (runnerPathMode === 'legacy-quoted-absolute') {
+        return buildLegacyQuotedAbsoluteRunnerInvocation(platform, hooksDir, hookScript, ...args);
+    }
+    if (runnerPathMode === 'legacy-bare-powershell-absolute') {
+        return buildLegacyBarePowerShellRunnerInvocation(platform, hooksDir, hookScript, ...args);
+    }
+    return buildRunnerInvocation(platform, hooksDir, _repoRoot, hookScript, ...args);
 }
-export function getManagedHookEntries(platform = process.platform, hooksDir, repoRoot) {
+export function getManagedHookEntries(platform = process.platform, hooksDir, repoRoot, runnerPathMode = 'absolute') {
     const resolvedRepo = path.resolve(repoRoot ?? process.cwd());
     const resolvedHooksDir = hooksDir ?? cursorLayout.hooksDir(resolvedRepo);
-    const toolGate = runnerCommand(platform, resolvedHooksDir, resolvedRepo, 'belay-tool-gate', 'preToolUse');
-    const subagentGate = runnerCommand(platform, resolvedHooksDir, resolvedRepo, 'belay-tool-gate', 'subagentStart');
-    return [
+    const toolGate = runnerCommand(platform, resolvedHooksDir, resolvedRepo, 'belay-tool-gate', runnerPathMode, 'preToolUse');
+    const subagentGate = runnerCommand(platform, resolvedHooksDir, resolvedRepo, 'belay-tool-gate', runnerPathMode, 'subagentStart');
+    const entries = [
         {
             event: 'beforeSubmitPrompt',
             definition: {
-                command: runnerCommand(platform, resolvedHooksDir, resolvedRepo, 'belay-before-submit'),
+                command: runnerCommand(platform, resolvedHooksDir, resolvedRepo, 'belay-before-submit', runnerPathMode),
                 placement: 'prepend',
             },
         },
         {
             event: 'beforeShellExecution',
             definition: {
-                command: runnerCommand(platform, resolvedHooksDir, resolvedRepo, 'belay-shell-gate'),
-                placement: 'prepend',
-            },
-        },
-        {
-            event: 'preToolUse',
-            definition: {
-                command: toolGate,
-                placement: 'prepend',
-                matcher: 'Task',
-            },
-        },
-        {
-            event: 'preToolUse',
-            definition: {
-                command: toolGate,
-                placement: 'prepend',
-                matcher: 'Write',
-            },
-        },
-        {
-            event: 'preToolUse',
-            definition: {
-                command: toolGate,
-                placement: 'prepend',
-                matcher: 'StrReplace',
-            },
-        },
-        {
-            event: 'preToolUse',
-            definition: {
-                command: toolGate,
+                command: runnerCommand(platform, resolvedHooksDir, resolvedRepo, 'belay-shell-gate', runnerPathMode),
                 placement: 'prepend',
-                matcher: 'Delete',
             },
         },
         {
@@ -64,8 +44,6 @@ export function getManagedHookEntries(platform = process.platform, hooksDir, rep
             definition: {
                 command: toolGate,
                 placement: 'prepend',
-                // Agent Shell tool (preToolUse) — distinct from terminal beforeShellExecution.
-                matcher: 'Shell',
             },
         },
         {
@@ -119,32 +97,36 @@ export function getManagedHookEntries(platform = process.platform, hooksDir, rep
         {
             event: 'postToolUse',
             definition: {
-                command: runnerCommand(platform, resolvedHooksDir, resolvedRepo, 'belay-audit', 'postToolUse'),
+                command: runnerCommand(platform, resolvedHooksDir, resolvedRepo, 'belay-audit', runnerPathMode, 'postToolUse'),
                 placement: 'append',
             },
         },
         {
             event: 'postToolUseFailure',
             definition: {
-                command: runnerCommand(platform, resolvedHooksDir, resolvedRepo, 'belay-audit', 'postToolUseFailure'),
+                command: runnerCommand(platform, resolvedHooksDir, resolvedRepo, 'belay-audit', runnerPathMode, 'postToolUseFailure'),
                 placement: 'append',
             },
         },
         {
             event: 'stop',
             definition: {
-                command: runnerCommand(platform, resolvedHooksDir, resolvedRepo, 'belay-audit', 'stop'),
+                command: runnerCommand(platform, resolvedHooksDir, resolvedRepo, 'belay-audit', runnerPathMode, 'stop'),
                 placement: 'append',
             },
         },
         {
             event: 'sessionEnd',
             definition: {
-                command: runnerCommand(platform, resolvedHooksDir, resolvedRepo, 'belay-audit', 'sessionEnd'),
+                command: runnerCommand(platform, resolvedHooksDir, resolvedRepo, 'belay-audit', runnerPathMode, 'sessionEnd'),
                 placement: 'append',
             },
         },
     ];
+    return entries.map(({ event, definition }) => ({
+        event,
+        definition: { ...definition, failClosed: true },
+    }));
 }
 /** @deprecated Use getManagedHookEntries instead. */
 export function getManagedHookEvents(platform = process.platform) {

package/dist/installer/bootstrap.d.ts

@@ -1,5 +1,6 @@
 import type { ScopedPaths } from '../adapters/layouts/scope.js';
 import type { AdapterName } from '../adapters/layouts/types.js';
 import type { BelayConfigV3 } from '../core/config.js';
+export declare const CURSOR_COMMAND_ARTIFACTS: readonly ["belay-approve.md", "belay-why.md", "belay-explain.md", "belay-status.md", "belay-report.md", "belay-recover.md"];
 export declare function bootstrapStateFiles(repoRoot: string, config: BelayConfigV3, paths: ScopedPaths): Promise<void>;
 export declare function writeSkillArtifacts(adapterName: AdapterName, paths: ScopedPaths): Promise<void>;

package/dist/installer/bootstrap.js

@@ -4,7 +4,7 @@ import path from 'node:path';
 import { approvedApprovalsPath, pendingApprovalsPath } from '../config-io.js';
 import { EMPTY_APPROVALS } from '../defaults.js';
 const BUNDLED_SKILL_TEMPLATE_URL = new URL('../../skills/belay/SKILL.md', import.meta.url);
-const BUNDLED_COMMAND_TEMPLATES = [
+export const CURSOR_COMMAND_ARTIFACTS = [
     'belay-approve.md',
     'belay-why.md',
     'belay-explain.md',
@@ -53,7 +53,7 @@ export async function writeSkillArtifacts(adapterName, paths) {
     await writeFile(path.join(paths.skillsDir, 'SKILL.md'), bundledSkill, 'utf8');
     if (adapterName === 'cursor' && paths.commandsDir) {
         await mkdir(paths.commandsDir, { recursive: true });
-        for (const fileName of BUNDLED_COMMAND_TEMPLATES) {
+        for (const fileName of CURSOR_COMMAND_ARTIFACTS) {
             const bundledCommand = await readBundledTemplate(new URL(`../../skills/belay/${fileName}`, import.meta.url));
             await writeFile(path.join(paths.commandsDir, fileName), bundledCommand, 'utf8');
         }

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.js

@@ -1,7 +1,7 @@
 import { existsSync } from 'node:fs';
 import { getAdapterLayout } from '../adapters/layouts/index.js';
 import { resolveInstallScope, resolveScopedPaths, } from '../adapters/layouts/scope.js';
-import { loadConfigFile, writeConfigFile } from '../config-io.js';
+import { loadConfigFile, writeTrustedConfigFile } from '../config-io.js';
 export async function resolveOperationScope(repoRoot, adapter, options = {}) {
     const layout = getAdapterLayout(adapter);
     let persisted;
@@ -17,7 +17,7 @@ export async function applyInstallScope(repoRoot, adapter, scope, config) {
         return current;
     }
     const updated = { ...current, installScope: scope };
-    await writeConfigFile(repoRoot, updated, adapter);
+    await writeTrustedConfigFile(repoRoot, updated, adapter);
     return updated;
 }
 export function pathsForOperation(adapter, scope, repoRoot) {

package/dist/installer.js

@@ -1,19 +1,19 @@
 import { existsSync } from 'node:fs';
 import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
 import path from 'node:path';
-import { mergeCursorHooksFile, stripCursorHooksFile } 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';
 import { dogfoodProject } from './commands/dogfood.js';
-import { detectAdapterName, loadConfigFile, mergeAndWriteConfig, writeConfigFile, } from './config-io.js';
+import { detectAdapterName, loadConfigFile, mergeAndWriteConfig, writeTrustedConfigFile, } from './config-io.js';
 import { appendCliAuditEvent } from './core/audit-io.js';
 import { archiveLegacyAuditLogIfNeeded } from './core/audit-legacy-archive.js';
 import { isFreshConfigInput, mergeConfig, normalizeConfig, } from './core/config.js';
 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,17 +84,31 @@ 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 = [
@@ -101,16 +118,34 @@ const BELAY_HOOK_ARTIFACTS = [
     '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 });
     }
-    await rm(paths.runtimeDir, { recursive: true, force: true });
-    await rm(paths.skillsDir, { recursive: true, 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) {
-        await rm(path.join(paths.commandsDir, 'belay.md'), { force: true });
+        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());
@@ -195,7 +230,7 @@ async function applyInitJudgeConfig(repoRoot, adapterName, options, isFreshBefor
         !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);
+    await writeTrustedConfigFile(repoRoot, configWithJudge, adapterName);
     if (migrated) {
         await auditJudgeMigrationIfNeeded(repoRoot, adapterName, mergedConfig.judge, finalJudge, options.migrateJudgeDefault ? 'belay init --migrate-judge-default' : 'belay init');
     }
@@ -228,7 +263,7 @@ export async function initProject(options = {}) {
         const existing = await loadConfigFile(repoRoot, adapterName);
         const presetConfig = mergeConfig(applyConfigPreset(options.preset));
         const merged = mergeConfig(presetConfig, existing);
-        await writeConfigFile(repoRoot, merged, adapterName);
+        await writeTrustedConfigFile(repoRoot, merged, adapterName);
     }
     if (options.dogfood === true) {
         await dogfoodProject({ targetDir: repoRoot, adapter: adapterName });
@@ -250,7 +285,7 @@ export async function upgradeProject(options = {}) {
         const migrated = migrateImplicitLocalJudgeIfNeeded(mergedConfig.judge, adapterName);
         if (migrated) {
             const configWithJudge = normalizeConfig({ ...mergedConfig, version: 4, judge: migrated });
-            await writeConfigFile(repoRoot, configWithJudge, adapterName);
+            await writeTrustedConfigFile(repoRoot, configWithJudge, adapterName);
             await auditJudgeMigrationIfNeeded(repoRoot, adapterName, mergedConfig.judge, migrated, 'belay upgrade --migrate-judge-default');
         }
     }

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

@@ -7,6 +7,7 @@ import type { ApprovalRecord, ClassifyResult } from './core/types.js';
 export interface HookEntry {
     command: string;
     matcher?: string;
+    failClosed?: boolean;
 }
 export interface HooksFile {
     version: number;
@@ -237,6 +238,8 @@ export interface DogfoodOptions {
     targetDir?: string;
     enforce?: boolean;
     force?: boolean;
+    check?: boolean;
+    since?: string;
     adapter?: AdapterName;
 }
 export interface DogfoodResult {
@@ -247,6 +250,23 @@ export interface DogfoodResult {
     mode: string;
     unknownLocalEffect: string;
 }
+export interface DogfoodCheckOptions {
+    targetDir?: string;
+    adapter?: AdapterName;
+    since: string;
+}
+export interface DogfoodCheckResult {
+    ok: boolean;
+    repoRoot: string;
+    since: string;
+    gateEvents: number;
+    auditModeDenyCount: number;
+    hostDeniedAfterAllowCount: number;
+    shellPreToolUseCount: number;
+    mismatchedCohortCount: number;
+    environmentSkewCount: number;
+    failures: string[];
+}
 export type ExplainKind = 'shell' | 'tool' | 'subagent';
 export interface ExplainReport {
     repoRoot: string;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const PACKAGE_VERSION = "0.9.3";
+export declare const PACKAGE_VERSION = "0.10.0";

package/dist/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@guilz-dev/belay",
-  "version": "0.9.3",
+  "version": "0.10.0",
   "description": "Belay-style approval and audit gating for agent runtimes.",
   "type": "module",
   "license": "MIT",
@@ -56,10 +56,14 @@
     "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:run": "vitest run",
     "test:structural": "pnpm build && vitest run src/__tests__/verdict/structural-suite.test.ts",
+    "test:structural:run": "vitest run src/__tests__/verdict/structural-suite.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",
+    "test:stable:run": "vitest run && vitest run && vitest run",
+    "test:macos": "vitest run src/__tests__/native-seatbelt-boundary-probe.test.ts src/__tests__/git-resource-identity.test.ts src/__tests__/installer-scope.test.ts src/__tests__/cursor-hook-precedence.integration.test.ts src/__tests__/cursor-hooks.test.ts",
     "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",