thumbgate 1.27.18 → 1.27.19

package/scripts/context-manager.js

@@ -1,6 +1,9 @@
 #!/usr/bin/env node
 'use strict';
 
+const fs = require('fs');
+const path = require('path');
+
 /**
  * Context Manager — Unified Context-Augmented Generation (CAG) Orchestrator
  *
@@ -27,8 +30,9 @@ const {
   recordProvenance,
 } = require('./contextfs');
 const { loadOptionalModule } = require('./private-core-boundary');
-const { retrieveRelevantLessons } = loadOptionalModule('./lesson-retrieval', () => ({
+const { retrieveRelevantLessons, calculateRetrievalEntropy } = loadOptionalModule('./lesson-retrieval', () => ({
   retrieveRelevantLessons: () => [],
+  calculateRetrievalEntropy: () => 0,
 }));
 const { evaluatePretool } = require('./hybrid-feedback-context');
 const { loadProfile } = require('./user-profile');
@@ -93,13 +97,21 @@ function assembleSession() {
 
 function assembleLessons(query, agentProfile, options = {}) {
   try {
-    return retrieveRelevantLessons(
+    const lessons = retrieveRelevantLessons(
       options.toolName || '',
       query,
       { maxResults: agentProfile.maxLessons, feedbackDir: options.feedbackDir },
     );
+    
+    const entropy = calculateRetrievalEntropy(lessons);
+    
+    return { 
+      items: lessons, 
+      entropy, 
+      highConflict: entropy > 0.7 
+    };
   } catch {
-    return [];
+    return { items: [], entropy: 0, highConflict: false };
   }
 }
 
@@ -111,13 +123,41 @@ function assembleGuards(toolName, toolInput) {
   }
 }
 
-function assembleContextPack(query, agentProfile) {
+function assembleContextPack(query, agentProfile, options = {}) {
+  const { guards } = options;
   try {
     ensureContextFs();
+
+    // 1. Proactive Governance: Filter what the agent sees based on prevention rules
+    let structuredQuery = query;
+    if (guards && guards.mode === 'block') {
+      structuredQuery = `${query} (Active Block Policy: ${guards.reason})`;
+    }
+
+    // 2. Elevate Thompson Sampling to Architecture Level
+    let strategy = null;
+    try {
+      const ts = require('./thompson-sampling');
+      const model = ts.loadModel();
+      const bestCategory = ts.argmaxPosteriors(model);
+      
+      // Route between context-building strategies based on TS posterior mean
+      if (bestCategory === 'architecture' || bestCategory === 'infra') {
+        strategy = 'hierarchical';
+      } else if (bestCategory === 'observability' || bestCategory === 'debugging') {
+        strategy = 'summarize-then-expand';
+      } else {
+        strategy = 'semantic';
+      }
+    } catch (e) {
+      // Fallback to default routing
+    }
+
     return constructContextPack({
-      query,
+      query: structuredQuery,
       maxItems: Math.min(8, Math.ceil(agentProfile.contextBudget / 1000)),
       maxChars: agentProfile.contextBudget,
+      strategy
     });
   } catch {
     return null;
@@ -196,7 +236,8 @@ function assembleUnifiedContext(params = {}) {
   // Assemble all components — each is fault-tolerant
   const session = assembleSession();
   const userProfile = assembleUserProfile();
-  const lessons = assembleLessons(query, agentProfile, { toolName, feedbackDir });
+  const lessonData = assembleLessons(query, agentProfile, { toolName, feedbackDir });
+  const lessons = lessonData.items;
   const guards = assembleGuards(toolName, toolInput);
   const contextPack = assembleContextPack(query, agentProfile);
   const codeGraph = assembleCodeGraph(query, repoPath, agentProfile);
@@ -204,9 +245,24 @@ function assembleUnifiedContext(params = {}) {
   const components = { session, userProfile, lessons, guards, contextPack, codeGraph };
   const tier = classifyTier(components);
 
+  // v4.2: Entropy-Aware Reliability Directive
+  let reliabilityDirective = null;
+  if (lessonData.highConflict) {
+    reliabilityDirective = 'CAUTION: Conflicting past patterns detected for this action. Prioritize absolute ground truth verification over rapid completion.';
+  }
+
+  // v1.26.0: CodeRabbit Planning Directive
+  const planPath = path.join(repoPath || process.cwd(), 'PLAN.md');
+  if (!fs.existsSync(planPath) && ['Bash', 'Write', 'Edit', 'Deploy'].includes(toolName)) {
+    const planReminder = 'ORCHESTRATION: High-risk action detected without a PLAN.md. Please document your intent, assumptions, and verification steps before proceeding.';
+    reliabilityDirective = reliabilityDirective ? `${reliabilityDirective}\n\n${planReminder}` : planReminder;
+  }
+
   const result = {
     tier,
     agentType: agentType || 'default',
+    reliabilityDirective,
+    entropy: lessonData.entropy,
     agentProfile: {
       maxLessons: agentProfile.maxLessons,
       contextBudget: agentProfile.contextBudget,
@@ -228,6 +284,12 @@ function assembleUnifiedContext(params = {}) {
       })),
       visibility: contextPack.visibility || null,
       cached: !!(contextPack.cache && contextPack.cache.hit),
+      layers: {
+        localState: session || null,
+        graphState: codeGraph || null,
+        policyState: guards || null,
+        sessionState: contextPack.items ? contextPack.items.filter(i => i.namespace === 'session') : []
+      }
     } : null,
     codeGraph: codeGraph || null,
     assembledAt: new Date().toISOString(),
@@ -306,6 +368,12 @@ function formatUnifiedContext(ctx) {
 
   // Context pack
   if (ctx.contextPack) {
+    lines.push(`### Context Architecture Layers`);
+    lines.push(`- Local State: ${ctx.contextPack.layers.localState ? 'Active' : 'Empty'}`);
+    lines.push(`- Graph State: ${ctx.contextPack.layers.graphState ? 'Active' : 'Empty'}`);
+    lines.push(`- Policy State: ${ctx.contextPack.layers.policyState ? ctx.contextPack.layers.policyState.mode : 'Empty'}`);
+    lines.push(`- Session State: ${ctx.contextPack.layers.sessionState.length} items`);
+    lines.push('');
     lines.push(`### Context Pack (${ctx.contextPack.itemCount} items)`);
     ctx.contextPack.items.forEach((item) => {
       lines.push(`- [${item.namespace}] ${item.title} (score: ${item.score})`);

package/scripts/dashboard.js

@@ -17,6 +17,7 @@ const { filterEntriesForWindow, resolveAnalyticsWindow } = require('./analytics-
 const { resolveHostedBillingConfig } = require('./hosted-config');
 const { generateAgentReadinessReport } = require('./agent-readiness');
 const { summarizeGateTemplates } = require('./gate-templates');
+const { mergeRepeatMetricIntoGateStats } = require('./repeat-metric');
 const { buildPredictiveInsights } = loadOptionalModule('./predictive-insights', () => ({
   buildPredictiveInsights: () => ({
     upgradePropensity: {
@@ -48,6 +49,10 @@ const {
   readDecisionLog,
 } = require('./decision-journal');
 const { analyzeFeedback } = require('./feedback-loop');
+const {
+  collectAggregateLogEntries,
+  shouldAggregateFeedback,
+} = require('./feedback-aggregate');
 
 const PROJECT_ROOT = path.join(__dirname, '..');
 const DEFAULT_GATES_PATH = path.join(PROJECT_ROOT, 'config', 'gates', 'default.json');
@@ -967,6 +972,20 @@ function computeAnalyticsSummary(feedbackDir, options = {}) {
   return {
     window: telemetry.window || analyticsWindow,
     telemetry,
+    firstPartyTrafficQuality: telemetry.trafficQuality || {
+      rawEvents: telemetry.totalEvents || 0,
+      externalEvents: 0,
+      excludedEvents: 0,
+      exclusionRate: 0,
+      byAudience: {},
+      byExclusionReason: {},
+      external: {
+        uniqueVisitors: 0,
+        pageViews: 0,
+        checkoutStarts: 0,
+      },
+      verdict: 'missing',
+    },
     funnel: {
       visitors: uniqueVisitors,
       sessions: telemetry.visitors ? telemetry.visitors.uniqueSessions || 0 : 0,
@@ -1149,16 +1168,42 @@ function computeInstrumentationReadiness(analytics, billing) {
   const coverage = billing && billing.coverage ? billing.coverage : {};
   const telemetry = analytics.telemetry || {};
   const visitors = telemetry.visitors || {};
+  const quality = telemetry.trafficQuality || analytics.firstPartyTrafficQuality || {};
+  const external = quality.external || {};
   const cli = telemetry.cli || {};
+  const plausibleExportConfigured = Boolean(
+    process.env.PLAUSIBLE_API_KEY && (process.env.PLAUSIBLE_SITE_ID || process.env.PLAUSIBLE_DOMAIN)
+  );
+  const posthogExportConfigured = Boolean(
+    (process.env.POSTHOG_PERSONAL_API_KEY || process.env.POSTHOG_API_KEY) && process.env.POSTHOG_PROJECT_ID
+  );
+  const ga4ExportConfigured = Boolean(
+    process.env.GA4_PROPERTY_ID && (process.env.GOOGLE_APPLICATION_CREDENTIALS || process.env.GOOGLE_CLIENT_EMAIL)
+  );
+  const dashboardGradeExportReady = plausibleExportConfigured || posthogExportConfigured || ga4ExportConfigured;
 
   return {
-    plausibleConfigured: /plausible\.io\/js\/script\.js|\/js\/analytics\.js/.test(landingPage),
+    plausibleConfigured: /plausible\.io\/js\/script(?:\.tagged-events)?\.js|\/js\/analytics\.js/.test(landingPage),
     ga4Configured: Boolean(runtimeConfig.gaMeasurementId),
     googleSearchConsoleConfigured: Boolean(runtimeConfig.googleSiteVerification),
     softwareApplicationSchemaPresent: /"@type": "SoftwareApplication"/.test(landingPage),
     faqSchemaPresent: /"@type": "FAQPage"/.test(landingPage),
     telemetryEventsPresent: (telemetry.totalEvents || 0) > 0,
     uniqueVisitorsTracked: visitors.uniqueVisitors || 0,
+    rawTelemetryEvents: quality.rawEvents || telemetry.totalEvents || 0,
+    externalTelemetryEvents: quality.externalEvents || 0,
+    excludedTelemetryEvents: quality.excludedEvents || 0,
+    externalVisitorsTracked: external.uniqueVisitors || 0,
+    externalPageViewsTracked: external.pageViews || 0,
+    externalCheckoutStartsTracked: external.checkoutStarts || 0,
+    externalVisitorPathsTracked: Array.isArray(external.visitorPaths) ? external.visitorPaths.length : 0,
+    internalTestPollutionRate: quality.exclusionRate || 0,
+    trafficQualityVerdict: quality.verdict || 'missing',
+    topExcludedTrafficReason: quality.topExclusionReason || null,
+    plausibleExportConfigured,
+    posthogExportConfigured,
+    ga4ExportConfigured,
+    dashboardGradeExportReady,
     cliInstallsTracked: cli.uniqueInstalls || 0,
     funnelEventsPresent: (analytics.reconciliation.telemetryCheckoutStarts || 0) > 0,
     seoSignalsPresent: (analytics.seo.landingViews || 0) > 0,
@@ -1504,6 +1549,10 @@ function resolveTeamWindowHours(analyticsWindow) {
 // ---------------------------------------------------------------------------
 
 function collectAllFeedbackEntries(feedbackDir) {
+  if (shouldAggregateFeedback()) {
+    return collectAggregateLogEntries('feedback-log.jsonl', { feedbackDir }).entries;
+  }
+
   const entries = [];
   const seen = new Set();
 
@@ -1573,7 +1622,11 @@ function generateDashboard(feedbackDir, options = {}) {
   const billingSummary = options.billingSummary || getBillingSummary(analyticsWindow);
 
   const approval = computeApprovalStats(entries);
-  const gateStats = computeGateStats();
+  // Surface the "repeat-attempts blocked before execution" metric on the
+  // dashboard JSON and the /v1/dashboard HTTP route. Use the non-mutating
+  // helper (mirrors server-stdio.js) instead of mutating computeGateStats()'s
+  // return value. (mergeRepeatMetricIntoGateStats is imported at top of file.)
+  const gateStats = mergeRepeatMetricIntoGateStats(computeGateStats());
   const prevention = computePreventionImpact(feedbackDir, gateStats);
   const trend = computeSessionTrend(entries, 10);
   const health = computeSystemHealth(feedbackDir, gateStats);
@@ -1865,8 +1918,10 @@ function printDashboard(data) {
   console.log('');
   console.log('\uD83D\uDCBC Growth Analytics');
   console.log(`  Unique Visitors  : ${analytics.trafficMetrics.visitors}`);
+  console.log(`  External Visitors: ${instrumentation.externalVisitorsTracked}`);
   console.log(`  Sessions         : ${analytics.trafficMetrics.sessions}`);
   console.log(`  Page Views       : ${analytics.trafficMetrics.pageViews}`);
+  console.log(`  External Views   : ${instrumentation.externalPageViewsTracked}`);
   console.log(`  CTA Clicks       : ${analytics.trafficMetrics.ctaClicks}`);
   console.log(`  Leads            : ${analytics.funnel.acquisitionLeads}`);
   console.log(`  Sprint Leads     : ${analytics.pipeline.workflowSprintLeads.total}`);
@@ -1877,6 +1932,7 @@ function printDashboard(data) {
   console.log(`  Booked Revenue   : $${(analytics.revenue.bookedRevenueCents / 100).toFixed(2)}`);
   console.log(`  Matched Journeys : ${analytics.reconciliation.matchedPaidOrders}/${analytics.reconciliation.telemetryCheckoutStarts}`);
   console.log(`  Buyer Loss       : ${analytics.buyerLoss.totalSignals}`);
+  console.log(`  Data Quality     : ${analytics.firstPartyTrafficQuality.verdict} (${instrumentation.excludedTelemetryEvents}/${instrumentation.rawTelemetryEvents} excluded)`);
   if (analytics.telemetry.visitors.topSource) {
     console.log(`  Top Source       : ${analytics.telemetry.visitors.topSource.key} (${analytics.telemetry.visitors.topSource.count}\u00D7)`);
   }
@@ -1896,6 +1952,15 @@ function printDashboard(data) {
   console.log(`  GA4              : ${instrumentation.ga4Configured ? 'configured' : 'missing'}`);
   console.log(`  Search Console   : ${instrumentation.googleSearchConsoleConfigured ? 'configured' : 'missing'}`);
   console.log(`  Telemetry Events : ${instrumentation.telemetryEventsPresent ? instrumentation.uniqueVisitorsTracked : 0} visitors`);
+  console.log(`  Clean Visitors   : ${instrumentation.externalVisitorsTracked} external (${Math.round((instrumentation.internalTestPollutionRate || 0) * 100)}% internal/test/bot events)`);
+  console.log(`  Clean Paths      : ${instrumentation.externalVisitorPathsTracked} first-party paths`);
+  if (instrumentation.topExcludedTrafficReason) {
+    console.log(`  Top Exclusion    : ${instrumentation.topExcludedTrafficReason.key} (${instrumentation.topExcludedTrafficReason.count}\u00D7)`);
+  }
+  console.log(`  Plausible Export : ${instrumentation.plausibleExportConfigured ? 'configured' : 'missing API credentials'}`);
+  console.log(`  PostHog Export   : ${instrumentation.posthogExportConfigured ? 'configured' : 'missing API credentials'}`);
+  console.log(`  GA4 Export       : ${instrumentation.ga4ExportConfigured ? 'configured' : 'missing API credentials'}`);
+  console.log(`  Visitor Paths    : ${instrumentation.dashboardGradeExportReady ? 'export-ready' : 'not dashboard-grade in repo'}`);
   console.log(`  SEO Signals      : ${instrumentation.seoSignalsPresent ? analytics.seo.landingViews : 0}`);
   console.log(`  Buyer Loss       : ${instrumentation.buyerLossSignalsPresent ? analytics.buyerLoss.totalSignals : 0}`);
   console.log(`  Attribution      : ${Math.round((instrumentation.trafficAttributionCoverage || 0) * 100)}% page-view coverage`);
@@ -2025,6 +2090,7 @@ module.exports = {
   computeObservabilityStats,
   readJSONL,
   readJsonFile,
+  collectAllFeedbackEntries,
 };
 
 if (require.main === module) {

package/scripts/export-databricks-bundle.js

@@ -6,6 +6,7 @@ const path = require('path');
 
 const { getFeedbackPaths } = require('./feedback-loop');
 const { ensureDir } = require('./fs-utils');
+const { redactSecretsDeep } = require('./secret-redaction');
 
 const PROJECT_ROOT = path.join(__dirname, '..');
 const DEFAULT_PROOF_DIR = process.env.THUMBGATE_PROOF_DIR
@@ -47,7 +48,10 @@ function readJSON(filePath) {
 }
 
 function writeJSONL(filePath, rows) {
-  const content = rows.map((row) => JSON.stringify(row)).join('\n');
+  // Redact secrets from every bundle row — this is the single choke point for all bundle tables
+  // (feedback_events, memory_records, sequences, attributions, proof_reports). A shared/published
+  // dataset must never ship a captured credential. See scripts/secret-redaction.js.
+  const content = rows.map((row) => JSON.stringify(redactSecretsDeep(row))).join('\n');
   fs.writeFileSync(filePath, content ? `${content}\n` : '');
 }
 

package/scripts/export-dpo-pairs.js

@@ -9,6 +9,7 @@ const fs = require('fs');
 const path = require('path');
 const { traceForDpoPair, aggregateTraces } = require('./code-reasoning');
 const { resolveFeedbackDir } = require('./feedback-paths');
+const { redactSecretsDeep } = require('./secret-redaction');
 
 const DEFAULT_LOCAL_MEMORY_LOG = path.join(resolveFeedbackDir(), 'memory-log.jsonl');
 
@@ -201,14 +202,18 @@ function exportDpoFromMemories(memories) {
     },
   }));
 
+  // Redact secrets before the pairs leave this module — they are derived from memory content and
+  // are shipped to disk here AND consumed by export-hf-dataset.js. See scripts/secret-redaction.js.
+  const redactedPairs = pairsWithTraces.map((pair) => redactSecretsDeep(pair));
+
   return {
-    pairs: pairsWithTraces,
+    pairs: redactedPairs,
     unpairedErrors: result.unpairedErrors,
     unpairedLearnings: result.unpairedLearnings,
     errors,
     learnings,
     reasoning,
-    jsonl: toJSONL(pairsWithTraces),
+    jsonl: toJSONL(redactedPairs),
   };
 }
 

package/scripts/feedback-loop.js

@@ -56,6 +56,90 @@ const {
 
 const AUDIT_TRAIL_TAG = 'audit-trail';
 
+/**
+ * Anonymous fire-and-forget CLI feedback telemetry.
+ *
+ * Pings the hosted /v1/telemetry/ping endpoint exactly once per successful
+ * local feedback capture so the dashboard can measure CLI-side lesson volume.
+ *
+ * Hard contract (do NOT widen without explicit approval):
+ *   - ONE event type: `feedback_captured`
+ *   - Payload: { installId, signal: 'up'|'down', tier, ts } only.
+ *     No context strings, tags, file paths, or content of any kind.
+ *   - Opt-out: THUMBGATE_DISABLE_TELEMETRY=1 (or 'true') short-circuits
+ *     immediately. Legacy THUMBGATE_NO_TELEMETRY=1 / DO_NOT_TRACK=1 are
+ *     also honored for parity with cli-telemetry.js.
+ *   - Fire-and-forget: NEVER await this call. Errors are swallowed.
+ *   - 2-second timeout via AbortSignal.timeout.
+ */
+function emitAnonymousFeedbackPing(signal) {
+  try {
+    const env = process.env || {};
+    if (
+      env.THUMBGATE_DISABLE_TELEMETRY === '1' ||
+      env.THUMBGATE_DISABLE_TELEMETRY === 'true' ||
+      env.THUMBGATE_NO_TELEMETRY === '1' ||
+      env.DO_NOT_TRACK === '1'
+    ) {
+      return;
+    }
+
+    const normalizedSignal = signal === 'positive' ? 'up' : signal === 'negative' ? 'down' : null;
+    if (!normalizedSignal) return;
+
+    // Reuse the canonical installId from cli-telemetry.js (persisted at
+    // ~/.thumbgate/install-id). Falls back to a fresh UUID if that module
+    // is unavailable — better to ship an event we can dedup on the server
+    // than to drop the ping entirely.
+    let installId = null;
+    try {
+      const { getInstallId } = require('./cli-telemetry');
+      installId = getInstallId();
+    } catch (_) { /* fall through */ }
+    if (!installId) {
+      try {
+        installId = require('crypto').randomUUID();
+      } catch (_) {
+        return; // no crypto, no install id → drop silently
+      }
+    }
+
+    let tier = 'free';
+    try {
+      const { getStatuslineMeta } = require('./statusline-meta');
+      const meta = getStatuslineMeta({ env });
+      const rawTier = String(meta && meta.tier ? meta.tier : 'free').toLowerCase();
+      if (rawTier === 'pro' || rawTier === 'enterprise' || rawTier === 'free') {
+        tier = rawTier;
+      }
+    } catch (_) { /* default to 'free' */ }
+
+    const base = env.THUMBGATE_PUBLIC_APP_ORIGIN
+      || env.THUMBGATE_API_URL
+      || 'https://thumbgate-production.up.railway.app';
+
+    const body = JSON.stringify({
+      eventType: 'feedback_captured',
+      clientType: 'cli',
+      installId,
+      signal: normalizedSignal,
+      tier,
+      ts: new Date().toISOString(),
+    });
+
+    // Fire-and-forget. No await. AbortSignal.timeout enforces the 2s cap.
+    if (typeof fetch !== 'function' || typeof AbortSignal === 'undefined' || typeof AbortSignal.timeout !== 'function') {
+      return;
+    }
+    fetch(`${base.replace(/\/+$/, '')}/v1/telemetry/ping`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body,
+      signal: AbortSignal.timeout(2000),
+    }).catch(() => { /* fire-and-forget */ });
+  } catch (_) { /* telemetry must never disrupt CLI */ }
+}
+
 function isAuditTrailEntry(entry = {}) {
   return Array.isArray(entry.tags) && entry.tags.includes(AUDIT_TRAIL_TAG);
 }
