thumbgate 1.28.2 → 1.28.4

package/scripts/feedback-loop.js

@@ -57,11 +57,15 @@ const {
 }));
 
 const AUDIT_TRAIL_TAG = 'audit-trail';
-const FEEDBACK_EVENT_DEDUPE_WINDOW_MS = 30 * 1000;
+const FEEDBACK_EVENT_DEDUPE_WINDOW_MS = 5 * 60 * 1000;
 const FEEDBACK_EVENT_CLAIM_STALE_MS = 60 * 1000;
 const FEEDBACK_EVENT_CLAIM_WAIT_MS = 15 * 1000;
 const FEEDBACK_EVENT_CLAIM_POLL_MS = 25;
 
+function isSelfHarnessOptimizerEnabled(env = process.env) {
+  return /^(?:1|true)$/i.test(String(env.THUMBGATE_SELF_HARNESS_OPTIMIZER || '').trim());
+}
+
 /**
  * Anonymous fire-and-forget CLI feedback telemetry.
  *
@@ -90,7 +94,9 @@ function emitAnonymousFeedbackPing(signal) {
       return;
     }
 
-    const normalizedSignal = signal === 'positive' ? 'up' : signal === 'negative' ? 'down' : null;
+    let normalizedSignal = null;
+    if (signal === 'positive') normalizedSignal = 'up';
+    if (signal === 'negative') normalizedSignal = 'down';
     if (!normalizedSignal) return;
 
     // Reuse the canonical installId from cli-telemetry.js (persisted at
@@ -101,24 +107,24 @@ function emitAnonymousFeedbackPing(signal) {
     try {
       const { getInstallId } = require('./cli-telemetry');
       installId = getInstallId();
-    } catch (_) { /* fall through */ }
+    } catch {
+      installId = null;
+    }
     if (!installId) {
-      try {
-        installId = require('crypto').randomUUID();
-      } catch (_) {
-        return; // no crypto, no install id → drop silently
-      }
+      installId = crypto.randomUUID();
     }
 
     let tier = 'free';
     try {
       const { getStatuslineMeta } = require('./statusline-meta');
       const meta = getStatuslineMeta({ env });
-      const rawTier = String(meta && meta.tier ? meta.tier : 'free').toLowerCase();
+      const rawTier = String(meta?.tier || 'free').toLowerCase();
       if (rawTier === 'pro' || rawTier === 'enterprise' || rawTier === 'free') {
         tier = rawTier;
       }
-    } catch (_) { /* default to 'free' */ }
+    } catch {
+      tier = 'free';
+    }
 
     const base = env.THUMBGATE_PUBLIC_APP_ORIGIN
       || env.THUMBGATE_API_URL
