thumbgate 1.27.20 → 1.28.1

package/adapters/claude/.mcp.json

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

package/adapters/mcp/server-stdio.js

@@ -231,7 +231,7 @@ const {
   finalizeSession: finalizeFeedbackSession,
 } = require('../../scripts/feedback-session');
 
-const SERVER_INFO = { name: 'thumbgate-mcp', version: '1.27.20' };
+const SERVER_INFO = { name: 'thumbgate-mcp', version: '1.28.1' };
 const COMMERCE_CATEGORIES = [
   'product_recommendation',
   'brand_compliance',
@@ -1430,22 +1430,14 @@ function writeNdjsonResponse(id, payload, error = null) {
   process.stdout.write(`${body}\n`);
 }
 
-/**
- * Default staleness threshold: if a lock is older than this (ms), the holder
- * is considered orphaned even if its PID is still alive — it likely belongs
- * to a defunct Claude Code session whose process was never reaped.
- */
-const LOCK_STALE_MS = Number(process.env.THUMBGATE_LOCK_STALE_MS) || 2 * 60 * 60 * 1000; // 2 hours
-
 /**
  * Acquire a file-system lock to prevent duplicate MCP server instances.
- * Returns { lockFile, cleanupLock } on success, or calls process.exit(1)
- * if another live server holds the lock.
+ * Returns { lockFile, cleanupLock } on success.
  *
- * Staleness reaping: if the lock-holding process is alive but the lock is
- * older than LOCK_STALE_MS, the holder is killed (SIGTERM) and the lock is
- * reclaimed. This prevents orphaned `thumbgate serve` processes from permanently
- * blocking new sessions.
+ * Every live stdio client needs its own MCP process, and those sessions can
+ * legitimately run for many hours. A lock's age is therefore not evidence that
+ * its owner is orphaned. Live owners coexist through per-session locks; only a
+ * lock whose PID is no longer running is reclaimed.
  */
 function acquireLock() {
   const feedbackDir = getFeedbackPaths().FEEDBACK_DIR;
@@ -1458,26 +1450,19 @@ function acquireLock() {
       try { process.kill(lockData.pid, 0); isRunning = true; } catch { /* process is dead */ }
 
       if (isRunning) {
-        const lockAge = Date.now() - new Date(lockData.startedAt).getTime();
-        if (lockAge > LOCK_STALE_MS) {
-          // Orphaned process — kill it and take over
-          process.stderr.write(`[thumbgate] Lock held by PID ${lockData.pid} is ${Math.round(lockAge / 60000)}m old (threshold: ${Math.round(LOCK_STALE_MS / 60000)}m). Reaping orphaned process.\n`);
-          try { process.kill(lockData.pid, 'SIGTERM'); } catch { /* already gone */ }
-        } else {
-          // Another session's MCP server is running — coexist via per-session lock.
-          // Each Claude session communicates via its own stdio pipe and needs its own server.
-          // SQLite WAL mode handles concurrent access safely.
-          process.stderr.write(`[thumbgate] Another MCP server (PID ${lockData.pid}) is running for ${feedbackDir}. Starting concurrent session.\n`);
-          const sessionLockFile = path.join(feedbackDir, `.mcp-server-${process.pid}.lock`);
-          fs.writeFileSync(sessionLockFile, JSON.stringify({ pid: process.pid, startedAt: new Date().toISOString() }));
-          const cleanupSessionLock = () => { try { fs.unlinkSync(sessionLockFile); } catch { /* already removed */ } };
-          process.on('exit', cleanupSessionLock);
-          process.on('SIGTERM', () => { cleanupSessionLock(); process.exit(0); });
-          process.on('SIGINT', () => { cleanupSessionLock(); process.exit(0); });
-          return { lockFile: sessionLockFile, cleanupLock: cleanupSessionLock };
-        }
+        // Another session's MCP server is running — coexist via per-session lock.
+        // Each client communicates via its own stdio pipe and needs its own server.
+        // SQLite WAL mode handles concurrent access safely.
+        process.stderr.write(`[thumbgate] Another MCP server (PID ${lockData.pid}) is running for ${feedbackDir}. Starting concurrent session.\n`);
+        const sessionLockFile = path.join(feedbackDir, `.mcp-server-${process.pid}.lock`);
+        fs.writeFileSync(sessionLockFile, JSON.stringify({ pid: process.pid, startedAt: new Date().toISOString() }));
+        const cleanupSessionLock = () => { try { fs.unlinkSync(sessionLockFile); } catch { /* already removed */ } };
+        process.on('exit', cleanupSessionLock);
+        process.on('SIGTERM', () => { cleanupSessionLock(); process.exit(0); });
+        process.on('SIGINT', () => { cleanupSessionLock(); process.exit(0); });
+        return { lockFile: sessionLockFile, cleanupLock: cleanupSessionLock };
       }
-      // Stale lock from a dead or reaped process — remove it
+      // Stale lock from a dead process — remove it.
       try { fs.unlinkSync(lockFile); } catch { /* already gone */ }
       process.stderr.write(`[thumbgate] Removed stale lock (PID ${lockData.pid} is no longer running).\n`);
     }

package/adapters/opencode/opencode.json

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

package/bin/cli.js

@@ -134,7 +134,7 @@ function upgradeNudge() {
     '\n  Team rollout: start with the $499 Workflow Hardening Diagnostic\n' +
     `  ${diagnosticUrl}\n` +
     `\n  Solo side lane: Pro — ${PRO_PRICE_LABEL}\n` +
-    '  Keeps lessons, rules, and the dashboard synced across machines and agent runtimes.\n' +
+    '  Removes solo caps; adds personal recall, dashboard proof, exports, and managed adapters.\n' +
     `  ${pricingUrl}\n\n`
   );
 }
@@ -234,9 +234,9 @@ function proNudge(context) {
   const checkoutUrl = checkoutUrlFor('cli_nudge', context || COMMAND || 'general');
   const pricingUrl = pricingUrlFor('cli_nudge', context || COMMAND || 'general');
   const messages = [
-    `\n  💡 Pro (${PRO_PRICE_LABEL}): keep lessons, rules, and dashboard state synced across machines and agent runtimes.\n     See pricing: ${pricingUrl}\n`,
-    `\n  💡 You just taught ThumbGate something locally. Pro keeps that lesson alive on every laptop, CI box, and agent runtime.\n     See pricing: ${pricingUrl}\n`,
-    `\n  💡 ThumbGate Pro syncs lessons/rules across Claude, Codex, Cursor, containers, and CI. ${PRO_PRICE_LABEL}.\n     Start Pro: ${checkoutUrl}\n`,
+    `\n  💡 Pro (${PRO_PRICE_LABEL}): personal recall, dashboard proof, exports, and managed adapters.\n     See pricing: ${pricingUrl}\n`,
+    `\n  💡 You just taught ThumbGate something locally. Pro keeps personal lessons searchable and exportable without free-tier caps.\n     See pricing: ${pricingUrl}\n`,
+    `\n  💡 ThumbGate Pro maintains adapter coverage across Claude, Codex, Cursor, containers, and CI. ${PRO_PRICE_LABEL}.\n     Start Pro: ${checkoutUrl}\n`,
   ];
   // Rotate message daily — no Math.random (security policy)
   const msg = messages[Math.floor(Date.now() / 86400000) % messages.length];
@@ -921,7 +921,7 @@ function init(cliArgs = parseArgs(process.argv.slice(3))) {
     console.log('Scaffold ThumbGate in the current project and wire detected agent integrations.');
     console.log('');
     console.log('Options:');
-    console.log('  --agent <name>           Wire a specific agent: claude-code, codex, gemini, amp, cursor, cline');
+    console.log('  --agent <name>           Wire a specific agent: claude-code, codex, gemini, amp, cursor, cline, opencode');
     console.log('  --wire-hooks             Wire hooks only; do not scaffold project files');
     console.log('  --email <email>          Subscribe installer to the setup guide and trial reminders');
     console.log('  --dry-run                Show hook changes without writing them');
@@ -1593,6 +1593,7 @@ function pro() {
   trackEvent('cli_pro_view', { command: 'pro' });
   const args = parseArgs(process.argv.slice(3));
   const {
+    notifyHostedProActivation,
     resolveProKey,
     saveLicense,
     startLocalProDashboard,
@@ -1606,9 +1607,10 @@ function pro() {
     console.log('Self-serve side lane today: Pro ($19/mo or $149/yr).');
     console.log('Every licensed Pro user gets a personal local dashboard on localhost.');
     console.log('\nWhat is available:');
-    console.log('  - Hosted sync: keep lessons, rules, and dashboard state aligned across laptops, CI, containers, and agent runtimes');
+    console.log('  - Personal recall: search lessons, rules, and proof');
     console.log('  - Local Pro dashboard: your own browser dashboard for search, gates, and DPO export');
-    console.log('  - Team rollout path: shared hosted lessons, org visibility, and workflow proof');
+    console.log('  - Managed adapters: Claude Code, Cursor, Codex, Gemini, Amp, Cline, OpenCode');
+    console.log('  - Team rollout path: Enterprise adds shared hosted lessons, org visibility, workflow proof');
     console.log('  - Commercial truth doc: source of truth for traction, pricing, and proof claims');
     console.log('\nLinks:');
     console.log(`  Buy Pro         : ${PRO_CHECKOUT_URL}`);
@@ -1661,7 +1663,22 @@ function pro() {
     console.log('\n✅ Pro license activated!');
     console.log(`   Key saved to: ${licensePath}`);
     console.log('   Launching your personal local dashboard...\n');
-    return launchDashboard(license.key, 'pro_activate');
+    return notifyHostedProActivation({
+      key: license.key,
+      source: 'cli_pro_activate',
+      version: license.version,
+    })
+      .then((notificationResult) => {
+        appendLocalTelemetry({
+          eventType: 'pro_activation_alert',
+          version: license.version,
+          timestamp: new Date().toISOString(),
+          notified: Boolean(notificationResult && notificationResult.notified),
+          sent: Boolean(notificationResult && notificationResult.alert && notificationResult.alert.sent),
+          reason: notificationResult && notificationResult.reason ? notificationResult.reason : null,
+        });
+        return launchDashboard(license.key, 'pro_activate');
+      });
   }
 
   if (args.upgrade) {
@@ -2678,23 +2695,27 @@ function install() {
 }
 
 async function gateCheck() {
-  // Explicit emergency escape hatch ONLY. The 2026-06-03 hotfix made this
-  // bypass-by-default, which silently disabled ThumbGate's enforcement entirely
-  // (the firewall approved everything). Restored 2026-06-04: enforcement runs by
-  // default in warn-by-default posture (see gates-engine applyEnforcementPosture);
-  // set THUMBGATE_HOTFIX_BYPASS=1 to disable all checks if a gate ever misfires.
-  if (process.env.THUMBGATE_HOTFIX_BYPASS === '1') {
-    process.stdout.write(JSON.stringify({
-      decision: 'approve',
-      reason: 'hotfix-bypass-opt-in',
-      hookSpecificOutput: { hookEventName: 'PreToolUse', additionalContext: '' }
-    }) + '\n');
-    return;
-  }
   try {
     const payload = readStdinText();
     const input = payload ? JSON.parse(payload) : {};
     const gatesEngine = require(path.join(PKG_ROOT, 'scripts', 'gates-engine'));
+
+    // The operator bypass only skips advisory and strict-mode gates. Security and
+    // self-protection floors are evaluated before the early approval path.
+    if (process.env.THUMBGATE_HOTFIX_BYPASS === '1') {
+      const hardFloorOutput = gatesEngine.runHardFloor(input);
+      if (hardFloorOutput) {
+        process.stdout.write(hardFloorOutput + '\n');
+        return;
+      }
+      process.stdout.write(JSON.stringify({
+        decision: 'approve',
+        reason: 'operator-bypass-opt-in',
+        hookSpecificOutput: { hookEventName: 'PreToolUse', additionalContext: '' }
+      }) + '\n');
+      return;
+    }
+
     const output = await gatesEngine.runAsync(input);
     process.stdout.write(output + '\n');
   } catch (err) {
@@ -2732,11 +2753,18 @@ function statuslineRender() {
 
 function hookAutoCapture() {
   syncActiveProjectContext();
+  const { extractPromptEnvelope } = require(path.join(PKG_ROOT, 'scripts', 'feedback-sanitizer'));
+  const rawStdin = readStdinText();
+  const promptEnvelope = extractPromptEnvelope(rawStdin);
+  // stdin on a UserPromptSubmit hook is the JSON payload
+  // {session_id, transcript_path, cwd, prompt, ...}. Persist ONLY the human
+  // `.prompt` field — never the whole stdin object — so session metadata blobs
+  // can't be promoted as lessons.
   const prompt = process.env.CLAUDE_USER_PROMPT
     || process.env.THUMBGATE_USER_PROMPT
     || process.env.CODEX_USER_PROMPT
     || process.env.USER_PROMPT
-    || readStdinText().trim();
+    || 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'));
@@ -2749,25 +2777,39 @@ function hookAutoCapture() {
     })
   );
 
-  recordConversationEntry({
-    author: 'user',
-    text: prompt,
-    source: 'claude_user_prompt',
-  });
-
   const guardResult = evaluatePromptGuard(prompt);
   if (guardResult) {
+    recordConversationEntry({
+      author: 'user',
+      text: prompt,
+      source: 'claude_user_prompt',
+    });
     process.stdout.write(`${JSON.stringify(guardResult)}\n`);
     return;
   }
 
   const detected = detectFeedbackSignal(prompt);
   if (!detected) {
+    recordConversationEntry({
+      author: 'user',
+      text: prompt,
+      source: 'claude_user_prompt',
+    });
     return;
   }
 
   const signal = detected.signal;
   const conversationWindow = readRecentConversationWindow({ limit: 8 });
+  const { buildFeedbackSourceIdentity } = require(path.join(PKG_ROOT, 'scripts', 'feedback-loop'));
+  const sourceEvent = buildFeedbackSourceIdentity({
+    signal,
+    promptText: prompt,
+    sessionId: promptEnvelope.sessionId || process.env.CLAUDE_SESSION_ID,
+    promptId: promptEnvelope.promptId,
+    projectDir: promptEnvelope.projectDir || CWD,
+    timestamp: promptEnvelope.timestamp,
+    source: 'claude-user-prompt',
+  });
   const result = processInlineFeedback({
     signal,
     context: prompt,
@@ -2776,7 +2818,15 @@ function hookAutoCapture() {
       : undefined,
     whatWentWrong: signal === 'down' ? prompt : undefined,
     whatWorked: signal === 'up' ? prompt : undefined,
+    sourceEvent,
   });
+  if (!result.feedbackResult || !result.feedbackResult.duplicate) {
+    recordConversationEntry({
+      author: 'user',
+      text: prompt,
+      source: 'claude_user_prompt',
+    });
+  }
   process.stdout.write(formatCliOutput(result) + '\n');
 }
 
@@ -3930,53 +3980,6 @@ switch (COMMAND) {
   case 'dispatch-brief':
     dispatchBrief();
     break;
-  case 'gate-check': {
-    // PreToolUse hook interface: reads tool call JSON from stdin, outputs gate verdict
-    // Used by: generate-pretool-hook.sh → npx thumbgate gate-check
-    const { run: gateRun, runAsync: gateRunAsync } = require(path.join(PKG_ROOT, 'scripts', 'gates-engine'));
-    const { evaluateSelfProtection } = require(path.join(PKG_ROOT, 'scripts', 'self-protection'));
-    let stdinData = '';
-    process.stdin.setEncoding('utf8');
-    process.stdin.on('data', (chunk) => { stdinData += chunk; });
-    process.stdin.on('end', async () => {
-      try {
-        const input = JSON.parse(stdinData);
-        const output = await gateRunAsync(input);
-        // Self-protection overlay (2026-07-08): the gate engine only denies edits
-        // to ThumbGate's own governance files under strict enforcement; by default
-        // such edits pass as a clean ALLOW. Surface them (or block in strict) so an
-        // agent can't silently disable the firewall. Only overlays when the engine
-        // did not already produce a hard deny.
-        let verdict = output;
-        try {
-          const parsed = JSON.parse(output || '{}');
-          const alreadyDeny = (parsed.hookSpecificOutput && parsed.hookSpecificOutput.permissionDecision === 'deny')
-            || parsed.decision === 'block';
-          if (!alreadyDeny) {
-            const sp = evaluateSelfProtection(input.tool_name, input.tool_input);
-            if (sp && sp.action === 'block') {
-              verdict = JSON.stringify({
-                decision: 'block',
-                reason: sp.message,
-                hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: sp.message },
-              });
-            } else if (sp && sp.action === 'warn') {
-              verdict = JSON.stringify({
-                hookSpecificOutput: { hookEventName: 'PreToolUse', additionalContext: sp.message },
-              });
-            }
-          }
-        } catch (_e) { /* non-JSON engine output: pass through unchanged */ }
-        process.stdout.write(verdict + '\n');
-        process.exit(0);
-      } catch (err) {
-        process.stderr.write(`gate-check error: ${err.message}\n`);
-        process.stdout.write(JSON.stringify({}) + '\n');
-        process.exit(0);
-      }
-    });
-    break;
-  }
   case 'hermes-gate': {
     // Nous Research Hermes Agent `pre_tool_call` shell hook.
     // Hermes pipes each pending tool call as JSON to stdin and reads a decision from stdout;
@@ -3987,7 +3990,7 @@ switch (COMMAND) {
     // Hermes `pre_tool_call` is binary (block or allow) with no warn channel, and the whole point
     // of wiring it is to gate, so we run STRICT enforcement by default — otherwise ThumbGate's
     // warn-by-default posture would pass every deny through and the hook would block nothing.
-    // Opt out with THUMBGATE_HERMES_WARN_ONLY=1; THUMBGATE_HOTFIX_BYPASS=1 still disables checks.
+    // Opt out with THUMBGATE_HERMES_WARN_ONLY=1; the operator bypass also leaves ordinary gates advisory.
     // Wire it in ~/.hermes/config.yaml — see adapters/hermes/config.yaml.
     if (process.env.THUMBGATE_HERMES_WARN_ONLY !== '1' && process.env.THUMBGATE_HOTFIX_BYPASS !== '1') {
       process.env.THUMBGATE_STRICT_ENFORCEMENT = '1';
@@ -3999,8 +4002,22 @@ switch (COMMAND) {
     process.stdin.on('end', async () => {
       try {
         const payload = JSON.parse(hermesStdin);
-        // Hermes sends snake_case tool_name/tool_input — gates-engine reads these directly.
-        const verdict = await hermesGateRun({ tool_name: payload.tool_name, tool_input: payload.tool_input });
+        const hermesToolName = String(payload.tool_name || '');
+        const canonicalToolNames = {
+          terminal: 'Bash',
+          process: 'Bash',
+          execute_code: 'Bash',
+          patch: 'Edit',
+          write_file: 'Write',
+          read_file: 'Read',
+        };
+        const verdict = await hermesGateRun({
+          tool_name: canonicalToolNames[hermesToolName] || hermesToolName,
+          tool_input: {
+            ...(payload.tool_input || {}),
+            hermes_tool_name: hermesToolName,
+          },
+        });
         let parsed = {};
         try { parsed = JSON.parse(verdict); } catch (_e) { parsed = {}; }
         const hso = parsed.hookSpecificOutput || {};

package/bin/postinstall.js

@@ -36,7 +36,7 @@ process.stderr.write(`
   ╰─────────────────────────────────────────────────────╯
 
   Trial unlocks: unlimited rules, lesson search, DPO export,
-  hosted dashboard. After 7 days, free tier limits apply.
+  and personal dashboard proof. After 7 days, free tier limits apply.
   Subscribe for the 5-min setup guide + weekly tips:
   npx thumbgate subscribe you@company.com
 

package/config/entitlement-public-keys.json

@@ -0,0 +1,6 @@
+{
+  "activeKid": "tgk_fd49d8ab2055",
+  "keys": {
+    "tgk_fd49d8ab2055": "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAEBVF8rLha9zsIhuiZ0CCslJK0SuCG6HL/bWXbkYVRiA=\n-----END PUBLIC KEY-----\n"
+  }
+}

package/config/gates/default.json

@@ -210,7 +210,7 @@
     {
       "id": "deny-network-egress",
       "layer": "Cloud",
-      "pattern": "curl\\s|wget\\s|fetch\\(|https?://(?!github\\.com|registry\\.npmjs\\.org|api\\.anthropic\\.com)",
+      "pattern": "fetch\\(|https?://(?!(?:github\\.com|registry\\.npmjs\\.org|api\\.anthropic\\.com|localhost|127\\.0\\.0\\.1|\\[::1\\]|0\\.0\\.0\\.0)(?:[:/?#]|$))|(?:curl|wget)\\s+(?:-\\S+\\s+)*(?!https?://|(?:github\\.com|registry\\.npmjs\\.org|api\\.anthropic\\.com|localhost|127\\.0\\.0\\.1|\\[::1\\]|0\\.0\\.0\\.0)(?:[:/?#]|$))[\\w.-]+\\.[a-z]{2,}",
       "action": "warn",
       "unless": "egress_approved",
       "message": "Potential unauthorized network egress detected.",
@@ -342,7 +342,7 @@
       "id": "self-protect-config",
       "layer": "Execution",
       "toolNames": ["Edit", "Write", "MultiEdit"],
-      "pattern": "(?:config/gates/|config/budget\\.json|\\.thumbgate/|thumbgate\\.json)",
+      "pattern": "(?:config/gates/|config/(?:budget|enforcement|mcp-allowlists)\\.json|\\.thumbgate/config\\.json|thumbgate\\.json)",
       "action": "block",
       "message": "Self-protection: agent cannot modify ThumbGate configuration, gate rules, or budget settings.",
       "severity": "critical",
@@ -372,7 +372,7 @@
       "id": "self-protect-hooks-disable",
       "layer": "Execution",
       "toolNames": ["Edit", "Write", "Bash"],
-      "pattern": "(?:settings\\.json|settings\\.local\\.json).*(?:hooks|PreToolUse|PostToolUse)",
+      "pattern": "(?:\\.claude/settings(?:\\.local)?\\.json|\\.codex/config\\.toml|scripts/hook-[^/]+\\.(?:js|sh))",
       "action": "block",
       "message": "Self-protection: agent cannot modify hook registrations.",
       "severity": "critical",

package/config/github-about.json

@@ -2,14 +2,11 @@
   "repo": "IgorGanapolsky/ThumbGate",
   "repositoryUrl": "https://github.com/IgorGanapolsky/ThumbGate",
   "homepageUrl": "https://thumbgate.ai",
-  "githubDescription": "Agent governance for ThumbGate: 👍/👎 become Pre-Action Checks that block repeat mistakes before code, money, or customer systems change.",
-  "metaDescription": "Stripe Connect integration engineering for ticketing and marketplace platforms — Pretix plugin shipped to Hilltown Media. ThumbGate is also the pre-action governance runtime for AI coding agents (Claude Code, Cursor, Codex, Gemini CLI): 👍 thumbs up and 👎 thumbs down feedback become history-aware lessons, shared lessons and org visibility, and PreToolUse checks that block repeated mistakes before code, money, or customer systems change. Perfect for vibe coding and human-in-the-loop workflows.",
+  "githubDescription": "ThumbGate Pre-Action Checks derive rules from repeated failures, flag risky tool calls, hard-block detected secret leaks, and block matches in strict mode.",
+  "metaDescription": "ThumbGate is the local pre-action governance runtime for AI coding agents (Claude Code, Cursor, Codex, Gemini CLI, Amp, Cline, OpenCode): accepted 👍 thumbs-up and 👎 thumbs-down feedback becomes history-aware local lessons; repeated failures can become prevention rules. PreToolUse checks flag and log risky tool calls, hard-block detected secret leaks, and block matching actions in strict mode. Pro is for individual operators; Enterprise rollout is scoped after intake.",
   "topics": [
     "thumbgate",
     "pre-action-checks",
-    "save-llm-tokens",
-    "reduce-llm-cost",
-    "ai-cost-optimization",
     "mcp",
     "mcp-server",
     "ai-agents",

package/config/merge-quality-checks.json

@@ -18,5 +18,8 @@
   "failingBuckets": [
     "fail",
     "cancel"
+  ],
+  "selfReferentialChecks": [
+    "Trunk Merge Queue (main)"
   ]
 }

package/config/post-deploy-marketing-pages.json

@@ -4,7 +4,7 @@
   "pages": [
     {
       "route": "/",
-      "sentinel": "Stop paying for the same AI mistake twice",
+      "sentinel": "Catch AI agents before they spend money",
       "description": "Home page hero (lifeblood — never regress)"
     },
     {

package/hooks/hooks.json

@@ -0,0 +1,38 @@
+{
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Bash|Edit|Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node",
+            "args": ["${CLAUDE_PLUGIN_ROOT}/scripts/hook-pre-tool-use.js"]
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node",
+            "args": ["${CLAUDE_PLUGIN_ROOT}/bin/cli.js", "hook-auto-capture"]
+          }
+        ]
+      }
+    ],
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node",
+            "args": ["${CLAUDE_PLUGIN_ROOT}/bin/cli.js", "session-start"]
+          }
+        ]
+      }
+    ]
+  }
+}