thumbgate 1.15.0 → 1.16.0

package/scripts/skill-rag-router.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+'use strict';
+
+function normalizeText(value) {
+  if (value === undefined || value === null) return '';
+  return String(value).trim();
+}
+
+function classifyRetrievalFailure(input = {}) {
+  const query = normalizeText(input.query);
+  const evidence = normalizeText(input.evidence);
+  const confidence = Number(input.confidence ?? 0.5);
+  const failed = input.failed === true || confidence < 0.35 || /unknown|not enough|cannot determine/i.test(evidence);
+  if (!failed) return 'none';
+  if (!query) return 'irreducible';
+  if (/\band\b|\bor\b|,|;|\bcompare\b|\bmultiple\b/i.test(query)) return 'question_decomposition';
+  if (evidence && !new RegExp(query.split(/\s+/).slice(0, 3).join('|'), 'i').test(evidence)) return 'query_rewrite';
+  if (evidence.length > 1200 || /irrelevant|too broad|many results/i.test(evidence)) return 'evidence_focus';
+  return 'query_rewrite';
+}
+
+function routeRetrievalSkill(input = {}) {
+  const failure = classifyRetrievalFailure(input);
+  const skill = {
+    none: 'skip_retrieval',
+    query_rewrite: 'rewrite_query',
+    question_decomposition: 'decompose_question',
+    evidence_focus: 'focus_evidence',
+    irreducible: 'exit_unknown',
+  }[failure];
+  return {
+    failure,
+    skill,
+    retrieve: failure !== 'none' && failure !== 'irreducible',
+    reason: reasonForFailure(failure),
+  };
+}
+
+function reasonForFailure(failure) {
+  if (failure === 'none') {
+    return 'Model answer is sufficiently confident; retrieval would waste budget.';
+  }
+  if (failure === 'irreducible') {
+    return 'Query lacks enough structure for retrieval; ask for clarification or return unknown.';
+  }
+  return 'Failure state detected; route to a typed retrieval repair skill before retrying generation.';
+}
+
+module.exports = {
+  classifyRetrievalFailure,
+  reasonForFailure,
+  routeRetrievalSkill,
+};

package/scripts/spec-gate.js

@@ -341,7 +341,7 @@ if (isCliInvocation()) {
     const entries = loadSpecAudit();
     console.log(JSON.stringify(summarizeSpecAudit(entries), null, 2));
   } else {
-    console.error(`Unknown command: ${command}. Use: check, gates, audit`);
+    console.error(`Unknown command: ${command}. Use: check, checks, audit`);
     process.exit(1);
   }
 }

package/scripts/student-consistent-training.js

@@ -0,0 +1,73 @@
+'use strict';
+
+function buildStudentConsistentTrainingPlan(options = {}) {
+  const student = options.student || 'target-agent-policy';
+  const teacher = options.teacher || 'frontier-reviewer';
+  const dataset = options.dataset || 'thumbgate-feedback-lessons';
+  const holdout = options.holdout || 'feedback-gate-holdout';
+
+  return {
+    method: 'student_consistent_synthetic_sft',
+    dataset,
+    teacher,
+    student,
+    generationContract: {
+      teacherRole: 'adds capability tokens: corrected decision, missing evidence, safer action',
+      studentRole: 'preserves target agent style: terse format, tool discipline, gate vocabulary',
+      rejectIf: [
+        'teacher rewrites the answer into unsupported style',
+        'lesson cannot be traced to source feedback',
+        'sample contains secrets or private customer context',
+        'sample teaches a shortcut that bypasses evidence gates',
+      ],
+    },
+    requiredArtifacts: [
+      'source feedback id',
+      'student baseline response',
+      'teacher correction',
+      'student-consistent final sample',
+      'redaction report',
+      'holdout eval result',
+    ],
+    evals: {
+      holdout,
+      compareAgainst: ['raw_teacher_sft', 'self_distill_only', 'no_training_baseline'],
+      metrics: ['gate_precision', 'gate_recall', 'unsupported_claim_rate', 'style_drift_rate'],
+    },
+  };
+}
+
+function evaluateStudentConsistentTrainingSample(sample = {}) {
+  const issues = [];
+
+  if (!sample.sourceFeedbackId) issues.push('missing_source_feedback_id');
+  if (!sample.studentBaseline) issues.push('missing_student_baseline');
+  if (!sample.teacherCorrection) issues.push('missing_teacher_correction');
+  if (!sample.finalSample) issues.push('missing_final_sample');
+  if (!sample.redacted) issues.push('redaction_required');
+  if (!sample.holdoutEval) issues.push('holdout_eval_required');
+
+  const text = [
+    sample.studentBaseline,
+    sample.teacherCorrection,
+    sample.finalSample,
+  ].filter(Boolean).join('\n');
+  if (/(api[_-]?key|secret|token|password)\s*[:=]/i.test(text)) {
+    issues.push('secret_like_content');
+  }
+
+  if (sample.styleDriftRate !== undefined && Number(sample.styleDriftRate) > 0.15) {
+    issues.push('style_drift_too_high');
+  }
+
+  return {
+    decision: issues.length ? 'warn' : 'allow',
+    issues,
+    onPolicy: !issues.includes('style_drift_too_high') && Boolean(sample.studentBaseline),
+  };
+}
+
+module.exports = {
+  buildStudentConsistentTrainingPlan,
+  evaluateStudentConsistentTrainingSample,
+};

