thumbgate 1.14.1 → 1.16.0

package/scripts/dispatch-brief.js

@@ -1,159 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-const { summarizePermissionTier } = require('./agent-readiness');
-const { getOperationalDashboard } = require('./operational-dashboard');
-
-const DISPATCH_TASK_DESCRIPTIONS = {
-  recall: 'Recall prior mistakes and prevention rules before planning.',
-  feedback_summary: 'Summarize recent wins, failures, and operator notes.',
-  search_lessons: 'Search promoted lessons and inspect what corrective action the system linked to each one.',
-  retrieve_lessons: 'Retrieve top-K relevant lessons for a given tool/action context (per-action guidance).',
-  search_thumbgate: 'Search raw ThumbGate feedback, ContextFS memory, and prevention rules.',
-  feedback_stats: 'Inspect approval trends and failure domains.',
-  diagnose_failure: 'Explain why a run failed or was blocked.',
-  list_intents: 'List available workflow plans without executing them.',
-  plan_intent: 'Plan a workflow with checkpoints and no execution.',
-  context_provenance: 'Audit recent context and evidence decisions.',
-  gate_stats: 'Review blocked and warned gate trends.',
-  dashboard: 'Summarize health, proof, gates, and pipeline metrics.',
-  get_business_metrics: 'Read revenue, conversion, and customer metrics.',
-  describe_semantic_entity: 'Explain Customer, Revenue, or Funnel state.',
-  enforcement_matrix: 'Full pipeline state: feedback counts, promotion rate, active gates, rejection ledger.',
-  get_reliability_rules: 'Review active prevention rules and success patterns.',
-  describe_reliability_entity: 'Alias for semantic entity definitions.',
-};
-
-const DISPATCH_BLOCKED_TASKS = [
-  'Direct code edits or git writes from the primary checkout.',
-  'Starting or completing handoffs from the remote session.',
-  'Memory writes, context-pack writes, or gate satisfaction mutations.',
-  'Admin-only billing or workflow mutation endpoints.',
-];
-
-const DISPATCH_PROMPTS = [
-  'Summarize revenue, funnel, gates, and proof-backed workflow health for the last 7d.',
-  'Explain the top blocked gate and the repeated mistake it is preventing.',
-  'Plan the next workflow-hardening sprint for this repo without executing any changes.',
-];
-
-function buildDispatchBrief(data, options = {}) {
-  const profileName = String(options.profile || 'dispatch').trim() || 'dispatch';
-  const permissions = summarizePermissionTier(profileName);
-  const analytics = data.analytics || {};
-  const revenue = analytics.revenue || {};
-  const funnel = analytics.funnel || {};
-  const northStar = analytics.northStar || {};
-  const gateStats = data.gateStats || {};
-  const readiness = data.readiness || {};
-  const operational = data.operational || {};
-
-  const allowedTasks = permissions.allowedTools
-    .map((toolName) => ({
-      tool: toolName,
-      description: DISPATCH_TASK_DESCRIPTIONS[toolName],
-    }))
-    .filter((entry) => entry.description);
-
-  return {
-    generatedAt: new Date().toISOString(),
-    source: options.source || operational.source || 'local',
-    fallbackReason: options.fallbackReason || operational.fallbackReason || null,
-    profile: permissions.profile,
-    tier: permissions.tier,
-    writeCapable: permissions.writeCapable,
-    readiness: {
-      overallStatus: readiness.overallStatus || 'unknown',
-      runtimeMode: readiness.runtime && readiness.runtime.mode ? readiness.runtime.mode : 'unknown',
-      bootstrapReady: Boolean(readiness.bootstrap && readiness.bootstrap.ready),
-    },
-    metrics: {
-      bookedRevenueUsd: Number(((Number(revenue.bookedRevenueCents || 0)) / 100).toFixed(2)),
-      paidOrders: revenue.paidOrders || 0,
-      uniqueLeads: funnel.uniqueLeads || 0,
-      visitors: funnel.visitors || 0,
-      checkoutStarts: funnel.checkoutStarts || 0,
-      weeklyProofBackedWorkflowRuns: northStar.weeklyActiveProofBackedWorkflowRuns || 0,
-      weeklyTeamsRunningProofBackedWorkflows: northStar.weeklyTeamsRunningProofBackedWorkflows || 0,
-      activeGates: gateStats.totalGates || 0,
-      blockedActions: gateStats.blocked || 0,
-      warnedActions: gateStats.warned || 0,
-      topBlockedGate: gateStats.topBlocked
-        ? {
-          id: gateStats.topBlocked,
-          count: gateStats.topBlockedCount || 0,
-        }
-        : null,
-    },
-    allowedTasks,
-    blockedTasks: DISPATCH_BLOCKED_TASKS,
-    promptTemplates: DISPATCH_PROMPTS,
-  };
-}
-
-function formatDispatchBrief(brief) {
-  const lines = [];
-  lines.push('Dispatch Ops Brief');
-  lines.push('─'.repeat(40));
-  lines.push(`Source                : ${brief.source}${brief.fallbackReason ? ` (${brief.fallbackReason})` : ''}`);
-  lines.push(`Profile               : ${brief.profile} (${brief.tier})`);
-  lines.push(`Readiness             : ${brief.readiness.overallStatus}`);
-  lines.push(`Runtime               : ${brief.readiness.runtimeMode}`);
-  lines.push(`Bootstrap             : ${brief.readiness.bootstrapReady ? 'ready' : 'missing context'}`);
-  lines.push('');
-  lines.push('Key Metrics');
-  lines.push(`  Booked revenue      : $${brief.metrics.bookedRevenueUsd.toFixed(2)}`);
-  lines.push(`  Paid orders         : ${brief.metrics.paidOrders}`);
-  lines.push(`  Unique leads        : ${brief.metrics.uniqueLeads}`);
-  lines.push(`  Visitors            : ${brief.metrics.visitors}`);
-  lines.push(`  Checkout starts     : ${brief.metrics.checkoutStarts}`);
-  lines.push(`  Weekly proof runs   : ${brief.metrics.weeklyProofBackedWorkflowRuns}`);
-  lines.push(`  Weekly teams        : ${brief.metrics.weeklyTeamsRunningProofBackedWorkflows}`);
-  lines.push(`  Active gates        : ${brief.metrics.activeGates}`);
-  lines.push(`  Blocked actions     : ${brief.metrics.blockedActions}`);
-  lines.push(`  Warned actions      : ${brief.metrics.warnedActions}`);
-  if (brief.metrics.topBlockedGate) {
-    lines.push(`  Top blocked gate    : ${brief.metrics.topBlockedGate.id} (${brief.metrics.topBlockedGate.count}x)`);
-  }
-  lines.push('');
-  lines.push('Safe Remote Tasks');
-  brief.allowedTasks.forEach((entry) => {
-    lines.push(`- ${entry.tool}: ${entry.description}`);
-  });
-  lines.push('');
-  lines.push('Do Not Do From Dispatch');
-  brief.blockedTasks.forEach((task) => {
-    lines.push(`- ${task}`);
-  });
-  lines.push('');
-  lines.push('Prompt Templates');
-  brief.promptTemplates.forEach((prompt) => {
-    lines.push(`- ${prompt}`);
-  });
-  return `${lines.join('\n')}\n`;
-}
-
-async function getDispatchBrief(options = {}) {
-  const profile = String(options.profile || 'dispatch').trim() || 'dispatch';
-  const { source, data, fallbackReason } = await getOperationalDashboard(options);
-  return buildDispatchBrief(data, { profile, source, fallbackReason });
-}
-
-module.exports = {
-  DISPATCH_BLOCKED_TASKS,
-  DISPATCH_PROMPTS,
-  buildDispatchBrief,
-  formatDispatchBrief,
-  getDispatchBrief,
-};
-
-if (require.main === module) {
-  getDispatchBrief()
-    .then((brief) => {
-      process.stdout.write(formatDispatchBrief(brief));
-    })
-    .catch((err) => {
-      console.error(err && err.message ? err.message : err);
-      process.exit(1);
-    });
-}

