thumbgate 1.27.17 → 1.27.18

package/scripts/feedback-loop.js

@@ -56,90 +56,6 @@ const {
 
 const AUDIT_TRAIL_TAG = 'audit-trail';
 
-/**
- * Anonymous fire-and-forget CLI feedback telemetry.
- *
- * Pings the hosted /v1/telemetry/ping endpoint exactly once per successful
- * local feedback capture so the dashboard can measure CLI-side lesson volume.
- *
- * Hard contract (do NOT widen without explicit approval):
- *   - ONE event type: `feedback_captured`
- *   - Payload: { installId, signal: 'up'|'down', tier, ts } only.
- *     No context strings, tags, file paths, or content of any kind.
- *   - Opt-out: THUMBGATE_DISABLE_TELEMETRY=1 (or 'true') short-circuits
- *     immediately. Legacy THUMBGATE_NO_TELEMETRY=1 / DO_NOT_TRACK=1 are
- *     also honored for parity with cli-telemetry.js.
- *   - Fire-and-forget: NEVER await this call. Errors are swallowed.
- *   - 2-second timeout via AbortSignal.timeout.
- */
-function emitAnonymousFeedbackPing(signal) {
-  try {
-    const env = process.env || {};
-    if (
-      env.THUMBGATE_DISABLE_TELEMETRY === '1' ||
-      env.THUMBGATE_DISABLE_TELEMETRY === 'true' ||
-      env.THUMBGATE_NO_TELEMETRY === '1' ||
-      env.DO_NOT_TRACK === '1'
-    ) {
-      return;
-    }
-
-    const normalizedSignal = signal === 'positive' ? 'up' : signal === 'negative' ? 'down' : null;
-    if (!normalizedSignal) return;
-
-    // Reuse the canonical installId from cli-telemetry.js (persisted at
-    // ~/.thumbgate/install-id). Falls back to a fresh UUID if that module
-    // is unavailable — better to ship an event we can dedup on the server
-    // than to drop the ping entirely.
-    let installId = null;
-    try {
-      const { getInstallId } = require('./cli-telemetry');
-      installId = getInstallId();
-    } catch (_) { /* fall through */ }
-    if (!installId) {
-      try {
-        installId = require('crypto').randomUUID();
-      } catch (_) {
-        return; // no crypto, no install id → drop silently
-      }
-    }
-
-    let tier = 'free';
-    try {
-      const { getStatuslineMeta } = require('./statusline-meta');
-      const meta = getStatuslineMeta({ env });
-      const rawTier = String(meta && meta.tier ? meta.tier : 'free').toLowerCase();
-      if (rawTier === 'pro' || rawTier === 'enterprise' || rawTier === 'free') {
-        tier = rawTier;
-      }
-    } catch (_) { /* default to 'free' */ }
-
-    const base = env.THUMBGATE_PUBLIC_APP_ORIGIN
-      || env.THUMBGATE_API_URL
-      || 'https://thumbgate-production.up.railway.app';
-
-    const body = JSON.stringify({
-      eventType: 'feedback_captured',
-      clientType: 'cli',
-      installId,
-      signal: normalizedSignal,
-      tier,
-      ts: new Date().toISOString(),
-    });
-
-    // Fire-and-forget. No await. AbortSignal.timeout enforces the 2s cap.
-    if (typeof fetch !== 'function' || typeof AbortSignal === 'undefined' || typeof AbortSignal.timeout !== 'function') {
-      return;
-    }
-    fetch(`${base.replace(/\/+$/, '')}/v1/telemetry/ping`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body,
-      signal: AbortSignal.timeout(2000),
-    }).catch(() => { /* fire-and-forget */ });
-  } catch (_) { /* telemetry must never disrupt CLI */ }
-}
-
 function isAuditTrailEntry(entry = {}) {
   return Array.isArray(entry.tags) && entry.tags.includes(AUDIT_TRAIL_TAG);
 }
@@ -315,34 +231,6 @@ function getMemoryFirewallModule() {
   }
 }
 
