thumbgate 1.27.18 → 1.27.20

package/scripts/feedback-aggregate.js

@@ -0,0 +1,281 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const {
+  getFallbackFeedbackDir,
+  getGlobalFeedbackDir,
+  getHomeDir,
+  getLegacyFeedbackDir,
+  getThumbgateFeedbackDir,
+  resolveFeedbackDir,
+  resolveProjectDir,
+} = require('./feedback-paths');
+const { readJsonl } = require('./fs-utils');
+
+const FEEDBACK_LOG = 'feedback-log.jsonl';
+const MEMORY_LOG = 'memory-log.jsonl';
+const STATUSLINE_CACHE = 'statusline_cache.json';
+
+function truthyDisabled(value) {
+  return value === '0' || value === 'false' || value === 'local';
+}
+
+function shouldAggregateFeedback(options = {}) {
+  const env = options.env || process.env;
+  return !truthyDisabled(String(env.THUMBGATE_STATUSLINE_AGGREGATE || env.THUMBGATE_AGGREGATE_FEEDBACK || '1').toLowerCase());
+}
+
+function normalizePath(candidate) {
+  if (!candidate) return null;
+  try {
+    return path.resolve(String(candidate));
+  } catch {
+    return null;
+  }
+}
+
+function uniquePaths(values = []) {
+  const seen = new Set();
+  const out = [];
+  for (const value of values) {
+    const resolved = normalizePath(value);
+    if (!resolved || seen.has(resolved)) continue;
+    seen.add(resolved);
+    out.push(resolved);
+  }
+  return out;
+}
+
+function safeExists(candidate) {
+  try {
+    return Boolean(candidate && fs.existsSync(candidate));
+  } catch {
+    return false;
+  }
+}
+
+function immediateChildDirs(parentDir) {
+  try {
+    return fs.readdirSync(parentDir, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => path.join(parentDir, entry.name));
+  } catch {
+    return [];
+  }
+}
+
+function ancestorProjectFeedbackDirs(projectDir, options = {}) {
+  const home = normalizePath(getHomeDir(options));
+  const start = normalizePath(projectDir);
+  if (!start) return [];
+
+  const dirs = [];
+  let cursor = start;
+  while (cursor && cursor !== path.dirname(cursor)) {
+    dirs.push(
+      path.join(cursor, '.thumbgate'),
+      path.join(cursor, '.thumbgate-compat'),
+      path.join(cursor, '.claude', 'memory', 'feedback')
+    );
+    if (home && cursor === home) break;
+    const next = path.dirname(cursor);
+    if (next === cursor) break;
+    cursor = next;
+  }
+  return dirs;
+}
+
+function listFeedbackStoreDirs(options = {}) {
+  const env = options.env || process.env;
+  const projectDir = resolveProjectDir({ cwd: options.cwd, env, projectDir: options.projectDir });
+  const home = getHomeDir({ env });
+  const homeThumbgate = path.join(home, '.thumbgate');
+  const projectsDir = path.join(homeThumbgate, 'projects');
+  const explicitRoots = String(env.THUMBGATE_AGGREGATE_ROOTS || '')
+    .split(path.delimiter)
+    .map((value) => value.trim())
+    .filter(Boolean);
+  const explicitFeedbackDir = options.feedbackDir || env.THUMBGATE_FEEDBACK_DIR;
+  const normalizedExplicitFeedbackDir = normalizePath(explicitFeedbackDir);
+
+  if (
+    normalizedExplicitFeedbackDir &&
+    normalizedExplicitFeedbackDir.startsWith(normalizePath(os.tmpdir()) + path.sep) &&
+    explicitRoots.length === 0
+  ) {
+    return uniquePaths([explicitFeedbackDir])
+      .filter((dir) => safeExists(path.join(dir, FEEDBACK_LOG)) || safeExists(path.join(dir, MEMORY_LOG)) || safeExists(path.join(dir, STATUSLINE_CACHE)));
+  }
+
+  return uniquePaths([
+    explicitFeedbackDir,
+    resolveFeedbackDir({ projectDir, env }),
+    getThumbgateFeedbackDir({ projectDir, env }),
+    getFallbackFeedbackDir({ projectDir, env }),
+    getLegacyFeedbackDir({ projectDir, env }),
+    getGlobalFeedbackDir({ projectDir, env }),
+    homeThumbgate,
+    ...immediateChildDirs(projectsDir),
+    ...ancestorProjectFeedbackDirs(projectDir, { env }),
+    ...explicitRoots,
+  ]).filter((dir) => safeExists(path.join(dir, FEEDBACK_LOG)) || safeExists(path.join(dir, MEMORY_LOG)) || safeExists(path.join(dir, STATUSLINE_CACHE)));
+}
+
+function normalizeSignal(signal) {
+  const raw = String(signal || '').toLowerCase();
+  if (raw === 'positive' || raw === 'up' || raw === 'thumbs_up') return 'positive';
+  if (raw === 'negative' || raw === 'down' || raw === 'thumbs_down') return 'negative';
+  return raw || null;
+}
+
+function stableEntryKey(entry = {}, source = {}) {
+  const id = entry.id || entry.feedbackId || entry.sourceFeedbackId;
+  if (id) return `id:${id}`;
+  const material = JSON.stringify({
+    sourcePath: source.logPath || '',
+    sourceIndex: Number.isFinite(source.index) ? source.index : -1,
+    entry,
+  });
+  return `sha:${crypto.createHash('sha256').update(material).digest('hex')}`;
+}
+
+function sortByTimestamp(entries) {
+  return entries.sort((a, b) => {
+    const at = a.timestamp ? Date.parse(a.timestamp) : 0;
+    const bt = b.timestamp ? Date.parse(b.timestamp) : 0;
+    return (Number.isFinite(at) ? at : 0) - (Number.isFinite(bt) ? bt : 0);
+  });
+}
+
+function collectAggregateLogEntries(fileName, options = {}) {
+  const stores = listFeedbackStoreDirs(options);
+  const seen = new Set();
+  const entries = [];
+
+  for (const dir of stores) {
+    const logPath = path.join(dir, fileName);
+    if (!safeExists(logPath)) continue;
+    const rows = readJsonl(logPath, { maxLines: 0 }) || [];
+    for (let index = 0; index < rows.length; index += 1) {
+      const rawEntry = rows[index];
+      const entry = { ...rawEntry };
+      if (entry.signal || entry.feedback) entry.signal = normalizeSignal(entry.signal || entry.feedback);
+      const key = stableEntryKey(entry, { logPath, index });
+      if (seen.has(key)) continue;
+      seen.add(key);
+      entries.push({ ...entry, sourceFeedbackDir: dir });
+    }
+  }
+
+  return {
+    entries: sortByTimestamp(entries),
+    stores,
+  };
+}
+
+function summarizeFeedbackEntries(entries) {
+  let totalPositive = 0;
+  let totalNegative = 0;
+  let rubricSamples = 0;
+
+  for (const entry of entries) {
+    if (entry.signal === 'positive') totalPositive += 1;
+    if (entry.signal === 'negative') totalNegative += 1;
+    if (entry.rubric && entry.rubric.weightedScore != null) rubricSamples += 1;
+  }
+
+  return { totalPositive, totalNegative, rubricSamples };
+}
+
+function createRateWindows(total, totalPositive, approvalRate) {
+  return {
+    '7d': { total: 0, positive: 0, rate: 0 },
+    '30d': { total: 0, positive: 0, rate: 0 },
+    lifetime: { total, positive: totalPositive, rate: approvalRate },
+  };
+}
+
+function applyEntryToRateWindow(window, entry) {
+  window.total += 1;
+  if (entry.signal === 'positive') window.positive += 1;
+}
+
+function updateRateWindows(windows, entries, now = Date.now()) {
+  const sevenDays = 7 * 24 * 60 * 60 * 1000;
+  const thirtyDays = 30 * 24 * 60 * 60 * 1000;
+
+  for (const entry of entries) {
+    const ts = entry.timestamp ? Date.parse(entry.timestamp) : Number.NaN;
+    if (!Number.isFinite(ts)) continue;
+    const age = now - ts;
+    if (age <= sevenDays) applyEntryToRateWindow(windows['7d'], entry);
+    if (age <= thirtyDays) applyEntryToRateWindow(windows['30d'], entry);
+  }
+}
+
+function finalizeRateWindows(windows) {
+  for (const key of ['7d', '30d']) {
+    const window = windows[key];
+    window.rate = 0;
+    if (window.total > 0) {
+      window.rate = Math.round((window.positive / window.total) * 1000) / 1000;
+    }
+  }
+}
+
+function trendFromRateWindows(windows) {
+  const hasTrendData = windows['7d'].total > 0 && windows['30d'].total > 0;
+  if (hasTrendData) {
+    if (windows['7d'].rate > windows['30d'].rate + 0.05) return 'improving';
+    if (windows['7d'].rate < windows['30d'].rate - 0.05) return 'degrading';
+  }
+  return 'stable';
+}
+
+function computeAggregateFeedbackStats(options = {}) {
+  const { entries, stores } = collectAggregateLogEntries(FEEDBACK_LOG, options);
+  const memory = collectAggregateLogEntries(MEMORY_LOG, options);
+  const { totalPositive, totalNegative, rubricSamples } = summarizeFeedbackEntries(entries);
+  const total = totalPositive + totalNegative;
+  const approvalRate = total > 0 ? Math.round((totalPositive / total) * 1000) / 1000 : 0;
+  const windows = createRateWindows(total, totalPositive, approvalRate);
+  updateRateWindows(windows, entries);
+  finalizeRateWindows(windows);
+  const trend = trendFromRateWindows(windows);
+
+  return {
+    total,
+    totalPositive,
+    totalNegative,
+    approvalRate,
+    recentRate: windows['7d'].rate || approvalRate,
+    trend,
+    windows,
+    rubric: { samples: rubricSamples || memory.entries.length, blockedPromotions: 0, failingCriteria: {} },
+    aggregate: {
+      enabled: true,
+      stores: stores.length,
+      feedbackLogPaths: stores.map((dir) => path.join(dir, FEEDBACK_LOG)),
+      memoryStores: memory.stores.length,
+    },
+  };
+}
+
+function getAggregateStatuslineCachePath(options = {}) {
+  const env = options.env || process.env;
+  if (env.THUMBGATE_STATUSLINE_CACHE) return path.resolve(env.THUMBGATE_STATUSLINE_CACHE);
+  return path.join(getHomeDir({ env }), '.thumbgate', STATUSLINE_CACHE);
+}
+
+module.exports = {
+  collectAggregateLogEntries,
+  computeAggregateFeedbackStats,
+  getAggregateStatuslineCachePath,
+  listFeedbackStoreDirs,
+  normalizeSignal,
+  shouldAggregateFeedback,
+};

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,

