thumbgate 1.29.2 → 1.30.0

package/scripts/activation-quickstart.js

@@ -93,6 +93,7 @@ async function runActivationFlow({ ask, out, isTTY, deps = {} }) {
         whatToChange: `Block this action: ${mistake}`,
         tags: 'quickstart,activation,first-rule',
         gateAction: 'block',
+        reviewOrigin: 'human',
       });
     } catch {
       // Capture failure should not abort the activation aha.

package/scripts/agent-outcome-monitor.js

@@ -5,11 +5,13 @@ const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
 const { calculateTaskOutcomeMetrics, readTaskOutcomes } = require('./task-outcomes');
+const { computeToolKpis } = require('./tool-kpi-tracker');
 
 const DEFAULT_THRESHOLDS = path.join(__dirname, '..', 'config', 'agent-outcome-monitor-thresholds.json');
 const DEFAULT_HOSTED_ORIGIN = 'https://thumbgate-production.up.railway.app';
 const DEFAULT_MONITOR_PATH = '/v1/task-outcomes/monitor';
 const DEFAULT_SCHEDULE_ID = 'thumbgate-agent-outcome-monitor';
+const DEFAULT_MINIMUM_TOOL_CALLS = 20;
 
 function monitorTaskOutcomes(outcomes = [], options = {}) {
   const metrics = calculateTaskOutcomeMetrics(outcomes);
@@ -72,6 +74,71 @@ function monitorTaskOutcomes(outcomes = [], options = {}) {
   };
 }
 
+function monitorProductionSignals(outcomes = [], toolKpis = {}, options = {}) {
+  const taskReport = monitorTaskOutcomes(outcomes, options);
+  const requestedMinimumToolCalls = Number(options.minimumToolCalls);
+  const minimumToolCalls = Number.isFinite(requestedMinimumToolCalls) && requestedMinimumToolCalls >= 1
+    ? Math.floor(requestedMinimumToolCalls)
+    : DEFAULT_MINIMUM_TOOL_CALLS;
+  const measuredToolCalls = Number(toolKpis.totalCalls);
+  const totalToolCalls = Number.isFinite(measuredToolCalls) && measuredToolCalls >= 0
+    ? Math.floor(measuredToolCalls)
+    : 0;
+  const toolAlerts = [];
+
+  if (totalToolCalls < minimumToolCalls) {
+    toolAlerts.push({
+      id: 'minimum-tool-calls',
+      severity: 'block',
+      message: `Need ${minimumToolCalls} observed tool calls; observed ${totalToolCalls}.`,
+    });
+  }
+  for (const tool of (toolKpis.tools || [])) {
+    if (tool.requestCount < 3) continue;
+    if (tool.successRate < 90) {
+      toolAlerts.push({
+        id: `tool-success-${tool.toolName}`,
+        severity: 'block',
+        actual: tool.successRate,
+        expected: 'gte 90',
+        message: `${tool.toolName} success rate ${tool.successRate}% is below 90%.`,
+      });
+    }
+    if (tool.p95 > 500) {
+      toolAlerts.push({
+        id: `tool-latency-${tool.toolName}`,
+        severity: 'warn',
+        actual: tool.p95,
+        expected: 'lte 500',
+        message: `${tool.toolName} p95 latency ${tool.p95}ms is above 500ms.`,
+      });
+    }
+  }
+
+  const alerts = [...taskReport.alerts, ...toolAlerts];
+  let verdict = taskReport.verdict;
+  if (taskReport.verdict !== 'blocked' && toolAlerts.some((alert) => alert.id === 'minimum-tool-calls')) {
+    verdict = 'insufficient_evidence';
+  } else if (toolAlerts.some((alert) => alert.severity === 'block')) {
+    verdict = 'blocked';
+  } else if (verdict === 'healthy' && toolAlerts.length > 0) {
+    verdict = 'watch';
+  }
+
+  return {
+    ...taskReport,
+    verdict,
+    alerts,
+    observability: {
+      minimumToolCalls,
+      totalToolCalls,
+      evidenceStatus: totalToolCalls >= minimumToolCalls ? 'measured' : 'insufficient_evidence',
+      tools: toolKpis.tools || [],
+      servers: toolKpis.servers || [],
+    },
+  };
+}
+
 function flattenMetricValues(metrics) {
   return {
     workingRate: metrics.task.workingRate,
@@ -228,8 +295,9 @@ async function main(argv = process.argv.slice(2)) {
 
   const report = options.hosted
     ? await fetchHostedMonitor(options)
-    : monitorTaskOutcomes(
+    : monitorProductionSignals(
       readTaskOutcomes({ inputPath: options.inputPath }),
+      computeToolKpis(),
       { thresholdsPath: options.thresholdsPath },
     );
   if (options.outputPath) {
@@ -255,7 +323,9 @@ module.exports = {
   flattenMetricValues,
   installAgentOutcomeMonitorSchedule,
   main,
+  monitorProductionSignals,
   monitorTaskOutcomes,
   parseArgs,
   passesRule,
+  DEFAULT_MINIMUM_TOOL_CALLS,
 };

package/scripts/billing.js

@@ -30,6 +30,7 @@ const {
   resolveFallbackArtifactPath,
 } = require('./feedback-paths');
 const { getTelemetryAnalytics, getTelemetrySourceDiagnostics } = require('./telemetry-analytics');
+const { normalizeCampaignId } = require('./growth-campaigns');
 const {
   PRO_MONTHLY_PRICE_ID,
   PRO_ANNUAL_PRICE_ID,
@@ -1154,7 +1155,7 @@ function extractAttribution(metadata = {}) {
   return {
     source: normalizeText(safe.utmSource || safe.source),
     medium: normalizeText(safe.utmMedium || safe.medium),
-    campaign: normalizeText(safe.utmCampaign || safe.campaign),
+    campaign: normalizeCampaignId(safe.utmCampaign || safe.campaign),
     content: normalizeText(safe.utmContent || safe.content),
     term: normalizeText(safe.utmTerm || safe.term),
     creator: normalizeText(safe.creator || safe.creatorHandle || safe.creator_handle),
@@ -4237,6 +4238,7 @@ module.exports = {
   _TRIAL_EMAIL_LEDGER_PATH: () => CONFIG.TRIAL_EMAIL_LEDGER_PATH,
   _ORDER_EMAIL_LEDGER_PATH: () => CONFIG.ORDER_EMAIL_LEDGER_PATH,
   _LOCAL_MODE: () => LOCAL_MODE(),
+  _extractAttribution: extractAttribution,
   _withTimeout: withTimeout,
   _mailer: mailer,
 };

package/scripts/claude-feedback-sync.js

@@ -8,7 +8,6 @@ const {
   buildFeedbackSourceIdentity,
   getFeedbackPaths,
   readJSONL,
-  analyzeFeedback,
 } = require('./feedback-loop');
 const { detectFeedbackSignal, normalizeFeedbackText } = require('./feedback-quality');
 const {
@@ -279,6 +278,7 @@ function syncClaudeHistoryFeedback(options = {}) {
         whatWorked: candidate.signal === 'up' ? candidate.promptText : undefined,
         tags: ['claude-history-sync', 'auto-capture-fallback'],
         sourceEvent,
+        reviewOrigin: 'human',
       });
 
       if (captureResult?.duplicate) {
@@ -300,7 +300,8 @@ function syncClaudeHistoryFeedback(options = {}) {
     }, { feedbackDir });
 
     if (importedCount > 0) {
-      refreshStatuslineCache(analyzeFeedback(path.join(feedbackDir, 'feedback-log.jsonl')), path.join(feedbackDir, 'statusline_cache.json'));
+      const { analyzeFeedback } = require('./feedback-loop');
+      refreshStatuslineCache(analyzeFeedback(path.join(feedbackDir, 'feedback-log.jsonl'), { humanOnly: true }), path.join(feedbackDir, 'statusline_cache.json'));
     }
 
     return {

package/scripts/cli-feedback.js

@@ -13,13 +13,9 @@
  *   node scripts/cli-feedback.js down "what went wrong"
  */
 
-const { captureFeedback } = require('./feedback-loop');
+const { captureFeedback, analyzeFeedback } = require('./feedback-loop');
 const { loadOptionalModule } = require('./private-core-boundary');
-// `history-distiller` is a PRIVATE_CORE_MODULE — present in this checkout and
-// in ThumbGate-Core, but intentionally excluded from the public npm tarball.
-// The hard `require('./history-distiller')` form crashed `hook-auto-capture`
-// in published 1.19.0 with MODULE_NOT_FOUND. Public-shell fallback returns
-// null distillation; caller already handles a null distillResult.
+// Keep the optional distiller from breaking the public package.
 const { distillFromHistory } = loadOptionalModule('./history-distiller', () => ({
   distillFromHistory: () => null,
 }));
@@ -60,6 +56,7 @@ function processInlineFeedback({ signal, context, chatHistory, whatWentWrong, wh
       whatWorked: whatWorked || undefined,
       chatHistory,
       sourceEvent,
+      reviewOrigin: 'human',
     });
   } catch (err) {
     feedbackResult = { accepted: false, reason: err.message };
@@ -75,7 +72,16 @@ function processInlineFeedback({ signal, context, chatHistory, whatWentWrong, wh
 
   // 3. Get the most recent lesson and stats
   const recentLesson = getRecentLesson();
-  const stats = getLessonStats();
+  const lessonStats = getLessonStats();
+  const feedbackStats = analyzeFeedback(undefined, { humanOnly: true });
+  const stats = {
+    ...lessonStats,
+    total: feedbackStats.total,
+    positive: feedbackStats.totalPositive,
+    negative: feedbackStats.totalNegative,
+    rawTotal: feedbackStats.rawTotal,
+    excludedTotal: feedbackStats.excludedTotal,
+  };
 
   // 4. If the user wrote an explicit "never …" / "always …" directive, surface
   //    an OFFER (never auto-act): "never" on a thumbs-down → offer force-gate now.

package/scripts/cross-encoder-reranker.js

@@ -133,6 +133,9 @@ async function retrieveWithReranking(toolName, actionContext, options = {}) {
   const candidates = retrieveRelevantLessons(toolName, actionContext, {
     maxResults: candidateCount,
     feedbackDir,
+    scope: options.scope,
+    requireScope: options.requireScope,
+    includeShared: options.includeShared,
   });
 
   if (candidates.length === 0) return [];

package/scripts/feedback-aggregate.js

@@ -239,11 +239,12 @@ function trendFromRateWindows(windows) {
 function computeAggregateFeedbackStats(options = {}) {
   const { entries, stores } = collectAggregateLogEntries(FEEDBACK_LOG, options);
   const memory = collectAggregateLogEntries(MEMORY_LOG, options);
-  const { totalPositive, totalNegative, rubricSamples } = summarizeFeedbackEntries(entries);
+  const humanReviewedEntries = entries.filter((entry) => entry.reviewOrigin === 'human');
+  const { totalPositive, totalNegative, rubricSamples } = summarizeFeedbackEntries(humanReviewedEntries);
   const total = totalPositive + totalNegative;
   const approvalRate = total > 0 ? Math.round((totalPositive / total) * 1000) / 1000 : 0;
   const windows = createRateWindows(total, totalPositive, approvalRate);
-  updateRateWindows(windows, entries);
+  updateRateWindows(windows, humanReviewedEntries);
   finalizeRateWindows(windows);
   const trend = trendFromRateWindows(windows);
 
@@ -255,6 +256,8 @@ function computeAggregateFeedbackStats(options = {}) {
     recentRate: windows['7d'].rate || approvalRate,
     trend,
     windows,
+    rawTotal: entries.length,
+    excludedTotal: entries.length - humanReviewedEntries.length,
     rubric: { samples: rubricSamples || memory.entries.length, blockedPromotions: 0, failingCriteria: {} },
     aggregate: {
       enabled: true,