thumbgate 1.27.18 → 1.27.20

package/scripts/pro-local-dashboard.js

@@ -16,7 +16,7 @@ const CREATOR_SYNTHETIC_KEY = process.env.THUMBGATE_DEV_KEY || '';
  *   2. Env var: THUMBGATE_DEV_BYPASS=[set via THUMBGATE_DEV_SECRET env var]
  * Requires a specific non-obvious value (not boolean) to prevent accidental activation.
  */
-function isCreatorDev({ env = process.env, homeDir = os.homedir() } = {}) {
+function isCreatorDev({ env = process.env, homeDir = env.HOME || env.USERPROFILE || os.homedir() } = {}) {
   // Layer 1: env var with specific value
   if (CREATOR_BYPASS_VALUE && String(env[CREATOR_BYPASS_ENV] || '') === CREATOR_BYPASS_VALUE) {
     return true;
@@ -37,7 +37,7 @@ function isCreatorDev({ env = process.env, homeDir = os.homedir() } = {}) {
  * with any non-empty bypass value. No env var needed — just the config file.
  * Used by the server to skip auth on localhost during local development.
  */
-function hasDevOverride(homeDir = os.homedir()) {
+function hasDevOverride(homeDir = process.env.HOME || process.env.USERPROFILE || os.homedir()) {
   // Disabled during test runs to avoid interfering with auth assertions
   if (process.env.NODE_TEST_CONTEXT || process.env.THUMBGATE_TESTING) return false;
   try {
@@ -47,11 +47,11 @@ function hasDevOverride(homeDir = os.homedir()) {
   } catch { return false; }
 }
 
-function getLicenseDir(homeDir = os.homedir()) {
+function getLicenseDir(homeDir = process.env.HOME || process.env.USERPROFILE || os.homedir()) {
   return path.join(homeDir, '.thumbgate');
 }
 
-function getLicensePath(homeDir = os.homedir()) {
+function getLicensePath(homeDir = process.env.HOME || process.env.USERPROFILE || os.homedir()) {
   return path.join(getLicenseDir(homeDir), 'license.json');
 }
 

package/scripts/proxy-pointer-rag-guardrails.js

@@ -39,9 +39,23 @@ function normalizeOptions(options = {}) {
     ...splitCsv(options.documents),
     ...splitCsv(options['document-ids']),
   ]);
+  const sourcePointers = unique([
+    ...splitCsv(options['source-pointers']),
+    ...splitCsv(options.pointers),
+    ...splitCsv(options.sources),
+  ]);
   const candidateImages = Number.isFinite(Number(options['candidate-images']))
     ? Number(options['candidate-images'])
     : null;
+  const extractedEntities = Number.isFinite(Number(options['extracted-entities']))
+    ? Number(options['extracted-entities'])
+    : 0;
+  const extractedRelations = Number.isFinite(Number(options['extracted-relations']))
+    ? Number(options['extracted-relations'])
+    : 0;
+  const promotionThreshold = Number.isFinite(Number(options['promotion-threshold']))
+    ? Number(options['promotion-threshold'])
+    : 3;
 
   return {
     ragTool: String(options['rag-tool'] || options.tool || 'proxy-pointer-rag').trim() || 'proxy-pointer-rag',
@@ -49,10 +63,15 @@ function normalizeOptions(options = {}) {
     sectionIds,
     imagePointers,
     documentIds,
+    sourcePointers,
     candidateImages,
+    extractedEntities,
+    extractedRelations,
+    promotionThreshold,
     crossDocumentPolicy: String(options['cross-doc-policy'] || options['cross-document-policy'] || '').trim().toLowerCase(),
     visionFilter: normalizeBoolean(options['vision-filter']),
     visualClaims: normalizeBoolean(options['visual-claims']),
+    pointerFirst: normalizeBoolean(options['pointer-first']) || normalizeBoolean(options['proxy-pointer']),
   };
 }
 
@@ -72,6 +91,14 @@ function gateApplicability(template, options) {
   return false;
 }
 
+function hasExtractionSprawl(options) {
+  const extractedFacts = options.extractedEntities + options.extractedRelations;
+  if (extractedFacts === 0) return false;
+  if (options.pointerFirst) return true;
+  if (options.sourcePointers.length === 0) return true;
+  return extractedFacts > options.sourcePointers.length * Math.max(2, options.promotionThreshold);
+}
+
 function buildSignalSummary(options) {
   const signals = [];
   if (options.treePath || options.sectionIds.length > 0) {
@@ -110,6 +137,19 @@ function buildSignalSummary(options) {
       risk: 'answers that describe image content may need a vision-model sanity check',
     });
   }
+  if (hasExtractionSprawl(options)) {
+    signals.push({
+      id: 'entity_relation_sprawl',
+      label: 'Entity/relation extraction sprawl',
+      values: unique([
+        `${options.extractedEntities} extracted entities`,
+        `${options.extractedRelations} extracted relations`,
+        `${options.sourcePointers.length} source pointers`,
+        `promotion threshold ${options.promotionThreshold}`,
+      ]),
+      risk: 'eager graph extraction can create stale aliases, weak edges, and unauditable memory; keep source pointers first and promote relations only after repeated retrieval value',
+    });
+  }
   return signals;
 }
 
@@ -139,11 +179,12 @@ function buildProxyPointerRagGuardrailsPlan(rawOptions = {}, templatesPath) {
     templates: recommendedTemplates,
     nextActions: [
       'Preserve document hierarchy, section IDs, and image file paths during ingestion.',
+      'Store source pointers before extracting entities or relations; promote a relation only after repeated retrieval value and source verification.',
       'Pass section-tree and image-pointer metadata into the agent before it answers with visuals.',
       'Enable the recommended Document RAG Safety templates as pre-action gates.',
       'Use a vision filter only for high-impact answers that make claims about visual content.',
     ],
-    exampleCommand: 'npx thumbgate proxy-pointer-rag-guardrails --tree-path=.rag/tree.json --image-pointers=paper-1/figures/fig2.png --documents=paper-1 --visual-claims --json',
+    exampleCommand: 'npx thumbgate proxy-pointer-rag-guardrails --tree-path=.rag/tree.json --source-pointers=lesson/fb_123,tool/run_456 --extracted-entities=120 --extracted-relations=80 --pointer-first --json',
   };
 }
 

package/scripts/published-cli.js

@@ -37,14 +37,6 @@ function publishedCliShellCommand(pkgVersion, commandArgs = [], options = {}) {
   const escapedArgs = commandArgs.map(shellQuote).join(' ');
   const fastPath = `[ -x ${shellQuote(runtimeBin)} ] && exec ${shellQuote(runtimeBin)}${escapedArgs ? ` ${escapedArgs}` : ''}`;
   const installPath = `mkdir -p ${shellQuote(prefixDir)} && exec npm ${publishedCliArgs(pkgVersion, commandArgs, { prefixDir }).map(shellQuote).join(' ')}`;
-  if (options.preferInstalled === false) {
-    const packageSpec = `thumbgate@${pkgVersion}`;
-    return [
-      `mkdir -p ${shellQuote(prefixDir)}`,
-      `npm "install" "--prefix" ${shellQuote(prefixDir)} "--no-save" "--omit=dev" ${shellQuote(packageSpec)} >/dev/null 2>&1`,
-      `exec ${shellQuote(runtimeBin)}${escapedArgs ? ` ${escapedArgs}` : ''}`,
-    ].join(' && ');
-  }
   return `${fastPath} || ${installPath}`;
 }
 

package/scripts/qa-scenario-planner.js

@@ -0,0 +1,136 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+
+const RUNTIME_PATTERNS = [
+  { pattern: /^public\/.*\.(html|css|js)$/i, surface: 'browser', reason: 'public UI asset changed' },
+  { pattern: /^src\/api\//i, surface: 'api', reason: 'API route or server behavior changed' },
+  { pattern: /^bin\//i, surface: 'cli', reason: 'CLI entrypoint changed' },
+  { pattern: /^scripts\/(dashboard|pro-local-dashboard|.*gate|.*scanner|.*reward|.*routing).*\.js$/i, surface: 'agent-runtime', reason: 'agent runtime or gate behavior changed' },
+  { pattern: /^adapters\//i, surface: 'agent-adapter', reason: 'agent adapter changed' },
+  { pattern: /^plugins\//i, surface: 'plugin', reason: 'plugin install path changed' },
+  { pattern: /^package\.json$/i, surface: 'package', reason: 'package manifest changed' },
+];
+
+const SKIP_PATTERNS = [
+  /^README\.md$/i,
+  /^docs\//i,
+  /^reports\//i,
+  /^proof\//i,
+  /^tests\/.*\.test\.js$/i,
+  /^\.claude\/implementation-notes\//i,
+];
+
+function normalizeFiles(files = []) {
+  return Array.from(new Set(files
+    .map((file) => String(file || '').trim().replace(/^\.?\//, ''))
+    .filter(Boolean)));
+}
+
+function classifyFile(file) {
+  for (const entry of RUNTIME_PATTERNS) {
+    if (entry.pattern.test(file)) return { ...entry, file };
+  }
+  for (const pattern of SKIP_PATTERNS) {
+    if (pattern.test(file)) return { surface: 'skip', reason: 'no runtime impact', file };
+  }
+  return { surface: 'focused', reason: 'unknown runtime impact; run focused checks', file };
+}
+
+function parseChangedFilesFromDiff(diff = '') {
+  const files = [];
+  for (const line of String(diff || '').split('\n')) {
+    const match = line.match(/^diff --git a\/(.+?) b\/(.+)$/);
+    if (match) files.push(match[2]);
+  }
+  return normalizeFiles(files);
+}
+
+function planQaScenario(input = {}) {
+  const files = normalizeFiles(input.files || parseChangedFilesFromDiff(input.diff || ''));
+  const classifications = files.map(classifyFile);
+  const surfaces = Array.from(new Set(classifications.map((entry) => entry.surface)));
+  const runtimeChanges = classifications.filter((entry) => entry.surface !== 'skip');
+  const skipOnly = files.length > 0 && runtimeChanges.length === 0;
+
+  const recommendedRunner = chooseRunner(surfaces, input);
+  const userScenario = buildUserScenario(runtimeChanges, input);
+  return {
+    name: 'thumbgate-user-impact-qa-scenario',
+    status: skipOnly ? 'skip' : 'actionable',
+    files,
+    classifications,
+    recommendedRunner,
+    userScenario,
+    commands: buildCommands(recommendedRunner, runtimeChanges),
+    regressionPolicy: skipOnly
+      ? 'skip durable QA; no runtime-impact files changed'
+      : 'if the QA agent finds a deterministic failure, convert it into a focused regression test before opening a fix PR',
+    transientFailurePolicy: 'doctor the browser/computer-use runner once, retry once, then label as infrastructure-flaky instead of product-regression',
+  };
+}
+
+function chooseRunner(surfaces, input = {}) {
+  if (input.forceComputerUse || surfaces.includes('plugin') || surfaces.includes('agent-adapter')) return 'computer-use-qa';
+  if (surfaces.includes('browser') || surfaces.includes('api')) return 'browser-qa';
+  if (surfaces.includes('cli') || surfaces.includes('agent-runtime') || surfaces.includes('package')) return 'focused-node-qa';
+  if (surfaces.every((surface) => surface === 'skip')) return 'skip';
+  return 'focused-node-qa';
+}
+
+function buildUserScenario(runtimeChanges, input = {}) {
+  if (runtimeChanges.length === 0) return 'No user-impact scenario required; changed files are docs, tests, reports, or proof artifacts only.';
+  const surfaces = Array.from(new Set(runtimeChanges.map((entry) => entry.surface)));
+  if (surfaces.includes('browser') || surfaces.includes('api')) {
+    return 'Open the affected page as a user, perform the primary CTA or dashboard action, verify visible state changes, then check the related API response.';
+  }
+  if (surfaces.includes('plugin') || surfaces.includes('agent-adapter')) {
+    return 'Install or reload the affected agent integration, run one thumbs-up and one thumbs-down capture, then verify the next risky action is gated.';
+  }
+  if (surfaces.includes('cli')) {
+    return 'Run the changed CLI command with --help and one realistic command path, then verify exit code, JSON output, and no stale command copy.';
+  }
+  return input.scenario || 'Run the focused test for the changed runtime surface, then verify the behavior with one realistic operator workflow.';
+}
+
+function buildCommands(runner, runtimeChanges) {
+  if (runner === 'skip') return [];
+  const commands = ['npm test -- --test-concurrency=1'];
+  if (runner === 'browser-qa') commands.push('npx playwright test tests/e2e --project=chromium');
+  if (runner === 'computer-use-qa') commands.push('node scripts/qa-scenario-planner.js --doctor-runner');
+  if (runtimeChanges.some((entry) => entry.surface === 'package')) commands.push('npm pack --dry-run');
+  return commands;
+}
+
+function parseArgs(argv = process.argv.slice(2)) {
+  const args = {};
+  for (const arg of argv) {
+    if (arg === '--json') args.json = true;
+    else if (arg === '--doctor-runner') args.doctorRunner = true;
+    else if (arg.startsWith('--files=')) args.files = arg.slice('--files='.length).split(',');
+    else if (arg.startsWith('--diff-file=')) args.diff = fs.readFileSync(arg.slice('--diff-file='.length), 'utf8');
+    else if (arg.startsWith('--scenario=')) args.scenario = arg.slice('--scenario='.length);
+  }
+  return args;
+}
+
+if (require.main === module) {
+  const args = parseArgs();
+  if (args.doctorRunner) {
+    console.log('QA runner doctor: verify browser/computer-use target, screenshot capture, and network reachability before blaming product code.');
+    process.exit(0);
+  }
+  const report = planQaScenario(args);
+  if (args.json) console.log(JSON.stringify(report, null, 2));
+  else {
+    console.log(`${report.status.toUpperCase()}: ${report.userScenario}`);
+    for (const command of report.commands) console.log(`- ${command}`);
+  }
+}
+
+module.exports = {
+  classifyFile,
+  parseChangedFilesFromDiff,
+  planQaScenario,
+};

package/scripts/rate-limiter.js

@@ -6,42 +6,78 @@ const path = require('path');
 const {
   PRO_MONTHLY_PAYMENT_LINK,
   PRO_PRICE_LABEL,
-  TEAM_PRICE_LABEL,
+  ENTERPRISE_PRICE_LABEL,
 } = require('./commercial-offer');
 
 const USAGE_FILE = path.join(process.env.HOME || '/tmp', '.thumbgate', 'usage-limits.json');
 
 // ──────────────────────────────────────────────────────────
-// Free tier: generous on captures (habit formation) and rules
-// (5 active gates), gated on Pro-only features (recall, search,
-// exports). Dashboard, exports, and unlimited rules drive Pro.
+// Free tier: tight enough to create upgrade pressure after
+// real usage. Captures and rules are capped so heavy users
+// hit the wall within the first week, not the first quarter.
 // ──────────────────────────────────────────────────────────
 const FREE_TIER_LIMITS = {
-  capture_feedback:   { daily: Infinity, lifetime: Infinity, label: 'feedback captures' },
-  prevention_rules:   { daily: Infinity, lifetime: Infinity, label: 'prevention rules generated' },
+  capture_feedback:   { daily: 2,        lifetime: 10,       label: 'feedback captures (2/day, 10 total on free)' },
+  prevention_rules:   { daily: 2,        lifetime: 3,        label: 'prevention rules generated (2/day on free)' },
   recall:             { daily: 0,        lifetime: 0,        label: 'recall queries (Pro only)' },
   search_lessons:     { daily: 0,        lifetime: 0,        label: 'lesson searches (Pro only)' },
   search_thumbgate:   { daily: 0,        lifetime: 0,        label: 'ThumbGate searches (Pro only)' },
   commerce_recall:    { daily: 0,        lifetime: 0,        label: 'commerce recalls (Pro only)' },
   export_dpo:         { daily: 0,        lifetime: 0,        label: 'DPO exports (Pro only)' },
   export_databricks:  { daily: 0,        lifetime: 0,        label: 'Databricks exports (Pro only)' },
-  construct_context_pack: { daily: Infinity, lifetime: Infinity, label: 'context packs' },
+  construct_context_pack: { daily: 3,    lifetime: Infinity,  label: 'context packs (3/day on free)' },
 };
 
-const FREE_TIER_MAX_GATES = 5; // 5 active prevention rules on free; Pro is unlimited
+const FREE_TIER_MAX_GATES = 3; // 3 active prevention rules on free; Pro is unlimited
+const FREE_TIER_DAILY_BLOCKS = 2; // 3 gate blocks/day on free; after limit, deny → warn + upgrade CTA
 
-const UPGRADE_MESSAGE = `Pro: ${PRO_PRICE_LABEL} — unlimited rules, recall, lesson search, dashboard, and exports: ${PRO_MONTHLY_PAYMENT_LINK}\n  Team: ${TEAM_PRICE_LABEL} after workflow qualification.`;
+const UPGRADE_MESSAGE = `Pro: ${PRO_PRICE_LABEL} — unlimited rules, recall, lesson search, dashboard, and exports: ${PRO_MONTHLY_PAYMENT_LINK}\n  Enterprise: ${ENTERPRISE_PRICE_LABEL} after workflow qualification.`;
 
 const PAYWALL_MESSAGES = {
-  prevention_rules: 'Free tier includes 5 active prevention rules. Promote more or unlock unlimited rules with Pro.',
+  capture_feedback: 'Free tier: 2 captures/day (10 total). Your feedback is stored locally — upgrade to capture unlimited.',
+  prevention_rules: 'Free tier includes 3 active prevention rules and 2 rule generations/day. Upgrade to Pro for unlimited rules.',
   recall: 'Recall is a Pro feature. Your past feedback is stored locally — upgrade to search and reuse it.',
   search_lessons: 'Lesson search is a Pro feature. Upgrade to find patterns in your agent\'s mistakes.',
+  construct_context_pack: 'Free tier: 3 context packs/day. Upgrade to Pro for unlimited.',
   default: 'This feature requires Pro. Start Pro — card required; billed today.',
 };
 
+const TRIAL_DAYS = 7;
+
+function getInstallAgeDays() {
+  try {
+    const { INSTALL_ID_PATH } = require('./cli-telemetry');
+    if (!fs.existsSync(INSTALL_ID_PATH)) return null;
+    // Use mtimeMs — birthtimeMs is unreliable on Linux (ext4 doesn't backdate creation time).
+    // The install-id file is written once at install, so mtime == creation time in practice.
+    const stat = fs.statSync(INSTALL_ID_PATH);
+    const created = stat.mtimeMs || stat.birthtimeMs;
+    if (!Number.isFinite(created) || created <= 0) return null;
+    return (Date.now() - created) / (1000 * 60 * 60 * 24);
+  } catch (_) {
+    return null;
+  }
+}
+
+function isInTrialPeriod() {
+  if (process.env.CI || process.env.GITHUB_ACTIONS) return false;
+  if (process.env.THUMBGATE_NO_TRIAL === '1') return false;
+  const age = getInstallAgeDays();
+  if (age === null) return false;
+  if (age < 0.0007) return false; // <1 minute old — just-created install, not a real trial
+  return age < TRIAL_DAYS;
+}
+
+function trialDaysRemaining() {
+  const age = getInstallAgeDays();
+  if (age === null) return 0;
+  return Math.max(0, Math.ceil(TRIAL_DAYS - age));
+}
+
 function isProTier(authContext) {
   if (authContext && authContext.tier === 'pro') return true;
-  if (process.env.THUMBGATE_API_KEY || process.env.THUMBGATE_PRO_MODE === '1' || process.env.THUMBGATE_NO_RATE_LIMIT === '1') return true;
+  if (process.env.THUMBGATE_API_KEY) return true;
+  if (process.env.THUMBGATE_NO_RATE_LIMIT === '1') return true;
   // Creator/dogfooding bypass: when the owner has the dev secret + bypass
   // configured (env or ~/.config/thumbgate/dev.json), treat the install as Pro
   // so marketing nudges and rate limits stop firing on the maintainer's own
@@ -57,6 +93,9 @@ function isProTier(authContext) {
     const { isProLicensed } = require('./license');
     if (isProLicensed()) return true;
   } catch (_) {}
+  // 7-day reverse trial: new installs get full Pro access, then hit a clear
+  // hosted-sync/unlimited-rules pay moment while the product is still fresh.
+  if (isInTrialPeriod()) return true;
   return false;
 }
 
@@ -114,12 +153,18 @@ function checkLimit(action, authContext) {
   const dailyCurrent = usage.counts[action] || 0;
   const lifetimeCurrent = usage.lifetime[action] || 0;
 
+  const isCapture = action === 'capture_feedback';
+  const monthlyLink = isCapture
+    ? 'https://buy.stripe.com/7sYfZhaiE1eSbO99uj3sI0d'
+    : PRO_MONTHLY_PAYMENT_LINK;
+  const upgradeMessage = `Pro: ${PRO_PRICE_LABEL} — unlimited rules, recall, lesson search, dashboard, and exports: ${monthlyLink}\n  Enterprise: ${ENTERPRISE_PRICE_LABEL} after workflow qualification.`;
+
   // Check lifetime limit first (the hard wall)
   if (lifetimeLimit !== Infinity && lifetimeCurrent >= lifetimeLimit) {
     const paywallMsg = PAYWALL_MESSAGES[action] || PAYWALL_MESSAGES.default;
     return {
       allowed: false,
-      message: `${paywallMsg}\n\n${UPGRADE_MESSAGE}`,
+      message: `${paywallMsg}\n\n${upgradeMessage}`,
       used: lifetimeCurrent,
       limit: lifetimeLimit,
       limitType: 'lifetime',
@@ -128,9 +173,10 @@ function checkLimit(action, authContext) {
 
   // Check daily limit
   if (dailyLimit !== Infinity && dailyCurrent >= dailyLimit) {
+    const paywallMsg = PAYWALL_MESSAGES[action] || PAYWALL_MESSAGES.default;
     return {
       allowed: false,
-      message: `Daily limit reached. ${UPGRADE_MESSAGE}`,
+      message: `Daily limit reached. ${paywallMsg}\n\n${upgradeMessage}`,
       used: dailyCurrent,
       limit: dailyLimit,
       limitType: 'daily',
@@ -179,12 +225,17 @@ function getUsage(action, authContext) {
 module.exports = {
   checkLimit,
   getUsage,
+  getInstallAgeDays,
   isProTier,
+  isInTrialPeriod,
+  trialDaysRemaining,
   loadUsage,
   saveUsage,
   todayKey,
   FREE_TIER_LIMITS,
   FREE_TIER_MAX_GATES,
+  FREE_TIER_DAILY_BLOCKS,
+  TRIAL_DAYS,
   UPGRADE_MESSAGE,
   PAYWALL_MESSAGES,
   USAGE_FILE,

package/scripts/repeat-metric.js

@@ -0,0 +1,137 @@
+'use strict';
+
+// ---------------------------------------------------------------------------
+// repeat-metric — first-class "repeat-attempts blocked before execution" metric
+//
+// This module exposes data ThumbGate already collects in gate-stats state. It
+// does NOT write to disk; it is a pure function over gates-engine.loadStats().
+//
+// The headline number is stats.recurringBlocks — incremented by recordStat()
+// in gates-engine.js every time the same gate blocks/warns the same sanitized
+// action fingerprint within one session bucket. That is "a pre-action gate fire
+// that stopped a tool call the agent had already been blocked on", rather than
+// merely "the same noisy gate fired again."
+// ---------------------------------------------------------------------------
+
+const gatesEngine = require('./gates-engine');
+
+/**
+ * Derive a per-gate { firstBlocks, repeatBlocks } split from the raw stats.
+ *
+ * Modern stats record, per session bucket, which sanitized action fingerprints
+ * each gate fired on:
+ *   stats.sessionFiredActions[sessionKey][gateId][fingerprint] === true
+ *
+ * firstBlocks is the count of distinct first action fingerprints. Legacy stats
+ * without fingerprints fall back to the old per-session-gate split.
+ *
+ * total block+warn events come from stats.byGate[id] (blocked + warned), which
+ * recordStat() also maintains. repeatBlocks is clamped to >= 0 to stay robust
+ * against partially-written / legacy state.
+ *
+ * @param {object} stats raw object returned by gates-engine.loadStats()
+ * @returns {Object<string,{firstBlocks:number, repeatBlocks:number}>}
+ */
+function computeByGateSplit(stats) {
+  const byGate = {};
+  const sessionFiredActions = (stats && stats.sessionFiredActions) || {};
+  const sessionFiredGates = (stats && stats.sessionFiredGates) || {};
+  const rawByGate = (stats && stats.byGate) || {};
+
+  // Count distinct action fingerprints each gate fired on => firstBlocks.
+  const firstBlocksByGate = {};
+  const gatesWithActionStats = new Set();
+  for (const sessionKey of Object.keys(sessionFiredActions)) {
+    const fired = sessionFiredActions[sessionKey] || {};
+    for (const gateId of Object.keys(fired)) {
+      const fingerprints = fired[gateId] || {};
+      const count = Object.values(fingerprints).filter(Boolean).length;
+      if (count > 0) {
+        gatesWithActionStats.add(gateId);
+        firstBlocksByGate[gateId] = (firstBlocksByGate[gateId] || 0) + count;
+      }
+    }
+  }
+
+  // Legacy fallback: old stats only tracked gate fired per session bucket.
+  for (const sessionKey of Object.keys(sessionFiredGates)) {
+    const fired = sessionFiredGates[sessionKey] || {};
+    for (const gateId of Object.keys(fired)) {
+      if (fired[gateId] && !gatesWithActionStats.has(gateId)) {
+        firstBlocksByGate[gateId] = (firstBlocksByGate[gateId] || 0) + 1;
+      }
+    }
+  }
+
+  // Union of every gate id we know about from either source.
+  const gateIds = new Set([
+    ...Object.keys(rawByGate),
+    ...Object.keys(firstBlocksByGate),
+    ...Object.keys(sessionFiredActions).flatMap((sessionKey) => Object.keys(sessionFiredActions[sessionKey] || {})),
+  ]);
+
+  for (const gateId of gateIds) {
+    const gateStat = rawByGate[gateId] || {};
+    const totalFires = (gateStat.blocked || 0) + (gateStat.warned || 0);
+    const firstBlocks = firstBlocksByGate[gateId] || 0;
+    // Repeat fires are total fires beyond the first fire per session bucket.
+    const repeatBlocks = Math.max(0, totalFires - firstBlocks);
+    byGate[gateId] = { firstBlocks, repeatBlocks };
+  }
+
+  return byGate;
+}
+
+/**
+ * Compute the repeat-attempts-blocked-before-execution metric.
+ *
+ * Pure read of gates-engine.loadStats(); no disk writes.
+ *
+ * @returns {{
+ *   repeatBlocksBeforeExecution: number,
+ *   recurringBlocks: number,
+ *   totalBlocked: number,
+ *   byGate: Object<string,{firstBlocks:number, repeatBlocks:number}>
+ * }}
+ */
+function computeRepeatMetric() {
+  let stats;
+  try {
+    stats = gatesEngine.loadStats() || {};
+  } catch (_) {
+    stats = {};
+  }
+
+  const recurringBlocks = Number(stats.recurringBlocks || 0);
+  const totalBlocked = Number(stats.blocked || 0);
+
+  return {
+    // Headline: a pre-action block that stopped a tool call the agent had
+    // already been blocked on this session.
+    repeatBlocksBeforeExecution: recurringBlocks,
+    recurringBlocks,
+    totalBlocked,
+    byGate: computeByGateSplit(stats),
+  };
+}
+
+/**
+ * Add a `repeat` sub-key to a gate-stats object WITHOUT mutating the original.
+ *
+ * Takes the object returned by gate-stats.calculateStats() or
+ * dashboard.computeGateStats() and returns a shallow copy with the repeat
+ * metric attached. The caller's file does not need to import any internals.
+ *
+ * @param {object} gateStatsObject
+ * @returns {object} copy of gateStatsObject with `.repeat`
+ */
+function mergeRepeatMetricIntoGateStats(gateStatsObject) {
+  const base = gateStatsObject && typeof gateStatsObject === 'object' ? gateStatsObject : {};
+  return Object.assign({}, base, { repeat: computeRepeatMetric() });
+}
+
+module.exports = {
+  computeRepeatMetric,
+  mergeRepeatMetricIntoGateStats,
+  computeByGateSplit,
+};

package/scripts/secret-fixture-tokens.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const FIXTURE_TOKENS = {
+  awsAccessKeyId: '__TG_FIXTURE_AWS_ACCESS_KEY_ID__',
+  githubPat: '__TG_FIXTURE_GITHUB_PAT__',
+  openAiLegacyKey: '__TG_FIXTURE_OPENAI_LEGACY_KEY__',
+  openAiProjectKey: '__TG_FIXTURE_OPENAI_PROJECT_KEY__',
+  rsaPrivateKeyHeader: '__TG_FIXTURE_RSA_PRIVATE_KEY_HEADER__',
+  ecPrivateKeyHeader: '__TG_FIXTURE_EC_PRIVATE_KEY_HEADER__',
+  privateKeyHeader: '__TG_FIXTURE_PRIVATE_KEY_HEADER__',
+};
+
+function buildAwsAccessKeyId() {
+  return ['AKIA', 'IOSFODNN7EXAMPLE'].join('');
+}
+
+function buildGitHubPat() {
+  return ['gh', 'p_', 'x'.repeat(36)].join('');
+}
+
+function buildOpenAiLegacyKey() {
+  return ['sk', '-', 'abcdefghijklmnopqrstuvwxyz01234567890'].join('');
+}
+
+function buildOpenAiProjectKey() {
+  return ['sk', '-proj-', 'abcdefghijklmnopqrstuvwxyz01234567890'].join('');
+}
+
+function buildPemHeader(prefix = '') {
+  return ['-----BEGIN ', prefix, 'PRIVATE KEY-----'].join('');
+}
+
+function fixtureReplacements() {
+  return [
+    [FIXTURE_TOKENS.awsAccessKeyId, buildAwsAccessKeyId()],
+    [FIXTURE_TOKENS.githubPat, buildGitHubPat()],
+    [FIXTURE_TOKENS.openAiLegacyKey, buildOpenAiLegacyKey()],
+    [FIXTURE_TOKENS.openAiProjectKey, buildOpenAiProjectKey()],
+    [FIXTURE_TOKENS.rsaPrivateKeyHeader, buildPemHeader('RSA ')],
+    [FIXTURE_TOKENS.ecPrivateKeyHeader, buildPemHeader('EC ')],
+    [FIXTURE_TOKENS.privateKeyHeader, buildPemHeader('')],
+  ];
+}
+
+function expandFixturePlaceholders(value) {
+  let expanded = String(value || '');
+  for (const [token, replacement] of fixtureReplacements()) {
+    expanded = expanded.split(token).join(replacement);
+  }
+  return expanded;
+}
+
+module.exports = {
+  FIXTURE_TOKENS,
+  buildAwsAccessKeyId,
+  buildGitHubPat,
+  buildOpenAiLegacyKey,
+  buildOpenAiProjectKey,
+  buildPemHeader,
+  expandFixturePlaceholders,
+};