thumbgate 1.4.2 → 1.4.4

package/scripts/skill-packs.js

@@ -1,136 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-const fs = require('fs');
-const path = require('path');
-const { registerPreventionRules } = require('./contextfs');
-const SKILL_PACKS_DIR = path.join(__dirname, '..', 'config', 'skill-packs');
-const BUILTIN_PACKS = {
-  'stripe-integration': { name: 'stripe-integration', description: 'Stripe API best practices', triggers: ['stripe', 'payment', 'checkout', 'subscription', 'webhook signature'], rules: ['ALWAYS use idempotency keys on PaymentIntent creation to prevent duplicate charges.', 'NEVER log or store raw card numbers — use Stripe tokens or PaymentMethod IDs.', 'ALWAYS verify webhook signatures with stripe.webhooks.constructEvent() before processing.', 'Use Checkout Sessions instead of raw PaymentIntents for new integrations.', 'ALWAYS handle payment_intent.succeeded AND payment_intent.payment_failed webhooks.'], packTemplate: { namespaces: ['memoryError', 'memoryLearning', 'rules'], maxItems: 8, maxChars: 6000, queryPrefix: 'stripe payment checkout webhook idempotency' } },
-  'railway-deploy': { name: 'railway-deploy', description: 'Railway deployment best practices', triggers: ['railway', 'deploy', 'dockerfile', 'health check'], rules: ['ALWAYS verify /health endpoint returns new version after deploy.', 'NEVER say "deployed" without curling the health endpoint and showing version match.', 'ALWAYS check Railway build logs for warnings even when deploy succeeds.', 'Use RAILWAY_VOLUME_MOUNT_PATH for persistent data.', 'ALWAYS wait 2-5 minutes after merge before verifying.'], packTemplate: { namespaces: ['memoryError', 'memoryLearning', 'rules'], maxItems: 8, maxChars: 6000, queryPrefix: 'railway deploy health version dockerfile' } },
-  'database-migration': { name: 'database-migration', description: 'Database migration best practices', triggers: ['migration', 'prisma', 'sqlite', 'schema', 'alter table'], rules: ['ALWAYS back up the database before running destructive migrations.', 'NEVER drop columns in production without verifying no code references them.', 'ALWAYS run migrations against a test database first.', 'Use reversible migrations — every up() should have a corresponding down().', 'ALWAYS check for pending migrations before deploying new code.'], packTemplate: { namespaces: ['memoryError', 'rules'], maxItems: 6, maxChars: 5000, queryPrefix: 'migration database schema prisma sqlite' } },
-};
-const registry = new Map(); for (const [id, p] of Object.entries(BUILTIN_PACKS)) registry.set(id, p);
-function ensurePacksDir() { if (!fs.existsSync(SKILL_PACKS_DIR)) fs.mkdirSync(SKILL_PACKS_DIR, { recursive: true }); }
-function registerSkillPack(pack) { if (!pack.name) throw new Error('Skill pack requires a name'); if (!Array.isArray(pack.rules) || pack.rules.length === 0) throw new Error('Skill pack requires at least one rule'); const n = { name: pack.name, description: pack.description || '', triggers: Array.isArray(pack.triggers) ? pack.triggers : [], rules: pack.rules, packTemplate: pack.packTemplate || null, registeredAt: new Date().toISOString() }; registry.set(n.name, n); ensurePacksDir(); fs.writeFileSync(path.join(SKILL_PACKS_DIR, `${n.name}.json`), JSON.stringify(n, null, 2) + '\n'); return n; }
-function loadSkillPacksFromDisk() { ensurePacksDir(); for (const f of fs.readdirSync(SKILL_PACKS_DIR).filter((x) => x.endsWith('.json'))) { try { const p = JSON.parse(fs.readFileSync(path.join(SKILL_PACKS_DIR, f), 'utf-8')); if (p.name) registry.set(p.name, p); } catch { /* skip */ } } }
-function listSkillPacks() { loadSkillPacksFromDisk(); return Array.from(registry.values()).map((p) => ({ name: p.name, description: p.description, triggers: p.triggers, ruleCount: p.rules.length, hasPackTemplate: !!p.packTemplate })); }
-function getSkillPack(name) { loadSkillPacksFromDisk(); return registry.get(name) || null; }
-function matchSkillPacks(query) { const tokens = String(query || '').toLowerCase().split(/\s+/).filter(Boolean); if (tokens.length === 0) return []; loadSkillPacksFromDisk(); const scored = []; for (const pack of registry.values()) { let score = 0; for (const trigger of pack.triggers) { for (const t of trigger.toLowerCase().split(/\s+/)) { if (tokens.some((qt) => qt.includes(t) || t.includes(qt))) score += 1; } } if (score > 0) scored.push({ pack, score }); } return scored.sort((a, b) => b.score - a.score).map((s) => s.pack); }
-function installSkillPackRules(name) { const pack = getSkillPack(name); if (!pack) throw new Error(`Skill pack not found: "${name}"`); return registerPreventionRules([`# Skill Pack: ${pack.name}`, '', pack.description || '', '', ...pack.rules.map((r, i) => `${i + 1}. ${r}`)].join('\n'), { skillPack: pack.name }); }
-// ---------------------------------------------------------------------------
-// L3 Resource Loading (ADK progressive disclosure)
-// ---------------------------------------------------------------------------
-
-const RESOURCES_DIR_NAME = 'references';
-
-/**
- * Load an L3 resource file for a skill pack.
- * Resources live in config/skill-packs/{pack-name}/references/{filename}.
- */
-function loadSkillResource(packName, resourceName) {
-  const resDir = path.join(SKILL_PACKS_DIR, packName, RESOURCES_DIR_NAME);
-  const resPath = path.join(resDir, resourceName);
-  if (!fs.existsSync(resPath)) return null;
-  return { name: resourceName, path: resPath, content: fs.readFileSync(resPath, 'utf-8'), sizeBytes: fs.statSync(resPath).size };
-}
-
-/**
- * List available L3 resources for a skill pack.
- */
-function listSkillResources(packName) {
-  const resDir = path.join(SKILL_PACKS_DIR, packName, RESOURCES_DIR_NAME);
-  if (!fs.existsSync(resDir)) return [];
-  return fs.readdirSync(resDir).filter((f) => !f.startsWith('.')).map((f) => {
-    const fp = path.join(resDir, f);
-    return { name: f, sizeBytes: fs.statSync(fp).size };
-  });
-}
-
-/**
- * Add an L3 resource file to a skill pack.
- */
-function addSkillResource(packName, resourceName, content) {
-  const resDir = path.join(SKILL_PACKS_DIR, packName, RESOURCES_DIR_NAME);
-  ensurePacksDir();
-  if (!fs.existsSync(resDir)) fs.mkdirSync(resDir, { recursive: true });
-  const resPath = path.join(resDir, resourceName);
-  fs.writeFileSync(resPath, content);
-  return { name: resourceName, path: resPath, sizeBytes: Buffer.byteLength(content) };
-}
-
-// ---------------------------------------------------------------------------
-// Skill Factory — agent-driven skill generation
-// ---------------------------------------------------------------------------
-
-/**
- * Auto-generate a skill pack from recurring failure patterns.
- * Uses distilled lessons to propose rules for a new domain.
- *
- * @param {Object} opts
- * @param {string} opts.domain - Domain name (e.g., 'graphql-api')
- * @param {Array} opts.lessons - Array of lesson strings from history distiller
- * @param {string} [opts.description] - Pack description
- * @param {Array} [opts.triggers] - Trigger keywords
- * @returns {Object} The created skill pack
- */
-function generateSkillPack({ domain, lessons, description, triggers } = {}) {
-  if (!domain) throw new Error('Skill factory requires a domain name');
-  if (!Array.isArray(lessons) || lessons.length === 0) throw new Error('Skill factory requires at least one lesson');
-
-  // Convert lessons into NEVER/ALWAYS rules
-  const rules = lessons.map((lesson) => {
-    const l = String(lesson).trim();
-    if (/^(NEVER|ALWAYS|DO NOT|MUST)/i.test(l)) return l;
-    if (/fail|error|broke|wrong|bug|crash/i.test(l)) return `NEVER ${l.replace(/^(avoid|don'?t|stop)\s*/i, '').trim()}`;
-    return `ALWAYS ${l.replace(/^(repeat|keep|continue)\s*/i, '').trim()}`;
-  });
-
-  // Infer triggers from domain + lesson content
-  const inferredTriggers = triggers || [domain, ...domain.split('-').filter((t) => t.length > 2)];
-
-  return registerSkillPack({
-    name: domain,
-    description: description || `Auto-generated skill pack for ${domain} from ${lessons.length} lessons`,
-    triggers: inferredTriggers,
-    rules,
-    packTemplate: { namespaces: ['memoryError', 'memoryLearning', 'rules'], maxItems: 8, maxChars: 6000, queryPrefix: inferredTriggers.join(' ') },
-  });
-}
-
-// ---------------------------------------------------------------------------
-// Token-Efficient Progressive Disclosure Metrics
-// ---------------------------------------------------------------------------
-
-/**
- * Measure token cost of each disclosure level for a skill pack.
- * Helps agents decide which packs to load.
- */
-function measureSkillTokens(packName) {
-  const pack = getSkillPack(packName);
-  if (!pack) return null;
-
-  // L1: metadata only (~name + description + triggers)
-  const l1Text = `${pack.name}: ${pack.description} [${(pack.triggers || []).join(', ')}]`;
-  const l1Chars = l1Text.length;
-
-  // L2: full rules
-  const l2Text = pack.rules.join('\n');
-  const l2Chars = l2Text.length;
-
-  // L3: resources
-  const resources = listSkillResources(packName);
-  const l3Chars = resources.reduce((sum, r) => sum + r.sizeBytes, 0);
-
-  const totalChars = l1Chars + l2Chars + l3Chars;
-
-  return {
-    packName,
-    l1: { chars: l1Chars, estimatedTokens: Math.ceil(l1Chars / 4) },
-    l2: { chars: l2Chars, estimatedTokens: Math.ceil(l2Chars / 4), ruleCount: pack.rules.length },
-    l3: { chars: l3Chars, estimatedTokens: Math.ceil(l3Chars / 4), resourceCount: resources.length },
-    total: { chars: totalChars, estimatedTokens: Math.ceil(totalChars / 4) },
-    disclosureSavings: totalChars > 0 ? Math.round((1 - l1Chars / totalChars) * 100) : 0,
-  };
-}
-
-module.exports = { BUILTIN_PACKS, registerSkillPack, listSkillPacks, getSkillPack, matchSkillPacks, installSkillPackRules, SKILL_PACKS_DIR, loadSkillResource, listSkillResources, addSkillResource, generateSkillPack, measureSkillTokens };

