thumbgate 0.9.9

package/scripts/filesystem-search.js

@@ -0,0 +1,405 @@
+'use strict';
+
+/**
+ * Filesystem Search — Embedding-Free Knowledge Retrieval
+ *
+ * Replaces LanceDB vector similarity search with deterministic filesystem
+ * operations (grep, token matching, recency weighting) over existing JSONL
+ * and ContextFS data. Inspired by Vercel's "knowledge agents without embeddings"
+ * approach: give the agent a filesystem and bash instead of vectors.
+ *
+ * Advantages over vector-store.js:
+ * - Zero binary dependencies (no LanceDB, no HuggingFace ONNX)
+ * - Deterministic, inspectable, debuggable retrieval
+ * - Works immediately without embedding model download
+ * - ~75% cheaper (no embedding compute)
+ * - Data is always the JSONL source of truth (no sync drift)
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const { resolveFeedbackDir } = require('./feedback-paths');
+
+const PROJECT_ROOT = path.join(__dirname, '..');
+const DEFAULT_FEEDBACK_DIR = resolveFeedbackDir();
+const DEFAULT_CONTEXTFS_DIR = path.join(DEFAULT_FEEDBACK_DIR, 'contextfs');
+
+// ---------------------------------------------------------------------------
+// Core utilities
+// ---------------------------------------------------------------------------
+
+function getFeedbackDir() {
+  return resolveFeedbackDir();
+}
+
+function getContextFsDir() {
+  return process.env.THUMBGATE_CONTEXTFS_DIR || path.join(getFeedbackDir(), 'contextfs');
+}
+
+function readJsonl(filePath) {
+  if (!fs.existsSync(filePath)) return [];
+  const raw = fs.readFileSync(filePath, 'utf-8').trim();
+  if (!raw) return [];
+  return raw.split('\n').map((line) => {
+    try { return JSON.parse(line); } catch { return null; }
+  }).filter(Boolean);
+}
+
+function listJsonFiles(dirPath) {
+  if (!fs.existsSync(dirPath)) return [];
+  const results = [];
+  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = path.join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...listJsonFiles(full));
+    } else if (entry.isFile() && entry.name.endsWith('.json')) {
+      results.push(full);
+    }
+  }
+  return results;
+}
+
+function tokenize(text) {
+  return String(text || '').toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
+}
+
+function unique(arr) {
+  return [...new Set(arr)];
+}
+
+// ---------------------------------------------------------------------------
+// Scoring: token overlap + recency boost + signal weighting
+// ---------------------------------------------------------------------------
+
+function jaccardSimilarity(tokensA, tokensB) {
+  const setA = new Set(unique(tokensA));
+  const setB = new Set(unique(tokensB));
+  if (setA.size === 0 && setB.size === 0) return 1;
+  if (setA.size === 0 || setB.size === 0) return 0;
+  let intersection = 0;
+  for (const t of setA) {
+    if (setB.has(t)) intersection++;
+  }
+  const union = setA.size + setB.size - intersection;
+  return union === 0 ? 0 : intersection / union;
+}
+
+function substringBoost(query, text) {
+  const q = query.toLowerCase();
+  const t = text.toLowerCase();
+  if (t.includes(q)) return 0.3;
+  const words = q.split(/\s+/).filter((w) => w.length > 2);
+  const matched = words.filter((w) => t.includes(w)).length;
+  return words.length > 0 ? (matched / words.length) * 0.2 : 0;
+}
+
+function recencyScore(timestamp) {
+  if (!timestamp) return 0;
+  const ms = typeof timestamp === 'number' ? timestamp : new Date(timestamp).getTime();
+  if (!Number.isFinite(ms)) return 0;
+  const ageHours = (Date.now() - ms) / (1000 * 60 * 60);
+  if (ageHours <= 24) return 0.15;
+  if (ageHours <= 168) return 0.1;
+  if (ageHours <= 720) return 0.05;
+  return 0;
+}
+
+function scoreRecord(queryTokens, queryText, record) {
+  const recordText = [
+    record.context || '',
+    record.whatWentWrong || record.what_went_wrong || '',
+    record.whatWorked || record.what_worked || '',
+    record.whatToChange || record.what_to_change || '',
+    (record.tags || []).join(' '),
+    record.pattern || '',
+    record.message || '',
+    record.query || '',
+    record.outcome || '',
+  ].filter(Boolean).join(' ');
+
+  const recordTokens = tokenize(recordText);
+  const jaccard = jaccardSimilarity(queryTokens, recordTokens);
+  const substr = substringBoost(queryText, recordText);
+  const recency = recencyScore(record.timestamp);
+  const signalBoost = record.signal === 'down' ? 0.05 : 0;
+
+  return {
+    score: jaccard + substr + recency + signalBoost,
+    record,
+    matchedTokens: unique(queryTokens).filter((t) => new Set(recordTokens).has(t)),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Search functions (drop-in replacements for vector-store.js exports)
+// ---------------------------------------------------------------------------
+
+function searchFeedbackLog(queryText, limit = 5, options = {}) {
+  const logPath = path.join(getFeedbackDir(), 'feedback-log.jsonl');
+  let records = readJsonl(logPath);
+
+  // SQLite fallback: if JSONL is empty/tiny, pull records from the lesson DB
+  if (records.length <= 1) {
+    try {
+      const { initDB } = require('./lesson-db');
+      const db = initDB();
+      const rows = db.prepare('SELECT * FROM lessons ORDER BY timestamp DESC LIMIT 500').all();
+      if (rows.length > records.length) {
+        records = rows.map((r) => ({
+          id: r.id,
+          signal: r.signal,
+          context: r.context,
+          title: r.title || r.context,
+          tags: r.tags ? JSON.parse(r.tags) : [],
+          timestamp: r.timestamp,
+          whatWentWrong: r.what_went_wrong,
+          whatWorked: r.what_worked,
+          whatToChange: r.what_to_change,
+        }));
+      }
+    } catch { /* lesson-db not available */ }
+  }
+
+  // Wildcard query: return all records sorted by recency
+  const isWildcard = queryText === '*' || queryText === '';
+  const queryTokens = isWildcard ? [] : tokenize(queryText);
+
+  let scored = isWildcard
+    ? records.map((r) => ({ score: recencyScore(r.timestamp) || 0.01, record: r, matchedTokens: [] }))
+    : records.map((r) => scoreRecord(queryTokens, queryText, r));
+
+  if (options.where) {
+    scored = scored.filter((s) => {
+      if (options.where.signal && s.record.signal !== options.where.signal) return false;
+      if (options.where.tags) {
+        const requiredTags = options.where.tags.split(',').map((t) => t.trim());
+        const recordTags = s.record.tags || [];
+        if (!requiredTags.some((rt) => recordTags.includes(rt))) return false;
+      }
+      return true;
+    });
+  }
+
+  return scored
+    .filter((s) => s.score > 0)
+    .sort((a, b) => b.score - a.score)
+    .slice(0, limit)
+    .map((s) => ({
+      ...s.record,
+      _score: s.score,
+      _matchedTokens: s.matchedTokens,
+    }));
+}
+
+function searchContextFs(queryText, limit = 5, options = {}) {
+  const contextDir = getContextFsDir();
+  const namespaces = options.namespaces || ['memory/error', 'memory/learning', 'rules', 'raw_history'];
+  const queryTokens = tokenize(queryText);
+  const scored = [];
+
+  for (const ns of namespaces) {
+    const nsDir = path.join(contextDir, ns);
+    const files = listJsonFiles(nsDir);
+
+    for (const filePath of files) {
+      try {
+        const raw = fs.readFileSync(filePath, 'utf-8');
+        const record = JSON.parse(raw);
+        record._source = path.relative(contextDir, filePath);
+        record._namespace = ns;
+        const result = scoreRecord(queryTokens, queryText, record);
+        if (result.score > 0) {
+          scored.push(result);
+        }
+      } catch {
+        // Skip malformed files
+      }
+    }
+  }
+
+  return scored
+    .sort((a, b) => b.score - a.score)
+    .slice(0, limit)
+    .map((s) => ({
+      ...s.record,
+      _score: s.score,
+      _matchedTokens: s.matchedTokens,
+    }));
+}
+
+function searchPreventionRules(queryText, limit = 5) {
+  const rulesPath = path.join(getFeedbackDir(), 'prevention-rules.md');
+  if (!fs.existsSync(rulesPath)) return [];
+
+  const content = fs.readFileSync(rulesPath, 'utf-8');
+  const queryTokens = tokenize(queryText);
+  const blocks = content.split(/^#{1,3}\s+/m).filter(Boolean);
+
+  return blocks
+    .map((block) => {
+      const lines = block.trim().split('\n');
+      const title = lines[0] || '';
+      const body = lines.slice(1).join('\n').trim();
+      const tokens = tokenize(`${title} ${body}`);
+      const jaccard = jaccardSimilarity(queryTokens, tokens);
+      const substr = substringBoost(queryText, `${title} ${body}`);
+      return { title, body, score: jaccard + substr };
+    })
+    .filter((r) => r.score > 0)
+    .sort((a, b) => b.score - a.score)
+    .slice(0, limit)
+    .map((r) => ({ ...r, _score: r.score }));
+}
+
+// ---------------------------------------------------------------------------
+// Unified search — searches all sources and merges results
+// ---------------------------------------------------------------------------
+
+function searchAll(queryText, limit = 10, options = {}) {
+  const feedbackResults = searchFeedbackLog(queryText, limit, options);
+  const contextResults = searchContextFs(queryText, limit, options);
+  const ruleResults = searchPreventionRules(queryText, limit);
+
+  const merged = [
+    ...feedbackResults.map((r) => ({ ...r, _source_type: 'feedback' })),
+    ...contextResults.map((r) => ({ ...r, _source_type: 'contextfs' })),
+    ...ruleResults.map((r) => ({ ...r, _source_type: 'prevention_rule' })),
+  ];
+
+  return merged
+    .sort((a, b) => (b._score || 0) - (a._score || 0))
+    .slice(0, limit);
+}
+
+// ---------------------------------------------------------------------------
+// Drop-in compatibility with vector-store.js interface
+// ---------------------------------------------------------------------------
+
+async function searchSimilar(queryText, limit = 5, options = {}) {
+  return searchAll(queryText, limit, options);
+}
+
+async function upsertFeedback(feedbackEvent) {
+  // No-op: feedback is already written to JSONL by feedback-loop.js.
+  // The filesystem IS the index. No separate upsert needed.
+  // Yield to microtask queue so trackBackgroundSideEffect captures a pending promise.
+  await Promise.resolve();
+  return feedbackEvent;
+}
+
+async function upsertPreventionRule(_rule) {
+  // No-op: prevention rules are already in prevention-rules.md
+  return _rule;
+}
+
+async function upsertContextPack(_pack) {
+  // No-op: context packs are already in contextfs/
+  return _pack;
+}
+
+async function searchPreventionRulesCompat(queryText, limit = 5, _options = {}) {
+  return searchPreventionRules(queryText, limit);
+}
+
+async function searchContextPacks(queryText, limit = 5, options = {}) {
+  return searchContextFs(queryText, limit, {
+    ...options,
+    namespaces: options.namespaces || ['session'],
+  });
+}
+
+function getEmbeddingConfig() {
+  return {
+    selectedProfile: { id: 'filesystem', model: 'none', quantized: false, maxChars: Infinity },
+    fallbackProfile: { id: 'filesystem', model: 'none', quantized: false, maxChars: Infinity },
+    reason: 'Filesystem search — no embeddings needed',
+  };
+}
+
+function getLastEmbeddingProfile() {
+  return {
+    activeProfile: { id: 'filesystem', model: 'none', quantized: false },
+    fallbackUsed: false,
+    reason: 'Filesystem search — no embeddings needed',
+  };
+}
+
+function getVersionSnapshot() {
+  return Promise.resolve({
+    rlhf_memories: null,
+    prevention_rules: null,
+    context_packs: null,
+    engine: 'filesystem-search',
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Stats / diagnostics
+// ---------------------------------------------------------------------------
+
+function getSearchStats() {
+  const feedbackPath = path.join(getFeedbackDir(), 'feedback-log.jsonl');
+  const contextDir = getContextFsDir();
+  const rulesPath = path.join(getFeedbackDir(), 'prevention-rules.md');
+
+  return {
+    engine: 'filesystem-search',
+    feedbackEntries: readJsonl(feedbackPath).length,
+    contextFsFiles: listJsonFiles(contextDir).length,
+    preventionRulesExist: fs.existsSync(rulesPath),
+    feedbackDir: getFeedbackDir(),
+    contextFsDir: contextDir,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// CLI
+// ---------------------------------------------------------------------------
+
+if (require.main === module) {
+  const query = process.argv.slice(2).join(' ') || 'test failure';
+  console.log(`Searching for: "${query}"`);
+  console.log('');
+
+  const stats = getSearchStats();
+  console.log('Search stats:', JSON.stringify(stats, null, 2));
+  console.log('');
+
+  const results = searchAll(query, 5);
+  console.log(`Found ${results.length} results:`);
+  results.forEach((r, i) => {
+    console.log(`  ${i + 1}. [${r._source_type}] score=${r._score?.toFixed(3)} tokens=${(r._matchedTokens || []).join(',')}`);
+    if (r.context) console.log(`     context: ${r.context.slice(0, 120)}`);
+    if (r.title) console.log(`     rule: ${r.title}`);
+  });
+}
+
+module.exports = {
+  // Primary search API
+  searchFeedbackLog,
+  searchContextFs,
+  searchPreventionRulesSync: searchPreventionRules,
+  searchAll,
+  getSearchStats,
+
+  // Drop-in vector-store.js compatibility
+  searchSimilar,
+  upsertFeedback,
+  upsertPreventionRule,
+  searchPreventionRules: searchPreventionRulesCompat,
+  upsertContextPack,
+  searchContextPacks,
+  getEmbeddingConfig,
+  getLastEmbeddingProfile,
+  getVersionSnapshot,
+  TABLE_NAME: 'rlhf_memories',
+  TABLE_PREVENTION_RULES: 'prevention_rules',
+  TABLE_CONTEXT_PACKS: 'context_packs',
+
+  // Test helpers (no-ops — no pipeline to mock)
+  setPipelineLoaderForTests: () => {},
+  setLanceLoaderForTests: () => {},
+  truncateForEmbedding: (text) => String(text || ''),
+};

package/scripts/funnel-analytics.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+const { getBusinessAnalytics } = require('./billing');
+
+function generateFunnelReport() {
+  const analytics = getBusinessAnalytics();
+  console.log('╔══════════════════════════════════════════════════════╗');
+  console.log('║      Marketing & Revenue Funnel Analytics            ║');
+  console.log('╠══════════════════════════════════════════════════════╣');
+  console.log(`║  Traffic Visitors:                  ${String((analytics.trafficMetrics && analytics.trafficMetrics.visitors) || 0).padStart(6)}           ║`);
+  console.log(`║  CTA Clicks:                        ${String((analytics.trafficMetrics && analytics.trafficMetrics.ctaClicks) || 0).padStart(6)}           ║`);
+  console.log(`║  Unique Leads:                      ${String(analytics.signups.uniqueLeads).padStart(6)}           ║`);
+  console.log(`║  Sprint Leads:                      ${String((analytics.pipeline.workflowSprintLeads && analytics.pipeline.workflowSprintLeads.total) || 0).padStart(6)}           ║`);
+  console.log(`║  Paid Provider Events:              ${String(analytics.revenue.paidProviderEvents || 0).padStart(6)}           ║`);
+  console.log(`║  Paid Orders Tracked:               ${String(analytics.revenue.paidOrders).padStart(6)}           ║`);
+  console.log(`║  Known Booked Revenue (cents):      ${String(analytics.revenue.bookedRevenueCents).padStart(6)}           ║`);
+  console.log('╠══════════════════════════════════════════════════════╣');
+  console.log('║  Acquisition by Source:                              ║');
+  Object.entries(analytics.signups.bySource).forEach(([key, count]) => {
+    const line = `    ${key}: ${count}`;
+    console.log(`║  ${line.padEnd(52)}║`);
+  });
+  console.log('║  Paid Orders by Source:                              ║');
+  Object.entries(analytics.attribution.paidBySource).forEach(([key, count]) => {
+    const line = `    ${key}: ${count}`;
+    console.log(`║  ${line.padEnd(52)}║`);
+  });
+  console.log('║  Revenue by Source (cents):                          ║');
+  Object.entries(analytics.attribution.bookedRevenueBySourceCents).forEach(([key, count]) => {
+    const line = `    ${key}: ${count}`;
+    console.log(`║  ${line.padEnd(52)}║`);
+  });
+  console.log('╚══════════════════════════════════════════════════════╝');
+}
+if (require.main === module) generateFunnelReport();
+module.exports = { generateFunnelReport };

package/scripts/gate-satisfy.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+'use strict';
+
+const { satisfyCondition } = require('./gates-engine');
+
+function run() {
+  const args = process.argv.slice(2);
+  let gateId = null;
+  let evidence = '';
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--gate' && args[i + 1]) {
+      gateId = args[i + 1];
+      i++;
+    } else if (args[i] === '--evidence' && args[i + 1]) {
+      evidence = args[i + 1];
+      i++;
+    }
+  }
+
+  if (!gateId) {
+    process.stderr.write('Usage: node scripts/gate-satisfy.js --gate <gate-id> [--evidence "<text>"]\n');
+    process.exit(1);
+  }
+
+  const entry = satisfyCondition(gateId, evidence);
+  const output = { gate: gateId, satisfied: true, timestamp: entry.timestamp, evidence: entry.evidence };
+  process.stdout.write(JSON.stringify(output, null, 2) + '\n');
+}
+
+// Export for MCP tool usage
+function satisfyGate(gateId, evidence) {
+  if (!gateId) throw new Error('gate ID is required');
+  const entry = satisfyCondition(gateId, evidence || '');
+  return { gate: gateId, satisfied: true, timestamp: entry.timestamp, evidence: entry.evidence };
+}
+
+module.exports = { satisfyGate };
+
+if (require.main === module) {
+  run();
+}

package/scripts/gate-stats.js

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { getAutoGatesPath } = require('./auto-promote-gates');
+
+const PROJECT_ROOT = path.join(__dirname, '..');
+const MANUAL_GATES_PATH = path.join(PROJECT_ROOT, 'config', 'gates', 'default.json');
+
+function loadGatesFile(filePath) {
+  if (!fs.existsSync(filePath)) return [];
+  try {
+    const data = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    return data.gates || [];
+  } catch {
+    return [];
+  }
+}
+
+function calculateStats() {
+  const autoGatesPath = getAutoGatesPath();
+  const manualGates = loadGatesFile(MANUAL_GATES_PATH);
+  const autoGates = loadGatesFile(autoGatesPath);
+  const allGates = [...manualGates, ...autoGates];
+
+  let autoPromotedData = { promotionLog: [] };
+  if (fs.existsSync(autoGatesPath)) {
+    try { autoPromotedData = JSON.parse(fs.readFileSync(autoGatesPath, 'utf-8')); } catch {}
+  }
+  const promotionLog = autoPromotedData.promotionLog || [];
+
+  const blockGates = allGates.filter((g) => g.action === 'block');
+  const warnGates = allGates.filter((g) => g.action === 'warn');
+
+  // Count total blocks/warns from occurrences in auto-promoted gates
+  const totalBlocked = autoGates
+    .filter((g) => g.action === 'block')
+    .reduce((sum, g) => sum + (g.occurrences || 0), 0);
+  const totalWarned = autoGates
+    .filter((g) => g.action === 'warn')
+    .reduce((sum, g) => sum + (g.occurrences || 0), 0);
+
+  // Top blocked gate
+  const topBlocked = [...allGates]
+    .sort((a, b) => (b.occurrences || 0) - (a.occurrences || 0))
+    .find((g) => g.action === 'block') || null;
+
+  // Last promotion event
+  const lastPromotion = promotionLog.length > 0
+    ? promotionLog[promotionLog.length - 1]
+    : null;
+
+  // Time saved estimate: ~15 min per blocked mistake
+  const estimatedMinutesSaved = (totalBlocked + totalWarned) * 15;
+  const estimatedHoursSaved = (estimatedMinutesSaved / 60).toFixed(1);
+
+  return {
+    totalGates: allGates.length,
+    manualGates: manualGates.length,
+    autoPromotedGates: autoGates.length,
+    blockGates: blockGates.length,
+    warnGates: warnGates.length,
+    totalBlocked,
+    totalWarned,
+    topBlocked,
+    lastPromotion,
+    estimatedHoursSaved,
+    gates: allGates,
+  };
+}
+
+function formatLastPromotion(promo) {
+  if (!promo) return 'none';
+  const ts = promo.timestamp ? new Date(promo.timestamp) : null;
+  if (!ts) return `${promo.gateId || 'unknown'}`;
+  const now = Date.now();
+  const diffMs = now - ts.getTime();
+  const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+  const ago = diffDays === 0 ? 'today' : diffDays === 1 ? '1 day ago' : `${diffDays} days ago`;
+  const label = promo.type === 'upgrade'
+    ? `${promo.gateId} -> ${promo.to} (${ago})`
+    : `${promo.gateId} (${ago})`;
+  return label;
+}
+
+function formatStats(stats) {
+  const lines = [];
+  lines.push('Gate Statistics');
+  lines.push('─'.repeat(38));
+  lines.push(`  Active gates: ${stats.totalGates} (${stats.manualGates} manual, ${stats.autoPromotedGates} auto-promoted)`);
+  lines.push(`  Actions blocked: ${stats.totalBlocked}`);
+  lines.push(`  Actions warned: ${stats.totalWarned}`);
+  lines.push(`  Top blocked gate: ${stats.topBlocked ? `${stats.topBlocked.id} (${stats.topBlocked.occurrences || 0} blocks)` : 'none'}`);
+  lines.push(`  Last promotion: ${formatLastPromotion(stats.lastPromotion)}`);
+  lines.push(`  Estimated time saved: ~${stats.estimatedHoursSaved} hours`);
+  return lines.join('\n');
+}
+
+if (require.main === module) {
+  try {
+    const stats = calculateStats();
+    console.log('\n' + formatStats(stats) + '\n');
+  } catch (err) {
+    console.error('gate-stats error:', err.message);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  calculateStats,
+  formatStats,
+  formatLastPromotion,
+  loadGatesFile,
+  MANUAL_GATES_PATH,
+};

package/scripts/gate-templates.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const ROOT = path.join(__dirname, '..');
+const DEFAULT_TEMPLATES_PATH = path.join(ROOT, 'config', 'gate-templates.json');
+
+function normalizeText(value) {
+  if (value === undefined || value === null) return null;
+  const text = String(value).trim();
+  return text || null;
+}
+
+function loadGateTemplates(filePath = DEFAULT_TEMPLATES_PATH) {
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`Gate templates file not found: ${filePath}`);
+  }
+
+  const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  if (!parsed || !Array.isArray(parsed.templates)) {
+    throw new Error(`Gate templates file ${filePath} is missing a "templates" array`);
+  }
+
+  return parsed;
+}
+
+function listGateTemplates(filePath = DEFAULT_TEMPLATES_PATH) {
+  const config = loadGateTemplates(filePath);
+  return config.templates.map((template) => ({
+    id: normalizeText(template.id),
+    name: normalizeText(template.name),
+    category: normalizeText(template.category),
+    signal: normalizeText(template.signal),
+    defaultAction: normalizeText(template.defaultAction),
+    severity: normalizeText(template.severity),
+    pattern: normalizeText(template.pattern),
+    problem: normalizeText(template.problem),
+    roi: normalizeText(template.roi),
+    rollout: normalizeText(template.rollout),
+  }));
+}
+
+function summarizeGateTemplates(filePath = DEFAULT_TEMPLATES_PATH) {
+  const templates = listGateTemplates(filePath);
+  const categories = {};
+  const byAction = {};
+
+  for (const template of templates) {
+    const category = template.category || 'Other';
+    categories[category] = (categories[category] || 0) + 1;
+    const action = template.defaultAction || 'unknown';
+    byAction[action] = (byAction[action] || 0) + 1;
+  }
+
+  return {
+    total: templates.length,
+    categories,
+    byAction,
+    templates,
+  };
+}
+
+module.exports = {
+  DEFAULT_TEMPLATES_PATH,
+  listGateTemplates,
+  loadGateTemplates,
+  summarizeGateTemplates,
+};