package/scripts/distribution-surfaces.js

@@ -1,110 +0,0 @@
-'use strict';
-
-const fs = require('node:fs');
-const path = require('node:path');
-
-const ROOT = path.join(__dirname, '..');
-const PRODUCTHUNT_URL = 'https://www.producthunt.com/products/thumbgate';
-const CLAUDE_PLUGIN_LATEST_ASSET_NAME = 'thumbgate-claude-desktop.mcpb';
-const CLAUDE_PLUGIN_NEXT_ASSET_NAME = 'thumbgate-claude-desktop-next.mcpb';
-const CLAUDE_PLUGIN_REVIEW_LATEST_ASSET_NAME = 'thumbgate-claude-plugin-review.zip';
-const CLAUDE_PLUGIN_REVIEW_NEXT_ASSET_NAME = 'thumbgate-claude-plugin-review-next.zip';
-const CODEX_PLUGIN_LATEST_ASSET_NAME = 'thumbgate-codex-plugin.zip';
-const CODEX_PLUGIN_NEXT_ASSET_NAME = 'thumbgate-codex-plugin-next.zip';
-
-function readJson(root, relativePath) {
-  return JSON.parse(fs.readFileSync(path.join(root, relativePath), 'utf8'));
-}
-
-function getPackageVersion(root = ROOT) {
-  return String(readJson(root, 'package.json').version || '').trim();
-}
-
-function getRepositoryUrl(root = ROOT) {
-  return String(readJson(root, 'package.json').repository.url || '').replace(/\.git$/, '');
-}
-
-function getClaudePluginVersionedAssetName(version = getPackageVersion(ROOT)) {
-  const normalized = String(version || '').replace(/^v/, '');
-  return `thumbgate-claude-desktop-v${normalized}.mcpb`;
-}
-
-function getClaudePluginReviewVersionedAssetName(version = getPackageVersion(ROOT)) {
-  const normalized = String(version || '').replace(/^v/, '');
-  return `thumbgate-claude-plugin-review-v${normalized}.zip`;
-}
-
-function isPrereleaseVersion(version = getPackageVersion(ROOT)) {
-  return /^\d+\.\d+\.\d+-[0-9A-Za-z.-]+$/.test(String(version || '').trim());
-}
-
-function getClaudePluginChannelAssetName(version = getPackageVersion(ROOT)) {
-  return isPrereleaseVersion(version) ? CLAUDE_PLUGIN_NEXT_ASSET_NAME : CLAUDE_PLUGIN_LATEST_ASSET_NAME;
-}
-
-function getClaudePluginReviewChannelAssetName(version = getPackageVersion(ROOT)) {
-  return isPrereleaseVersion(version)
-    ? CLAUDE_PLUGIN_REVIEW_NEXT_ASSET_NAME
-    : CLAUDE_PLUGIN_REVIEW_LATEST_ASSET_NAME;
-}
-
-function getClaudePluginLatestDownloadUrl(root = ROOT) {
-  return `${getRepositoryUrl(root)}/releases/latest/download/${CLAUDE_PLUGIN_LATEST_ASSET_NAME}`;
-}
-
-function getClaudePluginVersionedDownloadUrl(root = ROOT, version = getPackageVersion(root)) {
-  const normalized = String(version || '').replace(/^v/, '');
-  return `${getRepositoryUrl(root)}/releases/download/v${normalized}/${getClaudePluginVersionedAssetName(normalized)}`;
-}
-
-function getClaudePluginReviewLatestDownloadUrl(root = ROOT) {
-  return `${getRepositoryUrl(root)}/releases/latest/download/${CLAUDE_PLUGIN_REVIEW_LATEST_ASSET_NAME}`;
-}
-
-function getClaudePluginReviewVersionedDownloadUrl(root = ROOT, version = getPackageVersion(root)) {
-  const normalized = String(version || '').replace(/^v/, '');
-  return `${getRepositoryUrl(root)}/releases/download/v${normalized}/${getClaudePluginReviewVersionedAssetName(normalized)}`;
-}
-
-function getCodexPluginVersionedAssetName(version = getPackageVersion(ROOT)) {
-  const normalized = String(version || '').replace(/^v/, '');
-  return `thumbgate-codex-plugin-v${normalized}.zip`;
-}
-
-function getCodexPluginChannelAssetName(version = getPackageVersion(ROOT)) {
-  return isPrereleaseVersion(version) ? CODEX_PLUGIN_NEXT_ASSET_NAME : CODEX_PLUGIN_LATEST_ASSET_NAME;
-}
-
-function getCodexPluginLatestDownloadUrl(root = ROOT) {
-  return `${getRepositoryUrl(root)}/releases/latest/download/${CODEX_PLUGIN_LATEST_ASSET_NAME}`;
-}
-
-function getCodexPluginVersionedDownloadUrl(root = ROOT, version = getPackageVersion(root)) {
-  const normalized = String(version || '').replace(/^v/, '');
-  return `${getRepositoryUrl(root)}/releases/download/v${normalized}/${getCodexPluginVersionedAssetName(normalized)}`;
-}
-
-module.exports = {
-  CLAUDE_PLUGIN_LATEST_ASSET_NAME,
-  CLAUDE_PLUGIN_NEXT_ASSET_NAME,
-  CLAUDE_PLUGIN_REVIEW_LATEST_ASSET_NAME,
-  CLAUDE_PLUGIN_REVIEW_NEXT_ASSET_NAME,
-  CODEX_PLUGIN_LATEST_ASSET_NAME,
-  CODEX_PLUGIN_NEXT_ASSET_NAME,
-  PRODUCTHUNT_URL,
-  getClaudePluginChannelAssetName,
-  getClaudePluginLatestDownloadUrl,
-  getClaudePluginReviewChannelAssetName,
-  getClaudePluginReviewLatestDownloadUrl,
-  getClaudePluginReviewVersionedAssetName,
-  getClaudePluginReviewVersionedDownloadUrl,
-  getClaudePluginVersionedAssetName,
-  getClaudePluginVersionedDownloadUrl,
-  getCodexPluginChannelAssetName,
-  getCodexPluginLatestDownloadUrl,
-  getCodexPluginVersionedAssetName,
-  getCodexPluginVersionedDownloadUrl,
-  getPackageVersion,
-  getRepositoryUrl,
-  isPrereleaseVersion,
-};

