thumbgate 0.9.10

package/scripts/background-agent-governance.js

@@ -0,0 +1,237 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Background Agent Governance — the missing layer for Ramp/Ona-style agent stacks.
+ *
+ * Background agents run unattended (writing 57% of PRs at Ramp). They need:
+ * 1. Run tracking — what did each agent run do?
+ * 2. Governance gate — should this PR/action be allowed based on past failures?
+ * 3. Post-run audit — auto-capture feedback from CI results
+ * 4. Governance report — "X runs, Y blocked, Z lessons learned"
+ *
+ * Integrates with: MCP server, gates engine, org dashboard, lesson inference.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { resolveFeedbackDir } = require('./feedback-paths');
+
+const RUNS_FILE = 'agent-runs.jsonl';
+
+function getFeedbackDir() { return resolveFeedbackDir(); }
+function getRunsPath() { return path.join(getFeedbackDir(), RUNS_FILE); }
+
+function readJsonl(fp) {
+  if (!fs.existsSync(fp)) return [];
+  const raw = fs.readFileSync(fp, 'utf-8').trim();
+  if (!raw) return [];
+  return raw.split('\n').map((l) => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
+}
+
+function ensureDir(fp) { const d = path.dirname(fp); if (!fs.existsSync(d)) fs.mkdirSync(d, { recursive: true }); }
+
+// ---------------------------------------------------------------------------
+// 1. Run Tracking
+// ---------------------------------------------------------------------------
+
+/**
+ * Record a background agent run.
+ * Called when a background agent starts or completes a task.
+ */
+function recordAgentRun({ agentId, runType, source, branch, prNumber, status, gatesChecked, gatesBlocked, filesChanged, ciPassed, duration, metadata } = {}) {
+  const runsPath = getRunsPath();
+  ensureDir(runsPath);
+  const run = {
+    id: `run_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+    timestamp: new Date().toISOString(),
+    agentId: agentId || 'unknown',
+    runType: runType || 'unknown', // 'pr', 'fix', 'refactor', 'ci-repair', 'migration'
+    source: source || 'background', // 'background', 'triggered', 'scheduled', 'manual'
+    branch: branch || null,
+    prNumber: prNumber || null,
+    status: status || 'started', // 'started', 'completed', 'blocked', 'failed'
+    gatesChecked: gatesChecked || 0,
+    gatesBlocked: gatesBlocked || 0,
+    filesChanged: filesChanged || 0,
+    ciPassed: ciPassed === undefined ? null : ciPassed,
+    durationMs: duration || null,
+    metadata: metadata || {},
+  };
+  fs.appendFileSync(runsPath, JSON.stringify(run) + '\n');
+  return run;
+}
+
+// ---------------------------------------------------------------------------
+// 2. Governance Gate — pre-run check
+// ---------------------------------------------------------------------------
+
+/**
+ * Check if a background agent run should proceed based on governance rules.
+ * Returns { allowed, blockers, warnings, governanceScore }.
+ */
+function checkRunGovernance({ agentId, runType, branch, filesChanged } = {}) {
+  const runs = readJsonl(getRunsPath());
+  const blockers = [];
+  const warnings = [];
+
+  // Rule 1: Block if this agent has > 50% failure rate in last 10 runs
+  const agentRuns = runs.filter((r) => r.agentId === agentId).slice(-10);
+  const failedRuns = agentRuns.filter((r) => r.status === 'failed' || r.status === 'blocked');
+  if (agentRuns.length >= 5 && failedRuns.length / agentRuns.length > 0.5) {
+    blockers.push({ rule: 'high_failure_rate', message: `Agent ${agentId} has ${failedRuns.length}/${agentRuns.length} failed runs (>50%)`, severity: 'critical' });
+  }
+
+  // Rule 2: Warn if agent has been blocked by gates in recent runs
+  const recentBlocked = agentRuns.filter((r) => r.gatesBlocked > 0);
+  if (recentBlocked.length >= 3) {
+    warnings.push({ rule: 'repeated_gate_blocks', message: `Agent ${agentId} has been gate-blocked in ${recentBlocked.length} recent runs`, severity: 'warning' });
+  }
+
+  // Rule 3: Block if targeting protected branch without CI passing
+  if (branch && /^(main|master|develop)$/.test(branch)) {
+    warnings.push({ rule: 'protected_branch', message: `Run targets protected branch "${branch}" — CI must pass before merge`, severity: 'warning' });
+  }
+
+  // Rule 4: Warn if too many files changed (large blast radius)
+  if (filesChanged > 20) {
+    warnings.push({ rule: 'large_blast_radius', message: `${filesChanged} files changed — consider splitting into smaller PRs`, severity: 'warning' });
+  }
+
+  const governanceScore = Math.max(0, 100 - blockers.length * 40 - warnings.length * 10);
+
+  return {
+    allowed: blockers.length === 0,
+    blockers,
+    warnings,
+    governanceScore,
+    checkedAt: new Date().toISOString(),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// 3. Post-Run Audit — auto-capture feedback from CI
+// ---------------------------------------------------------------------------
+
+/**
+ * Auto-capture feedback from a completed background agent run.
+ * Converts CI pass/fail into structured feedback for the learning loop.
+ */
+function auditCompletedRun({ runId, agentId, ciPassed, ciOutput, prNumber, branch, filesChanged } = {}) {
+  const signal = ciPassed ? 'positive' : 'negative';
+  const context = ciPassed
+    ? `Background agent run ${runId || 'unknown'} completed successfully. PR #${prNumber || '?'} on ${branch || '?'}. ${filesChanged || 0} files changed. CI passed.`
+    : `Background agent run ${runId || 'unknown'} failed. PR #${prNumber || '?'} on ${branch || '?'}. ${filesChanged || 0} files changed. CI failed.`;
+
+  const whatWentWrong = !ciPassed && ciOutput ? ciOutput.slice(0, 500) : null;
+
+  // Record the completed run
+  const run = recordAgentRun({
+    agentId,
+    runType: 'pr',
+    source: 'background',
+    branch,
+    prNumber,
+    status: ciPassed ? 'completed' : 'failed',
+    filesChanged,
+    ciPassed,
+  });
+
+  // Auto-capture feedback
+  let feedbackResult = null;
+  try {
+    const { captureFeedback } = require('./feedback-loop');
+    feedbackResult = captureFeedback({
+      signal: ciPassed ? 'up' : 'down',
+      context,
+      whatWentWrong,
+      whatWorked: ciPassed ? `Agent successfully completed PR #${prNumber || '?'}` : undefined,
+      tags: ['background-agent', ciPassed ? 'ci-pass' : 'ci-fail', `agent:${agentId || 'unknown'}`],
+    });
+  } catch { /* feedback capture is non-critical */ }
+
+  return { run, feedbackResult, signal, context };
+}
+
+// ---------------------------------------------------------------------------
+// 4. Governance Report
+// ---------------------------------------------------------------------------
+
+/**
+ * Generate a governance report for background agent runs.
+ * Shows: total runs, blocked, pass rate, top failing agents, lessons learned.
+ */
+function generateGovernanceReport({ periodHours = 24 } = {}) {
+  const runs = readJsonl(getRunsPath());
+  const cutoff = Date.now() - periodHours * 60 * 60 * 1000;
+  const recent = runs.filter((r) => new Date(r.timestamp).getTime() > cutoff);
+
+  const total = recent.length;
+  const completed = recent.filter((r) => r.status === 'completed').length;
+  const failed = recent.filter((r) => r.status === 'failed').length;
+  const blocked = recent.filter((r) => r.status === 'blocked').length;
+  const started = recent.filter((r) => r.status === 'started').length;
+
+  const passRate = (completed + failed) > 0 ? Math.round((completed / (completed + failed)) * 1000) / 10 : 0;
+  const totalGatesChecked = recent.reduce((s, r) => s + (r.gatesChecked || 0), 0);
+  const totalGatesBlocked = recent.reduce((s, r) => s + (r.gatesBlocked || 0), 0);
+
+  // Per-agent breakdown
+  const byAgent = {};
+  for (const r of recent) {
+    if (!byAgent[r.agentId]) byAgent[r.agentId] = { completed: 0, failed: 0, blocked: 0, total: 0 };
+    byAgent[r.agentId].total++;
+    if (r.status === 'completed') byAgent[r.agentId].completed++;
+    if (r.status === 'failed') byAgent[r.agentId].failed++;
+    if (r.status === 'blocked') byAgent[r.agentId].blocked++;
+  }
+
+  const agentSummaries = Object.entries(byAgent).map(([id, counts]) => ({
+    agentId: id,
+    ...counts,
+    passRate: (counts.completed + counts.failed) > 0 ? Math.round((counts.completed / (counts.completed + counts.failed)) * 1000) / 10 : 0,
+  })).sort((a, b) => a.passRate - b.passRate);
+
+  // By run type
+  const byType = {};
+  for (const r of recent) {
+    if (!byType[r.runType]) byType[r.runType] = 0;
+    byType[r.runType]++;
+  }
+
+  return {
+    periodHours,
+    total, completed, failed, blocked, started,
+    passRate,
+    gatesChecked: totalGatesChecked,
+    gatesBlocked: totalGatesBlocked,
+    agents: agentSummaries,
+    topFailingAgent: agentSummaries.length > 0 && agentSummaries[0].passRate < 80 ? agentSummaries[0] : null,
+    byType,
+    generatedAt: new Date().toISOString(),
+  };
+}
+
+/**
+ * Format governance report as a human-readable string.
+ */
+function formatGovernanceReport(report) {
+  const lines = [
+    `Background Agent Governance Report (${report.periodHours}h)`,
+    `Total runs: ${report.total} | Completed: ${report.completed} | Failed: ${report.failed} | Blocked: ${report.blocked}`,
+    `Pass rate: ${report.passRate}%`,
+    `Gates checked: ${report.gatesChecked} | Gates blocked: ${report.gatesBlocked}`,
+  ];
+  if (report.topFailingAgent) {
+    lines.push(`Top failing agent: ${report.topFailingAgent.agentId} (${report.topFailingAgent.passRate}% pass rate)`);
+  }
+  if (Object.keys(report.byType).length > 0) {
+    lines.push(`Run types: ${Object.entries(report.byType).map(([t, c]) => `${t}:${c}`).join(', ')}`);
+  }
+  return lines.join('\n');
+}
+
+module.exports = {
+  recordAgentRun, checkRunGovernance, auditCompletedRun,
+  generateGovernanceReport, formatGovernanceReport, getRunsPath,
+};

package/scripts/behavioral-extraction.js

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+/**
+ * behavioral-extraction.js
+ * 
+ * Layer 4: Behavioral Learning
+ * Extracts user preference patterns from feedback logs to adjust agent approach.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const HOME = process.env.HOME || process.env.USERPROFILE || '';
+const envDir = process.env.THUMBGATE_FEEDBACK_DIR;
+const localFallback = path.join(process.cwd(), '.thumbgate');
+const localClaude = path.join(process.cwd(), '.claude', 'memory', 'feedback');
+const baseDir = envDir || (fs.existsSync(localFallback) ? localFallback : localClaude);
+
+const FEEDBACK_LOG_PATH = path.join(baseDir, 'feedback-log.jsonl');
+const TRAITS_PATH = path.join(baseDir, 'behavioral-traits.json');
+
+const TRAIT_DEFINITIONS = [
+  {
+    id: 'surgical-over-rewrite',
+    patterns: [/surgical/i, /targeted/i, /don't rewrite/i, /minimal change/i],
+    threshold: 2,
+    description: 'User prefers surgical edits over full file rewrites.'
+  },
+  {
+    id: 'concise-over-verbose',
+    patterns: [/concise/i, /short/i, /less talk/i, /too much chat/i],
+    threshold: 2,
+    description: 'User prefers concise, direct communication.'
+  },
+  {
+    id: 'test-driven',
+    patterns: [/test first/i, /where is the test/i, /run tests/i, /tdd/i],
+    threshold: 2,
+    description: 'User prioritizes test coverage and verification.'
+  }
+];
+
+function extractTraits() {
+  if (!fs.existsSync(FEEDBACK_LOG_PATH)) {
+    console.log('No feedback log found at', FEEDBACK_LOG_PATH);
+    return [];
+  }
+
+  const logLines = fs.readFileSync(FEEDBACK_LOG_PATH, 'utf-8').split('\n').filter(Boolean);
+  const evidenceCount = {};
+
+  logLines.forEach(line => {
+    try {
+      const entry = JSON.parse(line);
+      const text = `${entry.context || ''} ${entry.whatWorked || ''} ${entry.whatWentWrong || ''} ${entry.whatToChange || ''}`;
+      
+      TRAIT_DEFINITIONS.forEach(trait => {
+        if (trait.patterns.some(p => p.test(text))) {
+          evidenceCount[trait.id] = (evidenceCount[trait.id] || 0) + 1;
+        }
+      });
+    } catch (e) {
+      // skip malformed lines
+    }
+  });
+
+  const activeTraits = TRAIT_DEFINITIONS
+    .filter(trait => (evidenceCount[trait.id] || 0) >= trait.threshold)
+    .map(trait => ({
+      id: trait.id,
+      description: trait.description,
+      evidenceCount: evidenceCount[trait.id]
+    }));
+
+  return activeTraits;
+}
+
+function run() {
+  console.log('🤖 [Layer 4] Extracting behavioral patterns...');
+  const traits = extractTraits();
+  
+  if (traits.length > 0) {
+    fs.writeFileSync(TRAITS_PATH, JSON.stringify({
+      generatedAt: new Date().toISOString(),
+      traits
+    }, null, 2));
+    console.log(`✅ Extracted ${traits.length} behavioral traits.`);
+    traits.forEach(t => console.log(`  - ${t.id} (${t.evidenceCount} evidences)`));
+  } else {
+    console.log('No strong behavioral patterns identified yet.');
+  }
+}
+
+if (require.main === module) {
+  run();
+}
+
+module.exports = { extractTraits };

package/scripts/belief-update.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+/**
+ * Bayesian Belief Update Engine
+ *
+ * Implements belief revision using recursive Bayesian updates.
+ * Updates priorProbability and uncertainty based on new observations.
+ * Handles entropy-based pruning of low-confidence memories.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Perform a Bayesian update on a belief.
+ * @param {object} belief - The existing bayesian metadata
+ * @param {number} likelihood - The likelihood of the new observation (0-1)
+ * @returns {object} Updated bayesian metadata
+ */
+function updateBelief(belief, likelihood) {
+  const prior = belief.priorProbability;
+  const n = belief.observations;
+
+  // Simple Bayesian update for probability (weighted mean)
+  // P(H|E) = (P(E|H) * P(H)) / P(E)
+  // Here we use a simpler recursive update for multi-turn interaction
+  const newPrior = (prior * n + likelihood) / (n + 1);
+  
+  // Sentry fix: Contradiction should be based on raw difference between likelihood and prior
+  // to ensure strong contradictions increase uncertainty regardless of n.
+  const contradiction = Math.abs(likelihood - prior);
+  const newUncertainty = (belief.uncertainty * n + contradiction) / (n + 1);
+
+  return {
+    priorProbability: Math.round(newPrior * 1000) / 1000,
+    uncertainty: Math.round(newUncertainty * 1000) / 1000,
+    observations: n + 1,
+    lastUpdated: new Date().toISOString(),
+  };
+}
+
+/**
+ * Check if a memory should be pruned based on entropy.
+ * @param {object} bayesian - Bayesian metadata
+ * @returns {boolean} True if memory should be pruned
+ */
+function shouldPrune(bayesian) {
+  const ENTROPY_THRESHOLD = 0.7;
+  const OBSERVATION_FLOOR = 3;
+
+  // Prune if high uncertainty after enough observations
+  if (bayesian.observations >= OBSERVATION_FLOOR && bayesian.uncertainty > ENTROPY_THRESHOLD) {
+    return true;
+  }
+
+  // Prune if prior probability falls too low (it's likely a false belief)
+  if (bayesian.priorProbability < 0.2) {
+    return true;
+  }
+
+  return false;
+}
+
+module.exports = {
+  updateBelief,
+  shouldPrune,
+};
+
+if (require.main === module) {
+  // Unit test logic if run directly
+  console.log('Testing Bayesian Update...');
+  let belief = { priorProbability: 0.5, uncertainty: 0.5, observations: 1 };
+  
+  // Sequence of positive signals
+  belief = updateBelief(belief, 0.9);
+  console.log('Update 1 (Success):', belief);
+  belief = updateBelief(belief, 0.95);
+  console.log('Update 2 (Success):', belief);
+  
+  // Contradiction
+  belief = updateBelief(belief, 0.1);
+  console.log('Update 3 (Contradiction):', belief);
+  
+  console.log('Should prune?', shouldPrune(belief));
+}