@nerviq/cli 0.0.1 → 0.9.0-beta.1

package/src/cursor/governance.js

@@ -0,0 +1,229 @@
+/**
+ * Cursor Governance Module
+ *
+ * 6 permission profiles, 7 hook equivalents, 5 policy packs.
+ *
+ * Cursor-specific differences from Copilot/Gemini:
+ * - 3 execution surfaces: foreground (IDE), background (cloud VM), automations (event-driven)
+ * - Privacy Mode OFF by default (code sent to model providers)
+ * - No terminal sandbox (unlike Copilot's VS Code sandbox)
+ * - Settings stored in SQLite (state.vscdb), NOT JSON
+ * - Automations run without approval — trigger misconfiguration = runaway agents
+ * - MCP hard limit ~40 tools, silent drop beyond
+ * - Background agent has full home directory read access (security finding Nov 2025)
+ */
+
+const { CURSOR_DOMAIN_PACKS } = require('./domain-packs');
+const { CURSOR_MCP_PACKS } = require('./mcp-packs');
+
+const CURSOR_PERMISSION_PROFILES = [
+  {
+    key: 'read-only',
+    label: 'Read Only',
+    risk: 'low',
+    defaultSandbox: 'no-writes',
+    approvalPolicy: 'always-confirm',
+    useWhen: 'First contact with a repo, security review, or auditing.',
+    behavior: 'Agent can read and suggest, but all edits and terminal commands require explicit confirmation.',
+    surfaces: ['foreground'],
+  },
+  {
+    key: 'standard',
+    label: 'Standard',
+    risk: 'medium',
+    defaultSandbox: 'user-approval',
+    approvalPolicy: 'selective-approval',
+    useWhen: 'Default product work where agent edits locally but risky commands need review.',
+    behavior: 'Agent proposes edits. Terminal commands require per-command approval unless auto-run enabled.',
+    surfaces: ['foreground'],
+  },
+  {
+    key: 'agent-mode',
+    label: 'Agent Mode',
+    risk: 'medium',
+    defaultSandbox: 'auto-run-trusted',
+    approvalPolicy: 'auto-approve-safe',
+    useWhen: 'Trusted repos where full agent mode is the primary workflow.',
+    behavior: 'Full agent mode. Auto-run for trusted commands. YOLO mode available but discouraged.',
+    surfaces: ['foreground'],
+  },
+  {
+    key: 'background-agent',
+    label: 'Background Agent',
+    risk: 'high',
+    defaultSandbox: 'ephemeral-vm',
+    approvalPolicy: 'pr-gate',
+    useWhen: 'Async tasks that create branches and PRs. Privacy Mode must be disabled.',
+    behavior: 'Runs on ephemeral Ubuntu VM. Auto-approved terminal. Creates branch + PR. Full home directory readable (security finding). No max tool call limit.',
+    surfaces: ['background'],
+  },
+  {
+    key: 'automation',
+    label: 'Automation',
+    risk: 'high',
+    defaultSandbox: 'ephemeral-vm',
+    approvalPolicy: 'event-triggered',
+    useWhen: 'Event-driven triggers (push, PR, Slack, timer). No human approval before execution.',
+    behavior: 'Cloud VM per run. 30-minute cap. Diffs staged for review. Secrets via vault only. Can run hundreds per hour.',
+    surfaces: ['automations'],
+  },
+  {
+    key: 'enterprise',
+    label: 'Enterprise',
+    risk: 'low',
+    defaultSandbox: 'org-policy-enforced',
+    approvalPolicy: 'org-admin-controlled',
+    useWhen: 'Enterprise tier with SSO, SCIM, audit logs, MCP/model allowlists.',
+    behavior: 'Admin-managed policies. Privacy Mode enforced org-wide. Audit logs and AI code tracking APIs. BugBot for automated PR review.',
+    surfaces: ['foreground', 'background', 'automations'],
+  },
+];
+
+const CURSOR_HOOK_REGISTRY = [
+  {
+    key: 'always-apply-rules',
+    file: '.cursor/rules/*.mdc',
+    triggerPoint: 'alwaysApply: true',
+    matcher: 'every chat and agent message',
+    purpose: 'Inject core instructions into every agent interaction.',
+    risk: 'low',
+  },
+  {
+    key: 'auto-attached-rules',
+    file: '.cursor/rules/*.mdc',
+    triggerPoint: 'globs match',
+    matcher: 'file glob patterns',
+    purpose: 'Inject context-specific rules when matching files are open or referenced.',
+    risk: 'low',
+  },
+  {
+    key: 'auto-run-terminal',
+    file: 'Cursor Settings (SQLite)',
+    triggerPoint: 'terminal command execution',
+    matcher: 'terminal command patterns',
+    purpose: 'Auto-approve terminal commands without user confirmation (YOLO mode).',
+    risk: 'critical',
+  },
+  {
+    key: 'automation-trigger',
+    file: '.cursor/automations/*.yaml',
+    triggerPoint: 'event (push, PR, Slack, timer, webhook)',
+    matcher: 'event configuration',
+    purpose: 'Trigger cloud agent execution on specified events. Runs WITHOUT approval.',
+    risk: 'high',
+  },
+  {
+    key: 'bugbot-review',
+    file: 'BugBot config (per-repo)',
+    triggerPoint: 'PR opened/updated',
+    matcher: 'PR diff',
+    purpose: 'Automated code review on PRs. Can spawn cloud agent for auto-fixes.',
+    risk: 'medium',
+  },
+  {
+    key: 'environment-setup',
+    file: '.cursor/environment.json',
+    triggerPoint: 'background agent boot',
+    matcher: 'VM configuration',
+    purpose: 'Configure background agent VM: base image, env vars, persisted dirs, processes.',
+    risk: 'medium',
+  },
+  {
+    key: 'mcp-tool-approval',
+    file: '.cursor/mcp.json',
+    triggerPoint: 'MCP tool invocation',
+    matcher: 'tool name/server',
+    purpose: 'Control which MCP tools are available. Auto-run model for approved tools.',
+    risk: 'medium',
+  },
+];
+
+const CURSOR_POLICY_PACKS = [
+  {
+    key: 'baseline-safe',
+    label: 'Baseline Safe',
+    modules: ['.cursor/rules/ with alwaysApply', 'no .cursorrules', 'Privacy Mode awareness', 'no secrets in rules'],
+    useWhen: 'Default local Cursor rollout.',
+  },
+  {
+    key: 'background-agent-safe',
+    label: 'Background Agent Safe',
+    modules: ['environment.json configured', 'PR review gate', 'KMS secrets only', 'no direct push to main'],
+    useWhen: 'Repos using background agents for async tasks.',
+  },
+  {
+    key: 'automation-safe',
+    label: 'Automation Safe',
+    modules: ['scoped triggers (no wildcards)', 'debounce on frequent events', 'error notification', 'rate limits documented'],
+    useWhen: 'Repos using event-driven automations.',
+  },
+  {
+    key: 'enterprise-governed',
+    label: 'Enterprise Governed',
+    modules: ['SSO configured', 'audit logs enabled', 'MCP allowlist', 'Privacy Mode enforced', 'model access policy'],
+    useWhen: 'Enterprise tier repos with strict governance requirements.',
+  },
+  {
+    key: 'privacy-first',
+    label: 'Privacy First',
+    modules: ['Privacy Mode enabled', 'no secrets in any Cursor config', 'MCP env vars use ${env:} syntax', 'background agent home dir exposure documented'],
+    useWhen: 'Repos handling sensitive data where Privacy Mode and data protection are paramount.',
+  },
+];
+
+const CURSOR_PILOT_ROLLOUT_KIT = {
+  recommendedScope: [
+    'Start with audit and setup on one trusted repo before enabling background agents.',
+    'Keep .cursor/rules/ and .cursor/mcp.json in version control.',
+    'Enable Privacy Mode before using with sensitive code.',
+    'Migrate .cursorrules to .cursor/rules/*.mdc before relying on agent mode.',
+    'Test background agents on a non-critical repo first.',
+    'If using automations, start with manual triggers before event-driven.',
+  ],
+  approvals: [
+    'Engineering owner approves auto-run terminal policy and background agent usage.',
+    'Security owner approves Privacy Mode status and MCP server allowlist.',
+    'Pilot owner records before/after audit deltas and rollback expectations.',
+    'Org admin approves automation trigger scope and model access policy.',
+  ],
+  successMetrics: [
+    'Audit score delta',
+    'Surface coverage (foreground + background + automations)',
+    'Time to first useful agent task',
+    'No-overwrite rate on existing repo files',
+    'Legacy .cursorrules migration completion',
+    'MCP tool count within 40-tool limit',
+  ],
+  rollbackExpectations: [
+    'Every Cursor setup/apply write path should emit a rollback artifact.',
+    'Re-run audit after rollback to confirm the repo returned to expected state.',
+    'Background agents can be disabled by removing .cursor/environment.json.',
+    'Automations can be disabled by removing .cursor/automations/ directory.',
+  ],
+};
+
+function getCursorGovernanceSummary() {
+  return {
+    platform: 'cursor',
+    platformLabel: 'Cursor AI',
+    permissionProfiles: CURSOR_PERMISSION_PROFILES,
+    hookRegistry: CURSOR_HOOK_REGISTRY,
+    policyPacks: CURSOR_POLICY_PACKS,
+    domainPacks: CURSOR_DOMAIN_PACKS,
+    mcpPacks: CURSOR_MCP_PACKS,
+    pilotRolloutKit: CURSOR_PILOT_ROLLOUT_KIT,
+    platformCaveats: [
+      { id: 'cursorrules-ignored', severity: 'critical', message: 'Agent mode ignores .cursorrules — only .cursor/rules/*.mdc files work.' },
+      { id: 'privacy-off', severity: 'high', message: 'Privacy Mode OFF by default — code sent to model providers without zero-retention.' },
+      { id: 'mcp-tool-limit', severity: 'medium', message: 'MCP hard limit ~40 tools. Exceeding silently drops tools without warning.' },
+      { id: 'code-reversion', severity: 'critical', message: 'Code reversion risk from agent review + format-on-save + cloud sync conflict.' },
+      { id: 'no-terminal-sandbox', severity: 'high', message: 'No terminal sandbox equivalent (unlike Copilot). All terminal commands execute directly.' },
+      { id: 'bg-agent-home-dir', severity: 'critical', message: 'Background agents have full read access to home directory (~/.ssh/, ~/.aws/credentials, ~/.npmrc).' },
+      { id: 'automation-no-approval', severity: 'high', message: 'Automations run without human approval. Misconfigured triggers = uncontrolled execution.' },
+    ],
+  };
+}
+
+module.exports = {
+  getCursorGovernanceSummary,
+};

