@runhalo/engine 0.4.0 → 0.6.0

package/dist/graduation/graduation-codifier.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Sprint 13a Week 2: Graduation Codifier
+ *
+ * Stage 4 of the Graduation Pipeline.
+ * Takes approved graduation candidates and generates the code changes
+ * needed to codify them as permanent engine heuristics.
+ *
+ * Output: TypeScript code snippets ready to insert into classifyFile()
+ * or the scan loop in packages/engine/src/index.ts.
+ *
+ * This does NOT auto-apply changes. It generates code for Bobby to
+ * review and approve before merging.
+ */
+import { GraduationCandidate } from './graduation-validator';
+export interface CodegenResult {
+    /** Pattern being codified */
+    patternId: string;
+    /** Type of change */
+    changeType: 'classifyFile_pattern' | 'rule_suppression' | 'scan_loop_check';
+    /** Generated code snippet */
+    code: string;
+    /** Where to insert (file path + approximate location) */
+    insertLocation: string;
+    /** Human-readable explanation */
+    explanation: string;
+    /** Test case to validate the change */
+    testCase: string;
+}
+/**
+ * Generate code for a single graduation candidate.
+ */
+export declare function generateCode(candidate: GraduationCandidate): CodegenResult;
+/**
+ * Generate code for all eligible candidates.
+ */
+export declare function generateAllCode(candidates: GraduationCandidate[]): CodegenResult[];
+export declare function formatCodegenReport(results: CodegenResult[]): string;

package/dist/graduation/graduation-codifier.js

