feat: add slash commands for Claude/Cursor and switch to core.hooksPath

  - Add 6 reusable slash commands (analyze, review, fix, refactor, test, doc)
    for Claude (.claude/commands/) and Cursor (.cursor/prompts/)
  - Rewrite existing commands to be framework-agnostic (no React assumptions)
  - Switch git hooks from .git/hooks/ wrappers to git core.hooksPath
  - Auto-inject prepare script into package.json so hooks work for all devs
  - Add legacy cleanup for .git/hooks/ ContextKit wrappers
  - Rename hook files from .sh extension to match git conventions

Author: nolrm

CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## [0.9.4] - 2026-02-16
+
+### Added
+- **Slash Commands** for Claude Code (`.claude/commands/`) and Cursor (`.cursor/prompts/`)
+  - `/analyze` — scan codebase and generate standards content
+  - `/review` — code review with checklist
+  - `/fix` — diagnose and fix bugs
+  - `/refactor` — refactor code with safety checks
+  - `/test` — generate comprehensive tests
+  - `/doc` — add documentation
+- Both platforms delegate to universal `.contextkit/commands/` files
+- New command files: `review.md`, `fix.md`, `refactor.md`
+
+### Changed
+- Git hooks now use `git config core.hooksPath .contextkit/hooks` instead of writing to `.git/hooks/`
+- Auto-injects `prepare` script into `package.json` so hooks work for all devs after `npm install`
+- Hook files renamed from `.sh` extension to match git conventions (`pre-push`, `commit-msg`)
+- All existing commands rewritten to be framework-agnostic (no React assumptions)
+- Legacy `.git/hooks/` ContextKit wrappers automatically cleaned up
+
+### Fixed
+- Gradle quality gate now checks for `gradlew` and verifies `check` task exists
+- Go and Maven gates skip when no source files exist
+
 ## [0.9.0] - 2026-02-16
 
 ### Added
@@ -16,7 +40,7 @@
 - Integration test suite for framework detection and hook installation
 
 ### Changed
-- Git hooks now install to `.git/hooks/` (native) instead of `.husky/`
+- Git hooks now use native approach instead of Husky
 - Hooks work in any git repo — no longer requires package.json or Node.js
 - `ck install` hooks prompt now checks for `.git/` instead of `package.json`
 - Install prompt updated with "Quality Gates" branding

README.md

@@ -111,13 +111,17 @@ Each platform generates bridge files that the AI tool auto-reads. If a bridge fi
 
 ## Use it in your tool
 
-**Cursor** — rules auto-load from `.cursor/rules/`
+**Cursor** — rules auto-load from `.cursor/rules/`, slash commands in `.cursor/prompts/`
 ```
-@.contextkit/commands/analyze.md
+/analyze    # scan codebase and generate standards
+/review     # code review with checklist
+/fix        # diagnose and fix bugs
 ```
 
-**Claude Code** — reads `CLAUDE.md` + `.claude/rules/` automatically
+**Claude Code** — reads `CLAUDE.md` + `.claude/rules/`, slash commands in `.claude/commands/`
 ```bash
+/analyze    # scan codebase and generate standards
+/review     # code review with checklist
 claude "create checkout flow for customer"
 ```
 
@@ -133,14 +137,36 @@ codex "create checkout flow for customer"
 
 **CLI** (Chat with AI)
 ```bash
-ck ai "create checkout flow for customer"
+ck ai "create a button"
 ```
 
 ---
 
+## Slash Commands
+
+ContextKit installs reusable slash commands for supported platforms:
+
+| Command | What it does |
+|---------|-------------|
+| `/analyze` | Scan codebase and generate standards content |
+| `/review` | Code review with checklist |
+| `/fix` | Diagnose and fix bugs |
+| `/refactor` | Refactor code with safety checks |
+| `/test` | Generate comprehensive tests |
+| `/doc` | Add documentation |
+
+**Claude Code** — available as `/analyze`, `/review`, etc. in `.claude/commands/`
+**Cursor** — available as slash commands in Chat via `.cursor/prompts/`
+
+Both platforms delegate to the universal command files in `.contextkit/commands/`, so you maintain one set of workflows.
+
+---
+
 ## Git Hooks & Quality Gates
 
