@nerviq/cli 1.2.5 → 1.2.7

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', 'harmony-add', '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,10 @@ 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 harmony-add <platform>  Add a new platform to the project
     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 +412,8 @@ async function main() {
     lite: flags.includes('--lite'),
     snapshot: flags.includes('--snapshot'),
     feedback: flags.includes('--feedback'),
+    fix: flags.includes('--fix'),
+    autoSync: flags.includes('--auto-sync'),
     dryRun: flags.includes('--dry-run'),
     threshold: parsed.threshold !== null ? Number(parsed.threshold) : null,
     out: parsed.out,
@@ -501,7 +507,7 @@ async function main() {
       'history', 'compare', 'trend', 'feedback', 'catalog', 'certify', 'serve', 'help', 'version',
       // Harmony + Synergy (cross-platform)
       'harmony-audit', 'harmony-sync', 'harmony-drift', 'harmony-advise',
-      'harmony-watch', 'harmony-governance', 'synergy-report',
+      'harmony-watch', 'harmony-governance', 'harmony-add', 'synergy-report',
     ]);
 
     if (options.platform === 'codex') {
@@ -862,6 +868,129 @@ 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 === 'harmony-add') {
+      const { addPlatform } = require('../src/harmony/add');
+      const platformArg = parsed.extraArgs[0];
+      if (!platformArg) {
+        console.log('\n  Usage: nerviq harmony-add <platform>');
+        console.log('  Available: claude, codex, gemini, copilot, cursor, windsurf, aider, opencode\n');
+        process.exit(1);
+      }
+      const dir = options.dir || process.cwd();
+      const result = addPlatform(dir, platformArg.toLowerCase());
+      if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else if (result.success) {
+        console.log(`\n  \x1b[32m\u2713\x1b[0m Added ${result.platform} to project`);
+        result.created.forEach(f => console.log(`     Created: ${f}`));
+        console.log(`     Platforms: ${result.beforeCount} \u2192 ${result.afterCount}`);
+        if (result.syncApplied > 0) console.log(`     Harmony sync: ${result.syncApplied} file(s) updated`);
+        console.log('');
+      } else {
+        console.log(`\n  \x1b[31m\u2717\x1b[0m ${result.error}\n`);
+        process.exit(1);
+      }
+      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.7",
   "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/add.js

@@ -0,0 +1,68 @@
+/**
+ * Platform Addition Wizard
+ * Helps users add a new platform config to their project.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { detectActivePlatforms, PLATFORM_SIGNATURES } = require('./canon');
+const { applyHarmonySync } = require('./sync');
+
+const PLATFORM_BOOTSTRAPS = {
+  claude: { files: [{ path: 'CLAUDE.md', content: '# Project Instructions\n\nAdd your Claude Code instructions here.\n' }] },
+  codex: { files: [{ path: 'AGENTS.md', content: '# Agents Instructions\n\nAdd your Codex instructions here.\n' }] },
+  gemini: { files: [{ path: 'GEMINI.md', content: '# Gemini Instructions\n\nAdd your Gemini CLI instructions here.\n' }] },
+  copilot: { files: [{ path: '.github/copilot-instructions.md', content: '# Copilot Instructions\n\nAdd your GitHub Copilot instructions here.\n' }] },
+  cursor: { files: [{ path: '.cursorrules', content: '# Cursor Rules\n\nAdd your Cursor rules here.\n' }] },
+  windsurf: { files: [{ path: '.windsurfrules', content: '# Windsurf Rules\n\nAdd your Windsurf rules here.\n' }] },
+  aider: { files: [{ path: '.aider.conf.yml', content: '# Aider Configuration\n# See: https://aider.chat/docs/config/aider_conf.html\n' }] },
+  opencode: { files: [{ path: 'opencode.json', content: '{\n  "instructions": "Add your OpenCode instructions here."\n}\n' }] },
+};
+
+function addPlatform(dir, platformKey) {
+  // Validate platform
+  if (!PLATFORM_SIGNATURES[platformKey]) {
+    return { success: false, error: `Unknown platform: ${platformKey}. Available: ${Object.keys(PLATFORM_SIGNATURES).join(', ')}` };
+  }
+
+  // Check if already active
+  const active = detectActivePlatforms(dir);
+  const alreadyActive = active.find(p => p.platform === platformKey);
+  if (alreadyActive) {
+    return { success: false, error: `${platformKey} is already active in this project.` };
+  }
+
+  const beforeCount = active.length;
+  const bootstrap = PLATFORM_BOOTSTRAPS[platformKey];
+  const created = [];
+
+  // Create bootstrap files
+  for (const file of bootstrap.files) {
+    const fullPath = path.join(dir, file.path);
+    if (fs.existsSync(fullPath)) continue;
+    const dirName = path.dirname(fullPath);
+    fs.mkdirSync(dirName, { recursive: true });
+    fs.writeFileSync(fullPath, file.content, 'utf8');
+    created.push(file.path);
+  }
+
+  // Run harmony sync to populate managed blocks
+  let syncResult = null;
+  try {
+    syncResult = applyHarmonySync(dir);
+  } catch { /* sync is optional */ }
+
+  const afterActive = detectActivePlatforms(dir);
+  const afterCount = afterActive.length;
+
+  return {
+    success: true,
+    platform: platformKey,
+    created,
+    beforeCount,
+    afterCount,
+    syncApplied: syncResult ? syncResult.applied.length : 0,
+  };
+}
+
+module.exports = { addPlatform, PLATFORM_BOOTSTRAPS };

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/cli.js

