@nerviq/cli 1.2.5 → 1.2.6

package/bin/cli.js

@@ -24,7 +24,7 @@ const COMMAND_ALIASES = {
   gov: 'governance',
   outcome: 'feedback',
 };
-const KNOWN_COMMANDS = ['audit', 'org', 'setup', 'augment', 'suggest-only', 'plan', 'apply', 'governance', 'benchmark', 'deep-review', 'interactive', 'watch', 'badge', 'insights', 'history', 'compare', 'trend', 'scan', 'feedback', 'doctor', 'convert', 'migrate', 'catalog', 'certify', 'serve', 'help', 'version'];
+const KNOWN_COMMANDS = ['audit', 'org', 'setup', 'augment', 'suggest-only', 'plan', 'apply', 'governance', 'benchmark', 'deep-review', 'interactive', 'watch', 'badge', 'insights', 'history', 'compare', 'trend', 'scan', 'feedback', 'doctor', 'convert', 'migrate', 'catalog', 'certify', 'serve', 'harmony-audit', 'harmony-sync', 'harmony-drift', 'harmony-advise', 'harmony-watch', 'harmony-governance', 'synergy-report', 'help', 'version'];
 
 function levenshtein(a, b) {
   const matrix = Array.from({ length: a.length + 1 }, () => Array(b.length + 1).fill(0));
@@ -312,6 +312,9 @@ const HELP = `
 
   CROSS-PLATFORM
     nerviq harmony-audit          Drift detection across all active platforms
+    nerviq harmony-sync           Preview cross-platform sync (dry run)
+    nerviq harmony-sync --fix     Apply cross-platform sync (write files)
+    nerviq harmony-sync --json    JSON output for CI/automation
     nerviq synergy-report         Multi-agent amplification opportunities
     nerviq convert --from X --to Y   Convert configs between platforms
     nerviq migrate --platform X   Platform version migration helper
@@ -408,6 +411,7 @@ async function main() {
     lite: flags.includes('--lite'),
     snapshot: flags.includes('--snapshot'),
     feedback: flags.includes('--feedback'),
+    fix: flags.includes('--fix'),
     dryRun: flags.includes('--dry-run'),
     threshold: parsed.threshold !== null ? Number(parsed.threshold) : null,
     out: parsed.out,
@@ -862,6 +866,106 @@ async function main() {
       process.on('SIGINT', closeServer);
       process.on('SIGTERM', closeServer);
       return;
+    } else if (normalizedCommand === 'harmony-audit') {
+      const { runHarmonyAudit } = require('../src/harmony/cli');
+      await runHarmonyAudit(options);
+      process.exit(0);
+    } else if (normalizedCommand === 'harmony-sync') {
+      const { previewHarmonySync, applyHarmonySync } = require('../src/harmony/sync');
+      const dir = options.dir || process.cwd();
+
+      if (options.fix) {
+        // Apply mode: write files
+        const result = applyHarmonySync(dir);
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          console.log('');
+          console.log('\x1b[1m  Harmony Sync — Apply\x1b[0m');
+          console.log('\x1b[2m  ═══════════════════════════════════════\x1b[0m');
+          console.log('');
+          if (result.applied.length === 0 && result.skipped.length === 0) {
+            console.log('  \x1b[32mAll platforms are already in sync. Nothing to apply.\x1b[0m');
+          } else {
+            for (const item of result.applied) {
+              console.log(`  \x1b[32m✓\x1b[0m ${item.action.padEnd(8)} ${item.platform.padEnd(12)} ${item.path}`);
+            }
+            for (const item of result.skipped) {
+              const reason = typeof item === 'string' ? item : (item.reason || item.path);
+              console.log(`  \x1b[33m⚠\x1b[0m skipped  ${reason}`);
+            }
+            console.log('');
+            if (result.summary) {
+              console.log(`  Files: ${result.summary.totalFiles} (${result.summary.creates} created, ${result.summary.patches} patched)`);
+              console.log(`  Platforms: ${result.summary.platforms.join(', ')}`);
+            }
+          }
+          if (result.warnings && result.warnings.length > 0) {
+            console.log('');
+            for (const w of result.warnings) {
+              console.log(`  \x1b[33m⚠\x1b[0m ${w}`);
+            }
+          }
+          console.log('');
+        }
+      } else {
+        // Preview mode (dry run)
+        const plan = previewHarmonySync(dir);
+        if (options.json) {
+          console.log(JSON.stringify(plan, null, 2));
+        } else {
+          console.log('');
+          console.log('\x1b[1m  Harmony Sync — Preview\x1b[0m');
+          console.log('\x1b[2m  ═══════════════════════════════════════\x1b[0m');
+          console.log('');
+          if (plan.files.length === 0) {
+            console.log('  \x1b[32mAll platforms are already in sync. No changes needed.\x1b[0m');
+          } else {
+            for (const file of plan.files) {
+              const actionColor = file.action === 'create' ? '\x1b[32m' : '\x1b[36m';
+              console.log(`  ${actionColor}${file.action.padEnd(8)}\x1b[0m ${file.platform.padEnd(12)} ${file.path}`);
+              if (file.preview) {
+                console.log(`           \x1b[2m${file.preview}\x1b[0m`);
+              }
+            }
+            console.log('');
+            console.log(`  Total: ${plan.summary.totalFiles} file(s) — ${plan.summary.creates} create, ${plan.summary.patches} patch`);
+            console.log(`  Platforms: ${plan.summary.platforms.join(', ')}`);
+            if (plan.summary.recommendedTrust) {
+              console.log(`  Recommended trust: ${plan.summary.recommendedTrust}`);
+            }
+            console.log('');
+            console.log('  Run \x1b[1mnerviq harmony-sync --fix\x1b[0m to apply these changes.');
+          }
+          if (plan.warnings && plan.warnings.length > 0) {
+            console.log('');
+            for (const w of plan.warnings) {
+              console.log(`  \x1b[33m⚠\x1b[0m ${w}`);
+            }
+          }
+          console.log('');
+        }
+      }
+      process.exit(0);
+    } else if (normalizedCommand === 'harmony-drift') {
+      const { runHarmonyDrift } = require('../src/harmony/cli');
+      await runHarmonyDrift(options);
+      process.exit(0);
+    } else if (normalizedCommand === 'harmony-advise') {
+      const { runHarmonyAdvise } = require('../src/harmony/cli');
+      await runHarmonyAdvise(options);
+      process.exit(0);
+    } else if (normalizedCommand === 'harmony-watch') {
+      const { runHarmonyWatch } = require('../src/harmony/cli');
+      await runHarmonyWatch(options);
+    } else if (normalizedCommand === 'harmony-governance') {
+      const { runHarmonyGovernance } = require('../src/harmony/cli');
+      await runHarmonyGovernance(options);
+      process.exit(0);
+    } else if (normalizedCommand === 'synergy-report') {
+      // Placeholder — synergy report is referenced but may not be implemented yet
+      console.log('\n  Synergy report: coming soon.\n');
+      process.exit(0);
     } else if (normalizedCommand === 'doctor') {
       const { runDoctor } = require('../src/doctor');
       const output = await runDoctor({ dir: options.dir, json: options.json, verbose: options.verbose });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nerviq/cli",
-  "version": "1.2.5",
+  "version": "1.2.6",
   "description": "The intelligent nervous system for AI coding agents — 2,306 checks across 8 platforms and 10 languages. Audit, align, and amplify.",
   "main": "src/index.js",
   "bin": {

package/src/activity.js

@@ -228,7 +228,11 @@ function getHistory(dir, limit = 20) {
   const entries = readSnapshotIndex(dir);
   return entries
     .filter(e => e.snapshotKind === 'audit')
-    .sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt))
+    .sort((a, b) => {
+      const dateDiff = new Date(b.createdAt) - new Date(a.createdAt);
+      if (dateDiff !== 0) return dateDiff;
+      return (b.id || '').localeCompare(a.id || '');
+    })
     .slice(0, limit);
 }
 

package/src/audit.js

@@ -1279,7 +1279,25 @@ async function audit(options) {
     console.log('');
   }
 
-  console.log(colorize(`  Backed by CLAUDEX research and evidence for ${spec.platformLabel}`, 'dim'));
+  // Cross-platform synergy hint
+  try {
+    const { detectActivePlatforms } = require('./harmony/canon');
+    const { analyzeCompensation } = require('./synergy/compensation');
+    const { calculateSynergyScore } = require('./synergy/ranking');
+    const detected = detectActivePlatforms(options.dir);
+    const activePlatforms = (detected || []).filter(p => p.detected).map(p => p.platform);
+    if (activePlatforms.length >= 2) {
+      const comp = analyzeCompensation(activePlatforms);
+      const synergyScore = calculateSynergyScore(activePlatforms);
+      console.log(colorize(`  Cross-platform synergy: ${activePlatforms.length} platforms detected`, 'blue'));
+      console.log(colorize(`     Platforms: ${activePlatforms.join(', ')}`, 'dim'));
+      console.log(colorize(`     Compensations: ${comp.compensations.length} | Gaps: ${comp.uncoveredGaps.length}`, 'dim'));
+      console.log(colorize(`     Run: npx nerviq harmony-audit for full cross-platform analysis`, 'dim'));
+      console.log('');
+    }
+  } catch { /* synergy display is optional */ }
+
+  console.log(colorize(`  Backed by NERVIQ research and evidence for ${spec.platformLabel}`, 'dim'));
   console.log(colorize('  https://github.com/nerviq/nerviq', 'dim'));
   console.log('');
 

package/src/harmony/advisor.js

@@ -55,6 +55,16 @@ const TASK_TYPE_PROFILES = {
     requiredStrengths: { reasoning: 0.3, automation: 0.3, ide: 0.2, refactoring: 0.2 },
     description: 'Starting new projects or major new features from scratch.',
   },
+  'harness-optimization': {
+    label: 'Config Optimization',
+    requiredStrengths: { governance: 0.4, automation: 0.3, reasoning: 0.3 },
+    description: 'Optimizing AI coding agent configuration and harness settings.',
+  },
+  'phased-migration': {
+    label: 'Phased Migration',
+    requiredStrengths: { reasoning: 0.4, refactoring: 0.3, architecture: 0.3 },
+    description: 'Multi-phase migrations requiring sequential execution with validation gates.',
+  },
 };
 
 // ─── Scoring ──────────────────────────────────────────────────────────────────

package/src/harmony/canon.js

@@ -513,10 +513,33 @@ function buildCanonicalModel(dir) {
     governanceSummary[key] = platformDetails[key].governance;
   }
 
+  // SD2: Adaptive project signals — infrastructure & tooling detection
+  const projectSignals = {};
+  const signalChecks = [
+    { key: 'docker', label: 'Docker', files: ['Dockerfile', 'docker-compose.yml', 'docker-compose.yaml', '.dockerignore'] },
+    { key: 'terraform', label: 'Terraform', files: ['main.tf', 'terraform.tf', '.terraform.lock.hcl'] },
+    { key: 'kubernetes', label: 'Kubernetes', files: ['k8s/', 'kubernetes/', 'helm/', 'Chart.yaml'] },
+    { key: 'ci-github', label: 'GitHub Actions', files: ['.github/workflows/'] },
+    { key: 'ci-gitlab', label: 'GitLab CI', files: ['.gitlab-ci.yml'] },
+    { key: 'pytest', label: 'pytest', files: ['pytest.ini', 'conftest.py', 'pyproject.toml'] },
+    { key: 'jest', label: 'Jest', files: ['jest.config.js', 'jest.config.ts', 'jest.config.mjs'] },
+    { key: 'migrations', label: 'DB Migrations', files: ['migrations/', 'alembic/', 'prisma/migrations/', 'db/migrate/'] },
+    { key: 'monorepo', label: 'Monorepo', files: ['pnpm-workspace.yaml', 'lerna.json', 'nx.json', 'turbo.json'] },
+    { key: 'openapi', label: 'OpenAPI', files: ['openapi.yaml', 'openapi.json', 'swagger.yaml', 'swagger.json'] },
+  ];
+  for (const signal of signalChecks) {
+    const detected = signal.files.some(f => {
+      const full = path.join(dir, f);
+      try { return fs.existsSync(full); } catch { return false; }
+    });
+    if (detected) projectSignals[signal.key] = signal.label;
+  }
+
   return {
     projectName,
     dir,
     stacks: stacks.map(s => s.key),
+    projectSignals,
     activePlatforms: platformKeys.map(key => ({
       platform: key,
       label: platformDetails[key].label,

package/src/harmony/sync.js

@@ -3,7 +3,8 @@
  *
  * Generates aligned configs for ALL active platforms from a shared canonical
  * understanding. Ensures instructions, MCP servers, and trust posture are
- * consistent across Claude, Codex, Gemini, Copilot, and Cursor.
+ * consistent across Claude, Codex, Gemini, Copilot, Cursor, Windsurf,
+ * Aider, and OpenCode.
  *
  * Uses managed blocks from each platform's patch module so hand-authored
  * content is always preserved.
@@ -37,6 +38,12 @@ const MANAGED_MARKERS = {
     start: '<!-- nerviq:managed:start -->',
     end: '<!-- nerviq:managed:end -->',
   },
+  windsurf: {
+    start: '<!-- nerviq:managed:start -->',
+    end: '<!-- nerviq:managed:end -->',
+  },
+  // aider: uses .aider.conf.yml (YAML) — managed HTML-comment blocks not supported
+  // opencode: uses opencode.json (JSON) — managed HTML-comment blocks not supported
 };
 
 // ─── Helpers ────────────────────────────────────────────────────────────────
@@ -144,6 +151,9 @@ function getInstructionPath(platform) {
     case 'gemini': return 'GEMINI.md';
     case 'copilot': return '.github/copilot-instructions.md';
     case 'cursor': return '.cursorrules';
+    case 'windsurf': return '.windsurfrules';
+    // aider: .aider.conf.yml is YAML config — no managed block support, skip instruction sync
+    // opencode: opencode.json is JSON config — no managed block support, skip instruction sync
     default: return null;
   }
 }
@@ -178,6 +188,11 @@ function buildMcpConfig(platform, mcpServers) {
     return { mcpServers: servers };
   }
 
+  if (platform === 'windsurf') {
+    // Windsurf mcp.json format
+    return { mcpServers: servers };
+  }
+
   return null;
 }
 
@@ -190,6 +205,8 @@ function getMcpConfigPath(platform) {
     case 'gemini': return '.gemini/settings.json';
     case 'copilot': return '.vscode/mcp.json';
     case 'cursor': return '.cursor/mcp.json';
+    case 'windsurf': return '.windsurf/mcp.json';
+    // aider & opencode: no MCP config support
     default: return null;
   }
 }

package/src/techniques.js

@@ -4,12 +4,203 @@
  * Each technique includes: what to check, how to fix, impact level.
  */
 
+const fs = require('fs');
+const path = require('path');
+
 function hasFrontendSignals(ctx) {
   const pkg = ctx.fileContent('package.json') || '';
   return /react|vue|angular|next|svelte|tailwind|vite|astro/i.test(pkg) ||
     ctx.files.some(f => /tailwind\.config|vite\.config|next\.config|svelte\.config|nuxt\.config|pages\/|components\/|app\//i.test(f));
 }
 
+function getClaudeHookContents(ctx) {
+  const hookFiles = ctx.dirFiles('.claude/hooks').filter(f => /\.(js|cjs|mjs|ts|sh|py)$/.test(f));
+  return hookFiles.map(f => ctx.fileContent(`.claude/hooks/${f}`) || '');
+}
+
+function matchesPattern(value, pattern) {
+  if (pattern instanceof RegExp) {
+    pattern.lastIndex = 0;
+    return pattern.test(value);
+  }
+  return value === pattern;
+}
+
+function getProjectEntries(ctx) {
+  if (ctx.__nerviqProjectEntries) return ctx.__nerviqProjectEntries;
+
+  const entries = [];
+  const skippedDirs = new Set([
+    '.git',
+    '.hg',
+    '.svn',
+    'node_modules',
+    '__pycache__',
+    '.pytest_cache',
+    '.mypy_cache',
+    '.ruff_cache',
+    '.venv',
+    'venv',
+    'env',
+    '.tox',
+    '.nox',
+    'vendor',
+    'dist',
+    'build',
+    'coverage',
+  ]);
+
+  const walk = (relPath = '') => {
+    const fullPath = relPath
+      ? path.join(ctx.dir, ...relPath.split('/'))
+      : ctx.dir;
+
+    let dirents = [];
+    try {
+      dirents = fs.readdirSync(fullPath, { withFileTypes: true });
+    } catch {
+      return;
+    }
+
+    for (const dirent of dirents) {
+      if (dirent.name === '.DS_Store') continue;
+
+      const entryPath = relPath ? `${relPath}/${dirent.name}` : dirent.name;
+      if (dirent.isDirectory()) {
+        if (skippedDirs.has(dirent.name)) continue;
+        entries.push(`${entryPath}/`);
+        walk(entryPath);
+      } else {
+        entries.push(entryPath);
+      }
+    }
+  };
+
+  walk();
+  ctx.__nerviqProjectEntries = entries;
+  return entries;
+}
+
+function getProjectFiles(ctx) {
+  if (ctx.__nerviqProjectFiles) return ctx.__nerviqProjectFiles;
+  ctx.__nerviqProjectFiles = getProjectEntries(ctx).filter(entry => !entry.endsWith('/'));
+  return ctx.__nerviqProjectFiles;
+}
+
+function findProjectFiles(ctx, pattern) {
+  return getProjectFiles(ctx).filter(file => matchesPattern(file, pattern));
+}
+
+function hasProjectFile(ctx, pattern) {
+  return findProjectFiles(ctx, pattern).length > 0;
+}
+
+function readProjectFiles(ctx, pattern, limit = 60) {
+  return findProjectFiles(ctx, pattern)
+    .slice(0, limit)
+    .map(file => ctx.fileContent(file) || '')
+    .filter(Boolean)
+    .join('\n');
+}
+
+function isPythonProject(ctx) {
+  if (ctx.__nerviqIsPython !== undefined) return ctx.__nerviqIsPython;
+  ctx.__nerviqIsPython =
+    hasProjectFile(ctx, /(^|\/)(pyproject\.toml|requirements[^/]*\.txt|setup\.py)$/i) ||
+    hasProjectFile(ctx, /\.py$/i);
+  return ctx.__nerviqIsPython;
+}
+
+function isGoProject(ctx) {
+  if (ctx.__nerviqIsGo !== undefined) return ctx.__nerviqIsGo;
+  ctx.__nerviqIsGo = hasProjectFile(ctx, /(^|\/)go\.mod$/i);
+  return ctx.__nerviqIsGo;
+}
+
+function getPythonFiles(ctx) {
+  if (ctx.__nerviqPythonFiles) return ctx.__nerviqPythonFiles;
+  ctx.__nerviqPythonFiles = findProjectFiles(ctx, /\.py$/i);
+  return ctx.__nerviqPythonFiles;
+}
+
+function getMainPythonFiles(ctx) {
+  if (ctx.__nerviqMainPythonFiles) return ctx.__nerviqMainPythonFiles;
+  ctx.__nerviqMainPythonFiles = getPythonFiles(ctx)
+    .filter(file => !/(^|\/)(tests?|__pycache__|migrations)\//i.test(file))
+    .filter(file => !/(^|\/)(test_[^/]+|conftest)\.py$/i.test(file))
+    .slice(0, 50);
+  return ctx.__nerviqMainPythonFiles;
+}
+
+function getPythonProjectText(ctx) {
+  if (ctx.__nerviqPythonProjectText) return ctx.__nerviqPythonProjectText;
+  ctx.__nerviqPythonProjectText = [
+    readProjectFiles(ctx, /(^|\/)pyproject\.toml$/i),
+    readProjectFiles(ctx, /(^|\/)requirements[^/]*\.txt$/i),
+    readProjectFiles(ctx, /(^|\/)setup\.py$/i),
+    readProjectFiles(ctx, /(^|\/)setup\.cfg$/i),
+    readProjectFiles(ctx, /(^|\/)Pipfile$/i),
+  ].filter(Boolean).join('\n');
+  return ctx.__nerviqPythonProjectText;
+}
+
+function getGoFiles(ctx) {
+  if (ctx.__nerviqGoFiles) return ctx.__nerviqGoFiles;
+  ctx.__nerviqGoFiles = findProjectFiles(ctx, /\.go$/i);
+  return ctx.__nerviqGoFiles;
+}
+
+function getMainGoFiles(ctx) {
+  if (ctx.__nerviqMainGoFiles) return ctx.__nerviqMainGoFiles;
+  ctx.__nerviqMainGoFiles = getGoFiles(ctx).filter(file => !/_test\.go$/i.test(file)).slice(0, 60);
+  return ctx.__nerviqMainGoFiles;
+}
+
+function getWorkflowContent(ctx) {
+  if (ctx.__nerviqWorkflowContent !== undefined) return ctx.__nerviqWorkflowContent;
+  ctx.__nerviqWorkflowContent = readProjectFiles(ctx, /^\.github\/workflows\/.*\.ya?ml$/i);
+  return ctx.__nerviqWorkflowContent;
+}
+
+function getPreCommitContent(ctx) {
+  if (ctx.__nerviqPreCommitContent !== undefined) return ctx.__nerviqPreCommitContent;
+  ctx.__nerviqPreCommitContent = readProjectFiles(ctx, /(^|\/)\.pre-commit-config\.ya?ml$/i);
+  return ctx.__nerviqPreCommitContent;
+}
+
+function getGoProjectText(ctx) {
+  if (ctx.__nerviqGoProjectText) return ctx.__nerviqGoProjectText;
+  ctx.__nerviqGoProjectText = [
+    readProjectFiles(ctx, /(^|\/)go\.mod$/i),
+    getWorkflowContent(ctx),
+    readProjectFiles(ctx, /(^|\/)Makefile$/),
+    getPreCommitContent(ctx),
+    getMainGoFiles(ctx).slice(0, 25).map(file => ctx.fileContent(file) || '').filter(Boolean).join('\n'),
+  ].filter(Boolean).join('\n');
+  return ctx.__nerviqGoProjectText;
+}
+
+function getGoInterfaceBlocks(ctx) {
+  if (ctx.__nerviqGoInterfaces) return ctx.__nerviqGoInterfaces;
+  const blocks = [];
+  for (const file of getMainGoFiles(ctx)) {
+    const content = ctx.fileContent(file) || '';
+    for (const match of content.matchAll(/type\s+\w+\s+interface\s*\{([\s\S]*?)\}/g)) {
+      blocks.push(match[1]);
+    }
+  }
+  ctx.__nerviqGoInterfaces = blocks;
+  return ctx.__nerviqGoInterfaces;
+}
+
+function countGoInterfaceMethods(block) {
+  return block
+    .split(/\r?\n/)
+    .map(line => line.trim())
+    .filter(line => line && !line.startsWith('//') && !line.startsWith('/*'))
+    .length;
+}
+
 const { containsEmbeddedSecret } = require('./secret-patterns');
 const { attachSourceUrls } = require('./source-urls');
 const { buildSupplementalChecks } = require('./supplemental-checks');
@@ -2914,15 +3105,9 @@ const TECHNIQUES = {
     id: 110003,
     name: 'Hook scripts handle exit codes correctly',
     check: (ctx) => {
-      const hooksDir = ctx.dirFiles('.claude/hooks');
-      if (!hooksDir || hooksDir.length === 0) return null;
-      const hookFiles = hooksDir.filter(f => /\.(js|sh|py)$/.test(f));
-      if (hookFiles.length === 0) return null;
-      const hasExitHandling = hookFiles.some(f => {
-        const content = ctx.fileContent('.claude/hooks/' + f) || '';
-        return /process\.exit|exit\s+[012]|sys\.exit|return\s+[012]/i.test(content);
-      });
-      return hasExitHandling;
+      const hookContents = getClaudeHookContents(ctx);
+      if (hookContents.length === 0) return null;
+      return hookContents.some(content => /process\.exit|exit\s+[012]|sys\.exit|return\s+[012]/i.test(content));
     },
     impact: 'low', rating: 3, category: 'governance',
     fix: 'Hooks should use explicit exit codes: 0=success, 1=warning, 2=block. See Claude Code docs.',
@@ -2930,6 +3115,71 @@ const TECHNIQUES = {
     confidence: 0.7,
   },
 
+  loopSafetyBoundaries: {
+    id: 110004,
+    name: 'Loop safety boundaries configured',
+    check: (ctx) => {
+      const md = ctx.claudeMdContent() || '';
+      const settings = ctx.fileContent('.claude/settings.json') || '';
+      const hookContents = getClaudeHookContents(ctx).join('\n');
+      const loopSafetyConfig = [md, settings, hookContents].filter(Boolean).join('\n');
+
+      return /max[-_ ]?turns|maxTurns|max[-_ ]?tokens|maxTokens|loop(?:[-_ ]?(?:limit|limits|safety|guard|budget|boundary|boundaries))|iteration(?:[-_ ]?(?:limit|limits|guard|budget|cap|caps|count|max(?:imum)?))/i.test(loopSafetyConfig);
+    },
+    impact: 'medium', rating: 4, category: 'governance',
+    fix: 'Document loop safety limits such as maxTurns, maxTokens, or iteration caps in CLAUDE.md, settings, or hook guards.',
+    template: null,
+    confidence: 0.8,
+  },
+
+  consistencyPassAtK: {
+    id: 110005,
+    name: 'Consistency/pass@k evaluation mentioned',
+    check: (ctx) => {
+      const md = ctx.claudeMdContent() || '';
+      const configPaths = [
+        'package.json',
+        'jest.config.js',
+        'jest.config.cjs',
+        'jest.config.mjs',
+        'vitest.config.js',
+        'vitest.config.ts',
+        'playwright.config.js',
+        'playwright.config.ts',
+        'pytest.ini',
+        'pyproject.toml',
+        'tox.ini',
+        '.github/workflows/ci.yml',
+        '.github/workflows/ci.yaml',
+        '.github/workflows/test.yml',
+        '.github/workflows/test.yaml',
+      ];
+      const configContent = configPaths
+        .map(file => ctx.fileContent(file) || '')
+        .filter(Boolean)
+        .join('\n');
+
+      return /pass@k|consistency|multiple runs?|reproducib/i.test(`${md}\n${configContent}`);
+    },
+    impact: 'low', rating: 3, category: 'quality',
+    fix: 'Mention pass@k or consistency testing in CLAUDE.md or test configuration so repeated-run quality evaluation is explicit.',
+    template: null,
+    confidence: 0.7,
+  },
+
+  instinctToSkillProgression: {
+    id: 110006,
+    name: 'Instinct-to-skill progression documented',
+    check: (ctx) => {
+      const md = ctx.claudeMdContent() || '';
+      return /progressive learning|instinct[- ]to[- ]skill|instinct.{0,40}skill|skill.{0,40}instinct|graduated|phased approach/i.test(md);
+    },
+    impact: 'low', rating: 3, category: 'features',
+    fix: 'Document a progressive learning path that turns repeated instincts into reusable skills or phased practices.',
+    template: null,
+    confidence: 0.7,
+  },
+
 
 };