@rigour-labs/core 5.5.0 → 5.5.1

package/dist/gates/hallucinated-imports/js-resolver.js

@@ -12,6 +12,7 @@ import fs from 'fs-extra';
 import path from 'path';
 import ts from 'typescript';
 import { isNodeBuiltin } from '../hallucinated-imports-stdlib.js';
+import { resolveTsPathTarget } from './ts-path-target.js';
 /**
  * Check JavaScript/TypeScript imports in a source file and add hallucinated findings.
  */
@@ -148,7 +149,7 @@ export async function resolveTsPathAlias(file, importPath, cwd, projectFiles, ts
             continue;
         for (const target of rule.targets) {
             const candidatePattern = rule.hasWildcard ? target.replace('*', wildcard) : target;
-            if (resolveTsPathTarget(config.baseDir, candidatePattern, cwd, projectFiles)) {
+            if (await resolveTsPathTarget(config.baseDir, candidatePattern, cwd, projectFiles)) {
                 return true;
             }
         }
@@ -169,20 +170,6 @@ function matchTsPathRule(rule, importPath) {
     }
     return importPath.slice(rule.prefix.length, importPath.length - rule.suffix.length);
 }
-/**
- * Check if a TypeScript path target resolves to an actual project file.
- */
-function resolveTsPathTarget(baseDir, candidatePattern, cwd, projectFiles) {
-    const absolute = path.resolve(baseDir, candidatePattern);
-    const relative = path.relative(cwd, absolute).replace(/\\/g, '/');
-    const normalized = relative.replace(/\/$/, '');
-    const extensions = ['', '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.d.ts'];
-    const candidates = [
-        ...extensions.map(ext => normalized + ext),
-        ...extensions.map(ext => `${normalized}/index${ext}`),
-    ];
-    return candidates.some(c => projectFiles.has(c));
-}
 /**
  * Find and load TypeScript/JavaScript config for a file.
  * Walks up the directory tree to find tsconfig.json or jsconfig.json.
@@ -248,6 +235,12 @@ async function loadTsPathConfig(searchDir) {
                 continue;
             rules.push({ key, hasWildcard, prefix, suffix, targets });
         }
+        rules.sort((left, right) => {
+            if (left.hasWildcard !== right.hasWildcard)
+                return left.hasWildcard ? 1 : -1;
+            return (right.prefix.length + right.suffix.length)
+                - (left.prefix.length + left.suffix.length);
+        });
         if (rules.length === 0)
             continue;
         return { baseDir: resolvedBaseDir, rules };

package/dist/gates/hallucinated-imports/ts-path-target.d.ts

@@ -0,0 +1 @@
+export declare function resolveTsPathTarget(baseDir: string, candidatePattern: string, cwd: string, projectFiles: Set<string>): Promise<boolean>;

package/dist/gates/hallucinated-imports/ts-path-target.js

@@ -0,0 +1,27 @@
+import { pathExists, stat } from 'fs-extra';
+import path from 'path';
+const sourceExtensions = ['', '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.d.ts'];
+export async function resolveTsPathTarget(baseDir, candidatePattern, cwd, projectFiles) {
+    const absolute = path.resolve(baseDir, candidatePattern);
+    const relative = path.relative(cwd, absolute).replace(/\\/g, '/');
+    if (relative === '..' || relative.startsWith('../') || path.isAbsolute(relative))
+        return false;
+    const normalized = relative.replace(/\/$/, '');
+    const candidates = [
+        ...sourceExtensions.map(extension => normalized + extension),
+        ...sourceExtensions.map(extension => `${normalized}/index${extension}`),
+    ];
+    if (candidates.some(candidate => projectFiles.has(candidate)))
+        return true;
+    for (const candidate of candidates) {
+        const candidatePath = path.resolve(cwd, candidate);
+        if (!await pathExists(candidatePath))
+            continue;
+        try {
+            if ((await stat(candidatePath)).isFile())
+                return true;
+        }
+        catch { /* inaccessible targets do not resolve */ }
+    }
+    return false;
+}

package/dist/gates/hallucinated-imports.test.js

@@ -11,13 +11,14 @@ import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { HallucinatedImportsGate } from './hallucinated-imports/index.js';
 import path from 'path';
 // Mock fs-extra — vi.hoisted ensures these are available when vi.mock runs (hoisted)
