thumbgate 1.27.19 → 1.28.0

package/scripts/hook-stop-anti-claim.js

@@ -0,0 +1,301 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Stop hook: anti-claim enforcement.
+ *
+ * Scans the assistant's most recent turn (assistant text + same-turn tool_use
+ * blocks) and blocks the "deployed / live / done / fixed / ready" claim
+ * unless that same turn included a proof tool call (curl / grep / test).
+ *
+ * Why: CLAUDE.md anti-lying directive ("Never claim fix done until
+ * committed+pushed. Never claim 'ready' without running e2e.") was
+ * aspirational, not enforced. Per CEO 2026-05-13 feedback after a session in
+ * which 5+ unverified claims slipped through, this is the harness-level
+ * enforcement that ends the recurring trust-burn pattern. ThumbGate-on-
+ * ThumbGate dogfood — we are the prevention-rule generator and a perfect
+ * customer for our own gate.
+ *
+ * Wires through .claude/settings.json Stop hooks list. Always exits 0
+ * (informational): the goal is to surface a system reminder in the next
+ * turn so the agent corrects mid-conversation rather than to hard-block
+ * the turn that already happened.
+ *
+ * Stdin: Claude Code passes the hook payload as JSON on stdin. We read
+ * `transcript_path` to locate the JSONL session log and scan the last
+ * assistant message.
+ *
+ * Stdout: any text printed is shown to the agent on the next turn.
+ */
+
+const fs = require('node:fs');
+
+// Lie-phrase patterns. These match common "claim of completion" wording
+// the agent emits without verification. Word-boundary anchored to avoid
+// false positives ("ready-made", "live-streaming", etc).
+const CLAIM_PATTERNS = [
+  /\bis\s+live\b/i,
+  /\bnow\s+live\b/i,
+  /\bgoing\s+live\b/i,
+  /\bdeployed\b(?!\s*(yet|to\s+staging|on\s+a\s+branch))/i,
+  /\b(?:is|are|it'?s)\s+(?:now\s+)?(?:fully\s+)?(?:fixed|resolved|merged|shipped)\b/i,
+  /\bproduction[-\s]ready\b/i,
+  /\beverything\s+(?:is\s+)?(?:done|working|ready)\b/i,
+  /\b(?:github|repo|repository)\s+(?:about|metadata|description|topics?)\b.*\b(?:updated|verified|fixed|match(?:es|ed)?)\b/i,
+  /\b(?:about|metadata|description|topics?)\b.*\b(?:updated|verified|fixed|match(?:es|ed)?)\b.*\b(?:github|repo|repository)\b/i,
+  // Added 2026-06-11 after a cross-project failure analysis: these completion
+  // claims ("all green / stable / verified / race over / tests pass") were
+  // asserted without proof and slipped past the original set. The proof-gate
+  // below suppresses them whenever the SAME turn ran a verification tool, so a
+  // "verified" claim backed by a test/curl/Read stays silent.
+  /\b(?:all\s+)?(?:tests?|checks?|ci)\s+(?:are\s+)?(?:now\s+)?passing\b/i,
+  /\ball\s+(?:tests?|checks?)\s+pass(?:ed)?\b/i,
+  /\bverified\b/i,
+  /\bconfirmed\b/i,
+  /\b(?:is|are|it'?s|now)\s+stable\b/i,
+  /\ball\s+clear\b/i,
+  /\bgood\s+to\s+go\b/i,
+  /\brace\s+(?:is\s+)?over\b/i,
+  /\bno\s+longer\s+racing\b/i,
+];
+
+// Proof-of-verification patterns. If the SAME turn included one of these
+// tool calls or shell command tokens, the claim is considered backed and
+// the hook stays silent.
+const PROOF_PATTERNS = [
+  /\bcurl\b/,
+  /\bgh\s+pr\s+(?:view|checks|status)\b/,
+  /\bgh\s+run\s+view\b/,
+  /\bgh\s+api\b/,
+  /\bnode\s+--test\b/,
+  /\bnpm\s+(?:run\s+)?test\b/,
+  /\bnpm\s+pack\b/,
+  /\bjest\b/,
+  /\bmocha\b/,
+  /\bpytest\b/,
+  /\bplaywright\b/,
+  /\bgrep\b/,
+  /\bstripe\b/,
+  /\bplaid\b/,
+  /\bshopify\b/,
+  /\bsquare\b/,
+  /\bquickbooks\b/,
+  /Read\s*\(/, // Claude Code Read tool call
+  /Bash\s*\(/, // Claude Code Bash tool call
+];
+
+const COMMERCIAL_CLAIM_SUBJECTS = [
+  'money',
+  'payment',
+  'charge',
+  'checkout',
+  'revenue',
+  'price',
+  'pricing',
+  'invoice',
+  'billing',
+  'tax',
+  'sales tax',
+  'inventory',
+  'stock',
+  'permission',
+  'access',
+  'customer facing',
+];
+
+const COMMERCIAL_CLAIM_STATES = [
+  'correct',
+  'accurate',
+  'verified',
+  'valid',
+  'matches',
+  'working',
+  'fixed',
+  'resolved',
+  'calculated',
+  'configured',
+];
+
+const GREEN_CLAIM_PHRASES = [
+  'all green',
+  'all tests green',
+  'all checks green',
+  'all the tests green',
+  'all the checks green',
+  'all tests are green',
+  'all checks are green',
+];
+
+function normalizeClaimText(text) {
+  return String(text || '')
+    .toLowerCase()
+    .replace(/[-_]+/g, ' ')
+    .replace(/[^a-z0-9]+/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function containsPhrase(normalizedText, phrase) {
+  return ` ${normalizedText} `.includes(` ${phrase} `);
+}
+
+function findTokenListClaim(text, subjects, states, label) {
+  const normalized = normalizeClaimText(text);
+  if (!normalized) return null;
+  const subject = subjects.find((candidate) => containsPhrase(normalized, candidate));
+  const state = states.find((candidate) => containsPhrase(normalized, candidate));
+  return subject && state ? `${label}: ${subject} ${state}` : null;
+}
+
+function findGreenClaim(text) {
+  const normalized = normalizeClaimText(text);
+  return GREEN_CLAIM_PHRASES.find((phrase) => containsPhrase(normalized, phrase)) || null;
+}
+
+function readLastAssistantTurn(transcriptPath) {
+  if (!transcriptPath || !fs.existsSync(transcriptPath)) return null;
+  let content;
+  try {
+    content = fs.readFileSync(transcriptPath, 'utf8');
+  } catch {
+    return null;
+  }
+  const lines = content.trim().split('\n');
+  // Walk backwards to find the last assistant message
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const raw = lines[i].trim();
+    if (!raw) continue;
+    let entry;
+    try {
+      entry = JSON.parse(raw);
+    } catch {
+      continue;
+    }
+    if (entry.type === 'assistant' && entry.message) {
+      return entry.message;
+    }
+  }
+  return null;
+}
+
+function extractText(message) {
+  if (!message || !Array.isArray(message.content)) return '';
+  return message.content
+    .filter((b) => b && typeof b.text === 'string')
+    .map((b) => b.text)
+    .join('\n');
+}
+
+function extractToolUseSummary(message) {
+  if (!message || !Array.isArray(message.content)) return '';
+  return message.content
+    .filter((b) => b?.type === 'tool_use')
+    .map((b) => {
+      const name = b.name || 'tool';
+      let summary = '';
+      if (b.input && typeof b.input === 'object') {
+        if (typeof b.input.command === 'string') summary = b.input.command;
+        else if (typeof b.input.file_path === 'string') summary = b.input.file_path;
+        else if (typeof b.input.query === 'string') summary = b.input.query;
+        else summary = JSON.stringify(b.input).slice(0, 200);
+      }
+      return `${name}: ${summary}`;
+    })
+    .join('\n');
+}
+
+function findClaim(text) {
+  const commercialClaim = findTokenListClaim(
+    text,
+    COMMERCIAL_CLAIM_SUBJECTS,
+    COMMERCIAL_CLAIM_STATES,
+    'commercial truth',
+  );
+  if (commercialClaim) return commercialClaim;
+  const greenClaim = findGreenClaim(text);
+  if (greenClaim) return greenClaim;
+  for (const p of CLAIM_PATTERNS) {
+    const m = text.match(p);
+    if (m) return m[0];
+  }
+  return null;
+}
+
+function hasProof(combined) {
+  return PROOF_PATTERNS.some((p) => p.test(combined));
+}
+
+function readStdinSync() {
+  try {
+    return fs.readFileSync(0, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+function main() {
+  const raw = readStdinSync();
+  let payload = {};
+  try {
+    payload = raw ? JSON.parse(raw) : {};
+  } catch {
+    payload = {};
+  }
+
+  const transcriptPath = payload.transcript_path || process.env.CLAUDE_TRANSCRIPT_PATH;
+  const message = readLastAssistantTurn(transcriptPath);
+  if (!message) return; // no transcript visible; nothing to check
+
+  const text = extractText(message);
+  const toolUseSummary = extractToolUseSummary(message);
+  const claim = findClaim(text);
+  if (!claim) return; // no completion claim made; silent
+
+  const proofText = `${text}\n${toolUseSummary}`;
+  if (hasProof(proofText)) return; // claim backed by proof in same turn
+
+  // Strict mode (THUMBGATE_STRICT_ENFORCEMENT=1): hard-block the stop. Emit a
+  // Stop-hook block decision so Claude Code does NOT end the turn — the agent
+  // must run the verification (or retract) before it can stop. Default mode
+  // stays soft (a reminder for the next turn) so we don't break existing wiring.
+  if (process.env.THUMBGATE_STRICT_ENFORCEMENT === '1') {
+    const reason = `ThumbGate anti-claim gate (strict): you claimed completion ("${claim}") without a proof tool call in the same message. Run the verification (curl / grep / test / Read) and restate with the proof, or retract — do not end the turn on an unverified claim.`;
+    process.stdout.write(JSON.stringify({ decision: 'block', reason }) + '\n');
+    return;
+  }
+
+  // Default (soft): surface a system reminder for the NEXT turn. Do not hard-block.
+  const reminder = [
+    '⚠️ ThumbGate anti-claim gate: previous turn claimed completion',
+    `   ("${claim}") without a proof tool call in the same message.`,
+    '   Per CLAUDE.md anti-lying: never claim "done / live / deployed / fixed /',
+    '   verified / all green / stable" or commercial truth (money / tax / inventory /',
+    '   permissions / customer-facing state) without curl / grep / test / source-of-truth output in the SAME turn.',
+    '   If the work really is verified, re-state the claim with the proof.',
+    '   If not, retract and run the verification before re-asserting.',
+  ].join('\n');
+  process.stdout.write(reminder + '\n');
+}
+
+// Path-resolve check instead of `require.main === module`. SonarCloud's
+// strict type inference (rule S3403) flags the === form as always-false
+// in CommonJS, and CLAUDE.md "Hard-Won Lessons" pins the path-based form
+// as the portable fix (incident 2026-04-21 / PR #1115). Resolve BOTH sides
+// so the comparison is between two normalized absolute paths.
+const path = require('node:path');
+if (path.resolve(process.argv[1] || '') === path.resolve(__filename)) {
+  try {
+    main();
+  } catch {
+    // never crash the agent
+  }
+}
+
+module.exports = {
+  CLAIM_PATTERNS,
+  PROOF_PATTERNS,
+  findClaim,
+  hasProof,
+  extractText,
+  extractToolUseSummary,
+};

package/scripts/imperative-detector.js

@@ -0,0 +1,85 @@
+'use strict';
+
+/**
+ * imperative-detector.js — detect an explicit NEVER / ALWAYS directive in a
+ * feedback message so the CLI can OFFER immediate enforcement (force-gate) when
+ * the user clearly asked for it.
+ *
+ * Why this exists: auto-promotion is deliberately occurrence-gated (a rule
+ * blocks only after a pattern repeats) — that accumulate-evidence-before-you-
+ * enforce default is what makes ThumbGate trustworthy rather than a one-signal
+ * lockout. But when a user types "never do X again", that is an explicit intent
+ * to guard NOW. This module recognizes that intent and lets the CLI SURFACE the
+ * one-shot path (force-gate) as an offer. It never blocks on its own — the user
+ * still confirms. Detecting intent ≠ acting on it.
+ *
+ * Pure and deterministic: no state, no I/O.
+ */
+
+// A leading (or clause-initial) negative imperative → intent to forbid.
+const NEVER_RE = /(?:^|[.;:,]\s*)(never|do\s*not|don'?t|stop\s+\w|must\s*not|no\s+longer|quit\s+\w|avoid\s+\w)/i;
+// A leading (or clause-initial) positive imperative → intent to always do.
+const ALWAYS_RE = /(?:^|[.;:,]\s*)(always|make\s+sure|ensure\s+\w|be\s+sure\s+to)/i;
+
+function firstMeaningfulText(text) {
+  // Strip common feedback prefixes/quote marks so "❯ never …" still matches.
+  return String(text || '').trim().replace(/^[\s>❯"'`*-]+/, '');
+}
+
+/**
+ * @param {string} text
+ * @returns {{isImperative:boolean, polarity:('never'|'always'|null), directive:string}}
+ */
+function detectImperative(text) {
+  const t = firstMeaningfulText(text);
+  if (!t) return { isImperative: false, polarity: null, directive: '' };
+  // Negative wins if both appear — a forbid directive is the actionable one.
+  if (NEVER_RE.test(t)) return { isImperative: true, polarity: 'never', directive: t };
+  if (ALWAYS_RE.test(t)) return { isImperative: true, polarity: 'always', directive: t };
+  return { isImperative: false, polarity: null, directive: '' };
+}
+
+function shellQuote(text) {
+  return String(text).trim().slice(0, 140).replace(/"/g, "'").replace(/\s+/g, ' ');
+}
+
+/**
+ * Build a suggestion for the capture confirmation. Returns null when there's no
+ * explicit directive to act on.
+ * - down + "never …"  → OFFER immediate force-gate (the user asked to forbid it).
+ * - up   + "always …" → clarify it's stored as guidance, not a hard block.
+ * @param {{signal?:string, text?:string}} opts
+ * @returns {{kind:string, message:string}|null}
+ */
+function suggestForceGate({ signal, text } = {}) {
+  const isDown = signal === 'down' || signal === 'negative' || signal === 'thumbs_down';
+  const det = detectImperative(text);
+  if (!det.isImperative) return null;
+
+  if (isDown && det.polarity === 'never') {
+    const ctx = shellQuote(text);
+    return {
+      kind: 'force-gate-offer',
+      message: 'You said "never" — block this immediately instead of waiting for it to recur:\n'
+        + `    npx thumbgate force-gate --context="${ctx}" --action=block\n`
+        + '  (or run /thumbgate-guard). Left alone, it auto-promotes to a gate after the pattern repeats.',
+    };
+  }
+
+  if (!isDown && det.polarity === 'always') {
+    return {
+      kind: 'always-note',
+      message: 'You said "always" — stored as an ALWAYS guidance principle. '
+        + 'It is surfaced as context on future actions (guidance, not a hard block; positive patterns are not gate-enforced).',
+    };
+  }
+
+  return null;
+}
+
+module.exports = {
+  detectImperative,
+  suggestForceGate,
+  NEVER_RE,
+  ALWAYS_RE,
+};

package/scripts/install-shim.js

@@ -0,0 +1,87 @@
+'use strict';
+
+/**
+ * install-shim.js — Install a stable shim at ~/.thumbgate/bin/thumbgate-hook
+ *
+ * The shim is a tiny shell script that resolves the cached ThumbGate runtime
+ * first, so hook commands in settings.local.json stay stable across projects
+ * and agent restarts.
+ *
+ * The shim checks for a cached runtime binary first (fast path), and falls
+ * back to `npx --yes thumbgate@latest` (slow path, first-time self-install).
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const SHIM_DIR = path.join(os.homedir(), '.thumbgate', 'bin');
+const SHIM_PATH = path.join(SHIM_DIR, 'thumbgate-hook');
+const RUNTIME_BIN = path.join(os.homedir(), '.thumbgate', 'runtime', 'node_modules', '.bin', 'thumbgate');
+
+/**
+ * The shim script. Key design choices:
+ * - Uses `exec` to replace the shell process (no zombie processes)
+ * - Fast path: if cached runtime binary exists, exec it directly
+ * - Slow path: npx --yes thumbgate@latest (first-time auto-installs)
+ * - No default self-mutation: background upgrades are opt-in via
+ *   THUMBGATE_SHIM_AUTO_UPDATE=1 so source checkouts, enterprise pins, and
+ *   dogfood runtimes cannot be overwritten by a hook side effect.
+ */
+function shimContent() {
+  const escapedRuntimeBin = JSON.stringify(RUNTIME_BIN);
+  const escapedRuntimeDir = JSON.stringify(path.join(os.homedir(), '.thumbgate', 'runtime'));
+
+  return `#!/usr/bin/env bash
+# ThumbGate hook shim — DO NOT EDIT
+# Installed by: thumbgate init
+# Purpose: stable hook entry point that runs the cached ThumbGate runtime
+# Pattern: Volta-style stable shim (see https://volta.sh)
+
+set -euo pipefail
+
+RUNTIME_BIN=${escapedRuntimeBin}
+RUNTIME_DIR=${escapedRuntimeDir}
+
+# Fast path: cached runtime binary exists and is executable
+if [ -x "$RUNTIME_BIN" ]; then
+  # Optional background upgrade. Disabled by default so hooks never mutate a
+  # source checkout, enterprise pin, or dogfood runtime behind the operator's back.
+  if [ "\${THUMBGATE_SHIM_AUTO_UPDATE:-0}" = "1" ]; then
+    ( nohup npm install --prefix "$RUNTIME_DIR" --no-save --omit=dev thumbgate@latest >/dev/null 2>&1 & ) 2>/dev/null || true
+  fi
+  exec "$RUNTIME_BIN" "$@"
+fi
+
+# Slow path: no cached binary — install + exec via npx
+mkdir -p "$RUNTIME_DIR"
+exec npx --yes --package thumbgate@latest -- thumbgate "$@"
+`;
+}
+
+function installShim() {
+  fs.mkdirSync(SHIM_DIR, { recursive: true });
+  fs.writeFileSync(SHIM_PATH, shimContent(), { mode: 0o755 });
+  return SHIM_PATH;
+}
+
+function shimInstalled() {
+  try {
+    return fs.existsSync(SHIM_PATH) && (fs.statSync(SHIM_PATH).mode & 0o111) !== 0;
+  } catch {
+    return false;
+  }
+}
+
+function shimPath() {
+  return SHIM_PATH;
+}
+
+module.exports = {
+  installShim,
+  shimInstalled,
+  shimPath,
+  shimContent,
+  SHIM_DIR,
+  SHIM_PATH,
+};

package/scripts/intervention-policy.js

@@ -5,6 +5,7 @@ const fs = require('fs');
 const path = require('path');
 const { resolveFeedbackDir } = require('./feedback-paths');
 const { getDecisionLogPath, readDecisionLog, collapseDecisionTimeline } = require('./decision-journal');
+const { requireLearnedModelsEntitlement } = require('./entitlement');
 
 const LABELS = ['allow', 'recall', 'verify', 'warn', 'deny'];
 const DAY_MS = 24 * 60 * 60 * 1000;
@@ -551,6 +552,10 @@ function summarizeTopTokens(model, limit = 5) {
 }
 
 function trainInterventionPolicy(examples, options = {}) {
+  requireLearnedModelsEntitlement({
+    ...(options.entitlement || {}),
+    label: 'intervention-policy training',
+  });
   const split = splitExamples(examples);
   const evaluationModel = fitNaiveBayes(split.train);
   const deployedModel = fitNaiveBayes(examples);
@@ -631,6 +636,10 @@ function buildRuntimeCandidate(params = {}) {
 }
 
 function getInterventionRecommendation(params = {}, options = {}) {
+  requireLearnedModelsEntitlement({
+    ...(options.entitlement || {}),
+    label: 'intervention-policy recommendation',
+  });
   const resolvedDir = resolveFeedbackDir({ feedbackDir: options.feedbackDir || params.feedbackDir });
   let model = options.model || loadInterventionPolicy(resolvedDir);
   const candidate = options.candidate || buildRuntimeCandidate(params);
@@ -693,6 +702,10 @@ function computeDailySeries(examples, dayCount = 14) {
 }
 
 function getInterventionPolicySummary(feedbackDir, options = {}) {
+  requireLearnedModelsEntitlement({
+    ...(options.entitlement || {}),
+    label: 'intervention-policy summary',
+  });
   const resolvedDir = resolveFeedbackDir({ feedbackDir });
   const { examples, sourceCounts } = buildExamplesFromFeedbackDir(resolvedDir);
   const model = loadInterventionPolicy(resolvedDir) || trainInterventionPolicy(examples);