@rigour-labs/cli 5.4.0 → 5.5.1

package/README.md

@@ -29,7 +29,7 @@ brew install rigour
 
 AI agents are powerful but ungoverned. They claim success based on narrative, not execution. Credentials get cached in agent memory. Imports get hallucinated. Code quality drifts across sessions.
 
-**Rigour breaks this cycle** with deterministic PASS/FAIL gates, credential interception, and memory governance — all local-first.
+**Rigour breaks this cycle** with deterministic PASS/FAIL gates, credential warnings, and memory governance — all local-first.
 
 ## 🔄 How It Works
 
@@ -80,7 +80,7 @@ Every failure carries a provenance tag (`ai-drift`, `traditional`, `security`, `
 
 ## 🔒 AI Agent DLP (Data Loss Prevention)
 
-Real-time credential interception via PreToolUse hooks — blocks credentials before agents see them.
+Real-time credential detection via PreToolUse hooks — warns by default before agent actions.
 
 - **29 credential patterns**: AWS, GCP, Azure, OpenAI, Anthropic, GitHub, Stripe, private keys, database URLs, JWTs, CI/CD tokens
 - **Anti-evasion**: Unicode normalization, zero-width char removal, bidi control stripping, Shannon entropy detection (>4.5 bits)

package/dist/cli.js

@@ -267,7 +267,7 @@ const hooksCmd = program
     .description('Manage AI coding tool hook integrations (file checks + DLP credential scanning)')
     .addHelpText('after', `
 DLP false-positive learning:
-  When a hook blocks your prompt incorrectly, teach Rigour once:
+  When a hook warns about your prompt incorrectly, teach Rigour once:
   $ rigour hooks check --dlp-allow-last
 
   Learned patterns are stored per-project in .rigour/dlp-feedback.json.
@@ -305,7 +305,7 @@ hooksCmd
     .option('--timeout <ms>', 'Timeout in milliseconds (default: 5000)')
     .option('--mode <mode>', 'Check mode: "check" (default) or "dlp" (credential scanning)')
     .option('--agent <name>', 'Agent name for DLP audit trail (e.g., cursor, claude)')
-    .option('--dlp-allow-last', 'Record last DLP block as learned false positives (hook feedback)')
+    .option('--dlp-allow-last', 'Record the last DLP warning as learned false positives (hook feedback)')
     .addHelpText('after', `
 Examples:
   $ rigour hooks check --files src/app.ts
@@ -315,8 +315,8 @@ Examples:
   $ rigour hooks check --dlp-allow-last
 
 DLP learning:
-  After a false-positive block, run --dlp-allow-last to store the detection shape
-  in .rigour/dlp-feedback.json. Future scans allow matching patterns on the same line.
+  After a false-positive warning, run --dlp-allow-last to store a safe fingerprint
+  in .rigour/dlp-feedback.json. Future scans allow matching generic patterns.
   Provider keys and high-confidence secrets are never learned away.
     `)
     .action(async (options) => {

package/dist/commands/export-audit.js

@@ -135,6 +135,8 @@ function buildAuditPackage(cwd, report, config) {
         score_trend: trend ? {
             direction: trend.direction,
             delta: trend.delta,
+            visible_delta: trend.visibleDelta
+                ?? trend.recentScores[trend.recentScores.length - 1] - trend.recentScores[0],
             recent_average: trend.recentAvg,
             previous_average: trend.previousAvg,
             last_scores: trend.recentScores,
@@ -234,7 +236,8 @@ function renderMarkdown(audit) {
         lines.push(`**Direction:** ${audit.score_trend.direction} ${arrow}`);
         lines.push(`**Recent Average:** ${audit.score_trend.recent_average}/100`);
         lines.push(`**Previous Average:** ${audit.score_trend.previous_average}/100`);
-        lines.push(`**Delta:** ${audit.score_trend.delta > 0 ? '+' : ''}${audit.score_trend.delta}`);
+        lines.push(`**Visible Delta:** ${audit.score_trend.visible_delta > 0 ? '+' : ''}${audit.score_trend.visible_delta}`);
+        lines.push(`**Window Average Delta:** ${audit.score_trend.delta > 0 ? '+' : ''}${audit.score_trend.delta}`);
         lines.push(`**Recent Scores:** ${audit.score_trend.last_scores.join(' → ')}`);
         lines.push('');
     }

package/dist/commands/guide.js

@@ -13,9 +13,9 @@ export function guideCommand() {
     console.log(chalk.yellow('  • Strategic Guardians') + chalk.dim(': Dependency and Architectural boundary enforcement.\n'));
     console.log(chalk.bold('Hooks & DLP Learning:'));
     console.log(chalk.dim('  1. Run ') + chalk.cyan('rigour hooks init') + chalk.dim(' to wire Cursor/Claude/Cline/Windsurf hooks.'));
-    console.log(chalk.dim('  2. When DLP blocks a prompt falsely, run ') + chalk.cyan('rigour hooks check --dlp-allow-last'));
+    console.log(chalk.dim('  2. When DLP warns about a prompt falsely, run ') + chalk.cyan('rigour hooks check --dlp-allow-last'));
     console.log(chalk.dim('     to teach Rigour that pattern is safe (stored in ') + chalk.cyan('.rigour/dlp-feedback.json') + chalk.dim(').'));
-    console.log(chalk.dim('  3. Real provider keys (OpenAI, AWS, etc.) still block — learning only relaxes generic shapes.\n'));
+    console.log(chalk.dim('  3. Real provider keys (OpenAI, AWS, etc.) cannot be learned away.\n'));
     console.log(chalk.bold('Workflow Integration:'));
     console.log(chalk.green('  • Cursor') + chalk.dim(': Add the MCP server or use the ') + chalk.cyan('.cursor/rules/rigour.mdc') + chalk.dim(' handshake.'));
     console.log(chalk.green('  • CI/CD') + chalk.dim(': Use ') + chalk.cyan('rigour check --ci') + chalk.dim(' to fail PRs that violate quality gates.'));

package/dist/commands/hooks.d.ts

@@ -18,7 +18,7 @@ export interface HooksOptions {
     dryRun?: boolean;
     force?: boolean;
     block?: boolean;
-    /** Also generate DLP (pre-input credential interception) hooks */
+    /** Also generate DLP pre-input warning hooks */
     dlp?: boolean;
 }
 export interface HooksCheckOptions {
@@ -30,7 +30,7 @@ export interface HooksCheckOptions {
     mode?: 'check' | 'dlp';
     /** Agent name for audit trail (DLP mode) */
     agent?: string;
-    /** Record last DLP block detections as learned false positives (hook feedback) */
+    /** Record last DLP warning detections as learned false positives (hook feedback) */
     dlpAllowLast?: boolean;
 }
 export declare function hooksInitCommand(cwd: string, options?: HooksOptions): Promise<void>;

package/dist/commands/hooks.js

@@ -17,7 +17,18 @@ import fs from 'fs-extra';
 import path from 'path';
 import chalk from 'chalk';
 import { randomUUID } from 'crypto';
+import { fileURLToPath } from 'url';
 import { runHookChecker, scanInputForCredentials, formatDLPAlert, createDLPAuditEntry, writeDLPBlockManifest, allowLastDLPBlock } from '@rigour-labs/core';
+function getHookCliVersion() {
+    const thisDir = path.dirname(fileURLToPath(import.meta.url));
+    const packagePath = path.resolve(thisDir, '../../package.json');
+    const pkg = fs.readJsonSync(packagePath);
+    const version = pkg.version?.trim();
+    if (!version || !/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(version)) {
+        throw new Error('Unable to resolve the installed Rigour CLI version');
+    }
+    return version;
+}
 // ── Studio event logging ─────────────────────────────────────────────
 const MAX_EVENT_LOG_LINES = 2000;
 async function logStudioEvent(cwd, event) {
@@ -74,20 +85,11 @@ function detectTools(cwd) {
     }
     return detected;
 }
-function resolveCheckerCommand(cwd) {
-    // 1. Try project-local node_modules (installed as dependency)
-    const localPath = path.join(cwd, 'node_modules', '@rigour-labs', 'core', 'dist', 'hooks', 'standalone-checker.js');
-    if (fs.existsSync(localPath)) {
-        return { command: 'node', args: [localPath] };
-    }
-    // 2. Try dev checkout: ESM has no __dirname, derive from import.meta.url
-    const thisDir = path.dirname(new URL(import.meta.url).pathname);
-    const localCli = path.resolve(thisDir, '../cli.js');
-    if (fs.existsSync(localCli)) {
-        return { command: 'node', args: [localCli, 'hooks', 'check'] };
-    }
-    // 3. Fallback: assume globally installed or aliased
-    return { command: 'npx', args: ['@rigour-labs/cli', 'hooks', 'check'] };
+function resolveCheckerCommand() {
+    return {
+        command: 'npx',
+        args: ['--yes', `@rigour-labs/cli@${getHookCliVersion()}`, 'hooks', 'check'],
+    };
 }
 function shellEscape(arg) {
     if (/^[A-Za-z0-9_/@%+=:,.-]+$/.test(arg)) {
@@ -136,7 +138,7 @@ function generateClaudeHooks(checker, block, dlp = true) {
                     }]
             }],
     };
-    // DLP: Add PreToolUse hook for credential interception
+    // DLP: Add PreToolUse hook for credential warnings
     if (dlp) {
         hooks.PreToolUse = [{
                 matcher: ".*",
@@ -151,7 +153,7 @@ function generateClaudeHooks(checker, block, dlp = true) {
             path: '.claude/settings.json',
             content: JSON.stringify(settings, null, 4),
             description: dlp
-                ? 'Claude Code hooks — PostToolUse quality checks + PreToolUse DLP credential interception'
+                ? 'Claude Code hooks — PostToolUse quality checks + PreToolUse DLP credential warnings'
                 : 'Claude Code PostToolUse hook',
         }];
 }
@@ -169,7 +171,7 @@ function generateCursorHooks(checker, block, dlp = true) {
             path: '.cursor/hooks.json',
             content: JSON.stringify(hooks, null, 4),
             description: dlp
-                ? 'Cursor hooks — afterFileEdit quality checks + beforeSubmitPrompt DLP credential interception'
+                ? 'Cursor hooks — afterFileEdit quality checks + beforeSubmitPrompt DLP warnings'
                 : 'Cursor afterFileEdit hook config',
         }];
 }
@@ -185,7 +187,7 @@ function generateClineHooks(checker, block, dlp = true) {
             path: '.clinerules/hooks/PreToolUse',
             content: buildClineDLPScript(checker),
             executable: true,
-            description: 'Cline PreToolUse DLP hook — credential interception before agent execution',
+            description: 'Cline PreToolUse DLP hook — credential warnings before agent execution',
         });
     }
     return files;
@@ -251,7 +253,7 @@ function buildClineDLPScript(checker) {
     return `#!/usr/bin/env node
 /**
  * Cline PreToolUse DLP hook for Rigour.
- * Scans tool input for credentials BEFORE agent execution.
+ * Warns about possible credentials before agent execution.
  */
 let data = '';
 process.stdin.on('data', chunk => { data += chunk; });
@@ -288,14 +290,15 @@ process.stdin.on('end', async () => {
             return;
         }
         const result = JSON.parse(raw);
-        if (result.status === 'blocked') {
+        if (result.status !== 'clean') {
             const msgs = result.detections
                 .map(d => \`[rigour/dlp/\${d.type}] \${d.description} → \${d.recommendation}\`)
                 .join('\\n');
+            const label = result.status === 'blocked' ? 'BLOCKED' : 'warning';
             process.stdout.write(JSON.stringify({
-                contextModification: \`\\n🛑 [Rigour DLP] \${result.detections.length} credential(s) BLOCKED:\\n\${msgs}\\nReplace with environment variable references.\`,
+                contextModification: \`\\n⚠️ [Rigour DLP] \${result.detections.length} possible credential(s) \${label}:\\n\${msgs}\`,
             }));
-            process.exit(2);
+            if (result.status === 'blocked') process.exit(2);
         } else {
             process.stdout.write(JSON.stringify({}));
         }
@@ -320,7 +323,7 @@ function generateWindsurfHooks(checker, block, dlp = true) {
             path: '.windsurf/hooks.json',
             content: JSON.stringify(hooks, null, 4),
             description: dlp
-                ? 'Windsurf hooks — post_write_code quality checks + pre_write_code DLP credential interception'
+                ? 'Windsurf hooks — post_write_code quality checks + pre_write_code DLP warnings'
                 : 'Windsurf post_write_code hook config',
         }];
 }
@@ -345,6 +348,7 @@ function printDryRun(files) {
 async function writeHookFiles(cwd, files, force) {
     let written = 0;
     let skipped = 0;
+    const failedPaths = new Set();
     for (const file of files) {
         const fullPath = path.join(cwd, file.path);
         const exists = await fs.pathExists(fullPath);
@@ -353,16 +357,28 @@ async function writeHookFiles(cwd, files, force) {
             skipped++;
             continue;
         }
-        await fs.ensureDir(path.dirname(fullPath));
-        await fs.writeFile(fullPath, file.content, 'utf-8');
-        if (file.executable) {
-            await fs.chmod(fullPath, 0o755);
-        }
-        console.log(chalk.green(`  CREATE ${file.path}`));
-        console.log(chalk.dim(`         ${file.description}`));
-        written++;
-    }
-    return { written, skipped };
+        try {
+            await fs.ensureDir(path.dirname(fullPath));
+            await fs.writeFile(fullPath, file.content, 'utf-8');
+            if (file.executable) {
+                await fs.chmod(fullPath, 0o755);
+            }
+            console.log(chalk.green(`  CREATE ${file.path}`));
+            console.log(chalk.dim(`         ${file.description}`));
+            written++;
+        }
+        catch (error) {
+            const code = error instanceof Error && 'code' in error
+                ? String(error.code)
+                : 'UNKNOWN';
+            const reason = code === 'ENOTDIR'
+                ? 'a parent path is a file; keep the existing config and configure this tool manually'
+                : error instanceof Error ? error.message : String(error);
+            console.error(chalk.yellow(`  SKIP ${file.path} (${reason})`));
+            failedPaths.add(file.path);
+        }
+    }
+    return { written, skipped, failedPaths };
 }
 // ── Next-steps guidance ──────────────────────────────────────────────
 const NEXT_STEPS = {
@@ -371,10 +387,15 @@ const NEXT_STEPS = {
     cline: 'Cline: Hook is active. Quality feedback appears in agent context on violations.',
     windsurf: 'Windsurf: Reload editor. Check terminal for Rigour output after Cascade writes.',
 };
-function printNextSteps(tools) {
+function printNextSteps(tools, unavailableTools) {
     console.log(chalk.cyan('\nNext steps:'));
     for (const tool of tools) {
-        console.log(chalk.dim(`  ${NEXT_STEPS[tool]}`));
+        if (unavailableTools.has(tool)) {
+            console.log(chalk.yellow(`  ${tool[0].toUpperCase() + tool.slice(1)}: Not configured; resolve the path conflict or configure manually.`));
+        }
+        else {
+            console.log(chalk.dim(`  ${NEXT_STEPS[tool]}`));
+        }
     }
     console.log('');
 }
@@ -387,7 +408,7 @@ export async function hooksInitCommand(cwd, options = {}) {
         arguments: { tool: options.tool, dryRun: options.dryRun, dlp: options.dlp },
     });
     const tools = resolveTools(cwd, options.tool);
-    const checker = resolveCheckerCommand(cwd);
+    const checker = resolveCheckerCommand();
     const block = !!options.block;
     // DLP is ON by default — user must explicitly pass --no-dlp to disable
     const dlp = options.dlp !== false;
@@ -400,7 +421,12 @@ export async function hooksInitCommand(cwd, options = {}) {
         printDryRun(allFiles);
         return;
     }
-    const { written, skipped } = await writeHookFiles(cwd, allFiles, !!options.force);
+    const { written, skipped, failedPaths } = await writeHookFiles(cwd, allFiles, !!options.force);
+    const failed = failedPaths.size;
+    const unavailableTools = new Set(tools.filter(tool => {
+        const generatedPaths = GENERATORS[tool](checker, block, dlp).map(file => file.path);
+        return generatedPaths.every(filePath => failedPaths.has(filePath));
+    }));
     console.log('');
     if (written > 0) {
         console.log(chalk.green.bold(`Created ${written} hook file(s).`));
@@ -408,17 +434,24 @@ export async function hooksInitCommand(cwd, options = {}) {
     if (skipped > 0) {
         console.log(chalk.yellow(`Skipped ${skipped} existing file(s).`));
     }
-    printNextSteps(tools);
+    if (failed > 0) {
+        console.log(chalk.yellow(`Skipped ${failed} incompatible hook file(s); other tools were configured.`));
+    }
+    printNextSteps(tools, unavailableTools);
     if (dlp) {
-        console.log(chalk.red.bold('  🛑 DLP Protection ACTIVE'));
-        console.log(chalk.dim('  Credentials will be intercepted BEFORE reaching AI agents.'));
+        console.log(chalk.yellow.bold('  ⚠ DLP warnings ACTIVE'));
+        console.log(chalk.dim('  Possible credentials will be reported before agent actions.'));
+        console.log(chalk.dim('  Use --block only when every input path is covered by the same policy.'));
         console.log(chalk.dim('  Coverage: AWS keys, API tokens, database URLs, private keys, JWTs, passwords.\n'));
     }
     await logStudioEvent(cwd, {
         type: 'tool_response',
         tool: 'rigour_hooks_init',
-        status: 'success',
-        content: [{ type: 'text', text: `Generated hooks for: ${tools.join(', ')}${options.dlp ? ' (+ DLP)' : ''}` }],
+        status: failed > 0 ? 'partial' : 'success',
+        content: [{
+                type: 'text',
+                text: `Generated hooks for: ${tools.join(', ')}; ${written} written, ${skipped} existing, ${failed} incompatible`,
+            }],
     });
 }
 async function readStdin() {
@@ -533,19 +566,26 @@ export async function hooksCheckCommand(cwd, options = {}) {
         }
         const result = scanInputForCredentials(textToScan, {
             enabled: true,
-            block_on_detection: options.block ?? true,
+            block_on_detection: options.block ?? false,
             cwd,
             use_learned_feedback: true,
         });
+        const messages = result.detections
+            .map((d) => `[${d.type}] ${d.description} → ${d.recommendation}`)
+            .join('\n');
+        const allowCommand = `npx --yes @rigour-labs/cli@${getHookCliVersion()} hooks check --dlp-allow-last`;
         // Return Cursor-compatible format if detected as Cursor hook
         if (cursorMode) {
             if (result.status === 'blocked') {
-                const messages = result.detections
-                    .map((d) => `[${d.type}] ${d.description} → ${d.recommendation}`)
-                    .join('\n');
                 process.stdout.write(JSON.stringify({
                     continue: false,
-                    user_message: `🛑 Rigour DLP: ${result.detections.length} credential(s) detected in your prompt:\n${messages}\n\nReplace with environment variable references before submitting.\n\nIf this is a false positive, run: rigour hooks check --dlp-allow-last`,
+                    user_message: `🛑 Rigour DLP: ${result.detections.length} credential(s) detected in your prompt:\n${messages}\n\nReplace with environment variable references before submitting.\n\nIf this is a false positive, run: ${allowCommand}`,
+                }));
+            }
+            else if (result.status === 'warning') {
+                process.stdout.write(JSON.stringify({
+                    continue: true,
+                    user_message: `⚠️ Rigour DLP warning: ${result.detections.length} possible credential(s) detected:\n${messages}`,
                 }));
             }
             else {
@@ -567,13 +607,13 @@ export async function hooksCheckCommand(cwd, options = {}) {
             catch {
                 // Silent
             }
+            try {
+                await writeDLPBlockManifest(cwd, result.detections, textToScan);
+            }
+            catch {
+                // best-effort
+            }
             if (result.status === 'blocked') {
-                try {
-                    await writeDLPBlockManifest(cwd, result.detections, textToScan);
-                }
-                catch {
-                    // best-effort
-                }
                 process.exitCode = 2;
             }
         }

package/dist/commands/hooks.test.js

@@ -44,6 +44,17 @@ describe('hooksInitCommand', () => {
         const hookPath = path.join(testDir, '.clinerules', 'hooks', 'PostToolUse');
         expect(fs.existsSync(hookPath)).toBe(true);
     });
+    it('should skip a legacy .clinerules file and continue other tools', async () => {
+        fs.writeFileSync(path.join(testDir, '.clinerules'), 'legacy Cline rules');
+        await expect(hooksInitCommand(testDir, {
+            tool: 'cline,windsurf',
+        })).resolves.toBeUndefined();
+        expect(fs.readFileSync(path.join(testDir, '.clinerules'), 'utf-8'))
+            .toBe('legacy Cline rules');
+        expect(fs.existsSync(path.join(testDir, '.windsurf', 'hooks.json'))).toBe(true);
+        expect(console.error).toHaveBeenCalledWith(expect.stringContaining('SKIP .clinerules/hooks/PostToolUse'));
+        expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Cline: Not configured'));
+    });
     it('should generate Windsurf hooks', async () => {
         await hooksInitCommand(testDir, { tool: 'windsurf' });
         const hooksPath = path.join(testDir, '.windsurf', 'hooks.json');
@@ -109,6 +120,8 @@ describe('hooksInitCommand — DLP integration', () => {
         expect(settings.hooks.PostToolUse).toBeDefined();
         expect(settings.hooks.PreToolUse).toBeDefined();
         expect(settings.hooks.PreToolUse[0].hooks[0].command).toContain('--mode dlp');
+        expect(settings.hooks.PreToolUse[0].hooks[0].command)
+            .toMatch(/npx --yes @rigour-labs\/cli@\d+\.\d+\.\d+/);
     });
     it('should generate Cursor hooks with DLP (beforeFileEdit) by default', async () => {
         await hooksInitCommand(testDir, { tool: 'cursor', force: true });
@@ -131,6 +144,22 @@ describe('hooksInitCommand — DLP integration', () => {
         expect(settings.hooks.PostToolUse).toBeDefined();
         expect(settings.hooks.PreToolUse).toBeUndefined();
     });
+    it('should generate Cline DLP warnings without default blocking', async () => {
+        await hooksInitCommand(testDir, { tool: 'cline', force: true });
+        const script = fs.readFileSync(path.join(testDir, '.clinerules', 'hooks', 'PreToolUse'), 'utf-8');
+        expect(script).toContain("result.status !== 'clean'");
+        expect(script).toContain("if (result.status === 'blocked') process.exit(2)");
+    });
+    it('should not route DLP hooks through the file-only core checker', async () => {
+        const coreChecker = path.join(testDir, 'node_modules/@rigour-labs/core/dist/hooks/standalone-checker.js');
+        fs.mkdirSync(path.dirname(coreChecker), { recursive: true });
+        fs.writeFileSync(coreChecker, '');
+        await hooksInitCommand(testDir, { tool: 'cursor', force: true });
+        const hooks = JSON.parse(fs.readFileSync(path.join(testDir, '.cursor', 'hooks.json'), 'utf-8'));
+        const command = hooks.hooks.beforeSubmitPrompt[0].command;
+        expect(command).toMatch(/npx --yes @rigour-labs\/cli@\d+\.\d+\.\d+/);
+        expect(command).not.toContain('standalone-checker');
+    });
 });
 describe('hooksCheckCommand', () => {
     let testDir;
@@ -164,4 +193,32 @@ describe('hooksCheckCommand', () => {
         expect(process.exitCode).toBe(2);
         process.exitCode = originalExitCode;
     });
+    it('should warn and continue for DLP detections by default', async () => {
+        const stdoutSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        const stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+        const originalExitCode = process.exitCode;
+        await hooksCheckCommand(testDir, {
+            mode: 'dlp',
+            files: 'AKIAZ9Y8X7W6V5U4T3Q2',
+        });
+        const output = stdoutSpy.mock.calls.map(call => String(call[0])).join('');
+        expect(output).toContain('"status":"warning"');
+        expect(output).not.toContain('AKIAZ9Y8X7W6V5U4T3Q2');
+        expect(stderrSpy).toHaveBeenCalled();
+        expect(process.exitCode).toBe(originalExitCode);
+    });
+    it('should block DLP detections only with --block', async () => {
+        const stdoutSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+        const originalExitCode = process.exitCode;
+        await hooksCheckCommand(testDir, {
+            mode: 'dlp',
+            files: 'AKIAZ9Y8X7W6V5U4T3Q2',
+            block: true,
+        });
+        const output = stdoutSpy.mock.calls.map(call => String(call[0])).join('');
+        expect(output).toContain('"status":"blocked"');
+        expect(process.exitCode).toBe(2);
+        process.exitCode = originalExitCode;
+    });
 });

package/dist/commands/init.js

@@ -472,6 +472,12 @@ const IDE_TO_HOOK_TOOL = {
     cline: 'cline',
     windsurf: 'windsurf',
 };
+const PRIMARY_HOOK_PATH = {
+    claude: '.claude/settings.json',
+    cursor: '.cursor/hooks.json',
+    cline: '.clinerules/hooks/PostToolUse',
+    windsurf: '.windsurf/hooks.json',
+};
 /**
  * Build the pattern index so rigour_check_pattern can detect duplicates.
  * Uses semantic embeddings by default for fuzzy matching.
@@ -511,14 +517,16 @@ async function initHooksForAllDetectedTools(cwd, detectedIDEs) {
         try {
             console.log(chalk.dim(`\n   Setting up real-time hooks for ${ide}...`));
             await hooksInitCommand(cwd, { tool: hookTool, dlp: true, force: true, block: true });
-            enabledTools.push(hookTool);
+            if (await fs.pathExists(path.join(cwd, PRIMARY_HOOK_PATH[hookTool]))) {
+                enabledTools.push(hookTool);
+            }
         }
         catch (err) {
             console.log(chalk.dim(`   (Hooks setup for ${ide} failed: ${err?.message || err})`));
         }
     }
     if (enabledTools.length > 0) {
-        console.log(chalk.dim(`   🛑 DLP protection active for: ${enabledTools.join(', ')}`));
+        console.log(chalk.dim(`   ⚠ DLP warnings active for: ${enabledTools.join(', ')}`));
     }
     return enabledTools;
 }