thumbgate 0.9.9

package/scripts/feedback-session.js

@@ -0,0 +1,286 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Feedback Sessions
+ *
+ * When a user gives thumbs up/down, a session opens. Follow-up messages
+ * within a time window enrich the session. When the window closes,
+ * the full context is used to infer the lesson.
+ *
+ * Flow:
+ * 1. User gives 👎 → openSession() → returns sessionId
+ * 2. User types "you lied about X" → appendToSession(sessionId, message)
+ * 3. User types "you forgot Y" → appendToSession(sessionId, message)
+ * 4. 60s passes OR next assistant response → finalizeSession(sessionId)
+ * 5. Lesson is re-inferred with ALL follow-up context
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { buildStableId } = require('./conversation-context');
+
+const SESSION_TIMEOUT_MS = 60000; // 60 seconds
+const MAX_FOLLOWUP_MESSAGES = 20;
+
+// In-memory store for active sessions (keyed by sessionId)
+const activeSessions = new Map();
+
+function scheduleTimer(callback, timeoutMs) {
+  const handle = setTimeout(callback, timeoutMs);
+  if (typeof handle.unref === 'function') {
+    handle.unref();
+  }
+  return handle;
+}
+
+function resetSessionTimer(sessionId, session) {
+  if (session.timeoutHandle) {
+    clearTimeout(session.timeoutHandle);
+  }
+  session.timeoutHandle = scheduleTimer(() => {
+    if (session.status === 'open') {
+      finalizeSession(sessionId);
+    }
+  }, SESSION_TIMEOUT_MS);
+}
+
+/**
+ * Open a new feedback session after a thumbs up/down signal.
+ * The session stays open for follow-up messages.
+ */
+function openSession(feedbackEventId, signal, initialContext) {
+  const sessionId = buildStableId('fbs');
+
+  const session = {
+    sessionId,
+    feedbackEventId,
+    signal,
+    initialContext: initialContext || '',
+    followUpMessages: [],
+    openedAt: new Date().toISOString(),
+    status: 'open',
+    timeoutHandle: null,
+    finalizedAt: null,
+  };
+
+  resetSessionTimer(sessionId, session);
+
+  activeSessions.set(sessionId, session);
+
+  return {
+    sessionId,
+    status: 'open',
+    message: `Feedback session opened. Follow-up messages will be captured for ${SESSION_TIMEOUT_MS / 1000}s.`,
+    expiresAt: new Date(Date.now() + SESSION_TIMEOUT_MS).toISOString(),
+  };
+}
+
+/**
+ * Append a follow-up message to an open session.
+ * Called when user types additional context after thumbs up/down.
+ */
+function appendToSession(sessionId, message, role = 'user') {
+  const session = activeSessions.get(sessionId);
+  if (!session) {
+    return { status: 'not_found', message: `No active session: ${sessionId}` };
+  }
+  if (session.status !== 'open') {
+    return { status: 'closed', message: `Session already finalized at ${session.finalizedAt}` };
+  }
+  if (session.followUpMessages.length >= MAX_FOLLOWUP_MESSAGES) {
+    return { status: 'full', message: `Session has reached max ${MAX_FOLLOWUP_MESSAGES} messages` };
+  }
+
+  session.followUpMessages.push({
+    role,
+    content: (message || '').slice(0, 1000), // Cap per-message
+    timestamp: new Date().toISOString(),
+  });
+
+  resetSessionTimer(sessionId, session);
+
+  return {
+    status: 'appended',
+    messageCount: session.followUpMessages.length,
+    sessionId,
+  };
+}
+
+/**
+ * Finalize a session — collect all follow-up messages and re-infer the lesson.
+ * Called automatically after timeout, or manually when assistant responds.
+ */
+function finalizeSession(sessionId) {
+  const session = activeSessions.get(sessionId);
+  if (!session) {
+    return { status: 'not_found' };
+  }
+  if (session.status !== 'open') {
+    return { status: 'already_finalized', finalizedAt: session.finalizedAt };
+  }
+
+  // Clear timeout
+  if (session.timeoutHandle) {
+    clearTimeout(session.timeoutHandle);
+    session.timeoutHandle = null;
+  }
+
+  session.status = 'finalized';
+  session.finalizedAt = new Date().toISOString();
+
+  // Build the enriched context from follow-up messages
+  const followUpText = session.followUpMessages
+    .filter(m => m.role === 'user')
+    .map(m => m.content)
+    .join('\n');
+
+  const enrichedContext = session.initialContext
+    ? `${session.initialContext}\n\nFollow-up:\n${followUpText}`
+    : followUpText;
+
+  // Extract specific complaints/corrections from follow-ups
+  const complaints = extractComplaints(session.followUpMessages);
+
+  const result = {
+    status: 'finalized',
+    sessionId,
+    feedbackEventId: session.feedbackEventId,
+    signal: session.signal,
+    enrichedContext,
+    followUpMessages: session.followUpMessages,
+    followUpCount: session.followUpMessages.length,
+    complaints,
+    duration: new Date(session.finalizedAt) - new Date(session.openedAt),
+    openedAt: session.openedAt,
+    finalizedAt: session.finalizedAt,
+  };
+
+  // Persist to disk for durability
+  try {
+    persistSession(result);
+  } catch (_err) { /* non-critical */ }
+
+  // Clean up from active sessions after a delay (allow reads)
+  scheduleTimer(() => activeSessions.delete(sessionId), 5000);
+
+  return result;
+}
+
+/**
+ * Extract specific complaints/corrections from follow-up messages.
+ * These are the actual lesson content.
+ */
+function extractComplaints(messages) {
+  const complaints = [];
+
+  for (const msg of messages) {
+    if (msg.role !== 'user') continue;
+    const content = msg.content || '';
+
+    const matches = extractComplaintMatches(content);
+    complaints.push(...matches.map((match) => ({
+      type: match.type,
+      detail: match.detail,
+      source: content.slice(0, 100),
+      timestamp: msg.timestamp,
+    })));
+
+    if (matches.length === 0 && isGeneralFrustration(content)) {
+      complaints.push({
+        type: 'general-frustration',
+        detail: content.slice(0, 200),
+        source: content.slice(0, 100),
+        timestamp: msg.timestamp,
+      });
+    }
+  }
+
+  return complaints;
+}
+
+function extractComplaintMatches(content) {
+  const normalized = String(content || '').trim();
+  const lower = normalized.toLowerCase();
+  if (!lower) return [];
+
+  const phraseSets = [
+    { type: 'dishonesty', phrases: ['you lied about ', 'you lying about ', 'you lied to me about '] },
+    { type: 'omission', phrases: ['you didn\'t ', 'you did not ', 'you forgot to ', 'you failed to ', 'you never '] },
+    { type: 'damage', phrases: ['you broke ', 'you ruined ', 'you messed up ', 'you screwed up '] },
+    { type: 'quality', phrases: ['wrong ', 'incorrect ', 'bad ', 'terrible ', 'stupid '] },
+    { type: 'ignored-instruction', phrases: ['i said ', 'i told you ', 'i asked you to '] },
+    { type: 'constraint', phrases: ['don\'t ', 'do not ', 'never ', 'stop '] },
+    { type: 'missed-expectation', phrases: ['should have ', 'should\'ve ', 'why didn\'t you '] },
+    { type: 'performance', phrases: ['too slow', 'took too long', 'waste of time', '5 minutes'] },
+  ];
+
+  const matches = [];
+  for (const entry of phraseSets) {
+    for (const phrase of entry.phrases) {
+      const index = lower.indexOf(phrase);
+      if (index === -1) continue;
+      const start = index + phrase.length;
+      const detail = normalized.slice(start).trim().slice(0, 200);
+      matches.push({
+        type: entry.type,
+        detail: detail || phrase.trim(),
+      });
+      break;
+    }
+  }
+  return matches;
+}
+
+function isGeneralFrustration(content) {
+  const lower = String(content || '').toLowerCase();
+  return lower.includes('!!')
+    || lower.includes('fuck')
+    || lower.includes('shit')
+    || lower.includes('stupid')
+    || lower.includes('terrible')
+    || lower.includes('wrong')
+    || lower.includes('bad')
+    || lower.includes('lied');
+}
+
+/**
+ * Get an active session by ID
+ */
+function getSession(sessionId) {
+  return activeSessions.get(sessionId) || null;
+}
+
+/**
+ * Get the most recent open session (if any)
+ */
+function getActiveSession() {
+  for (const [, session] of activeSessions) {
+    if (session.status === 'open') return session;
+  }
+  return null;
+}
+
+/**
+ * Persist finalized session to disk
+ */
+function persistSession(result) {
+  const { getFeedbackPaths, appendJSONL } = require('./feedback-loop');
+  const paths = getFeedbackPaths();
+  const sessionLogPath = path.join(path.dirname(paths.FEEDBACK_LOG_PATH), 'feedback-sessions.jsonl');
+  appendJSONL(sessionLogPath, result);
+}
+
+module.exports = {
+  openSession,
+  appendToSession,
+  finalizeSession,
+  getSession,
+  getActiveSession,
+  extractComplaints,
+  SESSION_TIMEOUT_MS,
+  MAX_FOLLOWUP_MESSAGES,
+  scheduleTimer,
+  // For testing
+  _activeSessions: activeSessions,
+};

