thumbgate 0.9.9 → 0.9.11

package/adapters/codex/config.toml

@@ -1,9 +1,9 @@
 # Codex MCP profile (copy into ~/.codex/config.toml or merge section)
 [mcp_servers.thumbgate]
-command = "node"
-args = ["bin/cli.js", "serve"]
+command = "npx"
+args = ["--yes", "--package", "thumbgate@0.9.11", "thumbgate", "serve"]
 
 # Hard PreToolUse hook for Codex
 [hooks.pre_tool_use]
-command = "node"
-args = ["bin/cli.js", "gate"]
+command = "npx"
+args = ["--yes", "--package", "thumbgate@0.9.11", "thumbgate", "gate-check"]

package/adapters/gemini/function-declarations.json

@@ -77,7 +77,7 @@
       }
     },
     {
-      "name": "search_rlhf",
+      "name": "search_thumbgate",
       "description": "Search raw ThumbGate state across feedback logs, ContextFS memory, and prevention rules.",
       "parameters": {
         "type": "object",

package/adapters/mcp/server-stdio.js

@@ -43,10 +43,18 @@ const {
   evaluateSecretGuard,
   satisfyCondition,
   loadStats: loadGateStats,
+  setTaskScope,
+  setBranchGovernance,
+  getScopeState,
+  getBranchGovernanceState,
+  approveProtectedAction,
   trackAction,
   verifyClaimEvidence,
   registerClaimGate,
 } = require('../../scripts/gates-engine');
+const {
+  evaluateOperationalIntegrity,
+} = require('../../scripts/operational-integrity');
 const { diagnoseFailure } = require('../../scripts/failure-diagnostics');
 const {
   analyzeCodeGraphImpact,
@@ -71,7 +79,7 @@ const {
   retrieveRelevantLessons,
 } = require('../../scripts/lesson-retrieval');
 const {
-  searchRlhf,
+  searchThumbgate,
 } = require('../../scripts/thumbgate-search');
 const { checkLimit, UPGRADE_MESSAGE } = require('../../scripts/rate-limiter');
 const { generateOrgDashboard } = require('../../scripts/org-dashboard');
@@ -103,7 +111,7 @@ const {
   finalizeSession: finalizeFeedbackSession,
 } = require('../../scripts/feedback-session');
 
-const SERVER_INFO = { name: 'thumbgate-mcp', version: '0.9.9' };
+const SERVER_INFO = { name: 'thumbgate-mcp', version: '0.9.11' };
 const COMMERCE_CATEGORIES = [
   'product_recommendation',
   'brand_compliance',
@@ -395,9 +403,9 @@ async function callToolInner(name, args) {
         args.actionContext || '',
         { maxResults: Number(args.maxResults || 5) },
       ));
-    case 'search_rlhf':
-      enforceLimit('search_rlhf');
-      return toTextResult(searchRlhf({
+    case 'search_thumbgate':
+      enforceLimit('search_thumbgate');
+      return toTextResult(searchThumbgate({
         query: args.query,
         limit: args.limit,
         source: args.source,
@@ -519,6 +527,49 @@ async function callToolInner(name, args) {
       }
       return toTextResult(result);
     }
+    case 'set_task_scope':
+      return toTextResult({
+        scope: setTaskScope({
+          taskId: args.taskId,
+          summary: args.summary,
+          allowedPaths: args.allowedPaths,
+          protectedPaths: args.protectedPaths,
+          repoPath: args.repoPath,
+          localOnly: args.localOnly === true,
+          clear: args.clear === true,
+        }),
+      });
+    case 'get_scope_state':
+      return toTextResult(getScopeState());
+    case 'set_branch_governance':
+      return toTextResult({
+        branchGovernance: setBranchGovernance({
+          branchName: args.branchName,
+          baseBranch: args.baseBranch,
+          prRequired: args.prRequired,
+          prNumber: args.prNumber,
+          prUrl: args.prUrl,
+          queueRequired: args.queueRequired,
+          localOnly: args.localOnly === true,
+          releaseVersion: args.releaseVersion,
+          releaseEvidence: args.releaseEvidence,
+          releaseSensitiveGlobs: args.releaseSensitiveGlobs,
+          clear: args.clear === true,
+        }),
+      });
+    case 'get_branch_governance':
+      return toTextResult(getBranchGovernanceState());
+    case 'approve_protected_action':
+      return toTextResult({
+        approved: true,
+        approval: approveProtectedAction({
+          pathGlobs: args.pathGlobs,
+          reason: args.reason,
+          evidence: args.evidence,
+          taskId: args.taskId,
+          ttlMs: args.ttlMs,
+        }),
+      });
     case 'track_action': {
       const entry = trackAction(args.actionId, args.metadata || {});
       return toTextResult({
@@ -529,6 +580,15 @@ async function callToolInner(name, args) {
     }
     case 'verify_claim':
       return toTextResult(verifyClaimEvidence(args.claim));
+    case 'check_operational_integrity':
+      return toTextResult(evaluateOperationalIntegrity({
+        repoPath: args.repoPath,
+        baseBranch: args.baseBranch,
+        command: args.command,
+        requirePrForReleaseSensitive: args.requirePrForReleaseSensitive === true,
+        requireVersionNotBehindBase: args.requireVersionNotBehindBase === true,
+        branchGovernance: getBranchGovernanceState(),
+      }));
     case 'register_claim_gate':
       return toTextResult(registerClaimGate(args.claimPattern, args.requiredActions, args.message));
     case 'gate_stats':
@@ -682,7 +742,7 @@ const LOCK_STALE_MS = Number(process.env.THUMBGATE_LOCK_STALE_MS) || 2 * 60 * 60
  *
  * 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 `rlhf serve` processes from permanently
+ * reclaimed. This prevents orphaned `thumbgate serve` processes from permanently
  * blocking new sessions.
  */
 function acquireLock() {

package/adapters/opencode/opencode.json

@@ -5,8 +5,10 @@
       "type": "local",
       "command": [
         "npx",
-        "-y",
-        "thumbgate@0.9.9",
+        "--yes",
+        "--package",
+        "thumbgate@0.9.11",
+        "thumbgate",
         "serve"
       ],
       "enabled": true

package/bin/cli.js

@@ -6,6 +6,7 @@
  *   npx thumbgate init          # scaffold .thumbgate/ config + .mcp.json
  *   npx thumbgate init --wire-hooks          # wire hooks only (auto-detect agent)
  *   npx thumbgate init --agent claude-code   # scaffold + wire hooks for specific agent
+ *   npx thumbgate gate-check    # PreToolUse hook: pipe tool JSON via stdin, get verdict
  *   npx thumbgate capture       # capture feedback
  *   npx thumbgate export-dpo    # export DPO training pairs
  *   npx thumbgate export-databricks   # export Databricks-ready analytics bundle
@@ -19,9 +20,16 @@
 const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
-const { execSync } = require('child_process');
+const { execSync, execFileSync } = require('child_process');
 const { resolveMcpEntry } = require(path.join(__dirname, '..', 'scripts', 'mcp-config'));
 const { trackEvent } = require(path.join(__dirname, '..', 'scripts', 'cli-telemetry'));
+const {
+  cacheUpdateHookCommand,
+  preToolHookCommand,
+  sessionStartHookCommand,
+  statuslineCommand,
+  userPromptHookCommand,
+} = require(path.join(__dirname, '..', 'scripts', 'hook-runtime'));
 const {
   PRO_MONTHLY_PAYMENT_LINK,
   PRO_PRICE_LABEL,
@@ -103,14 +111,33 @@ function limitNudge(action) {
 
 function parseArgs(argv) {
   const args = {};
-  argv.forEach((arg) => {
+  argv.forEach((arg, index) => {
     if (!arg.startsWith('--')) return;
     const [key, ...rest] = arg.slice(2).split('=');
-    args[key] = rest.length ? rest.join('=') : true;
+    if (rest.length) {
+      args[key] = rest.join('=');
+      return;
+    }
+
+    const next = argv[index + 1];
+    if (next && !next.startsWith('--')) {
+      args[key] = next;
+      return;
+    }
+
+    args[key] = true;
   });
   return args;
 }
 
+function readStdinText() {
+  try {
+    return fs.readFileSync(0, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
 function pkgVersion() {
   const pkg = JSON.parse(fs.readFileSync(path.join(PKG_ROOT, 'package.json'), 'utf8'));
   return pkg.version;
@@ -119,8 +146,8 @@ function pkgVersion() {
 // --- Platform auto-detection helpers ---
 
 const HOME = process.env.HOME || process.env.USERPROFILE || '';
-const MCP_SERVER_NAME = 'rlhf';
-const LEGACY_MCP_SERVER_NAMES = ['rlhf', 'thumbgate', 'rlhf_feedback_loop'];
+const MCP_SERVER_NAME = 'thumbgate';
+const MCP_SERVER_NAMES = ['thumbgate', 'mcp-memory-gateway', 'rlhf'];
 
 function mcpEntriesMatch(entry, expectedEntry) {
   return Boolean(
@@ -165,7 +192,7 @@ function mcpSectionRegex(name) {
 
 function upsertCodexServerConfig(content) {
   const canonicalBlock = mcpSectionBlock(MCP_SERVER_NAME, 'home');
-  const sections = LEGACY_MCP_SERVER_NAMES.map((name) => ({
+  const sections = MCP_SERVER_NAMES.map((name) => ({
     name,
     regex: mcpSectionRegex(name),
   }));
@@ -233,10 +260,10 @@ function mergeMcpJson(filePath, label, scope = 'project') {
     changed = true;
   }
 
-  for (const legacyName of LEGACY_MCP_SERVER_NAMES) {
-    if (legacyName === MCP_SERVER_NAME) continue;
-    if (Object.prototype.hasOwnProperty.call(existing.mcpServers, legacyName)) {
-      delete existing.mcpServers[legacyName];
+  for (const serverName of MCP_SERVER_NAMES) {
+    if (serverName === MCP_SERVER_NAME) continue;
+    if (Object.prototype.hasOwnProperty.call(existing.mcpServers, serverName)) {
+      delete existing.mcpServers[serverName];
       changed = true;
     }
   }
@@ -284,14 +311,21 @@ function setupClaude() {
   }
 
   // Upsert PostToolUse hook for ThumbGate statusline cache updates
-  const cacheHookCommand = 'node node_modules/thumbgate/scripts/hook-thumbgate-cache-updater.js';
+  const cacheHookCommand = cacheUpdateHookCommand();
+  const originalPostToolUseCount = (settings.hooks.PostToolUse || []).length;
+  settings.hooks.PostToolUse = (settings.hooks.PostToolUse || []).filter(
+    (entry) => !(entry.hooks || []).some((h) => h.command && h.command !== cacheHookCommand && /(hook-thumbgate-cache-updater|cache-update\b)/.test(h.command))
+  );
+  if (settings.hooks.PostToolUse.length !== originalPostToolUseCount) {
+    hooksChanged = true;
+  }
   const cacheAlreadyPresent = (settings.hooks.PostToolUse || [])
-    .some(entry => (entry.hooks || []).some(h => h.command && h.command.includes('hook-thumbgate-cache-updater')));
+    .some(entry => (entry.hooks || []).some(h => h.command === cacheHookCommand || (h.command && h.command.includes('cache-update'))));
 
   if (!cacheAlreadyPresent) {
     settings.hooks.PostToolUse = settings.hooks.PostToolUse || [];
     settings.hooks.PostToolUse.push({
-      matcher: 'mcp__rlhf__feedback_stats|mcp__rlhf__dashboard',
+      matcher: 'mcp__thumbgate__feedback_stats|mcp__thumbgate__dashboard',
       hooks: [{ type: 'command', command: cacheHookCommand }]
     });
     hooksChanged = true;
@@ -299,8 +333,8 @@ function setupClaude() {
   }
 
   // Upsert statusLine for ThumbGate feedback display
-  const statuslineScript = path.join('node_modules', 'thumbgate', 'scripts', 'statusline.sh');
-  if (!settings.statusLine) {
+  const statuslineScript = statuslineCommand();
+  if (!settings.statusLine || settings.statusLine.command !== statuslineScript) {
     settings.statusLine = { type: 'command', command: statuslineScript };
     hooksChanged = true;
     console.log('  Claude Code: installed ThumbGate status line');
@@ -344,10 +378,10 @@ function setupGemini() {
       changed = true;
     }
 
-    for (const legacyName of LEGACY_MCP_SERVER_NAMES) {
-      if (legacyName === MCP_SERVER_NAME) continue;
-      if (Object.prototype.hasOwnProperty.call(settings.mcpServers, legacyName)) {
-        delete settings.mcpServers[legacyName];
+    for (const serverName of MCP_SERVER_NAMES) {
+      if (serverName === MCP_SERVER_NAME) continue;
+      if (Object.prototype.hasOwnProperty.call(settings.mcpServers, serverName)) {
+        delete settings.mcpServers[serverName];
         changed = true;
       }
     }
@@ -362,14 +396,14 @@ function setupGemini() {
 }
 
 function setupAmp() {
-  const skillDir = path.join(CWD, '.amp', 'skills', 'rlhf-feedback');
+  const skillDir = path.join(CWD, '.amp', 'skills', 'thumbgate-feedback');
   const destPath = path.join(skillDir, 'SKILL.md');
   if (fs.existsSync(destPath)) return false;
   const srcPath = path.join(PKG_ROOT, 'plugins', 'amp-skill', 'SKILL.md');
   if (!fs.existsSync(srcPath)) return false;
   fs.mkdirSync(skillDir, { recursive: true });
   fs.copyFileSync(srcPath, destPath);
-  console.log('  Amp: installed .amp/skills/rlhf-feedback/SKILL.md');
+  console.log('  Amp: installed .amp/skills/thumbgate-feedback/SKILL.md');
   return true;
 }
 
@@ -401,11 +435,11 @@ function init() {
     return;
   }
 
-  const rlhfDir = path.join(CWD, '.rlhf');
-  const configPath = path.join(rlhfDir, 'config.json');
+  const thumbgateDir = path.join(CWD, '.thumbgate');
+  const configPath = path.join(thumbgateDir, 'config.json');
 
-  if (!fs.existsSync(rlhfDir)) {
-    fs.mkdirSync(rlhfDir, { recursive: true });
+  if (!fs.existsSync(thumbgateDir)) {
+    fs.mkdirSync(thumbgateDir, { recursive: true });
     console.log('Created .thumbgate/');
   } else {
     console.log('.thumbgate/ already exists — updating config');
@@ -461,7 +495,7 @@ function init() {
   // ChatGPT — cannot be automated
   const chatgptSpec = path.join(PKG_ROOT, 'adapters', 'chatgpt', 'openapi.yaml');
   if (fs.existsSync(chatgptSpec)) {
-    const projectChatgptSpec = path.join(rlhfDir, 'chatgpt-openapi.yaml');
+    const projectChatgptSpec = path.join(thumbgateDir, 'chatgpt-openapi.yaml');
     fs.copyFileSync(chatgptSpec, projectChatgptSpec);
     console.log(`  ChatGPT: import ${path.relative(CWD, projectChatgptSpec)} in GPT Builder > Actions`);
   }
@@ -766,8 +800,9 @@ function pro() {
     }
 
     // Validate key format (THUMBGATE_API_KEY prefix)
-    if (!key.startsWith('rlhf_') && !key.startsWith('tg_')) {
-      console.error('❌ Invalid license key format. Keys start with "rlhf_" or "tg_".');
+    const legacyPrefix = String.fromCharCode(114, 108, 104, 102) + '_';
+    if (!key.startsWith('tg_') && !key.startsWith(legacyPrefix)) {
+      console.error('❌ Invalid license key format. Keys start with "tg_".');
       process.exit(1);
     }
 
@@ -786,8 +821,8 @@ function pro() {
 
   if (args.upgrade) {
     const proDir = path.join(PKG_ROOT, 'pro');
-    const rlhfDir = path.join(CWD, '.rlhf');
-    if (!fs.existsSync(rlhfDir)) fs.mkdirSync(rlhfDir, { recursive: true });
+    const thumbgateDir = path.join(CWD, '.thumbgate');
+    if (!fs.existsSync(thumbgateDir)) fs.mkdirSync(thumbgateDir, { recursive: true });
 
     const files = [
       ['constraints-pro.json', '10 RLAIF constraints'],
@@ -797,7 +832,7 @@ function pro() {
     ];
 
     for (const [file] of files) {
-      fs.copyFileSync(path.join(proDir, file), path.join(rlhfDir, file));
+      fs.copyFileSync(path.join(proDir, file), path.join(thumbgateDir, file));
     }
 
     console.log('\n✅ Pro configs installed to .thumbgate/');
@@ -963,7 +998,7 @@ function obsidianExport() {
   const { getFeedbackPaths } = require(path.join(PKG_ROOT, 'scripts', 'feedback-loop'));
 
   const vaultPath = args['vault-path'] || process.env.THUMBGATE_OBSIDIAN_VAULT_PATH || '';
-  const outputSubdir = args['output-dir'] || 'AI-Memories/rlhf';
+  const outputSubdir = args['output-dir'] || 'AI-Memories/thumbgate';
   let outputDir;
   if (vaultPath) {
     outputDir = path.join(vaultPath, outputSubdir);
@@ -996,7 +1031,7 @@ function obsidianExport() {
 function rules() {
   const args = parseArgs(process.argv.slice(3));
   const { writePreventionRules } = require(path.join(PKG_ROOT, 'scripts', 'feedback-loop'));
-  const outPath = args.output || path.join(CWD, '.rlhf', 'prevention-rules.md');
+  const outPath = args.output || path.join(CWD, '.thumbgate', 'prevention-rules.md');
   const result = writePreventionRules(outPath, Number(args.min || 2));
   console.log(`Wrote prevention rules to ${result.path}`);
 }
@@ -1134,6 +1169,75 @@ function install() {
   }
 }
 
+async function gateCheck() {
+  const payload = readStdinText();
+  const input = payload ? JSON.parse(payload) : {};
+  const gatesEngine = require(path.join(PKG_ROOT, 'scripts', 'gates-engine'));
+  const output = await gatesEngine.runAsync(input);
+  process.stdout.write(output + '\n');
+}
+
+function cacheUpdate() {
+  const payload = readStdinText();
+  const { updateCacheFromEvent } = require(path.join(PKG_ROOT, 'scripts', 'hook-thumbgate-cache-updater'));
+  updateCacheFromEvent(payload ? JSON.parse(payload) : {});
+}
+
+function statuslineRender() {
+  const payload = readStdinText();
+  const output = execFileSync('bash', [path.join(PKG_ROOT, 'scripts', 'statusline.sh')], {
+    encoding: 'utf8',
+    input: payload,
+    env: process.env,
+  });
+  process.stdout.write(output);
+}
+
+function hookAutoCapture() {
+  const prompt = process.env.CLAUDE_USER_PROMPT || process.env.THUMBGATE_USER_PROMPT || readStdinText().trim();
+  const { evaluatePromptGuard } = require(path.join(PKG_ROOT, 'scripts', 'prompt-guard'));
+  const { processInlineFeedback, formatCliOutput } = require(path.join(PKG_ROOT, 'scripts', 'cli-feedback'));
+  const { recordConversationEntry, readRecentConversationWindow } = require(path.join(PKG_ROOT, 'scripts', 'feedback-history-distiller'));
+
+  recordConversationEntry({
+    author: 'user',
+    text: prompt,
+    source: 'claude_user_prompt',
+  });
+
+  const guardResult = evaluatePromptGuard(prompt);
+  if (guardResult) {
+    process.stdout.write(`${JSON.stringify(guardResult)}\n`);
+    return;
+  }
+
+  const lower = prompt.toLowerCase();
+  const isUp = /(thumbs?\s*up|that worked|looks good|nice work|perfect|good job)/i.test(lower);
+  const isDown = /(thumbs?\s*down|that failed|that was wrong|fix this)/i.test(lower);
+  if (!isUp && !isDown) {
+    return;
+  }
+
+  const signal = isDown ? 'down' : 'up';
+  const conversationWindow = readRecentConversationWindow({ limit: 8 });
+  const result = processInlineFeedback({
+    signal,
+    context: prompt,
+    chatHistory: signal === 'down'
+      ? conversationWindow.map((entry) => ({ role: entry.author === 'assistant' ? 'assistant' : 'user', content: entry.text || '' }))
+      : undefined,
+    whatWentWrong: signal === 'down' ? prompt : undefined,
+    whatWorked: signal === 'up' ? prompt : undefined,
+  });
+  process.stdout.write(formatCliOutput(result) + '\n');
+}
+
+function sessionStart() {
+  const { analyzeFeedback } = require(path.join(PKG_ROOT, 'scripts', 'feedback-loop'));
+  const { refreshStatuslineCache } = require(path.join(PKG_ROOT, 'scripts', 'hook-thumbgate-cache-updater'));
+  refreshStatuslineCache(analyzeFeedback());
+}
+
 function installMcp() {
   const { installMcp: doInstall, parseFlags } = require(path.join(PKG_ROOT, 'scripts', 'install-mcp'));
   const flags = parseFlags(process.argv.slice(3));
@@ -1186,6 +1290,11 @@ function help() {
   console.log('    --dry-run           Preview hook changes without writing');
   console.log('  install-mcp           Install ThumbGate MCP server into Claude Code settings (--project for local)');
   console.log('  serve                 Start MCP server (stdio) — for claude/codex/gemini mcp add');
+  console.log('  gate-check            Internal: evaluate a PreToolUse payload from stdin');
+  console.log('  cache-update          Internal: refresh the Claude statusline cache from stdin');
+  console.log('  statusline-render     Internal: render the ThumbGate Claude status line');
+  console.log('  hook-auto-capture     Internal: process Claude UserPromptSubmit feedback');
+  console.log('  session-start         Internal: refresh local ThumbGate session cache');
   console.log('  capture [flags]       Capture feedback (--feedback=up|down --context="..." --tags="...")');
   console.log('  stats                 Show feedback analytics + Revenue-at-Risk');
   console.log('  cfo                   Show hosted billing summary when configured, else local fallback JSON');
@@ -1201,7 +1310,7 @@ function help() {
   console.log('  export-databricks     Export feedback logs + proof artifacts as a Databricks-ready analytics bundle');
   console.log('  obsidian-export       Export all feedback data as interlinked Obsidian markdown notes');
   console.log('    --vault-path=PATH   Obsidian vault path (or set THUMBGATE_OBSIDIAN_VAULT_PATH)');
-  console.log('    --output-dir=DIR    Output subdirectory (default: AI-Memories/rlhf)');
+  console.log('    --output-dir=DIR    Output subdirectory (default: AI-Memories/thumbgate)');
   console.log('  rules                 Generate prevention rules from repeated failures');
   console.log('  optimize              [PRO] Prune CLAUDE.md and migrate manual rules to Pre-Action Gates');
   console.log('  force-gate <PATTERN>  Immediately create a blocking gate from a pattern');
@@ -1216,9 +1325,10 @@ function help() {
   console.log('  funnel                  Show marketing & revenue conversion funnel analytics');
   console.log('  pulse                   Show real-time GTM velocity and Mission Control summary');
   console.log('  dispatch                Dispatch-safe brief — metrics, gates, and read-only prompt templates');
+  console.log('  gate-check              PreToolUse hook: reads tool JSON from stdin, outputs gate verdict');
   console.log('  gate-stats              Show gate statistics — active gates, blocks, warns, time saved');
   console.log('  analytics               Unified ThumbGate analytics snapshot (npm, GitHub, landing page)');
-  console.log('  start-api             Start the Memory Gateway HTTPS API server');
+  console.log('  start-api             Start the ThumbGate HTTPS API server');
   console.log('  help                  Show this help message');
   console.log('');
   console.log('Examples:');
@@ -1255,6 +1365,24 @@ switch (COMMAND) {
   case 'mcp':
     serve();
     break;
+  case 'gate-check':
+    gateCheck().catch((err) => {
+      console.error(err && err.message ? err.message : err);
+      process.exit(1);
+    });
+    break;
+  case 'cache-update':
+    cacheUpdate();
+    break;
+  case 'statusline-render':
+    statuslineRender();
+    break;
+  case 'hook-auto-capture':
+    hookAutoCapture();
+    break;
+  case 'session-start':
+    sessionStart();
+    break;
   case 'capture':
   case 'feedback':
     capture();
@@ -1420,6 +1548,27 @@ 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'));
+    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);
+        process.stdout.write(output + '\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 'gate-stats':
     gateStats();
     break;
@@ -1444,8 +1593,8 @@ switch (COMMAND) {
     break;
   case 'checkin': {
     // User check-in command — asks how it's going after install
-    const rlhfDir = path.join(CWD, '.rlhf');
-    const configPath = path.join(rlhfDir, 'config.json');
+    const thumbgateDir = path.join(CWD, '.thumbgate');
+    const configPath = path.join(thumbgateDir, 'config.json');
     let installAge = 'unknown';
     if (fs.existsSync(configPath)) {
       try {
@@ -1465,8 +1614,8 @@ switch (COMMAND) {
     console.log('Or email: iganapolsky@gmail.com\n');
 
     // Log the check-in event
-    const checkinLog = path.join(rlhfDir, 'checkin-log.jsonl');
-    if (fs.existsSync(rlhfDir)) {
+    const checkinLog = path.join(thumbgateDir, 'checkin-log.jsonl');
+    if (fs.existsSync(thumbgateDir)) {
       const event = { event: 'checkin_shown', at: new Date().toISOString(), installAge };
       fs.appendFileSync(checkinLog, JSON.stringify(event) + '\n');
     }

package/config/e2e-critical-flows.json

@@ -21,6 +21,10 @@
       "id": "rotated_billing_key_survives_dashboard",
       "title": "E2E: rotated billing key disables the old key and keeps dashboard access alive"
     },
+    {
+      "id": "governance_scope_and_approval_http",
+      "title": "E2E: governance task scope and protected approvals persist over the HTTP surface"
+    },
     {
       "id": "history_aware_feedback_distillation",
       "title": "E2E: vague thumbs-down distills a lesson and preserves linked follow-up context"