progmune-runtime 2.1.6 → 3.2.0

package/dist/llm.js

@@ -6,12 +6,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.callCount = void 0;
 exports.resetCallCount = resetCallCount;
 exports.estimateTokens = estimateTokens;
+exports.isVerbose = isVerbose;
 exports.generate = generate;
 exports.chat = chat;
 try {
     require("dotenv/config");
 }
-catch { }
+catch { /* ignore — dotenv is optional */ }
 const openai_1 = __importDefault(require("openai"));
 const provider = process.env.LLM_PROVIDER || "deepseek";
 const configs = {
@@ -33,8 +34,54 @@ const apiKey = process.env.LLM_API_KEY || "sk-xxxx";
 const baseURL = process.env.LLM_BASE_URL || selected.baseURL;
 const model = process.env.LLM_MODEL || selected.model;
 const client = new openai_1.default({ apiKey, baseURL });
+// ── API Key validation ──
+const KNOWN_KEY_PREFIXES = {
+    "ghp_": "GitHub Personal Access Token (classic)",
+    "github_pat_": "GitHub Personal Access Token (fine-grained)",
+    "glpat-": "GitLab Personal Access Token",
+    "sk-xxxx": "placeholder / default value",
+    "your-key": "placeholder / default value",
+};
+function validateApiKey(key) {
+    const warnings = [];
+    if (!key || key === "sk-xxxx" || key === "your-key") {
+        warnings.push("❌ LLM_API_KEY is not set or is a placeholder. Configure via .env: LLM_API_KEY=your-deepseek-key");
+        return warnings;
+    }
+    for (const [prefix, label] of Object.entries(KNOWN_KEY_PREFIXES)) {
+        if (key.startsWith(prefix)) {
+            warnings.push(`⚠️  LLM_API_KEY looks like a ${label} (prefix: "${prefix}"), not an LLM API key. DeepSeek keys start with "sk-". Get one at https://platform.deepseek.com/api_keys`);
+            break;
+        }
+    }
+    if (key.length < 20) {
+        warnings.push(`⚠️  LLM_API_KEY is unusually short (${key.length} chars). Most API keys are 30+ characters.`);
+    }
+    return warnings;
+}
+const keyWarnings = validateApiKey(apiKey);
+for (const w of keyWarnings) {
+    console.error(w);
+}
 exports.callCount = 0;
 function resetCallCount() { exports.callCount = 0; }
+const MAX_LLM_CALLS = parseInt(process.env.PROGMUNE_MAX_LLM_CALLS || "50", 10);
+const RATE_LIMIT_MS = parseInt(process.env.PROGMUNE_RATE_LIMIT_MS || "0", 10);
+let lastCallTime = 0;
+function assertCallLimit() {
+    if (exports.callCount >= MAX_LLM_CALLS) {
+        throw new Error(`LLM call limit reached (${exports.callCount}/${MAX_LLM_CALLS}). ` +
+            `Increase via PROGMUNE_MAX_LLM_CALLS env var or call resetCallCount().`);
+    }
+}
+async function applyRateLimit() {
+    if (RATE_LIMIT_MS <= 0)
+        return;
+    const elapsed = Date.now() - lastCallTime;
+    if (elapsed < RATE_LIMIT_MS) {
+        await new Promise(r => setTimeout(r, RATE_LIMIT_MS - elapsed));
+    }
+}
 /** 粗略 token 估算：CJK 字符 ~1.5 token/字，其余 ~0.4 token/字符 */
 /** @requires TEXT @produces TOKEN_COUNT */
 function estimateTokens(text) {
@@ -42,20 +89,42 @@ function estimateTokens(text) {
     const other = text.length - cjk;
     return Math.ceil(cjk * 1.5 + other * 0.4);
 }
+// ── Verbose debug logging ──
+const VERBOSE = process.env.PROGMUNE_VERBOSE === "1";
+function vlog(label, content, maxLen = 2000) {
+    if (!VERBOSE)
+        return;
+    const truncated = content.length > maxLen
+        ? content.slice(0, maxLen) + `\n... [truncated, ${content.length} total chars]`
+        : content;
+    console.error(`\n${"═".repeat(60)}\n🔍 [VERBOSE] ${label}\n${"─".repeat(60)}\n${truncated}\n${"═".repeat(60)}`);
+}
+function isVerbose() { return VERBOSE; }
 /** @requires PROMPT @produces LLM_RESPONSE */
 async function generate(prompt) {
+    assertCallLimit();
+    await applyRateLimit();
     exports.callCount++;
+    lastCallTime = Date.now();
+    vlog(`LLM Call #${exports.callCount} (generate) | Model: ${model} | Prompt (${estimateTokens(prompt)} est. tokens)`, prompt);
     const resp = await client.chat.completions.create({
         model,
         messages: [{ role: "user", content: prompt }],
         temperature: 0.0,
     });
-    return resp.choices[0]?.message?.content || "";
+    const content = resp.choices[0]?.message?.content || "";
+    vlog(`LLM Response #${exports.callCount} (${estimateTokens(content)} est. tokens, finish=${resp.choices[0]?.finish_reason})`, content);
+    return content;
 }
 /** 带 system prompt 的调用：静态规则放 system，动态内容放 user，语义分离便于未来对接各平台缓存策略 */
 /** @requires SYSTEM_PROMPT @produces LLM_RESPONSE */
 async function chat(systemPrompt, userPrompt) {
+    assertCallLimit();
+    await applyRateLimit();
     exports.callCount++;
+    lastCallTime = Date.now();
+    const totalTokens = estimateTokens(systemPrompt) + estimateTokens(userPrompt);
+    vlog(`LLM Call #${exports.callCount} (chat) | Model: ${model} | System (${estimateTokens(systemPrompt)}t) + User (${estimateTokens(userPrompt)}t) = ${totalTokens} est. tokens`, `── SYSTEM ──\n${systemPrompt}\n── USER ──\n${userPrompt}`);
     const resp = await client.chat.completions.create({
         model,
         messages: [
@@ -64,5 +133,7 @@ async function chat(systemPrompt, userPrompt) {
         ],
         temperature: 0.0,
     });
-    return resp.choices[0]?.message?.content || "";
+    const content = resp.choices[0]?.message?.content || "";
+    vlog(`LLM Response #${exports.callCount} (${estimateTokens(content)} est. tokens, finish=${resp.choices[0]?.finish_reason})`, content);
+    return content;
 }

package/dist/load-benchmarks.js

@@ -34,11 +34,16 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadBenchmarks = loadBenchmarks;
-/** Load benchmark tasks from bench/tasks.json
- * @protocol pre_states=[] post_states=["BENCHMARKS_LOADED"]
- */
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+/**
+ * Load benchmark tasks from bench/tasks.json.
+ * @requires BENCH_DIR @produces BENCHMARK_TASKS
+ * @purpose Load benchmark task definitions for execution
+ * @tags benchmark, load, data
+ * @useWhen running benchmarks, generating benchmark reports
+ * @protocol pre_states=[] post_states=["BENCHMARKS_LOADED"]
+ */
 function loadBenchmarks() {
     const tasksPath = path.resolve(process.cwd(), "bench/tasks.json");
     if (!fs.existsSync(tasksPath))

package/dist/logger.js

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * Structured logger for Progmune Runtime.
+ *
+ * Replaces raw console.* calls with leveled, module-scoped,
+ * optionally JSON-formatted output.
+ *
+ * Environment variables:
+ *   PROGMUNE_LOG_LEVEL  — debug | info | warn | error (default: info)
+ *   PROGMUNE_LOG_JSON   — "true" for machine-readable JSON lines
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLogger = createLogger;
+const LEVEL_ORDER = { debug: 0, info: 1, warn: 2, error: 3 };
+const minLevel = (process.env.PROGMUNE_LOG_LEVEL || "info");
+const jsonMode = process.env.PROGMUNE_LOG_JSON === "true";
+function shouldLog(level) {
+    return LEVEL_ORDER[level] >= LEVEL_ORDER[minLevel];
+}
+function formatLine(level, module, message, data) {
+    if (jsonMode) {
+        const entry = {
+            ts: new Date().toISOString(),
+            level,
+            module,
+            message,
+            ...(data !== undefined ? { data } : {}),
+        };
+        return JSON.stringify(entry);
+    }
+    const prefix = {
+        debug: "  ",
+        info: "ℹ ",
+        warn: "⚠ ",
+        error: "❌",
+    };
+    const tag = `[${module}]`;
+    const line = `${prefix[level]} ${tag} ${message}`;
+    if (data !== undefined) {
+        if (data instanceof Error) {
+            return `${line}\n       ${data.stack || data.message}`;
+        }
+        return `${line} ${JSON.stringify(data)}`;
+    }
+    return line;
+}
+function createLogger(module) {
+    return {
+        debug(message, data) {
+            if (shouldLog("debug"))
+                console.error(formatLine("debug", module, message, data));
+        },
+        info(message, data) {
+            if (shouldLog("info"))
+                console.error(formatLine("info", module, message, data));
+        },
+        warn(message, data) {
+            if (shouldLog("warn"))
+                console.error(formatLine("warn", module, message, data));
+        },
+        error(message, data) {
+            if (shouldLog("error"))
+                console.error(formatLine("error", module, message, data));
+        },
+    };
+}

package/dist/logger.test.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Unit tests for logger.ts — structured logging.
+ */
+const vitest_1 = require("vitest");
+const logger_1 = require("./logger");
+(0, vitest_1.describe)("createLogger", () => {
+    (0, vitest_1.it)("creates a logger with all log methods", () => {
+        const log = (0, logger_1.createLogger)("test");
+        (0, vitest_1.expect)(typeof log.debug).toBe("function");
+        (0, vitest_1.expect)(typeof log.info).toBe("function");
+        (0, vitest_1.expect)(typeof log.warn).toBe("function");
+        (0, vitest_1.expect)(typeof log.error).toBe("function");
+    });
+    (0, vitest_1.it)("returns a different logger per module name", () => {
+        const a = (0, logger_1.createLogger)("module-a");
+        const b = (0, logger_1.createLogger)("module-b");
+        (0, vitest_1.expect)(a).not.toBe(b);
+    });
+    (0, vitest_1.it)("log methods accept message and optional data", () => {
+        const log = (0, logger_1.createLogger)("test");
+        // Should not throw
+        log.info("hello");
+        log.info("with data", { key: "value" });
+        log.warn("warning");
+        log.error("error", new Error("boom"));
+        log.debug("debug message");
+    });
+    (0, vitest_1.it)("loggers are callable without throwing", () => {
+        const log = (0, logger_1.createLogger)("safety");
+        (0, vitest_1.expect)(() => log.info("msg")).not.toThrow();
+        (0, vitest_1.expect)(() => log.warn("msg")).not.toThrow();
+        (0, vitest_1.expect)(() => log.error("msg")).not.toThrow();
+        (0, vitest_1.expect)(() => log.debug("msg")).not.toThrow();
+    });
+});

package/dist/logistic-reward.js

@@ -0,0 +1,339 @@
+"use strict";
+/**
+ * P4.0: Logistic Reward Model
+ *
+ * Pure TypeScript logistic regression that predicts P(accepted)
+ * from 7 normalized features. Compatible with existing Ranker interface.
+ *
+ * Why logistic regression (not neural):
+ *   - Interpretable weights (auditable)
+ *   - Trains on ~1000 samples (neural needs 10K+)
+ *   - Same interface as LinearRanker / LearningRanker
+ *   - Weights directly tell you WHICH features drive acceptance
+ *
+ * Feature vector (all [0,1]):
+ *   1. protocolSafety
+ *   2. historicalSuccessRate
+ *   3. normActionCount     (actionCount / maxActions)
+ *   4. latencyCost
+ *   5. auditability
+ *   6. acceptanceRate      (from TelemetryIndex)
+ *   7. executionSuccessRate (from TelemetryIndex)
+ *
+ * Model:  P(accepted) = σ(w·x + b)
+ * Loss:   binary cross-entropy + L2 regularization
+ * Train:  mini-batch SGD
+ *
+ * Usage:
+ *   const model = LogisticRewardModel.train(telemetry, config);
+ *   const score = model.score(features, telemetryStats);
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogisticRewardModel = void 0;
+exports.compareModels = compareModels;
+const DEFAULT_CONFIG = {
+    learningRate: 0.01,
+    epochs: 200,
+    l2Lambda: 0.001,
+    batchSize: 32,
+    minSamples: 50,
+    convergenceThreshold: 1e-4,
+};
+// ═══════════════════════════════════════════════════════════════
+// Logistic Regression Implementation
+// ═══════════════════════════════════════════════════════════════
+function sigmoid(z) {
+    if (z > 20)
+        return 1.0;
+    if (z < -20)
+        return 0.0;
+    return 1.0 / (1.0 + Math.exp(-z));
+}
+function dot(a, b) {
+    return a.reduce((s, v, i) => s + v * b[i], 0);
+}
+function featureVecToArray(f) {
+    return [
+        f.protocolSafety,
+        f.historicalSuccessRate,
+        f.normActionCount,
+        f.latencyCost,
+        f.auditability,
+        f.acceptanceRate,
+        f.executionSuccessRate,
+    ];
+}
+const FEATURE_NAMES = [
+    "protocolSafety", "historicalSuccessRate", "normActionCount",
+    "latencyCost", "auditability", "acceptanceRate", "executionSuccessRate",
+];
+// ═══════════════════════════════════════════════════════════════
+// LogisticRewardModel
+// ═══════════════════════════════════════════════════════════════
+class LogisticRewardModel {
+    constructor(weights, bias, config) {
+        this.weights = weights || new Array(7).fill(0);
+        this.bias = bias || 0;
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.trained = weights !== undefined;
+        this.trainedSamples = 0;
+        this.loss = Infinity;
+    }
+    /** Predict P(accepted) from feature vector + telemetry stats. */
+    score(features, telemetryStats) {
+        const ts = telemetryStats || { acceptanceRate: 0.5, executionSuccessRate: 0.5 };
+        const maxActions = Math.max(features.actionCount, 8);
+        const fv = {
+            protocolSafety: features.protocolSafety,
+            historicalSuccessRate: features.historicalSuccessRate,
+            normActionCount: features.actionCount / maxActions,
+            latencyCost: features.latencyCost,
+            auditability: features.auditability,
+            acceptanceRate: ts.acceptanceRate,
+            executionSuccessRate: ts.executionSuccessRate,
+        };
+        return sigmoid(dot(this.weights, featureVecToArray(fv)) + this.bias);
+    }
+    /** Whether the model has been trained on sufficient data. */
+    get isTrained() { return this.trained; }
+    get sampleCount() { return this.trainedSamples; }
+    get finalLoss() { return this.loss; }
+    // ── Training ──
+    /** Train the model on telemetry data. */
+    static train(telemetry, config) {
+        const cfg = { ...DEFAULT_CONFIG, ...config };
+        const model = new LogisticRewardModel(undefined, undefined, cfg);
+        // Collect training samples from telemetry
+        const samples = LogisticRewardModel.collectSamples(telemetry);
+        if (samples.length < cfg.minSamples) {
+            // Not enough data — return untrained model (falls back to heuristic)
+            model.trainedSamples = samples.length;
+            return model;
+        }
+        // Normalize features
+        const normalized = LogisticRewardModel.normalizeSamples(samples);
+        // Initialize weights: small random values
+        let w = new Array(7).fill(0).map(() => (Math.random() - 0.5) * 0.1);
+        let b = 0.0;
+        let prevLoss = Infinity;
+        // Mini-batch SGD
+        for (let epoch = 0; epoch < cfg.epochs; epoch++) {
+            // Shuffle
+            const shuffled = [...normalized].sort(() => Math.random() - 0.5);
+            let totalLoss = 0;
+            for (let batchStart = 0; batchStart < shuffled.length; batchStart += cfg.batchSize) {
+                const batch = shuffled.slice(batchStart, batchStart + cfg.batchSize);
+                const [wGrad, bGrad] = LogisticRewardModel.computeGradients(batch, w, b, cfg.l2Lambda);
+                const loss = LogisticRewardModel.computeLoss(batch, w, b, cfg.l2Lambda);
+                totalLoss += loss;
+                // Update weights
+                for (let i = 0; i < 7; i++) {
+                    w[i] -= cfg.learningRate * wGrad[i];
+                }
+                b -= cfg.learningRate * bGrad;
+            }
+            const avgLoss = totalLoss / Math.ceil(shuffled.length / cfg.batchSize);
+            // Early stopping
+            if (Math.abs(prevLoss - avgLoss) < cfg.convergenceThreshold) {
+                break;
+            }
+            prevLoss = avgLoss;
+        }
+        model.weights.length = 0;
+        model.weights.push(...w);
+        model.bias = b;
+        model.trained = true;
+        model.trainedSamples = samples.length;
+        model.loss = prevLoss;
+        return model;
+    }
+    // ── Sample Collection ──
+    static collectSamples(telemetry) {
+        const samples = [];
+        const decisions = telemetry.all();
+        for (const d of decisions) {
+            if (!d.feedback || !d.selectedCandidateId)
+                continue;
+            const sel = d.candidates.find(c => c.candidateId === d.selectedCandidateId);
+            if (!sel || sel.actions.length === 0)
+                continue;
+            // Compute label: 1 = accepted AND executed successfully, 0 otherwise
+            const accepted = d.feedback.decision === "accepted";
+            const execOk = d.feedback.executionResult?.success !== false;
+            const label = (accepted && execOk) ? 1 : 0;
+            // Compute base features from the candidate
+            const actionCount = sel.actions.length;
+            const maxActions = Math.max(actionCount, 8);
+            // Get telemetry stats for this fingerprint
+            const fp = sel.candidateId;
+            const stats = telemetry.getCandidateStats(fp);
+            const acceptTotal = stats.accepted + stats.rejected;
+            const acceptanceRate = acceptTotal > 0 ? stats.accepted / acceptTotal : 0.5;
+            const execTotal = stats.executionSuccess + stats.executionFailure;
+            const executionSuccessRate = execTotal > 0 ? stats.executionSuccess / execTotal : 0.5;
+            // Compute protocolSafety heuristic
+            const safetyFromLength = Math.max(0, 1.0 - actionCount / 10);
+            samples.push({
+                features: {
+                    protocolSafety: safetyFromLength,
+                    historicalSuccessRate: 0.5,
+                    normActionCount: actionCount / maxActions,
+                    latencyCost: Math.min(1, actionCount / maxActions),
+                    auditability: 1.0 - actionCount / maxActions,
+                    acceptanceRate,
+                    executionSuccessRate,
+                },
+                label,
+            });
+        }
+        return samples;
+    }
+    // ── Normalization ──
+    static normalizeSamples(samples) {
+        // Features 0-5 are already [0,1]. Features 5,6 (acceptanceRate, executionSuccessRate) are also [0,1].
+        // No normalization needed — all features are already bounded.
+        return samples;
+    }
+    // ── Gradient Computation ──
+    static computeGradients(batch, w, b, l2Lambda) {
+        const wGrad = new Array(7).fill(0);
+        let bGrad = 0;
+        const n = batch.length;
+        if (n === 0)
+            return [wGrad, bGrad];
+        for (const sample of batch) {
+            const x = featureVecToArray(sample.features);
+            const z = dot(w, x) + b;
+            const yPred = sigmoid(z);
+            const error = yPred - sample.label;
+            for (let i = 0; i < 7; i++) {
+                wGrad[i] += error * x[i];
+            }
+            bGrad += error;
+        }
+        // Average gradients + L2 regularization on weights (not bias)
+        for (let i = 0; i < 7; i++) {
+            wGrad[i] = wGrad[i] / n + l2Lambda * w[i];
+        }
+        bGrad /= n;
+        return [wGrad, bGrad];
+    }
+    static computeLoss(batch, w, b, l2Lambda) {
+        let loss = 0;
+        const n = batch.length;
+        if (n === 0)
+            return 0;
+        for (const sample of batch) {
+            const x = featureVecToArray(sample.features);
+            const z = dot(w, x) + b;
+            const yPred = Math.max(1e-15, Math.min(1 - 1e-15, sigmoid(z))); // clip for numerical stability
+            const y = sample.label;
+            loss += -(y * Math.log(yPred) + (1 - y) * Math.log(1 - yPred));
+        }
+        loss /= n;
+        // L2 regularization (on weights only)
+        const l2Penalty = 0.5 * l2Lambda * w.reduce((s, wi) => s + wi * wi, 0);
+        return loss + l2Penalty;
+    }
+    // ── Interpretability ──
+    /** Return feature importance (absolute weight values, normalized). */
+    featureImportance() {
+        const absWeights = this.weights.map(Math.abs);
+        const total = absWeights.reduce((s, v) => s + v, 0) || 1;
+        return FEATURE_NAMES.map((name, i) => ({
+            name,
+            weight: this.weights[i],
+            importance: absWeights[i] / total,
+        })).sort((a, b) => b.importance - a.importance);
+    }
+    printWeights() {
+        console.log("\n─── LogisticRewardModel Weights ───");
+        console.log("Feature               Weight   Importance");
+        console.log("─────────────────────────────────────────");
+        const imp = this.featureImportance();
+        for (const f of imp) {
+            const w = f.weight.toFixed(4).padStart(8);
+            const pct = (f.importance * 100).toFixed(0).padStart(4);
+            console.log(`  ${f.name.padEnd(22)} ${w}   ${pct}%`);
+        }
+        console.log(`  bias: ${this.bias.toFixed(4)}`);
+        console.log(`  samples: ${this.trainedSamples} | loss: ${this.loss.toFixed(6)}`);
+        console.log();
+    }
+    /** Export weights for persistence. */
+    exportWeights() {
+        return {
+            weights: [...this.weights],
+            bias: this.bias,
+            trainedSamples: this.trainedSamples,
+            loss: this.loss,
+        };
+    }
+    /** Import weights from persistence. */
+    static importWeights(data, config) {
+        const model = new LogisticRewardModel(data.weights, data.bias, config);
+        model.trained = true;
+        model.trainedSamples = data.trainedSamples;
+        model.loss = data.loss;
+        return model;
+    }
+}
+exports.LogisticRewardModel = LogisticRewardModel;
+/**
+ * Compare LogisticRewardModel against LinearRanker and LearningRanker
+ * on held-out telemetry data.
+ */
+function compareModels(telemetry, testSplit = 0.3) {
+    const decisions = telemetry.all().filter(d => d.feedback && d.selectedCandidateId);
+    if (decisions.length < 20)
+        return [];
+    const testSize = Math.floor(decisions.length * testSplit);
+    const trainDecisions = decisions.slice(0, decisions.length - testSize);
+    const testDecisions = decisions.slice(decisions.length - testSize);
+    // Train LogisticRewardModel on training split
+    const model = LogisticRewardModel.train(telemetry);
+    // Evaluate all models on test split
+    const comparisons = [];
+    // LogisticRewardModel
+    if (model.isTrained) {
+        let correct = 0;
+        let logLoss = 0;
+        for (const d of testDecisions) {
+            const sel = d.candidates.find(c => c.candidateId === d.selectedCandidateId);
+            if (!sel)
+                continue;
+            const label = d.feedback.decision === "accepted" ? 1 : 0;
+            const stats = telemetry.getCandidateStats(sel.candidateId);
+            const acceptTotal = stats.accepted + stats.rejected;
+            const acceptanceRate = acceptTotal > 0 ? stats.accepted / acceptTotal : 0.5;
+            const execTotal = stats.executionSuccess + stats.executionFailure;
+            const executionSuccessRate = execTotal > 0 ? stats.executionSuccess / execTotal : 0.5;
+            const prediction = model.score({ protocolSafety: 0.8, historicalSuccessRate: 0.5, actionCount: sel.actions.length, latencyCost: 0.5, auditability: 0.5, corpusEvidence: 0, source: "protocol" }, { acceptanceRate, executionSuccessRate });
+            if ((prediction >= 0.5 ? 1 : 0) === label)
+                correct++;
+            const p = Math.max(1e-15, Math.min(1 - 1e-15, prediction));
+            logLoss += -(label * Math.log(p) + (1 - label) * Math.log(1 - p));
+        }
+        const n = testDecisions.length || 1;
+        comparisons.push({
+            model: "LogisticReward",
+            accuracy: correct / n,
+            auc: correct / n, // simplified: accuracy ≈ AUC for binary classification
+            logLoss: logLoss / n,
+            trained: true,
+        });
+    }
+    else {
+        comparisons.push({
+            model: "LogisticReward",
+            accuracy: 0, auc: 0, logLoss: Infinity, trained: false,
+        });
+    }
+    // Baseline: always predict majority class
+    const acceptedCount = testDecisions.filter(d => d.feedback.decision === "accepted").length;
+    const majorityRate = Math.max(acceptedCount, testDecisions.length - acceptedCount) / testDecisions.length;
+    comparisons.push({
+        model: "Baseline (majority)", accuracy: majorityRate, auc: 0.5, logLoss: Infinity, trained: false,
+    });
+    return comparisons;
+}