thumbgate 1.27.16 → 1.27.18

package/scripts/agent-reward-model.js

@@ -331,55 +331,6 @@ function buildRewardReport(episodes = [], options = {}) {
       deep: 'destructive, public, or production-adjacent work',
       xhigh: 'payments, secrets, deploy-prod, data-loss, force-push-main',
     },
-    continualAdapterPlan: buildContinualAdapterTrainingPlan(episodes, options),
-  };
-}
-
-function buildContinualAdapterTrainingPlan(episodes = [], options = {}) {
-  const maxAdapters = Math.max(1, Number(options.maxAdapters || 4));
-  const minExamples = Math.max(1, Number(options.minExamples || 2));
-  const pairs = buildPreferencePairs(episodes, { ...options, maxPairs: Number(options.maxPairs || 24) });
-  const candidates = rankGateCandidatesByReward(episodes, {
-    ...options,
-    minOccurrences: minExamples,
-    maxGateCandidates: maxAdapters,
-  }).slice(0, maxAdapters);
-
-  const adapters = candidates.map((candidate, index) => ({
-    id: `lora_${candidate.gateId || `adapter_${index + 1}`}`.slice(0, 96),
-    source: candidate.key,
-    trainingMode: 'concurrent-lora',
-    examples: candidate.occurrences,
-    priorityScore: candidate.priorityScore,
-    targetBehavior: candidate.recommendation,
-    retentionChecks: [
-      'baseline gate pass-rate must not regress',
-      'previous adapter reward must stay within tolerance',
-      'new adapter must improve blocked-repeat or verification reward on held-out episodes',
-    ],
-  }));
-
-  const enoughData = pairs.length >= minExamples && adapters.length > 0;
-  return {
-    status: enoughData ? 'ready' : 'needs_more_feedback',
-    trainingStack: 'multi-lora-continual-learning',
-    baseModelPolicy: 'freeze base model; train small adapters from reward-ranked DPO pairs',
-    scheduling: adapters.length > 1 ? 'batch adapters concurrently when they share the same frozen base' : 'train serially until at least two adapter candidates exist',
-    adapters,
-    dpoPairsAvailable: pairs.length,
-    retentionGate: 'ship no adapter unless reward, regression, and prior-domain retention checks pass',
-    nextActions: enoughData
-      ? [
-          'Export reward-ranked DPO pairs.',
-          'Train candidate LoRA adapters concurrently on the same frozen base.',
-          'Evaluate each adapter against held-out negative episodes and prior positive episodes.',
-          'Promote only the adapter that improves reward without retention regression.',
-        ]
-      : [
-          'Capture more thumbs-up/down outcomes before training.',
-          'Promote deterministic gates first when examples are sparse.',
-          'Use local semantic recall until enough reward-ranked pairs exist for adapter training.',
-        ],
   };
 }
 
@@ -468,10 +419,8 @@ if (isCliInvocation()) {
     console.log(JSON.stringify(buildPreferencePairs(episodes), null, 2));
   } else if (args.command === 'gates') {
     console.log(JSON.stringify(rankGateCandidatesByReward(episodes), null, 2));
-  } else if (args.command === 'adapters') {
-    console.log(JSON.stringify(buildContinualAdapterTrainingPlan(episodes), null, 2));
   } else {
-    console.error(`Unknown command: ${args.command}. Use: report, pairs, gates, adapters`);
+    console.error(`Unknown command: ${args.command}. Use: report, pairs, gates`);
     process.exit(1);
   }
 }
@@ -479,7 +428,6 @@ if (isCliInvocation()) {
 module.exports = {
   HIGH_RISK_TAGS,
   allocateTestTimeCompute,
-  buildContinualAdapterTrainingPlan,
   buildPreferencePairFromEpisodes,
   buildPreferencePairs,
   buildRewardReport,

package/scripts/auto-promote-gates.js

@@ -58,47 +58,6 @@ function readJSONL(filePath) {
   }).filter(Boolean);
 }
 
