thumbgate 1.15.0 → 1.16.0

package/scripts/code-mode-mcp-plan.js

@@ -0,0 +1,71 @@
+'use strict';
+
+function estimateToolSchemaTokens(endpointCount, tokensPerEndpoint = 450) {
+  return Math.max(0, Number(endpointCount || 0) * Number(tokensPerEndpoint || 0));
+}
+
+function buildCodeModeMcpPlan(options = {}) {
+  const endpointCount = Number(options.endpointCount || 0);
+  const traditionalTokens = estimateToolSchemaTokens(endpointCount, options.tokensPerEndpoint);
+  const codeModeTokens = Number(options.codeModeTokens || 1000);
+
+  return {
+    pattern: 'code_mode_mcp',
+    endpointCount,
+    traditionalTokens,
+    codeModeTokens,
+    tokenReductionPercent: traditionalTokens > 0
+      ? Number((((traditionalTokens - codeModeTokens) / traditionalTokens) * 100).toFixed(2))
+      : 0,
+    tools: [
+      {
+        name: 'search',
+        purpose: 'Find the relevant API area, path, operation, or type without loading the whole schema into context.',
+      },
+      {
+        name: 'execute',
+        purpose: 'Run a bounded code snippet against typed API helpers inside a sandbox.',
+      },
+    ],
+    sandbox: {
+      filesystem: 'none',
+      environmentVariables: 'not_exposed',
+      outboundRequests: 'explicit_handlers_only',
+      maxExecutionMs: Number(options.maxExecutionMs || 10000),
+    },
+    gates: [
+      'search before execute',
+      'execute only against typed helper SDK',
+      'block raw credential access',
+      'record code snippet and API calls in audit log',
+      'require idempotency key for write operations',
+    ],
+  };
+}
+
+function evaluateCodeModeMcpPlan(plan = {}) {
+  const issues = [];
+  if (Number(plan.endpointCount || 0) < 100) issues.push('api_surface_too_small_for_code_mode');
+  if (!Array.isArray(plan.tools) || plan.tools.length !== 2) issues.push('expected_search_and_execute_only');
+  if (plan.sandbox?.filesystem !== 'none') issues.push('filesystem_must_be_disabled');
+  if (plan.sandbox?.environmentVariables !== 'not_exposed') issues.push('env_vars_must_not_be_exposed');
+  if (plan.sandbox?.outboundRequests !== 'explicit_handlers_only') issues.push('outbound_requests_need_handlers');
+  if (!Array.isArray(plan.gates) || !plan.gates.includes('search before execute')) {
+    issues.push('search_before_execute_required');
+  }
+  if (!Array.isArray(plan.gates) || !plan.gates.includes('require idempotency key for write operations')) {
+    issues.push('write_idempotency_required');
+  }
+
+  return {
+    decision: issues.length ? 'warn' : 'allow',
+    issues,
+    tokenReductionPercent: plan.tokenReductionPercent || 0,
+  };
+}
+
+module.exports = {
+  buildCodeModeMcpPlan,
+  estimateToolSchemaTokens,
+  evaluateCodeModeMcpPlan,
+};

package/scripts/context-engine.js

@@ -9,8 +9,7 @@
  * topical bundles and route queries to the most relevant subset. This reduces
  * MCP tool calls and context window consumption.
  *
- * Ported from Subway_RN_Demo/scripts/context-engine.js for ThumbGate.
- * Ported from Subway_RN_Demo/scripts/context-engine.js for thumbgate.
+ * Context assembly engine for ThumbGate feedback memory.
  * PATH: PROJECT_ROOT = path.join(__dirname, '..') — 1 level up from scripts/
  */
 

package/scripts/context-manager.js

@@ -26,7 +26,10 @@ const {
   readSessionHandoff,
   recordProvenance,
 } = require('./contextfs');