@@ -1059,6 +1143,7 @@ function captureFeedback(params) {
         : null),
     structuredRule: structuredRule || null,
     ...(reflection && { reflection }),
+    gateAction: params.gateAction || null,
     timestamp: now,
   };
 
@@ -1112,6 +1197,7 @@ function captureFeedback(params) {
     summary.lastUpdated = now;
     saveSummary(summary);
     appendJSONL(FEEDBACK_LOG_PATH, feedbackEvent);
+    emitAnonymousFeedbackPing(signal);
     try { appendRejectionLedger(feedbackEvent, action.reason); } catch { /* non-critical */ }
     try {
       appendSequence(historyEntries, feedbackEvent, getFeedbackPaths(), { accepted: false });
@@ -1153,6 +1239,7 @@ function captureFeedback(params) {
       ...feedbackEvent,
       validationIssues: prepared.issues,
     });
+    emitAnonymousFeedbackPing(signal);
     try { appendRejectionLedger(feedbackEvent, `Schema validation failed: ${prepared.issues.join('; ')}`); } catch { /* non-critical */ }
     try {
       appendSequence(historyEntries, feedbackEvent, getFeedbackPaths(), { accepted: false });
@@ -1227,6 +1314,7 @@ function captureFeedback(params) {
   }
 
   appendJSONL(FEEDBACK_LOG_PATH, feedbackEvent);
+  emitAnonymousFeedbackPing(signal);
 
   // Synthesis: merge similar lessons instead of creating duplicates
   let synthesisResult = null;
@@ -1398,7 +1486,7 @@ function captureFeedback(params) {
   if (feedbackEvent.signal === 'negative') {
     try {
       const autoPromote = require('./auto-promote-gates');
-      const promoteResult = autoPromote.promote(FEEDBACK_LOG_PATH);
+      const promoteResult = autoPromote.promote(FEEDBACK_LOG_PATH, { gateAction: feedbackEvent.gateAction });
       // First-rule activation telemetry: anonymous ping the first time
       // a prevention rule auto-promotes for this install. Idempotent —
       // see scripts/activation-tracker.js. Critical for activation funnel
@@ -1411,10 +1499,44 @@ function captureFeedback(params) {
             totalGates: promoteResult.totalGates,
           });
         } catch { /* activation telemetry is non-critical */ }
+
+        // Trigger Self-Harness Optimizer to propagate the new rules to prompt files & validate
+        try {
+          const { fork } = require('child_process');
+          const localOptimizerPath = path.join(process.cwd(), 'scripts', 'self-harness-optimizer.js');
+          const packageOptimizerPath = path.join(__dirname, 'self-harness-optimizer.js');
+          
+          if (fs.existsSync(localOptimizerPath)) {
+            fork(localOptimizerPath, [], { stdio: 'ignore', detached: true }).unref();
+          } else if (fs.existsSync(packageOptimizerPath)) {
+            fork(packageOptimizerPath, [], { stdio: 'ignore', detached: true }).unref();
+          }
+        } catch (err) {
+          console.error('Failed to trigger self-harness optimizer:', err);
+        }
       }
     } catch { /* Gate promotion is non-critical */ }
   }
 
