thumbgate 1.28.0 → 1.28.1

package/scripts/checkout-attribution-reference.js

@@ -0,0 +1,85 @@
+'use strict';
+
+// Attribution survival for EXTERNAL Stripe Payment Links.
+//
+// The $499 diagnostic and the sprint check out via raw `buy.stripe.com` Payment
+// Links. Payment Links DROP appended utm_* query params and carry NO session
+// metadata — but they DO preserve `client_reference_id` into
+// `checkout.session.completed`. Without packing attribution into that field, a
+// marketplace-attributed paid checkout (e.g. utm_source=aiventyx) is recorded as
+// source=unknown, so it can neither be credited to the marketplace partner nor
+// reported. This module packs/parses a compact, URL- and Stripe-safe reference.
+//
+// Current format: `tg2<source><traceId><acquisitionId><planId>`, with every
+// field encoded as a two-digit length followed by the cleaned value. The
+// parser remains backward-compatible with the original three-field `tg1`
+// format. Stripe accepts only [A-Za-z0-9_-], so punctuation delimiters are
+// invalid. Length-prefixing preserves valid hyphens and underscores without
+// introducing an unsupported delimiter and keeps the value under Stripe's
+// 200-character limit.
+
+const CURRENT_PREFIX = 'tg2';
+const LEGACY_PREFIX = 'tg1';
+const MAX_FIELD = 45;
+
+function cleanField(value, maxLength = MAX_FIELD) {
+  return String(value == null ? '' : value)
+    .replace(/[^A-Za-z0-9_-]/g, '')
+    .slice(0, maxLength);
+}
+
+function encodeField(value) {
+  const field = cleanField(value);
+  return `${String(field.length).padStart(2, '0')}${field}`;
+}
+
+// Build a Stripe `client_reference_id` from checkout metadata. Returns null when
+// there is no attributable source (so callers append nothing).
+function packCheckoutReference(metadata = {}) {
+  const source = cleanField(metadata.utmSource || metadata.source);
+  if (!source) return null;
+  const traceId = cleanField(metadata.traceId);
+  const acquisitionId = cleanField(metadata.acquisitionId);
+  const planId = cleanField(metadata.planId || metadata.plan_id);
+  return `${CURRENT_PREFIX}${encodeField(source)}${encodeField(traceId)}${encodeField(acquisitionId)}${encodeField(planId)}`;
+}
+
+// Parse a `client_reference_id` produced by packCheckoutReference. Returns null
+// for anything that is not a recognized tg1 reference with a real source.
+function parseCheckoutReference(clientReferenceId) {
+  const raw = String(clientReferenceId == null ? '' : clientReferenceId);
+  const prefix = raw.startsWith(CURRENT_PREFIX)
+    ? CURRENT_PREFIX
+    : raw.startsWith(LEGACY_PREFIX)
+      ? LEGACY_PREFIX
+      : null;
+  if (!prefix) return null;
+  const fieldCount = prefix === CURRENT_PREFIX ? 4 : 3;
+  const maxFieldLength = prefix === CURRENT_PREFIX ? MAX_FIELD : 60;
+
+  const fields = [];
+  let cursor = prefix.length;
+  for (let index = 0; index < fieldCount; index += 1) {
+    const lengthToken = raw.slice(cursor, cursor + 2);
+    if (!/^\d{2}$/.test(lengthToken)) return null;
+    const fieldLength = Number(lengthToken);
+    if (fieldLength > maxFieldLength) return null;
+    cursor += 2;
+    const field = raw.slice(cursor, cursor + fieldLength);
+    if (field.length !== fieldLength || cleanField(field, maxFieldLength) !== field) return null;
+    fields.push(field);
+    cursor += fieldLength;
+  }
+  if (cursor !== raw.length) return null;
+
+  const [source, traceId, acquisitionId, planId] = fields;
+  if (!source) return null;
+  return {
+    source,
+    traceId: traceId || null,
+    acquisitionId: acquisitionId || null,
+    planId: planId || null,
+  };
+}
+
+module.exports = { packCheckoutReference, parseCheckoutReference };