package/scripts/skill-proposer.js

@@ -1,99 +0,0 @@
-#!/usr/bin/env node
-/**
- * Skill Proposer (EvoSkill Phase 1)
- * 
- * Analyzes recurring failure patterns in memory-log.jsonl.
- * Diagnoses the root cause using 'Reasoning' traces and proposes 
- * a new functional skill (tool) to solve the capability gap.
- */
-
-const fs = require('fs');
-const path = require('path');
-const { 
-  parseFeedbackFile, 
-  clusterByTags, 
-  extractTags,
-  discoverFeedbackDir
-} = require('./skill-generator');
-
-function proposeSkills(options = {}) {
-  const feedbackDir = options.feedbackDir || discoverFeedbackDir();
-  const logPath = path.join(feedbackDir, 'memory-log.jsonl');
-  const proposalsDir = path.join(feedbackDir, 'skill-proposals');
-
-  const memories = parseFeedbackFile(logPath);
-  const mistakes = memories.filter(m => m.category === 'error' || m.title.startsWith('MISTAKE:'));
-  
-  if (mistakes.length === 0) {
-    console.log('No mistakes found in memory log.');
-    return [];
-  }
-
-  // Cluster by tags (EvoSkill refinement)
-  const clusters = clusterByTags(mistakes, 2);
-  const proposals = [];
-
-  for (const [tagKey, cluster] of clusters) {
-    if (cluster.entries.length < 2) continue; // Lower threshold for autonomous discovery
-
-    console.log(`Analyzing cluster: [${tagKey}] (${cluster.entries.length} evidences)`);
-
-    // Extract root cause from reasoning traces
-    const reasoningTraces = cluster.entries
-      .map(e => {
-        const match = e.content.match(/Reasoning: (.*)/);
-        return match ? match[1] : null;
-      })
-      .filter(Boolean);
-
-    const commonProblem = cluster.entries[0].title.replace('MISTAKE: ', '');
-    const tags = cluster.tags;
-
-    const proposal = {
-      id: `prop_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
-      status: 'pending',
-      problem: commonProblem,
-      diagnosis: reasoningTraces.length > 0 ? reasoningTraces[0] : 'Repeated execution failure in this domain.',
-      suggestedSkill: {
-        name: `solve-${tags[0]}-${tags[1] || 'logic'}`.toLowerCase().replace(/[^a-z-]/g, ''),
-        description: `Automated skill to handle ${tags.join(', ')} patterns efficiently.`,
-        tags,
-        // Propose a generic tool structure that the Materializer can flesh out
-        toolSpec: {
-          name: `handle_${tags[0].replace(/-/g, '_')}`,
-          description: `Fixes ${commonProblem}`,
-          parameters: {
-            type: 'object',
-            properties: {
-              context: { type: 'string', description: 'The current task context' }
-            }
-          }
-        }
-      },
-      evidenceIds: cluster.entries.map(e => e.id),
-      timestamp: new Date().toISOString()
-    };
-
-    proposals.push(proposal);
-    
-    if (!fs.existsSync(proposalsDir)) fs.mkdirSync(proposalsDir, { recursive: true });
-    fs.writeFileSync(
-      path.join(proposalsDir, `${proposal.suggestedSkill.name}.json`), 
-      JSON.stringify(proposal, null, 2)
-    );
-  }
-
-  return proposals;
-}
-
-if (require.main === module) {
-  const props = proposeSkills();
-  if (props && props.length > 0) {
-    const feedbackDir = discoverFeedbackDir();
-    const proposalsDir = path.join(feedbackDir, 'skill-proposals');
-    console.log(`\nGenerated ${props.length} skill proposals in ${proposalsDir}`);
-    props.forEach(p => console.log(` - ${p.suggestedSkill.name}: ${p.problem}`));
-  }
-}
-
-module.exports = { proposeSkills };

package/scripts/skill-quality-tracker.js

@@ -1,282 +0,0 @@
-#!/usr/bin/env node
-/**
- * Skill Quality Tracker
- *
- * Correlates tool call metrics to feedback signals by timestamp proximity.
- * After a sequence of tool calls and feedback captures, produces a per-skill
- * quality score derived from timestamp-proximity correlation.
- *
- * Ported from Subway_RN_Demo/.claude/scripts/feedback/skill-quality-tracker.js
- * PATH: PROJECT_ROOT = path.join(__dirname, '..') — 1 level up from scripts/
- */
-
-'use strict';
-
-const fs = require('fs');
-const readline = require('readline');
-const path = require('path');
-const { resolveFeedbackDir } = require('./feedback-paths');
-
-const METRICS_PATH = process.env.METRICS_PATH
-  || path.join(resolveFeedbackDir(), 'tool-metrics.jsonl');
-
-const FEEDBACK_PATH = process.env.FEEDBACK_PATH
-  || path.join(resolveFeedbackDir(), 'feedback-log.jsonl');
-
-// Correlation window: feedback within 60 seconds of a tool call is considered correlated
-const CORRELATION_WINDOW_MS = 60_000;
-
-/**
- * Safely parse a single JSON line.
- *
- * @param {string} line
- * @returns {object|null}
- */
-function parseLine(line) {
-  try {
-    return JSON.parse(line);
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Load feedback entries from JSONL file.
- * Each entry needs: timestamp, feedback (signal).
- *
- * @param {string} filePath
- * @returns {Promise<Array<{ ts: number, feedback: string, tool: string|null }>>}
- */
-async function loadFeedback(filePath) {
-  const entries = [];
-  if (!fs.existsSync(filePath)) return entries;
-
-  const rl = readline.createInterface({
-    input: fs.createReadStream(filePath),
-    crlfDelay: Infinity,
-  });
-
-  for await (const line of rl) {
-    const obj = parseLine(line);
-    if (obj && obj.timestamp) {
-      // Support both 'feedback' (Subway) and 'signal' (ThumbGate) field names
-      const feedbackVal = obj.feedback || obj.signal;
-      if (feedbackVal) {
-        // Normalize to 'positive'/'negative' regardless of source schema
-        let normalized = feedbackVal;
-        if (feedbackVal === 'up') normalized = 'positive';
-        else if (feedbackVal === 'down') normalized = 'negative';
-
-        entries.push({
-          ts: new Date(obj.timestamp).getTime(),
-          feedback: normalized,
-          tool: obj.tool_name || null,
-        });
-      }
-    }
-  }
-
-  entries.sort((a, b) => a.ts - b.ts);
-  return entries;
-}
-
-/**
- * Find correlated feedback for a tool call by timestamp proximity.
- *
- * Searches feedback entries within CORRELATION_WINDOW_MS of the metric timestamp.
- * If the feedback entry has a tool_name, it must match the metric's tool name.
- *
- * @param {number} metricTs - Timestamp of the tool call (ms)
- * @param {string} metricTool - Tool name
- * @param {Array<{ ts: number, feedback: string, tool: string|null }>} feedbackEntries
- * @returns {string|null} 'positive', 'negative', or null if no correlation found
- */
-function correlateFeedback(metricTs, metricTool, feedbackEntries) {
-  for (const fb of feedbackEntries) {
-    if (Math.abs(fb.ts - metricTs) <= CORRELATION_WINDOW_MS) {
-      // If feedback has a tool name, it must match; otherwise correlate by time alone
-      if (!fb.tool || fb.tool === metricTool) {
-        return fb.feedback;
-      }
-    }
-  }
-  return null;
-}
-
-/**
- * Process tool metrics JSONL and correlate with feedback.
- *
- * @param {string} metricsPath
- * @param {Array<{ ts: number, feedback: string, tool: string|null }>} feedbackEntries
- * @returns {Promise<{ totalToolUses: number, breakdown: object }>}
- */
-async function processMetrics(metricsPath, feedbackEntries) {
-  const breakdown = {};
-  let totalToolUses = 0;
-
-  if (!fs.existsSync(metricsPath)) return { totalToolUses, breakdown };
-
-  const rl = readline.createInterface({
-    input: fs.createReadStream(metricsPath),
-    crlfDelay: Infinity,
-  });
-
-  for await (const line of rl) {
-    const obj = parseLine(line);
-    if (!obj || !obj.tool_name) continue;
-
-    totalToolUses++;
-    const name = obj.tool_name;
-
-    if (!breakdown[name]) {
-      breakdown[name] = { uses: 0, correlatedPositive: 0, correlatedNegative: 0 };
-    }
-
-    breakdown[name].uses++;
-
-    const ts = new Date(obj.timestamp).getTime();
-    if (!isNaN(ts)) {
-      const signal = correlateFeedback(ts, name, feedbackEntries);
-      if (signal === 'positive') breakdown[name].correlatedPositive++;
-      else if (signal === 'negative') breakdown[name].correlatedNegative++;
-    }
-  }
-
-  return { totalToolUses, breakdown };
-}
-
-/**
- * Compute per-tool success rates from correlation counts.
- * Mutates the breakdown object in place.
- *
- * @param {object} breakdown - { toolName: { uses, correlatedPositive, correlatedNegative } }
- */
-function computeSuccessRates(breakdown) {
-  for (const tool of Object.values(breakdown)) {
-    const correlated = tool.correlatedPositive + tool.correlatedNegative;
-    tool.successRate = correlated > 0
-      ? +(tool.correlatedPositive / correlated).toFixed(4)
-      : null;
-  }
-}
-
-/**
- * Return top-performing tools sorted by success rate.
- *
- * @param {object} breakdown
- * @param {number} [min=10] - Minimum uses threshold
- * @param {number} [limit=5] - Maximum entries to return
- * @returns {Array<{ tool: string, successRate: number, uses: number }>}
- */
-function topPerformers(breakdown, min = 10, limit = 5) {
-  return Object.entries(breakdown)
-    .filter(([, v]) => v.uses >= min && v.successRate !== null)
-    .sort((a, b) => b[1].successRate - a[1].successRate || b[1].uses - a[1].uses)
-    .slice(0, limit)
-    .map(([name, v]) => ({ tool: name, successRate: v.successRate, uses: v.uses }));
-}
-
-/**
- * Return tools with high negative correlation (potential trouble spots).
- * Threshold: >30% negative rate among correlated feedback.
- *
- * @param {object} breakdown
- * @returns {Array<{ tool: string, negativeRate: number, uses: number }>}
- */
-function troubleSpots(breakdown) {
-  return Object.entries(breakdown)
-    .filter(([, v]) => {
-      const total = v.correlatedPositive + v.correlatedNegative;
-      return total > 0 && v.correlatedNegative / total > 0.3;
-    })
-    .map(([name, v]) => {
-      const total = v.correlatedPositive + v.correlatedNegative;
-      return {
-        tool: name,
-        negativeRate: +(v.correlatedNegative / total).toFixed(4),
-        uses: v.uses,
-      };
-    })
-    .sort((a, b) => b.negativeRate - a.negativeRate);
-}
-
-/**
- * Generate actionable recommendations from top performers and trouble spots.
- *
- * @param {Array} top - topPerformers result
- * @param {Array} trouble - troubleSpots result
- * @param {object} breakdown - full breakdown
- * @returns {string[]}
- */
-function generateRecommendations(top, trouble, breakdown) {
-  const recs = [];
-
-  for (const t of trouble) {
-    recs.push(
-      `Investigate "${t.tool}" — ${(t.negativeRate * 100).toFixed(1)}% negative correlation across ${t.uses} uses.`
-    );
-  }
-
-  if (top.length > 0) {
-    recs.push(
-      `"${top[0].tool}" is the top performer (${(top[0].successRate * 100).toFixed(1)}% success). Consider expanding its usage patterns.`
-    );
-  }
-
-  const uncorrelated = Object.entries(breakdown).filter(
-    ([, v]) => v.uses >= 10 && v.successRate === null
-  );
-  if (uncorrelated.length > 0) {
-    recs.push(
-      `${uncorrelated.length} tool(s) with 10+ uses have no correlated feedback — consider adding coverage.`
-    );
-  }
-
-  if (recs.length === 0) recs.push('No actionable recommendations at this time.');
-  return recs;
-}
-
-/**
- * Main entry point: load data, correlate, produce report.
- *
- * @returns {Promise<object>} Full skill quality report
- */
-async function run() {
-  const feedbackEntries = await loadFeedback(FEEDBACK_PATH);
-  const { totalToolUses, breakdown } = await processMetrics(METRICS_PATH, feedbackEntries);
-
-  computeSuccessRates(breakdown);
-
-  const top = topPerformers(breakdown);
-  const trouble = troubleSpots(breakdown);
-  const recommendations = generateRecommendations(top, trouble, breakdown);
-
-  const report = {
-    generatedAt: new Date().toISOString(),
-    totalToolUses,
-    toolBreakdown: breakdown,
-    topPerformers: top,
-    troubleSpots: trouble,
-    recommendations,
-  };
-
-  console.log(JSON.stringify(report, null, 2));
-  return report;
-}
-
-if (require.main === module) {
-  run().catch(() => {}).finally(() => process.exit(0));
-}
-
-module.exports = {
-  parseLine,
-  correlateFeedback,
-  computeSuccessRates,
-  topPerformers,
-  troubleSpots,
-  generateRecommendations,
-  loadFeedback,
-  processMetrics,
-  run,
-  CORRELATION_WINDOW_MS,
-};

package/scripts/slow-loop.js

@@ -1,72 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const { createSchedule } = require('./schedule-manager');
-const { resolveFeedbackDir } = require('./feedback-paths');
-
-const IDLE_THRESHOLD_MINUTES = 30;
-const SLOW_LOOP_STATE_FILE = 'slow-loop-state.json';
-
-function getStatePath() {
-  return path.join(resolveFeedbackDir(), SLOW_LOOP_STATE_FILE);
-}
-
-function loadState() {
-  const p = getStatePath();
-  if (!fs.existsSync(p)) return { lastExportAt: null, exportCount: 0, lastIdleCheckAt: null, totalPairsExported: 0 };
-  try { return JSON.parse(fs.readFileSync(p, 'utf-8')); } catch { return { lastExportAt: null, exportCount: 0, lastIdleCheckAt: null, totalPairsExported: 0 }; }
-}
-
-function saveState(state) {
-  const p = getStatePath();
-  const dir = path.dirname(p);
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(p, JSON.stringify(state, null, 2) + '\n');
-}
-
-function isIdle({ thresholdMinutes = IDLE_THRESHOLD_MINUTES } = {}) {
-  const feedbackDir = resolveFeedbackDir();
-  const logPath = path.join(feedbackDir, 'feedback-log.jsonl');
-  if (!fs.existsSync(logPath)) return true;
-  try {
-    const stats = fs.statSync(logPath);
-    const minutesSinceModified = (Date.now() - stats.mtimeMs) / (1000 * 60);
-    return minutesSinceModified >= thresholdMinutes;
-  } catch { return true; }
-}
-
-function runSlowLoop({ thresholdMinutes = IDLE_THRESHOLD_MINUTES, force = false } = {}) {
-  const state = loadState();
-  const idle = force || isIdle({ thresholdMinutes });
-  if (!idle) { state.lastIdleCheckAt = new Date().toISOString(); saveState(state); return { action: 'skipped', reason: 'system not idle', idle: false, state }; }
-
-  const feedbackDir = resolveFeedbackDir();
-  const logPath = path.join(feedbackDir, 'feedback-log.jsonl');
-  let newEntries = 0;
-  if (fs.existsSync(logPath)) {
-    const totalEntries = fs.readFileSync(logPath, 'utf-8').trim().split('\n').filter(Boolean).length;
-    newEntries = totalEntries - (state.lastFeedbackCount || 0);
-    state.lastFeedbackCount = totalEntries;
-  }
-  if (newEntries <= 0 && !force) { state.lastIdleCheckAt = new Date().toISOString(); saveState(state); return { action: 'skipped', reason: 'no new feedback since last export', idle: true, newEntries: 0, state }; }
-
-  let dpoResult = null;
-  try { const { exportDpoPairs } = require('./feedback-loop'); dpoResult = exportDpoPairs(); } catch (err) { dpoResult = { error: err.message, pairsExported: 0 }; }
-
-  const pairsExported = dpoResult && dpoResult.pairs ? dpoResult.pairs.length : (dpoResult && dpoResult.pairsExported) || 0;
-  state.lastExportAt = new Date().toISOString();
-  state.exportCount = (state.exportCount || 0) + 1;
-  state.totalPairsExported = (state.totalPairsExported || 0) + pairsExported;
-  state.lastIdleCheckAt = new Date().toISOString();
-  saveState(state);
-  return { action: 'exported', idle: true, newEntries, pairsExported, totalExports: state.exportCount, totalPairsExported: state.totalPairsExported, exportedAt: state.lastExportAt, state };
-}
-
-function createSlowLoopSchedule({ schedule = 'hourly', thresholdMinutes = IDLE_THRESHOLD_MINUTES } = {}) {
-  const command = [`const sl = require(${JSON.stringify(__filename)});`, `const result = sl.runSlowLoop(${JSON.stringify({ thresholdMinutes })});`, 'process.stdout.write(JSON.stringify(result, null, 2) + "\\n");'].join(' ');
-  return createSchedule({ id: 'thumbgate-slow-loop', name: 'ThumbGate Slow Loop (DPO Export)', description: `Idle-time DPO export, runs ${schedule}`, schedule, command });
-}
-
-module.exports = { isIdle, runSlowLoop, createSlowLoopSchedule, loadState, getStatePath };

package/scripts/social-analytics/db/schema.sql

@@ -1,32 +0,0 @@
-CREATE TABLE IF NOT EXISTS engagement_metrics (
-  id            INTEGER PRIMARY KEY AUTOINCREMENT,
-  platform      TEXT NOT NULL,
-  content_type  TEXT NOT NULL,
-  post_id       TEXT NOT NULL,
-  post_url      TEXT,
-  published_at  TEXT,
-  metric_date   TEXT NOT NULL,
-  impressions   INTEGER DEFAULT 0,
-  reach         INTEGER DEFAULT 0,
-  likes         INTEGER DEFAULT 0,
-  comments      INTEGER DEFAULT 0,
-  shares        INTEGER DEFAULT 0,
-  saves         INTEGER DEFAULT 0,
-  clicks        INTEGER DEFAULT 0,
-  video_views   INTEGER DEFAULT 0,
-  followers_delta INTEGER DEFAULT 0,
-  extra_json    TEXT,
-  fetched_at    TEXT NOT NULL,
-  UNIQUE(platform, post_id, metric_date)
-);
-
-CREATE TABLE IF NOT EXISTS follower_snapshots (
-  id            INTEGER PRIMARY KEY AUTOINCREMENT,
-  platform      TEXT NOT NULL,
-  follower_count INTEGER NOT NULL,
-  snapshot_date TEXT NOT NULL,
-  UNIQUE(platform, snapshot_date)
-);
-
-CREATE INDEX IF NOT EXISTS idx_metrics_platform_date ON engagement_metrics(platform, metric_date);
-CREATE INDEX IF NOT EXISTS idx_metrics_published ON engagement_metrics(published_at);