+  // Auto-export to Obsidian if configured (deferred but tracked)
+  if (process.env.THUMBGATE_OBSIDIAN_VAULT_PATH) {
+    const exportPromise = new Promise((resolve) => {
+      setImmediate(() => {
+        try {
+          const { exportAll } = require('./obsidian-export');
+          exportAll({
+            feedbackDir: FEEDBACK_DIR,
+            outputDir: process.env.THUMBGATE_OBSIDIAN_VAULT_PATH,
+          });
+        } catch (_err) {
+          // Non-critical, do not crash feedback loop
+        }
+        resolve();
+      });
+    });
+    trackBackgroundSideEffect(exportPromise);
+  }
+
   // --- Deferred side-effects (contextFs, RLAIF — non-critical, potentially slow) ---
   setImmediate(() => {
     try {

package/scripts/feedback-quality.js

@@ -62,6 +62,92 @@ function normalizeFeedbackText(value) {
     .trim();
 }
 
+function editDistance(a, b) {
+  const left = String(a || '');
+  const right = String(b || '');
+  const dp = Array.from({ length: left.length + 1 }, () => Array(right.length + 1).fill(0));
+  for (let i = 0; i <= left.length; i++) dp[i][0] = i;
+  for (let j = 0; j <= right.length; j++) dp[0][j] = j;
+  for (let i = 1; i <= left.length; i++) {
+    for (let j = 1; j <= right.length; j++) {
+      const cost = left[i - 1] === right[j - 1] ? 0 : 1;
+      dp[i][j] = Math.min(
+        dp[i - 1][j] + 1,
+        dp[i][j - 1] + 1,
+        dp[i - 1][j - 1] + cost,
+      );
+    }
+  }
+  return dp[left.length][right.length];
+}
+
+function isNearThumbToken(token) {
+  const value = String(token || '');
+  if (value.length < 4) return false;
+  return editDistance(value, 'thumb') <= 1 || editDistance(value, 'thumbs') <= 2;
+}
+
+function isNearUpToken(token) {
+  const value = String(token || '');
+  return value === 'up' || editDistance(value, 'up') <= 1;
+}
+
+function isNearDownToken(token) {
+  const value = String(token || '');
+  if (value.length < 2) return false;
+  return editDistance(value, 'down') <= 1;
+}
+
+function detectFeedbackSignal(value) {
+  const raw = String(value || '');
+  if (/[👎👎🏻👎🏼👎🏽👎🏾👎🏿]/u.test(raw)) return { signal: 'down', confidence: 'emoji', match: '👎' };
+  if (/[👍👍🏻👍🏼👍🏽👍🏾👍🏿]/u.test(raw)) return { signal: 'up', confidence: 'emoji', match: '👍' };
+
+  const normalized = normalizeFeedbackText(raw);
+  if (!normalized) return null;
+
+  const exactDown = [
+    /\bthumbs?\s*down\b/,
+    /\bthumbs?down\b/,
+    /\bthat failed\b/,
+    /\bit failed\b/,
+    /\bthat was wrong\b/,
+    /\bfix this\b/,
+  ];
+  if (exactDown.some((pattern) => pattern.test(normalized))) {
+    return { signal: 'down', confidence: 'exact', match: normalized };
+  }
+
+  const exactUp = [
+    /\bthumbs?\s*up\b/,
+    /\bthumbs?up\b/,
+    /\bthat worked\b/,
+    /\bit worked\b/,
+    /\blooks good\b/,
+    /\bgood job\b/,
+    /\bgood work\b/,
+    /\bnice work\b/,
+    /\bperfect\b/,
+    /\blgtm\b/,
+  ];
+  if (exactUp.some((pattern) => pattern.test(normalized))) {
+    return { signal: 'up', confidence: 'exact', match: normalized };
+  }
+
+  const words = normalized.split(/\s+/).filter(Boolean);
+  for (let i = 0; i < words.length - 1; i++) {
+    if (!isNearThumbToken(words[i])) continue;
+    if (isNearDownToken(words[i + 1])) {
+      return { signal: 'down', confidence: 'fuzzy', match: `${words[i]} ${words[i + 1]}` };
+    }
+    if (isNearUpToken(words[i + 1])) {
+      return { signal: 'up', confidence: 'fuzzy', match: `${words[i]} ${words[i + 1]}` };
+    }
+  }
+
+  return null;
+}
+
 function isGenericFeedbackText(value, signal) {
   const normalized = normalizeFeedbackText(value);
   if (!normalized) return false;
@@ -131,6 +217,7 @@ function buildClarificationMessage(params = {}) {
 
 module.exports = {
   GENERIC_PHRASE_RULES,
+  detectFeedbackSignal,
   normalizeFeedbackSignal,
   normalizeFeedbackText,
   isGenericFeedbackText,