thumbgate 1.4.3 → 1.4.4

package/scripts/autonomous-sales-agent.js

@@ -1,39 +0,0 @@
-#!/usr/bin/env node
-/**
- * autonomous-sales-agent.js
- *
- * Wrapper for the truth-aware GSD revenue loop:
- * 1. read the current commercial snapshot
- * 2. pick the correct motion (Pro vs Workflow Hardening Sprint)
- * 3. generate operator-ready outreach artifacts
- * Canonical app origin remains https://thumbgate-production.up.railway.app.
- */
-
-'use strict';
-
-const { parseArgs, runRevenueLoop } = require('./gtm-revenue-loop');
-
-async function main(argv = process.argv.slice(2)) {
-  const options = parseArgs(argv);
-  const { report, written } = await runRevenueLoop(options);
-
-  console.log('\n✅ GTM automation complete.');
-  if (written.docsPath) {
-    console.log(`Open ${written.docsPath} to review the operator report.`);
-  }
-  if (written.reportDir) {
-    console.log(`Artifacts written to ${written.reportDir}.`);
-  }
-  console.log(`State: ${report.directive.state} | Targets: ${report.targets.length}`);
-}
-
-if (require.main === module) {
-  main().catch((err) => {
-    console.error(err && err.message ? err.message : err);
-    process.exit(1);
-  });
-}
-
-module.exports = {
-  main,
-};

package/scripts/autoresearch-runner.js