package/src/cursor/interactive.js

@@ -0,0 +1,391 @@
+/**
+ * Cursor Interactive Wizard — 10-stage guided setup.
+ *
+ * Adapted for Cursor's 3-surface architecture (foreground, background, automations).
+ *
+ * Stages:
+ *   1.  Project detection (stacks, existing .cursor/, .cursorrules)
+ *   2.  Rule type selection (Always, Auto Attached, Agent Requested, Manual)
+ *   3.  Legacy migration (.cursorrules → .cursor/rules/)
+ *   4.  Background agent setup
+ *   5.  Domain pack selection
+ *   6.  MCP pack selection
+ *   7.  Automation config
+ *   8.  BugBot configuration
+ *   9.  Privacy & security
+ *   10. Review & generate
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const readline = require('readline');
+const { STACKS } = require('../techniques');
+const { CursorProjectContext } = require('./context');
+const { CURSOR_TECHNIQUES } = require('./techniques');
+const { CURSOR_DOMAIN_PACKS, detectCursorDomainPacks } = require('./domain-packs');
+const { recommendCursorMcpPacks, CURSOR_MCP_PACKS } = require('./mcp-packs');
+
+const COLORS = {
+  reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
+  red: '\x1b[31m', green: '\x1b[32m', yellow: '\x1b[33m',
+  blue: '\x1b[36m', magenta: '\x1b[35m',
+};
+const c = (text, color) => `${COLORS[color] || ''}${text}${COLORS.reset}`;
+
+function ask(rl, question) {
+  return new Promise(resolve => rl.question(question, resolve));
+}
+
+function isTTY() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+
+const STAGE_NAMES = [
+  'Project Detection',
+  'Rule Type Selection',
+  'Legacy Migration',
+  'Background Agent Setup',
+  'Domain Pack Selection',
+  'MCP Pack Selection',
+  'Automation Config',
+  'BugBot Configuration',
+  'Privacy & Security',
+  'Review & Generate',
+];
+
+function printStageHeader(index) {
+  console.log('');
+  console.log(c(`  ── Stage ${index + 1}/${STAGE_NAMES.length}: ${STAGE_NAMES[index]} ──`, 'magenta'));
+  console.log('');
+}
+
+// --- Stage 1: Project Detection ---
+
+function runProjectDetection(ctx) {
+  const stacks = ctx.detectStacks(STACKS);
+  const rules = ctx.cursorRules ? ctx.cursorRules() : [];
+  const hasLegacy = ctx.hasLegacyRules ? ctx.hasLegacyRules() : false;
+  const hasMcpJson = ctx.mcpConfig().ok;
+  const hasEnvJson = ctx.environmentJson().ok;
+  const automations = ctx.automationsConfig ? ctx.automationsConfig() : [];
+  const surfaces = ctx.detectSurfaces();
+
+  const auditResults = [];
+  for (const [key, technique] of Object.entries(CURSOR_TECHNIQUES)) {
+    auditResults.push({ key, ...technique, passed: technique.check(ctx) });
+  }
+  const passed = auditResults.filter(r => r.passed === true);
+  const failed = auditResults.filter(r => r.passed === false);
+
+  return { stacks, rules, hasLegacy, hasMcpJson, hasEnvJson, automations, surfaces, auditResults, passed, failed };
+}
+
+async function stageProjectDetection(rl, ctx, state) {
+  printStageHeader(0);
+  const det = runProjectDetection(ctx);
+  Object.assign(state, det);
+
+  if (det.stacks.length > 0) console.log(c(`  Detected stacks: ${det.stacks.map(s => s.label).join(', ')}`, 'blue'));
+  else console.log(c('  No specific stack detected — will use baseline defaults.', 'dim'));
+
+  console.log(c(`  Working directory: ${ctx.dir}`, 'dim'));
+  console.log('');
+  console.log(`  ${c(`${det.passed.length}/${det.auditResults.length}`, 'bold')} Cursor checks passing.`);
+  console.log(`  ${c(String(det.failed.length), 'yellow')} improvements available.`);
+  console.log('');
+  console.log(`  Surfaces: FG ${det.surfaces.foreground ? c('Y', 'green') : c('N', 'red')} | BG ${det.surfaces.background ? c('Y', 'green') : c('N', 'red')} | Auto ${det.surfaces.automations ? c('Y', 'green') : c('N', 'red')}`);
+  console.log(`  Rules: ${det.rules.length} .mdc files${det.hasLegacy ? c(' + .cursorrules (IGNORED by agents!)', 'red') : ''}`);
+
+  if (det.rules.length > 0 || det.hasLegacy) {
+    console.log('');
+    if (det.hasLegacy) console.log(c('  CRITICAL: .cursorrules found — this file is IGNORED by agent mode!', 'red'));
+    if (det.rules.length > 0) console.log(c(`    ${det.rules.length} .mdc rule files in .cursor/rules/`, 'dim'));
+    if (det.hasMcpJson) console.log(c('    .cursor/mcp.json found', 'dim'));
+    if (det.hasEnvJson) console.log(c('    .cursor/environment.json found', 'dim'));
+    console.log('');
+
+    const answer = await ask(rl, c('  Merge with existing config or replace? (merge/replace/quit) ', 'magenta'));
+    const choice = answer.trim().toLowerCase();
+    if (choice === 'quit' || choice === 'q') return 'quit';
+    state.migrationMode = choice === 'replace' ? 'replace' : 'merge';
+  } else {
+    state.migrationMode = 'create';
+    console.log('');
+    console.log(c('  No existing Cursor rules — will create fresh setup.', 'dim'));
+  }
+
+  return 'next';
+}
+
+// --- Stage 2: Rule Type Selection ---
+
+async function stageRuleTypeSelection(rl, _ctx, state) {
+  printStageHeader(1);
+
+  console.log('  Cursor supports 4 rule types. Which do you want to generate?');
+  console.log('');
+  console.log(`    ${c('1', 'bold')}. ${c('Always Apply only', 'blue')} — Core rules for every interaction.`);
+  console.log(`    ${c('2', 'bold')}. ${c('Always + Auto Attached', 'blue')} — Core + file-type-specific rules.`);
+  console.log(`    ${c('3', 'bold')}. ${c('Full set', 'blue')} — Always + Auto Attached + Agent Requested.`);
+  console.log('');
+
+  const answer = await ask(rl, c('  Choice (1-3, or b=back, q=quit) [2]: ', 'magenta'));
+  const trimmed = answer.trim().toLowerCase();
+  if (trimmed === 'b') return 'back';
+  if (trimmed === 'q') return 'quit';
+
+  const choice = parseInt(trimmed, 10);
+  state.ruleTypes = ['always'];
+  if (choice >= 2 || trimmed === '') state.ruleTypes.push('auto-attached');
+  if (choice >= 3) state.ruleTypes.push('agent-requested');
+
+  console.log(c(`  → Rule types: ${state.ruleTypes.join(', ')}`, 'green'));
+  return 'next';
+}
+
+// --- Stage 3: Legacy Migration ---
+
+async function stageLegacyMigration(rl, ctx, state) {
+  if (!state.hasLegacy) return 'next';
+
+  printStageHeader(2);
+
+  console.log(c('  CRITICAL: .cursorrules file detected!', 'red'));
+  console.log('');
+  console.log('  Agent mode COMPLETELY IGNORES .cursorrules.');
+  console.log('  Only .cursor/rules/*.mdc files with MDC frontmatter reach agents.');
+  console.log('');
+  console.log(`    ${c('1', 'bold')}. ${c('Auto-migrate', 'blue')} — Convert .cursorrules content to .mdc format.`);
+  console.log(`    ${c('2', 'bold')}. ${c('Keep both', 'yellow')} — Generate new .mdc rules alongside .cursorrules.`);
+  console.log(`    ${c('3', 'bold')}. ${c('Skip', 'dim')} — Handle migration manually later.`);
+  console.log('');
+
+  const answer = await ask(rl, c('  Choice (1-3, or b=back, q=quit) [1]: ', 'magenta'));
+  const trimmed = answer.trim().toLowerCase();
+  if (trimmed === 'b') return 'back';
+  if (trimmed === 'q') return 'quit';
+
+  const choice = parseInt(trimmed, 10);
+  state.legacyMigration = choice === 3 ? 'skip' : choice === 2 ? 'keep-both' : 'auto-migrate';
+  console.log(c(`  → Legacy migration: ${state.legacyMigration}`, 'green'));
+  return 'next';
+}
+
+// --- Stage 4: Background Agent Setup ---
+
+async function stageBackgroundAgent(rl, _ctx, state) {
+  printStageHeader(3);
+
+  console.log('  Configure background agent environment?');
+  console.log('');
+  console.log(c('  Background agents run on ephemeral Ubuntu VMs.', 'dim'));
+  console.log(c('  SECURITY: They have full home directory read access.', 'yellow'));
+  console.log(c('  Privacy Mode must be DISABLED to use background agents.', 'yellow'));
+  console.log('');
+
+  const answer = await ask(rl, c('  Generate .cursor/environment.json? (y/n, or b=back, q=quit) [y]: ', 'magenta'));
+  const trimmed = answer.trim().toLowerCase();
+  if (trimmed === 'b') return 'back';
+  if (trimmed === 'q') return 'quit';
+
+  state.generateEnvironment = trimmed !== 'n';
+  console.log(c(`  → Background agent: ${state.generateEnvironment ? 'will configure' : 'skip'}`, 'green'));
+  return 'next';
+}
+
+// --- Stage 5: Domain Pack Selection ---
+
+async function stageDomainPacks(rl, ctx, state) {
+  printStageHeader(4);
+
+  const detected = detectCursorDomainPacks(ctx, state.stacks || []);
+  state.domainPacks = detected;
+
+  console.log(`  Detected ${detected.length} domain pack(s):`);
+  console.log('');
+  detected.forEach((pack, i) => {
+    console.log(`    ${c(`${i + 1}`, 'bold')}. ${c(pack.label, 'blue')} — ${pack.matchReasons[0] || pack.useWhen}`);
+  });
+  console.log('');
+
+  const answer = await ask(rl, c('  Accept detected packs? (y/n, or b=back, q=quit) [y]: ', 'magenta'));
+  const trimmed = answer.trim().toLowerCase();
+  if (trimmed === 'b') return 'back';
+  if (trimmed === 'q') return 'quit';
+  if (trimmed === 'n') state.domainPacks = [];
+
+  console.log(c(`  → Domain packs: ${state.domainPacks.map(p => p.label).join(', ') || 'none'}`, 'green'));
+  return 'next';
+}
+
+// --- Stage 6: MCP Pack Selection ---
+
+async function stageMcpPacks(rl, ctx, state) {
+  printStageHeader(5);
+
+  const backgroundOnly = state.generateEnvironment && !state.surfaces?.foreground;
+  const recommended = recommendCursorMcpPacks(state.stacks || [], state.domainPacks || [], { ctx, backgroundOnly });
+  state.mcpPacks = recommended;
+
+  console.log(`  Recommended ${recommended.length} MCP pack(s):`);
+  console.log(c(`  (Cursor hard limit: ~40 tools total — estimated: ~${recommended.length * 5} tools)`, 'yellow'));
+  console.log('');
+  recommended.forEach((pack, i) => {
+    const bgIcon = pack.backgroundAgentCompatible === false ? c(' [FG only]', 'yellow') : '';
+    console.log(`    ${c(`${i + 1}`, 'bold')}. ${c(pack.label, 'blue')}${bgIcon} — ${pack.description}`);
+  });
+  console.log('');
+
+  const answer = await ask(rl, c('  Accept recommended packs? (y/n, or b=back, q=quit) [y]: ', 'magenta'));
+  const trimmed = answer.trim().toLowerCase();
+  if (trimmed === 'b') return 'back';
+  if (trimmed === 'q') return 'quit';
+  if (trimmed === 'n') state.mcpPacks = [];
+
+  console.log(c(`  → MCP packs: ${state.mcpPacks.map(p => p.label).join(', ') || 'none'}`, 'green'));
+  return 'next';
+}
+
+// --- Stage 7: Automation Config ---
+
+async function stageAutomationConfig(rl, _ctx, state) {
+  printStageHeader(6);
+
+  console.log('  Configure event-driven automations?');
+  console.log('');
+  console.log(c('  Automations run WITHOUT human approval.', 'red'));
+  console.log(c('  Supported triggers: cron, GitHub events, Slack, Linear, webhook, etc.', 'dim'));
+  console.log(c('  Each run has a 30-minute cap and fresh container.', 'dim'));
+  console.log('');
+
+  const answer = await ask(rl, c('  Set up automations? (y/n, or b=back, q=quit) [n]: ', 'magenta'));
+  const trimmed = answer.trim().toLowerCase();
+  if (trimmed === 'b') return 'back';
+  if (trimmed === 'q') return 'quit';
+
+  state.generateAutomations = trimmed === 'y';
+  console.log(c(`  → Automations: ${state.generateAutomations ? 'will configure' : 'skip'}`, 'green'));
+  return 'next';
+}
+
+// --- Stage 8: BugBot ---
+
+async function stageBugbot(rl, _ctx, state) {
+  printStageHeader(7);
+
+  console.log('  Configure BugBot for automated PR review?');
+  console.log('');
+  console.log(c('  BugBot processes 2M+ PRs/month. Can auto-fix >70% of issues.', 'dim'));
+  console.log(c('  Pricing: $40/user/month for up to 200 PRs/month.', 'dim'));
+  console.log('');
+
+  const answer = await ask(rl, c('  Generate BugBot configuration guide? (y/n, or b=back, q=quit) [y]: ', 'magenta'));
+  const trimmed = answer.trim().toLowerCase();
+  if (trimmed === 'b') return 'back';
+  if (trimmed === 'q') return 'quit';
+
+  state.generateBugbot = trimmed !== 'n';
+  console.log(c(`  → BugBot: ${state.generateBugbot ? 'will configure' : 'skip'}`, 'green'));
+  return 'next';
+}
+
+// --- Stage 9: Privacy & Security ---
+
+async function stagePrivacySecurity(rl, _ctx, state) {
+  printStageHeader(8);
+
+  console.log(c('  IMPORTANT: Privacy Mode is OFF by default in Cursor!', 'red'));
+  console.log('');
+  console.log('  When Privacy Mode is off, your code is sent to model providers.');
+  console.log('  Enable in: Cursor Settings > General > Privacy Mode');
+  console.log('');
+
+  const answer = await ask(rl, c('  Acknowledge privacy risk and continue? (y/n, or b=back, q=quit) [y]: ', 'magenta'));
+  const trimmed = answer.trim().toLowerCase();
+  if (trimmed === 'b') return 'back';
+  if (trimmed === 'q') return 'quit';
+  if (trimmed === 'n') return 'quit';
+
+  state.privacyAcknowledged = true;
+  console.log(c('  → Privacy risk acknowledged. Remember to enable Privacy Mode for sensitive repos.', 'yellow'));
+  return 'next';
+}
+
+// --- Stage 10: Review & Generate ---
+
+async function stageReviewGenerate(rl, _ctx, state) {
+  printStageHeader(9);
+
+  console.log('  Summary of your Cursor setup:');
+  console.log('');
+  console.log(`    Rule types: ${(state.ruleTypes || []).join(', ')}`);
+  console.log(`    Legacy migration: ${state.legacyMigration || 'N/A'}`);
+  console.log(`    Background agent: ${state.generateEnvironment ? 'yes' : 'no'}`);
+  console.log(`    Domain packs: ${(state.domainPacks || []).map(p => p.label).join(', ') || 'none'}`);
+  console.log(`    MCP packs: ${(state.mcpPacks || []).map(p => p.label).join(', ') || 'none'}`);
+  console.log(`    Automations: ${state.generateAutomations ? 'yes' : 'no'}`);
+  console.log(`    BugBot: ${state.generateBugbot ? 'yes' : 'no'}`);
+  console.log('');
+
+  const answer = await ask(rl, c('  Generate files? (y/n, or b=back, q=quit) [y]: ', 'magenta'));
+  const trimmed = answer.trim().toLowerCase();
+  if (trimmed === 'b') return 'back';
+  if (trimmed === 'q') return 'quit';
+  if (trimmed === 'n') return 'quit';
+
+  state.confirmed = true;
+  return 'done';
+}
+
+// --- Main Wizard ---
+
+const STAGES = [
+  stageProjectDetection,
+  stageRuleTypeSelection,
+  stageLegacyMigration,
+  stageBackgroundAgent,
+  stageDomainPacks,
+  stageMcpPacks,
+  stageAutomationConfig,
+  stageBugbot,
+  stagePrivacySecurity,
+  stageReviewGenerate,
+];
+
+async function runCursorWizard(options) {
+  if (!isTTY()) {
+    console.log('Interactive wizard requires a TTY. Use --non-interactive or pipe mode instead.');
+    return null;
+  }
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const ctx = new CursorProjectContext(options.dir);
+  const state = {};
+
+  console.log('');
+  console.log(c('  nerviq cursor interactive wizard', 'bold'));
+  console.log(c('  ═══════════════════════════════════════', 'dim'));
+
+  let stageIndex = 0;
+
+  try {
+    while (stageIndex < STAGES.length) {
+      const result = await STAGES[stageIndex](rl, ctx, state);
+      if (result === 'quit') { rl.close(); return null; }
+      if (result === 'back') { stageIndex = Math.max(0, stageIndex - 1); continue; }
+      if (result === 'done') break;
+      stageIndex++;
+    }
+  } finally {
+    rl.close();
+  }
+
+  if (!state.confirmed) return null;
+  return state;
+}
+
+module.exports = {
+  runCursorWizard,
+  runProjectDetection,
+};