package/scripts/feedback-sanitizer.js

@@ -0,0 +1,105 @@
+'use strict';
+
+const crypto = require('crypto');
+
+const TRANSPORT_KEYS = new Set([
+  'hookeventname',
+  'hook_event_name',
+  'sessionid',
+  'session_id',
+  'transcriptpath',
+  'transcript_path',
+  'timestamp',
+  'createdat',
+  'created_at',
+  'updatedat',
+  'updated_at',
+  'cwd',
+  'pid',
+  'processid',
+  'process_id',
+  'promptid',
+  'prompt_id',
+  'traceid',
+  'trace_id',
+  'requestid',
+  'request_id',
+  'installid',
+  'install_id',
+  'visitorsessionid',
+  'visitor_session_id',
+  'toolinput',
+  'tool_input',
+]);
+
+const TRANSPORT_WORDS = new Set([
+  ...TRANSPORT_KEYS,
+  'hook',
+  'event',
+  'userpromptsubmit',
+  'user_prompt_submit',
+  'pretooluse',
+  'pre_tool_use',
+  'posttooluse',
+  'post_tool_use',
+  'claude',
+  'codex',
+  'projects',
+  'redacted',
+  'tmp',
+  'private',
+  'folders',
+  'json',
+]);
+
+function stripEphemeralText(text) {
+  if (!text || typeof text !== 'string') return '';
+  return String(text)
+    .replace(/["']?(?:hook_?event_?name|session_?id|transcript_?path|timestamp|created_?at|updated_?at|cwd|pid|process_?id|prompt_?id|trace_?id|request_?id|install_?id|visitor_?session_?id)["']?\s*[:=]\s*["']?[^"',}\]\s]+["']?/gi, ' ')
+    .replace(/\/(?:private\/)?tmp\/[^\s"',}\]]+/gi, ' ')
+    .replace(/\/var\/folders\/[^\s"',}\]]+/gi, ' ')
+    .replace(/\/Users\/[^/\s]+\/\.(?:claude|codex|thumbgate)\/[^\s"',}\]]+/gi, ' ')
+    .replace(/\/Users\/[^/\s]+\/\.config\/thumbgate\/[^\s"',}\]]+/gi, ' ')
+    .replace(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, ' ')
+    .replace(/\b[0-9a-f]{24,}\b/gi, ' ')
+    .replace(/\b\d{4}-\d{2}-\d{2}t\d{2}:\d{2}:\d{2}(?:\.\d+)?z?\b/gi, ' ')
+    .replace(/\b\d{10,13}\b/g, ' ')
+    .replace(/:\d{4,5}\b/g, ':PORT');
+}
+
+function transportWordsOnly(text) {
+  const tokens = String(text || '')
+    .toLowerCase()
+    .replace(/[^a-z0-9_ -]/g, ' ')
+    .split(/\s+/)
+    .filter((token) => token.length >= 3);
+  if (tokens.length === 0) return true;
+  return tokens.every((token) => TRANSPORT_WORDS.has(token));
+}
+
+function sanitizeFeedbackText(text) {
+  const stripped = stripEphemeralText(text)
+    .replace(/\/Users\/[^\s/]+/g, '/Users/redacted')
+    .replace(/\s+/g, ' ')
+    .trim();
+  if (transportWordsOnly(stripped)) return '';
+  return stripped;
+}
+
+function actionFingerprint(parts) {
+  const raw = Array.isArray(parts) ? parts.join(' ') : String(parts || '');
+  const stable = sanitizeFeedbackText(raw)
+    .toLowerCase()
+    .replace(/[^a-z0-9._:/ -]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+  if (!stable || transportWordsOnly(stable)) return null;
+  return crypto.createHash('sha256').update(stable).digest('hex').slice(0, 16);
+}
+
+module.exports = {
+  TRANSPORT_WORDS,
+  sanitizeFeedbackText,
+  actionFingerprint,
+  transportWordsOnly,
+};