@rigour-labs/cli 1.0.0 → 1.4.0

package/dist/commands/setup.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupCommand = setupCommand;
+const chalk_1 = __importDefault(require("chalk"));
+async function setupCommand() {
+    console.log(chalk_1.default.bold.cyan('\n🛠️ Rigour Labs | Setup & Installation\n'));
+    console.log(chalk_1.default.bold('1. Global Installation (Recommended)'));
+    console.log(chalk_1.default.dim('   To use Rigour anywhere in your terminal:'));
+    console.log(chalk_1.default.green('   $ npm install -g @rigour-labs/cli\n'));
+    console.log(chalk_1.default.bold('2. Project-Local installation'));
+    console.log(chalk_1.default.dim('   To keep Rigour versioned with your project:'));
+    console.log(chalk_1.default.green('   $ npm install --save-dev @rigour-labs/cli\n'));
+    console.log(chalk_1.default.bold('3. Standalone Binaries (Zero-Install)'));
+    console.log(chalk_1.default.dim('   If you do not want to use Node.js:'));
+    console.log(chalk_1.default.dim('   • macOS: ') + chalk_1.default.cyan('https://github.com/erashu212/rigour/releases/latest/download/rigour-macos'));
+    console.log(chalk_1.default.dim('   • Linux: ') + chalk_1.default.cyan('https://github.com/erashu212/rigour/releases/latest/download/rigour-linux'));
+    console.log(chalk_1.default.dim('   • Windows: ') + chalk_1.default.cyan('https://github.com/erashu212/rigour/releases/latest/download/rigour-windows.exe\n'));
+    console.log(chalk_1.default.bold('4. MCP Integration (for AI Agents)'));
+    console.log(chalk_1.default.dim('   To let Cursor or Claude use Rigour natively:'));
+    console.log(chalk_1.default.dim('   Path to MCP: ') + chalk_1.default.cyan('packages/rigour-mcp/dist/index.js'));
+    console.log(chalk_1.default.dim('   Add this to your Cursor/Claude settings.\n'));
+    console.log(chalk_1.default.bold('Update Guidance:'));
+    console.log(chalk_1.default.dim('   Keep Rigour sharp by updating regularly:'));
+    console.log(chalk_1.default.green('   $ npm install -g @rigour-labs/cli@latest\n'));
+}

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@rigour-labs/cli",
-  "version": "1.0.0",
+  "version": "1.4.0",
   "bin": {
     "rigour": "dist/cli.js"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/erashu212/rigour"
+    "url": "https://github.com/rigour-labs/rigour"
   },
   "publishConfig": {
     "access": "public",
@@ -20,7 +20,7 @@
     "fs-extra": "^11.2.0",
     "globby": "^14.0.1",
     "yaml": "^2.8.2",
-    "@rigour-labs/core": "1.0.0"
+    "@rigour-labs/core": "1.4.0"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",

package/src/cli.ts

@@ -2,36 +2,98 @@
 import { Command } from 'commander';
 import { initCommand } from './commands/init.js';
 import { checkCommand } from './commands/check.js';
+import { explainCommand } from './commands/explain.js';
 import { runLoop } from './commands/run.js';
+import { guideCommand } from './commands/guide.js';
+import { setupCommand } from './commands/setup.js';
+import chalk from 'chalk';
 
 const program = new Command();
 
 program
     .name('rigour')
-    .description('A quality gate loop controller for AI-assisted coding')
-    .version('1.0.0');
+    .description('🛡️ Rigour: The Quality Gate Loop for AI-Assisted Engineering')
+    .version('1.3.0')
+    .addHelpText('before', chalk.bold.cyan(`
+   ____  _                               
+  / __ \\(_)____ ___  __  __ _____        
+ / /_/ // // __ \`/ / / / / // ___/        
+/ _, _// // /_/ // /_/ / / // /            
+/_/ |_|/_/ \\__, / \\__,_/_/ /_/             
+          /____/                         
+    `));
 
 program
     .command('init')
-    .description('Initialize VibeGuard in the current directory')
-    .action(async () => {
-        await initCommand(process.cwd());
+    .description('Initialize Rigour in the current directory')
+    .option('-p, --preset <name>', 'Project preset (ui, api, infra, data)')
+    .option('--paradigm <name>', 'Coding paradigm (oop, functional, minimal)')
+    .option('--dry-run', 'Show detected configuration without writing files')
+    .option('--explain', 'Show detection markers for roles and paradigms')
+    .addHelpText('after', `
+Examples:
+  $ rigour init                        # Auto-discover role & paradigm
+  $ rigour init --preset api --explain # Force API role and show why
+    `)
+    .action(async (options: any) => {
+        await initCommand(process.cwd(), options);
     });
 
 program
     .command('check')
     .description('Run quality gate checks')
+    .option('--ci', 'CI mode (minimal output, non-zero exit on fail)')
+    .option('--json', 'Output report in JSON format')
+    .addHelpText('after', `
+Examples:
+  $ rigour check                       # Run interactive check
+  $ rigour check --ci                  # Run in CI environment
+    `)
+    .action(async (options: any) => {
+        await checkCommand(process.cwd(), options);
+    });
+
+program
+    .command('explain')
+    .description('Explain the last quality gate report with actionable bullets')
+    .addHelpText('after', `
+Examples:
+  $ rigour explain                     # Get a human-readable violation summary
+    `)
     .action(async () => {
-        await checkCommand(process.cwd());
+        await explainCommand(process.cwd());
     });
 
 program
     .command('run')
     .description('Execute an agent command in a loop until quality gates pass')
     .argument('[command...]', 'The agent command to run (e.g., cursor-agent ...)')
-    .option('-i, --iterations <number>', 'Maximum number of loop iterations', '3')
-    .action(async (args, options) => {
-        await runLoop(process.cwd(), args, { iterations: parseInt(options.iterations) });
+    .option('-c, --max-cycles <number>', 'Maximum number of loop iterations', '3')
+    .option('--fail-fast', 'Abort loop immediately on first gate failure')
+    .addHelpText('after', `
+Examples:
+  $ rigour run -- claude "fix issues"   # Loop Claude until PASS
+  $ rigour run -c 5 -- cursor-agent     # Run Cursor agent for up to 5 cycles
+    `)
+    .action(async (args: string[], options: any) => {
+        await runLoop(process.cwd(), args, {
+            iterations: parseInt(options.maxCycles),
+            failFast: !!options.failFast
+        });
+    });
+
+program
+    .command('guide')
+    .description('Show the interactive engineering guide')
+    .action(async () => {
+        await guideCommand();
+    });
+
+program
+    .command('setup')
+    .description('Show installation and global setup guidance')
+    .action(async () => {
+        await setupCommand();
     });
 
 program.parse();

package/src/commands/check.ts

@@ -4,52 +4,105 @@ import chalk from 'chalk';
 import yaml from 'yaml';
 import { GateRunner, ConfigSchema, Failure } from '@rigour-labs/core';
 
-export async function checkCommand(cwd: string) {
+// Exit codes per spec
+const EXIT_PASS = 0;
+const EXIT_FAIL = 1;
+const EXIT_CONFIG_ERROR = 2;
+const EXIT_INTERNAL_ERROR = 3;
+
+export interface CheckOptions {
+    ci?: boolean;
+    json?: boolean;
+}
+
+export async function checkCommand(cwd: string, options: CheckOptions = {}) {
     const configPath = path.join(cwd, 'rigour.yml');
 
     if (!(await fs.pathExists(configPath))) {
-        console.error(chalk.red('Error: rigour.yml not found. Run `rigour init` first.'));
-        process.exit(1);
+        if (options.json) {
+            console.log(JSON.stringify({ error: 'CONFIG_ERROR', message: 'rigour.yml not found' }));
+        } else if (!options.ci) {
+            console.error(chalk.red('Error: rigour.yml not found. Run `rigour init` first.'));
+        }
+        process.exit(EXIT_CONFIG_ERROR);
     }
 
-    const configContent = await fs.readFile(configPath, 'utf-8');
-    const rawConfig = yaml.parse(configContent);
-    const config = ConfigSchema.parse(rawConfig);
+    try {
+        const configContent = await fs.readFile(configPath, 'utf-8');
+        const rawConfig = yaml.parse(configContent);
+        const config = ConfigSchema.parse(rawConfig);
 
-    console.log(chalk.blue('Running Rigour checks...\n'));
+        if (!options.ci && !options.json) {
+            console.log(chalk.blue('Running Rigour checks...\n'));
+        }
+
+        const runner = new GateRunner(config);
+        const report = await runner.run(cwd);
 
-    const runner = new GateRunner(config);
-    const report = await runner.run(cwd);
+        // Write machine report
+        const reportPath = path.join(cwd, config.output.report_path);
+        await fs.writeJson(reportPath, report, { spaces: 2 });
 
-    // Write machine report
-    const reportPath = path.join(cwd, config.output.report_path);
-    await fs.writeJson(reportPath, report, { spaces: 2 });
+        // Generate Fix Packet v2 on failure
+        if (report.status === 'FAIL') {
+            const { FixPacketService } = await import('@rigour-labs/core');
+            const fixPacketService = new FixPacketService();
+            const fixPacket = fixPacketService.generate(report, config);
+            const fixPacketPath = path.join(cwd, 'rigour-fix-packet.json');
+            await fs.writeJson(fixPacketPath, fixPacket, { spaces: 2 });
+        }
 
-    // Print human summary
-    if (report.status === 'PASS') {
-        console.log(chalk.green.bold('✔ PASS - All quality gates satisfied.'));
-    } else {
-        console.log(chalk.red.bold('✘ FAIL - Quality gate violations found.\n'));
+        // JSON output mode
+        if (options.json) {
+            console.log(JSON.stringify(report, null, 2));
+            process.exit(report.status === 'PASS' ? EXIT_PASS : EXIT_FAIL);
+        }
 
-        for (const failure of report.failures as Failure[]) {
-            console.log(chalk.red(`[${failure.id}] ${failure.title}`));
-            console.log(chalk.dim(`  Details: ${failure.details}`));
-            if (failure.files && failure.files.length > 0) {
-                console.log(chalk.dim('  Files:'));
-                failure.files.forEach((f: string) => console.log(chalk.dim(`    - ${f}`)));
+        // CI mode: minimal output
+        if (options.ci) {
+            if (report.status === 'PASS') {
+                console.log('PASS');
+            } else {
+                console.log(`FAIL: ${report.failures.length} violation(s)`);
+                report.failures.forEach((f: Failure) => {
+                    console.log(`  - [${f.id}] ${f.title}`);
+                });
             }
-            if (failure.hint) {
-                console.log(chalk.cyan(`  Hint: ${failure.hint}`));
+            process.exit(report.status === 'PASS' ? EXIT_PASS : EXIT_FAIL);
+        }
+
+        // Normal human-readable output
+        if (report.status === 'PASS') {
+            console.log(chalk.green.bold('✔ PASS - All quality gates satisfied.'));
+        } else {
+            console.log(chalk.red.bold('✘ FAIL - Quality gate violations found.\n'));
+
+            for (const failure of report.failures as Failure[]) {
+                console.log(chalk.red(`[${failure.id}] ${failure.title}`));
+                console.log(chalk.dim(`  Details: ${failure.details}`));
+                if (failure.files && failure.files.length > 0) {
+                    console.log(chalk.dim('  Files:'));
+                    failure.files.forEach((f: string) => console.log(chalk.dim(`    - ${f}`)));
+                }
+                if (failure.hint) {
+                    console.log(chalk.cyan(`  Hint: ${failure.hint}`));
+                }
+                console.log('');
             }
-            console.log('');
+
+            console.log(chalk.yellow(`See ${config.output.report_path} for full details.`));
         }
 
-        console.log(chalk.yellow(`See ${config.output.report_path} for full details.`));
-    }
+        console.log(chalk.dim(`\nFinished in ${report.stats.duration_ms}ms`));
 
-    console.log(chalk.dim(`\nFinished in ${report.stats.duration_ms}ms`));
+        process.exit(report.status === 'PASS' ? EXIT_PASS : EXIT_FAIL);
 
-    if (report.status !== 'PASS') {
-        process.exit(1);
+    } catch (error: any) {
+        if (options.json) {
+            console.log(JSON.stringify({ error: 'INTERNAL_ERROR', message: error.message }));
+        } else if (!options.ci) {
+            console.error(chalk.red(`Internal error: ${error.message}`));
+        }
+        process.exit(EXIT_INTERNAL_ERROR);
     }
 }

package/src/commands/explain.ts

@@ -0,0 +1,68 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+
+export async function explainCommand(cwd: string) {
+    const configPath = path.join(cwd, 'rigour.yml');
+    let reportPath = path.join(cwd, 'rigour-report.json');
+
+    // Try to read custom path from config
+    if (await fs.pathExists(configPath)) {
+        try {
+            const yaml = await import('yaml');
+            const configContent = await fs.readFile(configPath, 'utf-8');
+            const config = yaml.parse(configContent);
+            if (config?.output?.report_path) {
+                reportPath = path.join(cwd, config.output.report_path);
+            }
+        } catch (e) { }
+    }
+
+    if (!(await fs.pathExists(reportPath))) {
+        console.error(chalk.red(`Error: No report found at ${reportPath}`));
+        console.error(chalk.dim('Run `rigour check` first to generate a report.'));
+        process.exit(2);
+    }
+
+    try {
+        const reportContent = await fs.readFile(reportPath, 'utf-8');
+        const report = JSON.parse(reportContent);
+
+        console.log(chalk.bold('\n📋 Rigour Report Explanation\n'));
+        console.log(chalk.bold('Status: ') + (report.status === 'PASS'
+            ? chalk.green.bold('✅ PASS')
+            : chalk.red.bold('🛑 FAIL')));
+
+        console.log(chalk.bold('\nGate Summary:'));
+        for (const [gate, status] of Object.entries(report.summary || {})) {
+            const icon = status === 'PASS' ? '✅' : status === 'FAIL' ? '❌' : '⏭️';
+            console.log(`  ${icon} ${gate}: ${status}`);
+        }
+
+        if (report.failures && report.failures.length > 0) {
+            console.log(chalk.bold.red(`\n🔧 ${report.failures.length} Violation(s) to Fix:\n`));
+
+            report.failures.forEach((failure: any, index: number) => {
+                console.log(chalk.white(`${index + 1}. `) + chalk.bold.yellow(`[${failure.id.toUpperCase()}]`) + chalk.white(` ${failure.title}`));
+                console.log(chalk.dim(`   └─ ${failure.details}`));
+                if (failure.files && failure.files.length > 0) {
+                    console.log(chalk.cyan(`   📁 Files: ${failure.files.join(', ')}`));
+                }
+                if (failure.hint) {
+                    console.log(chalk.green(`   💡 Hint: ${failure.hint}`));
+                }
+                console.log('');
+            });
+        } else if (report.status === 'PASS') {
+            console.log(chalk.green('\n✨ All quality gates passed! No violations found.\n'));
+        }
+
+        if (report.stats) {
+            console.log(chalk.dim(`Duration: ${report.stats.duration_ms}ms`));
+        }
+
+    } catch (error: any) {
+        console.error(chalk.red(`Error reading report: ${error.message}`));
+        process.exit(3);
+    }
+}

package/src/commands/guide.ts

@@ -0,0 +1,21 @@
+import chalk from 'chalk';
+
+export async function guideCommand() {
+    console.log(chalk.bold.cyan('\n🛡️ Rigour Labs | The Engineering Guide\n'));
+
+    console.log(chalk.bold('Getting Started:'));
+    console.log(chalk.dim('  1. Run ') + chalk.cyan('rigour init') + chalk.dim(' to detect your project role and apply standards.'));
+    console.log(chalk.dim('  2. Run ') + chalk.cyan('rigour check') + chalk.dim(' to see existing violations.'));
+    console.log(chalk.dim('  3. Run ') + chalk.cyan('rigour run -- <your-agent-command>') + chalk.dim(' to automate the fix loop.\n'));
+
+    console.log(chalk.bold('Key Concepts:'));
+    console.log(chalk.yellow('  • Fix Packet v2') + chalk.dim(': Structured diagnostics fed directly into AI agents.'));
+    console.log(chalk.yellow('  • Safety Rails') + chalk.dim(': Prevents "explosive" refactoring (max files changed).'));
+    console.log(chalk.yellow('  • Strategic Guardians') + chalk.dim(': Dependency and Architectural boundary enforcement.\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.\n'));
+
+    console.log(chalk.dim('For more detailed docs, visit: ') + chalk.underline('https://github.com/erashu212/rigour/docs\n'));
+}

package/src/commands/init.ts

@@ -4,9 +4,62 @@ import chalk from 'chalk';
 import yaml from 'yaml';
 import { DiscoveryService } from '@rigour-labs/core';
 
-export async function initCommand(cwd: string) {
+export interface InitOptions {
+    preset?: string;
+    paradigm?: string;
+    dryRun?: boolean;
+    explain?: boolean;
+}
+
+export async function initCommand(cwd: string, options: InitOptions = {}) {
     const discovery = new DiscoveryService();
-    const recommendedConfig = await discovery.discover(cwd);
+    const result = await discovery.discover(cwd);
+    let recommendedConfig = result.config;
+
+    // Override with user options if provided and re-apply template logic if necessary
+    if (options.preset || options.paradigm) {
+        const core = await import('@rigour-labs/core');
+
+        let customBase = { ...core.UNIVERSAL_CONFIG };
+
+        if (options.preset) {
+            const t = core.TEMPLATES.find((t: any) => t.name === options.preset);
+            if (t) customBase = (discovery as any).mergeConfig(customBase, t.config);
+        } else if (recommendedConfig.preset) {
+            const t = core.TEMPLATES.find((t: any) => t.name === recommendedConfig.preset);
+            if (t) customBase = (discovery as any).mergeConfig(customBase, t.config);
+        }
+
+        if (options.paradigm) {
+            const t = core.PARADIGM_TEMPLATES.find((t: any) => t.name === options.paradigm);
+            if (t) customBase = (discovery as any).mergeConfig(customBase, t.config);
+        } else if (recommendedConfig.paradigm) {
+            const t = core.PARADIGM_TEMPLATES.find((t: any) => t.name === recommendedConfig.paradigm);
+            if (t) customBase = (discovery as any).mergeConfig(customBase, t.config);
+        }
+
+        recommendedConfig = customBase;
+        if (options.preset) recommendedConfig.preset = options.preset;
+        if (options.paradigm) recommendedConfig.paradigm = options.paradigm;
+    }
+
+    if (options.dryRun || options.explain) {
+        console.log(chalk.bold.blue('\n🔍 Rigour Auto-Discovery (Dry Run):'));
+        if (recommendedConfig.preset) {
+            console.log(chalk.cyan(`   Role: `) + chalk.bold(recommendedConfig.preset.toUpperCase()));
+            if (options.explain && result.matches.preset) {
+                console.log(chalk.dim(`         (Marker found: ${result.matches.preset.marker})`));
+            }
+        }
+        if (recommendedConfig.paradigm) {
+            console.log(chalk.cyan(`   Paradigm: `) + chalk.bold(recommendedConfig.paradigm.toUpperCase()));
+            if (options.explain && result.matches.paradigm) {
+                console.log(chalk.dim(`             (Marker found: ${result.matches.paradigm.marker})`));
+            }
+        }
+        console.log(chalk.yellow('\n[DRY RUN] No files will be written.'));
+        return;
+    }
 
     const configPath = path.join(cwd, 'rigour.yml');
 
@@ -15,6 +68,15 @@ export async function initCommand(cwd: string) {
         return;
     }
 
+    console.log(chalk.bold.blue('\n🔍 Rigour Auto-Discovery:'));
+    if (recommendedConfig.preset) {
+        console.log(chalk.cyan(`   Role: `) + chalk.bold(recommendedConfig.preset.toUpperCase()));
+    }
+    if (recommendedConfig.paradigm) {
+        console.log(chalk.cyan(`   Paradigm: `) + chalk.bold(recommendedConfig.paradigm.toUpperCase()));
+    }
+    console.log('');
+
     await fs.writeFile(configPath, yaml.stringify(recommendedConfig));
     console.log(chalk.green('✔ Created rigour.yml'));
 
@@ -28,36 +90,56 @@ export async function initCommand(cwd: string) {
         }
     }
 
-    // Agent Handshake (Cursor/AntiGravity)
-    const cursorRulesDir = path.join(cwd, '.cursor', 'rules');
-    await fs.ensureDir(cursorRulesDir);
-    const rulePath = path.join(cursorRulesDir, 'rigour.mdc');
+    // Agent Handshake (Universal / AntiGravity / Cursor)
+    const rigourDocsDir = path.join(cwd, 'docs');
+    await fs.ensureDir(rigourDocsDir);
+    const instructionsPath = path.join(rigourDocsDir, 'AGENT_INSTRUCTIONS.md');
 
-    const ruleContent = `---
-description: Enforcement of Rigour quality gates and best practices.
-globs: **/*
----
+    const ruleContent = `# 🛡️ Rigour: Engineering Excellence Protocol
+
+You are an Elite Software Engineer. You do not just write code that "works"; you write code that is **modular, maintainable, and rigorously verified.**
+
+## 🚦 The Rigour Loop (Mandatory)
+Before claiming "Done" for any task, you MUST follow this loop:
 
-# Rigour Enforcement
+1.  **Check**: Run \`npx @rigour-labs/cli check\` to verify compliance.
+2.  **Analyze**: If it fails, read \`rigour-fix-packet.json\` (V2 High-Fidelity) for exact failure points and constraints.
+3.  **Refactor**: Apply **SOLID** and **DRY** principles to resolve the violations according to constraints.
+4.  **Repeat**: Continue until \`npx @rigour-labs/cli check\` returns **PASS**.
 
-You are operating under Rigour engineering discipline.
+## 🧩 Engineering Standards
+- **Single Responsibility**: Keep files small and focused (max 500 lines).
+- **DRY (Don't Repeat Yourself)**: Extract common logic into utilities.
+- **Done is Done**: No \`TODO\` or \`FIXME\` comments allowed in the final state.
+- **Memory Preservation**: Always update docs/SPEC.md, docs/ARCH.md, docs/DECISIONS.md.
 
-## Core Rules
-- **Never claim done** until you run \`rigour check\` and it returns PASS.
-- If checks FAIL, fix **only** the listed failures. Do not add new features or refactor unrelated code.
-- Maintain project memory in \`docs/SPEC.md\`, \`docs/ARCH.md\`, and \`docs/DECISIONS.md\`.
-- Keep files modular. If a file exceeds 500 lines, you MUST break it into smaller components.
-- No \`TODO\` or \`FIXME\` comments allowed in the final submission.
+## 🛠️ Commands
+\`\`\`bash
+# Verify current state
+npx @rigour-labs/cli check
 
-## Workflow
-1. Write/Modify code.
-2. Run \`rigour check\`.
-3. If FAIL: Read \`rigour-report.json\` for exact failure points and fix them.
-4. If PASS: You may claim task completion.
+# Self-healing agent loop
+npx @rigour-labs/cli run -- <agent-command>
+\`\`\`
 `;
 
-    await fs.writeFile(rulePath, ruleContent);
-    console.log(chalk.green('✔ Initialized Agent Handshake (.cursor/rules/rigour.mdc)'));
+    // 1. Create Universal Instructions
+    await fs.writeFile(instructionsPath, ruleContent);
+    console.log(chalk.green('✔ Initialized Universal Agent Handshake (docs/AGENT_INSTRUCTIONS.md)'));
+
+    // 2. Create Cursor Specific Rules (.mdc)
+    const cursorRulesDir = path.join(cwd, '.cursor', 'rules');
+    await fs.ensureDir(cursorRulesDir);
+    const mdcPath = path.join(cursorRulesDir, 'rigour.mdc');
+    const mdcContent = `---
+description: Enforcement of Rigour quality gates and best practices.
+globs: **/*
+---
+
+${ruleContent}`;
+
+    await fs.writeFile(mdcPath, mdcContent);
+    console.log(chalk.green('✔ Initialized Cursor Handshake (.cursor/rules/rigour.mdc)'));
 
-    console.log(chalk.blue('\nRigour is ready. Run `rigour check` to verify your project.'));
+    console.log(chalk.blue('\nRigour is ready. Run `npx @rigour-labs/cli check` to verify your project.'));
 }