thumbgate 1.29.2 → 1.30.0

package/scripts/gates-engine.js

@@ -146,10 +146,18 @@ const SELF_PROTECT_HARD_FLOOR_GATE_IDS = new Set([
   'self-protect-env-override',
   'self-protect-hooks-disable',
 ]);
+// An expired task-scope lease gets its OWN gate id so it can be exempted from the two downgrade
+// paths without touching ordinary task-scope denials. Without this the fail-closed guarantee is
+// cosmetic: applyEnforcementPosture turns denials into warnings by default, and applyDailyBlockCap
+// does the same for capped free-tier users — so an edit under a lapsed lease would execute anyway.
+// A lease that stops binding when you are busy or over quota is not a lease.
+const TASK_SCOPE_LEASE_EXPIRED_GATE_ID = 'task-scope-lease-expired';
+
 const UNCONDITIONAL_HARD_FLOOR_GATE_IDS = new Set([
   'secret-exfiltration',
   'security-vuln-scan',
   'slopsquat-guard',
+  TASK_SCOPE_LEASE_EXPIRED_GATE_ID,
   ...SELF_PROTECT_HARD_FLOOR_GATE_IDS,
 ]);
 // Issue #2782 (reported by Andy Martin, 2026-07-08): after the free-tier daily
@@ -161,6 +169,7 @@ const UNCONDITIONAL_HARD_FLOOR_GATE_IDS = new Set([
 // map directly to CLAUDE.md's own hard-block list and must never be subject
 // to the daily cap discount, regardless of tier or strict-mode setting.
 const CATASTROPHIC_DECLARATIVE_GATE_IDS = new Set([
+  TASK_SCOPE_LEASE_EXPIRED_GATE_ID,
   'force-push',
   'git-reset-hard',
   'git-clean-force',
@@ -425,6 +434,25 @@ function clampTtlMs(value, fallbackMs) {
   return Math.min(Math.max(numeric, 60 * 1000), 24 * 60 * 60 * 1000);
 }
 
+// Default lease when a caller asks for one without saying how long. clampTtlMs floors at 60s.
+const TASK_SCOPE_LEASE_MS = 15 * 60 * 1000;
+
+/**
+ * A task scope with no `expiresAt` is permanent — that is the historical contract and every
+ * existing scope on disk has it. Only a scope that explicitly took a lease can expire.
+ */
+function isTaskScopeExpired(taskScope, nowMs = Date.now()) {
+  if (!taskScope || typeof taskScope !== 'object') return false;
+  // `expiresAt: null` means permanent, and it MUST be checked before the numeric coercion:
+  // Number(null) is 0, not NaN, so a null deadline would otherwise read as "expired in 1970".
+  // Combined with fail-closed enforcement that would revoke authority from every permanent
+  // scope the moment this shipped. Caught by tests/task-scope-lease.test.js.
+  if (taskScope.expiresAt == null) return false;
+  const deadline = Number(taskScope.expiresAt);
+  if (!Number.isFinite(deadline)) return false;
+  return nowMs >= deadline;
+}
+
 function loadGovernanceState() {
   const raw = loadJSON(module.exports.GOVERNANCE_STATE_PATH);
   const state = {
@@ -438,6 +466,12 @@ function loadGovernanceState() {
       : null,
   };
   const now = Date.now();
+  // Annotate rather than delete. A vanished scope is indistinguishable from one never set, and
+  // the difference matters: "your lease lapsed, renew it" is a different instruction from
+  // "you never declared a scope".
+  if (state.taskScope) {
+    state.taskScope = { ...state.taskScope, expired: isTaskScopeExpired(state.taskScope, now) };
+  }
   const activeApprovals = state.protectedApprovals.filter((entry) => {
     if (!entry || typeof entry !== 'object') return false;
     if (!entry.timestamp || !entry.expiresAt) return false;
@@ -485,6 +519,11 @@ function setTaskScope(scopeInput = {}) {
       ? scopeInput.protectedPaths
       : DEFAULT_PROTECTED_FILE_GLOBS
   ), repoPath);
+  // Optional LEASE. Without ttlMs the scope is permanent, which is the historical behaviour
+  // and stays byte-identical. With ttlMs the scope becomes time-bounded authority: "write under
+  // ./src for 90 seconds" rather than a standing approval that never says when it stops.
+  const scopeNow = Date.now();
+  const leaseMs = scopeInput.ttlMs == null ? null : clampTtlMs(scopeInput.ttlMs, TASK_SCOPE_LEASE_MS);
   const taskScope = {
     taskId: String(scopeInput.taskId || '').trim() || null,
     summary: String(scopeInput.summary || '').trim() || null,
@@ -493,7 +532,9 @@ function setTaskScope(scopeInput = {}) {
     localOnly: scopeInput.localOnly === true,
     repoPath,
     createdAt: new Date().toISOString(),
-    timestamp: Date.now(),
+    timestamp: scopeNow,
+    leaseMs,
+    expiresAt: leaseMs == null ? null : scopeNow + leaseMs,
   };
   const state = loadGovernanceState();
   state.taskScope = taskScope;
@@ -1921,8 +1962,23 @@ function formatFileList(files, limit = 5) {
   return `${items.slice(0, limit).join(', ')} (+${items.length - limit} more)`;
 }
 
-function buildTaskScopeViolation(taskScope, affectedFiles) {
+function buildTaskScopeViolation(taskScope, affectedFiles, nowMs = Date.now()) {
   if (!Array.isArray(affectedFiles) || affectedFiles.length === 0) return null;
+  // EXPIRY FAILS CLOSED, and that direction is the whole point.
+  //
+  // A task scope is a restriction, so simply dropping it on expiry would make the agent MORE
+  // powerful the moment its lease ran out — expiry would remove a boundary instead of removing
+  // authority. A lease has to mean the opposite: while it is live you may work in these paths,
+  // and when it lapses the authority is gone until it is renewed.
+  if (taskScope && isTaskScopeExpired(taskScope, nowMs)) {
+    return {
+      reasonCode: 'expired_task_scope',
+      outsideFiles: affectedFiles.slice(),
+      allowedPaths: Array.isArray(taskScope.allowedPaths) ? taskScope.allowedPaths.slice() : [],
+      summary: taskScope.summary || null,
+      expiresAt: taskScope.expiresAt || null,
+    };
+  }
   if (!taskScope || !Array.isArray(taskScope.allowedPaths) || taskScope.allowedPaths.length === 0) {
     return {
       reasonCode: 'missing_task_scope',
@@ -1995,6 +2051,11 @@ function buildBranchGovernanceViolation(governanceState, toolInput = {}, affecte
 function buildGateMessage(gate, matchDetails) {
   if (matchDetails && matchDetails.taskScopeViolation) {
     const violation = matchDetails.taskScopeViolation;
+    if (violation.reasonCode === 'expired_task_scope') {
+      const lapsed = violation.expiresAt ? new Date(violation.expiresAt).toISOString() : 'unknown time';
+      return `The task-scope lease expired at ${lapsed}, so its authority no longer applies. `
+        + `Renew it with set_task_scope (allowed paths were: ${formatFileList(violation.allowedPaths)}).`;
+    }
     if (violation.reasonCode === 'missing_task_scope') {
       return `No task scope is declared for this high-risk action. Affected files: ${formatFileList(violation.outsideFiles)}.`;
     }
@@ -2760,7 +2821,13 @@ async function evaluateGatesAsyncInner(toolName, toolInput, configPath) {
     });
 
     if (gate.action === 'block') {
-      const denyResult = { decision: 'deny', gate: gate.id, message, severity: gate.severity, reasoning };
+      // Expired leases report under their own gate id so neither the enforcement posture nor
+      // the daily block cap can quietly turn this denial into a warning.
+      const gateId = matchDetails && matchDetails.taskScopeViolation
+        && matchDetails.taskScopeViolation.reasonCode === 'expired_task_scope'
+        ? TASK_SCOPE_LEASE_EXPIRED_GATE_ID
+        : gate.id;
+      const denyResult = { decision: 'deny', gate: gateId, message, severity: gate.severity, reasoning };
       // Free-tier daily block cap: after N blocks/day, deny → warn + upgrade CTA
       const cappedResult = applyDailyBlockCap(denyResult);
       if (cappedResult) {
@@ -2973,7 +3040,13 @@ function evaluateGatesInner(toolName, toolInput, configPath) {
     const reasoning = buildReasoning(gate, toolName, toolInput, matchDetails);
 
     if (gate.action === 'block') {
-      const denyResult = { decision: 'deny', gate: gate.id, message, severity: gate.severity, reasoning };
+      // Expired leases report under their own gate id so neither the enforcement posture nor
+      // the daily block cap can quietly turn this denial into a warning.
+      const gateId = matchDetails && matchDetails.taskScopeViolation
+        && matchDetails.taskScopeViolation.reasonCode === 'expired_task_scope'
+        ? TASK_SCOPE_LEASE_EXPIRED_GATE_ID
+        : gate.id;
+      const denyResult = { decision: 'deny', gate: gateId, message, severity: gate.severity, reasoning };
       // Free-tier daily block cap: after N blocks/day, deny → warn + upgrade CTA
       const cappedResult = applyDailyBlockCap(denyResult);
       if (cappedResult) {
@@ -3968,6 +4041,10 @@ module.exports = {
   loadGovernanceState,
   saveGovernanceState,
   setTaskScope,
+  isTaskScopeExpired,
+  TASK_SCOPE_LEASE_EXPIRED_GATE_ID,
+  applyEnforcementPosture,
+  buildTaskScopeViolation,
   setBranchGovernance,
   approveProtectedAction,
   breakGlassEmergency,

package/scripts/generate-case-study-outreach.js

@@ -0,0 +1,253 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * generate-case-study-outreach.js — buyer outreach pack from dogfood case studies.
+ *
+ * No fabricated customer logos. Packs are built from public case-study anchors
+ * with first-party UTMs for the cash path.
+ *
+ *   node scripts/generate-case-study-outreach.js --case=sudo-evasion
+ *   node scripts/generate-case-study-outreach.js --case=sudo-evasion --json
+ *   node scripts/generate-case-study-outreach.js --case=sudo-evasion --write
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const PROJECT_ROOT = path.resolve(__dirname, '..');
+const DEFAULT_OUT_DIR = path.join(PROJECT_ROOT, 'docs', 'proof', 'outreach');
+
+const CASES = Object.freeze({
+  'sudo-evasion': {
+    id: 'sudo-evasion',
+    title: 'A guardrail you could walk past with sudo',
+    anchor: 'sudo-evasion',
+    problem: 'Catastrophic PreToolUse gates matched the happy path but missed wrappers like `sudo rm -rf ~`.',
+    metric: '62 evasion holes → 0 on the published npm artifact',
+    result: 'Canonicalization + an adversarial grid (14 commands × 9 transforms) closed the class; CI + 6-hourly published-artifact jobs keep it closed.',
+    buyerPain: 'Your coding agent can re-spell a blocked command and walk past a regex denylist.',
+    ctaPrimary: 'diagnostic',
+    proofLinks: {
+      caseStudyPath: '/case-studies#sudo-evasion',
+      scorecardPath: '/eval-scorecard',
+      whitepaperPath: '/whitepaper',
+      diagnosticPath: '/diagnostic',
+      proPath: '/checkout/pro',
+    },
+  },
+  'fail-open': {
+    id: 'fail-open',
+    title: 'Production failure: a firewall enforcing nothing',
+    anchor: 'fail-open',
+    problem: 'A missing PreToolUse hook binary fails open — the product looked fine while blocking nothing.',
+    metric: 'Silent-gate canary + published-artifact deny checks',
+    result: 'Enforcement restored and verified with known-dangerous commands; silence is now treated as a P0 class.',
+    buyerPain: 'Green uptime does not mean your agent firewall is still firing.',
+    ctaPrimary: 'diagnostic',
+    proofLinks: {
+      caseStudyPath: '/case-studies#fail-open',
+      scorecardPath: '/eval-scorecard',
+      whitepaperPath: '/whitepaper',
+      diagnosticPath: '/diagnostic',
+      proPath: '/checkout/pro',
+    },
+  },
+});
+
+function parseArgs(argv = process.argv.slice(2)) {
+  const args = {
+    caseId: 'sudo-evasion',
+    json: false,
+    write: false,
+    help: false,
+    outDir: DEFAULT_OUT_DIR,
+    baseUrl: 'https://thumbgate.ai',
+  };
+  for (const arg of argv) {
+    if (arg === '--json') args.json = true;
+    else if (arg === '--write') args.write = true;
+    else if (arg === '--help' || arg === '-h') args.help = true;
+    else if (arg.startsWith('--case=')) args.caseId = arg.slice('--case='.length);
+    else if (arg.startsWith('--out-dir=')) args.outDir = path.resolve(arg.slice('--out-dir='.length));
+    else if (arg.startsWith('--base-url=')) args.baseUrl = arg.slice('--base-url='.length).replace(/\/$/, '');
+  }
+  return args;
+}
+
+function printHelp() {
+  console.log(`Usage: node scripts/generate-case-study-outreach.js --case=<id> [--write] [--json]
+
+Cases: ${Object.keys(CASES).join(', ')}
+`);
+}
+
+function withUtm(baseUrl, pathAndHash, campaign, content) {
+  const [pathname, hash = ''] = pathAndHash.split('#');
+  const url = new URL(pathname, baseUrl);
+  url.searchParams.set('utm_source', 'case_study_outreach');
+  url.searchParams.set('utm_medium', content);
+  url.searchParams.set('utm_campaign', campaign);
+  url.searchParams.set('cta_id', `${campaign}_${content}`);
+  const hashPart = hash ? `#${hash}` : '';
+  return `${url.toString()}${hashPart}`;
+}
+
+function buildPack(caseDef, options = {}) {
+  const baseUrl = options.baseUrl || 'https://thumbgate.ai';
+  const campaign = `case_${caseDef.id.replace(/-/g, '_')}`;
+  const links = {
+    caseStudy: withUtm(baseUrl, caseDef.proofLinks.caseStudyPath, campaign, 'case_study'),
+    scorecard: withUtm(baseUrl, caseDef.proofLinks.scorecardPath, campaign, 'scorecard'),
+    whitepaper: withUtm(baseUrl, caseDef.proofLinks.whitepaperPath, campaign, 'whitepaper'),
+    diagnostic: withUtm(baseUrl, caseDef.proofLinks.diagnosticPath, campaign, 'diagnostic'),
+    pro: withUtm(baseUrl, `${caseDef.proofLinks.proPath}`, campaign, 'pro'),
+  };
+
+  const linkedin = [
+    caseDef.buyerPain,
+    '',
+    `We dogfooded this on ThumbGate itself: ${caseDef.metric}.`,
+    caseDef.result,
+    '',
+    `Full write-up (no fabricated logos): ${links.caseStudy}`,
+    `Live bench scorecard: ${links.scorecard}`,
+    '',
+    `If one repeated AI-agent failure is already costing you, the $499 Diagnostic installs one hard gate with regression proof: ${links.diagnostic}`,
+  ].join('\n');
+
+  const email = [
+    `Subject: Your agent can walk past a regex denylist`,
+    '',
+    `Hi —`,
+    '',
+    caseDef.buyerPain,
+    '',
+    `Concrete proof from our own product loop (not a customer logo page):`,
+    `- ${caseDef.metric}`,
+    `- ${caseDef.result}`,
+    '',
+    `Case study: ${links.caseStudy}`,
+    `Scorecard: ${links.scorecard}`,
+    `White paper: ${links.whitepaper}`,
+    '',
+    `If you want this on one painful workflow this week: ${links.diagnostic}`,
+    `Self-serve Pro: ${links.pro}`,
+    '',
+    `— Igor`,
+  ].join('\n');
+
+  const reddit = [
+    `**Problem:** ${caseDef.problem}`,
+    '',
+    `**What we measured:** ${caseDef.metric}`,
+    '',
+    `**What fixed it:** ${caseDef.result}`,
+    '',
+    `Public case study (dogfood, not a fake logo wall): ${links.caseStudy}`,
+    `Bench scorecard: ${links.scorecard}`,
+  ].join('\n');
+
+  const markdown = [
+    `# Outreach pack — ${caseDef.title}`,
+    '',
+    `Case id: \`${caseDef.id}\``,
+    '',
+    '## Links (tracked)',
+    '',
+    `- Case study: ${links.caseStudy}`,
+    `- Scorecard: ${links.scorecard}`,
+    `- White paper: ${links.whitepaper}`,
+    `- Diagnostic $499: ${links.diagnostic}`,
+    `- Pro: ${links.pro}`,
+    '',
+    '## LinkedIn',
+    '',
+    linkedin,
+    '',
+    '## Email',
+    '',
+    '```',
+    email,
+    '```',
+    '',
+    '## Reddit / forum',
+    '',
+    reddit,
+    '',
+    '## Honesty',
+    '',
+    'First-party dogfood narrative only. Do not imply third-party customer endorsement.',
+    '',
+  ].join('\n');
+
+  return {
+    caseId: caseDef.id,
+    title: caseDef.title,
+    links,
+    channels: {
+      linkedin,
+      email,
+      reddit,
+    },
+    markdown,
+  };
+}
+
+function generate(options = {}) {
+  const caseId = options.caseId || 'sudo-evasion';
+  const caseDef = CASES[caseId];
+  if (!caseDef) {
+    throw new Error(`Unknown case id: ${caseId}. Known: ${Object.keys(CASES).join(', ')}`);
+  }
+  const pack = buildPack(caseDef, { baseUrl: options.baseUrl });
+  let outPath = null;
+  if (options.write) {
+    const outDir = options.outDir || DEFAULT_OUT_DIR;
+    fs.mkdirSync(outDir, { recursive: true });
+    outPath = path.join(outDir, `case-study-outreach-${caseId}.md`);
+    fs.writeFileSync(outPath, pack.markdown, 'utf8');
+  }
+  return { ...pack, outPath };
+}
+
+function main(argv = process.argv.slice(2)) {
+  const args = parseArgs(argv);
+  if (args.help) {
+    printHelp();
+    return 0;
+  }
+  const result = generate(args);
+  if (args.json) {
+    console.log(JSON.stringify({
+      caseId: result.caseId,
+      title: result.title,
+      links: result.links,
+      channels: result.channels,
+      outPath: result.outPath,
+    }, null, 2));
+  } else if (result.outPath) {
+    console.log(`Wrote ${result.outPath}`);
+  } else {
+    console.log(result.markdown);
+  }
+  return 0;
+}
+
+if (path.resolve(process.argv[1] || '') === path.resolve(__filename)) {
+  try {
+    process.exitCode = main();
+  } catch (err) {
+    console.error(err.message || err);
+    process.exitCode = 1;
+  }
+}
+
+module.exports = {
+  CASES,
+  parseArgs,
+  withUtm,
+  buildPack,
+  generate,
+  main,
+};