thumbgate 1.27.16 → 1.27.18

package/scripts/aws-blocks-guardrails.js

@@ -1,228 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-const fs = require('node:fs');
-const path = require('node:path');
-
-const AWS_BLOCKS_DEPENDENCY_PATTERN = /(^|\/)@aws-blocks\/(?:blocks|[^/\s"']+)/;
-
-function toList(value) {
-  if (Array.isArray(value)) return value.map(String).map((entry) => entry.trim()).filter(Boolean);
-  if (typeof value === 'string') return value.split(',').map((entry) => entry.trim()).filter(Boolean);
-  return [];
-}
-
-function normalizeText(value) {
-  if (value == null) return '';
-  if (typeof value === 'string') return value;
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return String(value);
-  }
-}
-
-function readPackageJson(projectDir) {
-  try {
-    return JSON.parse(fs.readFileSync(path.join(projectDir, 'package.json'), 'utf8'));
-  } catch {
-    return null;
-  }
-}
-
-function packageUsesAwsBlocks(pkg) {
-  if (!pkg || typeof pkg !== 'object') return false;
-  const dependencyText = JSON.stringify({
-    dependencies: pkg.dependencies || {},
-    devDependencies: pkg.devDependencies || {},
-    peerDependencies: pkg.peerDependencies || {},
-    optionalDependencies: pkg.optionalDependencies || {},
-  });
-  const scriptsText = JSON.stringify(pkg.scripts || {});
-  return AWS_BLOCKS_DEPENDENCY_PATTERN.test(dependencyText) || /aws-blocks|blocks-app|cdk|sandbox/i.test(scriptsText);
-}
-
-function detectAwsBlocksProject(projectDir = process.cwd()) {
-  const pkg = readPackageJson(projectDir);
-  if (packageUsesAwsBlocks(pkg)) return true;
-  return fs.existsSync(path.join(projectDir, 'aws-blocks', 'index.ts'))
-    || fs.existsSync(path.join(projectDir, 'aws-blocks', 'index.js'))
-    || fs.existsSync(path.join(projectDir, 'blocks.spec.json'));
-}
-
-function detectAction(input = {}) {
-  const command = normalizeText(input.command || input.args || input.shell || input.toolInput);
-  const toolName = normalizeText(input.toolName || input.tool || input.name);
-  const code = normalizeText(input.code || input.file || input.diff || input.body);
-  const combined = `${toolName}\n${command}\n${code}`;
-  const lower = combined.toLowerCase();
-
-  const signals = [];
-  const add = (id, label, severity = 'medium') => signals.push({ id, label, severity });
-
-  if (/\b(cdk\s+deploy|npm\s+run\s+deploy|pnpm\s+deploy|yarn\s+deploy|sst\s+deploy|blocks?\s+deploy)\b/i.test(combined)) {
-    add('aws-blocks-production-deploy', 'production deploy from an AWS Blocks workflow', 'high');
-  }
-
-  if (/\b(cdk\s+destroy|npm\s+run\s+destroy|pnpm\s+destroy|yarn\s+destroy|sandbox\b.*--destroy|--destroy\b|aws\s+cloudformation\s+delete-stack)\b/i.test(combined)) {
-    add('aws-blocks-destroy', 'destroy command can remove AWS resources created from local Blocks code', 'critical');
-  }
-
-  if (/\b(drop\s+(table|database|schema|index|column)|truncate\s+table|delete\s+from\s+[\w".-]+(?:\s*;|\s*$)|update\s+[\w".-]+\s+set\b(?![\s\S]{0,160}\bwhere\b))/i.test(combined)) {
-    add('destructive-sql-or-ddl', 'destructive or unscoped SQL mutation', 'critical');
-  }
-
-  if (/\b(aws\s+dynamodb\s+delete-table|aws\s+rds\s+delete-db-instance|aws\s+s3\s+rm\b[\s\S]*--recursive|aws\s+lambda\s+delete-function|aws\s+bedrock-agent\s+delete-|aws\s+bedrock-agent-runtime\b)/i.test(combined)) {
-    add('destructive-aws-cli', 'destructive AWS CLI or Bedrock agent action', 'critical');
-  }
-
-  if (/\b(gcloud|aws)\b[\s\S]{0,220}\b(add-iam-policy-binding|put-role-policy|attach-role-policy|create-policy-version)\b/i.test(combined)
-      || /\b(AdministratorAccess|roles\/owner|iam:PassRole|serviceAccountTokenCreator)\b/i.test(combined)) {
-    add('iam-escalation', 'agent session attempts to grant broad IAM authority', 'critical');
-  }
-
-  if (/\b(new\s+Agent\s*\(|@aws-blocks\/(?:agent|blocks)|\bAgent\b[\s\S]{0,120}\btools?\b)/.test(combined)) {
-    add('blocks-agent-tool-call', 'AWS Blocks Agent or Bedrock-style tool action needs a tool boundary', 'medium');
-  }
-
-  if (/\b(npm\s+run\s+dev|npm\s+start|pnpm\s+dev|yarn\s+dev|create-blocks-app)\b/i.test(combined)) {
-    add('local-dev', 'local AWS Blocks development loop', 'low');
-  }
-
-  return {
-    command,
-    toolName,
-    code,
-    signals,
-    highRisk: signals.some((signal) => ['high', 'critical'].includes(signal.severity)),
-    localOnly: signals.some((signal) => signal.id === 'local-dev') && signals.every((signal) => signal.severity === 'low'),
-    lower,
-  };
-}
-
-function evaluateAwsBlocksAction(input = {}) {
-  const projectDir = input.projectDir || input.cwd || process.cwd();
-  const projectUsesAwsBlocks = Boolean(
-    input.projectUsesAwsBlocks
-    || input.awsBlocks
-    || input.blocksProject
-    || detectAwsBlocksProject(projectDir)
-  );
-  const evidence = new Set(toList(input.evidence || input.proof || input.receipts));
-  const action = detectAction(input);
-  const requiredEvidence = [];
-
-  const requireEvidence = (id, label) => {
-    if (!evidence.has(id)) requiredEvidence.push({ id, label });
-  };
-
-  if (projectUsesAwsBlocks && action.signals.some((signal) => signal.id === 'aws-blocks-production-deploy')) {
-    requireEvidence('local-tests-pass', 'local AWS Blocks tests pass against local implementations');
-    requireEvidence('cdk-diff-reviewed', 'CDK diff or synthesized CloudFormation change set reviewed');
-    requireEvidence('cost-blast-radius-reviewed', 'AWS cost and resource blast radius reviewed');
-  }
-
-  if (action.signals.some((signal) => signal.id === 'aws-blocks-destroy')) {
-    requireEvidence('resource-inventory-exported', 'resource inventory exported before destroy');
-    requireEvidence('human-destroy-approval', 'named human approval for destroy');
-  }
-
-  if (action.signals.some((signal) => signal.id === 'destructive-sql-or-ddl')) {
-    requireEvidence('backup-or-rollback-ready', 'backup, rollback, or restore point exists');
-    requireEvidence('bounded-row-count-reviewed', 'row/table impact was previewed before mutation');
-  }
-
-  if (action.signals.some((signal) => signal.id === 'destructive-aws-cli')) {
-    requireEvidence('aws-account-and-region-confirmed', 'target AWS account and region confirmed');
-    requireEvidence('rollback-plan-attached', 'rollback or recovery plan attached');
-  }
-
-  if (action.signals.some((signal) => signal.id === 'iam-escalation')) {
-    requireEvidence('least-privilege-review', 'least-privilege review completed');
-    requireEvidence('security-owner-approval', 'security owner approval captured');
-  }
-
-  if (action.signals.some((signal) => signal.id === 'blocks-agent-tool-call')) {
-    requireEvidence('agent-tool-allowlist', 'agent tool allowlist and data boundary declared');
-  }
-
-  const shouldBlock = projectUsesAwsBlocks && requiredEvidence.length > 0;
-  const status = shouldBlock ? 'blocked' : (action.highRisk ? 'needs-review' : 'allowed');
-
-  return {
-    name: 'thumbgate-aws-blocks-guardrails',
-    status,
-    projectUsesAwsBlocks,
-    signals: action.signals,
-    requiredEvidence,
-    enforcementBoundary: 'local AWS Blocks confidence must not automatically become production AWS authority',
-    gates: [
-      'allow local AWS Blocks dev loops without AWS credentials',
-      'require local test proof plus CDK diff before production deploy',
-      'block destroy and destructive data mutations until backup, blast-radius, and human approval evidence exists',
-      'block IAM escalation and Bedrock/Agent tool expansion until an owner approves the tool boundary',
-      'write a ThumbGate receipt for every allowed high-risk cloud action',
-    ],
-    nextActions: shouldBlock
-      ? requiredEvidence.map((item) => `Provide ${item.id}: ${item.label}`)
-      : ['Record an allow receipt when this action touches real AWS resources'],
-  };
-}
-
-function buildAwsBlocksHardeningOffer(input = {}) {
-  const workflow = String(input.workflow || input.name || 'AWS Blocks backend').trim();
-  const buyer = String(input.buyer || input.owner || 'platform owner').trim();
-  return {
-    name: 'thumbgate-aws-blocks-hardening-offer',
-    status: 'ready-for-positioning',
-    buyer,
-    workflow,
-    headline: 'AWS Blocks helps agents build the backend. ThumbGate stops them before unsafe cloud actions run.',
-    offer: 'AWS Blocks Agent Safety Review',
-    diagnosticPrice: '$499',
-    proofPlan: [
-      'map one AWS Blocks local-to-cloud workflow',
-      'install ThumbGate against the agent running that workflow',
-      'add gates for deploy, destroy, data mutation, IAM, Bedrock Agent, and cost-blast-radius actions',
-      'produce a receipt showing the first blocked repeat and the evidence required to allow it',
-    ],
-    cta: 'Send one AWS Blocks workflow that is about to deploy, mutate data, or call Bedrock tools.',
-  };
-}
-
-function parseArgs(argv = process.argv.slice(2)) {
-  const args = {};
-  for (const arg of argv) {
-    if (arg === '--json') args.json = true;
-    else if (arg === '--aws-blocks' || arg === '--project-uses-aws-blocks') args.projectUsesAwsBlocks = true;
-    else if (arg.startsWith('--command=')) args.command = arg.slice('--command='.length);
-    else if (arg.startsWith('--tool=')) args.toolName = arg.slice('--tool='.length);
-    else if (arg.startsWith('--code=')) args.code = arg.slice('--code='.length);
-    else if (arg.startsWith('--cwd=')) args.projectDir = arg.slice('--cwd='.length);
-    else if (arg.startsWith('--evidence=')) args.evidence = arg.slice('--evidence='.length);
-    else if (arg.startsWith('--workflow=')) args.workflow = arg.slice('--workflow='.length);
-    else if (arg.startsWith('--buyer=')) args.buyer = arg.slice('--buyer='.length);
-    else if (arg === 'offer') args.commandName = 'offer';
-  }
-  return args;
-}
-
-function runCli(args = parseArgs()) {
-  const report = args.commandName === 'offer'
-    ? buildAwsBlocksHardeningOffer(args)
-    : evaluateAwsBlocksAction(args);
-  if (args.json) console.log(JSON.stringify(report, null, 2));
-  else {
-    console.log(`${report.name}: ${report.status}`);
-    for (const action of report.nextActions || report.proofPlan || []) console.log(`- ${action}`);
-  }
-}
-
-if (require.main === module) runCli();
-
-module.exports = {
-  detectAwsBlocksProject,
-  detectAction,
-  evaluateAwsBlocksAction,
-  buildAwsBlocksHardeningOffer,
-};

package/scripts/classifier-routing.js

@@ -1,130 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-
-const DEFAULT_CONFIG_PATH = path.join(__dirname, '..', 'config', 'gate-classifier-routing.json');
-
-function clamp01(value, fallback = 0) {
-  const number = Number(value);
-  if (!Number.isFinite(number)) return fallback;
-  return Math.min(1, Math.max(0, number));
-}
-
-function riskRank(risk) {
-  const normalized = String(risk || 'medium').toLowerCase();
-  if (['critical', 'block', 'regulated'].includes(normalized)) return 4;
-  if (['high', 'dangerous'].includes(normalized)) return 3;
-  if (['medium', 'warn'].includes(normalized)) return 2;
-  return 1;
-}
-
-function loadClassifierRoutingConfig(configPath = DEFAULT_CONFIG_PATH) {
-  return JSON.parse(fs.readFileSync(configPath, 'utf8'));
-}
-
-function lane(config, laneName, reason, input, overrides = {}) {
-  const laneConfig = (config.lanes && config.lanes[laneName]) || {};
-  return {
-    lane: laneName,
-    reason,
-    requiresEvidence: Boolean(laneConfig.requiresEvidence || overrides.requiresEvidence),
-    cloudAllowed: Boolean(laneConfig.cloudAllowed),
-    maxLatencyMs: laneConfig.maxLatencyMs,
-    risk: String(input.risk || 'medium').toLowerCase(),
-    ambiguity: clamp01(input.ambiguity),
-  };
-}
-
-function routeClassifier(input = {}, config = loadClassifierRoutingConfig()) {
-  const thresholds = config.thresholds || {};
-  const labelCount = Number(input.labelCount || input.examples || 0);
-  const latencyBudgetMs = Number(input.latencyBudgetMs || 0);
-  const ambiguity = clamp01(input.ambiguity);
-  const risk = riskRank(input.risk);
-  const largeBatch = Number(input.batchRows || 0) >= Number(thresholds.largeBatchRows || 50);
-  const privacySensitive = Boolean(input.privacySensitive || input.containsSecrets || input.customerData);
-  const allowCloud = Boolean(input.allowCloud);
-
-  if (input.hasHardRule || input.exactPolicyMatch) {
-    return lane(config, 'deterministic', 'exact hard rule or policy match; do not spend model tokens', input);
-  }
-
-  if (input.semanticCacheHit || input.equivalentRepeat) {
-    return lane(config, 'semantic_cache', 'semantically equivalent repeat; reuse the proven prior decision without a model call', input);
-  }
-
-  if (input.rubricFailed || input.missingEvidence || input.completionClaimWithoutProof) {
-    return lane(config, 'rubric_gate', 'rubric or completion evidence failed; block done claims until proof exists', input);
-  }
-
-  if (input.structuredDataset && (input.missingProvenance || input.missingSources)) {
-    return lane(config, 'rubric_gate', 'structured data claim is missing source provenance', input);
-  }
-
-  if (privacySensitive && !allowCloud && risk >= 3 && ambiguity >= Number(thresholds.mediumAmbiguity || 0.35)) {
-    return lane(config, 'human_review', 'private high-risk ambiguous action; keep data local and require approval', input);
-  }
-
-  if (labelCount >= Number(thresholds.classicalMinExamples || 40) && (largeBatch || latencyBudgetMs <= Number(thresholds.lowLatencyBudgetMs || 300)) && ambiguity < Number(thresholds.mediumAmbiguity || 0.35)) {
-    return lane(config, 'local_classical', 'enough examples and low ambiguity; use cheap local classification', input);
-  }
-
-  if (risk >= 3 && ambiguity >= Number(thresholds.highRiskAmbiguity || 0.65)) {
-    if (allowCloud && latencyBudgetMs >= Number(thresholds.llmMinLatencyBudgetMs || 2000)) {
-      return lane(config, 'llm_judge', 'high-risk semantic ambiguity; use a budget-capped LLM judge with evidence', input);
-    }
-    return lane(config, 'human_review', 'high-risk ambiguity without approved cloud/budget route', input);
-  }
-
-  if (labelCount < Number(thresholds.classicalMinExamples || 40) || ambiguity >= Number(thresholds.mediumAmbiguity || 0.35)) {
-    return lane(config, 'local_semantic', 'sparse labels or fuzzy intent; use local semantic recall before any LLM', input);
-  }
-
-  return lane(config, config.defaultLane || 'local_classical', 'default local route for routine gate classification', input);
-}
-
-function explainClassifierRoute(input = {}, config = loadClassifierRoutingConfig()) {
-  const decision = routeClassifier(input, config);
-  const laneConfig = (config.lanes && config.lanes[decision.lane]) || {};
-  return {
-    ...decision,
-    description: laneConfig.description || '',
-    useFor: laneConfig.useFor || [],
-  };
-}
-
-function parseArgs(argv) {
-  const input = {};
-  for (const arg of argv) {
-    if (arg === '--hard-rule') input.hasHardRule = true;
-    else if (arg === '--privacy-sensitive') input.privacySensitive = true;
-    else if (arg === '--allow-cloud') input.allowCloud = true;
-    else if (arg === '--customer-data') input.customerData = true;
-    else if (arg === '--semantic-cache-hit') input.semanticCacheHit = true;
-    else if (arg === '--equivalent-repeat') input.equivalentRepeat = true;
-    else if (arg === '--rubric-failed') input.rubricFailed = true;
-    else if (arg === '--missing-evidence') input.missingEvidence = true;
-    else if (arg === '--structured-dataset') input.structuredDataset = true;
-    else if (arg === '--missing-provenance') input.missingProvenance = true;
-    else if (arg.startsWith('--risk=')) input.risk = arg.slice('--risk='.length);
-    else if (arg.startsWith('--ambiguity=')) input.ambiguity = Number(arg.slice('--ambiguity='.length));
-    else if (arg.startsWith('--labels=')) input.labelCount = Number(arg.slice('--labels='.length));
-    else if (arg.startsWith('--latency-ms=')) input.latencyBudgetMs = Number(arg.slice('--latency-ms='.length));
-    else if (arg.startsWith('--batch-rows=')) input.batchRows = Number(arg.slice('--batch-rows='.length));
-  }
-  return input;
-}
-
-module.exports = {
-  DEFAULT_CONFIG_PATH,
-  explainClassifierRoute,
-  loadClassifierRoutingConfig,
-  routeClassifier,
-};
-
-if (require.main === module) {
-  const decision = explainClassifierRoute(parseArgs(process.argv.slice(2)));
-  process.stdout.write(`${JSON.stringify(decision, null, 2)}\n`);
-}

package/scripts/dashboard-chat.js

@@ -1,332 +0,0 @@
-'use strict';
-
-// scripts/dashboard-chat.js
-// -----------------------------------------------------------------------------
-// "Chat with your data" — the dashboard chat backend. Local-first RAG over
-// this install's ThumbGate data (lessons, raw feedback memories via LanceDB
-// vectors, receipts, gate stats). Retrieval is local (lesson search + optional
-// vector-store.searchSimilar). Generation uses your configured LLM: a local
-// OpenAI-compatible endpoint first, then Gemini or Perplexity when explicitly
-// configured.
-//
-// Dialogflow/Google is not the dashboard chatbot brain. It remains an optional
-// guard-adapter path for buyers who already run their own Google agent tenancy.
-// -----------------------------------------------------------------------------
-
-const path = require('path');
-
-const GEMINI_ENDPOINT = 'https://generativelanguage.googleapis.com/v1beta/models';
-const PERPLEXITY_ENDPOINT = 'https://api.perplexity.ai/chat/completions';
-const DEFAULT_MODEL = 'gemini-2.5-flash';
-const MAX_QUESTION_CHARS = 2000;
-const MAX_CONTEXT_LESSONS = 8;
-
-// Allowlist the model so a user-supplied `model` cannot route the call to an
-// arbitrary / unexpected (or more expensive) endpoint. Anything not on the list
-// falls back to the default.
-const ALLOWED_MODELS = new Set([
-  'gemini-2.5-flash', 'gemini-2.5-flash-lite', 'gemini-2.5-pro',
-  'gemini-2.0-flash', 'gemini-2.0-flash-lite',
-  'gemini-flash-latest', 'gemini-flash-lite-latest', 'gemini-pro-latest',
-]);
-
-function resolveModel(requested) {
-  const r = String(requested || '').trim();
-  if (r && ALLOWED_MODELS.has(r)) return r;
-  const envModel = String(process.env.THUMBGATE_GEMINI_MODEL || '').trim();
-  if (envModel && ALLOWED_MODELS.has(envModel)) return envModel;
-  return DEFAULT_MODEL;
-}
-
-function resolveApiKey(opts = {}) {
-  let key = '';
-  if (Object.hasOwn(opts, 'apiKey')) {
-    key = opts.apiKey || '';
-  } else {
-    key = opts.apiKey || process.env.GEMINI_API_KEY || process.env.THUMBGATE_GEMINI_API_KEY || process.env.GOOGLE_API_KEY || process.env.PERPLEXITY_API_KEY || process.env.THUMBGATE_PERPLEXITY_API_KEY || '';
-  }
-  if (!key) return '';
-  return key.trim().replace(/^["']|["']$/g, '');
-}
-
-function debugChatFallback(label, err) {
-  if (process.env.THUMBGATE_DEBUG_CHAT !== '1') return;
-  const detail = err?.message ? err.message : String(err);
-  console.warn(`[dashboard-chat] ${label}: ${detail}`);
-}
-
-function loadLessonSearcher() {
-  try {
-    return require(path.join(__dirname, 'lesson-search')).searchLessons;
-  } catch (err) {
-    debugChatFallback('lesson search unavailable', err);
-    return null;
-  }
-}
-
-function lessonToContextItem(lesson) {
-  return {
-    id: lesson.id,
-    signal: lesson.signal || lesson.feedback || '',
-    title: (lesson.title || '').replace(/^(?:MISTAKE|SUCCESS):\s*/i, '').slice(0, 160),
-    content: String(lesson.content || lesson.context || '').replace(/\s+/g, ' ').trim().slice(0, 600),
-    tags: lesson.tags || [],
-    source: 'lessons',
-  };
-}
-
-function vectorMatchToContextItem(match, index) {
-  return {
-    id: match.id || `vec-${index}`,
-    signal: match.signal || '',
-    title: String(match.context || match.text || '').slice(0, 100),
-    content: match.text || match.context || '',
-    tags: match.tags ? String(match.tags).split(',').filter(Boolean) : [],
-    source: 'lancedb-vector',
-  };
-}
-
-function dedupeContextItems(items, limit = MAX_CONTEXT_LESSONS + 3) {
-  const seen = new Set();
-  return items.filter((item) => {
-    if (!(item.content || item.title)) return false;
-    const key = item.id || item.content.slice(0, 80);
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  }).slice(0, limit);
-}
-
-function retrieveLessonContext(question, opts = {}) {
-  const searchLessons = loadLessonSearcher();
-  if (!searchLessons) return [];
-  try {
-    const res = searchLessons(String(question || ''), {
-      limit: MAX_CONTEXT_LESSONS,
-      feedbackDir: opts.feedbackDir,
-    });
-    const rows = res?.results || res?.lessons || [];
-    return rows.slice(0, MAX_CONTEXT_LESSONS).map(lessonToContextItem);
-  } catch (err) {
-    debugChatFallback('lesson retrieval failed', err);
-    return [];
-  }
-}
-
-async function retrieveVectorContext(question, opts = {}) {
-  if (opts.useVectorSearch === false) return [];
-  try {
-    const vectorStore = require(path.join(__dirname, 'vector-store'));
-    const vecResults = vectorStore.searchSimilar
-      ? await vectorStore.searchSimilar(String(question || ''), opts.vectorLimit || 4)
-      : [];
-    return vecResults
-      .filter((match) => match?.text)
-      .map(vectorMatchToContextItem);
-  } catch (err) {
-    debugChatFallback('vector retrieval failed', err);
-    return [];
-  }
-}
-
-// Live numeric snapshot from gate-stats + feedback analyzer. Always injected
-// (~120 tokens) so the LLM can answer count/quantity questions like
-// "how many were blocked today" without hallucinating.
-function retrieveMetricsContext() {
-  const snapshot = {};
-  try {
-    const gs = require(path.join(__dirname, 'gate-stats'));
-    const s = gs.calculateStats();
-    snapshot.gates = {
-      total: s.totalGates,
-      blockRules: s.blockGates,
-      warnRules: s.warnGates,
-      totalBlockedEvents: s.totalBlocked,
-      totalWarnedEvents: s.totalWarned,
-      estimatedHoursSaved: s.estimatedHoursSaved,
-      topBlockedTrigger: s.topBlocked?.trigger || null,
-      topBlockedOccurrences: s.topBlocked?.occurrences || 0,
-    };
-  } catch (err) {
-    debugChatFallback('gate-stats unavailable', err);
-  }
-  try {
-    const fl = require(path.join(__dirname, 'feedback-loop'));
-    const a = fl.analyzeFeedback();
-    snapshot.feedback = {
-      total: a.total,
-      positive: a.totalPositive,
-      negative: a.totalNegative,
-      approvalRate: a.approvalRate,
-      last7d: a.windows?.['7d'],
-      last30d: a.windows?.['30d'],
-      trend: a.trend,
-    };
-  } catch (err) {
-    debugChatFallback('feedback-loop analyze unavailable', err);
-  }
-  return snapshot;
-}
-
-// Retrieve relevant stored lessons and optional raw feedback vector matches.
-async function retrieveContext(question, opts = {}) {
-  const lessons = retrieveLessonContext(question, opts);
-  const vectors = await retrieveVectorContext(question, opts);
-  return dedupeContextItems([...lessons, ...vectors]);
-}
-
-// Build a grounded RAG prompt. Pure function (testable).
-function buildChatPrompt(question, lessons, metrics) {
-  const q = String(question || '').slice(0, MAX_QUESTION_CHARS).trim();
-  const context = (lessons || []).map((l, i) => {
-    const mark = /pos|up/i.test(l.signal) ? 'WORKED' : (/neg|down/i.test(l.signal) ? 'MISTAKE' : 'NOTE');
-    const tags = (l.tags || []).length ? ` [tags: ${l.tags.join(', ')}]` : '';
-    return `(${i + 1}) [${mark}] ${l.title || ''}${tags}\n    ${l.content}`;
-  }).join('\n');
-
-  const metricsBlock = metrics && Object.keys(metrics).length
-    ? `\n=== Live numeric snapshot (your data, current) ===\n${JSON.stringify(metrics, null, 2)}\n`
-    : '';
-
-  const system = [
-    'You are ThumbGate\'s "chat with your data" assistant. Answer the user\'s question',
-    'using ONLY the captured lessons and the live numeric snapshot below (this team\'s real data).',
-    'For count/quantity questions ("how many X", "what\'s our rate"), use the numeric snapshot.',
-    'For pattern/why questions, cite the lesson numbers like [1], [3].',
-    'If neither source contains the answer, say so plainly — do not invent facts.',
-  ].join(' ');
-
-  return `${system}\n\n=== Captured lessons (your data) ===\n${context || '(no relevant lessons found)'}\n${metricsBlock}\n=== Question ===\n${q}`;
-}
-
-// Parse the Gemini generateContent response into plain text. Pure (testable).
-function parseGeminiAnswer(body) {
-  const parts = body?.candidates?.[0]?.content?.parts;
-  if (!Array.isArray(parts)) return '';
-  return parts.map((p) => (p && typeof p.text === 'string' ? p.text : '')).join('').trim();
-}
-
-function buildOpenAiChatPayload(prompt, model) {
-  return JSON.stringify({
-    model,
-    messages: [{ role: 'user', content: prompt }],
-    temperature: 0.2,
-    max_tokens: 1024,
-  });
-}
-
-function parseOpenAiChatAnswer(json) {
-  return json?.choices?.[0]?.message?.content || '';
-}
-
-function parseModelError(json, status) {
-  return json?.error?.message ? String(json.error.message).split('\n')[0] : `HTTP ${status}`;
-}
-
-function trimTrailingSlashes(value) {
-  let text = String(value || '');
-  while (text.endsWith('/')) {
-    text = text.slice(0, -1);
-  }
-  return text;
-}
-
-async function callLocalOpenAiEndpoint({ endpoint, apiKey, model, prompt, fetchImpl, sources }) {
-  const url = endpoint.includes('/chat/completions')
-    ? endpoint
-    : `${trimTrailingSlashes(endpoint)}/chat/completions`;
-  const res = await fetchImpl(url, {
-    method: 'POST',
-    headers: {
-      'content-type': 'application/json',
-      'Authorization': `Bearer ${apiKey || 'local'}`
-    },
-    body: buildOpenAiChatPayload(prompt, model),
-  });
-  const json = await res.json().catch(() => ({}));
-  if (!res.ok) {
-    return { ok: false, error: 'local_llm_error', status: res.status, message: parseModelError(json, res.status), sources };
-  }
-  const answer = parseOpenAiChatAnswer(json);
-  return { ok: true, answer: answer.trim() || '(no answer returned)', sources, model: json.model || model };
-}
-
-async function callPerplexityEndpoint({ apiKey, prompt, fetchImpl, sources }) {
-  const res = await fetchImpl(PERPLEXITY_ENDPOINT, {
-    method: 'POST',
-    headers: { 'content-type': 'application/json', 'Authorization': `Bearer ${apiKey}` },
-    body: buildOpenAiChatPayload(prompt, 'sonar'),
-  });
-  const json = await res.json().catch(() => ({}));
-  if (!res.ok) {
-    return { ok: false, error: 'perplexity_error', status: res.status, message: parseModelError(json, res.status), sources };
-  }
-  const answer = parseOpenAiChatAnswer(json);
-  return { ok: true, answer: answer.trim() || '(no answer returned)', sources, model: json.model || 'perplexity-hybrid' };
-}
-
-async function callGeminiEndpoint({ apiKey, model, prompt, fetchImpl, sources }) {
-  const res = await fetchImpl(`${GEMINI_ENDPOINT}/${encodeURIComponent(model)}:generateContent`, {
-    method: 'POST',
-    headers: { 'content-type': 'application/json', 'x-goog-api-key': apiKey },
-    body: JSON.stringify({
-      contents: [{ role: 'user', parts: [{ text: prompt }] }],
-      generationConfig: { temperature: 0.2, maxOutputTokens: 1024 },
-    }),
-  });
-  const json = await res.json().catch(() => ({}));
-  if (!res.ok) {
-    return { ok: false, error: 'gemini_error', status: res.status, message: parseModelError(json, res.status), sources };
-  }
-  const answer = parseGeminiAnswer(json);
-  return { ok: true, answer: answer || '(no answer returned)', sources, model: json.modelVersion || model };
-}
-
-// Answer a question grounded in this install's lessons. Returns
-// { ok, answer, sources, model } or { ok:false, error, ... }.
-async function answerDataQuestion(question, opts = {}) {
-  const q = String(question || '').trim();
-  if (!q) return { ok: false, error: 'empty_question', message: 'Ask a question about your data.' };
-  if (q.length > MAX_QUESTION_CHARS) {
-    return { ok: false, error: 'question_too_long', message: `Question exceeds ${MAX_QUESTION_CHARS} characters.` };
-  }
-
-  const localEndpoint = opts.localEndpoint || process.env.THUMBGATE_LOCAL_LLM_ENDPOINT || '';
-  const localModel = opts.localModel || process.env.THUMBGATE_LOCAL_LLM_MODEL || 'llama3';
-  const apiKey = resolveApiKey(opts);
-  const lessons = await retrieveContext(q, opts);
-  const sources = lessons.map((l) => ({ id: l.id, title: l.title, signal: l.signal }));
-
-  if (!apiKey && !localEndpoint) {
-    return {
-      ok: false,
-      error: 'no_api_key',
-      message: 'Chat is not configured. Set a valid GEMINI_API_KEY, PERPLEXITY_API_KEY, or THUMBGATE_LOCAL_LLM_ENDPOINT in the project .env.',
-      sources,
-    };
-  }
-
-  const model = resolveModel(opts.model);
-  const metrics = retrieveMetricsContext();
-  const prompt = buildChatPrompt(q, lessons, metrics);
-  const fetchImpl = opts.fetch || globalThis.fetch;
-  const isPerplexity = apiKey && (apiKey.startsWith('pplx-') || apiKey.includes('perplexity'));
-
-  try {
-    if (localEndpoint) return await callLocalOpenAiEndpoint({ endpoint: localEndpoint, apiKey, model: localModel, prompt, fetchImpl, sources });
-    if (isPerplexity) return await callPerplexityEndpoint({ apiKey, prompt, fetchImpl, sources });
-    return await callGeminiEndpoint({ apiKey, model, prompt, fetchImpl, sources });
-  } catch (err) {
-    const safeMessage = (err && err.message) ? String(err.message).split('\n')[0].slice(0, 100) : 'An unexpected error occurred.';
-    return { ok: false, error: 'network', message: safeMessage, sources };
-  }
-}
-
-module.exports = {
-  answerDataQuestion,
-  buildChatPrompt,
-  parseGeminiAnswer,
-  retrieveContext,
-  DEFAULT_MODEL,
-  MAX_QUESTION_CHARS,
-};