progmune-runtime 2.1.6 → 3.2.0

package/dist/precision-analyze.js

@@ -0,0 +1,229 @@
+"use strict";
+/**
+ * FP Taxonomy Analyzer
+ *
+ * Classifies every false positive from a precision report into
+ * root cause categories. This tells us WHY precision is low
+ * before we attempt to fix anything.
+ *
+ * Usage:
+ *   npx ts-node src/precision-analyze.ts benchmarks/curl
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const resource_detector_1 = require("./resource-detector");
+// ── Classification Logic ──
+function classifyFP(calls, funcName, reason) {
+    // 1. State inference noise: SSG auto-discovered rule rejected valid ordering
+    //    Pattern: reason contains "requires [C0_S...] but state has [INIT,C0_S...]"
+    if (reason.includes("requires [C") && reason.includes("but state has [")) {
+        return "state_inference_noise";
+    }
+    // 2. Check if this is a resource lifecycle false positive
+    const resourceVios = (0, resource_detector_1.detectResourceViolations)(calls);
+    // 3. Allocator-return: function name suggests it's a factory/allocator
+    const allocatorPatterns = /\b(create|alloc|new|init|open|dup|clone|copy|build|make)\w*\b/i;
+    const isAllocator = allocatorPatterns.test(funcName);
+    if (isAllocator && resourceVios.some(v => v.type === "missing_release")) {
+        return "allocator_return";
+    }
+    // 4. Cross-function cleanup: resource acquired here, released elsewhere
+    //    Pattern: has acquire calls + has no matching release in this function
+    const hasAcquire = /\b(malloc|calloc|open|connect|SSL_new|BIO_new|Curl_open|ngx_.*_init|ngx_.*_create)\b/i;
+    const hasRelease = /\b(free|close|disconnect|SSL_free|BIO_free|Curl_close|ngx_.*_free|ngx_.*_cleanup)\b/i;
+    const callsStr = calls.join(" ");
+    if (hasAcquire.test(callsStr) && !hasRelease.test(callsStr) && !isAllocator) {
+        return "cross_function_cleanup";
+    }
+    // 5. Callback ownership: common async/event pattern
+    const callbackPatterns = /\b(callback|cb_|_cb|handler|on_|_done|_complete|_finish)\b/i;
+    if (callbackPatterns.test(funcName) || calls.some(c => callbackPatterns.test(c))) {
+        return "callback_ownership";
+    }
+    // 6. Noise call: logging/debug/trace functions in the call list
+    const noisePatterns = /\b(infof|failf|DEBUGF|DEBUGASSERT|log|trace|debug|print|dump|assert)\b/i;
+    const noiseCount = calls.filter(c => noisePatterns.test(c)).length;
+    if (noiseCount >= calls.length * 0.3) {
+        return "noise_call";
+    }
+    // 7. Protocol extraction error: calls don't form a meaningful protocol sequence
+    const protocolPatterns = /\b(init|open|connect|send|recv|read|write|close|free|cleanup|finish|done|stop|start)\b/i;
+    const protocolCount = calls.filter(c => protocolPatterns.test(c)).length;
+    if (protocolCount < calls.length * 0.3) {
+        return "protocol_extraction_error";
+    }
+    return "unknown";
+}
+function classifyFN(calls, funcName, reason) {
+    // FN: human said violation, detector said clean
+    // Why didn't the detector catch this?
+    const callsStr = calls.join(" ");
+    // State machine functions that are missing transitions
+    const stateMachinePatterns = /\b(state|statemachine|_step|_phase)\w*\b/i;
+    if (stateMachinePatterns.test(funcName)) {
+        return "state_inference_noise"; // Detector didn't learn the state machine correctly
+    }
+    // Missing acquire before release
+    const hasRelease = /\b(free|close|disconnect|SSL_free|BIO_free|cleanup|destroy)\b/i;
+    const hasAcquire = /\b(malloc|open|connect|SSL_new|BIO_new|init|create)\b/i;
+    if (hasRelease.test(callsStr) && !hasAcquire.test(callsStr)) {
+        return "cross_function_cleanup"; // Release without acquire in same function
+    }
+    return "unknown";
+}
+// ── Main Analyzer ──
+function analyze(repoPath) {
+    const precFile = path.join(path.dirname(repoPath), `${path.basename(repoPath)}-precision.json`);
+    if (!fs.existsSync(precFile)) {
+        console.error(`❌ Precision report not found: ${precFile}`);
+        process.exit(1);
+    }
+    const report = JSON.parse(fs.readFileSync(precFile, "utf-8"));
+    const details = report.details || [];
+    const fpCases = details.filter((d) => d.expected === "clean" && d.detected === "violation");
+    const fnCases = details.filter((d) => d.expected === "violation" && d.detected === "clean");
+    console.error(`\nAnalyzing ${report.total} samples: ${report.fp} FP, ${report.fn} FN`);
+    // Classify FPs
+    const fpByCategory = new Map();
+    for (const d of fpCases) {
+        const cat = classifyFP(d.calls || [], d.calls?.[0] || "", d.reason || "");
+        if (!fpByCategory.has(cat))
+            fpByCategory.set(cat, []);
+        fpByCategory.get(cat).push(d);
+    }
+    // Classify FNs
+    const fnByCategory = new Map();
+    for (const d of fnCases) {
+        const cat = classifyFN(d.calls || [], d.calls?.[0] || "", d.reason || "");
+        if (!fnByCategory.has(cat))
+            fnByCategory.set(cat, []);
+        fnByCategory.get(cat).push(d);
+    }
+    // ═══ FP Taxonomy Report ═══
+    const C = {
+        reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m",
+        green: "\x1b[32m", red: "\x1b[31m", yellow: "\x1b[33m", cyan: "\x1b[36m",
+    };
+    const CATEGORY_LABELS = {
+        state_inference_noise: {
+            label: "State inference noise",
+            desc: "Auto-discovered SSG rules overfit to call order. Valid protocol sequences flagged because they don't match the learned adjacency pattern.",
+            fix: "Replace auto-discovered rules with hand-written protocol definitions. Increase clean training sequences from 29 to 100+.",
+        },
+        cross_function_cleanup: {
+            label: "Cross-function cleanup",
+            desc: "Resource acquired in this function but released elsewhere (caller, callback, cleanup phase). Detector assumes acquire+release must be in same scope.",
+            fix: "Model protocol lifecycle across function boundaries. Recognize that acquire in step1() may be released in cleanup().",
+        },
+        allocator_return: {
+            label: "Allocator-return pattern",
+            desc: "Function allocates resource and returns it to caller. Detector sees malloc without free and flags as leak — but the caller is responsible for cleanup.",
+            fix: "Identify factory/allocator functions by name pattern. Exclude them from acquire-without-release checks.",
+        },
+        callback_ownership: {
+            label: "Callback ownership",
+            desc: "Resource passed to async callback. Ownership transfers — cleanup responsibility moves to callback or event handler.",
+            fix: "Track resource ownership across callback boundaries. Recognize event-driven cleanup patterns.",
+        },
+        noise_call: {
+            label: "Noise call in sequence",
+            desc: "Logging, debug, or trace calls mixed into protocol sequences. These create false adjacency patterns in SSG rule discovery.",
+            fix: "Filter noise calls (infof, failf, DEBUGF, etc.) before rule discovery.",
+        },
+        protocol_extraction_error: {
+            label: "Protocol extraction error",
+            desc: "Extracted calls don't form a real protocol sequence. C function call extraction picked up utility calls rather than protocol steps.",
+            fix: "Improve C call extraction: filter utility functions, focus on named protocol operations.",
+        },
+        unknown: {
+            label: "Unknown / Other",
+            desc: "Doesn't match any known FP pattern. Requires manual inspection.",
+            fix: "Manual review of individual cases.",
+        },
+    };
+    console.log(`\n${C.bold}${C.cyan}╔══════════════════════════════════════════════════════════════╗${C.reset}`);
+    console.log(`${C.bold}${C.cyan}║${C.reset}  ${C.bold}FP Taxonomy Report — curl${C.reset}                                     ${C.bold}${C.cyan}║${C.reset}`);
+    console.log(`${C.bold}${C.cyan}╚══════════════════════════════════════════════════════════════╝${C.reset}`);
+    console.log("");
+    // FP Breakdown
+    console.log(`${C.bold}False Positives (${fpCases.length}):${C.reset}\n`);
+    const fpSorted = [...fpByCategory.entries()].sort((a, b) => b[1].length - a[1].length);
+    for (const [cat, cases] of fpSorted) {
+        const pct = ((cases.length / fpCases.length) * 100).toFixed(0);
+        const bar = "█".repeat(Math.round(cases.length / fpCases.length * 30));
+        const info = CATEGORY_LABELS[cat];
+        console.log(`  ${C.red}${bar}${C.reset} ${pct}%  ${C.bold}${info.label}${C.reset} (${cases.length} cases)`);
+        console.log(`  ${C.dim}${info.desc}${C.reset}`);
+        // Show 2 examples
+        for (const ex of cases.slice(0, 2)) {
+            console.log(`  ${C.dim}  ex: ${(ex.calls || []).slice(0, 4).join(" → ")}${C.reset}`);
+        }
+        console.log("");
+    }
+    // FN Breakdown
+    console.log(`${C.bold}False Negatives (${fnCases.length}):${C.reset}\n`);
+    const fnSorted = [...fnByCategory.entries()].sort((a, b) => b[1].length - a[1].length);
+    for (const [cat, cases] of fnSorted) {
+        const pct = ((cases.length / fnCases.length) * 100).toFixed(0);
+        const bar = "█".repeat(Math.round(cases.length / Math.max(1, fnCases.length) * 30));
+        const info = CATEGORY_LABELS[cat];
+        console.log(`  ${C.yellow}${bar}${C.reset} ${pct}%  ${C.bold}${info.label}${C.reset} (${cases.length} cases)`);
+        for (const ex of cases.slice(0, 2)) {
+            console.log(`  ${C.dim}  ex: ${(ex.calls || []).slice(0, 4).join(" → ")}${C.reset}`);
+        }
+        console.log("");
+    }
+    // Fix priority
+    console.log(`${C.bold}Fix Priority:${C.reset}`);
+    const topFP = fpSorted[0];
+    if (topFP) {
+        const info = CATEGORY_LABELS[topFP[0]];
+        console.log(`  1. ${C.red}${info.label}${C.reset} — ${topFP[1].length} cases (${((topFP[1].length / fpCases.length) * 100).toFixed(0)}% of FP)`);
+        console.log(`     ${C.dim}→ ${info.fix}${C.reset}`);
+    }
+    if (fpSorted[1]) {
+        const info = CATEGORY_LABELS[fpSorted[1][0]];
+        console.log(`  2. ${info.label} — ${fpSorted[1][1].length} cases`);
+    }
+    console.log(`  3. Expand curl labels from ${report.total} to 100-150 samples`);
+    console.log(`  4. Re-measure Precision after fixing top category`);
+    console.log("");
+}
+// CLI
+const args = process.argv.slice(2);
+const repoPath = path.resolve(args.find(a => !a.startsWith("--")) || ".");
+analyze(repoPath);

package/dist/precision-benchmark.js

@@ -0,0 +1,147 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPrecisionBenchmark = runPrecisionBenchmark;
+const fs = __importStar(require("fs"));
+const state_inference_1 = require("./experimental/state-inference");
+/**
+ * Run precision benchmark with labeled data.
+ *
+ * Detection logic (structural, not template-matching):
+ *   1. Build REFERENCE SM from clean-labeled sequences
+ *   2. For each test sequence, build its SM
+ *   3. Compare: if a sequence has ≥2 fewer states than the reference,
+ *      OR has illegal transitions not in the reference, it's flagged.
+ *   4. Measure TP/FP/TN/FN against labels.
+ */
+function runPrecisionBenchmark(sequences, labels) {
+    // Build reference SM from clean sequences only
+    const cleanSeqs = sequences
+        .filter(s => labels[s.index] === 'clean' && s.calls.length >= 2)
+        .map(s => s.calls);
+    if (cleanSeqs.length === 0) {
+        return { total: 0, truePositive: 0, falsePositive: 0, trueNegative: 0, falseNegative: 0, precision: 0, recall: 0, f1: 0, mismatches: [] };
+    }
+    const referenceSM = (0, state_inference_1.inferStateMachine)(cleanSeqs);
+    const refStateCount = referenceSM.stateCount;
+    // Extract reference edge set (what transitions are "normal")
+    const refEdges = new Set();
+    for (let i = 0; i < referenceSM.stateTransitions.length; i++)
+        for (let j = 0; j < (referenceSM.stateTransitions[i] || []).length; j++)
+            if (referenceSM.stateTransitions[i][j] > 0)
+                refEdges.add(`${i}→${j}`);
+    let tp = 0, fp = 0, tn = 0, fn = 0;
+    const mismatches = [];
+    for (const seq of sequences) {
+        const expected = labels[seq.index] || 'skip';
+        if (expected === 'skip')
+            continue;
+        if (seq.calls.length < 2) {
+            tn++;
+            continue;
+        }
+        const testSM = (0, state_inference_1.inferStateMachine)([seq.calls]);
+        const stateDiff = refStateCount - testSM.stateCount;
+        // Detection: flagged if ≥2 fewer states than reference
+        const detected = stateDiff >= 2 ? 'violation' : 'clean';
+        let matched = false;
+        if (expected === 'clean' && detected === 'clean') {
+            tn++;
+            matched = true;
+        }
+        else if (expected === 'violation' && detected === 'violation') {
+            tp++;
+            matched = true;
+        }
+        else if (expected === 'clean' && detected === 'violation') {
+            fp++;
+        }
+        else if (expected === 'violation' && detected === 'clean') {
+            fn++;
+        }
+        if (!matched) {
+            mismatches.push({
+                index: seq.index,
+                functionName: seq.functionName,
+                expected,
+                detected,
+                stateDiff,
+                calls: seq.calls,
+            });
+        }
+    }
+    const total = tp + fp + tn + fn;
+    const precision = total > 0 ? tp / (tp + fp) : 0;
+    const recall = total > 0 ? tp / (tp + fn) : 0;
+    const f1 = precision + recall > 0 ? 2 * precision * recall / (precision + recall) : 0;
+    return { total, truePositive: tp, falsePositive: fp, trueNegative: tn, falseNegative: fn, precision, recall, f1, mismatches };
+}
+// ================ CLI ================
+const args = process.argv.slice(2);
+const seqFile = args[0];
+const labelFile = args[1];
+if (!seqFile || !labelFile) {
+    console.error('Usage: npx tsx src/precision-benchmark.ts <sequences.json> <labels.json>');
+    process.exit(1);
+}
+const seqData = JSON.parse(fs.readFileSync(seqFile, 'utf-8'));
+const sequences = seqData.sequences || seqData;
+const labels = JSON.parse(fs.readFileSync(labelFile, 'utf-8'));
+console.log('Running precision benchmark...');
+const result = runPrecisionBenchmark(sequences, labels);
+console.log('\n=== Precision Benchmark Results ===');
+console.log(`Total sequences evaluated: ${result.total}`);
+console.log(`True Positives:  ${result.truePositive}`);
+console.log(`False Positives: ${result.falsePositive}`);
+console.log(`True Negatives:  ${result.trueNegative}`);
+console.log(`False Negatives: ${result.falseNegative}`);
+console.log(`\nPrecision: ${(result.precision * 100).toFixed(1)}%`);
+console.log(`Recall:    ${(result.recall * 100).toFixed(1)}%`);
+console.log(`F1 Score:  ${(result.f1 * 100).toFixed(1)}%`);
+// 显示不匹配的详情
+const mismatches = (result.details || []).filter((d) => !d.matched);
+if (mismatches.length > 0) {
+    console.log(`\n--- Mismatches (${mismatches.length}) ---`);
+    for (const m of mismatches) {
+        console.log(`  [${m.index}] ${m.functionName}: expected=${m.expected}, detected=${m.detected}`);
+    }
+}
+// 保存报告
+const report = {
+    timestamp: new Date().toISOString(),
+    result
+};
+fs.writeFileSync('benchmarks/precision-report.json', JSON.stringify(report, null, 2));
+console.log('\nReport saved to benchmarks/precision-report.json');

