javi-forge 1.41.0 → 1.42.0

package/assets/claude-hooks/javi-forge-skillguard-pre-tool-use.mjs

@@ -9,6 +9,7 @@ export const MANAGED_MARKER = "// javi-forge-managed: claude-pretooluse v1";
 export const INPUT_LIMIT_BYTES = 1_048_576;
 export const SUPPORTED_TOOLS = Object.freeze(["Bash", "PowerShell", "Read", "Write", "Edit"]);
 export function mapGrokToolName(toolName, platform = process.platform) { return toolName === "run_terminal_command" ? (platform === "win32" ? "PowerShell" : "Bash") : toolName === "read_file" ? "Read" : toolName === "search_replace" ? "Edit" : toolName; }
+export function mapCursorToolName(toolName, platform = process.platform) { return toolName === "Shell" ? (platform === "win32" ? "PowerShell" : "Bash") : toolName === "Delete" ? "Edit" : toolName; }
 export const POLICY_REGISTRY = Object.freeze({ schemaVersion: 1, policyVersion: 2, diagnosticsMaxBytes: 240 });
 export function resolvePlatformSupport(platform = process.platform) { return platform === "linux" || platform === "win32" ? { supported: true } : { supported: false, reason: "unsupported-platform" }; }
 const PROJECT_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