@@ -300,6 +300,7 @@ async function runHarmonyWatch(options) {
 
   await startHarmonyWatch({
     dir,
+    autoSync: !!options.autoSync,
     debounceMs: options.debounce || 800,
     onDriftDetected: (platform, details) => {
       console.log(c(`  DRIFT ALERT: ${platform} score dropped by ${Math.abs(details.delta)}`, 'red'));

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/harmony/watch.js

@@ -36,6 +36,13 @@ const PLATFORM_WATCH_FILES = [
   '.github/copilot-review-instructions.md',
   // Cursor
   '.cursorrules',
+  // Windsurf
+  '.windsurfrules',
+  // Aider
+  '.aider.conf.yml',
+  '.aiderignore',
+  // OpenCode
+  'opencode.json',
   // Shared
   '.gitignore',
   'package.json',
@@ -53,6 +60,9 @@ const PLATFORM_WATCH_DIRS = [
   '.github',
   '.cursor',
   '.cursor/rules',
+  '.windsurf',
+  '.windsurf/rules',
+  '.opencode',
 ];
 
 // ─── fs.watch helpers (mirror pattern from src/watch.js) ──────────────────────
@@ -174,6 +184,9 @@ function identifyPlatform(filePath) {
   if (normalized.includes('.gemini') || normalized.includes('gemini.md')) return 'gemini';
   if (normalized.includes('copilot') || normalized.includes('.github')) return 'copilot';
   if (normalized.includes('.cursor') || normalized.includes('cursorrules')) return 'cursor';
+  if (normalized.includes('.windsurf') || normalized.includes('windsurfrules')) return 'windsurf';
+  if (normalized.includes('.aider') || normalized.includes('aiderignore')) return 'aider';
+  if (normalized.includes('.opencode') || normalized.includes('opencode.json')) return 'opencode';
   return 'unknown';
 }
 
@@ -187,6 +200,7 @@ function identifyPlatform(filePath) {
  * @param {Function} [options.onDriftDetected] - Callback when drift increases: (platform, details) => void
  * @param {Function} [options.onPlatformChange] - Callback on any platform config change: (platform, file) => void
  * @param {Function} [options.runAudit] - Optional audit function to re-run on changes
+ * @param {boolean} [options.autoSync=false] - Auto-apply harmony sync when drift is detected
  * @param {number} [options.debounceMs=800] - Debounce interval in ms
  */
 async function startHarmonyWatch(options) {
@@ -195,6 +209,7 @@ async function startHarmonyWatch(options) {
     onDriftDetected,
     onPlatformChange,
     runAudit,
+    autoSync = false,
     debounceMs = 800,
   } = options;
 
@@ -204,7 +219,10 @@ async function startHarmonyWatch(options) {
   console.log(c('  nerviq harmony watch', 'bold'));
   console.log(c('  ═══════════════════════════════════════', 'dim'));
   console.log(c(`  Watching: ${dir}`, 'dim'));
-  console.log(c(`  Platforms: Claude, Codex, Gemini, Copilot, Cursor`, 'dim'));
+  console.log(c(`  Platforms: Claude, Codex, Gemini, Copilot, Cursor, Windsurf, Aider, OpenCode`, 'dim'));
+  if (autoSync) {
+    console.log(c(`  Auto-sync: ON — drift will be auto-corrected`, 'green'));
+  }
   console.log(c(`  Mode: ${recursiveSupported ? 'native recursive' : 'expanded directory fallback'}`, 'dim'));
   console.log(c('  Press Ctrl+C to stop', 'dim'));
   console.log('');
@@ -293,6 +311,22 @@ async function startHarmonyWatch(options) {
                 }
               }
 
+              // Auto-sync on drift
+              if (delta < 0 && autoSync) {
+                try {
+                  const { applyHarmonySync } = require('./sync');
+                  const syncResult = applyHarmonySync(dir);
+                  if (syncResult.applied.length > 0) {
+                    console.log(c(`    Auto-sync: applied ${syncResult.applied.length} fix(es)`, 'green'));
+                    for (const item of syncResult.applied) {
+                      console.log(c(`      ✓ ${item.action} ${item.path}`, 'dim'));
+                    }
+                  }
+                } catch (_e) {
+                  console.log(c(`    Auto-sync failed: ${_e.message}`, 'yellow'));
+                }
+              }
+
               lastScores[p] = newScore;
             }
           }

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,
+  },
+
 
 };