thumbgate 0.9.10

package/scripts/model-tier-router.js

@@ -0,0 +1,301 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * GPT-5.4 Tier Router — routes tasks to nano/mini/frontier based on
+ * task complexity, context size, risk level, and retry count.
+ * Includes frontier budget control.
+ */
+
+const path = require('path');
+const { recommendInferenceBackend } = require('./local-model-profile');
+
+const CONFIG_PATH = path.join(__dirname, '..', 'config', 'model-tiers.json');
+
+// ---------------------------------------------------------------------------
+// Load config
+// ---------------------------------------------------------------------------
+
+let _config;
+function loadConfig() {
+  if (!_config) _config = require(CONFIG_PATH);
+  return _config;
+}
+
+// ---------------------------------------------------------------------------
+// Model tiers
+// ---------------------------------------------------------------------------
+
+const TIERS = {
+  nano: { label: 'nano', costMultiplier: 0.1, maxContext: 32000 },
+  mini: { label: 'mini', costMultiplier: 0.4, maxContext: 200000 },
+  frontier: { label: 'frontier', costMultiplier: 1.0, maxContext: 1000000 },
+};
+
+// ---------------------------------------------------------------------------
+// Task classification → tier mapping
+// ---------------------------------------------------------------------------
+
+/**
+ * Classify a task and route it to the appropriate model tier.
+ *
+ * @param {object} task
+ * @param {string}   task.type          — task type identifier
+ * @param {number}   [task.contextTokens] — estimated context window usage
+ * @param {string}   [task.riskLevel]   — 'low' | 'medium' | 'high'
+ * @param {number}   [task.retryCount]  — how many times this task has been retried
+ * @param {string[]} [task.tags]        — freeform tags for classification
+ * @returns {{ tier: string, reason: string, escalated: boolean }}
+ */
+function classifyTask(task = {}) {
+  const { type, contextTokens = 0, riskLevel, retryCount = 0, tags = [] } = task;
+  const config = loadConfig();
+  const escalation = config.escalationRules;
+  const archTags = escalation.architectureTags || [];
+
+  // --- Escalation checks (override normal routing) ---
+
+  // 1. Context exceeds frontier threshold
+  if (contextTokens > escalation.contextThreshold) {
+    return {
+      tier: 'frontier',
+      reason: `context size ${contextTokens} exceeds threshold ${escalation.contextThreshold}`,
+      escalated: true,
+    };
+  }
+
+  // 2. High risk + retried enough
+  if (riskLevel === 'high' && retryCount >= escalation.failureRetryThreshold) {
+    return {
+      tier: 'frontier',
+      reason: `high risk with ${retryCount} retries (threshold: ${escalation.failureRetryThreshold})`,
+      escalated: true,
+    };
+  }
+
+  // 3. Architecture / cross-file tags
+  const matchedTag = tags.find((t) => archTags.includes(t));
+  if (matchedTag) {
+    return {
+      tier: 'frontier',
+      reason: `tag "${matchedTag}" matches architecture escalation`,
+      escalated: true,
+    };
+  }
+
+  // --- Normal tier routing by task type ---
+
+  const tiers = config.tiers;
+  for (const tierName of ['nano', 'mini', 'frontier']) {
+    if (tiers[tierName].taskTypes.includes(type)) {
+      return {
+        tier: tierName,
+        reason: `task type "${type}" mapped to ${tierName}`,
+        escalated: false,
+      };
+    }
+  }
+
+  // Unknown type defaults to mini
+  return {
+    tier: 'mini',
+    reason: `unknown task type "${type}" — defaulting to mini`,
+    escalated: false,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Escalation logic
+// ---------------------------------------------------------------------------
+
+/**
+ * Determine whether a task should be escalated from its current tier.
+ *
+ * @param {object} task    — same shape as classifyTask input
+ * @param {object[]} history — array of { tier, success } from previous attempts
+ * @returns {{ escalate: boolean, from: string, to: string, reason: string }}
+ */
+function shouldEscalate(task = {}, history = []) {
+  const { contextTokens = 0, riskLevel, retryCount = 0, tags = [] } = task;
+  const config = loadConfig();
+  const rules = config.escalationRules;
+  const archTags = rules.architectureTags || [];
+
+  const currentTier = classifyTask(task).tier;
+
+  // 1. Context exceeds threshold
+  if (contextTokens > rules.contextThreshold && currentTier !== 'frontier') {
+    return {
+      escalate: true,
+      from: currentTier,
+      to: 'frontier',
+      reason: `context ${contextTokens} > threshold ${rules.contextThreshold}`,
+    };
+  }
+
+  // 2. High risk + retries
+  if (riskLevel === 'high' && retryCount >= rules.failureRetryThreshold && currentTier !== 'frontier') {
+    return {
+      escalate: true,
+      from: currentTier,
+      to: 'frontier',
+      reason: `high risk with ${retryCount} retries`,
+    };
+  }
+
+  // 3. Architecture tags
+  const matchedTag = tags.find((t) => archTags.includes(t));
+  if (matchedTag && currentTier !== 'frontier') {
+    return {
+      escalate: true,
+      from: currentTier,
+      to: 'frontier',
+      reason: `architecture tag "${matchedTag}"`,
+    };
+  }
+
+  // 4. Two consecutive failures at mini tier
+  if (history.length >= 2) {
+    const lastTwo = history.slice(-2);
+    if (lastTwo.every((h) => h.tier === 'mini' && !h.success)) {
+      return {
+        escalate: true,
+        from: 'mini',
+        to: 'frontier',
+        reason: 'two consecutive failures at mini tier',
+      };
+    }
+  }
+
+  return {
+    escalate: false,
+    from: currentTier,
+    to: currentTier,
+    reason: 'no escalation needed',
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Frontier budget tracker
+// ---------------------------------------------------------------------------
+
+class FrontierBudget {
+  /**
+   * @param {object} [options]
+   * @param {number} [options.tokenCap]       — max frontier tokens per session (default 500000)
+   * @param {boolean} [options.requireReason]  — require a reason string for spend (default true)
+   */
+  constructor(options = {}) {
+    const config = loadConfig();
+    const defaults = config.tiers.frontier.budgetDefaults || {};
+    this.tokenCap = options.tokenCap ?? defaults.tokenCap ?? 500000;
+    this.requireReason = options.requireReason ?? defaults.requireReason ?? true;
+    this.spent = 0;
+    this.invocations = [];
+  }
+
+  /**
+   * Check whether a spend is allowed without deducting.
+   * @param {number} tokens
+   * @param {string} [reason]
+   * @returns {{ allowed: boolean, remaining: number, reason: string }}
+   */
+  canSpend(tokens, reason) {
+    if (this.requireReason && !reason) {
+      return {
+        allowed: false,
+        remaining: this.tokenCap - this.spent,
+        reason: 'reason is required for frontier spend',
+      };
+    }
+    const remaining = this.tokenCap - this.spent;
+    if (tokens > remaining) {
+      return {
+        allowed: false,
+        remaining,
+        reason: `requested ${tokens} exceeds remaining ${remaining}`,
+      };
+    }
+    return {
+      allowed: true,
+      remaining,
+      reason: 'within budget',
+    };
+  }
+
+  /**
+   * Deduct tokens from the budget.
+   * @param {number} tokens
+   * @param {string} [reason]
+   * @returns {{ success: boolean, spent: number, remaining: number, reason: string }}
+   */
+  spend(tokens, reason) {
+    const check = this.canSpend(tokens, reason);
+    if (!check.allowed) {
+      return { success: false, spent: this.spent, remaining: check.remaining, reason: check.reason };
+    }
+    this.spent += tokens;
+    this.invocations.push({ tokens, reason, timestamp: new Date().toISOString() });
+    return {
+      success: true,
+      spent: this.spent,
+      remaining: this.tokenCap - this.spent,
+      reason: `spent ${tokens} tokens — ${reason}`,
+    };
+  }
+
+  /**
+   * Return current budget status.
+   * @returns {{ spent: number, remaining: number, cap: number, invocations: number }}
+   */
+  status() {
+    return {
+      spent: this.spent,
+      remaining: this.tokenCap - this.spent,
+      cap: this.tokenCap,
+      invocations: this.invocations.length,
+    };
+  }
+
+  /** Reset the budget for a new session. */
+  reset() {
+    this.spent = 0;
+    this.invocations = [];
+  }
+}
+
+function recommendExecutionPlan(task = {}, env = process.env) {
+  const classification = classifyTask(task);
+  const inference = recommendInferenceBackend(task, env);
+
+  return {
+    tier: classification.tier,
+    escalated: classification.escalated,
+    tierReason: classification.reason,
+    backendId: inference.backend.id,
+    providerMode: inference.backend.providerMode,
+    workloadClass: inference.workloadClass,
+    recommendationClass: inference.recommendationClass,
+    indexCacheEligible: inference.backend.indexCacheEligible,
+    indexCacheEnabled: inference.backend.indexCacheEnabled,
+    reason: `${classification.reason}; ${inference.reason}`,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Exports
+// ---------------------------------------------------------------------------
+
+module.exports = { TIERS, classifyTask, shouldEscalate, FrontierBudget, recommendExecutionPlan };
+
+// ---------------------------------------------------------------------------
+// CLI
+// ---------------------------------------------------------------------------
+
+if (require.main === module) {
+  const taskType = process.argv[2] || 'code-edit';
+  const result = classifyTask({ type: taskType });
+  const execution = recommendExecutionPlan({ type: taskType });
+  const budget = new FrontierBudget();
+  console.log(JSON.stringify({ classification: result, execution, budget: budget.status() }, null, 2));
+}

package/scripts/money-watcher.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+/**
+ * money-watcher.js
+ * Continuously polls the commercial summary for net-new paid orders or booked revenue.
+ */
+
+'use strict';
+
+const { getOperationalBillingSummary } = require('./operational-summary');
+
+function getCommercialRevenueSnapshot(summary) {
+  const revenue = summary.revenue || {};
+  return {
+    paidOrders: revenue.paidOrders || 0,
+    bookedRevenueCents: revenue.bookedRevenueCents || 0,
+    latestPaidAt: revenue.latestPaidAt || null,
+    latestPaidOrder: revenue.latestPaidOrder || null,
+  };
+}
+
+async function watchMoney(intervalMs = 10000) {
+  console.log('👀 Money Watcher activated. Polling billing summary for commercial changes...');
+  const initialState = await getOperationalBillingSummary();
+  let initialSnapshot = getCommercialRevenueSnapshot(initialState.summary);
+  let polling = false;
+
+  return setInterval(async () => {
+    if (polling) return;
+    polling = true;
+    try {
+      const { source, summary, fallbackReason } = await getOperationalBillingSummary();
+      const currentSnapshot = getCommercialRevenueSnapshot(summary);
+
+      const newPaidOrders = currentSnapshot.paidOrders - initialSnapshot.paidOrders;
+      const newBookedRevenue = currentSnapshot.bookedRevenueCents - initialSnapshot.bookedRevenueCents;
+
+      if (newPaidOrders > 0 || newBookedRevenue > 0) {
+        console.log('\n🚨🚨🚨 COMMERCIAL ALERT: NET-NEW PAID ACTIVITY DETECTED! 🚨🚨🚨');
+        console.log('Operational billing summary:');
+        console.log(JSON.stringify({
+          source,
+          fallbackReason,
+          newPaidOrders,
+          newBookedRevenueCents: newBookedRevenue,
+          latestPaidAt: currentSnapshot.latestPaidAt,
+          latestPaidOrder: currentSnapshot.latestPaidOrder,
+          bookedRevenueCents: currentSnapshot.bookedRevenueCents,
+          activeKeys: summary.keys.active,
+          totalUsage: summary.keys.totalUsage,
+        }, null, 2));
+
+        process.stdout.write('\x07');
+        initialSnapshot = currentSnapshot;
+      }
+    } finally {
+      polling = false;
+    }
+  }, intervalMs);
+}
+
+if (require.main === module) {
+  watchMoney().catch((err) => {
+    console.error(err && err.message ? err.message : err);
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  getCommercialRevenueSnapshot,
+  watchMoney,
+};

package/scripts/multi-hop-recall.js

@@ -0,0 +1,240 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Multi-Hop Recall — chains related lessons across hops for deeper context.
+ *
+ * Single-hop: query → top N lessons (current behavior)
+ * Multi-hop:  query → hop-1 lessons → extract tags/domains/rootCauses →
+ *             hop-2 lessons (related) → deduplicate → ranked chain
+ *
+ * Inspired by Chroma Context-1's multi-hop retrieval pattern.
+ * Pro-only feature — gated via requirePro('multi-hop-recall').
+ *
+ * @module multi-hop-recall
+ */
+
+const { requirePro } = require('./pro-features');
+
+/**
+ * Extract expansion terms from a set of lessons for the next hop.
+ * Pulls tags, domains, rootCauses, and key phrases from whatToChange.
+ */
+function extractExpansionTerms(lessons) {
+  const terms = new Set();
+
+  for (const lesson of lessons) {
+    // Tags
+    const tags = Array.isArray(lesson.tags) ? lesson.tags : safeParseTags(lesson.tags);
+    for (const tag of tags) {
+      if (tag && tag.length > 2) terms.add(tag);
+    }
+
+    // Domain
+    if (lesson.domain && lesson.domain !== 'general') {
+      terms.add(lesson.domain);
+    }
+
+    // Root cause category
+    if (lesson.rootCause) {
+      terms.add(lesson.rootCause);
+    }
+
+    // Key phrases from whatToChange (3+ char words, skip stopwords)
+    if (lesson.whatToChange) {
+      const words = lesson.whatToChange
+        .toLowerCase()
+        .replace(/[^a-z0-9\s]/g, '')
+        .split(/\s+/)
+        .filter((w) => w.length > 3 && !STOPWORDS.has(w));
+      for (const word of words.slice(0, 5)) {
+        terms.add(word);
+      }
+    }
+  }
+
+  return Array.from(terms);
+}
+
+const STOPWORDS = new Set([
+  'this', 'that', 'with', 'from', 'have', 'been', 'were', 'will',
+  'should', 'would', 'could', 'about', 'their', 'there', 'which',
+  'when', 'what', 'than', 'then', 'them', 'they', 'into', 'some',
+  'also', 'more', 'very', 'just', 'does', 'done', 'make', 'made',
+]);
+
+function safeParseTags(tags) {
+  if (Array.isArray(tags)) return tags;
+  if (typeof tags === 'string') {
+    try { return JSON.parse(tags); } catch { return []; }
+  }
+  return [];
+}
+
+/**
+ * Deduplicate lessons by ID, keeping first occurrence (higher-ranked).
+ */
+function deduplicateById(lessons) {
+  const seen = new Set();
+  return lessons.filter((l) => {
+    const id = l.id;
+    if (seen.has(id)) return false;
+    seen.add(id);
+    return true;
+  });
+}
+
+/**
+ * Score a lesson's relevance to a set of expansion terms.
+ * Higher = more relevant to the chain.
+ */
+function scoreRelevance(lesson, expansionTerms) {
+  let score = 0;
+  const termSet = new Set(expansionTerms.map((t) => t.toLowerCase()));
+
+  // Tag overlap: 3 points per matching tag
+  const tags = Array.isArray(lesson.tags) ? lesson.tags : safeParseTags(lesson.tags);
+  for (const tag of tags) {
+    if (termSet.has(tag.toLowerCase())) score += 3;
+  }
+
+  // Domain match: 2 points
+  if (lesson.domain && termSet.has(lesson.domain.toLowerCase())) score += 2;
+
+  // Root cause match: 2 points
+  if (lesson.rootCause && termSet.has(lesson.rootCause.toLowerCase())) score += 2;
+
+  // Content overlap: 1 point per matching word in whatToChange
+  if (lesson.whatToChange) {
+    const words = lesson.whatToChange.toLowerCase().split(/\s+/);
+    for (const word of words) {
+      if (word.length > 3 && termSet.has(word)) score += 1;
+    }
+  }
+
+  return score;
+}
+
+/**
+ * Perform multi-hop recall over a lesson database.
+ *
+ * @param {Function} searchFn - Search function: (query, options) => lesson[]
+ *   Must accept (query, { limit, signal, domain }) and return lesson rows.
+ * @param {string} query - Initial search query
+ * @param {object} [options]
+ * @param {number} [options.maxHops=2] - Maximum chain depth (1 = single-hop, 2+ = multi-hop)
+ * @param {number} [options.hopLimit=10] - Max results per hop
+ * @param {number} [options.totalLimit=15] - Max total results across all hops
+ * @param {string} [options.signal] - Filter by 'positive' or 'negative'
+ * @param {boolean} [options.skipProCheck=false] - Skip Pro license check (for testing)
+ * @param {Function} [options.requireProFn=requirePro] - Injectable Pro gate helper for testing
+ * @returns {{ results: object[], hops: object[], totalHops: number, expansionTerms: string[] }}
+ */
+function multiHopRecall(searchFn, query, options = {}) {
+  const {
+    maxHops = 2,
+    hopLimit = 10,
+    totalLimit = 15,
+    signal,
+    skipProCheck = false,
+    requireProFn = requirePro,
+  } = options;
+
+  // Pro gate (unless testing)
+  if (!skipProCheck && !requireProFn('multi-hop-recall')) {
+    return { results: [], hops: [], totalHops: 0, expansionTerms: [], proRequired: true };
+  }
+
+  // Clamp hops to [1, 3] to prevent runaway chains
+  const hops = Math.max(1, Math.min(maxHops, 3));
+  const allResults = [];
+  const hopMetadata = [];
+  let expansionTerms = [];
+
+  // Hop 1: direct query search
+  const hop1Results = searchFn(query, { limit: hopLimit, signal });
+  allResults.push(...hop1Results);
+  hopMetadata.push({
+    hop: 1,
+    query,
+    resultsCount: hop1Results.length,
+    type: 'direct',
+  });
+
+  if (hops < 2 || hop1Results.length === 0) {
+    return {
+      results: deduplicateById(allResults).slice(0, totalLimit),
+      hops: hopMetadata,
+      totalHops: 1,
+      expansionTerms: [],
+    };
+  }
+
+  // Extract expansion terms from hop 1
+  expansionTerms = extractExpansionTerms(hop1Results);
+
+  if (expansionTerms.length === 0) {
+    return {
+      results: deduplicateById(allResults).slice(0, totalLimit),
+      hops: hopMetadata,
+      totalHops: 1,
+      expansionTerms: [],
+    };
+  }
+
+  // Hop 2+: search using expansion terms
+  for (let hop = 2; hop <= hops; hop++) {
+    // Build expansion query from top terms (limit to 5 to keep FTS manageable)
+    const queryTerms = expansionTerms.slice(0, 5).join(' OR ');
+    const hopResults = searchFn(queryTerms, { limit: hopLimit, signal });
+
+    // Score and sort by relevance to expansion terms
+    const scored = hopResults
+      .map((lesson) => ({ ...lesson, _hopScore: scoreRelevance(lesson, expansionTerms) }))
+      .filter((l) => l._hopScore > 0)
+      .sort((a, b) => b._hopScore - a._hopScore);
+
+    allResults.push(...scored);
+    hopMetadata.push({
+      hop,
+      query: queryTerms,
+      resultsCount: scored.length,
+      type: 'expansion',
+      termsUsed: expansionTerms.slice(0, 5),
+    });
+
+    // Extract new terms for next hop (if any)
+    if (hop < hops && scored.length > 0) {
+      const newTerms = extractExpansionTerms(scored);
+      // Only add truly new terms
+      const existingSet = new Set(expansionTerms);
+      const novel = newTerms.filter((t) => !existingSet.has(t));
+      expansionTerms = [...expansionTerms, ...novel];
+    }
+  }
+
+  // Deduplicate and cap at totalLimit
+  const deduplicated = deduplicateById(allResults).slice(0, totalLimit);
+
+  // Tag each result with its hop number
+  const hop1Ids = new Set(hop1Results.map((l) => l.id));
+  const tagged = deduplicated.map((l) => ({
+    ...l,
+    _hop: hop1Ids.has(l.id) ? 1 : 2,
+  }));
+
+  return {
+    results: tagged,
+    hops: hopMetadata,
+    totalHops: hopMetadata.length,
+    expansionTerms,
+  };
+}
+
+module.exports = {
+  multiHopRecall,
+  extractExpansionTerms,
+  scoreRelevance,
+  deduplicateById,
+  STOPWORDS,
+};