@@ -1,216 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-/**
- * Autoresearch Runner (AUTORESEARCH-02)
- *
- * Karpathy-inspired self-optimizing loop for the ThumbGate feedback studio.
- * Each iteration: mutate local evolution state → run primary + holdout checks
- * → measure score → keep/discard with rollback snapshots.
- *
- * The runner never rewrites tracked source files. It mutates the local
- * evolution-state overlay, evaluates in place, and only persists accepted
- * settings plus rollback snapshots.
- *
- * Mutation targets (in priority order):
- *   1. Thompson Sampling priors (HALF_LIFE_DAYS, DECAY_FLOOR)
- *   2. Prevention rule thresholds (minOccurrences)
- *   3. Verification loop retries (MAX_RETRIES)
- *   4. DPO temperature (DPO_BETA)
- *
- * Score function: command pass rate × approval weighting, with holdout gating.
- *
- * Zero external dependencies.
- *
- * Exports: runIteration, runLoop, scoreSuite, MUTATION_TARGETS
- */
-
-const {
-  getProgress,
-} = require('./experiment-tracker');
-const { buildResearchBrief } = require('./hf-papers');
-const {
-  EVOLUTION_TARGETS,
-  parseCommandScore,
-  runWorkspaceEvolution,
-} = require('./workspace-evolver');
-
-// ---------------------------------------------------------------------------
-// Mutation Targets
-// ---------------------------------------------------------------------------
-
-const MUTATION_TARGETS = EVOLUTION_TARGETS;
-
-// ---------------------------------------------------------------------------
-// Score Function
-// ---------------------------------------------------------------------------
-
-/**
- * Score a test suite run. Returns a number in [0, 1].
- *
- * @param {object} params
- * @param {string} params.testOutput - stdout from test run
- * @param {number} [params.approvalRate] - Current approval rate from feedback
- * @returns {{ score: number, testPassRate: number, details: object }}
- */
-function scoreSuite(params) {
-  return parseCommandScore(params.testOutput || '', 0, typeof params.approvalRate === 'number' ? params.approvalRate : 0.5);
-}
-
-// ---------------------------------------------------------------------------
-// Single Iteration
-// ---------------------------------------------------------------------------
-
-/**
- * Run one autoresearch iteration.
- *
- * 1. Pick a random mutation target
- * 2. Read current value, compute a random neighbor
- * 3. Run the test suite in a tmp env with the mutation
- * 4. Score and keep/discard via experiment tracker
- *
- * @param {object} [opts]
- * @param {string} [opts.targetName] - Force a specific mutation target
- * @param {number} [opts.nextValue] - Force the candidate value instead of a random neighbor
- * @param {string} [opts.testCommand] - Override test command (default: npm test)
- * @param {string[]} [opts.holdoutCommands] - Optional holdout commands required for acceptance
- * @param {number} [opts.timeoutMs] - Test timeout in ms (default: 120000)
- * @param {string} [opts.researchQuery] - Optional external research query
- * @param {number} [opts.paperLimit] - Max papers to ingest for research context
- * @param {Function} [opts.fetchImpl] - Optional fetch implementation override
- * @param {Function} [opts.searchPapersImpl] - Optional paper search override
- * @returns {Promise<object>} experiment result
- */
-async function runIteration(opts = {}) {
-  const options = opts || {};
-  const timeoutMs = options.timeoutMs || 120000;
-  const testCommand = options.testCommand || 'npm test';
-  const research = options.researchQuery
-    ? await buildResearchBrief({
-      query: options.researchQuery,
-      limit: options.paperLimit,
-      fetchImpl: options.fetchImpl,
-      searchPapersImpl: options.searchPapersImpl,
-      template: 'autoresearch-brief',
-    })
-    : null;
-
-  const result = runWorkspaceEvolution({
-    targetName: options.targetName,
-    nextValue: options.nextValue,
-    primaryCommands: [testCommand],
-    holdoutCommands: options.holdoutCommands || [],
-    timeoutMs,
-    hypothesisSuffix: research ? `Research query: ${research.query}` : null,
-    additionalMetrics: {
-      researchQuery: research ? research.query : null,
-      researchPackId: research ? research.packId : null,
-      researchPaperIds: research ? research.citations.map((citation) => citation.paperId).filter(Boolean) : [],
-    },
-  });
-
-  return result;
-}
-
-// ---------------------------------------------------------------------------
-// Multi-Iteration Loop
-// ---------------------------------------------------------------------------
-
-/**
- * Run N autoresearch iterations.
- *
- * @param {object} params
- * @param {number} params.iterations - Number of experiments to run
- * @param {string} [params.testCommand] - Override test command
- * @param {number} [params.timeoutMs] - Per-iteration timeout
- * @param {string} [params.researchQuery] - Optional external research query
- * @param {number} [params.paperLimit] - Max papers to ingest for research context
- * @param {Function} [params.fetchImpl] - Optional fetch implementation override
- * @param {Function} [params.searchPapersImpl] - Optional paper search override
- * @returns {Promise<object>} { results, progress }
- */
-async function runLoop(params) {
-  const iterations = params.iterations || 1;
-  const results = [];
-
-  for (let i = 0; i < iterations; i++) {
-    console.log(`\n[autoresearch] Iteration ${i + 1}/${iterations}`);
-    try {
-      const result = await runIteration({
-        testCommand: params.testCommand,
-        holdoutCommands: params.holdoutCommands,
-        timeoutMs: params.timeoutMs,
-        researchQuery: params.researchQuery,
-        paperLimit: params.paperLimit,
-        fetchImpl: params.fetchImpl,
-        searchPapersImpl: params.searchPapersImpl,
-      });
-      results.push(result);
-      if (result.kept) {
-        console.log(`  ✓ KEPT: ${result.name} (delta: +${(result.delta || 0).toFixed(4)})`);
-      } else if (result.skipped) {
-        console.log(`  ⊘ SKIPPED: ${result.reason}`);
-      } else {
-        console.log(`  ✗ DISCARDED: ${result.reason}`);
-      }
-    } catch (err) {
-      console.error(`  ✗ ERROR: ${err.message}`);
-      results.push({ error: err.message });
-    }
-  }
-
-  const progress = getProgress();
-  console.log(`\n[autoresearch] Progress: ${progress.completed} experiments, ${progress.kept} kept (${progress.keepRate}%)`);
-  return { results, progress };
-}
-
-// ---------------------------------------------------------------------------
-// CLI
-// ---------------------------------------------------------------------------
-
-if (require.main === module) {
-  const args = {};
-  process.argv.slice(2).forEach((arg) => {
-    if (!arg.startsWith('--')) return;
-    const [key, ...rest] = arg.slice(2).split('=');
-    args[key] = rest.length > 0 ? rest.join('=') : true;
-  });
-
-  if (args.run) {
-    const iterations = Number(args.iterations || 1);
-    const testCommand = args['test-command'] || 'npm test';
-    const timeoutMs = Number(args.timeout || 120000);
-    const paperLimit = Number(args['paper-limit'] || 5);
-    const holdoutCommands = args.holdout ? [args.holdout] : [];
-    runLoop({
-      iterations,
-      testCommand,
-      holdoutCommands,
-      timeoutMs,
-      researchQuery: args['research-query'] || null,
-      paperLimit,
-    }).catch((error) => {
-      console.error(error.message);
-      process.exit(1);
-    });
-  } else if (args.targets) {
-    console.log('Mutation targets:');
-    MUTATION_TARGETS.forEach((t) => {
-      console.log(`  ${t.name} (${t.type}): range [${t.range.join(', ')}], step ${t.step}`);
-    });
-  } else {
-    console.log(`Usage:
-  node scripts/autoresearch-runner.js --run [--iterations=5] [--test-command="npm test"] [--holdout="npm run self-heal:check"] [--timeout=120000] [--research-query="rank fusion"] [--paper-limit=5]
-  node scripts/autoresearch-runner.js --targets`);
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Exports
-// ---------------------------------------------------------------------------
-
-module.exports = {
-  runIteration,
-  runLoop,
-  scoreSuite,
-  MUTATION_TARGETS,
-};

package/scripts/background-agent-governance.js

@@ -1,229 +0,0 @@
-#!/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 { ensureParentDir, readJsonl } = require('./fs-utils');
-
-const RUNS_FILE = 'agent-runs.jsonl';
-
-function getFeedbackDir() { return resolveFeedbackDir(); }
-function getRunsPath() { return path.join(getFeedbackDir(), RUNS_FILE); }
-
-// ---------------------------------------------------------------------------
-// 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();
-  ensureParentDir(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

@@ -1,93 +0,0 @@
-#!/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 { resolveFeedbackDir } = require('./feedback-paths');
-
-const baseDir = resolveFeedbackDir();
-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 };