@nerviq/cli 1.11.0 → 1.12.0

package/src/techniques/observability.js

@@ -0,0 +1,226 @@
+/**
+ * Observability technique fragments.
+ * Generated mechanically from the legacy techniques.js monolith during HR-09.
+ */
+
+const {
+  hasFrontendSignals,
+  hasProjectFile,
+  readProjectFiles,
+  isFlutterProject,
+  isSwiftProject,
+  isKotlinProject,
+} = require('./shared');
+
+module.exports = {
+  otelConfigured: {
+      id: 130001,
+      name: 'OpenTelemetry SDK configured',
+      check: (ctx) => {
+        const pkg = ctx.fileContent('package.json') || '';
+        const req = readProjectFiles(ctx, /(^|\/)requirements[^/]*\.txt$/i);
+        const goMod = ctx.fileContent('go.mod') || '';
+        const cargo = ctx.fileContent('Cargo.toml') || '';
+        const deps = [pkg, req, goMod, cargo].join('\n');
+        return /opentelemetry|@opentelemetry\/sdk|otel/i.test(deps) ||
+          ctx.files.some(f => /otel.*config|opentelemetry.*config/i.test(f));
+      },
+      impact: 'high',
+      category: 'observability',
+      fix: 'Add OpenTelemetry SDK to your project for unified traces, metrics, and logs collection.',
+    },
+
+  prometheusMetrics: {
+      id: 130002,
+      name: 'Prometheus metrics configured',
+      check: (ctx) => {
+        const pkg = ctx.fileContent('package.json') || '';
+        const req = readProjectFiles(ctx, /(^|\/)requirements[^/]*\.txt$/i);
+        const goMod = ctx.fileContent('go.mod') || '';
+        const cargo = ctx.fileContent('Cargo.toml') || '';
+        const deps = [pkg, req, goMod, cargo].join('\n');
+        if (/prom-client|prometheus_client|prometheus\/client_golang|prometheus/i.test(deps)) return true;
+        const code = readProjectFiles(ctx, /\.(js|ts|py|go|rs|java)$/i);
+        return /\/metrics\b/.test(code);
+      },
+      impact: 'high',
+      category: 'observability',
+      fix: 'Add a Prometheus client library and expose a /metrics endpoint for monitoring.',
+    },
+
+  structuredLogging: {
+      id: 130003,
+      name: 'Structured logging library',
+      check: (ctx) => {
+        const pkg = ctx.fileContent('package.json') || '';
+        const req = readProjectFiles(ctx, /(^|\/)requirements[^/]*\.txt$/i);
+        const goMod = ctx.fileContent('go.mod') || '';
+        const cargo = ctx.fileContent('Cargo.toml') || '';
+        const deps = [pkg, req, goMod, cargo].join('\n');
+        return /winston|pino|bunyan|structlog|python-json-logger|slog|log\/slog|tracing|tracing-subscriber|logback|log4j/i.test(deps);
+      },
+      impact: 'high',
+      category: 'observability',
+      fix: 'Use a structured logging library (winston, pino, structlog, slog, tracing) for machine-readable logs.',
+    },
+
+  distributedTracing: {
+      id: 130004,
+      name: 'Distributed tracing configured',
+      check: (ctx) => {
+        const pkg = ctx.fileContent('package.json') || '';
+        const req = readProjectFiles(ctx, /(^|\/)requirements[^/]*\.txt$/i);
+        const goMod = ctx.fileContent('go.mod') || '';
+        const cargo = ctx.fileContent('Cargo.toml') || '';
+        const deps = [pkg, req, goMod, cargo].join('\n');
+        if (/jaeger|zipkin|opentelemetry-api|@opentelemetry\/api|dd-trace|datadog-apm/i.test(deps)) return true;
+        return ctx.files.some(f => /jaeger|zipkin|tracing.*config/i.test(f));
+      },
+      impact: 'high',
+      category: 'observability',
+      fix: 'Add a distributed tracing library (Jaeger, Zipkin, OpenTelemetry) for cross-service request tracking.',
+    },
+
+  healthEndpoint: {
+      id: 130005,
+      name: 'Health check endpoint',
+      check: (ctx) => {
+        const code = readProjectFiles(ctx, /\.(js|ts|py|go|rs|java|rb)$/i);
+        const configs = readProjectFiles(ctx, /\.(ya?ml|json|toml)$/i);
+        return /['"\/]health[z]?['"]\s*[,):]|\/health[z]?\b|healthCheck|health_check|livenessProbe|readinessProbe/i.test(code + configs);
+      },
+      impact: 'high',
+      category: 'observability',
+      fix: 'Add a /health or /healthz endpoint for load balancer and orchestrator health checks.',
+    },
+
+  alertingConfigured: {
+      id: 130006,
+      name: 'Alerting system configured',
+      check: (ctx) => {
+        const pkg = ctx.fileContent('package.json') || '';
+        const deps = [pkg, readProjectFiles(ctx, /(^|\/)requirements[^/]*\.txt$/i)].join('\n');
+        const configs = readProjectFiles(ctx, /\.(ya?ml|json|toml)$/i);
+        return /alertmanager|pagerduty|opsgenie|victorops|alert.*rule/i.test(deps + configs) ||
+          ctx.files.some(f => /alert.*rule|alertmanager/i.test(f));
+      },
+      impact: 'medium',
+      category: 'observability',
+      fix: 'Configure alerting (Alertmanager, PagerDuty, OpsGenie) to get notified of production issues.',
+    },
+
+  dashboardDefined: {
+      id: 130007,
+      name: 'Monitoring dashboard defined',
+      check: (ctx) => {
+        const pkg = ctx.fileContent('package.json') || '';
+        return ctx.files.some(f => /grafana\/.*\.json|\.dashboard\.json/i.test(f)) ||
+          /grafana|@grafana/i.test(pkg) ||
+          hasProjectFile(ctx, /grafana/i);
+      },
+      impact: 'medium',
+      category: 'observability',
+      fix: 'Add Grafana dashboard JSON files or configure dashboard-as-code for production monitoring.',
+    },
+
+  logAggregation: {
+      id: 130008,
+      name: 'Log aggregation configured',
+      check: (ctx) => {
+        const pkg = ctx.fileContent('package.json') || '';
+        const req = readProjectFiles(ctx, /(^|\/)requirements[^/]*\.txt$/i);
+        const configs = readProjectFiles(ctx, /\.(ya?ml|json|toml)$/i);
+        const all = [pkg, req, configs].join('\n');
+        return /elasticsearch|elastic\.co|logstash|kibana|loki|grafana-loki|cloudwatch.*log|datadog|fluentd|fluent-bit|filebeat/i.test(all);
+      },
+      impact: 'medium',
+      category: 'observability',
+      fix: 'Configure log aggregation (ELK, Loki, CloudWatch, Datadog) for centralized log analysis.',
+    },
+
+  errorTrackingService: {
+      id: 130031,
+      name: 'Error tracking service configured',
+      check: (ctx) => {
+        const pkg = ctx.fileContent('package.json') || '';
+        const req = readProjectFiles(ctx, /(^|\/)requirements[^/]*\.txt$/i);
+        const goMod = ctx.fileContent('go.mod') || '';
+        const cargo = ctx.fileContent('Cargo.toml') || '';
+        const deps = [pkg, req, goMod, cargo].join('\n');
+        return /@sentry\/|sentry-sdk|sentry_sdk|bugsnag|rollbar|datadog.*apm|dd-trace|getsentry/i.test(deps);
+      },
+      impact: 'high',
+      category: 'error-tracking',
+      fix: 'Add an error tracking service (Sentry, Bugsnag, Rollbar, Datadog APM) to catch production errors.',
+    },
+
+  errorBoundaries: {
+      id: 130032,
+      name: 'Error boundaries in frontend',
+      check: (ctx) => {
+        if (!hasFrontendSignals(ctx)) return null;
+        const components = readProjectFiles(ctx, /\.(jsx|tsx|vue|svelte|js|ts)$/i);
+        if (!components) return null;
+        return /ErrorBoundary|errorHandler|onErrorCaptured|componentDidCatch|getDerivedStateFromError|error\.vue|_error\.(jsx|tsx|js|ts)/i.test(components);
+      },
+      impact: 'high',
+      category: 'error-tracking',
+      fix: 'Add error boundaries (React ErrorBoundary, Vue errorHandler) to gracefully handle frontend errors.',
+    },
+
+  unhandledRejection: {
+      id: 130033,
+      name: 'Unhandled rejection/exception handler',
+      check: (ctx) => {
+        const code = readProjectFiles(ctx, /\.(js|ts|py|go|rs)$/i);
+        return /unhandledRejection|uncaughtException|sys\.excepthook|recover\(\)|panic.*handler|set_hook.*panic/i.test(code);
+      },
+      impact: 'high',
+      category: 'error-tracking',
+      fix: 'Add handlers for unhandledRejection and uncaughtException to prevent silent failures.',
+    },
+
+  errorReporting: {
+      id: 130034,
+      name: 'Error notification/reporting pattern',
+      check: (ctx) => {
+        const code = readProjectFiles(ctx, /\.(js|ts|py|go|rs|java|rb)$/i);
+        return /error.*webhook|error.*slack|error.*notify|alert.*error|captureException|captureMessage|notify.*error/i.test(code);
+      },
+      impact: 'medium',
+      category: 'error-tracking',
+      fix: 'Add error reporting patterns (webhook, Slack alerts, Sentry capture) to get notified of failures.',
+    },
+
+  errorBudgetSlo: {
+      id: 130035,
+      name: 'SLO/SLA or error budget defined',
+      check: (ctx) => {
+        const docs = readProjectFiles(ctx, /\.(md|txt|rst|ya?ml|json|toml)$/i);
+        return /\bslo\b|\bsla\b|error.budget|service.level|uptime.*target|availability.*target/i.test(docs);
+      },
+      impact: 'medium',
+      category: 'error-tracking',
+      fix: 'Define SLOs, SLAs, or error budgets in your docs to set clear reliability targets.',
+    },
+
+  crashReporting: {
+      id: 130036,
+      name: 'Crash reporting for mobile',
+      check: (ctx) => {
+        const hasMobile = isFlutterProject(ctx) || isSwiftProject(ctx) || isKotlinProject(ctx) ||
+          /react-native|expo/i.test(ctx.fileContent('package.json') || '');
+        if (!hasMobile) return null;
+        const deps = [
+          ctx.fileContent('package.json') || '',
+          ctx.fileContent('pubspec.yaml') || '',
+          ctx.fileContent('Podfile') || '',
+          readProjectFiles(ctx, /(^|\/)build\.gradle(\.kts)?$/i),
+        ].join('\n');
+        return /crashlytics|sentry.*native|@sentry\/react-native|bugsnag.*react-native|firebase.*crash/i.test(deps);
+      },
+      impact: 'high',
+      category: 'error-tracking',
+      fix: 'Add crash reporting (Crashlytics, Sentry Native) to track mobile app crashes in production.',
+    },
+};

package/src/techniques/optimization.js

@@ -0,0 +1,142 @@
+/**
+ * Optimization technique fragments.
+ * Generated mechanically from the legacy techniques.js monolith during HR-09.
+ */
+
+const {
+  hasFrontendSignals,
+  hasProjectFile,
+  readProjectFiles,
+  getWorkflowContent,
+} = require('./shared');
+
+module.exports = {
+  compactionAwareness: {
+      id: 568,
+      name: 'CLAUDE.md mentions /compact or compaction',
+      check: (ctx) => {
+        const md = ctx.claudeMdContent() || '';
+        return /\/compact|compaction|context.*(limit|manage|budget)/i.test(md);
+      },
+      impact: 'medium',
+      rating: 4,
+      category: 'performance',
+      fix: 'Add compaction guidance to CLAUDE.md (e.g. "Run /compact when context is heavy").',
+      template: null
+    },
+
+  contextManagement: {
+      id: 45,
+      name: 'Context management awareness',
+      check: (ctx) => {
+        const md = ctx.claudeMdContent() || '';
+        return /context.*(manage|window|limit|budget|token)/i.test(md);
+      },
+      impact: 'medium',
+      rating: 4,
+      category: 'performance',
+      fix: 'Add context management tips to CLAUDE.md to help Claude stay within token limits.',
+      template: null
+    },
+
+  effortLevelConfigured: {
+      id: 2016,
+      name: 'Effort level or thinking configuration',
+      check: (ctx) => {
+        const md = ctx.claudeMdContent() || '';
+        const shared = ctx.jsonFile('.claude/settings.json') || {};
+        const local = ctx.jsonFile('.claude/settings.local.json') || {};
+        return /effort|thinking/i.test(md) || shared.effortLevel || local.effortLevel ||
+               shared.alwaysThinkingEnabled !== undefined || local.alwaysThinkingEnabled !== undefined;
+      },
+      impact: 'low', rating: 3, category: 'performance',
+      fix: 'Configure effortLevel or mention thinking strategy in CLAUDE.md for task-appropriate reasoning depth.',
+      template: null
+    },
+
+  lighthouseCI: {
+      id: 130171,
+      name: 'Lighthouse CI configured',
+      check: (ctx) => {
+        if (!hasFrontendSignals(ctx)) return null;
+        return hasProjectFile(ctx, /(^|\/)\.?lighthouserc\.(js|json|ya?ml)$/i) ||
+          /lighthouse/i.test(getWorkflowContent(ctx));
+      },
+      impact: 'medium',
+      category: 'performance-budget',
+      fix: 'Add Lighthouse CI (lighthouserc.js) to enforce performance budgets in your CI pipeline.',
+      confidence: 0.7,
+    },
+
+  bundleSizeLimit: {
+      id: 130172,
+      name: 'Bundle size check configured',
+      check: (ctx) => {
+        if (!hasFrontendSignals(ctx)) return null;
+        const pkg = ctx.fileContent('package.json') || '';
+        return /size-limit|bundlewatch|@next\/bundle-analyzer|webpack-bundle-analyzer/i.test(pkg);
+      },
+      impact: 'medium',
+      category: 'performance-budget',
+      fix: 'Add bundle size checks (size-limit, bundlewatch, @next/bundle-analyzer) to prevent bundle bloat.',
+      confidence: 0.7,
+    },
+
+  webVitals: {
+      id: 130173,
+      name: 'Core Web Vitals tracking configured',
+      check: (ctx) => {
+        if (!hasFrontendSignals(ctx)) return null;
+        const pkg = ctx.fileContent('package.json') || '';
+        const src = readProjectFiles(ctx, /\.(jsx?|tsx?)$/i, 20);
+        return /web-vitals|next\/web-vitals|@vercel\/speed-insights/i.test(pkg + src);
+      },
+      impact: 'medium',
+      category: 'performance-budget',
+      fix: 'Add Core Web Vitals tracking (web-vitals, next/web-vitals) for real user performance monitoring.',
+      confidence: 0.7,
+    },
+
+  performanceRegression: {
+      id: 130174,
+      name: 'Performance regression testing in CI',
+      check: (ctx) => {
+        if (!hasFrontendSignals(ctx)) return null;
+        const ci = getWorkflowContent(ctx);
+        const pkg = ctx.fileContent('package.json') || '';
+        return /benchmark|bench|perf.*test|lighthouse.*assert/i.test(ci + pkg);
+      },
+      impact: 'low',
+      category: 'performance-budget',
+      fix: 'Add performance regression testing in CI (benchmark, lighthouse assert) to catch regressions early.',
+      confidence: 0.7,
+    },
+
+  imageOptimization: {
+      id: 130175,
+      name: 'Image optimization configured',
+      check: (ctx) => {
+        if (!hasFrontendSignals(ctx)) return null;
+        const pkg = ctx.fileContent('package.json') || '';
+        return /sharp|imagemin|next\/image|responsive-loader|@squoosh/i.test(pkg);
+      },
+      impact: 'low',
+      category: 'performance-budget',
+      fix: 'Add image optimization (sharp, imagemin, next/image) to reduce page weight and improve loading.',
+      confidence: 0.7,
+    },
+
+  lazyLoading: {
+      id: 130176,
+      name: 'Code splitting and lazy loading',
+      check: (ctx) => {
+        if (!hasFrontendSignals(ctx)) return null;
+        const src = readProjectFiles(ctx, /\.(jsx?|tsx?)$/i, 30);
+        return /React\.lazy|import\s*\(|loadable|dynamic\s*\(\s*\(\)\s*=>/i.test(src);
+      },
+      impact: 'low',
+      category: 'performance-budget',
+      fix: 'Use code splitting and lazy loading (React.lazy, dynamic import, loadable) to reduce initial bundle size.',
+      confidence: 0.7,
+    },
+};

package/src/techniques/quality.js

@@ -0,0 +1,317 @@
+/**
+ * Quality technique fragments.
+ * Generated mechanically from the legacy techniques.js monolith during HR-09.
+ */
+
+const {
+  getClaudeInstructionBundle,
+  hasDocumentedVerificationGuidance,
+  hasDocumentedTestCommand,
+  hasDocumentedLintCommand,
+  hasDocumentedBuildCommand,
+  hasFrontendSignals,
+} = require('./shared');
+
+module.exports = {
+  verificationLoop: {
+      id: 93,
+      name: 'Claude instruction surfaces include verification criteria',
+      check: (ctx) => {
+        const docs = getClaudeInstructionBundle(ctx);
+        return hasDocumentedVerificationGuidance(docs);
+      },
+      impact: 'critical',
+      rating: 5,
+      category: 'quality',
+      fix: 'Add canonical test/lint/build commands to your Claude instruction surfaces (CLAUDE.md, imported docs, or .claude/commands) so Claude can verify its own work.',
+      template: null
+    },
+
+  testCommand: {
+      id: 93001,
+      name: 'Claude instruction surfaces include a test command',
+      check: (ctx) => {
+        return hasDocumentedTestCommand(getClaudeInstructionBundle(ctx));
+      },
+      impact: 'high',
+      rating: 5,
+      category: 'quality',
+      fix: 'Add an explicit test command to your Claude instruction surfaces (for example "Run `npm test` before committing").',
+      template: null
+    },
+
+  lintCommand: {
+      id: 93002,
+      name: 'Claude instruction surfaces include a lint command',
+      check: (ctx) => {
+        return hasDocumentedLintCommand(getClaudeInstructionBundle(ctx));
+      },
+      impact: 'high',
+      rating: 4,
+      category: 'quality',
+      fix: 'Add a lint command to your Claude instruction surfaces so Claude can check style and static quality automatically.',
+      template: null
+    },
+
+  buildCommand: {
+      id: 93003,
+      name: 'Claude instruction surfaces include a build command',
+      check: (ctx) => {
+        return hasDocumentedBuildCommand(getClaudeInstructionBundle(ctx));
+      },
+      impact: 'medium',
+      rating: 4,
+      category: 'quality',
+      fix: 'Add a build command to your Claude instruction surfaces so Claude can verify compilation before committing.',
+      template: null
+    },
+
+  frontendDesignSkill: {
+      id: 1025,
+      name: 'Frontend design skill for anti-AI-slop',
+      check: (ctx) => {
+        if (!hasFrontendSignals(ctx)) return null;
+        const md = ctx.claudeMdContent() || '';
+        return md.includes('frontend_aesthetics') || md.includes('anti-AI-slop') || md.includes('frontend-design');
+      },
+      impact: 'medium',
+      rating: 5,
+      category: 'design',
+      fix: 'Install the official frontend-design skill for better UI output quality.',
+      template: null
+    },
+
+  tailwindMention: {
+      id: 102501,
+      name: 'Tailwind CSS configured',
+      check: (ctx) => {
+        if (!hasFrontendSignals(ctx)) return null;
+        const pkg = ctx.fileContent('package.json') || '';
+        return pkg.includes('tailwind') ||
+          ctx.files.some(f => /tailwind\.config/.test(f));
+      },
+      impact: 'low',
+      rating: 3,
+      category: 'design',
+      fix: 'Consider adding Tailwind CSS for rapid, consistent UI styling with Claude.',
+      template: null
+    },
+
+  claudeMdFreshness: {
+      id: 2001,
+      name: 'CLAUDE.md mentions current Claude features',
+      check: (ctx) => {
+        const md = ctx.claudeMdContent() || '';
+        if (md.length < 50) return false; // too short to evaluate
+        // Check for awareness of features from 2025+
+        const modernFeatures = ['hook', 'skill', 'agent', 'subagent', 'mcp', 'compact', '/clear', 'extended thinking', 'tool_use', 'worktree'];
+        const found = modernFeatures.filter(f => md.toLowerCase().includes(f));
+        return found.length >= 2; // knows at least 2 modern features
+      },
+      impact: 'medium',
+      rating: 4,
+      category: 'quality-deep',
+      fix: 'Your CLAUDE.md may be outdated. Modern Claude Code supports hooks, skills, agents, MCP, worktrees, and extended thinking. Mention the ones you use.',
+      template: null
+    },
+
+  claudeMdNoContradictions: {
+      id: 2003,
+      name: 'CLAUDE.md has no obvious contradictions',
+      check: (ctx) => {
+        const md = ctx.claudeMdContent();
+        if (!md || md.length < 50) return false; // no CLAUDE.md or too short = not passing
+        // Check for common contradictions
+        // Check for contradictions on the SAME topic (same line or adjacent sentence)
+        const lines = md.split('\n');
+        let hasContradiction = false;
+        for (const line of lines) {
+          if (/\balways\b.*\bnever\b|\bnever\b.*\balways\b/i.test(line)) {
+            hasContradiction = true;
+            break;
+          }
+        }
+        const hasBothStyles = /\buse tabs\b/i.test(md) && /\buse spaces\b/i.test(md);
+        return !hasContradiction && !hasBothStyles;
+      },
+      impact: 'high',
+      rating: 4,
+      category: 'quality-deep',
+      fix: 'CLAUDE.md may contain contradictory instructions. Review for conflicting rules (e.g., "always X" and "never X" about the same topic).',
+      template: null
+    },
+
+  hooksAreSpecific: {
+      id: 2004,
+      name: 'Hooks use specific matchers (not catch-all)',
+      check: (ctx) => {
+        const settings = ctx.jsonFile('.claude/settings.local.json') || ctx.jsonFile('.claude/settings.json');
+        if (!settings || !settings.hooks) return null; // no hooks = not applicable
+        const hookStr = JSON.stringify(settings.hooks);
+        // Check that hooks have matchers, not just catch-all
+        return hookStr.includes('matcher');
+      },
+      impact: 'medium',
+      rating: 3,
+      category: 'quality-deep',
+      fix: 'Hooks without matchers run on every tool call. Use matchers like "Write|Edit" or "Bash" to target specific tools.',
+      template: null
+    },
+
+  commandsUseArguments: {
+      id: 2006,
+      name: 'Commands use $ARGUMENTS for flexibility',
+      check: (ctx) => {
+        if (!ctx.hasDir('.claude/commands')) return null; // not applicable
+        const files = ctx.dirFiles('.claude/commands');
+        if (files.length === 0) return null;
+        // Check if at least one command uses $ARGUMENTS
+        for (const f of files) {
+          const content = ctx.fileContent(`.claude/commands/${f}`) || '';
+          if (content.includes('$ARGUMENTS') || content.includes('$arguments')) return true;
+        }
+        return false;
+      },
+      impact: 'medium',
+      rating: 3,
+      category: 'quality-deep',
+      fix: 'Commands without $ARGUMENTS are static. Use $ARGUMENTS to make them flexible: "Fix the issue: $ARGUMENTS"',
+      template: null
+    },
+
+  agentsHaveMaxTurns: {
+      id: 2007,
+      name: 'Subagents have max-turns limit',
+      check: (ctx) => {
+        if (!ctx.hasDir('.claude/agents')) return null;
+        const files = ctx.dirFiles('.claude/agents');
+        if (files.length === 0) return null;
+        for (const f of files) {
+          const content = ctx.fileContent(`.claude/agents/${f}`) || '';
+          // Current frontmatter uses kebab-case: max-turns (also accept legacy maxTurns)
+          if (!content.includes('max-turns') && !content.includes('maxTurns')) return false;
+        }
+        return true;
+      },
+      impact: 'medium',
+      rating: 3,
+      category: 'quality-deep',
+      fix: 'Subagents without max-turns can run indefinitely. Add "max-turns: 50" to subagent YAML frontmatter.',
+      template: null
+    },
+
+  securityReviewInWorkflow: {
+      id: 2008,
+      name: '/security-review command or workflow',
+      check: (ctx) => {
+        const hasCommand = ctx.hasDir('.claude/commands') &&
+          (ctx.dirFiles('.claude/commands') || []).some(f => f.includes('security') || f.includes('review'));
+        const md = ctx.claudeMdContent() || '';
+        const hasExplicitRef = /\/security-review|security review command|security workflow/i.test(md);
+        return hasCommand || hasExplicitRef;
+      },
+      impact: 'medium',
+      rating: 4,
+      category: 'quality-deep',
+      fix: 'Claude Code has built-in /security-review (OWASP Top 10). Add it to your workflow or create a /security command.',
+      template: null
+    },
+
+  testCoverage: {
+      id: 2010,
+      name: 'Test coverage or strategy mentioned',
+      check: (ctx) => {
+        const md = ctx.claudeMdContent() || '';
+        return /coverage|test.*strateg|e2e|integration test|unit test/i.test(md);
+      },
+      impact: 'medium', rating: 3, category: 'quality',
+      fix: 'Mention your testing strategy in CLAUDE.md (unit, integration, E2E, coverage targets).',
+      template: null
+    },
+
+  typeCheckingConfigured: {
+      id: 2031,
+      name: 'Type checking configured (TypeScript or similar)',
+      check: (ctx) => {
+        return !!(ctx.fileContent('tsconfig.json') || ctx.fileContent('jsconfig.json') ||
+          ctx.fileContent('pyrightconfig.json') || ctx.fileContent('mypy.ini'));
+      },
+      impact: 'medium', rating: 3, category: 'quality',
+      fix: 'Add type checking configuration. Type-safe code produces fewer Claude errors.',
+      template: null
+    },
+
+  noDeprecatedPatterns: {
+      id: 2009,
+      name: 'No deprecated patterns detected',
+      check: (ctx) => {
+        const md = ctx.claudeMdContent();
+        if (!md) return false;
+        // Only flag truly deprecated patterns, not valid aliases
+        const deprecatedPatterns = [
+          /\bhuman_prompt\b/i, /\bassistant_prompt\b/i, // old completions API format (not Messages API)
+          /\buse model claude-3-opus\b/i, // explicit recommendation to use old name as --model
+          /\buse model claude-3-sonnet\b/i,
+        ];
+        return !deprecatedPatterns.some(p => p.test(md));
+      },
+      impact: 'medium',
+      rating: 3,
+      category: 'quality-deep',
+      fix: 'CLAUDE.md references deprecated API patterns (human_prompt/assistant_prompt). Update to current Messages API conventions.',
+      template: null
+    },
+
+  claudeMdQuality: {
+      id: 102502,
+      name: 'CLAUDE.md has substantive content',
+      check: (ctx) => {
+        const md = ctx.claudeMdContent();
+        if (!md) return null;
+        const lines = md.split('\n').filter(l => l.trim());
+        const sections = (md.match(/^##\s/gm) || []).length;
+        const hasCommand = /\b(npm|yarn|pnpm|pytest|go |make |ruff |cargo |dotnet )\b/i.test(md);
+        return lines.length >= 15 && sections >= 2 && hasCommand;
+      },
+      impact: 'medium',
+      rating: 4,
+      category: 'quality-deep',
+      fix: 'CLAUDE.md exists but lacks substance. Add at least 2 sections (## headings) and include your test/build/lint commands.',
+      template: null
+    },
+
+  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,
+    },
+};