-// --- Self-Harness stage 3: regression-gated promotion -----------------------
-// Inspired by "Self-Harness: Harnesses That Improve Themselves" (arXiv 2606.09498).
-// Stages 1-2 (weakness mining -> rule extraction) already exist via lesson
-// inference + this promoter. Stage 3 — accept a harness change only after
-// regression-testing it does not degrade behavior — was missing: a noisy 3x
-// capture could hard-block an over-broad pattern with no check that it wouldn't
-// have wrongly blocked actions that were previously ALLOWED. This replays a
-// candidate BLOCK rule against the audit trail's prior `allow` decisions; if it
-// would have blocked safe actions, the caller quarantines it to `warn` instead.
-const REGRESSION_FALSE_BLOCK_LIMIT = 0; // any prior safe action it would block => quarantine
-
-function getAuditTrailPath() {
-  return path.join(path.dirname(getFeedbackLogPath()), 'audit-trail.jsonl');
-}
-
-// Returns { falseBlocks, allowSampleSize } or null when there is no history /
-// matcher available — in which case the caller promotes as usual (fail-open to
-// existing behavior, since regression gating is an enhancement, not a hard gate).
-function regressionCheck(gate, options = {}) {
-  const auditPath = options.auditTrailPath || getAuditTrailPath();
-  const entries = readJSONL(auditPath);
-  if (!entries.length) return null;
-  // Lazy-require to avoid the gates-engine <-> auto-promote-gates require cycle.
-  let matchesGate;
-  try { ({ matchesGate } = require('./gates-engine')); } catch { return null; }
-  if (typeof matchesGate !== 'function') return null;
-  const allowed = entries.filter((e) => e && e.decision === 'allow' && e.toolName);
-  if (!allowed.length) return null;
-  let falseBlocks = 0;
-  for (const e of allowed) {
-    try {
-      if (matchesGate(gate, e.toolName, e.toolInput || {})) falseBlocks += 1;
-    } catch { /* a bad pattern/entry never counts as a false block */ }
-  }
-  return { falseBlocks, allowSampleSize: allowed.length };
-}
-
-function safeRegressionCheck(gate, options) {
-  try { return regressionCheck(gate, options); } catch { return null; }
-}
-
 function loadAutoGates() {
   const autoGatesPath = getAutoGatesPath();
   if (!fs.existsSync(autoGatesPath)) {
@@ -234,9 +193,9 @@ function patternToGateId(key) {
   return 'auto-' + key.replace(/[^a-z0-9]+/gi, '-').replace(/^-|-$/g, '').slice(0, 50).toLowerCase();
 }
 
-function buildGateRule(group, actionOverride) {
-  const action = actionOverride || (group.count === 'MANUAL' ? group.manualAction || 'block' : (group.count >= BLOCK_THRESHOLD ? 'block' : 'warn'));
-  const severity = action === 'block' ? 'critical' : action === 'approve' ? 'high' : 'medium';
+function buildGateRule(group) {
+  const action = group.count === 'MANUAL' ? group.manualAction || 'block' : (group.count >= BLOCK_THRESHOLD ? 'block' : 'warn');
+  const severity = action === 'block' ? 'critical' : 'medium';
   const context = group.latestContext.slice(0, 120);
   const kind = group.key.startsWith('diagnosis:')
     ? 'repeated diagnosis'
@@ -373,8 +332,7 @@ function forcePromote(context, action = 'block') {
   return { gateId, action, totalGates: data.gates.length };
 }
 
-function promote(feedbackLogPath, options) {
-  const opts = options || {};
+function promote(feedbackLogPath) {
   const logPath = feedbackLogPath || getFeedbackLogPath();
   const entries = readJSONL(logPath);
   const groups = groupNegativeFeedback(entries, WINDOW_DAYS);
@@ -399,38 +357,17 @@ function promote(feedbackLogPath, options) {
       const existing = data.gates[existingIdx];
       const newAction = group.count >= BLOCK_THRESHOLD ? 'block' : 'warn';
       if (existing.action !== newAction && newAction === 'block') {
-        // Self-Harness stage 3: regression-test before upgrading warn -> block.
-        const regression = opts.skipRegression ? null : safeRegressionCheck(buildGateRule(group, 'block'), opts);
-        if (regression && regression.falseBlocks > REGRESSION_FALSE_BLOCK_LIMIT) {
-          // Would block prior safe actions — hold at warn instead of upgrading.
-          promotions.push({ type: 'upgrade-quarantined', gateId, from: existing.action, occurrences: group.count, falseBlocks: regression.falseBlocks });
-        } else {
-          // Upgrade from warn to block
-          data.gates[existingIdx] = { ...existing, action: 'block', severity: 'critical', occurrences: group.count, upgradedAt: new Date().toISOString() };
-          promotions.push({ type: 'upgrade', gateId, from: existing.action, to: 'block', occurrences: group.count });
-        }
+        // Upgrade from warn to block
+        data.gates[existingIdx] = { ...existing, action: 'block', severity: 'critical', occurrences: group.count, upgradedAt: new Date().toISOString() };
+        promotions.push({ type: 'upgrade', gateId, from: existing.action, to: 'block', occurrences: group.count });
       }
       // Update occurrence count even if no action change
       data.gates[existingIdx].occurrences = group.count;
       continue;
     }
 
-    // New gate — respect explicit gateAction override (e.g. 'approve' for human-approval rules)
-    const gate = buildGateRule(group, opts.gateAction);
-
-    // Self-Harness stage 3: before a feedback rule goes live as a hard block,
-    // regression-test it against prior allowed actions. If it would have blocked
-    // safe actions, quarantine it to `warn` instead of `block`.
-    let regression = null;
-    if (gate.action === 'block' && !opts.gateAction && !opts.skipRegression) {
-      regression = safeRegressionCheck(gate, opts);
-      if (regression && regression.falseBlocks > REGRESSION_FALSE_BLOCK_LIMIT) {
-        gate.action = 'warn';
-        gate.severity = 'medium';
-        gate.quarantined = true;
-        gate.regression = regression;
-      }
-    }
+    // New gate
+    const gate = buildGateRule(group);
 
     // Enforce max limit — rotate oldest
     if (data.gates.length >= MAX_AUTO_GATES) {
@@ -439,13 +376,7 @@ function promote(feedbackLogPath, options) {
     }
 
     data.gates.push(gate);
-    promotions.push({
-      type: gate.quarantined ? 'new-quarantined' : 'new',
-      gateId: gate.id,
-      action: gate.action,
-      occurrences: group.count,
-      ...(gate.quarantined ? { falseBlocks: regression.falseBlocks, allowSampleSize: regression.allowSampleSize } : {}),
-    });
+    promotions.push({ type: 'new', gateId: gate.id, action: gate.action, occurrences: group.count });
   }
 
   // Log promotions
@@ -506,9 +437,6 @@ module.exports = {
   groupNegativeFeedback,
   patternToGateId,
   buildGateRule,
-  regressionCheck,
-  getAuditTrailPath,
-  REGRESSION_FALSE_BLOCK_LIMIT,
   extractPatternKey,
   normalizeCommandSignature,
   isNegative,

package/scripts/auto-wire-hooks.js

@@ -27,7 +27,6 @@ const {
   statuslineCommand,
   userPromptHookCommand,
 } = require('./hook-runtime');
-const { installShim } = require('./install-shim');
 
 function getHome() {
   return process.env.HOME || process.env.USERPROFILE || '';
@@ -339,19 +338,6 @@ function wireClaudeHooks(options) {
     options.projectSettingsPath || claudeProjectSettingsPath(options.projectDir);
   const dryRun = options.dryRun || false;
   const projectDir = options.projectDir || process.cwd();
-
-  // --- Install stable shim before resolving hook commands ---
-  // The shim at ~/.thumbgate/bin/thumbgate-hook always resolves @latest,
-  // so hooks never go stale across version bumps (Volta-style pattern).
-  // Skip in source-checkout mode — developers use direct node commands.
-  if (!dryRun && !require('./mcp-config').isSourceCheckout(path.join(__dirname, '..'))) {
-    try {
-      installShim();
-    } catch {
-      // Non-fatal: fall back to version-pinned commands
-    }
-  }
-
   const desiredStatusLine = statuslineCommand();
 
   // --- Step 0: clean up stale hooks from BOTH settings locations ---

package/scripts/billing.js

@@ -51,7 +51,6 @@ const {
 } = require('./analytics-window');
 const { ensureParentDir } = require('./fs-utils');
 const mailer = require('./mailer');
-const { recordCheckoutFunnelEvent } = require('./plausible-server-events');
 
 function loadWorkflowSprintIntakeModule() {
   const modulePath = path.resolve(__dirname, 'workflow-sprint-intake.js');
@@ -139,10 +138,6 @@ const IS_TEST = !!(
   process.env.NODE_ENV === 'test'
 );
 
-function allowUnsignedStripeWebhooks() {
-  return IS_TEST && process.env.THUMBGATE_ALLOW_UNSIGNED_STRIPE_WEBHOOKS === '1';
-}
-
 function shouldMergeLegacyBillingData() {
   return process.env._TEST_INCLUDE_LEGACY_BILLING_DATA === '1'
     || process.env.THUMBGATE_INCLUDE_LEGACY_BILLING_DATA === '1';
@@ -449,57 +444,6 @@ function buildCheckoutProductData({ name, description, appOrigin, planId }) {
   };
 }
 
-/**
- * Verify an ACTIVE Stripe product exists for the given plan name before
- * we let buildSubscriptionPriceData create inline price_data under it.
- *
- * Stripe matches product_data by `name`. If only an archived product
- * matches, new prices created via that path inherit active=false and the
- * generated checkout URL renders "Something went wrong / The page you
- * were looking for could not be found." for the buyer. Stripe Dashboard
- * shows the session as `open` with no email captured — looks like the
- * buyer abandoned, but they were never given a working page.
- *
- * Failing here surfaces the misconfiguration at the first checkout
- * attempt instead of silently breaking every buyer for days.
- *
- * Verified incident: ThumbGate#2188 (May 2026) — 20 sessions abandoned in
- * 7 days, all because the only product named "ThumbGate Pro" matching the
- * inline product_data was archived (prod_UXxOHAfbDsPyRb), while an active
- * product with the same name existed (prod_UW82THPxfNvwKT) that should
- * have been used instead.
- */
-async function verifyActiveProductForPlan(stripe, planId) {
-  const expectedName = planId === 'team' ? 'ThumbGate Team' : 'ThumbGate Pro';
-  let products;
-  try {
-    products = await stripe.products.list({ limit: 100 });
-  } catch (err) {
-    // Network/transient failures shouldn't block checkout creation.
-    // The original session.create call will surface real Stripe errors.
-    return;
-  }
-  const matching = (products && products.data ? products.data : [])
-    .filter((p) => p && p.name === expectedName);
-  if (matching.length === 0) {
-    // No product with this name exists; Stripe will create a new one when
-    // session.create fires with inline product_data. Safe path.
-    return;
-  }
-  const active = matching.find((p) => p.active === true);
-  if (!active) {
-    const archived = matching[0];
-    throw new Error(
-      `Refusing to create checkout session: Stripe product named "${expectedName}" ` +
-      `exists only in archived state (id=${archived.id}, active=false). New prices ` +
-      `created via inline product_data would inherit active=false, rendering ` +
-      `"page not found" on Stripe checkout for every buyer. Fix: reactivate the ` +
-      `archived product in Stripe Dashboard, or rename the active product to ` +
-      `match "${expectedName}". See ThumbGate#2188 for the May 2026 incident.`
-    );
-  }
-}
-
 function buildSubscriptionPriceData(checkoutSelection, appOrigin) {
   const isTeam = checkoutSelection.planId === 'team';
   const annual = checkoutSelection.billingCycle === 'annual';
@@ -2581,18 +2525,6 @@ async function createCheckoutSession({ successUrl, cancelUrl, customerEmail, ins
   }
 
   const stripe = getStripeClient();
-
-  // Defensive guard against ThumbGate#2188:
-  // When buildSubscriptionPriceData passes inline `product_data` to Stripe,
-  // Stripe name-matches existing products. If the only existing product with
-  // that name is ARCHIVED (active=false), the new price inherits active=false
-  // and every Stripe checkout page renders "page not found" for the buyer.
-  // That bug burnt 20+ silent abandoned sessions in May 2026. Fail fast
-  // instead of letting the broken page ship.
-  if (!packId) {
-    await verifyActiveProductForPlan(stripe, checkoutSelection.planId);
-  }
-
   const sessionPayload = buildCheckoutSessionPayload({
     successUrl,
     cancelUrl,
@@ -2905,7 +2837,7 @@ function disableCustomerKeys(customerId) {
 }
 
 function verifyWebhookSignature(rawBody, signature) {
-  if (!CONFIG.STRIPE_WEBHOOK_SECRET) return allowUnsignedStripeWebhooks();
+  if (!CONFIG.STRIPE_WEBHOOK_SECRET) return true;
   if (!signature || !rawBody) return false;
 
   // Stripe signature format: t=<timestamp>,v1=<hmac>,...
@@ -2935,13 +2867,6 @@ function verifyWebhookSignature(rawBody, signature) {
 
 async function handleWebhook(rawBody, signature) {
   if (LOCAL_MODE()) return { handled: false, reason: 'local_mode' };
-  if (!CONFIG.STRIPE_WEBHOOK_SECRET && !allowUnsignedStripeWebhooks()) {
-    return {
-      handled: false,
-      reason: 'invalid_signature',
-      error: 'STRIPE_WEBHOOK_SECRET is required before Stripe webhooks can be processed.',
-    };
-  }
   let event;
   try {
     if (CONFIG.STRIPE_WEBHOOK_SECRET) {
@@ -3050,22 +2975,6 @@ async function handleWebhook(rawBody, signature) {
           attribution,
         });
       }
-      // Fire Plausible purchase event so the funnel poller can measure
-      // end-to-end conversion: visitor → CTA → checkout → email → Stripe → purchase.
-      // Fire-and-forget (never blocks the webhook response).
-      void recordCheckoutFunnelEvent('purchase', {
-        page: '/success',
-        props: {
-          sessionId: session.id,
-          customerId,
-          traceId: traceId || '',
-          packId: packId || '',
-          amount: session.amount_total != null ? String(session.amount_total) : '',
-          currency: session.currency || '',
-          ...attribution,
-        },
-      });
-
       return {
         handled: true,
         action: 'provisioned_api_key',
@@ -3218,7 +3127,6 @@ module.exports = {
   _buildTrialActivationEmail: buildTrialActivationEmail,
   _sendTrialActivationEmail: sendTrialActivationEmail,
   _resolveSubscriptionCheckoutSelection: resolveSubscriptionCheckoutSelection,
-  _verifyActiveProductForPlan: verifyActiveProductForPlan,
   _API_KEYS_PATH: () => CONFIG.API_KEYS_PATH,
   _FUNNEL_LEDGER_PATH: () => CONFIG.FUNNEL_LEDGER_PATH,
   _REVENUE_LEDGER_PATH: () => CONFIG.REVENUE_LEDGER_PATH,

package/scripts/build-metadata.js

@@ -5,11 +5,6 @@ const PROJECT_ROOT = path.resolve(__dirname, '..');
 const DEFAULT_BUILD_METADATA_PATH = path.join(PROJECT_ROOT, 'config', 'build-metadata.json');
 const BUILD_SHA_ENV_KEY = 'THUMBGATE_BUILD_SHA';
 const BUILD_GENERATED_AT_ENV_KEY = 'THUMBGATE_BUILD_GENERATED_AT';
-// Railway injects this automatically for GitHub-connected deployments: the git
-// SHA of the commit that triggered the deploy. It is the ground truth for what
-// code is actually live, and unlike THUMBGATE_BUILD_SHA it cannot drift (Railway
-// sets it per deploy). https://docs.railway.com/reference/variables
-const RAILWAY_GIT_COMMIT_SHA_ENV_KEY = 'RAILWAY_GIT_COMMIT_SHA';
 
 function normalizeNullableText(value) {
   if (typeof value !== 'string') {
@@ -21,69 +16,35 @@ function normalizeNullableText(value) {
 }
 
 function resolveBuildMetadata({ env = process.env, filePath } = {}) {
-  // Precedence: immutable JSON file (baked into Docker image at build time, so it
-  // ALWAYS matches the deployed code) wins over runtime env vars. Env vars are
-  // mutable Railway/host config that can drift — they shadowed the freshly-stamped
-  // SHA in prod on 2026-05-20 and made /health lie about the deployed commit.
-  // Fall back to env vars only when the file is missing or its values are null,
-  // and require an explicit SHA env var (not just a stray GENERATED_AT) before
-  // trusting the env branch.
   const resolvedPath =
     normalizeNullableText(filePath) ||
     normalizeNullableText(env.THUMBGATE_BUILD_METADATA_PATH) ||
     DEFAULT_BUILD_METADATA_PATH;
   const envBuildSha = normalizeNullableText(env[BUILD_SHA_ENV_KEY]);
-  const railwayGitSha = normalizeNullableText(env[RAILWAY_GIT_COMMIT_SHA_ENV_KEY]);
   const envGeneratedAt = normalizeNullableText(env[BUILD_GENERATED_AT_ENV_KEY]);
 
-  let fileBuildSha = null;
-  let fileGeneratedAt = null;
-  try {
-    const parsed = JSON.parse(fs.readFileSync(resolvedPath, 'utf8'));
-    fileBuildSha = normalizeNullableText(parsed.buildSha);
-    fileGeneratedAt = normalizeNullableText(parsed.generatedAt);
-  } catch {
-    // file missing or unreadable — fall through to env branch
-  }
-
-  if (fileBuildSha) {
+  if (envBuildSha || envGeneratedAt) {
     return {
       path: resolvedPath,
-      buildSha: fileBuildSha,
-      generatedAt: fileGeneratedAt || envGeneratedAt,
+      buildSha: envBuildSha,
+      generatedAt: envGeneratedAt,
     };
   }
 
-  // No SHA baked into the image. Prefer Railway's own per-deploy commit SHA over
-  // THUMBGATE_BUILD_SHA: the latter is set out-of-band by the deploy workflow and
-  // has drifted in prod (stuck reporting an old commit while newer code was live,
-  // because RAILWAY_SYNC_VARIABLES is off and `railway up` stamping is unreliable).
-  // RAILWAY_GIT_COMMIT_SHA is injected by Railway per deploy, so it always matches
-  // the code actually serving traffic on a GitHub-connected service.
-  if (railwayGitSha) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(resolvedPath, 'utf8'));
     return {
       path: resolvedPath,
-      buildSha: railwayGitSha,
-      generatedAt: envGeneratedAt,
+      buildSha: normalizeNullableText(parsed.buildSha),
+      generatedAt: normalizeNullableText(parsed.generatedAt),
     };
-  }
-
-  // Last resort: the workflow-managed env var. Only trust it when an explicit SHA
-  // is set. (Previously a bare GENERATED_AT with no SHA could short-circuit and
-  // return { buildSha: null }, losing both signals; now we require the SHA.)
-  if (envBuildSha) {
+  } catch {
     return {
       path: resolvedPath,
-      buildSha: envBuildSha,
-      generatedAt: envGeneratedAt,
+      buildSha: null,
+      generatedAt: null,
     };
   }
-
-  return {
-    path: resolvedPath,
-    buildSha: null,
-    generatedAt: fileGeneratedAt || envGeneratedAt,
-  };
 }
 
 function writeBuildMetadataFile({ sha, outputPath, generatedAt = new Date().toISOString() }) {
@@ -144,7 +105,6 @@ if (require.main === module) {
 module.exports = {
   BUILD_GENERATED_AT_ENV_KEY,
   BUILD_SHA_ENV_KEY,
-  RAILWAY_GIT_COMMIT_SHA_ENV_KEY,
   DEFAULT_BUILD_METADATA_PATH,
   resolveBuildMetadata,
   writeBuildMetadataFile,

package/scripts/cli-feedback.js

@@ -14,7 +14,6 @@
  */
 
 const { captureFeedback } = require('./feedback-loop');
-const { isGenericFeedbackText, normalizeFeedbackSignal } = require('./feedback-quality');
 const { loadOptionalModule } = require('./private-core-boundary');
 // `history-distiller` is a PRIVATE_CORE_MODULE — present in this checkout and
 // in ThumbGate-Core, but intentionally excluded from the public npm tarball.
@@ -48,21 +47,15 @@ const RST = '\x1b[0m';
  */
 function processInlineFeedback({ signal, context, chatHistory, whatWentWrong, whatWorked } = {}) {
   const isDown = signal === 'down' || signal === 'negative';
-  const normalizedQualitySignal = normalizeFeedbackSignal(isDown ? 'down' : 'up');
-  const providedContext = String(context || '').trim();
-  const genericContext = isGenericFeedbackText(providedContext, normalizedQualitySignal);
-  const effectiveWhatWentWrong = whatWentWrong || (isDown && providedContext && !genericContext ? providedContext : undefined);
-  const effectiveWhatWorked = whatWorked || (!isDown && providedContext && !genericContext ? providedContext : undefined);
 
   // 1. Capture the feedback
   let feedbackResult;
   try {
     feedbackResult = captureFeedback({
       signal: isDown ? 'down' : 'up',
-      context: providedContext,
-      chatHistory,
-      whatWentWrong: effectiveWhatWentWrong,
-      whatWorked: effectiveWhatWorked,
+      context: context || (isDown ? 'Thumbs down from CLI' : 'Thumbs up from CLI'),
+      whatWentWrong: whatWentWrong || undefined,
+      whatWorked: whatWorked || undefined,
     });
   } catch (err) {
     feedbackResult = { accepted: false, reason: err.message };
@@ -95,19 +88,14 @@ function formatCliOutput(result) {
   if (result.feedbackResult && result.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;
     if (feedbackId) {
-      lines.push(`${D}  Feedback ID: ${feedbackId}${RST}`);
-      if (memoryId) lines.push(`${D}  Memory ID  : ${memoryId}${RST}`);
+      lines.push(`${D}  ID: ${feedbackId}${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`);
+      process.stderr.write(`✅ Feedback captured (${feedbackId})\n`);
     }
   } else {
-    const clarification = result.feedbackResult && result.feedbackResult.needsClarification
-      ? ` ${result.feedbackResult.prompt || result.feedbackResult.message || ''}`.trimEnd()
-      : '';
-    lines.push(`${R}Feedback not accepted: ${(result.feedbackResult && result.feedbackResult.reason) || 'unknown'}${clarification ? ` — ${clarification}` : ''}${RST}`);
+    lines.push(`${R}Feedback not accepted: ${(result.feedbackResult && result.feedbackResult.reason) || 'unknown'}${RST}`);
   }
 
   // Distilled lesson (if thumbs down)