-ContextKit can optionally install native Git hooks (`.git/hooks/`) during `ck install`. No external dependencies like Husky required — works in any git repo, not just Node.js projects.
+ContextKit can optionally install Git hooks during `ck install`. Uses `git config core.hooksPath` to point Git at `.contextkit/hooks/` — no external dependencies like Husky required. Works in any git repo, not just Node.js projects.
+
+For **Node.js projects**, a `prepare` script is automatically added to `package.json` so hooks activate for all developers after `npm install` — no need for everyone to run `ck install`.
 
 | Hook | What it does |
 |------|-------------|

__tests__/integration/quality-gates.test.js

@@ -3,7 +3,7 @@ const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
 
-const prePushScript = path.join(__dirname, '../../hooks/pre-push.sh');
+const prePushScript = path.join(__dirname, '../../hooks/pre-push');
 const setupScript = path.join(__dirname, '../../hooks/setup-hooks.sh');
 
 let tmpDir;
@@ -28,17 +28,15 @@ function runPrePush() {
 }
 
 // Run with minimal PATH so framework tools (cargo, go, mvn, etc.) are not found.
-// This prevents failures from CI-installed tools running against minimal project files.
 function runPrePushMinimalPath() {
   return execSync(`bash "${prePushScript}"`, {
     encoding: 'utf8',
     env: { ...process.env, PATH: '/usr/bin:/bin' }
   });
 }
 