-const { retrieveRelevantLessons } = require('./lesson-retrieval');
+const { loadOptionalModule } = require('./private-core-boundary');
+const { retrieveRelevantLessons } = loadOptionalModule('./lesson-retrieval', () => ({
+  retrieveRelevantLessons: () => [],
+}));
 const { evaluatePretool } = require('./hybrid-feedback-context');
 const { loadProfile } = require('./user-profile');
 const {

package/scripts/dashboard-render-spec.js

@@ -243,7 +243,7 @@ function buildIncidentReviewSpec(data) {
         badge: String(gate.action || 'block').toUpperCase(),
         tone: gate.action === 'warn' ? 'info' : 'warning',
       })),
-      'No active gates configured.'
+      'No active checks configured.'
     ),
     buildList(
       'Root cause clusters',

package/scripts/dashboard.js

@@ -6,16 +6,36 @@ const path = require('path');
 const { aggregateFailureDiagnostics } = require('./failure-diagnostics');
 const { AUDIT_LOG_FILENAME } = require('./audit-trail');
 const { getBillingSummary, loadFunnelLedger, loadResolvedRevenueEvents } = require('./billing');
+const {
+  createUnavailableReport,
+  loadOptionalModule,
+} = require('./private-core-boundary');
 const { getTelemetryAnalytics, loadTelemetryEvents } = require('./telemetry-analytics');
 const { getAutoGatesPath } = require('./auto-promote-gates');
-const { summarizeDelegation } = require('./delegation-runtime');
 const { loadGatesConfig } = require('./gates-engine');
 const { filterEntriesForWindow, resolveAnalyticsWindow } = require('./analytics-window');
 const { resolveHostedBillingConfig } = require('./hosted-config');
 const { generateAgentReadinessReport } = require('./agent-readiness');
 const { summarizeGateTemplates } = require('./gate-templates');
-const { generateOrgDashboard } = require('./org-dashboard');
-const { buildPredictiveInsights } = require('./predictive-insights');
+const { buildPredictiveInsights } = loadOptionalModule('./predictive-insights', () => ({
+  buildPredictiveInsights: () => ({
+    upgradePropensity: {
+      pro: { band: 'unavailable', score: 0 },
+      team: { band: 'unavailable', score: 0 },
+    },
+    revenueForecast: {
+      predictedBookedRevenueCents: 0,
+      incrementalOpportunityCents: 0,
+    },
+    anomalySummary: {
+      count: 0,
+      severity: 'none',
+    },
+    topCreators: [],
+    topSources: [],
+    ...createUnavailableReport('Predictive insights'),
+  }),
+}));
 const { routeProfile } = require('./profile-router');
 const { getSettingsStatus } = require('./settings-hierarchy');
 const { summarizeWorkflowRuns } = require('./workflow-runs');
@@ -28,6 +48,40 @@ const DEFAULT_GATES_PATH = path.join(PROJECT_ROOT, 'config', 'gates', 'default.j
 const LANDING_PAGE_PATH = path.join(PROJECT_ROOT, 'public', 'index.html');
 const DASHBOARD_REVIEW_STATE_FILE = 'dashboard-review-state.json';
 
+function loadOrgDashboardModule() {
+  const modulePath = path.resolve(__dirname, 'org-dashboard.js');
+  if (!fs.existsSync(modulePath)) return null;
+  return loadOptionalModule('./org-dashboard', () => ({
+    generateOrgDashboard: ({ windowHours } = {}) => buildUnavailableOrgDashboard(windowHours || 24),
+  }));
+}
+
+function loadDelegationRuntimeModule() {
+  const modulePath = path.resolve(__dirname, 'delegation-runtime.js');
+  if (!fs.existsSync(modulePath)) return null;
+  return require(modulePath);
+}
+
+function buildUnavailableOrgDashboard(windowHours) {
+  return {
+    available: false,
+    windowHours,
+    totalAgents: 0,
+    activeAgents: 0,
+    totalToolCalls: 0,
+    totalBlocked: 0,
+    totalWarned: 0,
+    totalAllowed: 0,
+    orgAdherenceRate: 100,
+    topBlockedGates: [],
+    riskAgents: [],
+    agents: [],
+    proRequired: true,
+    upgradeMessage: 'Org dashboard is available only in the private ThumbGate Core runtime (ThumbGate-Core).',
+    availability: 'private_core',
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Data readers
 // ---------------------------------------------------------------------------
@@ -665,6 +719,197 @@ function countCoverage(entries, resolver) {
   return safeRate(matched, entries.length);
 }
 
+function sumCounterValues(counter = {}) {
+  return Object.values(counter).reduce((sum, value) => sum + (Number(value) || 0), 0);
+}
+
+function sumKeysMatching(counter = {}, matcher) {
+  return Object.entries(counter).reduce((sum, entry) => {
+    const [key, value] = entry;
+    return matcher(key) ? sum + (Number(value) || 0) : sum;
+  }, 0);
+}
+
+function rankCounter(counter = {}, limit = 5) {
+  return Object.entries(counter)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, limit)
+    .map(([key, count]) => ({ key, count }));
+}
+
+function mapBuyerLossTheme(reasonCode) {
+  const normalized = String(reasonCode || 'unknown').toLowerCase();
+  if (['too_expensive', 'price_shock', 'budget', 'need_budget_approval'].includes(normalized)) {
+    return 'pricing';
+  }
+  if (['need_more_proof', 'trust_gap', 'security_unclear'].includes(normalized)) {
+    return 'trust';
+  }
+  if (['not_ready', 'later', 'just_researching'].includes(normalized)) {
+    return 'timing';
+  }
+  if (['need_team_features', 'need_team_approval'].includes(normalized)) {
+    return 'team';
+  }
+  if (['integration_unclear', 'setup_confusing'].includes(normalized)) {
+    return 'integration';
+  }
+  if (['prefer_oss'].includes(normalized)) {
+    return 'open_source';
+  }
+  return 'unknown';
+}
+
+function buildLossAnalysis(analytics) {
+  const telemetry = analytics.telemetry || {};
+  const visitors = telemetry.visitors || {};
+  const ctas = telemetry.ctas || {};
+  const behavior = telemetry.behavior || {};
+  const buyerLoss = analytics.buyerLoss || {};
+  const conversionFunnel = telemetry.conversionFunnel || {};
+  const runtimeConfig = resolveHostedBillingConfig();
+  const monthlyPriceCents = Math.round((Number(runtimeConfig.proPriceDollars) || 19) * 100);
+  const pageViews = visitors.pageViews || 0;
+  const checkoutStarts = ctas.checkoutStarts || 0;
+  const paidOrders = analytics.funnel ? analytics.funnel.paidOrders || 0 : 0;
+  const trialEmails = conversionFunnel.trialEmails || 0;
+  const explicitReasons = buyerLoss.reasonsByCode || {};
+  const reasonThemes = {};
+  Object.entries(explicitReasons).forEach(([reasonCode, count]) => {
+    const theme = mapBuyerLossTheme(reasonCode);
+    reasonThemes[theme] = (reasonThemes[theme] || 0) + count;
+  });
+
+  const proImpressions = sumKeysMatching(behavior.ctaImpressionsById || {}, (key) => /pro|pricing/i.test(key));
+  const proClicks = sumKeysMatching(ctas.byId || {}, (key) => /pro|pricing/i.test(key));
+  const pricingViews = sumKeysMatching(behavior.sectionViewsById || {}, (key) => /pricing/i.test(key));
+  const proofViews = sumKeysMatching(behavior.sectionViewsById || {}, (key) => /proof/i.test(key));
+  const exitsBeforePricing = sumKeysMatching(behavior.exitsByLastVisibleSection || {}, (key) => !/pricing|faq/i.test(key));
+  const checkoutLossCount = Math.max(0, checkoutStarts - paidOrders);
+
+  const stageDropoff = [
+    {
+      key: 'landing_to_checkout',
+      stage: 'landing',
+      lostCount: Math.max(0, pageViews - checkoutStarts),
+      rate: safeRate(Math.max(0, pageViews - checkoutStarts), pageViews),
+    },
+    {
+      key: 'cta_impression_to_click',
+      stage: 'message',
+      lostCount: Math.max(0, proImpressions - proClicks),
+      rate: safeRate(Math.max(0, proImpressions - proClicks), proImpressions),
+    },
+    {
+      key: 'email_focus_to_capture',
+      stage: 'lead_capture',
+      lostCount: Math.max(0, (behavior.emailFocusEvents || 0) - trialEmails),
+      rate: safeRate(Math.max(0, (behavior.emailFocusEvents || 0) - trialEmails), behavior.emailFocusEvents || 0),
+    },
+    {
+      key: 'checkout_to_paid',
+      stage: 'checkout',
+      lostCount: checkoutLossCount,
+      rate: safeRate(checkoutLossCount, checkoutStarts),
+    },
+  ].sort((a, b) => b.lostCount - a.lostCount);
+
+  const inferredCauses = [];
+  if (exitsBeforePricing > 0) {
+    inferredCauses.push({
+      key: 'message_drop_before_pricing',
+      stage: 'landing',
+      count: exitsBeforePricing,
+      evidence: {
+        topExitSection: behavior.topExitSection,
+        pricingViews,
+        pageExits: behavior.pageExits || 0,
+      },
+    });
+  }
+  if (proImpressions > 0 && proClicks < proImpressions) {
+    inferredCauses.push({
+      key: 'weak_pricing_cta_response',
+      stage: 'message',
+      count: Math.max(0, proImpressions - proClicks),
+      evidence: {
+        proImpressions,
+        proClicks,
+        impressionToClickRate: safeRate(proClicks, proImpressions),
+      },
+    });
+  }
+  if ((behavior.emailAbandonEvents || 0) > 0) {
+    inferredCauses.push({
+      key: 'email_capture_friction',
+      stage: 'lead_capture',
+      count: behavior.emailAbandonEvents || 0,
+      evidence: {
+        emailFocusEvents: behavior.emailFocusEvents || 0,
+        emailAbandonEvents: behavior.emailAbandonEvents || 0,
+        emailAbandonRate: behavior.emailAbandonRate || 0,
+      },
+    });
+  }
+  if (checkoutLossCount > 0 || ctas.checkoutFailures || ctas.lookupFailures || ctas.checkoutCancelled || ctas.checkoutAbandoned) {
+    inferredCauses.push({
+      key: 'checkout_friction',
+      stage: 'checkout',
+      count: checkoutLossCount,
+      evidence: {
+        checkoutStarts,
+        paidOrders,
+        checkoutCancelled: ctas.checkoutCancelled || 0,
+        checkoutAbandoned: ctas.checkoutAbandoned || 0,
+        checkoutFailures: ctas.checkoutFailures || 0,
+        lookupFailures: ctas.lookupFailures || 0,
+      },
+    });
+  }
+  const topTheme = rankCounter(reasonThemes, 1)[0] || null;
+  if (topTheme) {
+    inferredCauses.push({
+      key: `explicit_${topTheme.key}`,
+      stage: topTheme.key === 'pricing' ? 'pricing' : 'objection',
+      count: topTheme.count,
+      evidence: {
+        theme: topTheme.key,
+        topReasons: rankCounter(explicitReasons, 3),
+      },
+    });
+  }
+
+  inferredCauses.sort((a, b) => b.count - a.count);
+
+  return {
+    primaryIssue: inferredCauses[0] || null,
+    stageDropoff,
+    inferredCauses,
+    explicitThemes: rankCounter(reasonThemes, 6),
+    explicitReasons: rankCounter(explicitReasons, 6),
+    behaviorSignals: {
+      topViewedSection: behavior.topViewedSection || null,
+      topExitSection: behavior.topExitSection || null,
+      topExitDwellBucket: behavior.topExitDwellBucket || null,
+      topImpressionCta: behavior.topImpressionCta || null,
+      pricingViews,
+      proofViews,
+      pageExits: behavior.pageExits || 0,
+      exitsBeforePricing,
+      averageExitEngagementMs: behavior.averageExitEngagementMs || 0,
+      averageExitScrollPercent: behavior.averageExitScrollPercent || 0,
+      emailFocusEvents: behavior.emailFocusEvents || 0,
+      emailAbandonEvents: behavior.emailAbandonEvents || 0,
+    },
+    revenueOpportunity: {
+      currentMonthlyPriceCents: monthlyPriceCents,
+      checkoutLossCount,
+      explicitBuyerLossCount: buyerLoss.totalSignals || 0,
+      opportunityAtCurrentMonthlyPriceCents: checkoutLossCount * monthlyPriceCents,
+    },
+  };
+}
+
 function computeAnalyticsSummary(feedbackDir, options = {}) {
   const analyticsWindow = resolveAnalyticsWindow(options.analyticsWindow || options);
   const telemetryEntries = filterEntriesForWindow(
@@ -749,6 +994,13 @@ function computeAnalyticsSummary(feedbackDir, options = {}) {
       topSurface: null,
       topQuery: null,
     },
+    trackedLinks: telemetry.trackedLinks || {
+      totalHits: 0,
+      totalCheckoutStarts: 0,
+      overallConversionRate: 0,
+      bySlug: {},
+      topSlug: null,
+    },
     efficiency,
     revenue: billing.revenue || {
       paidProviderEvents: 0,
@@ -1150,9 +1402,19 @@ function generateDashboard(feedbackDir, options = {}) {
     analyticsWindow,
     billingSummary,
   });
+  analytics.lossAnalysis = buildLossAnalysis(analytics);
   const observability = computeObservabilityStats(diagnosticEntries, diagnostics, secretGuard, analytics.telemetry);
   const instrumentation = computeInstrumentationReadiness(analytics, billingSummary);
-  const delegation = summarizeDelegation(feedbackDir);
+  const delegationRuntime = loadDelegationRuntimeModule();
+  const delegation = delegationRuntime
+    ? delegationRuntime.summarizeDelegation(feedbackDir)
+    : {
+      totalHandoffs: 0,
+      successfulHandoffs: 0,
+      blockedHandoffs: 0,
+      activePlans: [],
+      availability: 'private_core',
+    };
   const readiness = generateAgentReadinessReport({ projectRoot: PROJECT_ROOT });
   const harness = computeHarnessOverview(feedbackDir, entries);
   const interventionPolicy = getInterventionPolicySummary(feedbackDir);
@@ -1219,11 +1481,15 @@ function generateDashboard(feedbackDir, options = {}) {
     day.lessons = lessonPipeline.lessonsByDay.get(day.dayKey) || 0;
   }
 
-  const team = generateOrgDashboard({
-    windowHours: resolveTeamWindowHours(analyticsWindow),
-    authContext: options.authContext,
-    proOverride: options.teamProOverride,
-  });
+  const teamWindowHours = resolveTeamWindowHours(analyticsWindow);
+  const orgDashboard = loadOrgDashboardModule();
+  const team = orgDashboard
+    ? orgDashboard.generateOrgDashboard({
+      windowHours: teamWindowHours,
+      authContext: options.authContext,
+      proOverride: options.teamProOverride,
+    })
+    : buildUnavailableOrgDashboard(teamWindowHours);
   const templateLibrary = summarizeGateTemplates();
   const predictive = buildPredictiveInsights({
     telemetryAnalytics: analytics.telemetry,

package/scripts/decision-journal.js

@@ -192,8 +192,18 @@ function collapseDecisionTimeline(records) {
   });
 }
 
-function initializeDaySeries(dayCount) {
-  const today = new Date();
+function resolveNow(now) {
+  if (now instanceof Date) return new Date(now.getTime());
+  if (typeof now === 'number' && Number.isFinite(now)) return new Date(now);
+  if (typeof now === 'string' && now) {
+    const parsed = new Date(now);
+    if (!Number.isNaN(parsed.getTime())) return parsed;
+  }
+  return new Date();
+}
+
+function initializeDaySeries(dayCount, now) {
+  const today = resolveNow(now);
   today.setHours(0, 0, 0, 0);
   const days = [];
   for (let offset = dayCount - 1; offset >= 0; offset -= 1) {
@@ -224,7 +234,7 @@ function computeDecisionMetrics(feedbackDir, options = {}) {
   const dayCount = Number.isInteger(options.dayCount) ? options.dayCount : DEFAULT_DAY_COUNT;
   const records = readDecisionLog(getDecisionLogPath(feedbackDir));
   const actions = collapseDecisionTimeline(records).filter((entry) => entry.evaluation);
-  const series = initializeDaySeries(dayCount);
+  const series = initializeDaySeries(dayCount, options.now);
   const dayMap = new Map(series.map((day) => [day.dayKey, day]));
   const outcomeCounts = {
     accepted: 0,

package/scripts/document-workflow-governance.js

@@ -0,0 +1,62 @@
+'use strict';
+
+function buildDocumentWorkflowPlan(options = {}) {
+  const provider = options.provider || 'secure_content_layer';
+  const workflow = options.workflow || 'document_intake_routing';
+
+  return {
+    workflow,
+    provider,
+    steps: [
+      'discover eligible folders through approved connector scope',
+      'extract document metadata inside sandbox',
+      'classify document type with structured output',
+      'route document to approved destination',
+      'write audit event for every read, extraction, decision, and route',
+    ],
+    zeroTrust: {
+      leastPrivilegeScopes: true,
+      credentialsOutsideSandbox: true,
+      noRawDocumentExportByDefault: true,
+      perFolderApproval: true,
+    },
+    requiredEvidence: [
+      'connector scope',
+      'source document id',
+      'classification result',
+      'route destination',
+      'audit event id',
+      'sandbox manifest',
+    ],
+    gates: [
+      'block routing when connector scope is missing',
+      'block raw content export unless explicitly approved',
+      'block completion claims without audit event id',
+      'require human review for legal, financial, medical, or HR documents',
+    ],
+  };
+}
+
+function evaluateDocumentWorkflowRun(run = {}) {
+  const issues = [];
+  if (!run.connectorScope) issues.push('missing_connector_scope');
+  if (!run.sourceDocumentId) issues.push('missing_source_document_id');
+  if (!run.classification) issues.push('missing_classification');
+  if (!run.routeDestination) issues.push('missing_route_destination');
+  if (!run.auditEventId) issues.push('missing_audit_event_id');
+  if (!run.sandboxManifest) issues.push('missing_sandbox_manifest');
+  if (run.rawExport && !run.rawExportApproved) issues.push('raw_export_requires_approval');
+  if (['legal', 'financial', 'medical', 'hr'].includes(String(run.classification).toLowerCase()) && !run.humanReviewed) {
+    issues.push('sensitive_document_human_review_required');
+  }
+
+  return {
+    decision: issues.length ? 'deny' : 'allow',
+    issues,
+  };
+}
+
+module.exports = {
+  buildDocumentWorkflowPlan,
+  evaluateDocumentWorkflowRun,
+};

package/scripts/enterprise-agent-rollout.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+'use strict';
+
+function buildEnterpriseAgentRollout(input = {}) {
+  const industry = input.industry || 'enterprise software';
+  return {
+    program: 'ThumbGate Enterprise Agent Acceleration',
+    industry,
+    operatingModel: {
+      forwardDeployedEngineer: true,
+      humanInTheLead: true,
+      domainExpertsRequired: true,
+      sovereignDeploymentOption: true,
+    },
+    phases: [
+      { id: 'discover', outcome: 'rank workflows by measurable business value and risk' },
+      { id: 'prototype', outcome: 'ship one governed agent with evidence and rollback' },
+      { id: 'scale', outcome: 'publish reusable agent catalog and approval policies' },
+      { id: 'operate', outcome: 'review traces, ROI, incidents, and policy drift weekly' },
+    ],
+    governance: [
+      'human oversight for high-stakes recommendations',
+      'sovereign data boundary when required',
+      'agent catalog with owner and allowed tools',
+      'decision journal for every business-critical action',
+      'measurable outcome before expansion',
+    ],
+    metrics: ['cycle_time_saved', 'blocked_risky_actions', 'approved_agent_runs', 'business_value_cents', 'incident_rate'],
+  };
+}
+
+module.exports = {
+  buildEnterpriseAgentRollout,
+};

package/scripts/experience-replay-governance.js

@@ -0,0 +1,69 @@
+'use strict';
+
+function buildExperienceReplayPolicy(options = {}) {
+  const maxStalenessHours = Number.isFinite(options.maxStalenessHours) ? options.maxStalenessHours : 24;
+  const replayRatio = Number.isFinite(options.replayRatio) ? options.replayRatio : 0.25;
+  const minEntropy = Number.isFinite(options.minEntropy) ? options.minEntropy : 0.65;
+
+  return {
+    policyId: 'feedback_experience_replay',
+    purpose: 'Reuse high-signal feedback trajectories without letting stale lessons dominate training.',
+    buffer: {
+      strategy: 'fifo_with_quality_filters',
+      maxStalenessHours,
+      replayRatio,
+      sampleWithoutRemoval: true,
+    },
+    filters: [
+      'redacted',
+      'source_feedback_id_present',
+      'outcome_evidence_present',
+      'not_contradicted_by_newer_lesson',
+      'not_low_confidence_or_vague_feedback',
+    ],
+    monitors: {
+      maxStalenessHours,
+      minEntropy,
+      compareAgainstFreshOnly: true,
+      metrics: ['gate_precision', 'gate_recall', 'unsupported_claim_rate', 'policy_entropy', 'compute_saved_percent'],
+    },
+  };
+}
+
+function evaluateReplayCandidate(candidate = {}, policy = buildExperienceReplayPolicy()) {
+  const issues = [];
+  if (!candidate.sourceFeedbackId) issues.push('missing_source_feedback_id');
+  if (!candidate.redacted) issues.push('redaction_required');
+  if (!candidate.outcomeEvidence) issues.push('missing_outcome_evidence');
+  if (candidate.contradictedByNewerLesson) issues.push('contradicted_by_newer_lesson');
+  if (candidate.vagueFeedback) issues.push('vague_feedback_not_replayable');
+
+  const ageHours = Number(candidate.ageHours || 0);
+  if (ageHours > policy.buffer.maxStalenessHours) issues.push('stale_replay_sample');
+
+  return {
+    decision: issues.length ? 'reject' : 'accept',
+    issues,
+    replayWeight: issues.length ? 0 : Math.min(policy.buffer.replayRatio, Number(candidate.qualityScore || 1)),
+  };
+}
+
+function evaluateReplayRun(run = {}, policy = buildExperienceReplayPolicy()) {
+  const issues = [];
+  if (Number(run.replayRatio || 0) > 0.5) issues.push('replay_ratio_too_high');
+  if (Number(run.policyEntropy || 0) < policy.monitors.minEntropy) issues.push('policy_entropy_too_low');
+  if (!run.freshOnlyBaseline) issues.push('missing_fresh_only_baseline');
+  if (!run.computeSavedPercent && run.computeSavedPercent !== 0) issues.push('missing_compute_saved_metric');
+
+  return {
+    decision: issues.length ? 'warn' : 'allow',
+    issues,
+    computeEfficient: Number(run.computeSavedPercent || 0) > 0 && Number(run.policyEntropy || 0) >= policy.monitors.minEntropy,
+  };
+}
+
+module.exports = {
+  buildExperienceReplayPolicy,
+  evaluateReplayCandidate,
+  evaluateReplayRun,
+};

package/scripts/export-hf-dataset.js

@@ -123,7 +123,7 @@ function buildPreferenceRow(pair, index) {
 function buildDatasetInfo({ traceCount, preferenceCount, exportedAt }) {
   return {
     dataset_info: {
-      description: 'Agent traces and DPO preference pairs from ThumbGate — pre-action gates for AI coding agents. Contains real-world tool call feedback, failure patterns, and learned corrections.',
+      description: 'Agent traces and DPO preference pairs from ThumbGate — pre-action checks for AI coding agents. Contains real-world tool call feedback, failure patterns, and learned corrections.',
       citation: '',
       homepage: 'https://github.com/IgorGanapolsky/ThumbGate',
       license: 'MIT',