-const { mockPathExists, mockPathExistsSync, mockReadFile, mockReadFileSync, mockReadJson, mockReaddirSync } = vi.hoisted(() => ({
+const { mockPathExists, mockPathExistsSync, mockReadFile, mockReadFileSync, mockReadJson, mockReaddirSync, mockStat } = vi.hoisted(() => ({
     mockPathExists: vi.fn(),
     mockPathExistsSync: vi.fn(),
     mockReadFile: vi.fn(),
     mockReadFileSync: vi.fn(),
     mockReadJson: vi.fn(),
     mockReaddirSync: vi.fn().mockReturnValue([]),
+    mockStat: vi.fn(),
 }));
 vi.mock('fs-extra', () => {
     const mock = {
@@ -27,6 +28,7 @@ vi.mock('fs-extra', () => {
         readFileSync: mockReadFileSync,
         readJson: mockReadJson,
         readdirSync: mockReaddirSync,
+        stat: mockStat,
     };
     return {
         ...mock,
@@ -365,6 +367,7 @@ import { cfg } from '~shared/config';
             return normalized === `${testCwdNormalized}/apps/desktop/tsconfig.json`
                 || normalized === `${testCwdNormalized}/package.json`;
         });
+        mockStat.mockResolvedValue({ isFile: () => true });
         mockReadJson.mockResolvedValue({
             dependencies: {},
             devDependencies: {},
@@ -410,6 +413,39 @@ import { cfg } from '~shared/config';
         expect(details.includes("Path alias '@/utils/missing' does not resolve to a project file")
             || details.includes("Package '@/utils' not in package.json dependencies")).toBe(true);
     });
+    it('should resolve configured aliases to hidden generated files', async () => {
+        const jsContent = `import { docs } from '@/.source';`;
+        const tsconfigContent = `{
+  "compilerOptions": {
+    "paths": {
+      "@/*": ["./*"],
+      "@/.source": ["./.source/index.ts"]
+    }
+  }
+}`;
+        FileScanner.findFiles.mockResolvedValue(['docs-site/lib/source.ts']);
+        mockReadFile.mockImplementation(async (p) => {
+            const normalized = normalizePath(p);
+            if (normalized.endsWith('/docs-site/tsconfig.json'))
+                return tsconfigContent;
+            return jsContent;
+        });
+        mockPathExists.mockImplementation(async (p) => {
+            const normalized = normalizePath(p);
+            return normalized === `${testCwdNormalized}/docs-site/tsconfig.json`
+                || normalized === `${testCwdNormalized}/docs-site/.source/index.ts`
+                || normalized === `${testCwdNormalized}/package.json`;
+        });
+        mockStat.mockResolvedValue({ isFile: () => true });
+        mockReadJson.mockResolvedValue({
+            dependencies: {},
+            devDependencies: {},
+            peerDependencies: {},
+            optionalDependencies: {},
+        });
+        const failures = await gate.run(context);
+        expect(failures).toHaveLength(0);
+    });
     it('should NOT flag ESM .js specifiers that resolve to .ts source files', async () => {
         const jsContent = `
 import { helper } from './utils.js';

package/dist/hooks/dlp-feedback.d.ts

@@ -14,11 +14,14 @@ export interface DLPBlockManifest {
     timestamp: string;
     detections: Array<{
         type: string;
-        match: string;
         fingerprint: string;
-        shape: string;
+        confidence: number;
     }>;
 }
+export declare function isLearnableDLPDetection(detection: {
+    type: string;
+    confidence?: number;
+}): boolean;
 /** Normalize a matched value to a shape for learning (preserves structure, not secret content). */
 export declare function shapeValue(value: string): string;
 export declare function fingerprintDetection(type: string, match: string, line?: string): string;
@@ -28,9 +31,10 @@ export declare function lastBlockPath(cwd: string): string;
 export declare function recordDLPFeedback(cwd: string, entry: {
     type: string;
     match: string;
+    confidence?: number;
     line?: string;
     source?: DLPFeedbackEntry['source'];
-}): Promise<string>;
+}): Promise<string | null>;
 export declare function isLearnedAllow(cwd: string | undefined, type: string, match: string, _line?: string): Promise<boolean>;
 export declare function isLearnedAllowSync(store: DLPFeedbackStore, type: string, match: string, _line?: string): boolean;
 export declare function loadDLPFeedbackStore(cwd: string): Promise<DLPFeedbackStore>;
@@ -39,10 +43,12 @@ export declare function getLearnedAllowCount(cwd: string): Promise<number>;
 export declare function loadDLPFeedbackStoreSync(cwd: string): DLPFeedbackStore;
 export declare function writeDLPBlockManifest(cwd: string, detections: Array<{
     type: string;
-    match: string;
+    match?: string;
+    feedback_fingerprint?: string;
+    confidence?: number;
     position?: {
         start: number;
         end: number;
     };
-}>, input: string): Promise<void>;
+}>, _input: string): Promise<void>;
 export declare function allowLastDLPBlock(cwd: string, source?: DLPFeedbackEntry['source']): Promise<number>;

package/dist/hooks/dlp-feedback.js

@@ -5,6 +5,31 @@
 import { createHash } from 'crypto';
 import fs from 'fs-extra';
 import path from 'path';
+const DLP_BLOCK_MANIFEST_TTL_MS = 10 * 60 * 1000;
+const MAX_LEARNABLE_CONFIDENCE = 79;
+const NON_LEARNABLE_TYPES = new Set([
+    'private_key',
+    'private_key_full',
+    'gcp_service_account',
+    'bearer_token',
+    'jwt_token',
+    'aws_secret_key',
+    'azure_key',
+    'anthropic_key',
+    'slack_token',
+    'sendgrid_key',
+    'aws_access_key',
+    'openai_key',
+    'github_token',
+    'stripe_key',
+    'twilio_key',
+    'high_entropy_secret',
+]);
+export function isLearnableDLPDetection(detection) {
+    const confidence = detection.confidence ?? 100;
+    return !NON_LEARNABLE_TYPES.has(detection.type)
+        && confidence <= MAX_LEARNABLE_CONFIDENCE;
+}
 /** Normalize a matched value to a shape for learning (preserves structure, not secret content). */
 export function shapeValue(value) {
     return value
@@ -55,8 +80,9 @@ async function saveStore(cwd, store) {
     await fs.writeJson(feedbackPath(cwd), store, { spaces: 2 });
 }
 export async function recordDLPFeedback(cwd, entry) {
+    if (!isLearnableDLPDetection(entry))
+        return null;
     const fingerprint = feedbackFingerprint(entry.type, entry.match);
-    const shape = extractValueShape(entry.match);
     const store = await loadStore(cwd);
     const existing = store.entries.find(e => e.fingerprint === fingerprint);
     const now = new Date().toISOString();
@@ -68,7 +94,7 @@ export async function recordDLPFeedback(cwd, entry) {
         store.entries.push({
             fingerprint,
             type: entry.type,
-            shape,
+            shape: '[redacted]',
             hits: 1,
             lastSeenAt: now,
             source: entry.source ?? 'hook',
@@ -119,37 +145,62 @@ function getLineAt(input, start) {
     const lineEnd = input.indexOf('\n', start);
     return input.slice(lineStart, lineEnd === -1 ? undefined : lineEnd).trim();
 }
-export async function writeDLPBlockManifest(cwd, detections, input) {
+export async function writeDLPBlockManifest(cwd, detections, _input) {
     const seen = new Set();
     const manifestDetections = [];
     for (const d of detections) {
-        const fp = feedbackFingerprint(d.type, d.match);
+        if (!isLearnableDLPDetection(d))
+            continue;
+        const fp = d.feedback_fingerprint
+            ?? (d.match ? feedbackFingerprint(d.type, d.match) : null);
+        if (!fp)
+            continue;
         if (seen.has(fp))
             continue;
         seen.add(fp);
         manifestDetections.push({
             type: d.type,
-            match: d.match.slice(0, 80),
             fingerprint: fp,
-            shape: extractValueShape(d.match),
+            confidence: d.confidence ?? 100,
         });
     }
+    const manifestPath = lastBlockPath(cwd);
+    if (manifestDetections.length === 0) {
+        await fs.remove(manifestPath);
+        return;
+    }
     const manifest = {
         timestamp: new Date().toISOString(),
         detections: manifestDetections,
     };
-    await fs.ensureDir(path.dirname(lastBlockPath(cwd)));
-    await fs.writeJson(lastBlockPath(cwd), manifest, { spaces: 2 });
+    await fs.ensureDir(path.dirname(manifestPath));
+    await fs.writeJson(manifestPath, manifest, { spaces: 2 });
 }
 export async function allowLastDLPBlock(cwd, source = 'hook') {
     const manifestPath = lastBlockPath(cwd);
     if (!await fs.pathExists(manifestPath))
         return 0;
-    const manifest = await fs.readJson(manifestPath);
+    let manifest;
+    try {
+        manifest = await fs.readJson(manifestPath);
+    }
+    catch {
+        await fs.remove(manifestPath);
+        return 0;
+    }
+    await fs.remove(manifestPath);
+    const manifestAge = Date.now() - Date.parse(manifest.timestamp);
+    if (!Number.isFinite(manifestAge)
+        || manifestAge < 0
+        || manifestAge > DLP_BLOCK_MANIFEST_TTL_MS
+        || !Array.isArray(manifest.detections))
+        return 0;
     const store = await loadStore(cwd);
     const now = new Date().toISOString();
     let count = 0;
     for (const d of manifest.detections ?? []) {
+        if (!isLearnableDLPDetection(d))
+            continue;
         const existing = store.entries.find(e => e.fingerprint === d.fingerprint);
         if (existing) {
             existing.hits += 1;
@@ -159,7 +210,7 @@ export async function allowLastDLPBlock(cwd, source = 'hook') {
             store.entries.push({
                 fingerprint: d.fingerprint,
                 type: d.type,
-                shape: d.shape,
+                shape: '[redacted]',
                 hits: 1,
                 lastSeenAt: now,
                 source,

package/dist/hooks/dlp-feedback.test.js

@@ -4,6 +4,7 @@ import os from 'os';
 import fs from 'fs-extra';
 import { recordDLPFeedback, feedbackFingerprint, loadDLPFeedbackStoreSync, isLearnedAllowSync, writeDLPBlockManifest, allowLastDLPBlock, } from './dlp-feedback.js';
 import { scanInputForCredentials } from './input-validator.js';
+import { generateDLPHookFiles } from './dlp-templates.js';
 describe('DLP feedback learning', () => {
     const testCwd = path.join(os.tmpdir(), `rigour-dlp-fb-${Date.now()}`);
     beforeEach(async () => {
@@ -19,7 +20,12 @@ describe('DLP feedback learning', () => {
     });
     it('records and applies learned false positives', async () => {
         const match = 'api_key = "Z9y8X7w6V5u4T3s2R1q0P9o8N7m6B5c4"';
-        await recordDLPFeedback(testCwd, { type: 'password_assignment', match, source: 'hook' });
+        await recordDLPFeedback(testCwd, {
+            type: 'password_assignment',
+            match,
+            confidence: 55,
+            source: 'hook',
+        });
         const store = loadDLPFeedbackStoreSync(testCwd);
         expect(isLearnedAllowSync(store, 'password_assignment', match)).toBe(true);
         const result = scanInputForCredentials(match, { cwd: testCwd });
@@ -36,4 +42,90 @@ describe('DLP feedback learning', () => {
         const retry = scanInputForCredentials(text, { cwd: testCwd });
         expect(retry.status).toBe('clean');
     });
+    it('never learns provider or high-confidence detections', async () => {
+        const provider = await recordDLPFeedback(testCwd, {
+            type: 'openai_key',
+            match: 'sk-proj-Z9Y8X7W6V5U4T3S2R1Q0P9O8N7M6',
+            confidence: 92,
+        });
+        const highConfidence = await recordDLPFeedback(testCwd, {
+            type: 'password_assignment',
+            match: 'password = "Z9y8X7w6V5u4T3s2R1q0P9o8N7m6B5c4"',
+            confidence: 95,
+        });
+        expect(provider).toBeNull();
+        expect(highConfidence).toBeNull();
+        expect(loadDLPFeedbackStoreSync(testCwd).entries).toHaveLength(0);
+    });
+    it('does not retain raw credential fragments in manifests', async () => {
+        const text = 'api_key = "Z9y8X7w6V5u4T3s2R1q0P9o8N7m6B5c4"';
+        const result = scanInputForCredentials(text);
+        expect(result.detections[0].match).toBe(result.detections[0].redacted);
+        expect(result.detections[0].match).not.toContain('Z9y8X7w6V5u4T3s2R1q0P9o8N7m6B5c4');
+        await writeDLPBlockManifest(testCwd, result.detections, text);
+        const manifest = fs.readFileSync(path.join(testCwd, '.rigour', 'dlp-last-block.json'), 'utf-8');
+        expect(manifest).not.toContain('Z9y8X7w6V5u4T3s2R1q0P9o8N7m6B5c4');
+        expect(manifest).not.toContain('match');
+        expect(manifest).not.toContain('shape');
+    });
+    it('rejects and consumes expired manifests', async () => {
+        const text = 'api_key = "Z9y8X7w6V5u4T3s2R1q0P9o8N7m6B5c4"';
+        const result = scanInputForCredentials(text);
+        await writeDLPBlockManifest(testCwd, result.detections, text);
+        const manifestPath = path.join(testCwd, '.rigour', 'dlp-last-block.json');
+        const manifest = fs.readJsonSync(manifestPath);
+        manifest.timestamp = '2020-01-01T00:00:00.000Z';
+        fs.writeJsonSync(manifestPath, manifest);
+        expect(await allowLastDLPBlock(testCwd, 'hook')).toBe(0);
+        expect(fs.existsSync(manifestPath)).toBe(false);
+    });
+    it('rejects and consumes malformed manifests', async () => {
+        const manifestPath = path.join(testCwd, '.rigour', 'dlp-last-block.json');
+        fs.writeFileSync(manifestPath, '{not-json');
+        expect(await allowLastDLPBlock(testCwd, 'hook')).toBe(0);
+        expect(fs.existsSync(manifestPath)).toBe(false);
+    });
+});
+describe('DLP scanner URL boundaries', () => {
+    it('detects genuine HTTP basic-auth credentials', () => {
+        const result = scanInputForCredentials('https://alice:S3cr3t-Prod-9842@example.com/v1');
+        expect(result.status).toBe('warning');
+        expect(result.detections.some(d => d.type === 'credentials_in_url')).toBe(true);
+    });
+    it('allows signed GCS URLs without URL user-info', () => {
+        const url = 'https://storage.googleapis.com/example/archive.zip'
+            + '?X-Goog-Credential=service%40example.invalid&X-Goog-Signature=redacted';
+        expect(scanInputForCredentials(url).status).toBe('clean');
+    });
+    it('does not cross multiline JSON boundaries while scanning URLs', () => {
+        const input = `{
+            "task_archive_url": "https://storage.googleapis.com/example/archive.zip",
+            "provider": { "npm": "@ai-sdk/openai-compatible" }
+        }`;
+        expect(scanInputForCredentials(input).status).toBe('clean');
+    });
+    it('allows nested OpenCode configuration with scoped npm packages', () => {
+        const config = JSON.stringify({
+            $schema: 'https://opencode.ai/config.json',
+            provider: {
+                moonshot: {
+                    npm: '@ai-sdk/openai-compatible',
+                    options: {
+                        baseURL: 'https://api.moonshot.ai/v1',
+                        apiKey: '{env:OPENAI_API_KEY}',
+                    },
+                },
+            },
+        }, null, 2);
+        expect(scanInputForCredentials(config).status).toBe('clean');
+    });
+});
+describe('DLP hook warning templates', () => {
+    it.each(['cursor', 'cline', 'windsurf'])('generates non-blocking %s warnings', (tool) => {
+        const content = generateDLPHookFiles(tool, 'rigour hooks check')
+            .map(file => file.content)
+            .join('\n');
+        expect(content).toContain('possible credential');
+        expect(content).not.toContain('process.exit(2)');
+    });
 });

package/dist/hooks/dlp-templates.d.ts

@@ -1,8 +1,8 @@
 /**
- * DLP Hook Templates — Pre-Input Credential Interception
+ * DLP Hook Templates — Pre-Input Credential Warnings
  *
  * Generates tool-native hook configs that intercept user input
- * BEFORE it reaches the AI agent. Complements the existing
+ * before agent actions. Complements the existing
  * post-output templates in templates.ts.
  *
  * Hook events:

package/dist/hooks/dlp-templates.js

@@ -1,8 +1,8 @@
 /**
- * DLP Hook Templates — Pre-Input Credential Interception
+ * DLP Hook Templates — Pre-Input Credential Warnings
  *
  * Generates tool-native hook configs that intercept user input
- * BEFORE it reaches the AI agent. Complements the existing
+ * before agent actions. Complements the existing
  * post-output templates in templates.ts.
  *
  * Hook events:
@@ -32,7 +32,7 @@ export function generateDLPHookFiles(tool, checkerCommand) {
 // ── Claude Code DLP Hook ──────────────────────────────────────────
 function generateClaudeDLPHooks(checkerCommand) {
     // Claude Code supports PreToolUse hooks that fire BEFORE tool execution.
-    // We intercept all tool uses to scan user input for credentials.
+    // Scan tool input and report warnings without blocking by default.
     const settings = {
         hooks: {
             PreToolUse: [
@@ -102,13 +102,12 @@ process.stdin.on('end', async () => {
         if (proc.error) throw proc.error;
 
         const result = JSON.parse((proc.stdout || '').trim());
-        if (result.status === 'blocked') {
-            process.stderr.write('[rigour/dlp] ' + result.detections.length + ' credential(s) BLOCKED\\n');
+        if (result.status !== 'clean') {
+            process.stderr.write('[rigour/dlp] ' + result.detections.length + ' possible credential(s) detected\\n');
             for (const d of result.detections) {
-                process.stderr.write('  [' + d.severity.toUpperCase() + '] ' + d.description + '\\n');
+                process.stderr.write('  [WARNING] ' + d.description + '\\n');
                 process.stderr.write('    → ' + d.recommendation + '\\n');
             }
-            process.exit(2); // Block the operation
         }
 
         process.stdout.write(JSON.stringify({ status: 'ok' }));
@@ -128,7 +127,7 @@ process.stdin.on('end', async () => {
             path: '.cursor/rigour-dlp-hook.js',
             content: wrapper,
             executable: true,
-            description: 'Cursor DLP hook wrapper — credential interception',
+            description: 'Cursor DLP hook wrapper — credential warnings',
         },
     ];
 }
@@ -178,15 +177,14 @@ process.stdin.on('end', async () => {
         if (proc.error) throw proc.error;
 
         const result = JSON.parse((proc.stdout || '').trim());
-        if (result.status === 'blocked') {
+        if (result.status !== 'clean') {
             const msgs = result.detections
                 .map(d => '[rigour/dlp/' + d.type + '] ' + d.description + ' → ' + d.recommendation)
                 .join('\\n');
 
             process.stdout.write(JSON.stringify({
-                contextModification: '\\n🛑 [Rigour DLP] ' + result.detections.length + ' credential(s) BLOCKED before agent processing:\\n' + msgs + '\\nReplace with environment variable references.',
+                contextModification: '\\n⚠️ [Rigour DLP] ' + result.detections.length + ' possible credential(s) detected:\\n' + msgs,
             }));
-            process.exit(2);
         } else {
             process.stdout.write(JSON.stringify({}));
         }
@@ -201,7 +199,7 @@ process.stdin.on('end', async () => {
             path: '.clinerules/hooks/PreToolUse',
             content: script,
             executable: true,
-            description: 'Cline PreToolUse DLP hook — credential interception before agent execution',
+            description: 'Cline PreToolUse DLP hook — credential warnings before agent execution',
         },
     ];
 }
@@ -249,12 +247,11 @@ process.stdin.on('end', async () => {
         if (proc.error) throw proc.error;
 
         const result = JSON.parse((proc.stdout || '').trim());
-        if (result.status === 'blocked') {
+        if (result.status !== 'clean') {
             for (const d of result.detections) {
-                process.stderr.write('[rigour/dlp] 🛑 ' + d.severity.toUpperCase() + ': ' + d.description + '\\n');
+                process.stderr.write('[rigour/dlp] ⚠ possible credential: ' + d.description + '\\n');
                 process.stderr.write('  → ' + d.recommendation + '\\n');
             }
-            process.exit(2); // Block
         }
     } catch (err) {
         process.stderr.write('Rigour DLP hook error: ' + err.message + '\\n');
@@ -271,7 +268,7 @@ process.stdin.on('end', async () => {
             path: '.windsurf/rigour-dlp-hook.js',
             content: wrapper,
             executable: true,
-            description: 'Windsurf DLP hook wrapper — credential interception before Cascade',
+            description: 'Windsurf DLP hook wrapper — credential warnings before Cascade',
         },
     ];
 }

package/dist/hooks/input-validator.d.ts

@@ -19,7 +19,9 @@
 export interface CredentialDetection {
     type: string;
     severity: 'critical' | 'high' | 'medium';
+    /** Redacted match only. Raw credential material never leaves the scanner. */
     match: string;
+    feedback_fingerprint?: string;
     redacted: string;
     description: string;
     recommendation: string;

package/dist/hooks/input-validator.js

@@ -17,7 +17,7 @@
  *
  */
 import { classifyDLPDetection } from './dlp-confidence.js';
-import { isLearnedAllowSync, loadDLPFeedbackStoreSync } from './dlp-feedback.js';
+import { feedbackFingerprint, isLearnableDLPDetection, isLearnedAllowSync, loadDLPFeedbackStoreSync, } from './dlp-feedback.js';
 const CREDENTIAL_PATTERNS = [
     // ── Cloud Provider Keys ───────────────────────────────────
     {
@@ -174,7 +174,7 @@ const CREDENTIAL_PATTERNS = [
     // ── IP Addresses with Credentials ─────────────────────────
     {
         type: 'credentials_in_url',
-        regex: /\b(https?:\/\/[^:]+:[^@]+@[^\s'"`,;}{)]+)\b/gi,
+        regex: /\b(https?:\/\/[^/\s:@]+:[^/\s@]+@[^\s'"`,;}{)]+)\b/gi,
         severity: 'critical',
         description: 'URL with embedded credentials detected',
         recommendation: 'Remove credentials from URLs. Use environment variables for auth',
@@ -406,24 +406,25 @@ export function scanInputForCredentials(input, config = {}) {
         ? loadDLPFeedbackStoreSync(config.cwd)
         : null;
     const classified = detections.map(d => {
-        if (feedbackStore) {
+        const baseline = {
+            ...d,
+            ...classifyDLPDetection(d, input),
+        };
+        if (feedbackStore && isLearnableDLPDetection(baseline)) {
             const start = d.position?.start ?? 0;
             const lineStart = input.lastIndexOf('\n', start) + 1;
             const lineEnd = input.indexOf('\n', start);
             const line = input.slice(lineStart, lineEnd === -1 ? undefined : lineEnd).trim();
             if (isLearnedAllowSync(feedbackStore, d.type, d.match, line)) {
                 return {
-                    ...d,
+                    ...baseline,
                     confidence: 12,
                     decision: 'allow',
                     reason_codes: ['learned_false_positive'],
                 };
             }
         }
-        return {
-            ...d,
-            ...classifyDLPDetection(d, input),
-        };
+        return baseline;
     });
     // Line-level learned expansion: one false-positive mark allows sibling patterns on same line
     const learnedStarts = new Set(classified
@@ -431,7 +432,10 @@ export function scanInputForCredentials(input, config = {}) {
         .map(d => d.position?.start ?? -1));
     const expanded = classified.map(d => {
         const start = d.position?.start ?? -1;
-        if (start >= 0 && learnedStarts.has(start) && d.decision !== 'allow') {
+        if (start >= 0
+            && learnedStarts.has(start)
+            && d.decision !== 'allow'
+            && isLearnableDLPDetection(d)) {
             return {
                 ...d,
                 confidence: 12,
@@ -458,8 +462,10 @@ export function scanInputForCredentials(input, config = {}) {
             : 'warning';
     return {
         status,
-        detections: deduped,
-        ...(allowedDeduped.length > 0 ? { allowed_detections: allowedDeduped } : {}),
+        detections: deduped.map(toPublicDetection),
+        ...(allowedDeduped.length > 0
+            ? { allowed_detections: allowedDeduped.map(toPublicDetection) }
+            : {}),
         duration_ms: Date.now() - start,
         scanned_length: input.length,
     };
@@ -467,6 +473,14 @@ export function scanInputForCredentials(input, config = {}) {
 /**
  * Deduplicate overlapping detections — keep the higher severity one.
  */
+function toPublicDetection(detection) {
+    const { match, ...safe } = detection;
+    return {
+        ...safe,
+        match: detection.redacted,
+        feedback_fingerprint: feedbackFingerprint(detection.type, match),
+    };
+}
 function deduplicateDetections(detections) {
     if (detections.length <= 1)
         return detections;

package/dist/hooks/standalone-dlp-checker.d.ts

@@ -6,8 +6,8 @@
  * InputValidationGate, and outputs JSON result to stdout.
  *
  * Exit codes:
- *   0 — clean (no credentials found)
- *   2 — blocked (credentials detected, transmission prevented)
+ *   0 — clean or warning (default)
+ *   2 — blocked when --block is explicitly set
  *
  * Usage:
  *   echo "my api_key = sk-abc123..." | node standalone-dlp-checker.js

package/dist/hooks/standalone-dlp-checker.js

@@ -6,8 +6,8 @@
  * InputValidationGate, and outputs JSON result to stdout.
  *
  * Exit codes:
- *   0 — clean (no credentials found)
- *   2 — blocked (credentials detected, transmission prevented)
+ *   0 — clean or warning (default)
+ *   2 — blocked when --block is explicitly set
  *
  * Usage:
  *   echo "my api_key = sk-abc123..." | node standalone-dlp-checker.js
@@ -20,7 +20,7 @@ import path from 'path';
 async function main() {
     const args = process.argv.slice(2);
     const isJson = args.includes('--json');
-    const block = !args.includes('--warn-only');
+    const block = args.includes('--block');
     const agent = args.find(a => a.startsWith('--agent='))?.split('=')[1] || 'unknown';
     // Read stdin
     const chunks = [];

package/dist/services/score-history.d.ts

@@ -20,7 +20,10 @@ export interface ScoreEntry {
 }
 export interface ScoreTrend {
     direction: 'improving' | 'stable' | 'degrading';
+    /** Difference between recent and previous window averages. */
     delta: number;
+    /** Difference between the first and last score displayed to the user. */
+    visibleDelta: number;
     recentAvg: number;
     previousAvg: number;
     recentScores: number[];
@@ -48,6 +51,7 @@ export declare function recordScore(cwd: string, report: {
 export declare function getScoreHistory(cwd: string, limit?: number): ScoreEntry[];
 /**
  * Calculate score trend from history.
- * Compares average of last 5 runs vs previous 5 runs.
+ * Direction and delta describe the same recent scores shown to users.
+ * Window averages remain available for detailed historical comparison.
  */
 export declare function getScoreTrend(cwd: string): ScoreTrend | null;

package/dist/services/score-history.js

@@ -65,7 +65,8 @@ export function getScoreHistory(cwd, limit = 20) {
 }
 /**
  * Calculate score trend from history.
- * Compares average of last 5 runs vs previous 5 runs.
+ * Direction and delta describe the same recent scores shown to users.
+ * Window averages remain available for detailed historical comparison.
  */
 export function getScoreTrend(cwd) {
     const history = getScoreHistory(cwd, 20);
@@ -75,27 +76,21 @@ export function getScoreTrend(cwd) {
     const recentScores = scores.slice(-5);
     const previousScores = scores.slice(-10, -5);
     const recentAvg = recentScores.reduce((a, b) => a + b, 0) / recentScores.length;
-    if (previousScores.length === 0) {
-        return {
-            direction: 'stable',
-            delta: 0,
-            recentAvg: Math.round(recentAvg),
-            previousAvg: Math.round(recentAvg),
-            recentScores,
-        };
-    }
-    const previousAvg = previousScores.reduce((a, b) => a + b, 0) / previousScores.length;
-    const delta = recentAvg - previousAvg;
+    const previousAvg = previousScores.length > 0
+        ? previousScores.reduce((a, b) => a + b, 0) / previousScores.length
+        : recentAvg;
+    const windowDelta = recentAvg - previousAvg;
+    const visibleDelta = recentScores[recentScores.length - 1] - recentScores[0];
     // If all recent scores are the same (e.g. all 0 or all 100), trend is stable
     const allSame = recentScores.every(s => s === recentScores[0]);
     let direction;
-    if (allSame && previousScores.length > 0 && previousScores.every(s => s === recentScores[0])) {
+    if (allSame) {
         direction = 'stable';
     }
-    else if (delta > 3) {
+    else if (visibleDelta > 3) {
         direction = 'improving';
     }
-    else if (delta < -3) {
+    else if (visibleDelta < -3) {
         direction = 'degrading';
     }
     else {
@@ -103,7 +98,8 @@ export function getScoreTrend(cwd) {
     }
     return {
         direction,
-        delta: Math.round(delta * 10) / 10,
+        delta: Math.round(windowDelta * 10) / 10,
+        visibleDelta: Math.round(visibleDelta * 10) / 10,
         recentAvg: Math.round(recentAvg),
         previousAvg: Math.round(previousAvg),
         recentScores,

package/dist/services/score-history.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/score-history.test.js

@@ -0,0 +1,53 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { getScoreTrend } from './score-history.js';
+describe('getScoreTrend', () => {
+    let testDir;
+    beforeEach(() => {
+        testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'score-history-test-'));
+        fs.mkdirSync(path.join(testDir, '.rigour'));
+    });
+    afterEach(() => {
+        fs.rmSync(testDir, { recursive: true, force: true });
+    });
+    function writeScores(scores) {
+        const entries = scores.map((score, index) => ({
+            timestamp: new Date(index * 1000).toISOString(),
+            status: 'FAIL',
+            score,
+            failureCount: 1,
+            severity_breakdown: {},
+            provenance_breakdown: {},
+        }));
+        fs.writeFileSync(path.join(testDir, '.rigour', 'score-history.jsonl'), entries.map(entry => JSON.stringify(entry)).join('\n') + '\n');
+    }
+    it('labels the displayed rising scores as improving despite a higher older window', () => {
+        writeScores([90, 92, 94, 96, 98, 34, 29, 29, 52, 59]);
+        expect(getScoreTrend(testDir)).toMatchObject({
+            direction: 'improving',
+            delta: -53.4,
+            visibleDelta: 25,
+            recentScores: [34, 29, 29, 52, 59],
+            recentAvg: 41,
+            previousAvg: 94,
+        });
+    });
+    it('labels a falling displayed series as degrading', () => {
+        writeScores([80, 75, 70, 64, 59]);
+        expect(getScoreTrend(testDir)).toMatchObject({
+            direction: 'degrading',
+            delta: 0,
+            visibleDelta: -21,
+        });
+    });
+    it('treats small visible changes as stable', () => {
+        writeScores([50, 49, 52, 51, 53]);
+        expect(getScoreTrend(testDir)).toMatchObject({
+            direction: 'stable',
+            delta: 0,
+            visibleDelta: 3,
+        });
+    });
+});

package/dist/templates/universal-config.js

@@ -215,7 +215,7 @@ export const UNIVERSAL_CONFIG = {
         },
         input_validation: {
             enabled: true,
-            block_on_detection: true,
+            block_on_detection: false,
             min_secret_length: 8,
             custom_patterns: [],
             ignore_patterns: [],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/core",
-  "version": "5.5.0",
+  "version": "5.5.1",
   "description": "AI-native quality gate engine with local Bayesian learning. AST analysis, drift detection, Fix Packet generation, and agent self-healing across TypeScript, JavaScript, Python, Go, Ruby, and C#.",
   "license": "MIT",
   "homepage": "https://rigour.run",
@@ -66,11 +66,11 @@
     "@xenova/transformers": "^2.17.2",
     "sqlite3": "^5.1.7",
     "openai": "^4.104.0",
-    "@rigour-labs/brain-darwin-arm64": "5.5.0",
-    "@rigour-labs/brain-darwin-x64": "5.5.0",
-    "@rigour-labs/brain-linux-x64": "5.5.0",
-    "@rigour-labs/brain-win-x64": "5.5.0",
-    "@rigour-labs/brain-linux-arm64": "5.5.0"
+    "@rigour-labs/brain-darwin-x64": "5.5.1",
+    "@rigour-labs/brain-linux-arm64": "5.5.1",
+    "@rigour-labs/brain-darwin-arm64": "5.5.1",
+    "@rigour-labs/brain-win-x64": "5.5.1",
+    "@rigour-labs/brain-linux-x64": "5.5.1"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",