-describe('Quality Gates — pre-push.sh framework detection', () => {
+describe('Quality Gates — pre-push framework detection', () => {
   it('1. detects Node.js project (package.json)', async () => {
-    // Use a name that won't trigger gate grep patterns (no "test", "build", etc.)
     await fs.writeJson('package.json', { name: 'my-app', version: '1.0.0' });
     const output = runPrePush();
     expect(output).toContain('Quality Gates');
@@ -100,41 +98,31 @@ describe('Quality Gates — pre-push.sh framework detection', () => {
   });
 
   it('11. Node.js gates skip gracefully when tools are not in package.json', async () => {
-    // Minimal package.json with no tools or scripts referenced
     await fs.writeJson('package.json', { name: 'bare-project', version: '1.0.0' });
     const output = runPrePush();
     expect(output).toContain('Project: node');
     expect(output).toContain('passed');
-    // Should not fail — no gates triggered
   });
 
   it('12. Python gates skip gracefully when tools are not installed', async () => {
     await fs.writeFile('requirements.txt', 'flask\n');
-    // Create a restricted PATH so tools aren't found
-    const output = execSync(`bash "${prePushScript}"`, {
-      encoding: 'utf8',
-      env: { ...process.env, PATH: '/usr/bin:/bin' }
-    });
+    const output = runPrePushMinimalPath();
     expect(output).toContain('Project: python');
     expect(output).toContain('skipped');
   });
 });
 
 describe('Quality Gates — setup-hooks.sh', () => {
-  it('13. installs hooks to .git/hooks/ in a git repo', async () => {
+  it('13. sets core.hooksPath via setup script', async () => {
     execSync('git init', { stdio: 'pipe' });
     await fs.ensureDir('.contextkit/hooks');
-    await fs.writeFile('.contextkit/hooks/pre-push.sh', '#!/bin/sh\nexit 0');
-    await fs.writeFile('.contextkit/hooks/commit-msg.sh', '#!/bin/sh\nexit 0');
+    await fs.writeFile('.contextkit/hooks/pre-push', '#!/bin/sh\nexit 0');
+    await fs.writeFile('.contextkit/hooks/commit-msg', '#!/bin/sh\nexit 0');
 
     execSync(`bash "${setupScript}"`, { encoding: 'utf8' });
 
-    expect(fs.existsSync('.git/hooks/pre-push')).toBe(true);
-    expect(fs.existsSync('.git/hooks/commit-msg')).toBe(true);
-
-    const prePush = await fs.readFile('.git/hooks/pre-push', 'utf8');
-    expect(prePush).toContain('ContextKit managed hook');
-    expect(prePush).toContain('.contextkit/hooks/pre-push.sh "$@"');
+    const hooksPath = execSync('git config core.hooksPath', { encoding: 'utf8' }).trim();
+    expect(hooksPath).toBe('.contextkit/hooks');
   });
 
   it('14. fails if not a git repo', () => {
@@ -145,24 +133,23 @@ describe('Quality Gates — setup-hooks.sh', () => {
 });
 
 describe('Quality Gates — GitHooksManager end-to-end', () => {
-  it('15. full install flow: hooks land in .git/hooks/ and delegate correctly', async () => {
+  it('15. full flow: core.hooksPath set, hook executes correctly', async () => {
     const GitHooksManager = require('../../lib/utils/git-hooks');
 
     execSync('git init', { stdio: 'pipe' });
     await fs.ensureDir('.contextkit/hooks');
-    await fs.writeFile('.contextkit/hooks/pre-push.sh', '#!/bin/sh\nexit 0');
-    await fs.chmod('.contextkit/hooks/pre-push.sh', '755');
+    await fs.writeFile('.contextkit/hooks/pre-push', '#!/bin/sh\necho "hook ran"\nexit 0');
+    await fs.chmod('.contextkit/hooks/pre-push', '755');
 
     const manager = new GitHooksManager();
     await manager.installHooks('npm', { prePush: true, commitMsg: false });
 
-    // Verify the hook exists and is executable
-    const hookPath = '.git/hooks/pre-push';
-    expect(fs.existsSync(hookPath)).toBe(true);
-    const stat = await fs.stat(hookPath);
-    expect(stat.mode & 0o111).toBeTruthy();
+    // Verify core.hooksPath is set
+    const hooksPath = execSync('git config core.hooksPath', { encoding: 'utf8' }).trim();
+    expect(hooksPath).toBe('.contextkit/hooks');
 
-    // Actually run the hook — it should delegate to our dummy script and exit 0
-    execSync(`./${hookPath}`, { encoding: 'utf8' });
+    // Actually run the hook directly
+    const output = execSync('.contextkit/hooks/pre-push', { encoding: 'utf8' });
+    expect(output).toContain('hook ran');
   });
 });

__tests__/integrations/claude-integration.test.js

@@ -64,14 +64,17 @@ describe('ClaudeIntegration', () => {
     expect(content).toContain('lib/**');
   });
 
-  test('5. creates .claude/commands/analyze.md', async () => {
+  test('5. creates all slash command files', async () => {
     const integration = new ClaudeIntegration();
     await integration.install();
 
-    const filePath = '.claude/commands/analyze.md';
-    expect(await fs.pathExists(filePath)).toBe(true);
-    const content = await fs.readFile(filePath, 'utf-8');
-    expect(content).toContain('analyze');
+    const commands = ['analyze', 'review', 'fix', 'refactor', 'test', 'doc'];
+    for (const cmd of commands) {
+      const filePath = `.claude/commands/${cmd}.md`;
+      expect(await fs.pathExists(filePath)).toBe(true);
+      const content = await fs.readFile(filePath, 'utf-8');
+      expect(content).toContain('.contextkit/commands/');
+    }
   });
 
   test('6. appends to existing CLAUDE.md without overwriting', async () => {

__tests__/integrations/cursor-integration.test.js

@@ -68,7 +68,20 @@ describe('CursorIntegration', () => {
     expect(await fs.pathExists('.cursor/rules/contextkit-standards.mdc')).toBe(true);
   });
 
-  test('6. validate returns valid after install', async () => {
+  test('6. creates all prompt files for slash commands', async () => {
+    const integration = new CursorIntegration();
+    await integration.install();
+
+    const prompts = ['analyze', 'review', 'fix', 'refactor', 'test', 'doc'];
+    for (const prompt of prompts) {
+      const filePath = `.cursor/prompts/${prompt}.md`;
+      expect(await fs.pathExists(filePath)).toBe(true);
+      const content = await fs.readFile(filePath, 'utf-8');
+      expect(content).toContain('.contextkit/commands/');
+    }
+  });
+
+  test('7. validate returns valid after install', async () => {
     const integration = new CursorIntegration();
     await integration.install();