package/dist/precision-label-c.js

@@ -0,0 +1,134 @@
+"use strict";
+/**
+ * Precision Labeling Tool for C/C++ projects
+ *
+ * Reads pre-extracted sequences JSON and saves labels.
+ * For TypeScript projects, use precision-label.ts instead.
+ *
+ * Usage:
+ *   npx ts-node src/precision-label-c.ts benchmarks/curl
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
+const C = {
+    reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m",
+    green: "\x1b[32m", red: "\x1b[31m", yellow: "\x1b[33m", cyan: "\x1b[36m",
+};
+async function main() {
+    const args = process.argv.slice(2);
+    const repoPath = path.resolve(args.find(a => !a.startsWith("--")) || ".");
+    const maxSeq = parseInt(args.includes("--max") ? args[args.indexOf("--max") + 1] : "50", 10);
+    const resume = args.includes("--resume");
+    const seqFile = path.join(path.dirname(repoPath), `${path.basename(repoPath)}-sequences.json`);
+    const labelFile = path.join(path.dirname(repoPath), `${path.basename(repoPath)}-labels.json`);
+    if (!fs.existsSync(seqFile)) {
+        console.error(`❌ Sequences file not found: ${seqFile}`);
+        console.error(`   Run C extraction first to generate this file.`);
+        process.exit(1);
+    }
+    // Load sequences
+    const allSeqs = JSON.parse(fs.readFileSync(seqFile, "utf-8"));
+    const sequences = allSeqs.slice(0, maxSeq);
+    // Load existing labels (resume)
+    let data = { repo: repoPath, labeledAt: "", total: 0, labels: {}, sequences: {} };
+    if (fs.existsSync(labelFile) && resume) {
+        data = JSON.parse(fs.readFileSync(labelFile, "utf-8"));
+    }
+    else if (fs.existsSync(labelFile)) {
+        data = JSON.parse(fs.readFileSync(labelFile, "utf-8"));
+    }
+    const alreadyLabeled = Object.keys(data.labels).length;
+    console.error(`\n${C.bold}${C.cyan}Precision Labeling — C/C++ Projects${C.reset}`);
+    console.error(`  Sequences: ${sequences.length} (${alreadyLabeled} already labeled)`);
+    console.error(`  Commands: ${C.green}c${C.reset}=clean  ${C.red}v${C.reset}=violation  ${C.yellow}s${C.reset}=skip  q=quit\n`);
+    console.error(`  ${C.dim}clean    = protocol looks complete (init→use→cleanup present)${C.reset}`);
+    console.error(`  ${C.dim}violation = protocol incomplete (missing init/cleanup, wrong order)${C.reset}`);
+    console.error(``);
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (q) => new Promise(resolve => rl.question(q, resolve));
+    let labeled = 0;
+    let skipped = 0;
+    for (let i = 0; i < sequences.length; i++) {
+        if (data.labels[i] !== undefined)
+            continue;
+        const seq = sequences[i];
+        const calls = seq.calls.slice(0, 8);
+        const more = seq.calls.length > 8 ? ` … (+${seq.calls.length - 8} more)` : "";
+        console.error(`${C.bold}[${i + 1}/${sequences.length}]${C.reset} ${C.dim}${seq.file || ""}${C.reset}`);
+        console.error(`  ${C.cyan}${seq.function}${C.reset}`);
+        console.error(`  → ${calls.join(" → ")}${more}`);
+        const answer = await ask(`  ${C.green}[c]lean${C.reset} ${C.red}[v]iolation${C.reset} ${C.yellow}[s]kip${C.reset} [q]uit: `);
+        switch (answer) {
+            case "q":
+                console.error(`\n  Quit. Saving ${labeled} new labels...`);
+                rl.close();
+                saveLabels(labelFile, data, labeled + alreadyLabeled);
+                return;
+            case "s":
+                skipped++;
+                console.error(`  ${C.yellow}↻ skipped${C.reset}\n`);
+                continue;
+            case "c":
+                data.labels[i] = "clean";
+                data.sequences[i] = seq.calls;
+                labeled++;
+                console.error(`  ${C.green}✓ clean${C.reset}\n`);
+                break;
+            case "v":
+                data.labels[i] = "violation";
+                data.sequences[i] = seq.calls;
+                labeled++;
+                console.error(`  ${C.red}✗ violation${C.reset}\n`);
+                break;
+            default:
+                console.error(`  ${C.yellow}? unknown — use c/v/s/q${C.reset}\n`);
+                break;
+        }
+    }
+    rl.close();
+    saveLabels(labelFile, data, labeled + alreadyLabeled);
+    console.error(`\n  Clean: ${Object.values(data.labels).filter((l) => l === "clean").length}`);
+    console.error(`  Violation: ${Object.values(data.labels).filter((l) => l === "violation").length}`);
+    console.error(`\n  Next: npx ts-node src/precision-report-c.ts ${repoPath}\n`);
+}
+function saveLabels(filePath, data, total) {
+    data.labeledAt = new Date().toISOString();
+    data.total = total;
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8");
+}
+main().catch(e => { console.error(e); process.exit(1); });