package/scripts/feedback-to-memory.js

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+/**
+ * Feedback → Memory Bridge
+ *
+ * Converts raw feedback params into a schema-validated memory object
+ * suitable for mcp__memory__remember. This is the validation boundary
+ * between external feedback signals and MCP memory storage.
+ *
+ * Usage:
+ *   echo '{"signal":"negative","context":"...","whatWentWrong":"...","tags":["testing"]}' | node scripts/feedback-to-memory.js
+ *   node scripts/feedback-to-memory.js --test
+ *
+ * Input (stdin JSON):
+ *   signal: "positive" | "negative"
+ *   context: string — what the agent was doing
+ *   whatWentWrong: string — for negative: what failed
+ *   whatToChange: string — for negative: how to avoid
+ *   whatWorked: string — for positive: the pattern to repeat
+ *   tags: string[] — optional domain tags; a fallback domain tag is inferred when omitted
+ *
+ * Output (stdout JSON):
+ *   { ok: true, memory: { title, content, category, importance, tags } }
+ *   { ok: false, reason: string, issues?: string[] }
+ */
+'use strict';
+
+const { resolveFeedbackAction, prepareForStorage } = require('./feedback-schema');
+const { buildClarificationMessage } = require('./feedback-quality');
+
+function convertFeedbackToMemory(params) {
+  const action = resolveFeedbackAction({
+    signal: params.signal,
+    context: params.context || '',
+    whatWentWrong: params.whatWentWrong,
+    whatToChange: params.whatToChange,
+    whatWorked: params.whatWorked,
+    tags: params.tags || [],
+  });
+
+  if (!action || action.type === 'no-action') {
+    const clarification = buildClarificationMessage({
+      signal: params.signal,
+      context: params.context || '',
+      whatWentWrong: params.whatWentWrong,
+      whatToChange: params.whatToChange,
+      whatWorked: params.whatWorked,
+    });
+    return {
+      ok: false,
+      reason: action ? action.reason : 'Unknown action resolution failure',
+      ...(clarification || {}),
+    };
+  }
+
+  const prep = prepareForStorage(action.memory);
+  if (!prep.ok) {
+    return { ok: false, reason: `Schema validation failed: ${prep.issues.join('; ')}`, issues: prep.issues };
+  }
+
+  return { ok: true, actionType: action.type, memory: prep.memory };
+}
+
+// ---------------------------------------------------------------------------
+// CLI: stdin mode
+// ---------------------------------------------------------------------------
+
+function runStdin() {
+  let input = '';
+  process.stdin.setEncoding('utf-8');
+  process.stdin.on('data', (chunk) => { input += chunk; });
+  process.stdin.on('end', () => {
+    try {
+      const params = JSON.parse(input.trim());
+      const result = convertFeedbackToMemory(params);
+      process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+      process.exit(result.ok ? 0 : 2);
+    } catch (err) {
+      process.stdout.write(JSON.stringify({ ok: false, reason: `Parse error: ${err.message}` }, null, 2) + '\n');
+      process.exit(1);
+    }
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Built-in Tests
+// ---------------------------------------------------------------------------
+
+function runTests() {
+  let passed = 0;
+  let failed = 0;
+
+  function assert(condition, name) {
+    if (condition) {
+      passed++;
+      console.log(`  ✅ ${name}`);
+    } else {
+      failed++;
+      console.log(`  ❌ ${name}`);
+    }
+  }
+
+  console.log('\n🧪 feedback-to-memory.js — Tests\n');
+
+  // Valid negative feedback → memory
+  const neg = convertFeedbackToMemory({
+    signal: 'negative',
+    context: 'Agent claimed fix without test evidence',
+    whatWentWrong: 'No tests were run before claiming the bug was fixed',
+    whatToChange: 'Always run tests and show output before claiming done',
+    tags: ['verification', 'testing'],
+  });
+  assert(neg.ok === true, 'valid negative → ok');
+  assert(neg.actionType === 'store-mistake', 'negative → store-mistake');
+  assert(neg.memory.title.startsWith('MISTAKE:'), 'negative → MISTAKE: prefix');
+  assert(neg.memory.category === 'error', 'negative → error category');
+  assert(neg.memory.tags.includes('verification'), 'preserves domain tags');
+
+  // Valid positive feedback → memory
+  const pos = convertFeedbackToMemory({
+    signal: 'positive',
+    whatWorked: 'Built schema-validated feedback system with prevention rules',
+    tags: ['architecture', 'rlhf'],
+  });
+  assert(pos.ok === true, 'valid positive → ok');
+  assert(pos.actionType === 'store-learning', 'positive → store-learning');
+  assert(pos.memory.title.startsWith('SUCCESS:'), 'positive → SUCCESS: prefix');
+  assert(pos.memory.category === 'learning', 'positive → learning category');
+
+  const inferredPos = convertFeedbackToMemory({
+    signal: 'positive',
+    context: 'ThumbGate automation and Claude statusline repair',
+    whatWorked: 'Verified the live ThumbGate version and fixed the stale Claude statusline wiring',
+  });
+  assert(inferredPos.ok === true, 'specific positive without tags → ok');
+  assert(inferredPos.memory.tags.includes('thumbgate'), 'infers a non-generic domain tag');
+
+  // Bare thumbs down → rejected
+  const bare = convertFeedbackToMemory({ signal: 'negative' });
+  assert(bare.ok === false, 'bare negative → rejected');
+  assert(bare.reason.includes('No context') || bare.reason.includes('cannot'), 'reports missing context');
+
+  // Bare thumbs up → rejected
+  const bareUp = convertFeedbackToMemory({ signal: 'positive' });
+  assert(bareUp.ok === false, 'bare positive → rejected');
+
+  // Unknown signal → rejected
+  const unknown = convertFeedbackToMemory({ signal: 'maybe', context: 'test' });
+  assert(unknown.ok === false, 'unknown signal → rejected');
+
+  // Context-only negative → ok
+  const ctxNeg = convertFeedbackToMemory({
+    signal: 'negative',
+    context: 'Showed fake ThumbGate statistics panel to user',
+    tags: ['rlhf'],
+  });
+  assert(ctxNeg.ok === true, 'context-only negative → ok');
+
+  // Context-only positive → ok
+  const ctxPos = convertFeedbackToMemory({
+    signal: 'positive',
+    context: 'Ran full test suite and showed green output before responding',
+    tags: ['verification'],
+  });
+  assert(ctxPos.ok === true, 'context-only positive → ok');
+
+  console.log(`\n${'═'.repeat(50)}`);
+  console.log(`Results: ${passed} passed, ${failed} failed, ${passed + failed} total`);
+  console.log(`${'═'.repeat(50)}\n`);
+
+  process.exit(failed > 0 ? 1 : 0);
+}
+
+// ---------------------------------------------------------------------------
+// Exports & main
+// ---------------------------------------------------------------------------
+
+module.exports = { convertFeedbackToMemory };
+
+if (require.main === module) {
+  if (process.argv.includes('--test')) {
+    runTests();
+  } else {
+    runStdin();
+  }
+}

package/scripts/feedback-to-rules.js

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const { getAutoGatesPath } = require('./auto-promote-gates');
+const { resolveFeedbackDir } = require('./feedback-paths');
+
+const DEFAULT_LOG = path.join(resolveFeedbackDir(), 'feedback-log.jsonl');
+const NEG = new Set(['negative', 'negative_strong', 'down', 'thumbs_down']);
+const POS = new Set(['positive', 'positive_strong', 'up', 'thumbs_up']);
+
+function parseFeedbackFile(filePath) {
+  if (!fs.existsSync(filePath)) return [];
+  const entries = [];
+  for (const line of fs.readFileSync(filePath, 'utf8').split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try { entries.push(JSON.parse(trimmed)); } catch { /* skip malformed */ }
+  }
+  return entries;
+}
+
+function classifySignal(entry) {
+  const sig = (entry.signal || entry.feedback || '').toLowerCase();
+  if (NEG.has(sig)) return 'negative';
+  if (POS.has(sig)) return 'positive';
+  return null;
+}
+
+function normalize(ctx) {
+  return (ctx || '').replace(/\/Users\/[^\s/]+/g, '~').replace(/:[0-9]+/g, '').toLowerCase().trim();
+}
+
+const HIGH_RISK_TAGS = new Set(['git-workflow', 'scope-control', 'trust-breach', 'execution-gap', 'regression', 'security']);
+function analyze(entries) {
+  let positiveCount = 0, negativeCount = 0;
+  const categories = {};
+  const toolBuckets = {};
+  const contextCounts = {};
+
+  for (const e of entries) {
+    const cls = classifySignal(e);
+    if (!cls) continue;
+    cls === 'positive' ? positiveCount++ : negativeCount++;
+
+    const cat = e.task_category || e.category || 'uncategorized';
+    categories[cat] = categories[cat] || { positive: 0, negative: 0, total: 0 };
+    categories[cat][cls]++;
+    categories[cat].total++;
+
+    if (cls === 'negative') {
+      const tool = e.tool_name || 'unknown';
+      toolBuckets[tool] = (toolBuckets[tool] || 0) + 1;
+      const key = normalize(e.context);
+      if (key.length > 10) {
+        if (!contextCounts[key]) {
+          contextCounts[key] = { 
+            raw: e.context, 
+            count: 0, 
+            tool, 
+            tags: e.tags || [],
+            hasHighRisk: (e.tags || []).some(t => HIGH_RISK_TAGS.has(t))
+          };
+        }
+        contextCounts[key].count++;
+      }
+    }
+  }
+
+  const total = positiveCount + negativeCount;
+  const recurringIssues = Object.values(contextCounts)
+    .filter(v => v.count >= 2 || (v.count >= 1 && v.hasHighRisk)) // Lower threshold for high-risk
+    .sort((a, b) => b.count - a.count)
+    .map(v => {
+      // Threshold hardening: promote high-risk to block after 2 failures
+      const threshold = v.hasHighRisk ? 2 : 4;
+      const severity = v.count >= threshold ? 'critical' : v.count >= (threshold - 1) ? 'high' : 'medium';
+      
+      return {
+        pattern: v.raw.slice(0, 120),
+        count: v.count,
+        severity,
+        hasHighRisk: v.hasHighRisk,
+        suggestedRule: `NEVER ${v.raw.slice(0, 80).replace(/CRITICAL ERROR - User frustrated: /i, '')}`,
+      };
+    });
+
+  // Auto-Gate Promotion logic
+  promoteToGates(recurringIssues);
+
+  return {
+    generatedAt: new Date().toISOString(),
+    totalFeedback: total,
+    negativeCount,
+    positiveCount,
+    negativeRate: total ? `${((negativeCount / total) * 100).toFixed(1)}%` : '0%',
+    recurringIssues,
+    categoryBreakdown: categories,
+    topTools: toolBuckets,
+  };
+}
+
+function promoteToGates(recurringIssues) {
+  const autoGatePath = getAutoGatesPath();
+  const autoGates = { version: 1, gates: [] };
+  
+  for (const issue of recurringIssues) {
+    if (issue.severity === 'critical') {
+      // Extract key nouns/verbs for pattern matching
+      const keywords = issue.pattern
+        .toLowerCase()
+        .replace(/[^a-z0-9\s]/g, '')
+        .split(/\s+/)
+        .filter(w => w.length > 4)
+        .slice(0, 3);
+      
+      if (keywords.length >= 2) {
+        const pattern = keywords.join('.*');
+        autoGates.gates.push({
+          id: `auto-${issue.hasHighRisk ? 'hardened' : 'promoted'}-${Date.now().toString(36)}`,
+          pattern,
+          action: 'block',
+          message: `Automatically blocked due to repeated failures: ${issue.suggestedRule}`,
+          severity: 'critical',
+          source: 'feedback-auto-promotion'
+        });
+      }
+    }
+  }
+
+  if (autoGates.gates.length > 0) {
+    fs.mkdirSync(path.dirname(autoGatePath), { recursive: true });
+    fs.writeFileSync(autoGatePath, JSON.stringify(autoGates, null, 2));
+  }
+}
+
+function toRules(report) {
+  const lines = ['# Suggested Rules from Feedback Analysis', `# Generated: ${report.generatedAt}`, ''];
+  lines.push(`# Negative rate: ${report.negativeRate} (${report.negativeCount}/${report.totalFeedback})`);
+  lines.push('');
+  for (const issue of report.recurringIssues) {
+    lines.push(`- [${issue.severity.toUpperCase()}] (${issue.count}x) ${issue.suggestedRule}`);
+  }
+  if (!report.recurringIssues.length) lines.push('- No recurring issues detected.');
+  return lines.join('\n');
+}
+
+if (require.main === module) {
+  try {
+    const logPath = process.argv[2] && !process.argv[2].startsWith('--') ? process.argv[2] : DEFAULT_LOG;
+    const entries = parseFeedbackFile(logPath);
+    const report = analyze(entries);
+    if (process.argv.includes('--rules')) {
+      console.log(toRules(report));
+    } else {
+      console.log(JSON.stringify(report, null, 2));
+    }
+  } catch (err) {
+    console.error('Warning:', err.message);
+  }
+  process.exit(0);
+}
+
+module.exports = { parseFeedbackFile, classifySignal, analyze, toRules, normalize };