package/scripts/synthetic-data-provenance.js

@@ -0,0 +1,98 @@
+'use strict';
+
+function buildSyntheticDataProvenanceRecord(input = {}) {
+  return {
+    sampleId: input.sampleId || null,
+    sourceFeedbackId: input.sourceFeedbackId || null,
+    teacher: {
+      model: input.teacherModel || null,
+      baseModelFamily: input.teacherBaseModelFamily || null,
+      promptHash: input.teacherPromptHash || null,
+      riskLabel: input.teacherRiskLabel || 'unknown',
+    },
+    student: {
+      model: input.studentModel || null,
+      baseModelFamily: input.studentBaseModelFamily || null,
+    },
+    generation: {
+      generatedAt: input.generatedAt || null,
+      filterReportId: input.filterReportId || null,
+      redactionReportId: input.redactionReportId || null,
+      datasetVersion: input.datasetVersion || null,
+    },
+    evals: {
+      semanticFilterPassed: Boolean(input.semanticFilterPassed),
+      behavioralHoldoutPassed: Boolean(input.behavioralHoldoutPassed),
+      styleDriftScore: Number.isFinite(input.styleDriftScore) ? input.styleDriftScore : null,
+      hiddenTraitProbePassed: Boolean(input.hiddenTraitProbePassed),
+    },
+  };
+}
+
+function evaluateSyntheticDataPromotion(record = {}) {
+  const teacher = record.teacher || {};
+  const student = record.student || {};
+  const generation = record.generation || {};
+  const evals = record.evals || {};
+  const issues = [
+    ...missingIdentityIssues(record),
+    ...missingModelIssues(teacher, student),
+    ...missingGenerationIssues(generation),
+    ...failedEvalIssues(evals),
+  ];
+
+  const sameBaseFamily = Boolean(
+    teacher.baseModelFamily
+    && student.baseModelFamily
+    && teacher.baseModelFamily === student.baseModelFamily,
+  );
+  if (sameBaseFamily && teacher.riskLabel !== 'trusted') {
+    issues.push('same_base_teacher_requires_trusted_risk_label');
+  }
+
+  return {
+    decision: issues.length ? 'deny' : 'allow',
+    issues,
+    sameBaseFamily,
+    riskClass: sameBaseFamily ? 'subliminal_learning_sensitive' : 'standard_distillation',
+  };
+}
+
+function missingIdentityIssues(record) {
+  const issues = [];
+  if (!record.sampleId) issues.push('missing_sample_id');
+  if (!record.sourceFeedbackId) issues.push('missing_source_feedback_id');
+  return issues;
+}
+
+function missingModelIssues(teacher, student) {
+  const issues = [];
+  if (!teacher.model) issues.push('missing_teacher_model');
+  if (!teacher.baseModelFamily) issues.push('missing_teacher_base_model_family');
+  if (!student.model) issues.push('missing_student_model');
+  if (!student.baseModelFamily) issues.push('missing_student_base_model_family');
+  return issues;
+}
+
+function missingGenerationIssues(generation) {
+  const issues = [];
+  if (!generation.filterReportId) issues.push('missing_filter_report');
+  if (!generation.redactionReportId) issues.push('missing_redaction_report');
+  if (!generation.datasetVersion) issues.push('missing_dataset_version');
+  return issues;
+}
+
+function failedEvalIssues(evals) {
+  const issues = [];
+  if (!evals.semanticFilterPassed) issues.push('semantic_filter_failed_or_missing');
+  if (!evals.behavioralHoldoutPassed) issues.push('behavioral_holdout_required');
+  if (!evals.hiddenTraitProbePassed) issues.push('hidden_trait_probe_required');
+  if (evals.styleDriftScore === null) issues.push('missing_style_drift_score');
+  if (evals.styleDriftScore !== null && evals.styleDriftScore > 0.15) issues.push('style_drift_too_high');
+  return issues;
+}
+
+module.exports = {
+  buildSyntheticDataProvenanceRecord,
+  evaluateSyntheticDataPromotion,
+};