package/scripts/feedback-history-distiller.js

@@ -1,382 +0,0 @@
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const { resolveFeedbackDir: resolveSharedFeedbackDir } = require('./feedback-paths');
-const { readJsonlTail } = require('./fs-utils');
-
-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 });
-  fs.appendFileSync(filePath, `${JSON.stringify(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,
-};

package/scripts/funnel-analytics.js

@@ -1,35 +0,0 @@
-#!/usr/bin/env node
-const { getBusinessAnalytics } = require('./billing');
-
-function generateFunnelReport() {
-  const analytics = getBusinessAnalytics();
-  console.log('╔══════════════════════════════════════════════════════╗');
-  console.log('║      Marketing & Revenue Funnel Analytics            ║');
-  console.log('╠══════════════════════════════════════════════════════╣');
-  console.log(`║  Traffic Visitors:                  ${String((analytics.trafficMetrics && analytics.trafficMetrics.visitors) || 0).padStart(6)}           ║`);
-  console.log(`║  CTA Clicks:                        ${String((analytics.trafficMetrics && analytics.trafficMetrics.ctaClicks) || 0).padStart(6)}           ║`);
-  console.log(`║  Unique Leads:                      ${String(analytics.signups.uniqueLeads).padStart(6)}           ║`);
-  console.log(`║  Sprint Leads:                      ${String((analytics.pipeline.workflowSprintLeads && analytics.pipeline.workflowSprintLeads.total) || 0).padStart(6)}           ║`);
-  console.log(`║  Paid Provider Events:              ${String(analytics.revenue.paidProviderEvents || 0).padStart(6)}           ║`);
-  console.log(`║  Paid Orders Tracked:               ${String(analytics.revenue.paidOrders).padStart(6)}           ║`);
-  console.log(`║  Known Booked Revenue (cents):      ${String(analytics.revenue.bookedRevenueCents).padStart(6)}           ║`);
-  console.log('╠══════════════════════════════════════════════════════╣');
-  console.log('║  Acquisition by Source:                              ║');
-  Object.entries(analytics.signups.bySource).forEach(([key, count]) => {
-    const line = `    ${key}: ${count}`;
-    console.log(`║  ${line.padEnd(52)}║`);
-  });
-  console.log('║  Paid Orders by Source:                              ║');
-  Object.entries(analytics.attribution.paidBySource).forEach(([key, count]) => {
-    const line = `    ${key}: ${count}`;
-    console.log(`║  ${line.padEnd(52)}║`);
-  });
-  console.log('║  Revenue by Source (cents):                          ║');
-  Object.entries(analytics.attribution.bookedRevenueBySourceCents).forEach(([key, count]) => {
-    const line = `    ${key}: ${count}`;
-    console.log(`║  ${line.padEnd(52)}║`);
-  });
-  console.log('╚══════════════════════════════════════════════════════╝');
-}
-if (require.main === module) generateFunnelReport();
-module.exports = { generateFunnelReport };