package/scripts/claude-feedback-sync.js

@@ -5,11 +5,12 @@ const fs = require('fs');
 const path = require('path');
 const {
   captureFeedback,
+  buildFeedbackSourceIdentity,
   getFeedbackPaths,
   readJSONL,
   analyzeFeedback,
 } = require('./feedback-loop');
-const { normalizeFeedbackText } = require('./feedback-quality');
+const { detectFeedbackSignal, normalizeFeedbackText } = require('./feedback-quality');
 const {
   resolveFeedbackDir,
   resolveProjectDir,
@@ -126,10 +127,8 @@ function parseHistoryTimestamp(value) {
 }
 
 function detectSignal(text) {
-  const normalized = String(text || '').toLowerCase();
-  if (/(thumbs?\s*down|that failed|that was wrong|fix this)/i.test(normalized)) return 'down';
-  if (/(thumbs?\s*up|that worked|looks good|nice work|perfect|good job)/i.test(normalized)) return 'up';
-  return null;
+  const detected = detectFeedbackSignal(text);
+  return detected ? detected.signal : null;
 }
 
 function extractPromptText(entry) {
@@ -179,6 +178,9 @@ function toHistoryCandidate(entry, options = {}) {
     promptText,
     signal,
     timestampMs: parseHistoryTimestamp(entry.timestamp),
+    sessionId: entry.sessionId || entry.session_id || null,
+    promptId: entry.promptId || entry.prompt_id || null,
+    projectDir: entry.project || entry.cwd || null,
   };
 }
 
@@ -261,15 +263,30 @@ function syncClaudeHistoryFeedback(options = {}) {
         continue;
       }
 
+      const sourceEvent = buildFeedbackSourceIdentity({
+        signal: candidate.signal,
+        promptText: candidate.promptText,
+        sessionId: candidate.sessionId,
+        promptId: candidate.promptId,
+        projectDir: candidate.projectDir,
+        timestamp: candidate.timestampMs,
+        source: 'claude-history',
+      });
       const captureResult = captureFeedback({
         signal: candidate.signal,
         context: candidate.promptText,
         whatWentWrong: candidate.signal === 'down' ? candidate.promptText : undefined,
         whatWorked: candidate.signal === 'up' ? candidate.promptText : undefined,
         tags: ['claude-history-sync', 'auto-capture-fallback'],
+        sourceEvent,
       });
 
-      if (captureResult && captureResult.feedbackEvent) {
+      if (captureResult?.duplicate) {
+        processedIds.add(candidate.externalId);
+        skippedCount += 1;
+        continue;
+      }
+      if (captureResult?.feedbackEvent) {
         existingEntries.push(captureResult.feedbackEvent);
       }
       processedIds.add(candidate.externalId);

package/scripts/cli-feedback.js

@@ -44,9 +44,10 @@ const RST = '\x1b[0m';
  * @param {Array} [opts.chatHistory] - Conversation messages for distillation
  * @param {string} [opts.whatWentWrong] - For thumbs down
  * @param {string} [opts.whatWorked] - For thumbs up
+ * @param {Object} [opts.sourceEvent] - Hashed source identity for idempotent hook capture
  * @returns {Object} Result with feedback + lesson + stats
  */
-function processInlineFeedback({ signal, context, chatHistory, whatWentWrong, whatWorked } = {}) {
+function processInlineFeedback({ signal, context, chatHistory, whatWentWrong, whatWorked, sourceEvent } = {}) {
   const isDown = signal === 'down' || signal === 'negative';
 
   // 1. Capture the feedback
@@ -57,6 +58,7 @@ function processInlineFeedback({ signal, context, chatHistory, whatWentWrong, wh
       context: context || (isDown ? 'Thumbs down from CLI' : 'Thumbs up from CLI'),
       whatWentWrong: whatWentWrong || undefined,
       whatWorked: whatWorked || undefined,
+      sourceEvent,
     });
   } catch (err) {
     feedbackResult = { accepted: false, reason: err.message };
@@ -90,30 +92,37 @@ function processInlineFeedback({ signal, context, chatHistory, whatWentWrong, wh
  */
 function formatCliOutput(result) {
   const lines = [];
-  const feedbackSignal = result.feedbackResult?.signal || result.feedbackResult?.feedbackEvent?.signal;
+  const feedbackResult = result.feedbackResult;
+  const feedbackSignal = feedbackResult?.signal || feedbackResult?.feedbackEvent?.signal;
   const isDown = ['down', 'negative', 'thumbs_down'].includes(feedbackSignal);
 
   // Header
-  if (result.feedbackResult && result.feedbackResult.accepted !== false) {
+  if (feedbackResult?.duplicate) {
+    lines.push(`${Y}${BD}Feedback already captured${RST}`);
+    const feedbackId = feedbackResult.feedbackEvent?.id;
+    const memoryId = feedbackResult.memoryRecord?.id;
+    if (feedbackId) lines.push(`${D}  Feedback ID: ${feedbackId}${RST}`);
+    if (memoryId) lines.push(`${D}  Memory ID  : ${memoryId}${RST}`);
+  } else if (feedbackResult && feedbackResult.accepted !== false) {
     lines.push(`${isDown ? R : G}${BD}${isDown ? '👎 Thumbs down recorded' : '👍 Thumbs up recorded'}${RST}`);
-    const feedbackId = (result.feedbackResult.feedbackEvent && result.feedbackResult.feedbackEvent.id) || result.feedbackResult.id;
-    const memoryId = (result.feedbackResult.memoryRecord && result.feedbackResult.memoryRecord.id) || result.feedbackResult.memoryId;
+    const feedbackId = feedbackResult.feedbackEvent?.id || feedbackResult.id;
+    const memoryId = feedbackResult.memoryRecord?.id || feedbackResult.memoryId;
     if (feedbackId) {
       lines.push(`${D}  Feedback ID: ${feedbackId}${RST}`);
       if (memoryId) lines.push(`${D}  Memory ID  : ${memoryId}${RST}`);
       // Echo feedback ID to stderr so it's visible directly in the terminal,
       // not hidden behind Claude Code's "ctrl+o to expand" MCP call collapse.
-      process.stderr.write(`✅ Feedback captured (${feedbackId}${memoryId ? `, ${memoryId}` : ''})\n`);
+      const capturedIds = memoryId ? `${feedbackId}, ${memoryId}` : feedbackId;
+      process.stderr.write(`✅ Feedback captured (${capturedIds})\n`);
     }
   } else {
-    lines.push(`${R}Feedback not accepted: ${(result.feedbackResult && result.feedbackResult.reason) || 'unknown'}${RST}`);
+    lines.push(`${R}Feedback not accepted: ${feedbackResult?.reason || 'unknown'}${RST}`);
   }
 
   // Explicit-directive offer (e.g. "never …" → offer immediate force-gate).
-  if (result.forceGateHint && result.forceGateHint.message) {
+  if (result.forceGateHint?.message) {
     const color = result.forceGateHint.kind === 'force-gate-offer' ? Y : D;
-    lines.push('');
-    lines.push(`${color}💡 ${result.forceGateHint.message}${RST}`);
+    lines.push('', `${color}💡 ${result.forceGateHint.message}${RST}`);
   }
 
   // Distilled lesson (if thumbs down)

package/scripts/feedback-loop.js

@@ -7,6 +7,7 @@
  *   -> compute analytics -> generate prevention rules
  */
 
+const crypto = require('node:crypto');
 const fs = require('fs');
 const path = require('path');
 const { loadOptionalModule } = require('./private-core-boundary');
@@ -19,6 +20,7 @@ const {
 const {
   buildClarificationMessage,
   isGenericFeedbackText,
+  normalizeFeedbackText,
 } = require('./feedback-quality');
 const {
   buildRubricEvaluation,
@@ -55,6 +57,10 @@ const {
 }));
 
 const AUDIT_TRAIL_TAG = 'audit-trail';
+const FEEDBACK_EVENT_DEDUPE_WINDOW_MS = 30 * 1000;
+const FEEDBACK_EVENT_CLAIM_STALE_MS = 60 * 1000;
+const FEEDBACK_EVENT_CLAIM_WAIT_MS = 15 * 1000;
+const FEEDBACK_EVENT_CLAIM_POLL_MS = 25;
 
 /**
  * Anonymous fire-and-forget CLI feedback telemetry.
@@ -631,6 +637,269 @@ function normalizeSignal(signal) {
   return null;
 }
 
+function hashFeedbackSourcePart(value) {
+  const text = String(value || '').trim();
+  if (!text) return null;
+  return crypto.createHash('sha256').update(text).digest('hex');
+}
+
+function parseFeedbackSourceTimestamp(value) {
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    return value > 1e12 ? value : value * 1000;
+  }
+  const text = String(value || '').trim();
+  if (!text) return Date.now();
+  if (/^\d+$/.test(text)) {
+    const numeric = Number(text);
+    return numeric > 1e12 ? numeric : numeric * 1000;
+  }
+  const parsed = Date.parse(text);
+  return Number.isFinite(parsed) ? parsed : Date.now();
+}
+
+/**
+ * Build a privacy-preserving identity for one external thumbs event.
+ * Raw session, prompt, and project identifiers are hashed before persistence.
+ * A prompt ID wins when present so two distinct prompts with identical text are
+ * still separate events; otherwise the session + project + text fingerprint is
+ * deduplicated inside a short capture window.
+ */
+function buildFeedbackSourceIdentity(input = {}) {
+  const signal = normalizeSignal(input.signal);
+  const normalizedText = normalizeFeedbackText(input.promptText || input.context);
+  if (!signal || !normalizedText) return null;
+
+  const sessionHash = hashFeedbackSourcePart(input.sessionId);
+  const promptIdHash = hashFeedbackSourcePart(input.promptId);
+  const projectHash = hashFeedbackSourcePart(input.projectDir || input.project);
+  if (!sessionHash && !promptIdHash) return null;
+
+  const textHash = hashFeedbackSourcePart(normalizedText);
+  const discriminator = promptIdHash
+    ? `prompt:${sessionHash || ''}:${projectHash || ''}:${promptIdHash}`
+    : `content:${sessionHash || ''}:${projectHash || ''}:${textHash}`;
+  const eventHash = hashFeedbackSourcePart(['v1', signal, discriminator].join(':'));
+  const key = `fev_${eventHash}`;
+
+  return {
+    key,
+    signal,
+    normalizedText,
+    sessionHash,
+    promptIdHash,
+    projectHash,
+    eventTimestampMs: parseFeedbackSourceTimestamp(input.timestamp),
+    source: String(input.source || 'external').replace(/[^a-z0-9._-]/gi, '-').slice(0, 64),
+  };
+}
+
+function normalizeFeedbackSourceIdentity(identity, params = {}) {
+  if (!identity || typeof identity !== 'object' || typeof identity.key !== 'string') return null;
+  const signal = normalizeSignal(params.signal || identity.signal);
+  const normalizedText = normalizeFeedbackText(
+    identity.normalizedText || params.context || params.whatWentWrong || params.whatWorked,
+  );
+  if (!signal || !normalizedText) return null;
+
+  return {
+    key: `fev_${hashFeedbackSourcePart(identity.key)}`,
+    signal,
+    normalizedText,
+    sessionHash: hashFeedbackSourcePart(identity.sessionHash),
+    promptIdHash: hashFeedbackSourcePart(identity.promptIdHash),
+    projectHash: hashFeedbackSourcePart(identity.projectHash),
+    eventTimestampMs: parseFeedbackSourceTimestamp(identity.eventTimestampMs),
+    source: String(identity.source || 'external').replace(/[^a-z0-9._-]/gi, '-').slice(0, 64),
+  };
+}
+
+function publicFeedbackSourceMetadata(identity) {
+  if (!identity) return null;
+  return {
+    key: identity.key,
+    sessionHash: identity.sessionHash,
+    promptIdHash: identity.promptIdHash,
+    projectHash: identity.projectHash,
+    source: identity.source,
+    timestamp: new Date(identity.eventTimestampMs).toISOString(),
+  };
+}
+
+function readClaimState(claimPath) {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(claimPath, 'state.json'), 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function writeClaimState(claimPath, state) {
+  const target = path.join(claimPath, 'state.json');
+  const temporary = path.join(claimPath, `state.${process.pid}.${Date.now()}.tmp`);
+  fs.writeFileSync(temporary, `${JSON.stringify(state)}\n`, { mode: 0o600 });
+  fs.renameSync(temporary, target);
+}
+
+function sleepSync(milliseconds) {
+  const signal = new Int32Array(new SharedArrayBuffer(4));
+  Atomics.wait(signal, 0, 0, milliseconds);
+}
+
+function replaceStaleClaim(claimPath) {
+  const nonce = crypto.randomBytes(4).toString('hex');
+  const stalePath = `${claimPath}.stale-${process.pid}-${Date.now()}-${nonce}`;
+  try {
+    fs.renameSync(claimPath, stalePath);
+    fs.rmSync(stalePath, { recursive: true, force: true });
+    return true;
+  } catch (error) {
+    if (error && (error.code === 'ENOENT' || error.code === 'EEXIST')) return false;
+    throw error;
+  }
+}
+
+function waitForClaimCompletion(claimPath, deadlineMs) {
+  let state = readClaimState(claimPath);
+  while ((!state || state.status === 'pending') && Date.now() < deadlineMs) {
+    sleepSync(FEEDBACK_EVENT_CLAIM_POLL_MS);
+    state = readClaimState(claimPath);
+  }
+  return state;
+}
+
+function findRecordById(filePath, id) {
+  if (!id) return null;
+  const entries = readJSONL(filePath, { maxLines: 500 });
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    if (entries[index]?.id === id) return entries[index];
+  }
+  return null;
+}
+
+function duplicateCaptureResult(receipt, paths, options = {}) {
+  const feedbackEvent = findRecordById(paths.FEEDBACK_LOG_PATH, receipt?.feedbackId);
+  const memoryRecord = findRecordById(paths.MEMORY_LOG_PATH, receipt?.memoryId);
+  return {
+    accepted: Boolean(receipt?.accepted),
+    signalLogged: Boolean(receipt?.signalLogged),
+    duplicate: true,
+    pending: Boolean(options.pending),
+    status: options.pending ? 'duplicate_in_progress' : 'duplicate',
+    reason: options.pending ? 'source_event_capture_in_progress' : 'source_event_already_captured',
+    message: options.pending
+      ? 'Equivalent feedback is already being captured.'
+      : 'This feedback event was already captured; no counters or lessons were changed.',
+    feedbackEvent: feedbackEvent || (receipt?.feedbackId ? { id: receipt.feedbackId } : null),
+    memoryRecord: memoryRecord || (receipt?.memoryId ? { id: receipt.memoryId } : null),
+  };
+}
+
+function sourceHashMatches(expected, actual) {
+  return !expected || !actual || expected === actual;
+}
+
+function isDuplicateFeedbackEntry(entry, identity) {
+  if (!entry || entry.signal !== identity.signal) return false;
+  if (normalizeFeedbackText(entry.submittedContext || entry.context) !== identity.normalizedText) return false;
+
+  const sourceEvent = entry.sourceEvent || {};
+  if (!sourceHashMatches(identity.sessionHash, sourceEvent.sessionHash)) return false;
+  if (!sourceHashMatches(identity.projectHash, sourceEvent.projectHash)) return false;
+  if (!sourceHashMatches(identity.promptIdHash, sourceEvent.promptIdHash)) return false;
+  if (identity.promptIdHash && sourceEvent.promptIdHash === identity.promptIdHash) return true;
+
+  const timestamp = parseFeedbackSourceTimestamp(sourceEvent.timestamp || entry.timestamp);
+  return Math.abs(identity.eventTimestampMs - timestamp) <= FEEDBACK_EVENT_DEDUPE_WINDOW_MS;
+}
+
+function receiptFromFeedbackEntry(entry, paths) {
+  if (!entry) return null;
+  const memories = readJSONL(paths.MEMORY_LOG_PATH, { maxLines: 500 });
+  const memory = memories.find((candidate) => candidate?.sourceFeedbackId === entry.id);
+  return {
+    status: 'complete',
+    feedbackId: entry.id,
+    memoryId: memory?.id,
+    accepted: entry.actionType !== 'no-action'
+      && (!Array.isArray(entry.validationIssues) || entry.validationIssues.length === 0),
+    signalLogged: true,
+    completedAtMs: Date.parse(entry.timestamp || '') || Date.now(),
+  };
+}
+
+function recentDuplicateReceipt(identity, paths) {
+  const entries = readJSONL(paths.FEEDBACK_LOG_PATH, { maxLines: 250 });
+  const entry = entries.findLast((candidate) => isDuplicateFeedbackEntry(candidate, identity));
+  return receiptFromFeedbackEntry(entry, paths);
+}
+
+function tryCreateFeedbackClaim(claimPath) {
+  try {
+    fs.mkdirSync(claimPath, { mode: 0o700 });
+    writeClaimState(claimPath, { status: 'pending', startedAtMs: Date.now() });
+    return { owned: true, claimPath };
+  } catch (error) {
+    if (error?.code === 'EEXIST') return null;
+    throw error;
+  }
+}
+
+function existingClaimResult(state, identity, paths) {
+  const stateTimestamp = Number(state?.completedAtMs || state?.startedAtMs || 0);
+  const ageMs = stateTimestamp > 0 ? Date.now() - stateTimestamp : 0;
+  if (state?.status === 'complete'
+    && (identity.promptIdHash || ageMs <= FEEDBACK_EVENT_DEDUPE_WINDOW_MS)) {
+    return duplicateCaptureResult(state, paths);
+  }
+  if (state?.status === 'pending' && ageMs <= FEEDBACK_EVENT_CLAIM_STALE_MS) {
+    return duplicateCaptureResult(state, paths, { pending: true });
+  }
+  return null;
+}
+
+function acquireFeedbackEventClaim(identity, paths) {
+  const recent = recentDuplicateReceipt(identity, paths);
+  if (recent) return { owned: false, result: duplicateCaptureResult(recent, paths) };
+
+  const claimsRoot = path.join(paths.FEEDBACK_DIR, '.feedback-event-claims');
+  const claimPath = path.join(claimsRoot, identity.key);
+  ensureDir(claimsRoot);
+
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    const ownedClaim = tryCreateFeedbackClaim(claimPath);
+    if (ownedClaim) return ownedClaim;
+
+    const state = waitForClaimCompletion(claimPath, Date.now() + FEEDBACK_EVENT_CLAIM_WAIT_MS);
+    const duplicateResult = existingClaimResult(state, identity, paths);
+    if (duplicateResult) return { owned: false, result: duplicateResult };
+    if (!replaceStaleClaim(claimPath)) continue;
+  }
+
+  return {
+    owned: false,
+    result: duplicateCaptureResult(null, paths, { pending: true }),
+  };
+}
+
+function finalizeFeedbackEventClaim(claim, result) {
+  if (!claim?.owned) return;
+  writeClaimState(claim.claimPath, {
+    status: 'complete',
+    startedAtMs: Date.now(),
+    completedAtMs: Date.now(),
+    accepted: Boolean(result?.accepted),
+    signalLogged: Boolean(result?.signalLogged || result?.feedbackEvent),
+    feedbackId: result?.feedbackEvent?.id || null,
+    memoryId: result?.memoryRecord?.id || null,
+  });
+}
+
+function releaseFeedbackEventClaim(claim) {
+  if (claim?.owned && claim.claimPath) {
+    fs.rmSync(claim.claimPath, { recursive: true, force: true });
+  }
+}
+
 function parseOptionalObject(input, name) {
   if (input == null) return {};
   if (typeof input === 'object' && !Array.isArray(input)) return input;
@@ -1144,6 +1413,7 @@ function captureFeedback(params) {
     structuredRule: structuredRule || null,
     ...(reflection && { reflection }),
     gateAction: params.gateAction || null,
+    sourceEvent: publicFeedbackSourceMetadata(params.sourceEvent),
     timestamp: now,
   };
 
@@ -1567,6 +1837,24 @@ function captureFeedback(params) {
   return result;
 }
 
+function captureFeedbackIdempotent(params = {}) {
+  const paths = getFeedbackPaths();
+  const identity = normalizeFeedbackSourceIdentity(params.sourceEvent, params);
+  if (!identity) return captureFeedback(params);
+
+  const claim = acquireFeedbackEventClaim(identity, paths);
+  if (!claim.owned) return claim.result;
+
+  try {
+    const result = captureFeedback({ ...params, sourceEvent: identity });
+    finalizeFeedbackEventClaim(claim, result);
+    return result;
+  } catch (error) {
+    releaseFeedbackEventClaim(claim);
+    throw error;
+  }
+}
+
 function analyzeFeedback(logPath) {
   const { FEEDBACK_LOG_PATH } = getFeedbackPaths();
   const resolvedLogPath = logPath || FEEDBACK_LOG_PATH;
@@ -2200,7 +2488,8 @@ function buildCorrectiveActionsReminder(correctiveActions = []) {
 }
 
 module.exports = {
-  captureFeedback,
+  captureFeedback: captureFeedbackIdempotent,
+  buildFeedbackSourceIdentity,
   compactMemories,
   buildCorrectiveActionsReminder,
   analyzeFeedback,

package/scripts/feedback-quality.js

@@ -100,49 +100,48 @@ function isNearDownToken(token) {
 
 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 leading = raw.trimStart();
+  if (/^["'`]/.test(leading)) return null;
+  if (/^👎(?:🏻|🏼|🏽|🏾|🏿)?/u.test(leading)) return { signal: 'down', confidence: 'emoji', match: '👎' };
+  if (/^👍(?:🏻|🏼|🏽|🏾|🏿)?/u.test(leading)) 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/,
+    /^thumbs?\s*down\b/,
+    /^thumbs?down\b/,
+    /^that failed\b/,
+    /^it failed\b/,
+    /^that was wrong\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/,
+    /^thumbs?\s*up\b/,
+    /^thumbs?up\b/,
+    /^that worked\b/,
+    /^it worked\b/,
+    /^looks good\b/,
+    /^good job\b/,
+    /^good work\b/,
+    /^nice work\b/,
+    /^perfect\b/,
+    /^lgtm\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]}` };
-    }
+  if (!isNearThumbToken(words[0])) return null;
+  if (isNearDownToken(words[1])) {
+    return { signal: 'down', confidence: 'fuzzy', match: `${words[0]} ${words[1]}` };
+  }
+  if (isNearUpToken(words[1])) {
+    return { signal: 'up', confidence: 'fuzzy', match: `${words[0]} ${words[1]}` };
   }
 
   return null;