package/scripts/task-context-result.js

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+'use strict';
+
+function normalizeText(value) {
+  if (value === undefined || value === null) return '';
+  return String(value).trim();
+}
+
+function normalizeList(value) {
+  return Array.isArray(value) ? value.map(normalizeText).filter(Boolean) : [];
+}
+
+function buildTaskContextResultQuery(input = {}) {
+  const task = normalizeText(input.task);
+  const context = normalizeList(input.context);
+  const result = normalizeText(input.result);
+  const tools = normalizeList(input.tools);
+  const files = normalizeList(input.files);
+  const sequence = normalizeList(input.sequence);
+  const audience = normalizeText(input.audience);
+  const creditBudget = normalizeText(input.creditBudget) || 'standard';
+  const missing = [];
+  if (!task) missing.push('task');
+  if (context.length === 0 && files.length === 0 && tools.length === 0) missing.push('context');
+  if (!result) missing.push('result');
+  const contextParts = [
+    ...context,
+    ...files.map((file) => `file:${file}`),
+    ...tools.map((tool) => `tool:${tool}`),
+  ];
+  const sequenceText = sequence
+    .map((step, index) => `${index + 1}. ${step}`)
+    .join(' ');
+
+  return {
+    pattern: 'TaskContextResult',
+    status: missing.length === 0 ? 'ready' : 'needs_context',
+    missing,
+    query: [
+      `Task: ${task || '[required]'}`,
+      `Context: ${contextParts.join('; ') || '[required]'}`,
+      `Result: ${result || '[required]'}`,
+      audience ? `Audience: ${audience}` : null,
+      sequence.length > 0 ? `Sequence: ${sequenceText}` : null,
+      `Credit budget: ${creditBudget}`,
+    ].filter(Boolean).join('\n'),
+    governance: {
+      explicitTools: tools,
+      explicitFiles: files,
+      multiStep: sequence.length > 1,
+      highCreditRisk: /web|browser|scrape|dashboard|presentation|multi[-\s]?step|full/i.test(`${task} ${result} ${sequence.join(' ')}`),
+      recommendation: creditBudget === 'low'
+        ? 'Use focused read-only work unless the operator approves a larger run.'
+        : 'Run through ThumbGate gates before write/tool side effects.',
+    },
+  };
+}
+
+function reviewTaskContextResultQuery(input = {}) {
+  const plan = input.pattern === 'TaskContextResult' ? input : buildTaskContextResultQuery(input);
+  const issues = [];
+  for (const field of plan.missing || []) issues.push({ field, issue: 'missing_tcr_component' });
+  if (plan.governance.highCreditRisk && !/high|approved|enterprise/i.test(plan.query)) {
+    issues.push({ field: 'creditBudget', issue: 'expensive_workflow_without_budget_ack' });
+  }
+  if (plan.governance.multiStep && !/Sequence:/i.test(plan.query)) {
+    issues.push({ field: 'sequence', issue: 'missing_ordered_steps' });
+  }
+  return {
+    status: issues.length === 0 ? 'pass' : 'warn',
+    issues,
+    recommendation: issues.length === 0
+      ? 'Query is concrete enough for a workspace agent.'
+      : 'Clarify task, context, result, tools/files, or credit budget before dispatch.',
+  };
+}
+
+module.exports = {
+  buildTaskContextResultQuery,
+  reviewTaskContextResultQuery,
+};