@@ -137,13 +143,17 @@ function emitAnonymousFeedbackPing(signal) {
     if (typeof fetch !== 'function' || typeof AbortSignal === 'undefined' || typeof AbortSignal.timeout !== 'function') {
       return;
     }
-    fetch(`${base.replace(/\/+$/, '')}/v1/telemetry/ping`, {
+    let appOrigin = String(base);
+    while (appOrigin.endsWith('/')) appOrigin = appOrigin.slice(0, -1);
+    void fetch(`${appOrigin}/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 */ }
+    }).catch(() => undefined);
+  } catch {
+    return;
+  }
 }
 
 function isAuditTrailEntry(entry = {}) {
@@ -666,8 +676,11 @@ function parseFeedbackSourceTimestamp(value) {
  */
 function buildFeedbackSourceIdentity(input = {}) {
   const signal = normalizeSignal(input.signal);
-  const normalizedText = normalizeFeedbackText(input.promptText || input.context);
-  if (!signal || !normalizedText) return null;
+  if (!signal) return null;
+  // Emoji-only prompts normalize to no alphanumeric text. Preserve a stable,
+  // non-sensitive canonical value so duplicate 👍/👎 hook deliveries still
+  // share one source identity and cannot create duplicate feedback rows.
+  const normalizedText = normalizeFeedbackText(input.promptText || input.context) || `thumbs-${signal}`;
 
   const sessionHash = hashFeedbackSourcePart(input.sessionId);
   const promptIdHash = hashFeedbackSourcePart(input.promptId);
@@ -696,10 +709,10 @@ function buildFeedbackSourceIdentity(input = {}) {
 function normalizeFeedbackSourceIdentity(identity, params = {}) {
   if (!identity || typeof identity !== 'object' || typeof identity.key !== 'string') return null;
   const signal = normalizeSignal(params.signal || identity.signal);
+  if (!signal) return null;
   const normalizedText = normalizeFeedbackText(
     identity.normalizedText || params.context || params.whatWentWrong || params.whatWorked,
-  );
-  if (!signal || !normalizedText) return null;
+  ) || `thumbs-${signal}`;
 
   return {
     key: `fev_${hashFeedbackSourcePart(identity.key)}`,
@@ -781,6 +794,9 @@ function duplicateCaptureResult(receipt, paths, options = {}) {
   const memoryRecord = findRecordById(paths.MEMORY_LOG_PATH, receipt?.memoryId);
   return {
     accepted: Boolean(receipt?.accepted),
+    captured: Boolean(receipt?.signalLogged),
+    promoted: Boolean(receipt?.promoted),
+    promotionAccepted: Boolean(receipt?.promoted),
     signalLogged: Boolean(receipt?.signalLogged),
     duplicate: true,
     pending: Boolean(options.pending),
@@ -820,7 +836,8 @@ function receiptFromFeedbackEntry(entry, paths) {
     status: 'complete',
     feedbackId: entry.id,
     memoryId: memory?.id,
-    accepted: entry.actionType !== 'no-action'
+    accepted: !Array.isArray(entry.validationIssues) || entry.validationIssues.length === 0,
+    promoted: entry.actionType !== 'no-action'
       && (!Array.isArray(entry.validationIssues) || entry.validationIssues.length === 0),
     signalLogged: true,
     completedAtMs: Date.parse(entry.timestamp || '') || Date.now(),
@@ -888,6 +905,7 @@ function finalizeFeedbackEventClaim(claim, result) {
     startedAtMs: Date.now(),
     completedAtMs: Date.now(),
     accepted: Boolean(result?.accepted),
+    promoted: Boolean(result?.promoted || result?.memoryRecord),
     signalLogged: Boolean(result?.signalLogged || result?.feedbackEvent),
     feedbackId: result?.feedbackEvent?.id || null,
     memoryId: result?.memoryRecord?.id || null,
@@ -1481,12 +1499,15 @@ function captureFeedback(params) {
       trainAndPersistInterventionPolicy(FEEDBACK_DIR);
     } catch { /* non-critical */ }
     updateStatuslineWithLesson({
-      accepted: false,
+      accepted: true,
       signal,
       feedbackId: feedbackEvent.id,
     });
     return {
-      accepted: false,
+      accepted: true,
+      captured: true,
+      promoted: false,
+      promotionAccepted: false,
       signalLogged: true,
       status: clarification ? 'clarification_required' : 'rejected',
       reason: action.reason,
@@ -1692,6 +1713,9 @@ function captureFeedback(params) {
   // Build result immediately — all remaining side-effects are deferred
   const result = {
     accepted: true,
+    captured: true,
+    promoted: true,
+    promotionAccepted: true,
     status: 'promoted',
     message: 'Feedback promoted to reusable memory.',
     feedbackEvent,
@@ -1770,19 +1794,23 @@ function captureFeedback(params) {
           });
         } catch { /* activation telemetry is non-critical */ }
 
-        // Trigger Self-Harness Optimizer to propagate the new rules to prompt files & validate
-        try {
-          const { fork } = require('child_process');
-          const localOptimizerPath = path.join(process.cwd(), 'scripts', 'self-harness-optimizer.js');
-          const packageOptimizerPath = path.join(__dirname, 'self-harness-optimizer.js');
-          
-          if (fs.existsSync(localOptimizerPath)) {
-            fork(localOptimizerPath, [], { stdio: 'ignore', detached: true }).unref();
-          } else if (fs.existsSync(packageOptimizerPath)) {
-            fork(packageOptimizerPath, [], { stdio: 'ignore', detached: true }).unref();
+        // Prompt-file mutation and git commits are explicit opt-in side effects.
+        // Feedback capture must never detach an unrequested process that edits
+        // AGENTS.md/GEMINI.md merely because a negative rule was promoted.
+        if (isSelfHarnessOptimizerEnabled()) {
+          try {
+            const { fork } = require('node:child_process');
+            const localOptimizerPath = path.join(process.cwd(), 'scripts', 'self-harness-optimizer.js');
+            const packageOptimizerPath = path.join(__dirname, 'self-harness-optimizer.js');
+
+            if (fs.existsSync(localOptimizerPath)) {
+              fork(localOptimizerPath, [], { stdio: 'ignore', detached: true }).unref();
+            } else if (fs.existsSync(packageOptimizerPath)) {
+              fork(packageOptimizerPath, [], { stdio: 'ignore', detached: true }).unref();
+            }
+          } catch (err) {
+            console.error('Failed to trigger self-harness optimizer:', err);
           }
-        } catch (err) {
-          console.error('Failed to trigger self-harness optimizer:', err);
         }
       }
     } catch { /* Gate promotion is non-critical */ }
@@ -1798,8 +1826,9 @@ function captureFeedback(params) {
             feedbackDir: FEEDBACK_DIR,
             outputDir: process.env.THUMBGATE_OBSIDIAN_VAULT_PATH,
           });
-        } catch (_err) {
-          // Non-critical, do not crash feedback loop
+        } catch {
+          resolve();
+          return;
         }
         resolve();
       });
@@ -2416,10 +2445,10 @@ function runTests() {
       budgetCompliant: true,
     }),
   });
-  assert(!blocked.accepted, 'captureFeedback blocks unsafe positive promotion via rubric gate');
+  assert(blocked.accepted && blocked.promoted === false, 'captureFeedback stores but does not promote unsafe positive feedback');
 
   const bad = captureFeedback({ signal: 'down' });
-  assert(!bad.accepted, 'captureFeedback rejects vague negative feedback');
+  assert(bad.accepted && bad.promoted === false, 'captureFeedback stores vague negative feedback without promotion');
   assert(bad.needsClarification === true, 'captureFeedback requests clarification for vague negative feedback');
 
   const summary = feedbackSummary(5);
@@ -2489,6 +2518,7 @@ function buildCorrectiveActionsReminder(correctiveActions = []) {
 
 module.exports = {
   captureFeedback: captureFeedbackIdempotent,
+  emitAnonymousFeedbackPing,
   buildFeedbackSourceIdentity,
   compactMemories,
   buildCorrectiveActionsReminder,
@@ -2508,6 +2538,7 @@ module.exports = {
   updateStatuslineWithLesson,
   waitForBackgroundSideEffects,
   getPendingBackgroundSideEffectCount,
+  isSelfHarnessOptimizerEnabled,
   getFeedbackPaths,
   get FEEDBACK_LOG_PATH() {
     return getFeedbackPaths().FEEDBACK_LOG_PATH;

package/scripts/gates-engine.js

@@ -2003,7 +2003,12 @@ function evaluateMemoryGuard(toolName, toolInput = {}) {
   } else {
     guard = hybrid.evaluatePretool(toolName, serializedInput);
   }
-  if (!guard || guard.mode === 'allow') {
+  if (!guard || guard.mode !== 'block') {
+    return null;
+  }
+  const guardReason = String(guard.reason || '');
+  const contextualMatch = /^(?:Matched guard pattern|Recurring negative pattern)\b/i.test(guardReason);
+  if (!contextualMatch) {
     return null;
   }
 

package/scripts/lesson-embedding-index.js

@@ -0,0 +1,203 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Lesson Embedding Index — maintained dense index over the lesson corpus.
+ *
+ * Powers the dense half of hybrid retrieval in the per-action gating hot path.
+ * The gating path reads memory-log lessons and must surface past mistakes that
+ * are semantically related to the current action even when they share no
+ * keywords (paraphrase, synonym, different file path). Pure lexical scoring
+ * misses those; dense embeddings catch them.
+ *
+ * Design constraints:
+ *   - Embedding the whole corpus on every tool call is too expensive. We cache
+ *     document vectors keyed by `id + sha1(text)` in <feedbackDir>/lesson-embeddings.json.
+ *     Only the query is embedded per call; only new/changed lessons re-embed.
+ *   - The embedder is reused from vector-store.embed (Gemini -> local transformers
+ *     -> stub). No new embedding dependency.
+ *   - HONESTY: when no real embedder is available, callers must degrade to lexical.
+ *     We never synthesize fake (e.g. hash-based) vectors — that would be overclaiming.
+ *
+ * Zero hard dependency on LanceDB: this module only needs the embed() function.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const CACHE_FILE = 'lesson-embeddings.json';
+
+function resolveFeedbackDir(explicit) {
+  if (explicit) return explicit;
+  try {
+    const { resolveFeedbackDir: resolve } = require('./feedback-paths');
+    return resolve();
+  } catch {
+    return process.env.THUMBGATE_FEEDBACK_DIR || process.cwd();
+  }
+}
+
+function getCachePath(feedbackDir) {
+  return path.join(resolveFeedbackDir(feedbackDir), CACHE_FILE);
+}
+
+/** Canonical text for a lesson record (title + content + tags). */
+function lessonText(lesson) {
+  if (!lesson) return '';
+  return [
+    lesson.title || '',
+    lesson.content || '',
+    Array.isArray(lesson.tags) ? lesson.tags.join(' ') : '',
+  ].filter(Boolean).join(' ').trim();
+}
+
+/**
+ * Truncate a vector to a specific dimension (Matryoshka Embedding Truncation).
+ * Assumes the model supports MRL (like text-embedding-3 or modern transformers).
+ */
+function truncateVector(vector, dimension) {
+  if (!Array.isArray(vector) || !dimension || vector.length <= dimension) {
+    return vector;
+  }
+  return vector.slice(0, dimension);
+}
+
+function hashText(text) {
+  // Content-change key for the embedding cache (not a security context). sha256
+  // matches the repo's standard non-security hashing and avoids the weak-hash flag.
+  return crypto.createHash('sha256').update(String(text || '')).digest('hex');
+}
+
+function cosineSimilarity(a, b) {
+  if (!Array.isArray(a) || !Array.isArray(b) || a.length === 0 || a.length !== b.length) {
+    return 0;
+  }
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    const x = Number(a[i]) || 0;
+    const y = Number(b[i]) || 0;
+    dot += x * y;
+    normA += x * x;
+    normB += y * y;
+  }
+  if (normA === 0 || normB === 0) return 0;
+  return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+
+/**
+ * Is a real embedder available? Used so callers can decide hybrid vs lexical-only
+ * WITHOUT loading a model. Returns true for the deterministic stub (test/CI safe).
+ */
+function isEmbedderAvailable() {
+  if (process.env.THUMBGATE_VECTOR_STUB_EMBED === 'true') return true;
+  // Managed Gemini path
+  try {
+    const { resolveGeminiEmbeddingConfig } = require('./gemini-embedding-policy');
+    const cfg = resolveGeminiEmbeddingConfig();
+    if (cfg && cfg.enabled && cfg.apiKey) return true;
+  } catch { /* policy module unavailable */ }
+  // Local transformers path
+  try {
+    require.resolve('@huggingface/transformers');
+    return true;
+  } catch { /* not installed */ }
+  return false;
+}
+
+function defaultEmbedder() {
+  // Lazy: do not pull in LanceDB/transformers at module require time.
+  const { embed } = require('./vector-store');
+  return embed;
+}
+
+function readCache(cachePath) {
+  try {
+    const raw = fs.readFileSync(cachePath, 'utf8');
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === 'object' ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function writeCache(cachePath, cache) {
+  try {
+    fs.mkdirSync(path.dirname(cachePath), { recursive: true });
+    fs.writeFileSync(cachePath, JSON.stringify(cache));
+  } catch {
+    /* cache is best-effort; never throw into the hot path */
+  }
+}
+
+/**
+ * Rank lessons by dense (embedding) similarity to the query.
+ * Returns [{ id, score }] sorted descending. Embeds the query once; reuses cached
+ * document vectors and only embeds new/changed lessons.
+ *
+ * @returns {Promise<Array<{id:string, score:number}>>}
+ */
+async function semanticRank(queryText, lessons = [], options = {}) {
+  const { feedbackDir, embedder = defaultEmbedder(), persist = true, truncateDimension = null } = options;
+  if (!queryText || !Array.isArray(lessons) || lessons.length === 0) return [];
+
+  const cachePath = getCachePath(feedbackDir);
+  const cache = readCache(cachePath);
+  let cacheDirty = false;
+
+  let queryVector = await embedder(queryText, { kind: 'query', task: 'code retrieval' });
+  if (!Array.isArray(queryVector) || queryVector.length === 0) return [];
+  
+  if (truncateDimension) {
+    queryVector = truncateVector(queryVector, truncateDimension);
+  }
+
+  const scored = [];
+  for (const lesson of lessons) {
+    if (!lesson || !lesson.id) continue;
+    const text = lessonText(lesson);
+    if (!text) continue;
+    const hash = hashText(text);
+
+    let entry = cache[lesson.id];
+    if (!entry || entry.hash !== hash || !Array.isArray(entry.vector)) {
+      const vector = await embedder(text, {
+        kind: 'document',
+        task: 'code retrieval',
+        title: lesson.title || undefined,
+      });
+      if (!Array.isArray(vector) || vector.length === 0) continue;
+      entry = { hash, vector };
+      cache[lesson.id] = entry;
+      cacheDirty = true;
+    }
+
+    const docVector = truncateDimension ? truncateVector(entry.vector, truncateDimension) : entry.vector;
+    scored.push({ id: lesson.id, score: cosineSimilarity(queryVector, docVector) });
+  }
+
+  // Prune cache entries for lessons no longer present (bounded growth).
+  const liveIds = new Set(lessons.map((l) => l && l.id).filter(Boolean));
+  for (const id of Object.keys(cache)) {
+    if (!liveIds.has(id)) {
+      delete cache[id];
+      cacheDirty = true;
+    }
+  }
+
+  if (persist && cacheDirty) writeCache(cachePath, cache);
+
+  return scored.sort((a, b) => b.score - a.score);
+}
+
+module.exports = {
+  semanticRank,
+  isEmbedderAvailable,
+  cosineSimilarity,
+  truncateVector,
+  lessonText,
+  hashText,
+  getCachePath,
+};