@@ -26,9 +27,11 @@ const CLAUDE_MANAGED_SET = Object.freeze({ exact: Object.freeze([".claude/settin
 const CODEX_MANAGED_SET = Object.freeze({ exact: Object.freeze([".codex/hooks.json", ".claude/settings.json", ".claude/settings.local.json", ".claude/CLAUDE.md", "CLAUDE.md", ".javi-forge/ci.yaml"]), prefixes: Object.freeze([".claude/hooks/", ".claude/agents/", ".claude/skills/"]), caseFoldExact: Object.freeze(["claude.md", ".claude/claude.md"]) });
 const OPENCODE_MANAGED_SET = Object.freeze({ exact: Object.freeze(["opencode.json", "opencode.jsonc", ".opencode/opencode.json", ".opencode/opencode.jsonc", ".opencode/AGENTS.md", "AGENTS.md", ".javi-forge/ci.yaml"]), prefixes: Object.freeze([".opencode/plugins/", ".opencode/agents/", ".opencode/skills/", ".agents/skills/", ".claude/hooks/", ".claude/agents/", ".claude/skills/"]), caseFoldExact: Object.freeze(["agents.md", ".opencode/agents.md", "claude.md", ".claude/claude.md"]) });
 const GROK_MANAGED_SET = Object.freeze({ exact: Object.freeze([".grok/config.toml", "AGENTS.md", ".claude/settings.json", ".claude/settings.local.json", ".claude/CLAUDE.md", "CLAUDE.md", ".javi-forge/ci.yaml"]), prefixes: Object.freeze([".grok/hooks/", ".claude/hooks/", ".claude/agents/", ".claude/skills/"]), caseFoldExact: Object.freeze(["agents.md", "claude.md", ".claude/claude.md"]) });
+const CURSOR_MANAGED_SET = Object.freeze({ exact: Object.freeze([".cursor/hooks.json", ".cursor/rules/", "AGENTS.md", ".claude/settings.json", ".claude/settings.local.json", ".claude/CLAUDE.md", "CLAUDE.md", ".javi-forge/ci.yaml"]), prefixes: Object.freeze([".cursor/hooks/", ".cursor/rules/", ".claude/hooks/", ".claude/agents/", ".claude/skills/"]), caseFoldExact: Object.freeze(["agents.md", "claude.md", ".claude/claude.md"]) });
 const CODEX_GLOBAL_MANAGED_PATHS = Object.freeze([".codex/hooks.json", ".codex/config.toml"]);
 const GROK_GLOBAL_MANAGED_PATHS = Object.freeze([path.join(GROK_HOME_ROOT, "hooks", "javi-forge-skillguard-pre-tool-use.json"), path.join(GROK_HOME_ROOT, "hooks", "javi-forge-skillguard-pre-tool-use.mjs")]);
-export const AGENT_CONFIGS = Object.freeze({ claude: Object.freeze({ id: "claude", managedSet: CLAUDE_MANAGED_SET, globalManagedPaths: Object.freeze([]), projectDir: Object.freeze({ envVar: "CLAUDE_PROJECT_DIR", fallback: "asset-root" }), marker: MANAGED_MARKER }), codex: Object.freeze({ id: "codex", managedSet: CODEX_MANAGED_SET, globalManagedPaths: CODEX_GLOBAL_MANAGED_PATHS, projectDir: Object.freeze({ envVar: null, fallback: "cwd" }), marker: "// javi-forge-managed: codex-pretooluse v1" }), opencode: Object.freeze({ id: "opencode", managedSet: OPENCODE_MANAGED_SET, globalManagedPaths: Object.freeze([]), projectDir: Object.freeze({ envVar: null, fallback: "cwd" }), marker: "// javi-forge-managed: opencode-skillguard v1" }), grok: Object.freeze({ id: "grok", managedSet: GROK_MANAGED_SET, globalManagedPaths: GROK_GLOBAL_MANAGED_PATHS, projectDir: Object.freeze({ envVar: null, fallback: "cwd" }), marker: "javi-forge-managed: grok-pretooluse v1" }) });
+const CURSOR_GLOBAL_MANAGED_PATHS = Object.freeze([path.join(HOST_HOME, ".cursor", "hooks.json"), path.join(HOST_HOME, ".cursor", "hooks", "javi-forge-skillguard-pre-tool-use.mjs")]);
+export const AGENT_CONFIGS = Object.freeze({ claude: Object.freeze({ id: "claude", managedSet: CLAUDE_MANAGED_SET, globalManagedPaths: Object.freeze([]), projectDir: Object.freeze({ envVar: "CLAUDE_PROJECT_DIR", fallback: "asset-root" }), marker: MANAGED_MARKER }), codex: Object.freeze({ id: "codex", managedSet: CODEX_MANAGED_SET, globalManagedPaths: CODEX_GLOBAL_MANAGED_PATHS, projectDir: Object.freeze({ envVar: null, fallback: "cwd" }), marker: "// javi-forge-managed: codex-pretooluse v1" }), opencode: Object.freeze({ id: "opencode", managedSet: OPENCODE_MANAGED_SET, globalManagedPaths: Object.freeze([]), projectDir: Object.freeze({ envVar: null, fallback: "cwd" }), marker: "// javi-forge-managed: opencode-skillguard v1" }), grok: Object.freeze({ id: "grok", managedSet: GROK_MANAGED_SET, globalManagedPaths: GROK_GLOBAL_MANAGED_PATHS, projectDir: Object.freeze({ envVar: null, fallback: "cwd" }), marker: "javi-forge-managed: grok-pretooluse v1" }), cursor: Object.freeze({ id: "cursor", managedSet: CURSOR_MANAGED_SET, globalManagedPaths: CURSOR_GLOBAL_MANAGED_PATHS, projectDir: Object.freeze({ envVar: "CURSOR_PROJECT_DIR", fallback: "cwd" }), marker: "// javi-forge-managed: cursor-pretooluse v1" }) });
 // Fail-closed agent selector: a missing/unknown --agent means we cannot know what to protect, so refuse.
 function resolveAgentConfig(argv) { const arg = argv.find((value) => typeof value === "string" && value.startsWith("--agent=")); const id = arg === undefined ? undefined : arg.slice("--agent=".length); const config = id === undefined ? undefined : AGENT_CONFIGS[id]; if (!config) fail("invalid-config"); return config; }
 // Project root per agent: the env var when set (Claude = CLAUDE_PROJECT_DIR); otherwise the per-agent
@@ -956,15 +959,18 @@ export function parseApplyPatchPaths(command) {
 	return paths;
 }
 export function evaluateEvent(input, config = AGENT_CONFIGS.claude) {
-	if (!isObject(input) || input.hook_event_name !== "PreToolUse") fail("invalid-event");
+	if (!isObject(input)) fail("invalid-event");
+	const eventName = input.hook_event_name;
+	if (eventName !== "PreToolUse" && !(config.id === "cursor" && eventName === "preToolUse")) fail("invalid-event");
 	const rawToolName = typeof input.tool_name === "string" ? input.tool_name : input.toolName;
-	const toolName = config.id === "grok" && typeof rawToolName === "string" ? mapGrokToolName(rawToolName) : rawToolName;
+	const toolName = config.id === "grok" && typeof rawToolName === "string" ? mapGrokToolName(rawToolName) : config.id === "cursor" && typeof rawToolName === "string" ? mapCursorToolName(rawToolName) : rawToolName;
 	const toolInput = isObject(input.tool_input) ? input.tool_input : input.toolInput;
 	if (typeof toolName !== "string" || !isObject(toolInput)) fail("invalid-event");
 	if (input.toolInputTruncated === true || input.tool_input_truncated === true) return { allowed: false, ruleId: "tool-input-truncated" };
 	const applyPatch = toolName === "apply_patch";
 	if (!applyPatch && !SUPPORTED_TOOLS.includes(toolName)) fail("invalid-event");
-	const cwd = typeof input.cwd === "string" && isAbsolutePolicyPath(input.cwd) ? input.cwd : PROJECT_ROOT;
+	const toolWorkingDirectory = isObject(toolInput) && typeof toolInput.working_directory === "string" ? toolInput.working_directory : undefined;
+	const cwd = typeof input.cwd === "string" && isAbsolutePolicyPath(input.cwd) ? input.cwd : typeof toolWorkingDirectory === "string" && isAbsolutePolicyPath(toolWorkingDirectory) ? toolWorkingDirectory : PROJECT_ROOT;
 	const projectRoot = resolveProjectRoot(config, cwd);
 	if (applyPatch) {
 		if (typeof toolInput.command !== "string") fail("invalid-event");
@@ -983,7 +989,7 @@ export function evaluateEvent(input, config = AGENT_CONFIGS.claude) {
 		if (typeof toolInput.command !== "string") fail("invalid-event");
 		return toolName === "Bash" ? evaluateBash(toolInput.command, cwd, config, projectRoot) : evaluatePowerShell(toolInput.command, cwd, config, projectRoot);
 	}
-	const filePath = typeof toolInput.file_path === "string" ? toolInput.file_path : typeof toolInput.filePath === "string" ? toolInput.filePath : config.id === "grok" && typeof toolInput.path === "string" ? lexicalizePolicyPath(toolInput.path, { base: cwd, projectRoot }) : undefined;
+	const filePath = typeof toolInput.file_path === "string" ? toolInput.file_path : typeof toolInput.filePath === "string" ? toolInput.filePath : (config.id === "grok" || config.id === "cursor") && typeof toolInput.path === "string" ? lexicalizePolicyPath(toolInput.path, { base: cwd, projectRoot }) : undefined;
 	if (typeof filePath !== "string" || !isAbsolutePolicyPath(filePath)) fail("invalid-event");
 	return evaluateFile(toolName, filePath, config, projectRoot);
 }
@@ -1032,6 +1038,20 @@ function denyAndExit(message) {
 		process.exit(2);
 	}
 }
+function cursorDecisionAndExit(permission, message) {
+	try {
+		const body = permission === "allow" ? { permission: "allow" } : { permission: "deny", user_message: message, agent_message: message };
+		fs.writeSync(1, `${JSON.stringify(body)}\n`);
+	} finally {
+		process.stdin.destroy();
+		process.stdin.unref?.();
+		process.exit(permission === "allow" ? 0 : 2);
+	}
+}
+function failClosed(message, config) {
+	if (config?.id === "cursor") cursorDecisionAndExit("deny", message);
+	denyAndExit(message);
+}
 export function readBoundedStdin(stream = process.stdin) {
 	return new Promise((resolve, reject) => {
 		const chunks = [];
@@ -1083,11 +1103,14 @@ export async function main() {
 		if (fault === "evaluator-throw") throw new Error("internal-error");
 		const decision = evaluateEvent(parsed, config);
 		const rawToolName = typeof parsed.tool_name === "string" ? parsed.tool_name : parsed.toolName;
-		const toolName = config.id === "grok" && typeof rawToolName === "string" ? mapGrokToolName(rawToolName) : rawToolName;
-		if (!decision.allowed) denyAndExit(denialDiagnostic(toolName, decision));
+		const toolName = config.id === "grok" && typeof rawToolName === "string" ? mapGrokToolName(rawToolName) : config.id === "cursor" && typeof rawToolName === "string" ? mapCursorToolName(rawToolName) : rawToolName;
+		if (!decision.allowed) failClosed(denialDiagnostic(toolName, decision), config);
+		if (config.id === "cursor") cursorDecisionAndExit("allow", "");
 		process.exitCode = 0;
 	} catch (error) {
-		denyAndExit(diagnostic(error));
+		let config;
+		try { config = resolveAgentConfig(process.argv); } catch {}
+		failClosed(diagnostic(error), config);
 	}
 }
 if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) await main();

package/assets/claude-hooks/manifest.json

@@ -4,7 +4,7 @@
 		"name": "javi-forge-skillguard-pre-tool-use.mjs",
 		"version": 1,
 		"policyVersion": 2,
-		"sha256": "044f6816d18a2894532fde52a145f10347f617cbb361fc10075d04f885327d22",
+		"sha256": "9c175bb1daed3055420cc6b1d7b4f90a7779da3525b23315e2a66767b8de96dc",
 		"historical": [
 			"78be7e6613c012280b7ad17886462ba166b63ebd031e34565d757b3a0796d7cc",
 			"5dc2a5c31131f4ac7d8657c78b950de52776aad6eaefe78ea0d764a9963c4425",
@@ -18,7 +18,8 @@
 			"f55ece1aea76251ec005f2b731fa44a58b6245fef8150b58486ae062167a2377",
 			"6fe1ef55363e6e3f38253ca94b17ec50c942352c00d8431cd2ff2f6858c094b6",
 			"b79ee8dc3df525810b07215927590366ed2669255666fdc817e9637cf0e10cf2",
-			"a352b5b6c29fcdeecf2a014ab0e271cab9373119460134d65134f16a19222e47"
+			"a352b5b6c29fcdeecf2a014ab0e271cab9373119460134d65134f16a19222e47",
+			"044f6816d18a2894532fde52a145f10347f617cbb361fc10075d04f885327d22"
 		]
 	},
 	"settingsEntries": {

package/dist/cli/dispatch/hooks.d.ts

@@ -6,7 +6,7 @@
  *
  * Subcommands:
  *   - `hooks run <pre-commit|pre-push>` → runHook, exits with its code.
- *   - `hooks <install|doctor|repair> <claude|codex|opencode> [--force]` → the matching
+ *   - `hooks <install|doctor|repair> <claude|codex|opencode|grok|cursor> [--force]` → the matching
  *     agent command, exits with its code (unknown/missing agent → usage + exit 1).
  * Any other subcommand or a missing name → usage + exit 1.
  *

package/dist/cli/dispatch/hooks.js

@@ -6,7 +6,7 @@
  *
  * Subcommands:
  *   - `hooks run <pre-commit|pre-push>` → runHook, exits with its code.
- *   - `hooks <install|doctor|repair> <claude|codex|opencode> [--force]` → the matching
+ *   - `hooks <install|doctor|repair> <claude|codex|opencode|grok|cursor> [--force]` → the matching
  *     agent command, exits with its code (unknown/missing agent → usage + exit 1).
  * Any other subcommand or a missing name → usage + exit 1.
  *
@@ -25,6 +25,7 @@ const AGENT_COMMAND_LOADERS = {
     codex: async () => (await import("../../commands/codex-hooks.js")).runCodexHookCommand,
     opencode: async () => (await import("../../commands/opencode-hooks.js")).runOpenCodeHookCommand,
     grok: async () => (await import("../../commands/grok-hooks.js")).runGrokHookCommand,
+    cursor: async () => (await import("../../commands/cursor-hooks.js")).runCursorHookCommand,
 };
 export async function handleHooks(cli) {
     if (cli.flags.help === true) {
@@ -47,7 +48,7 @@ export async function handleHooks(cli) {
         // Validity is decided by the agent registry (isAgentId), the single source
         // of truth; the loader map is exhaustive over AgentId by type.
         if (!isAgentId(agent)) {
-            console.error(`Usage: javi-forge hooks ${sub} <claude|codex|opencode|grok>`);
+            console.error(`Usage: javi-forge hooks ${sub} <claude|codex|opencode|grok|cursor>`);
             process.exit(1);
         }
         const run = await AGENT_COMMAND_LOADERS[agent]();

package/dist/cli/help.d.ts

@@ -19,7 +19,7 @@ export declare const CI_HELP_TEXT = "\n  Usage\n    $ javi-forge ci [subcommand]
  * Per-command help for `hooks`, shown by `javi-forge hooks --help` (or when
  * `hooks` is given an unknown subcommand). Whitespace is significant.
  */
-export declare const HOOKS_HELP_TEXT = "\n  Usage\n    $ javi-forge hooks run <pre-commit|pre-push>\n    $ javi-forge hooks <install|doctor|repair> <claude|codex|opencode|grok> [--force]\n\n    Run the sections enabled under hooks: in .javi-forge/ci.yaml, in a fixed\n    cheap\u2192expensive order, fail-fast. With no hooks: config the default is the\n    quick native CI gate (setup + lint + compile + gates \u2014 no tests, no coverage).\n\n  Subcommands\n    run pre-commit    Run the composed pre-commit sections\n    run pre-push      Run the composed pre-push sections\n    install claude    Install the managed Claude PreToolUse guard (.claude/)\n    doctor claude     Report Claude PreToolUse guard health (informational)\n    repair claude     Repair the managed guard; --force overwrites edited assets\n    install codex     Install the managed Codex PreToolUse guard (~/.codex/)\n    doctor codex      Report Codex hook execution readiness and trust boundary\n    repair codex      Repair the managed Codex guard; --force overwrites edits\n    install opencode  Install the managed OpenCode global plugin (~/.config/opencode/plugins/)\n    doctor opencode   Report OpenCode plugin and policy file currency (informational)\n    repair opencode   Repair the OpenCode plugin pair; --force overwrites edits\n    install grok      Install the Grok Build global PreToolUse hook (~/.grok/hooks/)\n    doctor grok       Report Grok hook registration and policy file currency (informational)\n    repair grok       Repair the Grok hook pair; --force overwrites edits\n\n  Notes\n    A blocking section failure exits non-zero and blocks the commit/push.\n    A broken .javi-forge/ci.yaml exits 1 (fail-closed \u2014 never skips a gate).\n    To skip: git commit --no-verify   (pre-push: git push --no-verify)\n    doctor claude is informational (always exits 0); install/repair exit 0 on\n    success, non-zero on refusal/failure. Use repair claude --force to overwrite\n    a locally edited managed asset.\n    doctor codex exits 0 when runnable, 1 when blocked, and 2 when inconclusive;\n    it does not prove provider trust or runtime execution. Use repair codex\n    --force only to overwrite an edited managed asset.\n    doctor opencode is informational and inspects installed files only; it does\n    not prove OpenCode discovered, loaded, or executed the plugin.\n    doctor grok is informational and inspects the global hook registration and\n    adjacent policy runtime only; it does not prove Grok loaded or executed them.\n    Linux: install/repair claude and grok need the acl package (getfacl) to\n    prove the parent chain \u2014 apt install acl / apk add acl / dnf install acl.\n    Without it\n    they refuse fail-closed; an already-installed guard keeps firing, and\n    doctor claude reports the acl capability as its own row.\n    Claude Code spawns the guard with node from ITS path, so node must resolve\n    there, not only inside javi-forge.\n\n  Examples\n    $ javi-forge hooks run pre-commit\n    $ javi-forge hooks run pre-push\n    $ javi-forge hooks install claude\n    $ javi-forge hooks doctor claude\n    $ javi-forge hooks repair claude --force\n    $ javi-forge hooks install codex\n    $ javi-forge hooks doctor codex\n    $ javi-forge hooks repair codex --force\n    $ javi-forge hooks install opencode\n    $ javi-forge hooks doctor opencode\n    $ javi-forge hooks repair opencode --force\n    $ javi-forge hooks install grok\n    $ javi-forge hooks doctor grok\n    $ javi-forge hooks repair grok --force\n";
+export declare const HOOKS_HELP_TEXT = "\n  Usage\n    $ javi-forge hooks run <pre-commit|pre-push>\n    $ javi-forge hooks <install|doctor|repair> <claude|codex|opencode|grok|cursor> [--force]\n\n    Run the sections enabled under hooks: in .javi-forge/ci.yaml, in a fixed\n    cheap\u2192expensive order, fail-fast. With no hooks: config the default is the\n    quick native CI gate (setup + lint + compile + gates \u2014 no tests, no coverage).\n\n  Subcommands\n    run pre-commit    Run the composed pre-commit sections\n    run pre-push      Run the composed pre-push sections\n    install claude    Install the managed Claude PreToolUse guard (.claude/)\n    doctor claude     Report Claude PreToolUse guard health (informational)\n    repair claude     Repair the managed guard; --force overwrites edited assets\n    install codex     Install the managed Codex PreToolUse guard (~/.codex/)\n    doctor codex      Report Codex hook execution readiness and trust boundary\n    repair codex      Repair the managed Codex guard; --force overwrites edits\n    install opencode  Install the managed OpenCode global plugin (~/.config/opencode/plugins/)\n    doctor opencode   Report OpenCode plugin and policy file currency (informational)\n    repair opencode   Repair the OpenCode plugin pair; --force overwrites edits\n    install grok      Install the Grok Build global PreToolUse hook (~/.grok/hooks/)\n    doctor grok       Report Grok hook registration and policy file currency (informational)\n    repair grok       Repair the Grok hook pair; --force overwrites edits\n    install cursor    Install the Cursor global preToolUse hook (~/.cursor/)\n    doctor cursor     Report Cursor hook registration and policy file currency (informational)\n    repair cursor     Repair the Cursor hook pair; --force overwrites edits\n\n  Notes\n    A blocking section failure exits non-zero and blocks the commit/push.\n    A broken .javi-forge/ci.yaml exits 1 (fail-closed \u2014 never skips a gate).\n    To skip: git commit --no-verify   (pre-push: git push --no-verify)\n    doctor claude is informational (always exits 0); install/repair exit 0 on\n    success, non-zero on refusal/failure. Use repair claude --force to overwrite\n    a locally edited managed asset.\n    doctor codex exits 0 when runnable, 1 when blocked, and 2 when inconclusive;\n    it does not prove provider trust or runtime execution. Use repair codex\n    --force only to overwrite an edited managed asset.\n    doctor opencode is informational and inspects installed files only; it does\n    not prove OpenCode discovered, loaded, or executed the plugin.\n    doctor grok is informational and inspects the global hook registration and\n    adjacent policy runtime only; it does not prove Grok loaded or executed them.\n    doctor cursor is informational and inspects the global hook registration and\n    adjacent policy runtime only; it does not prove Cursor loaded or executed them.\n    Linux: install/repair claude, grok, and cursor need the acl package (getfacl) to\n    prove the parent chain \u2014 apt install acl / apk add acl / dnf install acl.\n    Without it\n    they refuse fail-closed; an already-installed guard keeps firing, and\n    doctor claude reports the acl capability as its own row.\n    Claude Code spawns the guard with node from ITS path, so node must resolve\n    there, not only inside javi-forge.\n\n  Examples\n    $ javi-forge hooks run pre-commit\n    $ javi-forge hooks run pre-push\n    $ javi-forge hooks install claude\n    $ javi-forge hooks doctor claude\n    $ javi-forge hooks repair claude --force\n    $ javi-forge hooks install codex\n    $ javi-forge hooks doctor codex\n    $ javi-forge hooks repair codex --force\n    $ javi-forge hooks install opencode\n    $ javi-forge hooks doctor opencode\n    $ javi-forge hooks repair opencode --force\n    $ javi-forge hooks install grok\n    $ javi-forge hooks doctor grok\n    $ javi-forge hooks repair grok --force\n    $ javi-forge hooks install cursor\n    $ javi-forge hooks doctor cursor\n    $ javi-forge hooks repair cursor --force\n";
 export declare const FLAGS_SCHEMA: {
     readonly help: {
         readonly type: "boolean";

package/dist/cli/help.js

@@ -167,7 +167,7 @@ export const CI_HELP_TEXT = `
 export const HOOKS_HELP_TEXT = `
   Usage
     $ javi-forge hooks run <pre-commit|pre-push>
-    $ javi-forge hooks <install|doctor|repair> <claude|codex|opencode|grok> [--force]
+    $ javi-forge hooks <install|doctor|repair> <claude|codex|opencode|grok|cursor> [--force]
 
     Run the sections enabled under hooks: in .javi-forge/ci.yaml, in a fixed
     cheap→expensive order, fail-fast. With no hooks: config the default is the
@@ -188,6 +188,9 @@ export const HOOKS_HELP_TEXT = `
     install grok      Install the Grok Build global PreToolUse hook (~/.grok/hooks/)
     doctor grok       Report Grok hook registration and policy file currency (informational)
     repair grok       Repair the Grok hook pair; --force overwrites edits
+    install cursor    Install the Cursor global preToolUse hook (~/.cursor/)
+    doctor cursor     Report Cursor hook registration and policy file currency (informational)
+    repair cursor     Repair the Cursor hook pair; --force overwrites edits
 
   Notes
     A blocking section failure exits non-zero and blocks the commit/push.
@@ -203,7 +206,9 @@ export const HOOKS_HELP_TEXT = `
     not prove OpenCode discovered, loaded, or executed the plugin.
     doctor grok is informational and inspects the global hook registration and
     adjacent policy runtime only; it does not prove Grok loaded or executed them.
-    Linux: install/repair claude and grok need the acl package (getfacl) to
+    doctor cursor is informational and inspects the global hook registration and
+    adjacent policy runtime only; it does not prove Cursor loaded or executed them.
+    Linux: install/repair claude, grok, and cursor need the acl package (getfacl) to
     prove the parent chain — apt install acl / apk add acl / dnf install acl.
     Without it
     they refuse fail-closed; an already-installed guard keeps firing, and
@@ -226,6 +231,9 @@ export const HOOKS_HELP_TEXT = `
     $ javi-forge hooks install grok
     $ javi-forge hooks doctor grok
     $ javi-forge hooks repair grok --force
+    $ javi-forge hooks install cursor
+    $ javi-forge hooks doctor cursor
+    $ javi-forge hooks repair cursor --force
 `;
 export const FLAGS_SCHEMA = {
     // `--help` is handled manually (autoHelp is disabled at the entrypoint so

package/dist/commands/cursor-hooks.d.ts

@@ -0,0 +1,15 @@
+/** Console renderer for the Cursor global SkillGuard hook manager. */
+import { doctorCursorSkillGuard, installCursorSkillGuard, repairCursorSkillGuard } from "../lib/cursor-hook-manager.js";
+export type CursorHookSub = "install" | "doctor" | "repair";
+export interface CursorHookCmdDeps {
+    install?: typeof installCursorSkillGuard;
+    doctor?: typeof doctorCursorSkillGuard;
+    repair?: typeof repairCursorSkillGuard;
+    homeDir?: string;
+    log?: (msg: string) => void;
+    logError?: (msg: string) => void;
+}
+export declare function runCursorHookCommand(sub: CursorHookSub, _cwd: string, opts: {
+    force?: boolean;
+}, deps?: CursorHookCmdDeps): Promise<number>;
+//# sourceMappingURL=cursor-hooks.d.ts.map

package/dist/commands/cursor-hooks.js

@@ -0,0 +1,44 @@
+/** Console renderer for the Cursor global SkillGuard hook manager. */
+import { doctorCursorSkillGuard, installCursorSkillGuard, repairCursorSkillGuard, } from "../lib/cursor-hook-manager.js";
+function renderMutation(verb, result, log, logError) {
+    if (!result.ok) {
+        logError(`${verb} cursor: refused`);
+        for (const error of result.errors)
+            logError(`  ${error}`);
+        for (const backup of result.backups)
+            logError(`  backup: ${backup}`);
+        return 1;
+    }
+    log(`${verb} cursor: ok`);
+    if (result.changed.length === 0)
+        log("changed: nothing (already up to date)");
+    else
+        for (const changed of result.changed)
+            log(`changed: ${changed}`);
+    for (const backup of result.backups)
+        log(`backup: ${backup}`);
+    return 0;
+}
+function renderDoctor(report, log) {
+    log(`doctor cursor: ${report.healthy ? "healthy" : "unhealthy"}`);
+    log(`  hooks.json: ${report.hooksJson.state}`);
+    log(`  policy: ${report.policy.state}`);
+    log("  runtime: not verified (installed files only)");
+    for (const remediation of report.remediation)
+        log(`  remediation: ${remediation}`);
+    // Informational: installed files cannot prove Cursor discovered or invoked them.
+    return 0;
+}
+export async function runCursorHookCommand(sub, _cwd, opts, deps = {}) {
+    const log = deps.log ?? ((message) => console.log(message));
+    const logError = deps.logError ?? ((message) => console.error(message));
+    const home = deps.homeDir;
+    if (sub === "install")
+        return renderMutation("install", await (deps.install ?? installCursorSkillGuard)(home), log, logError);
+    if (sub === "repair")
+        return renderMutation("repair", await (deps.repair ?? repairCursorSkillGuard)(home, {
+            force: opts.force === true,
+        }), log, logError);
+    return renderDoctor(await (deps.doctor ?? doctorCursorSkillGuard)(home), log);
+}
+//# sourceMappingURL=cursor-hooks.js.map

package/dist/lib/agent-adapter.d.ts

@@ -1,6 +1,6 @@
 /**
  * Agent adapter registry (agent-agnostic slice 2). One descriptor per host
- * (`claude`, `codex`, `opencode`) capturing the per-agent facts the SkillGuard installer and
+ * (`claude`, `codex`, `opencode`, `grok`, `cursor`) capturing the per-agent facts the SkillGuard installer and
  * doctor need: config paths, the protected managed set, the project-root source,
  * the host registration schema, the managed marker, the deny protocol, and the
  * trust model.
@@ -14,7 +14,7 @@
  * map is typed `Record<AgentId, …>`, so omitting a loader is a compile error.
  */
 import { validateSettingsShape } from "./claude-hook-settings.js";
-export type AgentId = "claude" | "codex" | "opencode" | "grok";
+export type AgentId = "claude" | "codex" | "opencode" | "grok" | "cursor";
 export type TrustState = "trusted" | "untrusted" | "unknown";
 export interface TrustDescriptor {
     /** Detect whether the installed hook is TRUSTED from the host config text. */
@@ -40,7 +40,7 @@ export interface AgentAdapter {
     /** The managed asset marker for this host. */
     marker: string;
     /** Deny protocol emitted by the host integration. */
-    emitDeny: "exit2+stderr" | "throw-error";
+    emitDeny: "exit2+stderr" | "throw-error" | "json-stdout";
     /** Hook-trust model, or null when the host has none (Claude). */
     trust: TrustDescriptor | null;
 }
@@ -48,6 +48,7 @@ export declare const claudeAdapter: AgentAdapter;
 export declare const codexAdapter: AgentAdapter;
 export declare const opencodeAdapter: AgentAdapter;
 export declare const grokAdapter: AgentAdapter;
+export declare const cursorAdapter: AgentAdapter;
 export declare const AGENT_ADAPTERS: Record<AgentId, AgentAdapter>;
 /**
  * Whether a raw CLI token names a known agent adapter. Backed by the

package/dist/lib/agent-adapter.js

@@ -1,6 +1,6 @@
 /**
  * Agent adapter registry (agent-agnostic slice 2). One descriptor per host
- * (`claude`, `codex`, `opencode`) capturing the per-agent facts the SkillGuard installer and
+ * (`claude`, `codex`, `opencode`, `grok`, `cursor`) capturing the per-agent facts the SkillGuard installer and
  * doctor need: config paths, the protected managed set, the project-root source,
  * the host registration schema, the managed marker, the deny protocol, and the
  * trust model.
@@ -67,6 +67,21 @@ const GROK_MANAGED_SET = [
     ".claude/agents/",
     ".claude/skills/",
 ];
+const CURSOR_MANAGED_SET = [
+    ".cursor/hooks.json",
+    ".cursor/hooks/javi-forge-skillguard-pre-tool-use.mjs",
+    "AGENTS.md",
+    ".claude/settings.json",
+    ".claude/settings.local.json",
+    ".claude/CLAUDE.md",
+    "CLAUDE.md",
+    ".javi-forge/ci.yaml",
+    ".cursor/hooks/",
+    ".cursor/rules/",
+    ".claude/hooks/",
+    ".claude/agents/",
+    ".claude/skills/",
+];
 export const claudeAdapter = {
     id: "claude",
     configPaths(projectDir) {
@@ -134,11 +149,28 @@ export const grokAdapter = {
     emitDeny: "exit2+stderr",
     trust: null,
 };
+export const cursorAdapter = {
+    id: "cursor",
+    configPaths(homeDir) {
+        const cursorDir = path.join(homeDir, ".cursor");
+        return {
+            hooksFile: path.join(cursorDir, "hooks.json"),
+            settingsFile: path.join(cursorDir, "hooks", "javi-forge-skillguard-pre-tool-use.mjs"),
+        };
+    },
+    managedSet: CURSOR_MANAGED_SET,
+    projectDir: { envVar: "CURSOR_PROJECT_DIR" },
+    settingsSchema: null,
+    marker: "// javi-forge-managed: cursor-pretooluse v1",
+    emitDeny: "json-stdout",
+    trust: null,
+};
 export const AGENT_ADAPTERS = {
     claude: claudeAdapter,
     codex: codexAdapter,
     opencode: opencodeAdapter,
     grok: grokAdapter,
+    cursor: cursorAdapter,
 };
 /**
  * Whether a raw CLI token names a known agent adapter. Backed by the

package/dist/lib/cursor-hook-manager.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Cursor SkillGuard hook ownership manager. Cursor reads per-user hooks from
+ * ~/.cursor/hooks.json and hook scripts from ~/.cursor/hooks/, so installation is
+ * a two-file transaction: a merged preToolUse registration plus the shared
+ * policy runtime copied beside it. Doctor reports installed bytes/registration
+ * only; it cannot prove Cursor loaded or executed the hook in a live session.
+ */
+import type { AssetManifestEntry } from "./claude-hook-manager.js";
+import type { ClaudeHookComponentState } from "./claude-hook-settings.js";
+import { type PlatformSecureFs } from "./secure-fs-transaction.js";
+export declare const CURSOR_HOOKS_NAME = "hooks.json";
+export declare const CURSOR_POLICY_NAME = "javi-forge-skillguard-pre-tool-use.mjs";
+export declare const CURSOR_HOOK_MARKER = "javi-forge-managed: cursor-pretooluse v1";
+export declare const CURSOR_POLICY_MARKER = "// javi-forge-managed: claude-pretooluse v1";
+export declare const CURSOR_HOOK_VERSION = 1;
+export declare const CURSOR_TIMEOUT = 30;
+export declare const CURSOR_TOOL_MATCHER = "Shell|Read|Write|Delete";
+export declare const SHIPPED_CURSOR_POLICY: string;
+export interface CursorConfigPaths {
+    cursorDir: string;
+    hooksDir: string;
+    hooksFile: string;
+    policyFile: string;
+}
+export declare function cursorConfigPaths(homeDir: string): CursorConfigPaths;
+export interface CursorAssetClassification {
+    state: ClaudeHookComponentState;
+    sha256?: string;
+    version?: number;
+    detail?: string;
+}
+export declare function classifyCursorAsset(target: string, marker: string, manifest: AssetManifestEntry): Promise<CursorAssetClassification>;
+export declare function expectedCursorHooksJson(policyFile: string): string;
+export declare function mergeCursorHooks(existing: unknown, policyFile: string): Record<string, unknown>;
+export declare function classifyCursorHooksJson(value: unknown, policyFile: string): CursorAssetClassification;
+interface CursorManifest {
+    policy: AssetManifestEntry;
+}
+export interface CursorHookDoctorReport {
+    healthy: boolean;
+    hooksJson: CursorAssetClassification;
+    policy: CursorAssetClassification;
+    remediation: string[];
+    /** Installed files and registration only; no Cursor execution is observed. */
+    runtimeEvidence: "not-implemented";
+}
+export interface CursorDoctorOptions {
+    manifest?: CursorManifest;
+    policySource?: string;
+}
+export declare function doctorCursorSkillGuard(homeDir?: string, options?: CursorDoctorOptions): Promise<CursorHookDoctorReport>;
+interface CursorMutationSuccess {
+    ok: boolean;
+    changed: string[];
+    backups: string[];
+    errors: string[];
+    warnings: string[];
+    report: CursorHookDoctorReport;
+}
+export type CursorHookMutationResult = CursorMutationSuccess;
+export interface CursorHookRunDeps extends CursorDoctorOptions {
+    secureFs?: PlatformSecureFs | null;
+    clock?: () => Date;
+    nonce?: () => string;
+    doctor?: typeof doctorCursorSkillGuard;
+}
+export declare function _runCursor(homeDir: string, mode: "install" | "repair", options: {
+    force?: boolean;
+}, deps?: CursorHookRunDeps): Promise<CursorHookMutationResult>;
+export declare function installCursorSkillGuard(homeDir?: string, deps?: CursorHookRunDeps): Promise<CursorHookMutationResult>;
+export declare function repairCursorSkillGuard(homeDir?: string, options?: {
+    force?: boolean;
+}, deps?: CursorHookRunDeps): Promise<CursorHookMutationResult>;
+export {};
+//# sourceMappingURL=cursor-hook-manager.d.ts.map

package/dist/lib/cursor-hook-manager.js

@@ -0,0 +1,379 @@
+/**
+ * Cursor SkillGuard hook ownership manager. Cursor reads per-user hooks from
+ * ~/.cursor/hooks.json and hook scripts from ~/.cursor/hooks/, so installation is
+ * a two-file transaction: a merged preToolUse registration plus the shared
+ * policy runtime copied beside it. Doctor reports installed bytes/registration
+ * only; it cannot prove Cursor loaded or executed the hook in a live session.
+ */
+import { createHash, randomBytes } from "node:crypto";
+import { lstat, readFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { CLAUDE_HOOK_ASSETS_DIR } from "../constants.js";
+import { safeReadFile } from "./safe-read.js";
+import { selectSecureFs } from "./secure-fs-posix.js";
+import { runTransaction, } from "./secure-fs-transaction.js";
+const MAX_BYTES = 1024 * 1024;
+const READ_OPTS = {
+    maxBytes: MAX_BYTES,
+    hardRejectOverBytes: MAX_BYTES,
+    maxLineLength: Number.POSITIVE_INFINITY,
+};
+export const CURSOR_HOOKS_NAME = "hooks.json";
+export const CURSOR_POLICY_NAME = "javi-forge-skillguard-pre-tool-use.mjs";
+export const CURSOR_HOOK_MARKER = "javi-forge-managed: cursor-pretooluse v1";
+export const CURSOR_POLICY_MARKER = "// javi-forge-managed: claude-pretooluse v1";
+export const CURSOR_HOOK_VERSION = 1;
+export const CURSOR_TIMEOUT = 30;
+export const CURSOR_TOOL_MATCHER = "Shell|Read|Write|Delete";
+export const SHIPPED_CURSOR_POLICY = path.join(CLAUDE_HOOK_ASSETS_DIR, CURSOR_POLICY_NAME);
+export function cursorConfigPaths(homeDir) {
+    const cursorDir = path.join(homeDir, ".cursor");
+    const hooksDir = path.join(cursorDir, "hooks");
+    return {
+        cursorDir,
+        hooksDir,
+        hooksFile: path.join(cursorDir, CURSOR_HOOKS_NAME),
+        policyFile: path.join(hooksDir, CURSOR_POLICY_NAME),
+    };
+}
+async function fileKind(target) {
+    try {
+        const stat = await lstat(target);
+        if (stat.isSymbolicLink())
+            return { kind: "symlink" };
+        return stat.isFile() ? { kind: "file" } : { kind: "non-regular" };
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT" || code === "ENOTDIR")
+            return { kind: "absent" };
+        return { kind: "error", detail: code ?? String(error) };
+    }
+}
+function sha256(content) {
+    return createHash("sha256").update(content).digest("hex");
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export async function classifyCursorAsset(target, marker, manifest) {
+    const stat = await fileKind(target);
+    if (stat.kind === "absent")
+        return { state: "absent" };
+    if (stat.kind === "symlink")
+        return { state: "symlink" };
+    if (stat.kind !== "file")
+        return { state: "non-regular", detail: stat.detail };
+    const read = await safeReadFile(target, READ_OPTS);
+    if (!read.ok) {
+        if (read.reason === "not-found")
+            return { state: "absent" };
+        if (read.reason === "binary" || read.reason === "too-large")
+            return { state: "foreign", detail: read.reason };
+        return { state: "non-regular", detail: read.reason };
+    }
+    if (!read.content.startsWith(`${marker}\n`))
+        return { state: "foreign" };
+    const observed = sha256(read.content);
+    if (observed === manifest.sha256)
+        return {
+            state: "managed-current",
+            sha256: observed,
+            version: manifest.version,
+        };
+    if (manifest.historical.includes(observed))
+        return {
+            state: "released-outdated",
+            sha256: observed,
+            version: manifest.version,
+        };
+    return { state: "edited-managed", sha256: observed };
+}
+function expectedCursorCommand(policyFile) {
+    return `${JSON.stringify(process.execPath)} ${JSON.stringify(policyFile)} --agent=cursor`;
+}
+function buildCursorHook(policyFile) {
+    return {
+        command: expectedCursorCommand(policyFile),
+        type: "command",
+        matcher: CURSOR_TOOL_MATCHER,
+        timeout: CURSOR_TIMEOUT,
+        failClosed: true,
+    };
+}
+export function expectedCursorHooksJson(policyFile) {
+    return `${JSON.stringify({
+        "javi-forge-managed": CURSOR_HOOK_MARKER,
+        version: CURSOR_HOOK_VERSION,
+        hooks: { preToolUse: [buildCursorHook(policyFile)] },
+    }, null, 2)}\n`;
+}
+const CURSOR_CMD_RE = /(?:^|\s)(?:"[^"]*node[^"]*"|node)\s+(?:"[^"]*javi-forge-skillguard-pre-tool-use\.mjs"|\S*javi-forge-skillguard-pre-tool-use\.mjs)\s+--agent=cursor(?:\s|$)/;
+function preToolUseHandlers(value) {
+    if (!isObject(value))
+        return null;
+    const hooks = value.hooks;
+    if (hooks === undefined)
+        return [];
+    if (!isObject(hooks))
+        return null;
+    const groups = hooks.preToolUse;
+    if (groups === undefined)
+        return [];
+    if (!Array.isArray(groups))
+        return null;
+    const handlers = [];
+    for (const group of groups) {
+        if (!isObject(group))
+            return null;
+        handlers.push(group);
+    }
+    return handlers;
+}
+export function mergeCursorHooks(existing, policyFile) {
+    const container = isObject(existing)
+        ? structuredClone(existing)
+        : {};
+    if (!isObject(container.hooks))
+        container.hooks = {};
+    const hooks = container.hooks;
+    const groups = Array.isArray(hooks.preToolUse) ? hooks.preToolUse : [];
+    hooks.preToolUse = [
+        ...groups.filter((group) => !(isObject(group) &&
+            typeof group.command === "string" &&
+            CURSOR_CMD_RE.test(group.command))),
+        buildCursorHook(policyFile),
+    ];
+    container["javi-forge-managed"] = CURSOR_HOOK_MARKER;
+    container.version = CURSOR_HOOK_VERSION;
+    return container;
+}
+export function classifyCursorHooksJson(value, policyFile) {
+    const handlers = preToolUseHandlers(value);
+    if (handlers === null)
+        return { state: "malformed" };
+    const expected = buildCursorHook(policyFile);
+    const ours = handlers.filter((handler) => typeof handler.command === "string" &&
+        CURSOR_CMD_RE.test(handler.command));
+    if (ours.some((handler) => JSON.stringify(handler) === JSON.stringify(expected) &&
+        isObject(value) &&
+        value["javi-forge-managed"] === CURSOR_HOOK_MARKER &&
+        value.version === CURSOR_HOOK_VERSION)) {
+        return { state: "managed-current", version: CURSOR_HOOK_VERSION };
+    }
+    if (ours.length > 0)
+        return { state: "released-outdated" };
+    if (handlers.length > 0)
+        return { state: "foreign" };
+    return { state: "absent" };
+}
+async function readManifest() {
+    const read = await safeReadFile(path.join(CLAUDE_HOOK_ASSETS_DIR, "manifest.json"), READ_OPTS);
+    if (!read.ok)
+        throw new Error(`unreadable claude-hooks manifest: ${read.reason}`);
+    const manifest = JSON.parse(read.content);
+    return { policy: manifest.asset };
+}
+async function readJsonFile(target) {
+    const stat = await fileKind(target);
+    if (stat.kind === "absent")
+        return { ok: false, state: "absent" };
+    if (stat.kind === "symlink")
+        return { ok: false, state: "symlink" };
+    if (stat.kind !== "file")
+        return { ok: false, state: "non-regular", detail: stat.detail };
+    const read = await safeReadFile(target, READ_OPTS);
+    if (!read.ok) {
+        if (read.reason === "not-found")
+            return { ok: false, state: "absent" };
+        if (read.reason === "binary" || read.reason === "too-large")
+            return { ok: false, state: "foreign", detail: read.reason };
+        return { ok: false, state: "non-regular", detail: read.reason };
+    }
+    try {
+        return { ok: true, value: JSON.parse(read.content) };
+    }
+    catch {
+        return { ok: false, state: "malformed", detail: "invalid-json" };
+    }
+}
+export async function doctorCursorSkillGuard(homeDir = os.homedir(), options = {}) {
+    const manifest = options.manifest ?? (await readManifest());
+    const paths = cursorConfigPaths(homeDir);
+    const hooksRead = await readJsonFile(paths.hooksFile);
+    const hooksJson = hooksRead.ok
+        ? classifyCursorHooksJson(hooksRead.value, paths.policyFile)
+        : { state: hooksRead.state, detail: hooksRead.detail };
+    const policy = await classifyCursorAsset(paths.policyFile, CURSOR_POLICY_MARKER, manifest.policy);
+    const remediation = [];
+    for (const [name, asset] of [
+        ["hook registration", hooksJson],
+        ["policy runtime", policy],
+    ]) {
+        if (asset.state === "absent" ||
+            asset.state === "released-outdated" ||
+            asset.state === "foreign") {
+            remediation.push(`install the Cursor ${name} with: javi-forge hooks install cursor`);
+        }
+        else if (asset.state === "edited-managed") {
+            remediation.push(`repair the edited Cursor ${name} with: javi-forge hooks repair cursor --force`);
+        }
+        else if (asset.state !== "managed-current") {
+            remediation.push(`manually review the Cursor ${name} (${asset.state}); it will not be overwritten`);
+        }
+    }
+    return {
+        healthy: hooksJson.state === "managed-current" &&
+            policy.state === "managed-current",
+        hooksJson,
+        policy,
+        remediation: [...new Set(remediation)],
+        runtimeEvidence: "not-implemented",
+    };
+}
+function hookWritePlan(state, force, name) {
+    if (state === "absent" ||
+        state === "released-outdated" ||
+        state === "foreign")
+        return { write: true };
+    if (state === "managed-current")
+        return { write: false };
+    if (state === "edited-managed" && force)
+        return { write: true };
+    if (state === "edited-managed")
+        return {
+            write: false,
+            refusal: `refuse edited ${name}; rerun repair with --force`,
+        };
+    return {
+        write: false,
+        refusal: `refuse ${name} in state ${state} — manual review`,
+    };
+}
+function policyWritePlan(state, force, name) {
+    if (state === "absent" || state === "released-outdated")
+        return { write: true };
+    if (state === "managed-current")
+        return { write: false };
+    if (state === "edited-managed" && force)
+        return { write: true };
+    if (state === "edited-managed")
+        return {
+            write: false,
+            refusal: `refuse edited ${name}; rerun repair with --force`,
+        };
+    return {
+        write: false,
+        refusal: `refuse ${name} in state ${state} — manual review`,
+    };
+}
+function serialize(container) {
+    return Buffer.from(`${JSON.stringify(container, null, 2)}\n`, "utf8");
+}
+export async function _runCursor(homeDir, mode, options, deps = {}) {
+    const manifest = deps.manifest ?? (await readManifest());
+    const paths = cursorConfigPaths(homeDir);
+    const doctorFn = deps.doctor ?? doctorCursorSkillGuard;
+    const doctor = () => doctorFn(homeDir, {
+        manifest,
+        policySource: deps.policySource,
+    });
+    const force = mode === "repair" && options.force === true;
+    const hooksRead = await readJsonFile(paths.hooksFile);
+    const hooksState = hooksRead.ok
+        ? classifyCursorHooksJson(hooksRead.value, paths.policyFile)
+        : { state: hooksRead.state, detail: hooksRead.detail };
+    const policyState = await classifyCursorAsset(paths.policyFile, CURSOR_POLICY_MARKER, manifest.policy);
+    const hookPlan = hookWritePlan(hooksState.state, force, "Cursor hook registration");
+    const policyPlan = policyWritePlan(policyState.state, force, "Cursor policy runtime");
+    if (hookPlan.refusal || policyPlan.refusal) {
+        return {
+            ok: false,
+            changed: [],
+            backups: [],
+            errors: [hookPlan.refusal ?? policyPlan.refusal ?? "refused"],
+            warnings: [],
+            report: await doctor(),
+        };
+    }
+    if (!hookPlan.write && !policyPlan.write) {
+        return {
+            ok: true,
+            changed: [],
+            backups: [],
+            errors: [],
+            warnings: [],
+            report: await doctor(),
+        };
+    }
+    const secureFs = deps.secureFs !== undefined
+        ? deps.secureFs
+        : selectSecureFs(process.platform);
+    if (!secureFs) {
+        return {
+            ok: false,
+            changed: [],
+            backups: [],
+            errors: ["windows-secure-object-unavailable"],
+            warnings: [],
+            report: await doctor(),
+        };
+    }
+    const policySource = deps.policySource ?? SHIPPED_CURSOR_POLICY;
+    const policyBytes = policyPlan.write ? await readFile(policySource) : null;
+    if (policyBytes && sha256(policyBytes) !== manifest.policy.sha256) {
+        return {
+            ok: false,
+            changed: [],
+            backups: [],
+            errors: [
+                "refuse packaged Cursor policy asset with manifest hash mismatch",
+            ],
+            warnings: [],
+            report: await doctor(),
+        };
+    }
+    const existing = hooksRead.ok ? hooksRead.value : undefined;
+    const hookBytes = hookPlan.write
+        ? serialize(mergeCursorHooks(existing, paths.policyFile))
+        : null;
+    const components = [
+        {
+            path: paths.hooksFile,
+            desired: hookBytes,
+            capturePrior: hookPlan.write && hooksState.state !== "absent",
+            forceBackup: force && hooksState.state === "edited-managed",
+            wasAbsent: hooksState.state === "absent",
+        },
+        {
+            path: paths.policyFile,
+            desired: policyBytes,
+            capturePrior: policyPlan.write && policyState.state !== "absent",
+            forceBackup: force && policyState.state === "edited-managed",
+            wasAbsent: policyState.state === "absent",
+        },
+    ];
+    const tx = await runTransaction({
+        secureFs,
+        clock: deps.clock ?? (() => new Date()),
+        nonce: deps.nonce ?? (() => randomBytes(4).toString("hex")),
+        projectDir: homeDir,
+        layout: { containers: [paths.cursorDir, paths.hooksDir], components },
+    });
+    return {
+        ok: tx.ok,
+        changed: tx.committed,
+        backups: tx.backups,
+        errors: tx.errors,
+        warnings: [],
+        report: await doctor(),
+    };
+}
+export function installCursorSkillGuard(homeDir, deps = {}) {
+    return _runCursor(homeDir ?? os.homedir(), "install", {}, deps);
+}
+export function repairCursorSkillGuard(homeDir, options, deps = {}) {
+    return _runCursor(homeDir ?? os.homedir(), "repair", options ?? {}, deps);
+}
+//# sourceMappingURL=cursor-hook-manager.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "javi-forge",
-	"version": "1.41.0",
+	"version": "1.42.0",
 	"description": "Project scaffolding and AI-ready CI bootstrap",
 	"type": "module",
 	"bin": {