package/scripts/telemetry-analytics.js

@@ -315,6 +315,15 @@ function sanitizeTelemetryPayload(payload = {}, headers = {}) {
     pricingInterest: pickFirstText(raw.pricingInterest, raw.interestLevel),
     seoQuery: pickFirstText(raw.seoQuery, raw.query),
     seoSurface: pickFirstText(raw.seoSurface, raw.searchSurface, raw.surface),
+    sectionId: pickFirstText(raw.sectionId, raw.section),
+    sectionLabel: pickFirstText(raw.sectionLabel),
+    lastVisibleSection: pickFirstText(raw.lastVisibleSection, raw.visibleSection),
+    dwellBucket: pickFirstText(raw.dwellBucket, raw.engagementBucket),
+    scrollBucket: pickFirstText(raw.scrollBucket),
+    engagementMs: normalizeInteger(raw.engagementMs),
+    maxScrollPercent: normalizeInteger(raw.maxScrollPercent ?? raw.scrollPercent),
+    buyerEmailFocused: Boolean(raw.buyerEmailFocused),
+    buyerEmailCaptured: Boolean(raw.buyerEmailCaptured),
     trafficChannel: inferTrafficChannel(raw, referrerHost),
     failureCode: pickFirstText(raw.failureCode),
     httpStatus: normalizeInteger(raw.httpStatus),
@@ -442,10 +451,19 @@ function getTelemetrySummary(feedbackDir, options = {}) {
   const pricingInterestByLevel = {};
   const seoLandingViewsBySurface = {};
   const seoLandingViewsByQuery = {};
+  const trackedLinkHitsBySlug = {};
+  const trackedLinkCheckoutStartsBySlug = {};
+  const sectionViewsById = {};
+  const pageExitsByLastVisibleSection = {};
+  const pageExitsByDwellBucket = {};
+  const pageExitsByScrollBucket = {};
+  const ctaImpressionsById = {};
+  const ctaImpressionsByPlacement = {};
   const cliByPlatform = {};
   const cliByVersion = {};
   let pageViews = 0;
   let ctaClicks = 0;
+  let ctaImpressions = 0;
   let checkoutStarts = 0;
   let checkoutFailures = 0;
   let checkoutCancelled = 0;
@@ -458,6 +476,9 @@ function getTelemetrySummary(feedbackDir, options = {}) {
   let buyerLossSignals = 0;
   let pricingInterestEvents = 0;
   let seoLandingViews = 0;
+  let pageExitEvents = 0;
+  let emailFocusEvents = 0;
+  let emailAbandonEvents = 0;
   let webEvents = 0;
   let webEventsWithVisitorId = 0;
   let webEventsWithSessionId = 0;
@@ -465,6 +486,10 @@ function getTelemetrySummary(feedbackDir, options = {}) {
   let attributedPageViews = 0;
   let attributedCheckoutStarts = 0;
   let latestSeenAt = null;
+  let exitEngagementMsTotal = 0;
+  let exitEngagementMsCount = 0;
+  let exitScrollPercentTotal = 0;
+  let exitScrollPercentCount = 0;
 
   for (const entry of events) {
     incrementCounter(byClientType, entry.clientType || entry.client || 'unknown');
@@ -506,6 +531,9 @@ function getTelemetrySummary(feedbackDir, options = {}) {
         incrementCounter(ctaClicksByOfferCode, entry.offerCode);
         incrementCounter(ctaClicksByCampaignVariant, entry.campaignVariant);
         incrementCounter(byCtaId, entry.ctaId);
+        if (entry.linkSlug && (entry.eventType || entry.event) === 'cta_click') {
+          incrementCounter(trackedLinkHitsBySlug, entry.linkSlug);
+        }
       }
 
       if ((entry.eventType || entry.event) === 'checkout_start' || (entry.eventType || entry.event) === 'checkout_bootstrap') {
@@ -517,6 +545,7 @@ function getTelemetrySummary(feedbackDir, options = {}) {
         incrementCounter(checkoutStartsByCommunity, entry.community);
         incrementCounter(checkoutStartsByOfferCode, entry.offerCode);
         incrementCounter(checkoutStartsByCampaignVariant, entry.campaignVariant);
+        if (entry.linkSlug) incrementCounter(trackedLinkCheckoutStartsBySlug, entry.linkSlug);
         const starterKey = pickFirstText(
           entry.acquisitionId,
           entry.visitorId,
@@ -581,6 +610,39 @@ function getTelemetrySummary(feedbackDir, options = {}) {
         buyerLossSignals += 1;
       }
 
+      if ((entry.eventType || entry.event) === 'section_view') {
+        incrementCounter(sectionViewsById, entry.sectionId);
+      }
+
+      if ((entry.eventType || entry.event) === 'cta_impression') {
+        ctaImpressions += 1;
+        incrementCounter(ctaImpressionsById, entry.ctaId);
+        incrementCounter(ctaImpressionsByPlacement, entry.ctaPlacement);
+      }
+
+      if ((entry.eventType || entry.event) === 'page_exit') {
+        pageExitEvents += 1;
+        incrementCounter(pageExitsByLastVisibleSection, entry.lastVisibleSection);
+        incrementCounter(pageExitsByDwellBucket, entry.dwellBucket);
+        incrementCounter(pageExitsByScrollBucket, entry.scrollBucket);
+        if (entry.engagementMs !== null) {
+          exitEngagementMsTotal += entry.engagementMs;
+          exitEngagementMsCount += 1;
+        }
+        if (entry.maxScrollPercent !== null) {
+          exitScrollPercentTotal += entry.maxScrollPercent;
+          exitScrollPercentCount += 1;
+        }
+      }
+
+      if ((entry.eventType || entry.event) === 'buyer_email_focus') {
+        emailFocusEvents += 1;
+      }
+
+      if ((entry.eventType || entry.event) === 'buyer_email_abandon') {
+        emailAbandonEvents += 1;
+      }
+
       if ((entry.eventType || entry.event) === 'pricing_interest') {
         pricingInterestEvents += 1;
         incrementCounter(pricingInterestByLevel, entry.pricingInterest);
@@ -623,6 +685,17 @@ function getTelemetrySummary(feedbackDir, options = {}) {
       pageViewsByTrafficChannel[channelKey] || 0
     );
   }
+
+  const trackedLinkConversionBySlug = {};
+  for (const slugKey of new Set([
+    ...Object.keys(trackedLinkHitsBySlug),
+    ...Object.keys(trackedLinkCheckoutStartsBySlug),
+  ])) {
+    trackedLinkConversionBySlug[slugKey] = safeRate(
+      trackedLinkCheckoutStartsBySlug[slugKey] || 0,
+      trackedLinkHitsBySlug[slugKey] || 0
+    );
+  }
   const installCopies = byEventType.install_copy || 0;
   const gptOpens = (byEventType.chatgpt_gpt_open || 0) + (byEventType.chatgpt_gpt_click || 0);
   const trialEmails = byEventType.trial_email_captured || 0;
@@ -666,6 +739,10 @@ function getTelemetrySummary(feedbackDir, options = {}) {
       buyerLossSignals,
       pricingInterestEvents,
       seoLandingViews,
+      ctaImpressions,
+      pageExitEvents,
+      emailFocusEvents,
+      emailAbandonEvents,
       pageViewToCheckoutRate: safeRate(checkoutStarts, pageViews),
       visitorToCheckoutRate: safeRate(checkoutStarts, webVisitors.size),
       visitorIdCoverageRate: safeRate(webEventsWithVisitorId, webEvents),
@@ -674,6 +751,12 @@ function getTelemetrySummary(feedbackDir, options = {}) {
       attributedPageViews,
       attributedCheckoutStarts,
       attributionCoverageRate: safeRate(attributedPageViews, pageViews),
+      averageExitEngagementMs: exitEngagementMsCount > 0
+        ? Math.round(exitEngagementMsTotal / exitEngagementMsCount)
+        : 0,
+      averageExitScrollPercent: exitScrollPercentCount > 0
+        ? Math.round(exitScrollPercentTotal / exitScrollPercentCount)
+        : 0,
     },
     cli: {
       uniqueInstalls: cliInstalls.size,
@@ -716,9 +799,18 @@ function getTelemetrySummary(feedbackDir, options = {}) {
       pricingInterestByLevel,
       seoLandingViewsBySurface,
       seoLandingViewsByQuery,
+      sectionViewsById,
+      pageExitsByLastVisibleSection,
+      pageExitsByDwellBucket,
+      pageExitsByScrollBucket,
+      ctaImpressionsById,
+      ctaImpressionsByPlacement,
       checkoutConversionBySource,
       checkoutConversionByCampaign,
       checkoutConversionByTrafficChannel,
+      trackedLinkHitsBySlug,
+      trackedLinkCheckoutStartsBySlug,
+      trackedLinkConversionBySlug,
     },
     recent: summarizeRecentEvents(events),
   };
@@ -744,6 +836,20 @@ function getTelemetryAnalytics(feedbackDir, options = {}) {
   const topBuyerLossReason = getTopCounterEntry(summary.marketing.buyerLossReasons);
   const topSeoSurface = getTopCounterEntry(summary.marketing.seoLandingViewsBySurface);
   const topSeoQuery = getTopCounterEntry(summary.marketing.seoLandingViewsByQuery);
+  const topViewedSection = getTopCounterEntry(summary.marketing.sectionViewsById);
+  const topExitSection = getTopCounterEntry(summary.marketing.pageExitsByLastVisibleSection);
+  const topExitDwellBucket = getTopCounterEntry(summary.marketing.pageExitsByDwellBucket);
+  const topImpressionCta = getTopCounterEntry(summary.marketing.ctaImpressionsById);
+  const impressionToClickRateById = {};
+  for (const ctaId of new Set([
+    ...Object.keys(summary.marketing.ctaImpressionsById || {}),
+    ...Object.keys(summary.marketing.byCtaId || {}),
+  ])) {
+    impressionToClickRateById[ctaId] = safeRate(
+      (summary.marketing.byCtaId || {})[ctaId] || 0,
+      (summary.marketing.ctaImpressionsById || {})[ctaId] || 0
+    );
+  }
 
   return {
     window: summary.window,
@@ -788,6 +894,7 @@ function getTelemetryAnalytics(feedbackDir, options = {}) {
       checkoutFailures: summary.web.checkoutFailures,
       checkoutCancelled: summary.web.checkoutCancelled,
       checkoutAbandoned: summary.web.checkoutAbandoned,
+      ctaImpressions: summary.web.ctaImpressions,
       successPageViews: summary.web.checkoutSuccessPageViews,
       cancelPageViews: summary.web.checkoutCancelPageViews,
       paidConfirmations: summary.web.checkoutPaidConfirmations,
@@ -824,6 +931,25 @@ function getTelemetryAnalytics(feedbackDir, options = {}) {
       successPageViewRate: safeRate(summary.web.checkoutSuccessPageViews, summary.web.checkoutStarts),
       conversionByTrafficChannel: summary.marketing.checkoutConversionByTrafficChannel,
     },
+    behavior: {
+      sectionViewsById: summary.marketing.sectionViewsById,
+      ctaImpressionsById: summary.marketing.ctaImpressionsById,
+      ctaImpressionsByPlacement: summary.marketing.ctaImpressionsByPlacement,
+      pageExits: summary.web.pageExitEvents,
+      exitsByLastVisibleSection: summary.marketing.pageExitsByLastVisibleSection,
+      exitsByDwellBucket: summary.marketing.pageExitsByDwellBucket,
+      exitsByScrollBucket: summary.marketing.pageExitsByScrollBucket,
+      emailFocusEvents: summary.web.emailFocusEvents,
+      emailAbandonEvents: summary.web.emailAbandonEvents,
+      emailAbandonRate: safeRate(summary.web.emailAbandonEvents, summary.web.emailFocusEvents),
+      averageExitEngagementMs: summary.web.averageExitEngagementMs,
+      averageExitScrollPercent: summary.web.averageExitScrollPercent,
+      impressionToClickRateById,
+      topViewedSection: topViewedSection ? { key: topViewedSection[0], count: topViewedSection[1] } : null,
+      topExitSection: topExitSection ? { key: topExitSection[0], count: topExitSection[1] } : null,
+      topExitDwellBucket: topExitDwellBucket ? { key: topExitDwellBucket[0], count: topExitDwellBucket[1] } : null,
+      topImpressionCta: topImpressionCta ? { key: topImpressionCta[0], count: topImpressionCta[1] } : null,
+    },
     buyerLoss: {
       totalSignals: summary.web.buyerLossSignals,
       reasonsByCode: summary.marketing.buyerLossReasons,
@@ -842,6 +968,29 @@ function getTelemetryAnalytics(feedbackDir, options = {}) {
       topSurface: topSeoSurface ? { key: topSeoSurface[0], count: topSeoSurface[1] } : null,
       topQuery: topSeoQuery ? { key: topSeoQuery[0], count: topSeoQuery[1] } : null,
     },
+    trackedLinks: (() => {
+      const hits = summary.marketing.trackedLinkHitsBySlug || {};
+      const conversions = summary.marketing.trackedLinkCheckoutStartsBySlug || {};
+      const conversionRate = summary.marketing.trackedLinkConversionBySlug || {};
+      const totalHits = Object.values(hits).reduce((acc, n) => acc + n, 0);
+      const totalCheckoutStarts = Object.values(conversions).reduce((acc, n) => acc + n, 0);
+      const top = getTopCounterEntry(hits);
+      const bySlug = {};
+      for (const slug of new Set([...Object.keys(hits), ...Object.keys(conversions)])) {
+        bySlug[slug] = {
+          hits: hits[slug] || 0,
+          checkoutStarts: conversions[slug] || 0,
+          conversionRate: conversionRate[slug] || 0,
+        };
+      }
+      return {
+        totalHits,
+        totalCheckoutStarts,
+        overallConversionRate: safeRate(totalCheckoutStarts, totalHits),
+        bySlug,
+        topSlug: top ? { key: top[0], count: top[1] } : null,
+      };
+    })(),
     cli: summary.cli,
     recent: summary.recent,
   };

package/scripts/thompson-sampling.js

@@ -5,7 +5,7 @@
  * Implements per-category reliability estimates (ML-01) and exponential
  * time-decay weighting with half-life of 7 days (ML-02).
  *
- * Source: Direct port of train_from_feedback.py (Subway_RN_Demo) lines 218-293.
+ * Source: Adapted from earlier local feedback-modeling experiments.
  * Algorithm: Beta-Bernoulli update with Marsaglia-Tsang gamma sampling for
  *            posterior draws. Zero external npm dependencies.
  *
@@ -45,7 +45,7 @@ const DECAY_FLOOR = 0.01;
 const MIN_SAMPLES_THRESHOLD = 5;
 
 /**
- * Default category taxonomy — mirrors Subway's 8-keyword categories plus
+ * Default category taxonomy — mirrors the legacy 8-keyword categories plus
  * 'uncategorized' as the catch-all. Used when initializing a new model.
  */
 const DEFAULT_CATEGORIES = [

package/scripts/token-savings.js

@@ -6,7 +6,7 @@
  *
  * Why this exists:
  *   The mission of ThumbGate is "stop paying for the same AI mistake
- *   twice." Every time a Pre-Action Gate blocks a known-bad tool call,
+ *   twice." Every time a Pre-Action Check blocks a known-bad tool call,
  *   the agent does NOT make a round-trip to the model. That's:
  *
  *     - input tokens you didn't spend (system prompt + tool defs +
@@ -22,10 +22,11 @@
  * Defaults are intentionally conservative — the goal is "you almost
  * certainly saved at least this much," not "let's flatter ourselves."
  *
- * Pricing snapshot (USD per 1M tokens, retrieved 2026-04-15):
+ * Pricing snapshot (USD per 1M tokens, retrieved 2026-04-22 from Anthropic's
+ * official prompt-caching pricing table):
  *   Sonnet 4.5: $3 input, $15 output
- *   Opus 4.6:   $15 input, $75 output
- *   Haiku 4.5:  $0.80 input, $4 output
+ *   Opus 4.6:   $5 input, $25 output
+ *   Haiku 4.5:  $1 input, $5 output
  *   GPT-4o:     $2.50 input, $10 output
  *
  * If the caller doesn't pass a modelMix, we assume a Sonnet-heavy
@@ -36,8 +37,8 @@
 const DEFAULT_MODEL_PRICES = Object.freeze({
   // USD per 1M tokens
   'claude-sonnet-4-5': { input: 3.0, output: 15.0 },
-  'claude-opus-4-6': { input: 15.0, output: 75.0 },
-  'claude-haiku-4-5': { input: 0.80, output: 4.0 },
+  'claude-opus-4-6': { input: 5.0, output: 25.0 },
+  'claude-haiku-4-5': { input: 1.0, output: 5.0 },
   'gpt-4o': { input: 2.50, output: 10.0 },
 });
 

package/scripts/token-tco.js

@@ -0,0 +1,46 @@
+'use strict';
+
+function computeCostPerMillionTokens(input = {}) {
+  const gpuDollarsPerHour = Number(input.gpuDollarsPerHour || 0);
+  const tokensPerSecond = Number(input.tokensPerSecond || 0);
+  if (gpuDollarsPerHour <= 0 || tokensPerSecond <= 0) return Infinity;
+  const tokensPerHour = tokensPerSecond * 60 * 60;
+  return Number(((gpuDollarsPerHour / tokensPerHour) * 1000000).toFixed(6));
+}
+
+function evaluateInferenceTco(input = {}) {
+  let costPerMillionTokens = computeCostPerMillionTokens(input);
+  if (input.costPerMillionTokens !== undefined) {
+    costPerMillionTokens = Number(input.costPerMillionTokens);
+  }
+  const tokensPerRun = Number(input.tokensPerRun || 0);
+  const runsPerDay = Number(input.runsPerDay || 0);
+  const usefulBlocksPerDay = Number(input.usefulBlocksPerDay || 0);
+  const minutesSavedPerBlock = Number(input.minutesSavedPerBlock || 16);
+  const laborDollarsPerHour = Number(input.laborDollarsPerHour || 100);
+
+  const dailyTokenCost = Number(((costPerMillionTokens / 1000000) * tokensPerRun * runsPerDay).toFixed(4));
+  const dailyValue = Number(((usefulBlocksPerDay * minutesSavedPerBlock / 60) * laborDollarsPerHour).toFixed(4));
+  const roi = dailyTokenCost > 0 ? Number((dailyValue / dailyTokenCost).toFixed(2)) : Infinity;
+  const issues = [];
+
+  if (!Number.isFinite(costPerMillionTokens)) issues.push('missing_token_tco_inputs');
+  if (!tokensPerRun) issues.push('missing_tokens_per_run');
+  if (!runsPerDay) issues.push('missing_runs_per_day');
+  if (!usefulBlocksPerDay) issues.push('missing_useful_blocks_per_day');
+
+  return {
+    decision: issues.length ? 'warn' : 'allow',
+    issues,
+    costPerMillionTokens,
+    dailyTokenCost,
+    dailyValue,
+    roi,
+    metric: 'cost_per_useful_blocked_failure',
+  };
+}
+
+module.exports = {
+  computeCostPerMillionTokens,
+  evaluateInferenceTco,
+};