@guilz-dev/belay 0.9.3 → 0.9.4

package/dist/core/glob.js

@@ -1,26 +1,42 @@
+import { escapeRegex } from './approval.js';
+function globPatternToRegexSource(pattern) {
+    let result = '';
+    let index = 0;
+    while (index < pattern.length) {
+        const char = pattern[index];
+        if (char === '*' && pattern[index + 1] === '*') {
+            index += 2;
+            if (pattern[index] === '/') {
+                result += '(?:.*/)?';
+                index += 1;
+            }
+            else {
+                result += '.*';
+            }
+            continue;
+        }
+        if (char === '*') {
+            result += '[^/]*';
+            index += 1;
+            continue;
+        }
+        result += escapeRegex(char);
+        index += 1;
+    }
+    return result;
+}
+function globPatternMatches(pattern, normalized, baseName) {
+    const regex = new RegExp(`^${globPatternToRegexSource(pattern)}$`);
+    return regex.test(normalized) || regex.test(baseName);
+}
 export function matchesSensitivePath(filePath, patterns) {
     const normalized = filePath.replaceAll('\\', '/');
     const segments = normalized.split('/');
     const baseName = segments.at(-1) ?? normalized;
     for (const pattern of patterns) {
         const normalizedPattern = pattern.replaceAll('\\', '/');
-        if (normalizedPattern.includes('**')) {
-            const parts = normalizedPattern.split('**').map((part) => part.replace(/^\/+|\/+$/g, ''));
-            const prefix = parts[0]?.replace(/\/+$/, '') ?? '';
-            const suffix = parts[1]?.replace(/^\/+/, '') ?? '';
-            if (prefix && !normalized.startsWith(prefix)) {
-                continue;
-            }
-            if (suffix && !normalized.includes(suffix)) {
-                continue;
-            }
-            if (prefix || suffix) {
-                return true;
-            }
-        }
         if (normalizedPattern.includes('*')) {
-            const regex = new RegExp(`^${normalizedPattern.replaceAll('.', '\\.').replaceAll('*', '.*')}$`);
-            if (regex.test(normalized) || regex.test(baseName)) {
+            if (globPatternMatches(normalizedPattern, normalized, baseName)) {
                 return true;
             }
             continue;

package/dist/core/integrity.d.ts

@@ -8,9 +8,9 @@ export interface IntegrityManifest {
 }
 export declare function sha256File(filePath: string): Promise<string>;
 export declare function integrityManifestPath(layout: AdapterLayout, repoRoot: string): string;
-export declare function runtimeIntegrityFiles(_layout: AdapterLayout, paths: ScopedPaths): string[];
+export declare function runtimeIntegrityFiles(layout: AdapterLayout, paths: ScopedPaths): string[];
 export declare function writeIntegrityManifest(repoRoot: string, layout: AdapterLayout, filePaths: string[]): Promise<void>;
-export declare function verifyIntegrityManifest(repoRoot: string, layout: AdapterLayout): Promise<{
+export declare function verifyIntegrityManifest(repoRoot: string, layout: AdapterLayout, requiredFilePaths?: string[]): Promise<{
     ok: boolean;
     mismatches: string[];
 }>;

package/dist/core/integrity.js

@@ -3,8 +3,24 @@ import { existsSync } from 'node:fs';
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { getAdapterLayout } from '../adapters/layouts/index.js';
-import { resolveScopedPaths } from '../adapters/layouts/scope.js';
+import { isPathInside, resolveScopedPaths } from '../adapters/layouts/scope.js';
 import { resolveAdapterName } from '../config-io.js';
+const GLOBAL_INTEGRITY_PREFIX = '@global/';
+function portableRelativePath(from, to) {
+    return path.relative(from, to).split(path.sep).join('/');
+}
+function integrityManifestFileKey(repoRoot, layout, filePath) {
+    const absolutePath = path.resolve(filePath);
+    if (isPathInside(absolutePath, repoRoot)) {
+        return portableRelativePath(repoRoot, absolutePath);
+    }
+    const globalPaths = resolveScopedPaths(layout, 'global', repoRoot);
+    const globalAgentDir = path.dirname(globalPaths.hooksSettingsPath);
+    if (isPathInside(absolutePath, globalAgentDir)) {
+        return `${GLOBAL_INTEGRITY_PREFIX}${portableRelativePath(globalAgentDir, absolutePath)}`;
+    }
+    throw new Error(`Integrity file is outside the repository and global adapter root: ${filePath}`);
+}
 export async function sha256File(filePath) {
     const content = await readFile(filePath);
     return createHash('sha256').update(content).digest('hex');
@@ -12,11 +28,8 @@ export async function sha256File(filePath) {
 export function integrityManifestPath(layout, repoRoot) {
     return path.join(layout.repoLocalStateDir(repoRoot), 'integrity-manifest.json');
 }
-export function runtimeIntegrityFiles(_layout, paths) {
+export function runtimeIntegrityFiles(layout, paths) {
     const files = [paths.configPath];
-    if (paths.scope !== 'project') {
-        return files;
-    }
     const hooksDir = paths.hooksDir;
     const runtimeDir = paths.runtimeDir;
     return [
@@ -28,7 +41,9 @@ export function runtimeIntegrityFiles(_layout, paths) {
         path.join(hooksDir, 'belay-audit.mjs'),
         path.join(hooksDir, 'belay-runner'),
         path.join(hooksDir, 'belay-runner.cmd'),
+        ...(layout.name === 'cursor' ? [path.join(hooksDir, 'belay-runner.ps1')] : []),
         path.join(runtimeDir, 'core.mjs'),
+        ...(layout.name === 'cursor' ? [path.join(runtimeDir, 'dispatcher.mjs')] : []),
     ];
 }
 export async function writeIntegrityManifest(repoRoot, layout, filePaths) {
@@ -37,8 +52,8 @@ export async function writeIntegrityManifest(repoRoot, layout, filePaths) {
         if (!existsSync(filePath)) {
             continue;
         }
-        const relativePath = path.relative(repoRoot, filePath);
-        files[relativePath] = await sha256File(filePath);
+        const manifestKey = integrityManifestFileKey(repoRoot, layout, filePath);
+        files[manifestKey] = await sha256File(filePath);
     }
     const manifest = {
         version: 1,
@@ -49,22 +64,47 @@ export async function writeIntegrityManifest(repoRoot, layout, filePaths) {
     await mkdir(path.dirname(manifestPath), { recursive: true });
     await writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
 }
-export async function verifyIntegrityManifest(repoRoot, layout) {
+export async function verifyIntegrityManifest(repoRoot, layout, requiredFilePaths = []) {
     const manifestPath = integrityManifestPath(layout, repoRoot);
     if (!existsSync(manifestPath)) {
         return { ok: false, mismatches: ['missing integrity-manifest.json'] };
     }
     const manifest = JSON.parse(await readFile(manifestPath, 'utf8'));
     const mismatches = [];
-    for (const [relativePath, expectedHash] of Object.entries(manifest.files ?? {})) {
-        const absolutePath = path.join(repoRoot, relativePath);
+    const requiredPathsByKey = new Map(requiredFilePaths.map((requiredPath) => [
+        integrityManifestFileKey(repoRoot, layout, requiredPath),
+        path.resolve(requiredPath),
+    ]));
+    for (const requiredPath of requiredFilePaths) {
+        const requiredKey = integrityManifestFileKey(repoRoot, layout, requiredPath);
+        if (!Object.hasOwn(manifest.files ?? {}, requiredKey)) {
+            mismatches.push(`missing integrity pin ${requiredKey}`);
+        }
+    }
+    for (const [manifestKey, expectedHash] of Object.entries(manifest.files ?? {})) {
+        let absolutePath;
+        if (manifestKey.startsWith(GLOBAL_INTEGRITY_PREFIX)) {
+            const requiredPath = requiredPathsByKey.get(manifestKey);
+            if (!requiredPath) {
+                mismatches.push(`unrecognized global integrity pin ${manifestKey}`);
+                continue;
+            }
+            absolutePath = requiredPath;
+        }
+        else {
+            absolutePath = path.resolve(repoRoot, manifestKey);
+            if (!isPathInside(absolutePath, repoRoot)) {
+                mismatches.push(`integrity pin escapes repository ${manifestKey}`);
+                continue;
+            }
+        }
         if (!existsSync(absolutePath)) {
-            mismatches.push(`missing ${relativePath}`);
+            mismatches.push(`missing ${manifestKey}`);
             continue;
         }
         const actualHash = await sha256File(absolutePath);
         if (actualHash !== expectedHash) {
-            mismatches.push(`hash mismatch ${relativePath}`);
+            mismatches.push(`hash mismatch ${manifestKey}`);
         }
     }
     return { ok: mismatches.length === 0, mismatches };

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

@@ -3,6 +3,8 @@ import type { ScrubOptions } from './types.js';
 export declare function redactToolInvocationId(value: unknown, rawToolUseId?: string): unknown;
 /** Subagent fingerprint input — must match classify-subagent `fingerprintSource`. */
 export declare function subagentFingerprintSource(payload: Record<string, unknown>, scrubOptions: ScrubOptions): unknown;
+/** Stable tool-input source for fingerprints — redacts volatile ids only, not secret values. */
+export declare function fingerprintToolInputSource(payload: Record<string, unknown>): Record<string, unknown>;
 /**
  * Scrubbed payload used for replay envelope hashing — aligned with classifier fingerprints.
  * Tool: scrubbed `tool_input`. Subagent: description/prompt subset. Other: full payload.

package/dist/core/replay-scrub.js

@@ -40,6 +40,14 @@ export function subagentFingerprintSource(payload, scrubOptions) {
     }
     return scrubValue(payload, scrubOptions);
 }
+/** Stable tool-input source for fingerprints — redacts volatile ids only, not secret values. */
+export function fingerprintToolInputSource(payload) {
+    const toolInput = payload.tool_input;
+    if (!toolInput || typeof toolInput !== 'object') {
+        return {};
+    }
+    return redactToolInvocationId(toolInput, typeof payload.tool_use_id === 'string' ? payload.tool_use_id : undefined);
+}
 /**
  * Scrubbed payload used for replay envelope hashing — aligned with classifier fingerprints.
  * Tool: scrubbed `tool_input`. Subagent: description/prompt subset. Other: full payload.

package/dist/core/shell-substitution.js

@@ -16,7 +16,7 @@ export function findCommandSubstitutions(command) {
             index += 1;
             continue;
         }
-        if (char === '\\' && (inSingle || inDouble)) {
+        if (char === '\\' && inDouble) {
             escaping = true;
             index += 1;
             continue;
@@ -156,7 +156,7 @@ function extractBalancedParenContent(command, start) {
             index += 1;
             continue;
         }
-        if (char === '\\' && (inSingle || inDouble)) {
+        if (char === '\\' && inDouble) {
             escaping = true;
             index += 1;
             continue;

package/dist/core/shell-unparseable.js

@@ -42,7 +42,9 @@ function hasUnclosedQuote(command) {
             continue;
         }
         if (char === '\\') {
-            escaping = true;
+            if (quote !== "'") {
+                escaping = true;
+            }
             continue;
         }
         if (quote) {

package/dist/defaults.d.ts

@@ -5,13 +5,17 @@ export type ManagedHookDefinition = {
     command: string;
     placement: 'prepend' | 'append';
     matcher?: string;
+    failClosed?: boolean;
 };
-export declare function getManagedHookEntries(platform?: NodeJS.Platform, hooksDir?: string, repoRoot?: string): Array<{
+export type CursorManagedHookDefinition = ManagedHookDefinition & {
+    failClosed: true;
+};
+export declare function getManagedHookEntries(platform?: NodeJS.Platform, hooksDir?: string, repoRoot?: string, runnerPathMode?: 'absolute' | 'legacy-relative' | 'legacy-absolute' | 'legacy-quoted-absolute' | 'legacy-bare-powershell-absolute'): Array<{
     event: string;
-    definition: ManagedHookDefinition;
+    definition: CursorManagedHookDefinition;
 }>;
 /** @deprecated Use getManagedHookEntries instead. */
-export declare function getManagedHookEvents(platform?: NodeJS.Platform): Record<string, ManagedHookDefinition>;
+export declare function getManagedHookEvents(platform?: NodeJS.Platform): Record<string, CursorManagedHookDefinition>;
 export declare const EMPTY_APPROVALS: {
     readonly version: 1;
     readonly approvals: readonly [];

package/dist/defaults.js

@@ -1,29 +1,41 @@
 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'),
+                command: runnerCommand(platform, resolvedHooksDir, resolvedRepo, 'belay-shell-gate', runnerPathMode),
                 placement: 'prepend',
             },
         },
@@ -59,15 +71,6 @@ export function getManagedHookEntries(platform = process.platform, hooksDir, rep
                 matcher: 'Delete',
             },
         },
-        {
-            event: 'preToolUse',
-            definition: {
-                command: toolGate,
-                placement: 'prepend',
-                // Agent Shell tool (preToolUse) — distinct from terminal beforeShellExecution.
-                matcher: 'Shell',
-            },
-        },
         {
             event: 'subagentStart',
             definition: {
@@ -119,32 +122,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.js

@@ -1,7 +1,7 @@
 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';
@@ -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,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());

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
+`;
+}