thumbgate 1.28.1 → 1.28.2

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "thumbgate",
   "description": "One 👎 becomes a hard rule the agent cannot bypass. Captures thumbs-down feedback, distills it into PreToolUse Pre-Action Checks, enforced across every future Claude Code session.",
-  "version": "1.28.1",
+  "version": "1.28.2",
   "author": {
     "name": "Igor Ganapolsky",
     "email": "ig5973700@gmail.com",

package/.well-known/mcp/server-card.json

@@ -1,6 +1,6 @@
 {
   "name": "thumbgate",
-  "version": "1.28.1",
+  "version": "1.28.2",
   "description": "ThumbGate — 👍👎 feedback that teaches your AI agent. Thumbs down a mistake, it never happens again.",
   "homepage": "https://thumbgate.ai",
   "transport": "stdio",

package/adapters/claude/.mcp.json

@@ -2,13 +2,13 @@
   "mcpServers": {
     "thumbgate": {
       "command": "npx",
-      "args": ["--yes", "--package", "thumbgate@1.28.1", "thumbgate", "serve"]
+      "args": ["--yes", "--package", "thumbgate@1.28.2", "thumbgate", "serve"]
     }
   },
   "hooks": {
     "preToolUse": {
       "command": "npx",
-      "args": ["--yes", "--package", "thumbgate@1.28.1", "thumbgate", "gate-check"]
+      "args": ["--yes", "--package", "thumbgate@1.28.2", "thumbgate", "gate-check"]
     }
   }
 }

package/adapters/mcp/server-stdio.js

@@ -187,6 +187,24 @@ const PRIVATE_MCP_MODULES = Object.freeze({
   lessonSearch: path.resolve(__dirname, '../../scripts/lesson-search.js'),
 });
 
+const PRIVATE_MCP_TOOL_REQUIREMENTS = Object.freeze({
+  search_lessons: ['lessonSearch'],
+  reflect_on_feedback: ['reflectorAgent'],
+  list_intents: ['intentRouter'],
+  plan_intent: ['intentRouter'],
+  start_handoff: ['intentRouter', 'delegationRuntime'],
+  complete_handoff: ['delegationRuntime'],
+  distribute_context_to_agents: ['swarmCoordinator'],
+  session_report: ['sessionReport'],
+  generate_operator_artifact: ['operatorArtifacts'],
+  org_dashboard: ['orgDashboard'],
+  get_business_metrics: ['semanticLayer'],
+  describe_semantic_entity: ['semanticLayer'],
+  run_managed_lesson_agent: ['managedLessonAgent'],
+  managed_agent_status: ['managedLessonAgent'],
+  context_stuff_lessons: ['lessonInference'],
+});
+
 function loadPrivateMcpModule(key) {
   const modulePath = PRIVATE_MCP_MODULES[key];
   if (!modulePath) {
@@ -204,6 +222,20 @@ function loadPrivateMcpModule(key) {
   }
 }
 
+function isToolAvailable(toolName) {
+  const requirements = PRIVATE_MCP_TOOL_REQUIREMENTS[toolName] || [];
+  try {
+    return requirements.every((key) => Boolean(loadPrivateMcpModule(key)));
+  } catch {
+    return false;
+  }
+}
+
+function listAvailableTools(profileName = getActiveMcpProfile()) {
+  const allowedTools = new Set(getAllowedTools(profileName));
+  return TOOLS.filter((tool) => allowedTools.has(tool.name) && isToolAvailable(tool.name));
+}
+
 function unavailablePrivateMcpFeature(toolName) {
   return toTextResult({
     ok: false,
@@ -231,7 +263,7 @@ const {
   finalizeSession: finalizeFeedbackSession,
 } = require('../../scripts/feedback-session');
 
-const SERVER_INFO = { name: 'thumbgate-mcp', version: '1.28.1' };
+const SERVER_INFO = { name: 'thumbgate-mcp', version: '1.28.2' };
 const COMMERCE_CATEGORIES = [
   'product_recommendation',
   'brand_compliance',
@@ -1357,7 +1389,7 @@ async function handleRequest(message) {
     };
   }
   if (message.method === 'ping') return {};
-  if (message.method === 'tools/list') return { tools: TOOLS };
+  if (message.method === 'tools/list') return { tools: listAvailableTools() };
   if (message.method === 'tools/call') return callTool(message.params.name, message.params.arguments);
   throw new Error(`Unsupported method: ${message.method}`);
 }
@@ -1559,7 +1591,10 @@ module.exports = {
   buildSuggestFixResponse,
   __test__: {
     PRIVATE_MCP_MODULES,
+    PRIVATE_MCP_TOOL_REQUIREMENTS,
     loadPrivateMcpModule,
+    isToolAvailable,
+    listAvailableTools,
     unavailablePrivateMcpFeature,
     callToolInner,
   },

package/adapters/opencode/opencode.json

@@ -7,7 +7,7 @@
         "npx",
         "--yes",
         "--package",
-        "thumbgate@1.28.1",
+        "thumbgate@1.28.2",
         "thumbgate",
         "serve"
       ],

package/bin/cli.js

@@ -444,6 +444,11 @@ function codexPreToolHookSectionBlock() {
   return `[hooks.pre_tool_use]\ncommand = "${entry.command}"\nargs = ${formatTomlStringArray(entry.args)}\n`;
 }
 
+function codexUserPromptHookSectionBlock() {
+  const entry = canonicalCodexCliEntry(['hook-auto-capture']);
+  return `[hooks.user_prompt_submit]\ncommand = "${entry.command}"\nargs = ${formatTomlStringArray(entry.args)}\n`;
+}
+
 function mcpSectionRegex(name) {
   return new RegExp(
     `^\\[mcp_servers\\.${escapeRegExp(name)}\\]\\n(?:^(?!\\[).*(?:\\n|$))*`,
@@ -461,6 +466,7 @@ function tomlSectionRegex(name) {
 function upsertCodexServerConfig(content) {
   const canonicalBlock = codexMcpSectionBlock(MCP_SERVER_NAME);
   const canonicalHookBlock = codexPreToolHookSectionBlock();
+  const canonicalUserPromptHookBlock = codexUserPromptHookSectionBlock();
   const sections = MCP_SERVER_NAMES.map((name) => ({
     name,
     regex: mcpSectionRegex(name),
@@ -473,7 +479,7 @@ function upsertCodexServerConfig(content) {
     const prefix = content.trimEnd();
     return {
       changed: true,
-      content: `${prefix}${prefix ? '\n\n' : ''}${canonicalBlock}\n${canonicalHookBlock}`,
+      content: `${prefix}${prefix ? '\n\n' : ''}${canonicalBlock}\n${canonicalHookBlock}\n${canonicalUserPromptHookBlock}`,
     };
   }
 
@@ -517,6 +523,19 @@ function upsertCodexServerConfig(content) {
     changed = true;
   }
 
+  const userPromptHookRegex = tomlSectionRegex('hooks.user_prompt_submit');
+  if (userPromptHookRegex.test(nextContent)) {
+    const current = nextContent.match(userPromptHookRegex)[0];
+    if (current !== canonicalUserPromptHookBlock) {
+      nextContent = nextContent.replace(userPromptHookRegex, canonicalUserPromptHookBlock);
+      changed = true;
+    }
+  } else {
+    const prefix = nextContent.trimEnd();
+    nextContent = `${prefix}${prefix ? '\n\n' : ''}${canonicalUserPromptHookBlock}`;
+    changed = true;
+  }
+
   return {
     changed,
     content: nextContent.endsWith('\n') ? nextContent : `${nextContent}\n`,
@@ -2767,7 +2786,7 @@ function hookAutoCapture() {
     || promptEnvelope.prompt;
   const { evaluatePromptGuard } = require(path.join(PKG_ROOT, 'scripts', 'prompt-guard'));
   const { processInlineFeedback, formatCliOutput } = require(path.join(PKG_ROOT, 'scripts', 'cli-feedback'));
-  const { detectFeedbackSignal } = require(path.join(PKG_ROOT, 'scripts', 'feedback-quality'));
+  const { detectFeedbackSignal, isGenericFeedbackText } = require(path.join(PKG_ROOT, 'scripts', 'feedback-quality'));
   const { loadOptionalModule } = require(path.join(PKG_ROOT, 'scripts', 'private-core-boundary'));
   const { recordConversationEntry, readRecentConversationWindow } = loadOptionalModule(
     path.join(PKG_ROOT, 'scripts', 'feedback-history-distiller'),
@@ -2800,6 +2819,12 @@ function hookAutoCapture() {
 
   const signal = detected.signal;
   const conversationWindow = readRecentConversationWindow({ limit: 8 });
+  const chatHistory = conversationWindow.map((entry) => ({
+    role: entry.author === 'assistant' ? 'assistant' : 'user',
+    content: entry.text || '',
+  }));
+  const normalizedSignal = signal === 'down' ? 'negative' : 'positive';
+  const genericFeedback = isGenericFeedbackText(prompt, normalizedSignal);
   const { buildFeedbackSourceIdentity } = require(path.join(PKG_ROOT, 'scripts', 'feedback-loop'));
   const sourceEvent = buildFeedbackSourceIdentity({
     signal,
@@ -2813,11 +2838,9 @@ function hookAutoCapture() {
   const result = processInlineFeedback({
     signal,
     context: prompt,
-    chatHistory: signal === 'down'
-      ? conversationWindow.map((entry) => ({ role: entry.author === 'assistant' ? 'assistant' : 'user', content: entry.text || '' }))
-      : undefined,
-    whatWentWrong: signal === 'down' ? prompt : undefined,
-    whatWorked: signal === 'up' ? prompt : undefined,
+    chatHistory,
+    whatWentWrong: signal === 'down' && !genericFeedback ? prompt : undefined,
+    whatWorked: signal === 'up' && !genericFeedback ? prompt : undefined,
     sourceEvent,
   });
   if (!result.feedbackResult || !result.feedbackResult.duplicate) {

package/config/mcp-allowlists.json

@@ -68,6 +68,11 @@
       "distribute_context_to_agents",
       "session_report",
       "generate_operator_artifact",
+      "run_managed_lesson_agent",
+      "managed_agent_status",
+      "run_self_distill",
+      "self_distill_status",
+      "context_stuff_lessons",
       "perplexity_search",
       "perplexity_ask",
       "perplexity_research",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thumbgate",
-  "version": "1.28.1",
+  "version": "1.28.2",
   "description": "ThumbGate Pre-Action Checks derive rules from repeated failures, flag risky tool calls, hard-block detected secret leaks, and block matches in strict mode.",
   "homepage": "https://thumbgate.ai",
   "repository": {
@@ -90,6 +90,7 @@
     "scripts/export-hf-dataset.js",
     "scripts/failure-diagnostics.js",
     "scripts/feedback-aggregate.js",
+    "scripts/feedback-history-distiller.js",
     "scripts/feedback-attribution.js",
     "scripts/feedback-loop.js",
     "scripts/feedback-paths.js",

package/public/index.html

@@ -20,7 +20,7 @@ __GOOGLE_SITE_VERIFICATION_META__
 <meta property="og:image" content="https://thumbgate.ai/og.png">
 <meta name="twitter:card" content="summary_large_image">
 <meta name="twitter:image" content="https://thumbgate.ai/og.png">
-<meta name="thumbgate-version" content="1.28.1">
+<meta name="thumbgate-version" content="1.28.2">
 <meta name="keywords" content="ThumbGate, thumbgate, AI agent orchestration, AI experience orchestration, agentic development cycle, AC/DC framework, Guide Generate Verify Solve, agent enforcement layer, pre-action checks, agent governance, Claude Code, Cursor, Codex, Gemini, Amp, Cline, OpenCode, workflow hardening, context engineering, AI authenticity, brand authenticity AI">
 <link rel="canonical" href="__APP_ORIGIN__/">
 <link rel="alternate" type="text/markdown" title="ThumbGate LLM context" href="__APP_ORIGIN__/llm-context.md">
@@ -1776,7 +1776,7 @@ __GA_BOOTSTRAP__
       <a href="https://www.linkedin.com/in/igorganapolsky" target="_blank" rel="noopener">LinkedIn</a>
       <a href="/blog">Blog</a>
     </div>
-    <span class="footer-copy">© 2026 ThumbGate · MIT License · npm v1.28.1</span>
+    <span class="footer-copy">© 2026 ThumbGate · MIT License · npm v1.28.2</span>
   </div>
 </footer>
 

package/public/numbers.html

@@ -25,7 +25,7 @@
   "alternateName": "thumbgate",
   "applicationCategory": "DeveloperApplication",
   "operatingSystem": "Cross-platform, Node.js >=18.18.0",
-  "softwareVersion": "1.28.1",
+  "softwareVersion": "1.28.2",
   "url": "https://thumbgate.ai/numbers",
   "dateModified": "2026-05-07",
   "creator": {
@@ -202,7 +202,7 @@
 <main class="container">
   <h1>The Numbers</h1>
   <p class="subtitle">Generated first-party operational snapshot from the ThumbGate runtime. This is not customer traction, install volume, revenue, or proof that a configured gate has fired.</p>
-  <div class="freshness">Updated: 2026-05-07 · Version 1.28.1</div>
+  <div class="freshness">Updated: 2026-05-07 · Version 1.28.2</div>
   <div class="truth-note"><strong>Read this first:</strong> configured checks are inventory. Recorded blocks and warnings are usage evidence. This snapshot currently reports 0 recorded hard-block event(s) and 0 recorded warning event(s).</div>
 
   <h2>Gate enforcement</h2>

package/scripts/auto-wire-hooks.js

@@ -452,6 +452,46 @@ function codexConfigPath() {
   return path.join(getHome(), '.codex', 'config.json');
 }
 
+function codexTomlConfigPath(configPath = codexConfigPath()) {
+  return path.join(path.dirname(configPath), 'config.toml');
+}
+
+function tomlSectionRegex(name) {
+  return new RegExp(`^\\[${String(name).replace(/[.*+?^${}()|[\\]\\\\]/g, '\\$&')}\\]\\n(?:^(?!\\[).*(?:\\n|$))*`, 'm');
+}
+
+function codexUserPromptTomlBlock() {
+  const hookCommand = codexUserPromptHookCommand();
+  return `[hooks.user_prompt_submit]\ncommand = "sh"\nargs = ["-lc", ${JSON.stringify(hookCommand)}]\n`;
+}
+
+function upsertCodexUserPromptToml(configPath, dryRun = false) {
+  const tomlPath = codexTomlConfigPath(configPath);
+  const current = fs.existsSync(tomlPath) ? fs.readFileSync(tomlPath, 'utf8') : '';
+  const canonicalBlock = codexUserPromptTomlBlock();
+  const sectionRegex = tomlSectionRegex('hooks.user_prompt_submit');
+  let next = current;
+
+  if (sectionRegex.test(current)) {
+    const existingBlock = current.match(sectionRegex)[0];
+    if (existingBlock === canonicalBlock) {
+      return { changed: false, settingsPath: tomlPath };
+    }
+    next = current.replace(sectionRegex, canonicalBlock);
+  } else {
+    const prefix = current.trimEnd();
+    next = `${prefix}${prefix ? '\n\n' : ''}${canonicalBlock}`;
+  }
+
+  if (!dryRun) {
+    const dir = path.dirname(tomlPath);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(tomlPath, next.endsWith('\n') ? next : `${next}\n`);
+  }
+
+  return { changed: true, settingsPath: tomlPath };
+}
+
 function writeJsonFile(filePath, payload, dryRun) {
   if (dryRun) {
     return;
@@ -500,6 +540,7 @@ function wireCodexHooks(options) {
   const configPath = options.settingsPath || codexConfigPath();
   const dryRun = options.dryRun || false;
   const desiredStatusLine = codexStatuslineCommand();
+  const tomlResult = upsertCodexUserPromptToml(configPath, dryRun);
 
   let config = loadJsonFile(configPath) || {};
   config.hooks = config.hooks || {};
@@ -519,15 +560,28 @@ function wireCodexHooks(options) {
   if (added.length === 0) {
     if (syncCodexStatusLine(config, desiredStatusLine)) {
       writeJsonFile(configPath, config, dryRun);
-      return { changed: true, settingsPath: configPath, added: [{ lifecycle: 'statusLine', command: desiredStatusLine }] };
+      const statusAdded = [{ lifecycle: 'statusLine', command: desiredStatusLine }];
+      if (tomlResult.changed) {
+        statusAdded.push({ lifecycle: 'UserPromptSubmit', command: `${codexUserPromptHookCommand()} (${tomlResult.settingsPath})` });
+      }
+      return { changed: true, settingsPath: configPath, added: statusAdded };
     }
-    return { changed: false, settingsPath: configPath, added: [] };
+    return {
+      changed: tomlResult.changed,
+      settingsPath: configPath,
+      added: tomlResult.changed
+        ? [{ lifecycle: 'UserPromptSubmit', command: `${codexUserPromptHookCommand()} (${tomlResult.settingsPath})` }]
+        : [],
+    };
   }
 
   syncCodexStatusLine(config, desiredStatusLine);
   writeJsonFile(configPath, config, dryRun);
 
   added.push({ lifecycle: 'statusLine', command: desiredStatusLine });
+  if (tomlResult.changed) {
+    added.push({ lifecycle: 'UserPromptSubmit', command: `${codexUserPromptHookCommand()} (${tomlResult.settingsPath})` });
+  }
   return { changed: true, settingsPath: configPath, added };
 }
 
@@ -702,6 +756,8 @@ module.exports = {
   claudeSharedSettingsPath,
   claudeProjectSettingsPath,
   codexConfigPath,
+  codexTomlConfigPath,
+  upsertCodexUserPromptToml,
   geminiSettingsPath,
   syncClaudeStatusLine,
   forgeConfigPath,

package/scripts/cli-feedback.js

@@ -58,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,
+      chatHistory,
       sourceEvent,
     });
   } catch (err) {

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,
+};