thumbgate 1.34.3 → 1.37.1

package/scripts/hybrid-feedback-context.js

@@ -176,13 +176,51 @@ function patternContext(entry) {
   return context;
 }
 
+/**
+ * Tags that mark capture/enforcement machinery, not a human judgment about an
+ * agent action. An entry carrying one of these is never a human lesson.
+ */
+const MACHINERY_FEEDBACK_TAGS = Object.freeze([
+  'auto-capture',
+  'gates-engine',
+  'audit-trail',
+]);
+
+/**
+ * Transport tags stamped by `scripts/claude-feedback-sync.js` on EVERY record
+ * it recovers from Claude history — bare "thumbs down" junk and rich human
+ * lessons alike. Bare rows were measured (2026-08-26) becoming the PreToolUse
+ * constraint `Avoid: "thumbs down claude-history-sync auto-capture-fallback"
+ * (seen 44x)`. Because the tags mark the transport rather than the content,
+ * they demote an entry to "automated" only when the recovered text is a bare
+ * signal with no described mistake; substantive repeated feedback such as
+ * "thumbs down: claimed merged without a SHA" must still rank.
+ */
+const HISTORY_SYNC_TRANSPORT_TAGS = Object.freeze([
+  'auto-capture-fallback',
+  'claude-history-sync',
+]);
+
+const BARE_SIGNAL_PREFIX_RE = /^(?:thumbs\s*(?:up|down)|👍|👎)[\s:,.!-]*/i;
+
+function isBareHistorySyncSignal(entry) {
+  if (String(entry.whatToChange || entry.what_to_change || '').trim()) return false;
+  const text = String(entry.context || entry.whatWentWrong || entry.what_went_wrong || '').trim();
+  if (!text) return true;
+  const stripped = text.replace(BARE_SIGNAL_PREFIX_RE, '').trim();
+  return stripped.length < 8;
+}
+
 /**
  * Check if the feedback entry is an automated enforcement log (e.g. from gates engine)
  * rather than real developer/user feedback.
  */
 function isAutomatedFeedback(entry) {
-  const tags = entry.tags || [];
-  if (tags.includes('auto-capture') || tags.includes('gates-engine') || tags.includes('audit-trail')) {
+  const tags = Array.isArray(entry.tags) ? entry.tags : [];
+  if (tags.some((tag) => MACHINERY_FEEDBACK_TAGS.includes(tag))) {
+    return true;
+  }
+  if (tags.some((tag) => HISTORY_SYNC_TRANSPORT_TAGS.includes(tag)) && isBareHistorySyncSignal(entry)) {
     return true;
   }
   const context = String(entry.context || entry.whatWentWrong || '').toLowerCase();
@@ -203,15 +241,51 @@ function getTimestampMs(value) {
  * Extract meaningful keywords from text.
  * min 4 chars, no stopwords, max 8 tokens.
  */
+// Hook payloads are JSON envelopes. When a malformed one leaks into the feedback
+// store, its FIELD NAMES become "keywords" — and field names appear in every
+// payload, so the resulting pattern matches every action ever taken. One corrupt
+// entry becomes a universal block.
+//
+// Observed 2026-08-06: a truncated payload fragment
+//   { , , ,"workspaceroot":"/users/<redacted>/workspace/git/igor/thumbgate/", , , ,"pe"
+// was admitted as a recurring negative pattern with count 6. "workspaceroot" is
+// long enough that isSpecificKeyword() treats it as decisive on its own, so a
+// SINGLE hit hard-denied every Bash call in the repository — including the
+// commands needed to diagnose it. It blocked 20 times and warned zero times.
+//
+// These tokens describe the transport, never the mistake, so they can never be
+// evidence of a recurring failure.
+const ENVELOPE_TOKENS = new Set([
+  'workspaceroot', 'toolname', 'toolinput', 'tooloutput', 'toolresponse', 'tooluseid',
+  'sessionid', 'transcriptpath', 'hookeventname', 'permissionmode', 'promptid',
+  'cwd', 'timestamp', 'metadata', 'payload', 'stdout', 'stderr',
+  'users', 'workspace', 'thumbgate', 'igor',
+]);
+
 function keywords(text) {
   if (!text) return [];
   const tokens = normalize(text)
     .replace(/[^a-z0-9\s_-]/g, ' ')
     .split(/\s+/)
-    .filter((t) => t.length >= 4 && !STOPWORDS.has(t));
+    .filter((t) => t.length >= 4 && !STOPWORDS.has(t) && !ENVELOPE_TOKENS.has(t));
   return [...new Set(tokens)].slice(0, 8);
 }
 
+/**
+ * True when text is a serialized payload fragment rather than a description of
+ * a mistake. Real lessons are prose; fragments are punctuation and field names.
+ * Admitting one as a pattern is how a transport artifact becomes a gate.
+ */
+function looksLikeSerializedFragment(text) {
+  const raw = String(text || '');
+  if (!raw.trim()) return false;
+  // Runs of empty JSON slots (", , ,") only occur when a serializer dropped keys.
+  if (/(?:,\s*){3,}/.test(raw)) return true;
+  const wordChars = (raw.match(/[a-z]/gi) || []).length;
+  const structural = (raw.match(/["{}[\]:,]/g) || []).length;
+  return wordChars > 0 && structural >= wordChars / 2;
+}
+
 /**
  * FNV-1a 32-bit hash.
  */
@@ -277,11 +351,12 @@ function buildHybridState(opts) {
     if (cls === 'positive') positive++;
     if (cls === 'negative') {
       negative++;
-      // Track tool-level negative counts (exclude automated gate logs)
-      if (!isAutomatedFeedback(entry)) {
-        const toolName = inferToolName(entry.toolName || entry.tool_name || 'unknown', entry.context || '');
-        toolNegatives[toolName] = (toolNegatives[toolName] || 0) + 1;
-      }
+      // History-sync fallback and gate logs still count as events, but they must
+      // not become recurring "Avoid" constraints injected on every PreToolUse.
+      if (isAutomatedFeedback(entry)) continue;
+
+      const toolName = inferToolName(entry.toolName || entry.tool_name || 'unknown', entry.context || '');
+      toolNegatives[toolName] = (toolNegatives[toolName] || 0) + 1;
 
       // Build pattern from context / whatWentWrong / what_went_wrong
       const rawText = [
@@ -346,6 +421,8 @@ function buildHybridState(opts) {
     ].join(' ');
     const norm = normalizePatternText(rawText);
     if (!norm) continue;
+    // A serialized payload fragment is a transport artifact, not a lesson.
+    if (looksLikeSerializedFragment(rawText) || looksLikeSerializedFragment(norm)) continue;
     const words = keywords(norm);
     if (words.length < 2) continue;
     const patKey = words.slice(0, 4).join('_');
@@ -520,23 +597,60 @@ function isSpecificKeyword(word) {
 // Whole-word matching: a bare includes() let "app" hit "apps/", "application" and "happen".
 // Boundaries are non-alphanumerics, so path and punctuation separators still delimit tokens
 // (`src/jobs/queue.js` matches the word "jobs").
+//
+// NVHBM-style optimization (2026-08-28): the previous implementation compiled a NEW RegExp
+// for every word on every call — per-tool-call "memory bandwidth" burned on regex construction
+// instead of matching. The boundary scan below is semantics-identical (same boundary class:
+// non-alphanumeric delimits the word) without any regex compilation, and never throws on
+// punctuation-heavy words.
+function isWordChar(ch) {
+  return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9');
+}
+
 function containsWholeWord(haystack, word) {
-  const escaped = String(word).replace(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
-  try {
-    return new RegExp(`(?:^|[^a-z0-9])${escaped}(?:[^a-z0-9]|$)`, 'i').test(haystack);
-  } catch {
-    return haystack.includes(word);
+  const hay = String(haystack == null ? '' : haystack).toLowerCase();
+  const w = String(word == null ? '' : word).toLowerCase();
+  if (!hay || !w) return false;
+  let idx = hay.indexOf(w);
+  while (idx !== -1) {
+    const before = idx === 0 ? '' : hay[idx - 1];
+    const afterIdx = idx + w.length;
+    const after = afterIdx >= hay.length ? '' : hay[afterIdx];
+    if (!isWordChar(before) && !isWordChar(after)) return true;
+    idx = hay.indexOf(w, idx + 1);
+  }
+  return false;
+}
+
+// Token membership is O(1) per word once the haystack is split, but splitting is O(n) —
+// callers that check many word lists against the SAME haystack (the guard loop) must pass
+// the precomputed set instead of letting each check re-split. Compound words (containing
+// '-' or '_') can never appear in the token set (splitting breaks on both), so they fall
+// back to the boundary scan — same rule isSpecificKeyword uses to treat them as strong hits.
+function buildHaystackTokens(normalizedInput) {
+  const tokens = new Set();
+  for (const token of String(normalizedInput || '').toLowerCase().split(/[^a-z0-9]+/)) {
+    if (token) tokens.add(token);
   }
+  return tokens;
 }
 
-function hasTwoKeywordHits(normalizedInput, words) {
+function hasTwoKeywordHits(normalizedInput, words, precomputedTokens) {
   if (!normalizedInput || !words || words.length === 0) return false;
+  const tokens = precomputedTokens || buildHaystackTokens(normalizedInput);
   let hits = 0;
   const seen = new Set();
   for (const word of words) {
     if (!word || seen.has(word)) continue;
     seen.add(word);
-    if (!containsWholeWord(normalizedInput, word)) continue;
+    // Pure-alphanumeric words are O(1) Set lookups against the precomputed token
+    // set. Anything with punctuation (compound words with '-'/'_', or any other
+    // symbol) can never equal a token, so it keeps the boundary scan — exactly
+    // the cases isSpecificKeyword treats as strong single-hit evidence.
+    const matched = /^[a-z0-9]+$/i.test(word)
+      ? tokens.has(word.toLowerCase())
+      : containsWholeWord(normalizedInput, word);
+    if (!matched) continue;
     // A specific compound/long token carries a match on its own; generic words need two.
     if (isSpecificKeyword(word)) return true;
     hits++;
@@ -640,6 +754,10 @@ function readGuardArtifact(filePath) {
 // evaluateCompiledGuards (fast path)
 // ---------------------------------------------------------------------------
 
+// Memoized normalize(guard.text) per guard object. WeakMap keeps artifacts
+// pristine (no added keys that would leak into JSON round-trips or deep-equals).
+const GUARD_NORM_TEXT_CACHE = new WeakMap();
+
 /**
  * Check compiled artifact against toolName + toolInput.
  *
@@ -655,12 +773,23 @@ function evaluateCompiledGuards(artifact, toolName, toolInput) {
 
   const normInput = normalizeActionText(buildMatchHaystack(toolInput));
   const normTool = (toolName || '').toLowerCase();
+  // NVHBM-style: hoist the O(n) haystack tokenization out of the per-guard loop
+  // (one split per call, O(1) membership per word). Guard-text normalization is
+  // memoized per guard object (WeakMap — no artifact mutation, no JSON leakage)
+  // so repeated evaluations of the same in-memory artifact pay it once.
+  const haystackTokens = buildHaystackTokens(normInput);
 
   for (const guard of artifact.guards) {
-    const guardText = normalize(guard.text || '');
-    const toolMentioned = guardText.includes(normTool) || normTool === 'unknown';
+    if (guard === null || typeof guard !== 'object') continue;
+    let normText = GUARD_NORM_TEXT_CACHE.get(guard);
+    if (normText === undefined) {
+      normText = normalize(guard.text || '');
+      GUARD_NORM_TEXT_CACHE.set(guard, normText);
+    }
+    const toolMentioned = normText.includes(normTool) || normTool === 'unknown';
 
-    const keywordMatch = hasTwoKeywordHits(normInput, guard.words || []);
+    const guardWords = Array.isArray(guard.words) ? guard.words : [];
+    const keywordMatch = hasTwoKeywordHits(normInput, guardWords, haystackTokens);
 
     // Match if: keyword hits in input, OR tool mentioned + high count.
     // Previously tool-name matching only worked for short inputs — this was
@@ -697,9 +826,11 @@ function evaluateCompiledGuards(artifact, toolName, toolInput) {
 function evaluatePretoolFromState(state, toolName, toolInput) {
   const normInput = normalizeActionText(buildMatchHaystack(toolInput));
   const normTool = (toolName || '').toLowerCase();
+  // Same NVHBM-style hoist as the compiled path: tokenize the haystack once.
+  const haystackTokens = buildHaystackTokens(normInput);
 
   for (const pattern of state.recurringNegativePatterns || []) {
-    if (hasTwoKeywordHits(normInput, pattern.words || [])) {
+    if (hasTwoKeywordHits(normInput, pattern.words || [], haystackTokens)) {
       const mode = pattern.count >= 3 ? 'block' : 'warn';
       return {
         mode,
@@ -861,9 +992,11 @@ module.exports = {
   inferToolName,
   classify,
   keywords,
+  looksLikeSerializedFragment,
   hashText,
   hasTwoKeywordHits,
   buildMatchHaystack,
+  buildHaystackTokens,
   normalizeActionText,
   isSpecificKeyword,
   containsWholeWord,