@nerviq/cli 0.9.3 → 0.9.4

package/bin/cli.js

@@ -7,6 +7,7 @@ const { buildProposalBundle, printProposalBundle, writePlanFile, applyProposalBu
 const { getGovernanceSummary, printGovernanceSummary, ensureWritableProfile, renderGovernanceMarkdown } = require('../src/governance');
 const { runBenchmark, printBenchmark, writeBenchmarkReport } = require('../src/benchmark');
 const { writeSnapshotArtifact, recordRecommendationOutcome, formatRecommendationOutcomeSummary, getRecommendationOutcomeSummary } = require('../src/activity');
+const { collectFeedback } = require('../src/feedback');
 const { version } = require('../package.json');
 
 const args = process.argv.slice(2);
@@ -20,7 +21,7 @@ const COMMAND_ALIASES = {
   gov: 'governance',
   outcome: 'feedback',
 };
-const KNOWN_COMMANDS = ['audit', 'setup', 'augment', 'suggest-only', 'plan', 'apply', 'governance', 'benchmark', 'deep-review', 'interactive', 'watch', 'badge', 'insights', 'history', 'compare', 'trend', 'scan', 'feedback', 'help', 'version'];
+const KNOWN_COMMANDS = ['audit', 'setup', 'augment', 'suggest-only', 'plan', 'apply', 'governance', 'benchmark', 'deep-review', 'interactive', 'watch', 'badge', 'insights', 'history', 'compare', 'trend', 'scan', 'feedback', 'doctor', 'convert', 'migrate', 'help', 'version'];
 
 function levenshtein(a, b) {
   const matrix = Array.from({ length: a.length + 1 }, () => Array(b.length + 1).fill(0));
@@ -73,11 +74,15 @@ function parseArgs(rawArgs) {
   let format = null;
   let commandSet = false;
   let extraArgs = [];
+  let convertFrom = null;
+  let convertTo = null;
+  let migrateFrom = null;
+  let migrateTo = null;
 
   for (let i = 0; i < rawArgs.length; i++) {
     const arg = rawArgs[i];
 
-    if (arg === '--threshold' || arg === '--out' || arg === '--plan' || arg === '--only' || arg === '--profile' || arg === '--mcp-pack' || arg === '--require' || arg === '--key' || arg === '--status' || arg === '--effect' || arg === '--notes' || arg === '--source' || arg === '--score-delta' || arg === '--platform' || arg === '--format') {
+    if (arg === '--threshold' || arg === '--out' || arg === '--plan' || arg === '--only' || arg === '--profile' || arg === '--mcp-pack' || arg === '--require' || arg === '--key' || arg === '--status' || arg === '--effect' || arg === '--notes' || arg === '--source' || arg === '--score-delta' || arg === '--platform' || arg === '--format' || arg === '--from' || arg === '--to') {
       const value = rawArgs[i + 1];
       if (!value || value.startsWith('--')) {
         throw new Error(`${arg} requires a value`);
@@ -97,6 +102,8 @@ function parseArgs(rawArgs) {
       if (arg === '--score-delta') feedbackScoreDelta = value.trim();
       if (arg === '--platform') platform = value.trim().toLowerCase();
       if (arg === '--format') format = value.trim().toLowerCase();
+      if (arg === '--from') { convertFrom = value.trim(); migrateFrom = value.trim(); }
+      if (arg === '--to') { convertTo = value.trim(); migrateTo = value.trim(); }
       i++;
       continue;
     }
@@ -191,7 +198,7 @@ function parseArgs(rawArgs) {
 
   const normalizedCommand = COMMAND_ALIASES[command] || command;
 
-  return { flags, command, normalizedCommand, threshold, out, planFile, only, profile, mcpPacks, requireChecks, feedbackKey, feedbackStatus, feedbackEffect, feedbackNotes, feedbackSource, feedbackScoreDelta, platform, format, extraArgs };
+  return { flags, command, normalizedCommand, threshold, out, planFile, only, profile, mcpPacks, requireChecks, feedbackKey, feedbackStatus, feedbackEffect, feedbackNotes, feedbackSource, feedbackScoreDelta, platform, format, extraArgs, convertFrom, convertTo, migrateFrom, migrateTo };
 }
 
 const HELP = `
@@ -230,6 +237,11 @@ const HELP = `
     npx nerviq badge            Generate shields.io badge markdown
     npx nerviq feedback         Record recommendation outcomes or show local outcome summary
 
+  Utilities:
+    npx nerviq doctor           Self-diagnostics: Node version, deps, freshness gates, platform detection
+    npx nerviq convert --from claude --to codex   Convert config between platforms
+    npx nerviq migrate --platform cursor --from v2 --to v3   Migrate platform config to newer version
+
   Options:
     --threshold N   Exit with code 1 if score is below N (useful for CI)
     --require A,B   Exit with code 1 if named checks fail (e.g. --require secretsProtection,permissionDeny)
@@ -246,6 +258,7 @@ const HELP = `
     --score-delta N Optional observed score delta tied to the outcome
     --platform NAME Choose platform surface (claude default, codex advisory/build preview)
     --format NAME   Output format for audit results (json, sarif)
+    --feedback      After audit output, prompt "Was this helpful? (y/n)" for each displayed top action and save answers locally
     --snapshot      Save a normalized snapshot artifact under .claude/nerviq/snapshots/
     --lite          Show a short top-3 quick scan with one clear next command
     --dry-run       Preview apply without writing files
@@ -316,6 +329,7 @@ async function main() {
     auto: flags.includes('--auto'),
     lite: flags.includes('--lite'),
     snapshot: flags.includes('--snapshot'),
+    feedback: flags.includes('--feedback'),
     dryRun: flags.includes('--dry-run'),
     threshold: parsed.threshold !== null ? Number(parsed.threshold) : null,
     out: parsed.out,
@@ -699,6 +713,34 @@ async function main() {
     } else if (normalizedCommand === 'watch') {
       const { watch } = require('../src/watch');
       await watch(options);
+    } else if (normalizedCommand === 'doctor') {
+      const { runDoctor } = require('../src/doctor');
+      const output = await runDoctor({ dir: options.dir, json: options.json, verbose: options.verbose });
+      console.log(output);
+      process.exit(0);
+    } else if (normalizedCommand === 'convert') {
+      const { runConvert } = require('../src/convert');
+      const output = await runConvert({
+        dir: options.dir,
+        from: parsed.convertFrom,
+        to: parsed.convertTo,
+        dryRun: options.dryRun,
+        json: options.json,
+      });
+      console.log(output);
+      process.exit(0);
+    } else if (normalizedCommand === 'migrate') {
+      const { runMigrate } = require('../src/migrate');
+      const output = await runMigrate({
+        dir: options.dir,
+        platform: options.platform || parsed.platform || 'claude',
+        from: parsed.migrateFrom,
+        to: parsed.migrateTo,
+        dryRun: options.dryRun,
+        json: options.json,
+      });
+      console.log(output);
+      process.exit(0);
     } else if (normalizedCommand === 'setup') {
       await setup(options);
       if (options.snapshot) {
@@ -712,6 +754,25 @@ async function main() {
       }
     } else {
       const result = await audit(options);
+      if (options.feedback && !options.json && options.format === null) {
+        const feedbackTargets = options.lite
+          ? (result.liteSummary?.topNextActions || [])
+          : (result.topNextActions || []);
+        const feedbackResult = await collectFeedback(options.dir, {
+          findings: feedbackTargets,
+          platform: result.platform,
+          sourceCommand: normalizedCommand,
+          score: result.score,
+        });
+        if (feedbackResult.mode === 'skipped-noninteractive') {
+          console.log('  Feedback prompt skipped: interactive terminal required.');
+          console.log('');
+        } else if (feedbackResult.saved > 0) {
+          console.log(`  Feedback saved: ${feedbackResult.relativeDir}`);
+          console.log(`  Helpful: ${feedbackResult.helpful} | Not helpful: ${feedbackResult.unhelpful}`);
+          console.log('');
+        }
+      }
       const snapshot = options.snapshot ? writeSnapshotArtifact(options.dir, 'audit', result, {
         sourceCommand: normalizedCommand,
       }) : null;

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@nerviq/cli",
-  "version": "0.9.3",
+  "version": "0.9.4",
   "description": "The intelligent nervous system for AI coding agents — audit, align, and amplify every platform on every project.",
   "main": "src/index.js",
   "bin": {
-    "nerviq": "bin/cli.js"
+    "nerviq": "bin/cli.js",
+    "nerviq-mcp": "src/mcp-server.js"
   },
   "files": [
     "bin",

package/src/aider/techniques.js

@@ -20,6 +20,7 @@
  */
 
 const { containsEmbeddedSecret } = require('../secret-patterns');
+const { attachSourceUrls } = require('../source-urls');
 
 const FILLER_PATTERNS = [
   /\bbe helpful\b/i,
@@ -1389,6 +1390,8 @@ const AIDER_TECHNIQUES = {
   },
 };
 
+attachSourceUrls('aider', AIDER_TECHNIQUES);
+
 module.exports = {
   AIDER_TECHNIQUES,
 };

package/src/audit.js

@@ -461,7 +461,7 @@ function buildTopNextActions(failed, limit = 5, outcomeSummaryByKey = {}, option
       return scoreB - scoreA;
     })
     .slice(0, limit)
-    .map(({ key, id, name, impact, fix, category }) => {
+    .map(({ key, id, name, impact, fix, category, sourceUrl }) => {
       const feedback = outcomeSummaryByKey[key] || null;
       const rankingAdjustment = getRecommendationAdjustment(outcomeSummaryByKey, key);
       const signals = [
@@ -491,6 +491,7 @@ function buildTopNextActions(failed, limit = 5, outcomeSummaryByKey = {}, option
       name,
       impact,
       category,
+      sourceUrl,
       module: CATEGORY_MODULES[category] || category,
       fix,
       priorityScore,
@@ -810,7 +811,7 @@ async function audit(options) {
     stacks,
     results,
     categoryScores,
-    quickWins: quickWins.map(({ key, name, impact, fix, category }) => ({ key, name, impact, category, fix })),
+    quickWins: quickWins.map(({ key, name, impact, fix, category, sourceUrl }) => ({ key, name, impact, category, fix, sourceUrl })),
     topNextActions,
     recommendationOutcomes: {
       totalEntries: outcomeSummary.totalEntries,

package/src/codex/techniques.js

@@ -1,6 +1,7 @@
 const os = require('os');
 const path = require('path');
 const { EMBEDDED_SECRET_PATTERNS, containsEmbeddedSecret } = require('../secret-patterns');
+const { attachSourceUrls } = require('../source-urls');
 
 const DEFAULT_PROJECT_DOC_MAX_BYTES = 32768;
 const SUPPORTED_HOOK_EVENTS = new Set(['SessionStart', 'PreToolUse', 'PostToolUse', 'UserPromptSubmit', 'Stop']);
@@ -3249,6 +3250,8 @@ const CODEX_TECHNIQUES = {
   },
 };
 
+attachSourceUrls('codex', CODEX_TECHNIQUES);
+
 module.exports = {
   CODEX_TECHNIQUES,
 };

package/src/convert.js

@@ -0,0 +1,336 @@
+/**
+ * Nerviq Convert
+ *
+ * Converts configuration files between AI coding platforms.
+ * Reads the source platform's config and emits equivalent config
+ * for the target platform, preserving intent where possible.
+ *
+ * Supported conversions:
+ *   claude  → codex, cursor, copilot, gemini, windsurf, aider
+ *   codex   → claude, cursor, copilot, gemini, windsurf, aider
+ *   cursor  → claude, codex, copilot, gemini, windsurf, aider
+ *   (any)   → (any)  using canonical model as intermediary
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const COLORS = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[36m',
+};
+
+function c(text, color) {
+  return `${COLORS[color] || ''}${text}${COLORS.reset}`;
+}
+
+// ─── Platform config readers ─────────────────────────────────────────────────
+
+/**
+ * Read the canonical "intent" from a source platform.
+ * Returns a normalized object with: name, description, rules[], mcpServers{}, hooks[]
+ */
+function readSourceConfig(dir, from) {
+  const canonical = {
+    platform: from,
+    name: path.basename(dir),
+    description: null,
+    rules: [],         // Array of { name, content, alwaysOn, glob, description }
+    mcpServers: {},    // { serverName: { command, args, env, url, type } }
+    hooks: [],         // Array of { event, command, matcher }
+    techStack: [],     // Detected languages/frameworks
+    lintCmd: null,
+    testCmd: null,
+    buildCmd: null,
+  };
+
+  if (from === 'claude') {
+    const claudeMd = fs.existsSync(path.join(dir, 'CLAUDE.md'))
+      ? fs.readFileSync(path.join(dir, 'CLAUDE.md'), 'utf8')
+      : null;
+    if (claudeMd) {
+      canonical.description = claudeMd.slice(0, 500);
+      canonical.rules.push({ name: 'CLAUDE.md', content: claudeMd, alwaysOn: true });
+    }
+    // Read .claude/settings.json for MCP
+    const settingsPath = path.join(dir, '.claude', 'settings.json');
+    if (fs.existsSync(settingsPath)) {
+      try {
+        const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+        if (settings.mcpServers) canonical.mcpServers = settings.mcpServers;
+      } catch {}
+    }
+  }
+
+  if (from === 'codex') {
+    const agentsMd = fs.existsSync(path.join(dir, 'AGENTS.md'))
+      ? fs.readFileSync(path.join(dir, 'AGENTS.md'), 'utf8')
+      : null;
+    if (agentsMd) {
+      canonical.description = agentsMd.slice(0, 500);
+      canonical.rules.push({ name: 'AGENTS.md', content: agentsMd, alwaysOn: true });
+    }
+  }
+
+  if (from === 'cursor') {
+    const rulesDir = path.join(dir, '.cursor', 'rules');
+    if (fs.existsSync(rulesDir)) {
+      const files = fs.readdirSync(rulesDir).filter(f => f.endsWith('.mdc'));
+      for (const file of files) {
+        const content = fs.readFileSync(path.join(rulesDir, file), 'utf8');
+        // Parse frontmatter
+        const fmMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+        let alwaysOn = false;
+        let glob = null;
+        let desc = null;
+        if (fmMatch) {
+          alwaysOn = /alwaysApply\s*:\s*true/i.test(fmMatch[1]);
+          const globMatch = fmMatch[1].match(/globs?\s*:\s*(.+)/i);
+          if (globMatch) glob = globMatch[1].trim();
+          const descMatch = fmMatch[1].match(/description\s*:\s*"?([^"\n]+)"?/i);
+          if (descMatch) desc = descMatch[1].trim();
+        }
+        canonical.rules.push({
+          name: file.replace('.mdc', ''),
+          content,
+          alwaysOn,
+          glob,
+          description: desc,
+        });
+      }
+    }
+    // Cursor MCP
+    const mcpPath = path.join(dir, '.cursor', 'mcp.json');
+    if (fs.existsSync(mcpPath)) {
+      try {
+        const mcp = JSON.parse(fs.readFileSync(mcpPath, 'utf8'));
+        if (mcp.mcpServers) canonical.mcpServers = mcp.mcpServers;
+      } catch {}
+    }
+  }
+
+  if (from === 'gemini') {
+    const geminiMd = fs.existsSync(path.join(dir, 'GEMINI.md'))
+      ? fs.readFileSync(path.join(dir, 'GEMINI.md'), 'utf8')
+      : null;
+    if (geminiMd) {
+      canonical.description = geminiMd.slice(0, 500);
+      canonical.rules.push({ name: 'GEMINI.md', content: geminiMd, alwaysOn: true });
+    }
+  }
+
+  if (from === 'windsurf') {
+    const windsurfRulesDir = path.join(dir, '.windsurf', 'rules');
+    if (fs.existsSync(windsurfRulesDir)) {
+      const files = fs.readdirSync(windsurfRulesDir).filter(f => f.endsWith('.md'));
+      for (const file of files) {
+        const content = fs.readFileSync(path.join(windsurfRulesDir, file), 'utf8');
+        canonical.rules.push({ name: file.replace('.md', ''), content, alwaysOn: true });
+      }
+    }
+  }
+
+  if (from === 'aider') {
+    const aiderConf = fs.existsSync(path.join(dir, '.aider.conf.yml'))
+      ? fs.readFileSync(path.join(dir, '.aider.conf.yml'), 'utf8')
+      : null;
+    if (aiderConf) {
+      canonical.rules.push({ name: '.aider.conf.yml', content: aiderConf, alwaysOn: false });
+      const lintMatch = aiderConf.match(/lint-cmd\s*:\s*(.+)/);
+      if (lintMatch) canonical.lintCmd = lintMatch[1].trim().replace(/^['"]|['"]$/g, '');
+      const testMatch = aiderConf.match(/test-cmd\s*:\s*(.+)/);
+      if (testMatch) canonical.testCmd = testMatch[1].trim().replace(/^['"]|['"]$/g, '');
+    }
+  }
+
+  if (from === 'copilot') {
+    const copilotPath = path.join(dir, '.github', 'copilot-instructions.md');
+    if (fs.existsSync(copilotPath)) {
+      const content = fs.readFileSync(copilotPath, 'utf8');
+      canonical.rules.push({ name: 'copilot-instructions', content, alwaysOn: true });
+    }
+  }
+
+  return canonical;
+}
+
+// ─── Platform config writers ─────────────────────────────────────────────────
+
+function buildTargetOutput(canonical, to, { dryRun = false } = {}) {
+  const outputs = [];  // Array of { path, content }
+  const combinedContent = canonical.rules.map(r => r.content).join('\n\n');
+
+  if (to === 'claude') {
+    // Extract or create CLAUDE.md from combined rules
+    const content = `# ${canonical.name}\n\n${combinedContent}\n`;
+    outputs.push({ file: 'CLAUDE.md', content });
+
+    if (Object.keys(canonical.mcpServers).length > 0) {
+      const settings = { mcpServers: canonical.mcpServers };
+      outputs.push({ file: '.claude/settings.json', content: JSON.stringify(settings, null, 2) + '\n' });
+    }
+  }
+
+  if (to === 'codex') {
+    const content = `# ${canonical.name}\n\n${combinedContent}\n`;
+    outputs.push({ file: 'AGENTS.md', content });
+  }
+
+  if (to === 'cursor') {
+    // Write each rule as an .mdc file
+    if (canonical.rules.length === 0) {
+      const content = `---\nalwaysApply: true\n---\n\n# ${canonical.name}\n\n${combinedContent}\n`;
+      outputs.push({ file: '.cursor/rules/core.mdc', content });
+    } else {
+      for (const rule of canonical.rules) {
+        const fm = rule.alwaysOn
+          ? `---\nalwaysApply: true\n---\n`
+          : rule.glob
+            ? `---\nglobs: ${rule.glob}\nalwaysApply: false\n---\n`
+            : `---\nalwaysApply: false\n---\n`;
+        outputs.push({ file: `.cursor/rules/${rule.name}.mdc`, content: `${fm}\n${rule.content}\n` });
+      }
+    }
+    if (Object.keys(canonical.mcpServers).length > 0) {
+      const mcp = { mcpServers: canonical.mcpServers };
+      outputs.push({ file: '.cursor/mcp.json', content: JSON.stringify(mcp, null, 2) + '\n' });
+    }
+  }
+
+  if (to === 'gemini') {
+    const content = `# ${canonical.name}\n\n${combinedContent}\n`;
+    outputs.push({ file: 'GEMINI.md', content });
+    if (Object.keys(canonical.mcpServers).length > 0) {
+      const settings = { mcpServers: canonical.mcpServers };
+      outputs.push({ file: '.gemini/settings.json', content: JSON.stringify(settings, null, 2) + '\n' });
+    }
+  }
+
+  if (to === 'windsurf') {
+    if (canonical.rules.length === 0) {
+      outputs.push({ file: '.windsurf/rules/core.md', content: `---\ntrigger: always_on\n---\n\n${combinedContent}\n` });
+    } else {
+      for (const rule of canonical.rules) {
+        const fm = `---\ntrigger: always_on\n---\n`;
+        const safeContent = rule.content.replace(/^---[\s\S]*?---\n/m, '').trim();
+        outputs.push({ file: `.windsurf/rules/${rule.name}.md`, content: `${fm}\n${safeContent}\n` });
+      }
+    }
+  }
+
+  if (to === 'aider') {
+    const confLines = ['# Generated by nerviq convert'];
+    if (canonical.lintCmd) confLines.push(`lint-cmd: '${canonical.lintCmd}'`);
+    if (canonical.testCmd) confLines.push(`test-cmd: '${canonical.testCmd}'`);
+    confLines.push('auto-commits: true');
+    confLines.push('auto-lint: true');
+    outputs.push({ file: '.aider.conf.yml', content: confLines.join('\n') + '\n' });
+    if (combinedContent.trim()) {
+      outputs.push({ file: 'CONVENTIONS.md', content: `# ${canonical.name} Conventions\n\n${combinedContent}\n` });
+    }
+  }
+
+  if (to === 'copilot') {
+    const content = `# ${canonical.name}\n\n${combinedContent}\n`;
+    outputs.push({ file: '.github/copilot-instructions.md', content });
+  }
+
+  return outputs;
+}
+
+// ─── Main convert function ────────────────────────────────────────────────────
+
+async function runConvert({ dir = process.cwd(), from, to, dryRun = false, json = false } = {}) {
+  if (!from || !to) {
+    throw new Error('Both --from and --to are required. Example: nerviq convert --from claude --to codex');
+  }
+
+  const SUPPORTED = ['claude', 'codex', 'cursor', 'copilot', 'gemini', 'windsurf', 'aider', 'opencode'];
+  if (!SUPPORTED.includes(from)) throw new Error(`Unsupported source platform '${from}'. Use: ${SUPPORTED.join(', ')}`);
+  if (!SUPPORTED.includes(to)) throw new Error(`Unsupported target platform '${to}'. Use: ${SUPPORTED.join(', ')}`);
+  if (from === to) throw new Error(`Source and target platform are the same: '${from}'`);
+
+  const canonical = readSourceConfig(dir, from);
+  const outputs = buildTargetOutput(canonical, to, { dryRun });
+
+  const written = [];
+  const skipped = [];
+
+  if (!dryRun) {
+    for (const out of outputs) {
+      const outPath = path.join(dir, out.file);
+      const outDir = path.dirname(outPath);
+      if (!fs.existsSync(outPath)) {
+        fs.mkdirSync(outDir, { recursive: true });
+        fs.writeFileSync(outPath, out.content, 'utf8');
+        written.push(out.file);
+      } else {
+        skipped.push(out.file);
+      }
+    }
+  }
+
+  const result = {
+    from,
+    to,
+    dir,
+    dryRun,
+    sourceRulesFound: canonical.rules.length,
+    mcpServersFound: Object.keys(canonical.mcpServers).length,
+    outputFiles: outputs.map(o => o.file),
+    written: dryRun ? [] : written,
+    skipped: dryRun ? [] : skipped,
+    wouldWrite: dryRun ? outputs.map(o => o.file) : [],
+  };
+
+  if (json) return JSON.stringify(result, null, 2);
+
+  const lines = [''];
+  lines.push(c(`  nerviq convert  ${from} → ${to}`, 'bold'));
+  lines.push(c('  ═══════════════════════════════════════', 'dim'));
+  lines.push('');
+  lines.push(`  Source platform:  ${c(from, 'blue')}   (${canonical.rules.length} rule(s) found)`);
+  lines.push(`  Target platform:  ${c(to, 'blue')}`);
+  lines.push(`  Directory:        ${dir}`);
+  lines.push(`  MCP servers:      ${Object.keys(canonical.mcpServers).length}`);
+  lines.push('');
+
+  if (dryRun) {
+    lines.push(c('  Dry run — no files written', 'yellow'));
+    lines.push('');
+    lines.push('  Would generate:');
+    for (const f of outputs) {
+      lines.push(`    ${c('→', 'dim')} ${f.file}`);
+    }
+  } else if (written.length > 0 || skipped.length > 0) {
+    if (written.length > 0) {
+      lines.push('  Written:');
+      for (const f of written) lines.push(`    ${c('✓', 'green')} ${f}`);
+    }
+    if (skipped.length > 0) {
+      lines.push('  Skipped (already exists):');
+      for (const f of skipped) lines.push(`    ${c('-', 'dim')} ${f}`);
+    }
+  }
+
+  lines.push('');
+  if (!dryRun && written.length > 0) {
+    lines.push(c(`  ✓ Conversion complete. Run \`nerviq audit --platform ${to}\` to verify.`, 'green'));
+  } else if (dryRun) {
+    lines.push(c(`  Run without --dry-run to write files.`, 'dim'));
+  } else {
+    lines.push(c(`  No new files written (all already exist).`, 'dim'));
+  }
+  lines.push('');
+
+  return lines.join('\n');
+}
+
+module.exports = { runConvert };

package/src/copilot/techniques.js

@@ -15,6 +15,7 @@ const os = require('os');
 const path = require('path');
 const { CopilotProjectContext } = require('./context');
 const { EMBEDDED_SECRET_PATTERNS, containsEmbeddedSecret } = require('../secret-patterns');
+const { attachSourceUrls } = require('../source-urls');
 const { extractFrontmatter, validateInstructionFrontmatter, validatePromptFrontmatter } = require('./config-parser');
 
 // ─── Shared helpers ─────────────────────────────────────────────────────────
@@ -1928,6 +1929,8 @@ const COPILOT_TECHNIQUES = {
   },
 };
 
+attachSourceUrls('copilot', COPILOT_TECHNIQUES);
+
 module.exports = {
   COPILOT_TECHNIQUES,
 };

package/src/cursor/techniques.js

@@ -15,6 +15,7 @@ const os = require('os');
 const path = require('path');
 const { CursorProjectContext } = require('./context');
 const { EMBEDDED_SECRET_PATTERNS, containsEmbeddedSecret } = require('../secret-patterns');
+const { attachSourceUrls } = require('../source-urls');
 const { validateMdcFrontmatter, validateMcpEnvVars } = require('./config-parser');
 
 // ─── Shared helpers ─────────────────────────────────────────────────────────
@@ -1861,6 +1862,8 @@ const CURSOR_TECHNIQUES = {
   },
 };
 
+attachSourceUrls('cursor', CURSOR_TECHNIQUES);
+
 module.exports = {
   CURSOR_TECHNIQUES,
 };