-function launchSelfHarnessOptimizer() {
-  if (process.env.THUMBGATE_DISABLE_SELF_HARNESS_OPTIMIZER === '1') {
-    return { launched: false, reason: 'disabled' };
-  }
-
-  const explicitOptimizerPath = process.env.THUMBGATE_SELF_HARNESS_OPTIMIZER_PATH
-    ? path.resolve(process.env.THUMBGATE_SELF_HARNESS_OPTIMIZER_PATH)
-    : null;
-  const localOptimizerPath = path.join(process.cwd(), 'scripts', 'self-harness-optimizer.js');
-  const packageOptimizerPath = path.join(__dirname, 'self-harness-optimizer.js');
-  const optimizerPath = explicitOptimizerPath
-    || (fs.existsSync(localOptimizerPath) ? localOptimizerPath : null)
-    || (fs.existsSync(packageOptimizerPath) ? packageOptimizerPath : null);
-
-  if (!optimizerPath || !fs.existsSync(optimizerPath)) {
-    return { launched: false, reason: 'missing' };
-  }
-
-  const { spawn } = require('child_process');
-  const child = spawn(process.execPath, [optimizerPath], {
-    detached: true,
-    stdio: 'ignore',
-    env: process.env,
-  });
-  child.unref();
-  return { launched: true, path: optimizerPath };
-}
-
 
 function appendJSONL(filePath, record) {
   ensureDir(path.dirname(filePath));
@@ -1171,7 +1059,6 @@ function captureFeedback(params) {
         : null),
     structuredRule: structuredRule || null,
     ...(reflection && { reflection }),
-    gateAction: params.gateAction || null,
     timestamp: now,
   };
 
@@ -1225,7 +1112,6 @@ function captureFeedback(params) {
     summary.lastUpdated = now;
     saveSummary(summary);
     appendJSONL(FEEDBACK_LOG_PATH, feedbackEvent);
-    emitAnonymousFeedbackPing(signal);
     try { appendRejectionLedger(feedbackEvent, action.reason); } catch { /* non-critical */ }
     try {
       appendSequence(historyEntries, feedbackEvent, getFeedbackPaths(), { accepted: false });
@@ -1267,7 +1153,6 @@ function captureFeedback(params) {
       ...feedbackEvent,
       validationIssues: prepared.issues,
     });
-    emitAnonymousFeedbackPing(signal);
     try { appendRejectionLedger(feedbackEvent, `Schema validation failed: ${prepared.issues.join('; ')}`); } catch { /* non-critical */ }
     try {
       appendSequence(historyEntries, feedbackEvent, getFeedbackPaths(), { accepted: false });
@@ -1342,7 +1227,6 @@ function captureFeedback(params) {
   }
 
   appendJSONL(FEEDBACK_LOG_PATH, feedbackEvent);
-  emitAnonymousFeedbackPing(signal);
 
   // Synthesis: merge similar lessons instead of creating duplicates
   let synthesisResult = null;
@@ -1514,7 +1398,7 @@ function captureFeedback(params) {
   if (feedbackEvent.signal === 'negative') {
     try {
       const autoPromote = require('./auto-promote-gates');
-      const promoteResult = autoPromote.promote(FEEDBACK_LOG_PATH, { gateAction: feedbackEvent.gateAction });
+      const promoteResult = autoPromote.promote(FEEDBACK_LOG_PATH);
       // First-rule activation telemetry: anonymous ping the first time
       // a prevention rule auto-promotes for this install. Idempotent —
       // see scripts/activation-tracker.js. Critical for activation funnel
@@ -1527,38 +1411,10 @@ function captureFeedback(params) {
             totalGates: promoteResult.totalGates,
           });
         } catch { /* activation telemetry is non-critical */ }
-
-        // Trigger Self-Harness Optimizer to propagate the new rules to prompt
-        // files & validate. Use spawn instead of fork: fork creates an IPC
-        // pipe that keeps CLI feedback capture alive after the durable write.
-        try {
-          launchSelfHarnessOptimizer();
-        } catch (err) {
-          console.error('Failed to trigger self-harness optimizer:', err);
-        }
       }
     } catch { /* Gate promotion is non-critical */ }
   }
 