@@ -0,0 +1,205 @@
+"use strict";
+/**
+ * Sprint 13a Week 2: Graduation Codifier
+ *
+ * Stage 4 of the Graduation Pipeline.
+ * Takes approved graduation candidates and generates the code changes
+ * needed to codify them as permanent engine heuristics.
+ *
+ * Output: TypeScript code snippets ready to insert into classifyFile()
+ * or the scan loop in packages/engine/src/index.ts.
+ *
+ * This does NOT auto-apply changes. It generates code for Bobby to
+ * review and approve before merging.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCode = generateCode;
+exports.generateAllCode = generateAllCode;
+exports.formatCodegenReport = formatCodegenReport;
+// ─── Code Generation ────────────────────────────────────────────────────────
+/**
+ * Generate code for a single graduation candidate.
+ */
+function generateCode(candidate) {
+    switch (candidate.recommendedHeuristic) {
+        case 'file_skip':
+            return generateFileSkipCode(candidate);
+        case 'rule_suppress':
+            return generateRuleSuppressionCode(candidate);
+        case 'severity_downgrade':
+            return generateSeverityDowngradeCode(candidate);
+        case 'context_check':
+            return generateContextCheckCode(candidate);
+    }
+}
+/**
+ * Generate code for all eligible candidates.
+ */
+function generateAllCode(candidates) {
+    return candidates
+        .filter(c => c.eligible)
+        .map(c => generateCode(c));
+}
+// ─── Generators ─────────────────────────────────────────────────────────────
+function generateFileSkipCode(candidate) {
+    const pattern = candidate.pattern;
+    const patternId = pattern.fpPatternId;
+    // Extract path signals from sample paths
+    const pathPatterns = inferPathPatterns(pattern.samplePaths);
+    const code = `// Graduated from FP pattern: ${patternId}
+// ${pattern.totalDismissals} dismissals, avg confidence ${pattern.avgConfidence}
+// Source: Graduation Pipeline Sprint 13a
+if (${pathPatterns.map(p => `normalizedPath.includes('${p}')`).join(' || ')}) {
+  return {
+    ...baseClassification,
+    shouldSkip: true,
+    skipReason: '${patternId} (graduated)',
+  };
+}`;
+    return {
+        patternId,
+        changeType: 'classifyFile_pattern',
+        code,
+        insertLocation: 'packages/engine/src/index.ts → classifyFile() function, before return statement',
+        explanation: `Skip files matching ${patternId} pattern. Based on ${pattern.totalDismissals} consistent dismissals across ${pattern.uniqueScans} scans with avg confidence ${pattern.avgConfidence}.`,
+        testCase: generateTestCase(patternId, pattern.samplePaths[0] || 'test/path', 'shouldSkip', true),
+    };
+}
+function generateRuleSuppressionCode(candidate) {
+    const pattern = candidate.pattern;
+    const patternId = pattern.fpPatternId;
+    const rules = pattern.affectedRules;
+    const code = `// Graduated from FP pattern: ${patternId}
+// ${pattern.totalDismissals} dismissals, avg confidence ${pattern.avgConfidence}
+const ${camelCase(patternId)}_SUPPRESS_RULES = new Set(${JSON.stringify(rules)});
+
+// In scan loop, after classification:
+if (classification.${inferClassificationFlag(patternId)} && ${camelCase(patternId)}_SUPPRESS_RULES.has(rule.id)) {
+  continue; // Skip this rule for ${patternId} files
+}`;
+    return {
+        patternId,
+        changeType: 'rule_suppression',
+        code,
+        insertLocation: 'packages/engine/src/index.ts → scan loop, rule iteration block',
+        explanation: `Suppress rules [${rules.join(', ')}] when ${patternId} pattern detected. Based on ${pattern.totalDismissals} dismissals.`,
+        testCase: generateTestCase(patternId, pattern.samplePaths[0] || 'test/path', 'violations.length', 0),
+    };
+}
+function generateSeverityDowngradeCode(candidate) {
+    const pattern = candidate.pattern;
+    const patternId = pattern.fpPatternId;
+    const code = `// Graduated from FP pattern: ${patternId}
+// ${pattern.totalDismissals} dismissals as downgrade, avg confidence ${pattern.avgConfidence}
+if (${inferCondition(patternId)}) {
+  violation.severity = 'info'; // Downgraded from ${patternId}
+  violation.message += ' [Severity downgraded: ${patternId}]';
+}`;
+    return {
+        patternId,
+        changeType: 'scan_loop_check',
+        code,
+        insertLocation: 'packages/engine/src/index.ts → after violation creation, before push to results',
+        explanation: `Downgrade severity for ${patternId} pattern. Mitigating factors present but not full dismissal.`,
+        testCase: generateTestCase(patternId, pattern.samplePaths[0] || 'test/path', 'severity', 'info'),
+    };
+}
+function generateContextCheckCode(candidate) {
+    const pattern = candidate.pattern;
+    const patternId = pattern.fpPatternId;
+    const code = `// Graduated from FP pattern: ${patternId}
+// ${pattern.totalDismissals} dismissals, avg confidence ${pattern.avgConfidence}
+// NOTE: This pattern requires surrounding code analysis.
+// Consider adding to AI Review Board FP checklist instead of engine heuristic.
+//
+// Candidate code signals to check:
+// ${pattern.fpReason || 'See FP library for details'}
+//
+// TODO: Implement context check or add to AI Review Board FP library`;
+    return {
+        patternId,
+        changeType: 'scan_loop_check',
+        code,
+        insertLocation: 'packages/engine/src/index.ts OR supabase/functions/ai-review/index.ts (FP checklists)',
+        explanation: `Context-dependent FP pattern. May be better served by expanding the AI Review Board FP checklist rather than engine heuristic.`,
+        testCase: `// Manual test: verify ${patternId} pattern is dismissed by Review Board`,
+    };
+}
+// ─── Helpers ────────────────────────────────────────────────────────────────
+function inferPathPatterns(samplePaths) {
+    if (samplePaths.length === 0)
+        return ['UNKNOWN_PATTERN'];
+    // Find common path segments
+    const segments = samplePaths.flatMap(p => p.split('/'));
+    const commonSegments = new Map();
+    for (const seg of segments) {
+        if (seg && seg.length > 2 && !seg.includes('.')) {
+            commonSegments.set(seg, (commonSegments.get(seg) || 0) + 1);
+        }
+    }
+    // Return segments that appear in multiple paths
+    const patterns = [...commonSegments.entries()]
+        .filter(([, count]) => count >= Math.max(samplePaths.length / 2, 1))
+        .map(([seg]) => seg)
+        .slice(0, 3);
+    return patterns.length > 0 ? patterns : ['REVIEW_PATH_PATTERN'];
+}
+function inferClassificationFlag(patternId) {
+    if (patternId.includes('admin'))
+        return 'isAdmin';
+    if (patternId.includes('consent'))
+        return 'isConsent';
+    if (patternId.includes('test') || patternId.includes('mock'))
+        return 'isTest';
+    if (patternId.includes('vendor'))
+        return 'isVendor';
+    if (patternId.includes('doc'))
+        return 'isDocGenerator';
+    return 'shouldSkip';
+}
+function inferCondition(patternId) {
+    if (patternId.includes('framework'))
+        return `classification.language && ['jsx', 'tsx', 'vue', 'svelte'].includes(fileExt)`;
+    if (patternId.includes('sanitized'))
+        return `codeContent.includes('DOMPurify') || codeContent.includes('sanitize(')`;
+    if (patternId.includes('error-monitoring'))
+        return `codeContent.includes('Sentry') || codeContent.includes('Bugsnag')`;
+    return `/* TODO: define condition for ${patternId} */`;
+}
+function camelCase(str) {
+    return str.replace(/[-_](\w)/g, (_, c) => c.toUpperCase());
+}
+function generateTestCase(patternId, samplePath, assertion, expected) {
+    return `test('${patternId} graduated pattern', () => {
+  const result = classifyFile('${samplePath}');
+  expect(result.${assertion}).toBe(${JSON.stringify(expected)});
+});`;
+}
+// ─── Report ─────────────────────────────────────────────────────────────────
+function formatCodegenReport(results) {
+    const lines = [
+        '═══ Graduation Codifier — Generated Code ═══',
+        '',
+        `Total patterns codified: ${results.length}`,
+        '',
+    ];
+    for (const result of results) {
+        lines.push(`── ${result.patternId} (${result.changeType}) ──`);
+        lines.push(result.explanation);
+        lines.push('');
+        lines.push('Location: ' + result.insertLocation);
+        lines.push('');
+        lines.push('Code:');
+        lines.push('```typescript');
+        lines.push(result.code);
+        lines.push('```');
+        lines.push('');
+        lines.push('Test:');
+        lines.push('```typescript');
+        lines.push(result.testCase);
+        lines.push('```');
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=graduation-codifier.js.map

package/dist/graduation/graduation-codifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"graduation-codifier.js","sourceRoot":"","sources":["../../src/graduation/graduation-codifier.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;GAYG;;AA0BH,oCAWC;AAKD,0CAIC;AA+JD,kDA2BC;AAnND,+EAA+E;AAE/E;;GAEG;AACH,SAAgB,YAAY,CAAC,SAA8B;IACzD,QAAQ,SAAS,CAAC,oBAAoB,EAAE,CAAC;QACvC,KAAK,WAAW;YACd,OAAO,oBAAoB,CAAC,SAAS,CAAC,CAAC;QACzC,KAAK,eAAe;YAClB,OAAO,2BAA2B,CAAC,SAAS,CAAC,CAAC;QAChD,KAAK,oBAAoB;YACvB,OAAO,6BAA6B,CAAC,SAAS,CAAC,CAAC;QAClD,KAAK,eAAe;YAClB,OAAO,wBAAwB,CAAC,SAAS,CAAC,CAAC;IAC/C,CAAC;AACH,CAAC;AAED;;GAEG;AACH,SAAgB,eAAe,CAAC,UAAiC;IAC/D,OAAO,UAAU;SACd,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC;SACvB,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;AAC/B,CAAC;AAED,+EAA+E;AAE/E,SAAS,oBAAoB,CAAC,SAA8B;IAC1D,MAAM,OAAO,GAAG,SAAS,CAAC,OAAO,CAAC;IAClC,MAAM,SAAS,GAAG,OAAO,CAAC,WAAW,CAAC;IAEtC,yCAAyC;IACzC,MAAM,YAAY,GAAG,iBAAiB,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;IAE5D,MAAM,IAAI,GAAG,iCAAiC,SAAS;KACpD,OAAO,CAAC,eAAe,+BAA+B,OAAO,CAAC,aAAa;;MAE1E,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,4BAA4B,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC;;;;mBAIxD,SAAS;;EAE1B,CAAC;IAED,OAAO;QACL,SAAS;QACT,UAAU,EAAE,sBAAsB;QAClC,IAAI;QACJ,cAAc,EAAE,iFAAiF;QACjG,WAAW,EAAE,uBAAuB,SAAS,sBAAsB,OAAO,CAAC,eAAe,iCAAiC,OAAO,CAAC,WAAW,8BAA8B,OAAO,CAAC,aAAa,GAAG;QACpM,QAAQ,EAAE,gBAAgB,CAAC,SAAS,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,WAAW,EAAE,YAAY,EAAE,IAAI,CAAC;KACjG,CAAC;AACJ,CAAC;AAED,SAAS,2BAA2B,CAAC,SAA8B;IACjE,MAAM,OAAO,GAAG,SAAS,CAAC,OAAO,CAAC;IAClC,MAAM,SAAS,GAAG,OAAO,CAAC,WAAW,CAAC;IACtC,MAAM,KAAK,GAAG,OAAO,CAAC,aAAa,CAAC;IAEpC,MAAM,IAAI,GAAG,iCAAiC,SAAS;KACpD,OAAO,CAAC,eAAe,+BAA+B,OAAO,CAAC,aAAa;QACxE,SAAS,CAAC,SAAS,CAAC,6BAA6B,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC;;;qBAGzD,uBAAuB,CAAC,SAAS,CAAC,OAAO,SAAS,CAAC,SAAS,CAAC;oCAC9C,SAAS;EAC3C,CAAC;IAED,OAAO;QACL,SAAS;QACT,UAAU,EAAE,kBAAkB;QAC9B,IAAI;QACJ,cAAc,EAAE,gEAAgE;QAChF,WAAW,EAAE,mBAAmB,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,SAAS,+BAA+B,OAAO,CAAC,eAAe,cAAc;QACvI,QAAQ,EAAE,gBAAgB,CAAC,SAAS,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,WAAW,EAAE,mBAAmB,EAAE,CAAC,CAAC;KACrG,CAAC;AACJ,CAAC;AAED,SAAS,6BAA6B,CAAC,SAA8B;IACnE,MAAM,OAAO,GAAG,SAAS,CAAC,OAAO,CAAC;IAClC,MAAM,SAAS,GAAG,OAAO,CAAC,WAAW,CAAC;IAEtC,MAAM,IAAI,GAAG,iCAAiC,SAAS;KACpD,OAAO,CAAC,eAAe,4CAA4C,OAAO,CAAC,aAAa;MACvF,cAAc,CAAC,SAAS,CAAC;oDACqB,SAAS;iDACZ,SAAS;EACxD,CAAC;IAED,OAAO;QACL,SAAS;QACT,UAAU,EAAE,iBAAiB;QAC7B,IAAI;QACJ,cAAc,EAAE,iFAAiF;QACjG,WAAW,EAAE,0BAA0B,SAAS,8DAA8D;QAC9G,QAAQ,EAAE,gBAAgB,CAAC,SAAS,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,WAAW,EAAE,UAAU,EAAE,MAAM,CAAC;KACjG,CAAC;AACJ,CAAC;AAED,SAAS,wBAAwB,CAAC,SAA8B;IAC9D,MAAM,OAAO,GAAG,SAAS,CAAC,OAAO,CAAC;IAClC,MAAM,SAAS,GAAG,OAAO,CAAC,WAAW,CAAC;IAEtC,MAAM,IAAI,GAAG,iCAAiC,SAAS;KACpD,OAAO,CAAC,eAAe,+BAA+B,OAAO,CAAC,aAAa;;;;;KAK3E,OAAO,CAAC,QAAQ,IAAI,4BAA4B;;sEAEiB,CAAC;IAErE,OAAO;QACL,SAAS;QACT,UAAU,EAAE,iBAAiB;QAC7B,IAAI;QACJ,cAAc,EAAE,uFAAuF;QACvG,WAAW,EAAE,gIAAgI;QAC7I,QAAQ,EAAE,0BAA0B,SAAS,uCAAuC;KACrF,CAAC;AACJ,CAAC;AAED,+EAA+E;AAE/E,SAAS,iBAAiB,CAAC,WAAqB;IAC9C,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAEzD,4BAA4B;IAC5B,MAAM,QAAQ,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;IACxD,MAAM,cAAc,GAAG,IAAI,GAAG,EAAkB,CAAC;IAEjD,KAAK,MAAM,GAAG,IAAI,QAAQ,EAAE,CAAC;QAC3B,IAAI,GAAG,IAAI,GAAG,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YAChD,cAAc,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,cAAc,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QAC9D,CAAC;IACH,CAAC;IAED,gDAAgD;IAChD,MAAM,QAAQ,GAAG,CAAC,GAAG,cAAc,CAAC,OAAO,EAAE,CAAC;SAC3C,MAAM,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;SACnE,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC;SACnB,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAEf,OAAO,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,qBAAqB,CAAC,CAAC;AAClE,CAAC;AAED,SAAS,uBAAuB,CAAC,SAAiB;IAChD,IAAI,SAAS,CAAC,QAAQ,CAAC,OAAO,CAAC;QAAE,OAAO,SAAS,CAAC;IAClD,IAAI,SAAS,CAAC,QAAQ,CAAC,SAAS,CAAC;QAAE,OAAO,WAAW,CAAC;IACtD,IAAI,SAAS,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,SAAS,CAAC,QAAQ,CAAC,MAAM,CAAC;QAAE,OAAO,QAAQ,CAAC;IAC9E,IAAI,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC;QAAE,OAAO,UAAU,CAAC;IACpD,IAAI,SAAS,CAAC,QAAQ,CAAC,KAAK,CAAC;QAAE,OAAO,gBAAgB,CAAC;IACvD,OAAO,YAAY,CAAC;AACtB,CAAC;AAED,SAAS,cAAc,CAAC,SAAiB;IACvC,IAAI,SAAS,CAAC,QAAQ,CAAC,WAAW,CAAC;QAAE,OAAO,8EAA8E,CAAC;IAC3H,IAAI,SAAS,CAAC,QAAQ,CAAC,WAAW,CAAC;QAAE,OAAO,wEAAwE,CAAC;IACrH,IAAI,SAAS,CAAC,QAAQ,CAAC,kBAAkB,CAAC;QAAE,OAAO,mEAAmE,CAAC;IACvH,OAAO,iCAAiC,SAAS,KAAK,CAAC;AACzD,CAAC;AAED,SAAS,SAAS,CAAC,GAAW;IAC5B,OAAO,GAAG,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC;AAC7D,CAAC;AAED,SAAS,gBAAgB,CACvB,SAAiB,EACjB,UAAkB,EAClB,SAAiB,EACjB,QAAiB;IAEjB,OAAO,SAAS,SAAS;iCACM,UAAU;kBACzB,SAAS,UAAU,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC;IACzD,CAAC;AACL,CAAC;AAED,+EAA+E;AAE/E,SAAgB,mBAAmB,CAAC,OAAwB;IAC1D,MAAM,KAAK,GAAa;QACtB,8CAA8C;QAC9C,EAAE;QACF,4BAA4B,OAAO,CAAC,MAAM,EAAE;QAC5C,EAAE;KACH,CAAC;IAEF,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;QAC7B,KAAK,CAAC,IAAI,CAAC,MAAM,MAAM,CAAC,SAAS,KAAK,MAAM,CAAC,UAAU,MAAM,CAAC,CAAC;QAC/D,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;QAC/B,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACf,KAAK,CAAC,IAAI,CAAC,YAAY,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC;QACjD,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACf,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACpB,KAAK,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QAC5B,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QACxB,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAClB,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACf,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACpB,KAAK,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QAC5B,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAC5B,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAClB,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACjB,CAAC;IAED,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC1B,CAAC"}

package/dist/graduation/graduation-validator.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Sprint 13a Week 2: Graduation Validator
+ *
+ * Stage 3 of the Graduation Pipeline.
+ * Evaluates aggregated FP patterns against graduation criteria.
+ * Patterns that meet all thresholds become candidates for codification
+ * as permanent engine heuristics.
+ *
+ * Graduation criteria (configurable):
+ * - Minimum N dismissals across scans
+ * - Average confidence above threshold
+ * - Zero (or near-zero) false confirmations
+ * - Minimum precision when validated against ground truth
+ * - Appeared in minimum N unique scans
+ */
+import { PatternStats, AggregationResult } from './pattern-aggregator';
+export interface GraduationCriteria {
+    /** Minimum total dismissals required */
+    minDismissals: number;
+    /** Minimum average confidence (1-10) */
+    minAvgConfidence: number;
+    /** Maximum allowed false confirmations (ground truth contradictions) */
+    maxFalseConfirmations: number;
+    /** Minimum precision when validated against ground truth (0-1) */
+    minPrecision: number;
+    /** Minimum unique scans the pattern appeared in */
+    minUniqueScans: number;
+}
+export interface GraduationCandidate {
+    /** The FP pattern being evaluated */
+    pattern: PatternStats;
+    /** Whether this pattern meets all criteria */
+    eligible: boolean;
+    /** Which criteria passed/failed */
+    criteriaResults: {
+        criterion: string;
+        passed: boolean;
+        actual: number;
+        required: number;
+    }[];
+    /** Recommended heuristic type for codification */
+    recommendedHeuristic: 'file_skip' | 'rule_suppress' | 'severity_downgrade' | 'context_check';
+    /** Generated heuristic description */
+    heuristicDescription: string;
+    /** Priority score (higher = graduate first) */
+    priorityScore: number;
+}
+export interface GraduationReport {
+    /** When validation was run */
+    validatedAt: string;
+    /** Criteria used */
+    criteria: GraduationCriteria;
+    /** All candidates evaluated */
+    candidates: GraduationCandidate[];
+    /** Eligible candidates only */
+    eligible: GraduationCandidate[];
+    /** Nearly eligible (missing 1 criterion) */
+    nearMiss: GraduationCandidate[];
+    /** Summary stats */
+    summary: {
+        totalPatterns: number;
+        eligibleCount: number;
+        nearMissCount: number;
+        rejectedCount: number;
+    };
+}
+export declare const DEFAULT_GRADUATION_CRITERIA: GraduationCriteria;
+export declare const MVP_GRADUATION_CRITERIA: GraduationCriteria;
+/**
+ * Evaluate FP patterns against graduation criteria.
+ */
+export declare function validateGraduation(aggregation: AggregationResult, criteria?: GraduationCriteria, groundTruthPrecision?: Map<string, number>): GraduationReport;
+export declare function formatGraduationReport(report: GraduationReport): string;

package/dist/graduation/graduation-validator.js

@@ -0,0 +1,204 @@
+"use strict";
+/**
+ * Sprint 13a Week 2: Graduation Validator
+ *
+ * Stage 3 of the Graduation Pipeline.
+ * Evaluates aggregated FP patterns against graduation criteria.
+ * Patterns that meet all thresholds become candidates for codification
+ * as permanent engine heuristics.
+ *
+ * Graduation criteria (configurable):
+ * - Minimum N dismissals across scans
+ * - Average confidence above threshold
+ * - Zero (or near-zero) false confirmations
+ * - Minimum precision when validated against ground truth
+ * - Appeared in minimum N unique scans
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MVP_GRADUATION_CRITERIA = exports.DEFAULT_GRADUATION_CRITERIA = void 0;
+exports.validateGraduation = validateGraduation;
+exports.formatGraduationReport = formatGraduationReport;
+// ─── Default Criteria ───────────────────────────────────────────────────────
+exports.DEFAULT_GRADUATION_CRITERIA = {
+    minDismissals: 15,
+    minAvgConfidence: 7.0,
+    maxFalseConfirmations: 0,
+    minPrecision: 0.95,
+    minUniqueScans: 2,
+};
+// Relaxed criteria for MVP (smaller dataset)
+exports.MVP_GRADUATION_CRITERIA = {
+    minDismissals: 5,
+    minAvgConfidence: 6.0,
+    maxFalseConfirmations: 1,
+    minPrecision: 0.90,
+    minUniqueScans: 1,
+};
+// ─── Validator ──────────────────────────────────────────────────────────────
+/**
+ * Evaluate FP patterns against graduation criteria.
+ */
+function validateGraduation(aggregation, criteria = exports.DEFAULT_GRADUATION_CRITERIA, groundTruthPrecision // patternId → precision from ground truth
+) {
+    const candidates = [];
+    for (const pattern of aggregation.patterns) {
+        const precision = groundTruthPrecision?.get(pattern.fpPatternId) ?? 1.0;
+        const criteriaResults = [
+            {
+                criterion: 'minDismissals',
+                passed: pattern.totalDismissals >= criteria.minDismissals,
+                actual: pattern.totalDismissals,
+                required: criteria.minDismissals,
+            },
+            {
+                criterion: 'minAvgConfidence',
+                passed: pattern.avgConfidence >= criteria.minAvgConfidence,
+                actual: pattern.avgConfidence,
+                required: criteria.minAvgConfidence,
+            },
+            {
+                criterion: 'maxFalseConfirmations',
+                passed: pattern.falseConfirmations <= criteria.maxFalseConfirmations,
+                actual: pattern.falseConfirmations,
+                required: criteria.maxFalseConfirmations,
+            },
+            {
+                criterion: 'minPrecision',
+                passed: precision >= criteria.minPrecision,
+                actual: Math.round(precision * 100) / 100,
+                required: criteria.minPrecision,
+            },
+            {
+                criterion: 'minUniqueScans',
+                passed: pattern.uniqueScans >= criteria.minUniqueScans,
+                actual: pattern.uniqueScans,
+                required: criteria.minUniqueScans,
+            },
+        ];
+        const eligible = criteriaResults.every(r => r.passed);
+        const failedCount = criteriaResults.filter(r => !r.passed).length;
+        // Determine recommended heuristic type
+        const recommendedHeuristic = inferHeuristicType(pattern);
+        const heuristicDescription = generateHeuristicDescription(pattern, recommendedHeuristic);
+        // Priority score: higher = more confident graduation candidate
+        const priorityScore = calculatePriorityScore(pattern, precision);
+        candidates.push({
+            pattern,
+            eligible,
+            criteriaResults,
+            recommendedHeuristic,
+            heuristicDescription,
+            priorityScore,
+        });
+    }
+    // Sort by priority score
+    candidates.sort((a, b) => b.priorityScore - a.priorityScore);
+    const eligible = candidates.filter(c => c.eligible);
+    const nearMiss = candidates.filter(c => {
+        const failed = c.criteriaResults.filter(r => !r.passed).length;
+        return !c.eligible && failed === 1;
+    });
+    return {
+        validatedAt: new Date().toISOString(),
+        criteria,
+        candidates,
+        eligible,
+        nearMiss,
+        summary: {
+            totalPatterns: candidates.length,
+            eligibleCount: eligible.length,
+            nearMissCount: nearMiss.length,
+            rejectedCount: candidates.length - eligible.length - nearMiss.length,
+        },
+    };
+}
+// ─── Heuristic Inference ────────────────────────────────────────────────────
+function inferHeuristicType(pattern) {
+    const patternId = pattern.fpPatternId.toLowerCase();
+    // File-level skip patterns
+    if (patternId.includes('vendor') ||
+        patternId.includes('test') ||
+        patternId.includes('doc-generator') ||
+        patternId.includes('migration') ||
+        patternId.includes('fixture') ||
+        patternId.includes('mock') ||
+        patternId.includes('build-output') ||
+        patternId.includes('type-def')) {
+        return 'file_skip';
+    }
+    // Rule suppression patterns (specific rule on specific file types)
+    if (patternId.includes('admin') ||
+        patternId.includes('consent') ||
+        patternId.includes('playback') ||
+        patternId.includes('deletion')) {
+        return 'rule_suppress';
+    }
+    // Severity downgrade patterns
+    if (patternId.includes('framework') ||
+        patternId.includes('sanitized') ||
+        patternId.includes('error-monitoring')) {
+        return 'severity_downgrade';
+    }
+    // Context check (needs surrounding code analysis)
+    return 'context_check';
+}
+function generateHeuristicDescription(pattern, type) {
+    const rules = pattern.affectedRules.join(', ');
+    switch (type) {
+        case 'file_skip':
+            return `Add path pattern to classifyFile() → shouldSkip=true. Affects: ${rules}. Pattern: ${pattern.fpPatternId}`;
+        case 'rule_suppress':
+            return `Add to rule-specific suppression list (similar to TEST_FP_RULES). Suppress ${rules} when pattern "${pattern.fpPatternId}" matches.`;
+        case 'severity_downgrade':
+            return `Add severity downgrade logic for ${rules} when "${pattern.fpPatternId}" context detected. Downgrade from 'warning' to 'info'.`;
+        case 'context_check':
+            return `Add code context check in scan loop: when "${pattern.fpPatternId}" signals detected in surrounding code, suppress ${rules}.`;
+    }
+}
+function calculatePriorityScore(pattern, precision) {
+    // Weighted score:
+    // - 40% based on total dismissals (capped at 50)
+    // - 30% based on average confidence
+    // - 20% based on precision
+    // - 10% based on unique scans
+    const dismissalScore = Math.min(pattern.totalDismissals / 50, 1) * 40;
+    const confidenceScore = (pattern.avgConfidence / 10) * 30;
+    const precisionScore = precision * 20;
+    const scanScore = Math.min(pattern.uniqueScans / 5, 1) * 10;
+    return Math.round((dismissalScore + confidenceScore + precisionScore + scanScore) * 10) / 10;
+}
+// ─── Report Formatting ──────────────────────────────────────────────────────
+function formatGraduationReport(report) {
+    const lines = [
+        '═══ Graduation Pipeline — Validation Report ═══',
+        '',
+        `Validated at: ${report.validatedAt}`,
+        `Criteria: minDismissals=${report.criteria.minDismissals}, minConf=${report.criteria.minAvgConfidence}, maxFalseConf=${report.criteria.maxFalseConfirmations}, minPrecision=${report.criteria.minPrecision}, minScans=${report.criteria.minUniqueScans}`,
+        '',
+        `Total patterns: ${report.summary.totalPatterns}`,
+        `Eligible for graduation: ${report.summary.eligibleCount}`,
+        `Near miss (1 criterion short): ${report.summary.nearMissCount}`,
+        `Rejected: ${report.summary.rejectedCount}`,
+    ];
+    if (report.eligible.length > 0) {
+        lines.push('');
+        lines.push('── ELIGIBLE FOR GRADUATION ──');
+        for (const c of report.eligible) {
+            lines.push(`  [${c.priorityScore}] ${c.pattern.fpPatternId}`);
+            lines.push(`    Dismissals: ${c.pattern.totalDismissals}, Avg Conf: ${c.pattern.avgConfidence}, Scans: ${c.pattern.uniqueScans}`);
+            lines.push(`    Rules: ${c.pattern.affectedRules.join(', ')}`);
+            lines.push(`    Action: ${c.heuristicDescription}`);
+        }
+    }
+    if (report.nearMiss.length > 0) {
+        lines.push('');
+        lines.push('── NEAR MISS (1 criterion short) ──');
+        for (const c of report.nearMiss) {
+            const failed = c.criteriaResults.find(r => !r.passed);
+            lines.push(`  ${c.pattern.fpPatternId}`);
+            lines.push(`    Missing: ${failed?.criterion} (actual: ${failed?.actual}, required: ${failed?.required})`);
+        }
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=graduation-validator.js.map

package/dist/graduation/graduation-validator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"graduation-validator.js","sourceRoot":"","sources":["../../src/graduation/graduation-validator.ts"],"names":[],"mappings":"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"}

package/dist/graduation/index.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Graduation Pipeline — Sprint 13a Week 2
+ *
+ * Four-stage pipeline that transforms AI Review Board FP verdicts
+ * into permanent engine heuristics:
+ *
+ * Stage 1: COLLECT — Log each verdict to structured JSONL
+ * Stage 2: AGGREGATE — Compute per-pattern statistics across scans
+ * Stage 3: VALIDATE — Check graduation criteria (dismissals, confidence, precision)
+ * Stage 4: CODIFY — Generate engine heuristic code for approved patterns
+ *
+ * Usage:
+ *   import { GraduationPipeline } from './graduation';
+ *   const pipeline = new GraduationPipeline({ logDir: './verdict-logs' });
+ *   pipeline.logVerdict(verdict);           // Stage 1
+ *   const stats = pipeline.aggregate();     // Stage 2
+ *   const candidates = pipeline.validate(); // Stage 3
+ *   const code = pipeline.codify();         // Stage 4
+ */
+export { FPVerdictLogger, VerdictLogEntry } from './fp-verdict-logger';
+export { aggregatePatterns, aggregateFromDirectory, formatAggregationReport, PatternStats, AggregationResult, } from './pattern-aggregator';
+export { validateGraduation, formatGraduationReport, DEFAULT_GRADUATION_CRITERIA, MVP_GRADUATION_CRITERIA, GraduationCriteria, GraduationCandidate, GraduationReport, } from './graduation-validator';
+export { generateCode, generateAllCode, formatCodegenReport, CodegenResult, } from './graduation-codifier';
+import { FPVerdictLogger, VerdictLogEntry } from './fp-verdict-logger';
+import { AggregationResult } from './pattern-aggregator';
+import { GraduationCriteria, GraduationReport } from './graduation-validator';
+import { CodegenResult } from './graduation-codifier';
+export interface GraduationPipelineConfig {
+    /** Directory for verdict JSONL logs */
+    logDir: string;
+    /** Known FP pattern IDs from the static library */
+    knownPatternIds?: Set<string>;
+    /** Graduation criteria (defaults to MVP criteria) */
+    criteria?: GraduationCriteria;
+    /** Ground truth precision per pattern (from regression suite) */
+    groundTruthPrecision?: Map<string, number>;
+}
+export declare class GraduationPipeline {
+    private config;
+    private logger;
+    constructor(config: GraduationPipelineConfig);
+    /**
+     * Initialize logger for a new scan.
+     */
+    startScan(scanId: string, promptVersion?: string): FPVerdictLogger;
+    /**
+     * Log a single verdict (convenience method).
+     */
+    logVerdict(entry: Omit<VerdictLogEntry, 'timestamp' | 'scanId' | 'promptVersion'>): void;
+    /**
+     * Aggregate all verdict logs in the log directory.
+     */
+    aggregate(): AggregationResult;
+    /**
+     * Validate aggregated patterns against graduation criteria.
+     */
+    validate(aggregation?: AggregationResult): GraduationReport;
+    /**
+     * Generate code for all eligible graduation candidates.
+     */
+    codify(report?: GraduationReport): CodegenResult[];
+    /**
+     * Run the full pipeline (stages 2-4) on existing log data.
+     * Stage 1 (logging) happens during scans, not here.
+     */
+    runPipeline(): {
+        aggregation: AggregationResult;
+        graduation: GraduationReport;
+        codegen: CodegenResult[];
+    };
+}