thumbgate 1.28.0 → 1.28.2

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,8 @@ function processInlineFeedback({ signal, context, chatHistory, whatWentWrong, wh
       context: context || (isDown ? 'Thumbs down from CLI' : 'Thumbs up from CLI'),
       whatWentWrong: whatWentWrong || undefined,
       whatWorked: whatWorked || undefined,
+      chatHistory,
+      sourceEvent,
     });
   } catch (err) {
     feedbackResult = { accepted: false, reason: err.message };
@@ -90,30 +93,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-history-distiller.js

@@ -0,0 +1,385 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { resolveFeedbackDir: resolveSharedFeedbackDir } = require('./feedback-paths');
+const { readJsonlTail } = require('./fs-utils');
+const { redactSecretsDeep } = require('./secret-redaction');
+
+const DEFAULT_HISTORY_LIMIT = 10;
+
+const CORRECTION_PATTERNS = [
+  /\bdon['’]?t\b/i,
+  /\bdo not\b/i,
+  /\bnever\b/i,
+  /\bavoid\b/i,
+  /\bstop\b/i,
+  /\bmust\b/i,
+  /\bshould\b/i,
+  /\bneed to\b/i,
+  /\buse\b/i,
+  /\brun tests?\b/i,
+  /\binclude\b/i,
+  /\bprove\b/i,
+];
+
+const FAILURE_PATTERNS = [
+  /\bfailed\b/i,
+  /\bbroke\b/i,
+  /\berror\b/i,
+  /\bwrong\b/i,
+  /\bignored\b/i,
+  /\bskipped\b/i,
+  /\bhallucinat/i,
+  /\bclaimed done\b/i,
+  /\bwithout proof\b/i,
+  /\bwithout evidence\b/i,
+];
+
+const SUCCESS_PATTERNS = [
+  /\bworked\b/i,
+  /\bpassed\b/i,
+  /\bverified\b/i,
+  /\bproof\b/i,
+  /\bevidence\b/i,
+  /\btests?\b/i,
+  /\bfixed\b/i,
+  /\bsuccess/i,
+];
+
+function normalizeText(value) {
+  return String(value || '')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function truncate(value, max = 180) {
+  const text = normalizeText(value);
+  if (text.length <= max) return text;
+  return `${text.slice(0, max - 1).trim()}…`;
+}
+
+function appendJsonl(filePath, record) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  // Redact secrets before any conversation turn touches disk — conversation-window.jsonl was the
+  // 2026-06-10 sk_live_ leak vector. See scripts/secret-redaction.js.
+  fs.appendFileSync(filePath, `${JSON.stringify(redactSecretsDeep(record))}\n`);
+}
+
+function resolveFeedbackDir(feedbackDir) {
+  if (feedbackDir) {
+    return resolveSharedFeedbackDir({ feedbackDir });
+  }
+  const env = { ...process.env };
+  delete env.INIT_CWD;
+  delete env.PWD;
+  return resolveSharedFeedbackDir({ env });
+}
+
+function getConversationPaths(feedbackDir) {
+  const resolved = resolveFeedbackDir(feedbackDir);
+  return {
+    feedbackDir: resolved,
+    conversationLogPath: path.join(resolved, 'conversation-window.jsonl'),
+    feedbackLogPath: path.join(resolved, 'feedback-log.jsonl'),
+  };
+}
+
+function normalizeChatHistory(entries = []) {
+  if (!Array.isArray(entries)) return [];
+  return entries
+    .map((entry) => {
+      if (typeof entry === 'string') {
+        const text = normalizeText(entry);
+        return text ? { author: null, text, timestamp: null, source: 'chat_history' } : null;
+      }
+      if (!entry || typeof entry !== 'object') return null;
+      const text = normalizeText(entry.text || entry.body || entry.message || entry.content);
+      if (!text) return null;
+      return {
+        author: normalizeText(entry.author || entry.role || entry.user || entry.name) || null,
+        text,
+        timestamp: normalizeText(entry.timestamp || entry.createdAt || entry.updatedAt) || null,
+        source: normalizeText(entry.source) || 'chat_history',
+      };
+    })
+    .filter(Boolean);
+}
+
+function recordConversationEntry(entry, options = {}) {
+  const { conversationLogPath } = getConversationPaths(options.feedbackDir);
+  const normalized = normalizeChatHistory([entry])[0];
+  if (!normalized) {
+    return { recorded: false, reason: 'empty_text', conversationLogPath };
+  }
+  const record = {
+    ...normalized,
+    timestamp: normalized.timestamp || new Date().toISOString(),
+  };
+  appendJsonl(conversationLogPath, record);
+  return { recorded: true, record, conversationLogPath };
+}
+
+function readRecentConversationWindow(options = {}) {
+  const limit = Number(options.limit || DEFAULT_HISTORY_LIMIT);
+  const { conversationLogPath } = getConversationPaths(options.feedbackDir);
+  return readJsonlTail(conversationLogPath, limit)
+    .map((entry) => normalizeChatHistory([entry])[0])
+    .filter(Boolean);
+}
+
+function findFeedbackEventById(feedbackId, options = {}) {
+  if (!feedbackId) return null;
+  const { feedbackLogPath } = getConversationPaths(options.feedbackDir);
+  const matches = readJsonlTail(feedbackLogPath, Number(options.searchLimit || 200));
+  for (let index = matches.length - 1; index >= 0; index -= 1) {
+    if (matches[index] && matches[index].id === feedbackId) {
+      return matches[index];
+    }
+  }
+  return null;
+}
+
+function buildLastActionMessage(lastAction) {
+  if (!lastAction || typeof lastAction !== 'object') return null;
+  const tool = normalizeText(lastAction.tool || lastAction.tool_name || 'unknown tool');
+  const file = normalizeText(lastAction.file || lastAction.path || '');
+  const detail = file ? `${tool} on ${file}` : tool;
+  return {
+    author: 'tool',
+    text: `Last action: ${detail}`,
+    timestamp: normalizeText(lastAction.timestamp) || null,
+    source: 'last_action',
+  };
+}
+
+function buildRelatedFeedbackMessages(feedbackEvent) {
+  if (!feedbackEvent || typeof feedbackEvent !== 'object') return [];
+  const messages = [];
+
+  if (feedbackEvent.conversationWindow && Array.isArray(feedbackEvent.conversationWindow)) {
+    for (const entry of normalizeChatHistory(feedbackEvent.conversationWindow)) {
+      messages.push({ ...entry, source: 'related_feedback_window' });
+    }
+  }
+
+  const snippets = [
+    feedbackEvent.submittedContext || null,
+    feedbackEvent.context || null,
+    feedbackEvent.whatWentWrong || null,
+    feedbackEvent.whatWorked || null,
+    feedbackEvent.whatToChange || null,
+  ].filter(Boolean);
+
+  for (const text of snippets) {
+    messages.push({
+      author: 'related-feedback',
+      text: normalizeText(text),
+      timestamp: normalizeText(feedbackEvent.timestamp) || null,
+      source: 'related_feedback',
+    });
+  }
+
+  const lastActionMessage = buildLastActionMessage(feedbackEvent.lastAction);
+  if (lastActionMessage) messages.push(lastActionMessage);
+
+  return messages;
+}
+
+function matchesAny(text, patterns) {
+  return patterns.some((pattern) => pattern.test(text));
+}
+
+function chooseMessage(messages, predicate) {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    if (predicate(messages[index])) return messages[index];
+  }
+  return null;
+}
+
+function buildRuleSuggestion(correctionMessage, signal) {
+  if (!correctionMessage) return null;
+  const text = truncate(correctionMessage.text, 120);
+  if (signal === 'negative' && /\bnever\b/i.test(text)) return text;
+  if (signal === 'negative' && /\bdo not\b/i.test(text)) {
+    return text.replace(/\bdo not\b/i, 'Never');
+  }
+  if (signal === 'negative' && /\bdon['’]?t\b/i.test(text)) {
+    return text
+      .replace(/\bdon['’]?t\b/i, 'Never')
+      .replace(/\bdo not\b/i, 'Never');
+  }
+  if (signal === 'negative' && /\bavoid\b/i.test(text)) {
+    return text.replace(/\bavoid\b/i, 'Avoid');
+  }
+  if (signal === 'negative') return `Follow the earlier instruction: ${text}`;
+  return `Repeat the successful pattern: ${text}`;
+}
+
+function inferNegativeDistillation(messages, params) {
+  const correctionMessage = chooseMessage(messages, (entry) => {
+    const text = normalizeText(entry.text);
+    return Boolean(text) && matchesAny(text, CORRECTION_PATTERNS);
+  });
+
+  const failureMessage = chooseMessage(messages, (entry) => {
+    const text = normalizeText(entry.text);
+    return Boolean(text) && matchesAny(text, FAILURE_PATTERNS);
+  }) || buildLastActionMessage(params.lastAction);
+
+  if (!correctionMessage && !failureMessage) {
+    return {
+      usedHistory: false,
+      inferredFields: {},
+      lessonProposal: null,
+      evidence: [],
+      source: 'none',
+    };
+  }
+
+  const evidence = [correctionMessage, failureMessage].filter(Boolean).map((entry) => truncate(entry.text));
+  const whatWentWrong = correctionMessage
+    ? `It ignored a prior instruction: ${truncate(correctionMessage.text, 140)}`
+    : `The failure centered on: ${truncate(failureMessage.text, 140)}`;
+  const whatToChange = correctionMessage
+    ? `Follow the earlier instruction instead of repeating the same pattern: ${truncate(correctionMessage.text, 140)}`
+    : failureMessage
+      ? `Inspect and correct the failing step before repeating it: ${truncate(failureMessage.text, 140)}`
+      : null;
+  const context = failureMessage
+    ? `History-aware distillation linked this failure to ${truncate(failureMessage.text, 140)}`
+    : `History-aware distillation linked this failure to ${truncate(correctionMessage.text, 140)}`;
+
+  return {
+    usedHistory: true,
+    source: correctionMessage ? correctionMessage.source : failureMessage.source,
+    inferredFields: {
+      context,
+      whatWentWrong,
+      whatToChange,
+    },
+    lessonProposal: {
+      summary: whatWentWrong,
+      proposedRule: buildRuleSuggestion(correctionMessage, 'negative'),
+      confidence: correctionMessage && failureMessage ? 0.92 : 0.78,
+    },
+    evidence,
+  };
+}
+
+function inferPositiveDistillation(messages) {
+  const successMessage = chooseMessage(messages, (entry) => {
+    const text = normalizeText(entry.text);
+    return Boolean(text) && matchesAny(text, SUCCESS_PATTERNS);
+  });
+
+  if (!successMessage) {
+    return {
+      usedHistory: false,
+      inferredFields: {},
+      lessonProposal: null,
+      evidence: [],
+      source: 'none',
+    };
+  }
+
+  const whatWorked = `The successful pattern was: ${truncate(successMessage.text, 140)}`;
+  return {
+    usedHistory: true,
+    source: successMessage.source,
+    inferredFields: {
+      context: `History-aware distillation found a successful pattern in recent conversation: ${truncate(successMessage.text, 140)}`,
+      whatWorked,
+    },
+    lessonProposal: {
+      summary: whatWorked,
+      proposedRule: buildRuleSuggestion(successMessage, 'positive'),
+      confidence: 0.81,
+    },
+    evidence: [truncate(successMessage.text)],
+  };
+}
+
+function distillFeedbackHistory(params = {}) {
+  const signal = String(params.signal || '').toLowerCase().trim();
+  const historyLimit = Number(params.historyLimit || DEFAULT_HISTORY_LIMIT);
+  const explicitHistory = normalizeChatHistory(params.chatHistory || params.messages || []);
+  const fallbackHistory = params.allowLocalConversationFallback
+    ? readRecentConversationWindow({ feedbackDir: params.feedbackDir, limit: historyLimit })
+    : [];
+  const relatedEvent = findFeedbackEventById(params.relatedFeedbackId, {
+    feedbackDir: params.feedbackDir,
+    searchLimit: params.searchLimit,
+  });
+
+  const conversationWindow = [
+    ...explicitHistory,
+    ...(explicitHistory.length === 0 ? fallbackHistory : []),
+    ...buildRelatedFeedbackMessages(relatedEvent),
+  ]
+    .filter((entry) => entry && normalizeText(entry.text))
+    .slice(-historyLimit);
+
+  const distillation = signal === 'negative'
+    ? inferNegativeDistillation(conversationWindow, params)
+    : inferPositiveDistillation(conversationWindow, params);
+
+  return {
+    usedHistory: distillation.usedHistory,
+    source: explicitHistory.length > 0
+      ? 'chat_history'
+      : fallbackHistory.length > 0
+        ? 'local_conversation_window'
+        : relatedEvent ? 'related_feedback' : 'none',
+    conversationWindow,
+    relatedFeedbackId: relatedEvent ? relatedEvent.id : null,
+    inferredFields: distillation.inferredFields,
+    lessonProposal: distillation.lessonProposal,
+    evidence: distillation.evidence,
+  };
+}
+
+function main(argv = process.argv.slice(2)) {
+  const [command, ...rest] = argv;
+  if (command !== 'record') {
+    console.error('Usage: node scripts/feedback-history-distiller.js record --author=user --text="..."');
+    process.exit(1);
+  }
+
+  const args = {};
+  for (const token of rest) {
+    if (!token.startsWith('--')) continue;
+    const [key, ...valueParts] = token.slice(2).split('=');
+    args[key] = valueParts.join('=');
+  }
+
+  const result = recordConversationEntry({
+    author: args.author || null,
+    text: args.text || '',
+    timestamp: args.timestamp || new Date().toISOString(),
+    source: args.source || 'cli_record',
+  }, {
+    feedbackDir: args.feedbackDir,
+  });
+
+  if (!result.recorded) {
+    console.error(result.reason || 'failed_to_record');
+    process.exit(1);
+  }
+
+  process.stdout.write(JSON.stringify(result, null, 2));
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  DEFAULT_HISTORY_LIMIT,
+  distillFeedbackHistory,
+  findFeedbackEventById,
+  getConversationPaths,
+  normalizeChatHistory,
+  readRecentConversationWindow,
+  recordConversationEntry,
+};