-  // Auto-export to Obsidian if configured (deferred but tracked)
-  if (process.env.THUMBGATE_OBSIDIAN_VAULT_PATH) {
-    const exportPromise = new Promise((resolve) => {
-      setImmediate(() => {
-        try {
-          const { exportAll } = require('./obsidian-export');
-          exportAll({
-            feedbackDir: FEEDBACK_DIR,
-            outputDir: process.env.THUMBGATE_OBSIDIAN_VAULT_PATH,
-          });
-        } catch (_err) {
-          // Non-critical, do not crash feedback loop
-        }
-        resolve();
-      });
-    });
-    trackBackgroundSideEffect(exportPromise);
-  }
-
   // --- Deferred side-effects (contextFs, RLAIF — non-critical, potentially slow) ---
   setImmediate(() => {
     try {

package/scripts/feedback-quality.js

@@ -62,92 +62,6 @@ function normalizeFeedbackText(value) {
     .trim();
 }
 
-function editDistance(a, b) {
-  const left = String(a || '');
-  const right = String(b || '');
-  const dp = Array.from({ length: left.length + 1 }, () => Array(right.length + 1).fill(0));
-  for (let i = 0; i <= left.length; i++) dp[i][0] = i;
-  for (let j = 0; j <= right.length; j++) dp[0][j] = j;
-  for (let i = 1; i <= left.length; i++) {
-    for (let j = 1; j <= right.length; j++) {
-      const cost = left[i - 1] === right[j - 1] ? 0 : 1;
-      dp[i][j] = Math.min(
-        dp[i - 1][j] + 1,
-        dp[i][j - 1] + 1,
-        dp[i - 1][j - 1] + cost,
-      );
-    }
-  }
-  return dp[left.length][right.length];
-}
-
-function isNearThumbToken(token) {
-  const value = String(token || '');
-  if (value.length < 4) return false;
-  return editDistance(value, 'thumb') <= 1 || editDistance(value, 'thumbs') <= 2;
-}
-
-function isNearUpToken(token) {
-  const value = String(token || '');
-  return value === 'up' || editDistance(value, 'up') <= 1;
-}
-
-function isNearDownToken(token) {
-  const value = String(token || '');
-  if (value.length < 2) return false;
-  return editDistance(value, 'down') <= 1;
-}
-
-function detectFeedbackSignal(value) {
-  const raw = String(value || '');
-  if (/[👎👎🏻👎🏼👎🏽👎🏾👎🏿]/u.test(raw)) return { signal: 'down', confidence: 'emoji', match: '👎' };
-  if (/[👍👍🏻👍🏼👍🏽👍🏾👍🏿]/u.test(raw)) return { signal: 'up', confidence: 'emoji', match: '👍' };
-
-  const normalized = normalizeFeedbackText(raw);
-  if (!normalized) return null;
-
-  const exactDown = [
-    /\bthumbs?\s*down\b/,
-    /\bthumbs?down\b/,
-    /\bthat failed\b/,
-    /\bit failed\b/,
-    /\bthat was wrong\b/,
-    /\bfix this\b/,
-  ];
-  if (exactDown.some((pattern) => pattern.test(normalized))) {
-    return { signal: 'down', confidence: 'exact', match: normalized };
-  }
-
-  const exactUp = [
-    /\bthumbs?\s*up\b/,
-    /\bthumbs?up\b/,
-    /\bthat worked\b/,
-    /\bit worked\b/,
-    /\blooks good\b/,
-    /\bgood job\b/,
-    /\bgood work\b/,
-    /\bnice work\b/,
-    /\bperfect\b/,
-    /\blgtm\b/,
-  ];
-  if (exactUp.some((pattern) => pattern.test(normalized))) {
-    return { signal: 'up', confidence: 'exact', match: normalized };
-  }
-
-  const words = normalized.split(/\s+/).filter(Boolean);
-  for (let i = 0; i < words.length - 1; i++) {
-    if (!isNearThumbToken(words[i])) continue;
-    if (isNearDownToken(words[i + 1])) {
-      return { signal: 'down', confidence: 'fuzzy', match: `${words[i]} ${words[i + 1]}` };
-    }
-    if (isNearUpToken(words[i + 1])) {
-      return { signal: 'up', confidence: 'fuzzy', match: `${words[i]} ${words[i + 1]}` };
-    }
-  }
-
-  return null;
-}
-
 function isGenericFeedbackText(value, signal) {
   const normalized = normalizeFeedbackText(value);
   if (!normalized) return false;
@@ -217,7 +131,6 @@ function buildClarificationMessage(params = {}) {
 
 module.exports = {
   GENERIC_PHRASE_RULES,
-  detectFeedbackSignal,
   normalizeFeedbackSignal,
   normalizeFeedbackText,
   isGenericFeedbackText,

package/scripts/filesystem-search.js

@@ -53,31 +53,10 @@ function listJsonFiles(dirPath) {
   return results;
 }
 
-const STOPWORDS = new Set([
-  'a', 'about', 'above', 'after', 'again', 'against', 'all', 'am', 'an', 'and', 'any', 'are', 'arent', 'as', 'at',
-  'be', 'because', 'been', 'before', 'being', 'below', 'between', 'both', 'but', 'by',
-  'cant', 'cannot', 'could', 'couldnt', 'did', 'didnt', 'do', 'does', 'doesnt', 'doing', 'dont', 'down', 'during',
-  'each', 'few', 'for', 'from', 'further', 'had', 'hadnt', 'has', 'hasnt', 'have', 'havent', 'having',
-  'he', 'hed', 'hell', 'hes', 'her', 'here', 'heres', 'hers', 'herself', 'him', 'himself', 'his',
-  'how', 'hows', 'i', 'id', 'ill', 'im', 'ive', 'if', 'in', 'into', 'is', 'isnt', 'it', 'its', 'itself',
-  'lets', 'me', 'more', 'most', 'mustnt', 'my', 'myself',
-  'no', 'nor', 'not', 'of', 'off', 'on', 'once', 'only', 'or', 'other', 'ought', 'our', 'ours', 'ourselves', 'out', 'over', 'own',
-  'same', 'shant', 'she', 'shed', 'shell', 'shes', 'should', 'shouldnt', 'so', 'some', 'such',
-  'than', 'that', 'thats', 'the', 'their', 'theirs', 'them', 'themselves', 'then', 'there', 'theres', 'these', 'they', 'theyd', 'theyll', 'theyre', 'theyve', 'this', 'those', 'through', 'to', 'too', 'under', 'until', 'up', 'very',
-  'was', 'wasnt', 'we', 'wed', 'well', 'were', 'weve', 'werent', 'what', 'whats', 'when', 'whens', 'where', 'wheres', 'which', 'while', 'who', 'whos', 'whom', 'why', 'whys',
-  'with', 'wont', 'would', 'wouldnt', 'you', 'youd', 'youll', 'youre', 'youve', 'your', 'yours', 'yourself', 'yourselves'
-]);
-
 function tokenize(text) {
   return String(text || '').toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
 }
 
-function getSearchTokens(queryText) {
-  const allTokens = tokenize(queryText);
-  const contentTokens = allTokens.filter(t => !STOPWORDS.has(t));
-  return contentTokens.length > 0 ? contentTokens : allTokens;
-}
-
 function unique(arr) {
   return [...new Set(arr)];
 }
@@ -103,7 +82,7 @@ function substringBoost(query, text) {
   const q = query.toLowerCase();
   const t = text.toLowerCase();
   if (t.includes(q)) return 0.3;
-  const words = q.split(/\s+/).filter((w) => w.length > 2 && !STOPWORDS.has(w));
+  const words = q.split(/\s+/).filter((w) => w.length > 2);
   const matched = words.filter((w) => t.includes(w)).length;
   return words.length > 0 ? (matched / words.length) * 0.2 : 0;
 }
@@ -138,12 +117,8 @@ function scoreRecord(queryTokens, queryText, record) {
   const recency = recencyScore(record.timestamp);
   const signalBoost = record.signal === 'down' ? 0.05 : 0;
 
-  const matchScore = jaccard + substr;
-  const isWildcard = !queryText || queryText === '*';
-  const score = isWildcard ? (recency + signalBoost || 0.01) : (matchScore > 0 ? matchScore + recency + signalBoost : 0);
-
   return {
-    score: Number(score.toFixed(4)),
+    score: jaccard + substr + recency + signalBoost,
     record,
     matchedTokens: unique(queryTokens).filter((t) => new Set(recordTokens).has(t)),
   };
@@ -154,7 +129,7 @@ function scoreRecord(queryTokens, queryText, record) {
 // ---------------------------------------------------------------------------
 
 function searchFeedbackLog(queryText, limit = 5, options = {}) {
-  const logPath = path.join(options.feedbackDir || getFeedbackDir(), 'feedback-log.jsonl');
+  const logPath = path.join(getFeedbackDir(), 'feedback-log.jsonl');
   let records = readJsonl(logPath);
 
   // SQLite fallback: if JSONL is empty/tiny, pull records from the lesson DB
@@ -181,7 +156,7 @@ function searchFeedbackLog(queryText, limit = 5, options = {}) {
 
   // Wildcard query: return all records sorted by recency
   const isWildcard = queryText === '*' || queryText === '';
-  const queryTokens = isWildcard ? [] : getSearchTokens(queryText);
+  const queryTokens = isWildcard ? [] : tokenize(queryText);
 
   let scored = isWildcard
     ? records.map((r) => ({ score: recencyScore(r.timestamp) || 0.01, record: r, matchedTokens: [] }))
@@ -211,9 +186,9 @@ function searchFeedbackLog(queryText, limit = 5, options = {}) {
 }
 
 function searchContextFs(queryText, limit = 5, options = {}) {
-  const contextDir = options.contextDir || (options.feedbackDir ? path.join(options.feedbackDir, 'contextfs') : getContextFsDir());
+  const contextDir = getContextFsDir();
   const namespaces = options.namespaces || ['memory/error', 'memory/learning', 'rules', 'raw_history'];
-  const queryTokens = getSearchTokens(queryText);
+  const queryTokens = tokenize(queryText);
   const scored = [];
 
   for (const ns of namespaces) {
@@ -246,12 +221,12 @@ function searchContextFs(queryText, limit = 5, options = {}) {
     }));
 }
 
-function searchPreventionRules(queryText, limit = 5, options = {}) {
-  const rulesPath = path.join(options.feedbackDir || getFeedbackDir(), 'prevention-rules.md');
+function searchPreventionRules(queryText, limit = 5) {
+  const rulesPath = path.join(getFeedbackDir(), 'prevention-rules.md');
   if (!fs.existsSync(rulesPath)) return [];
 
   const content = fs.readFileSync(rulesPath, 'utf-8');
-  const queryTokens = getSearchTokens(queryText);
+  const queryTokens = tokenize(queryText);
   const blocks = content.split(/^#{1,3}\s+/m).filter(Boolean);
 
   return blocks
@@ -277,7 +252,7 @@ function searchPreventionRules(queryText, limit = 5, options = {}) {
 function searchAll(queryText, limit = 10, options = {}) {
   const feedbackResults = searchFeedbackLog(queryText, limit, options);
   const contextResults = searchContextFs(queryText, limit, options);
-  const ruleResults = searchPreventionRules(queryText, limit, options);
+  const ruleResults = searchPreventionRules(queryText, limit);
 
   const merged = [
     ...feedbackResults.map((r) => ({ ...r, _source_type: 'feedback' })),

package/scripts/gate-stats.js

@@ -9,7 +9,6 @@ const { sequencePathFor } = require('./risk-scorer');
 
 const PROJECT_ROOT = path.join(__dirname, '..');
 const MANUAL_GATES_PATH = path.join(PROJECT_ROOT, 'config', 'gates', 'default.json');
-const STATS_PATH = path.join(process.env.HOME || '/tmp', '.thumbgate', 'gate-stats.json');
 
 function loadGatesFile(filePath) {
   if (!fs.existsSync(filePath)) return [];
@@ -66,15 +65,6 @@ function calculateStats() {
   // sample can produce a misleading 0.0% floor.
   const bayesErrorRate = tryComputeBayesErrorRate();
 
-  // Calibration: per-gate assessment of whether block actions are well-supported
-  // by negative feedback, or potentially over/under-blocking without confirmation.
-  const calibration = computeCalibration(allGates);
-
-  // First-time fix rate: 1 - (recurringBlocks / totalBlocksAndWarns)
-  // Measures how often a single gate fire resolves the issue vs the agent retrying.
-  // Returns null when there is no recorded block/warn data yet.
-  const firstTimeFixRate = computeFirstTimeFixRate();
-
   return {
     totalGates: allGates.length,
     manualGates: manualGates.length,
@@ -87,70 +77,10 @@ function calculateStats() {
     lastPromotion,
     estimatedHoursSaved,
     bayesErrorRate,
-    calibration,
-    firstTimeFixRate,
     gates: allGates,
   };
 }
 
-/**
- * Assess each gate's calibration by comparing block occurrences to confirmed
- * negative feedback counts. A gate with many blocks but no confirming negative
- * feedback may be over-blocking; one with matching feedback is well-calibrated.
- *
- * @param {Array} gates - Combined array of manual + auto-promoted gate objects
- * @returns {Array<{gateId: string, occurrences: number, action: string, calibrationNote: string}>}
- */
-function computeCalibration(gates) {
-  const calibration = [];
-  for (const gate of gates || []) {
-    if (!gate || !gate.id) continue;
-    const occurrences = Number(gate.occurrences || 0);
-    const action = gate.action || 'unknown';
-    // Only annotate gates with recorded occurrence data
-    if (occurrences === 0) continue;
-
-    if (action === 'block') {
-      const confirmedNegative = Number(gate.confirmedNegative || gate.negativeCount || 0);
-      let calibrationNote;
-      if (occurrences > 10 && confirmedNegative === 0) {
-        calibrationNote = `over-blocking (${occurrences} blocks, 0 confirmed)`;
-      } else if (confirmedNegative > 0) {
-        calibrationNote = `well-calibrated (${occurrences} blocks, ${confirmedNegative} confirmed)`;
-      } else {
-        // Low occurrence count with no feedback — not enough data yet
-        calibrationNote = `insufficient data (${occurrences} blocks, 0 confirmed)`;
-      }
-      calibration.push({ gateId: gate.id, occurrences, action, calibrationNote });
-    }
-  }
-  return calibration;
-}
-
-/**
- * Compute the first-time fix rate from the persisted gate-stats.json file.
- *
- * firstTimeFixRate = 1 - (recurringBlocks / totalBlocksAndWarns)
- *
- * Returns null when there are no recorded block/warn events yet.
- * Returns a number in [0, 1] otherwise, where 1.0 means every gate fire
- * was a first-time occurrence and 0.0 means every gate fired at least twice.
- */
-function computeFirstTimeFixRate() {
-  try {
-    if (!fs.existsSync(STATS_PATH)) return null;
-    const raw = fs.readFileSync(STATS_PATH, 'utf8');
-    const data = JSON.parse(raw);
-    const totalBlocksAndWarns = (data.blocked || 0) + (data.warned || 0);
-    if (totalBlocksAndWarns === 0) return null;
-    const recurring = data.recurringBlocks || 0;
-    const rate = 1 - (recurring / totalBlocksAndWarns);
-    return Math.max(0, Math.min(1, rate));
-  } catch {
-    return null;
-  }
-}
-
 function tryComputeBayesErrorRate() {
   try {
     const seqPath = sequencePathFor();
@@ -212,13 +142,6 @@ function formatStats(stats) {
   lines.push(`  Last promotion: ${formatLastPromotion(stats.lastPromotion)}`);
   lines.push(`  Estimated time saved: ~${stats.estimatedHoursSaved} hours`);
   lines.push(`  Bayes error rate: ${formatBayesErrorRate(stats.bayesErrorRate)}`);
-  lines.push(`  First-time fix rate: ${formatFirstTimeFixRate(stats.firstTimeFixRate)}`);
-  if (Array.isArray(stats.calibration) && stats.calibration.length > 0) {
-    lines.push('Calibration:');
-    for (const entry of stats.calibration) {
-      lines.push(`  - ${entry.gateId}: ${entry.calibrationNote}`);
-    }
-  }
   return lines.join('\n');
 }
 
@@ -230,14 +153,6 @@ function formatBayesErrorRate(rate) {
   return `${pct}% — high irreducible error; the feature set can't discriminate`;
 }
 
-function formatFirstTimeFixRate(rate) {
-  if (rate === null || rate === undefined) return 'n/a (no blocks or warns recorded yet)';
-  const pct = (rate * 100).toFixed(1);
-  if (rate >= 0.95) return `${pct}% — agents fix issues on first block (excellent)`;
-  if (rate >= 0.80) return `${pct}% — most blocks resolved first time (good)`;
-  return `${pct}% — recurring blocks detected; agents may be ignoring gate feedback`;
-}
-
 if (require.main === module) {
   try {
     const stats = calculateStats();
@@ -253,11 +168,7 @@ module.exports = {
   formatStats,
   formatLastPromotion,
   formatBayesErrorRate,
-  formatFirstTimeFixRate,
-  computeFirstTimeFixRate,
   loadGatesFile,
   tryComputeBayesErrorRate,
-  computeCalibration,
   MANUAL_GATES_PATH,
-  STATS_PATH,
 };