thumbgate 1.27.19 → 1.28.0

package/scripts/aws-blocks-guardrails.js

@@ -0,0 +1,272 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const AWS_BLOCKS_DEPENDENCY_PATTERN = /(^|\/)@aws-blocks\/(?:blocks|[^/\s"']+)/;
+const PRODUCTION_DEPLOY_PATTERNS = [
+  /\bcdk\s+deploy\b/i,
+  /\bnpm\s+run\s+deploy\b/i,
+  /\bpnpm\s+deploy\b/i,
+  /\byarn\s+deploy\b/i,
+  /\bsst\s+deploy\b/i,
+  /\bblocks?\s+deploy\b/i,
+];
+const DESTROY_PATTERNS = [
+  /\bcdk\s+destroy\b/i,
+  /\bnpm\s+run\s+destroy\b/i,
+  /\bpnpm\s+destroy\b/i,
+  /\byarn\s+destroy\b/i,
+  /\bsandbox\b.*--destroy\b/i,
+  /\b--destroy\b/i,
+  /\baws\s+cloudformation\s+delete-stack\b/i,
+];
+const DESTRUCTIVE_AWS_PATTERNS = [
+  /\baws\s+dynamodb\s+delete-table\b/i,
+  /\baws\s+rds\s+delete-db-instance\b/i,
+  /\baws\s+s3\s+rm\b[\s\S]*--recursive\b/i,
+  /\baws\s+lambda\s+delete-function\b/i,
+  /\baws\s+bedrock-agent\s+delete-/i,
+  /\baws\s+bedrock-agent-runtime\b/i,
+];
+
+function toList(value) {
+  if (Array.isArray(value)) return value.map(String).map((entry) => entry.trim()).filter(Boolean);
+  if (typeof value === 'string') return value.split(',').map((entry) => entry.trim()).filter(Boolean);
+  return [];
+}
+
+function normalizeText(value) {
+  if (value == null) return '';
+  if (typeof value === 'string') return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+
+function readPackageJson(projectDir) {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(projectDir, 'package.json'), 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function matchesAny(text, patterns) {
+  return patterns.some((pattern) => pattern.test(text));
+}
+
+function hasDestructiveSql(text) {
+  if (/\bdrop\s+(table|database|schema|index|column)\b/i.test(text)) return true;
+  if (/\btruncate\s+table\b/i.test(text)) return true;
+  if (/\bdelete\s+from\s+[\w".-]+(?:\s*;|\s*$)/i.test(text)) return true;
+  const updateMatch = /\bupdate\s+[\w".-]+\s+set\b/i.exec(text);
+  if (!updateMatch) return false;
+  const afterUpdate = text.slice(updateMatch.index, updateMatch.index + 180);
+  return !/\bwhere\b/i.test(afterUpdate);
+}
+
+function packageUsesAwsBlocks(pkg) {
+  if (!pkg || typeof pkg !== 'object') return false;
+  const dependencyText = JSON.stringify({
+    dependencies: pkg.dependencies || {},
+    devDependencies: pkg.devDependencies || {},
+    peerDependencies: pkg.peerDependencies || {},
+    optionalDependencies: pkg.optionalDependencies || {},
+  });
+  const scriptsText = JSON.stringify(pkg.scripts || {});
+  return AWS_BLOCKS_DEPENDENCY_PATTERN.test(dependencyText) || /aws-blocks|blocks-app|cdk|sandbox/i.test(scriptsText);
+}
+
+function detectAwsBlocksProject(projectDir = process.cwd()) {
+  const pkg = readPackageJson(projectDir);
+  if (packageUsesAwsBlocks(pkg)) return true;
+  return fs.existsSync(path.join(projectDir, 'aws-blocks', 'index.ts'))
+    || fs.existsSync(path.join(projectDir, 'aws-blocks', 'index.js'))
+    || fs.existsSync(path.join(projectDir, 'blocks.spec.json'));
+}
+
+function detectAction(input = {}) {
+  const command = normalizeText(input.command || input.args || input.shell || input.toolInput);
+  const toolName = normalizeText(input.toolName || input.tool || input.name);
+  const code = normalizeText(input.code || input.file || input.diff || input.body);
+  const combined = `${toolName}\n${command}\n${code}`;
+  const lower = combined.toLowerCase();
+
+  const signals = [];
+  const add = (id, label, severity = 'medium') => signals.push({ id, label, severity });
+
+  if (matchesAny(combined, PRODUCTION_DEPLOY_PATTERNS)) {
+    add('aws-blocks-production-deploy', 'production deploy from an AWS Blocks workflow', 'high');
+  }
+
+  if (matchesAny(combined, DESTROY_PATTERNS)) {
+    add('aws-blocks-destroy', 'destroy command can remove AWS resources created from local Blocks code', 'critical');
+  }
+
+  if (hasDestructiveSql(combined)) {
+    add('destructive-sql-or-ddl', 'destructive or unscoped SQL mutation', 'critical');
+  }
+
+  if (matchesAny(combined, DESTRUCTIVE_AWS_PATTERNS)) {
+    add('destructive-aws-cli', 'destructive AWS CLI or Bedrock agent action', 'critical');
+  }
+
+  if (/\b(gcloud|aws)\b[\s\S]{0,220}\b(add-iam-policy-binding|put-role-policy|attach-role-policy|create-policy-version)\b/i.test(combined)
+      || /\b(AdministratorAccess|roles\/owner|iam:PassRole|serviceAccountTokenCreator)\b/i.test(combined)) {
+    add('iam-escalation', 'agent session attempts to grant broad IAM authority', 'critical');
+  }
+
+  if (/\b(new\s+Agent\s*\(|@aws-blocks\/(?:agent|blocks)|\bAgent\b[\s\S]{0,120}\btools?\b)/.test(combined)) {
+    add('blocks-agent-tool-call', 'AWS Blocks Agent or Bedrock-style tool action needs a tool boundary', 'medium');
+  }
+
+  if (/\b(npm\s+run\s+dev|npm\s+start|pnpm\s+dev|yarn\s+dev|create-blocks-app)\b/i.test(combined)) {
+    add('local-dev', 'local AWS Blocks development loop', 'low');
+  }
+
+  return {
+    command,
+    toolName,
+    code,
+    signals,
+    highRisk: signals.some((signal) => ['high', 'critical'].includes(signal.severity)),
+    localOnly: signals.some((signal) => signal.id === 'local-dev') && signals.every((signal) => signal.severity === 'low'),
+    lower,
+  };
+}
+
+function evaluateAwsBlocksAction(input = {}) {
+  const projectDir = input.projectDir || input.cwd || process.cwd();
+  const projectUsesAwsBlocks = Boolean(
+    input.projectUsesAwsBlocks
+    || input.awsBlocks
+    || input.blocksProject
+    || detectAwsBlocksProject(projectDir)
+  );
+  const evidence = new Set(toList(input.evidence || input.proof || input.receipts));
+  const action = detectAction(input);
+  const requiredEvidence = [];
+
+  const requireEvidence = (id, label) => {
+    if (!evidence.has(id)) requiredEvidence.push({ id, label });
+  };
+
+  if (projectUsesAwsBlocks && action.signals.some((signal) => signal.id === 'aws-blocks-production-deploy')) {
+    requireEvidence('local-tests-pass', 'local AWS Blocks tests pass against local implementations');
+    requireEvidence('cdk-diff-reviewed', 'CDK diff or synthesized CloudFormation change set reviewed');
+    requireEvidence('cost-blast-radius-reviewed', 'AWS cost and resource blast radius reviewed');
+  }
+
+  if (action.signals.some((signal) => signal.id === 'aws-blocks-destroy')) {
+    requireEvidence('resource-inventory-exported', 'resource inventory exported before destroy');
+    requireEvidence('human-destroy-approval', 'named human approval for destroy');
+  }
+
+  if (action.signals.some((signal) => signal.id === 'destructive-sql-or-ddl')) {
+    requireEvidence('backup-or-rollback-ready', 'backup, rollback, or restore point exists');
+    requireEvidence('bounded-row-count-reviewed', 'row/table impact was previewed before mutation');
+  }
+
+  if (action.signals.some((signal) => signal.id === 'destructive-aws-cli')) {
+    requireEvidence('aws-account-and-region-confirmed', 'target AWS account and region confirmed');
+    requireEvidence('rollback-plan-attached', 'rollback or recovery plan attached');
+  }
+
+  if (action.signals.some((signal) => signal.id === 'iam-escalation')) {
+    requireEvidence('least-privilege-review', 'least-privilege review completed');
+    requireEvidence('security-owner-approval', 'security owner approval captured');
+  }
+
+  if (action.signals.some((signal) => signal.id === 'blocks-agent-tool-call')) {
+    requireEvidence('agent-tool-allowlist', 'agent tool allowlist and data boundary declared');
+  }
+
+  const shouldBlock = projectUsesAwsBlocks && requiredEvidence.length > 0;
+  let status = 'allowed';
+  if (shouldBlock) {
+    status = 'blocked';
+  } else if (action.highRisk) {
+    status = 'needs-review';
+  }
+
+  return {
+    name: 'thumbgate-aws-blocks-guardrails',
+    status,
+    projectUsesAwsBlocks,
+    signals: action.signals,
+    requiredEvidence,
+    enforcementBoundary: 'local AWS Blocks confidence must not automatically become production AWS authority',
+    gates: [
+      'allow local AWS Blocks dev loops without AWS credentials',
+      'require local test proof plus CDK diff before production deploy',
+      'block destroy and destructive data mutations until backup, blast-radius, and human approval evidence exists',
+      'block IAM escalation and Bedrock/Agent tool expansion until an owner approves the tool boundary',
+      'write a ThumbGate receipt for every allowed high-risk cloud action',
+    ],
+    nextActions: shouldBlock
+      ? requiredEvidence.map((item) => `Provide ${item.id}: ${item.label}`)
+      : ['Record an allow receipt when this action touches real AWS resources'],
+  };
+}
+
+function buildAwsBlocksHardeningOffer(input = {}) {
+  const workflow = String(input.workflow || input.name || 'AWS Blocks backend').trim();
+  const buyer = String(input.buyer || input.owner || 'platform owner').trim();
+  return {
+    name: 'thumbgate-aws-blocks-hardening-offer',
+    status: 'ready-for-positioning',
+    buyer,
+    workflow,
+    headline: 'AWS Blocks helps agents build the backend. ThumbGate stops them before unsafe cloud actions run.',
+    offer: 'AWS Blocks Agent Safety Review',
+    diagnosticPrice: '$499',
+    proofPlan: [
+      'map one AWS Blocks local-to-cloud workflow',
+      'install ThumbGate against the agent running that workflow',
+      'add gates for deploy, destroy, data mutation, IAM, Bedrock Agent, and cost-blast-radius actions',
+      'produce a receipt showing the first blocked repeat and the evidence required to allow it',
+    ],
+    cta: 'Send one AWS Blocks workflow that is about to deploy, mutate data, or call Bedrock tools.',
+  };
+}
+
+function parseArgs(argv = process.argv.slice(2)) {
+  const args = {};
+  for (const arg of argv) {
+    if (arg === '--json') args.json = true;
+    else if (arg === '--aws-blocks' || arg === '--project-uses-aws-blocks') args.projectUsesAwsBlocks = true;
+    else if (arg.startsWith('--command=')) args.command = arg.slice('--command='.length);
+    else if (arg.startsWith('--tool=')) args.toolName = arg.slice('--tool='.length);
+    else if (arg.startsWith('--code=')) args.code = arg.slice('--code='.length);
+    else if (arg.startsWith('--cwd=')) args.projectDir = arg.slice('--cwd='.length);
+    else if (arg.startsWith('--evidence=')) args.evidence = arg.slice('--evidence='.length);
+    else if (arg.startsWith('--workflow=')) args.workflow = arg.slice('--workflow='.length);
+    else if (arg.startsWith('--buyer=')) args.buyer = arg.slice('--buyer='.length);
+    else if (arg === 'offer') args.commandName = 'offer';
+  }
+  return args;
+}
+
+function runCli(args = parseArgs()) {
+  const report = args.commandName === 'offer'
+    ? buildAwsBlocksHardeningOffer(args)
+    : evaluateAwsBlocksAction(args);
+  if (args.json) console.log(JSON.stringify(report, null, 2));
+  else {
+    console.log(`${report.name}: ${report.status}`);
+    for (const action of report.nextActions || report.proofPlan || []) console.log(`- ${action}`);
+  }
+}
+
+if (require.main?.filename === __filename) runCli();
+
+module.exports = {
+  detectAwsBlocksProject,
+  detectAction,
+  evaluateAwsBlocksAction,
+  buildAwsBlocksHardeningOffer,
+};

package/scripts/bayes-optimal-gate.js

@@ -32,6 +32,7 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
+const { requireLearnedModelsEntitlement } = require('./entitlement');
 
 // Baseline loss matrix. `default` applies when no tag-specific override
 // matches. Higher = more expensive. The asymmetry below reflects the
@@ -181,7 +182,11 @@ function computeBayesPosterior({ tags, riskByTag, baseRate, modelProbability } =
  *
  * This reduces to the usual Bayes classifier when both costs are equal.
  */
-function bayesOptimalDecision(posterior, tags, lossMatrix = DEFAULT_LOSS_MATRIX) {
+function bayesOptimalDecision(posterior, tags, lossMatrix = DEFAULT_LOSS_MATRIX, options = {}) {
+  requireLearnedModelsEntitlement({
+    ...(options.entitlement || {}),
+    label: 'Bayes-optimal gate decisioning',
+  });
   const pHarmful = clip(Number(posterior?.pHarmful), 0, 1);
   const pSafe = clip(Number(posterior?.pSafe ?? 1 - pHarmful), 0, 1);
   const cFalseAllow = resolveCost(lossMatrix?.falseAllow || {}, tags);

package/scripts/classifier-routing.js

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_CONFIG_PATH = path.join(__dirname, '..', 'config', 'gate-classifier-routing.json');
+
+function clamp01(value, fallback = 0) {
+  const number = Number(value);
+  if (!Number.isFinite(number)) return fallback;
+  return Math.min(1, Math.max(0, number));
+}
+
+function riskRank(risk) {
+  const normalized = String(risk || 'medium').toLowerCase();
+  if (['critical', 'block', 'regulated'].includes(normalized)) return 4;
+  if (['high', 'dangerous'].includes(normalized)) return 3;
+  if (['medium', 'warn'].includes(normalized)) return 2;
+  return 1;
+}
+
+function loadClassifierRoutingConfig(configPath = DEFAULT_CONFIG_PATH) {
+  return JSON.parse(fs.readFileSync(configPath, 'utf8'));
+}
+
+function lane(config, laneName, reason, input, overrides = {}) {
+  const laneConfig = (config.lanes && config.lanes[laneName]) || {};
+  return {
+    lane: laneName,
+    reason,
+    requiresEvidence: Boolean(laneConfig.requiresEvidence || overrides.requiresEvidence),
+    cloudAllowed: Boolean(laneConfig.cloudAllowed),
+    maxLatencyMs: laneConfig.maxLatencyMs,
+    risk: String(input.risk || 'medium').toLowerCase(),
+    ambiguity: clamp01(input.ambiguity),
+  };
+}
+
+function routeClassifier(input = {}, config = loadClassifierRoutingConfig()) {
+  const thresholds = config.thresholds || {};
+  const labelCount = Number(input.labelCount || input.examples || 0);
+  const latencyBudgetMs = Number(input.latencyBudgetMs || 0);
+  const ambiguity = clamp01(input.ambiguity);
+  const risk = riskRank(input.risk);
+  const largeBatch = Number(input.batchRows || 0) >= Number(thresholds.largeBatchRows || 50);
+  const privacySensitive = Boolean(input.privacySensitive || input.containsSecrets || input.customerData);
+  const allowCloud = Boolean(input.allowCloud);
+
+  if (input.hasHardRule || input.exactPolicyMatch) {
+    return lane(config, 'deterministic', 'exact hard rule or policy match; do not spend model tokens', input);
+  }
+
+  if (input.semanticCacheHit || input.equivalentRepeat) {
+    return lane(config, 'semantic_cache', 'semantically equivalent repeat; reuse the proven prior decision without a model call', input);
+  }
+
+  if (input.rubricFailed || input.missingEvidence || input.completionClaimWithoutProof) {
+    return lane(config, 'rubric_gate', 'rubric or completion evidence failed; block done claims until proof exists', input);
+  }
+
+  if (input.structuredDataset && (input.missingProvenance || input.missingSources)) {
+    return lane(config, 'rubric_gate', 'structured data claim is missing source provenance', input);
+  }
+
+  if (privacySensitive && !allowCloud && risk >= 3 && ambiguity >= Number(thresholds.mediumAmbiguity || 0.35)) {
+    return lane(config, 'human_review', 'private high-risk ambiguous action; keep data local and require approval', input);
+  }
+
+  if (labelCount >= Number(thresholds.classicalMinExamples || 40) && (largeBatch || latencyBudgetMs <= Number(thresholds.lowLatencyBudgetMs || 300)) && ambiguity < Number(thresholds.mediumAmbiguity || 0.35)) {
+    return lane(config, 'local_classical', 'enough examples and low ambiguity; use cheap local classification', input);
+  }
+
+  if (risk >= 3 && ambiguity >= Number(thresholds.highRiskAmbiguity || 0.65)) {
+    if (allowCloud && latencyBudgetMs >= Number(thresholds.llmMinLatencyBudgetMs || 2000)) {
+      return lane(config, 'llm_judge', 'high-risk semantic ambiguity; use a budget-capped LLM judge with evidence', input);
+    }
+    return lane(config, 'human_review', 'high-risk ambiguity without approved cloud/budget route', input);
+  }
+
+  if (labelCount < Number(thresholds.classicalMinExamples || 40) || ambiguity >= Number(thresholds.mediumAmbiguity || 0.35)) {
+    return lane(config, 'local_semantic', 'sparse labels or fuzzy intent; use local semantic recall before any LLM', input);
+  }
+
+  return lane(config, config.defaultLane || 'local_classical', 'default local route for routine gate classification', input);
+}
+
+function explainClassifierRoute(input = {}, config = loadClassifierRoutingConfig()) {
+  const decision = routeClassifier(input, config);
+  const laneConfig = (config.lanes && config.lanes[decision.lane]) || {};
+  return {
+    ...decision,
+    description: laneConfig.description || '',
+    useFor: laneConfig.useFor || [],
+  };
+}
+
+function parseArgs(argv) {
+  const input = {};
+  for (const arg of argv) {
+    if (arg === '--hard-rule') input.hasHardRule = true;
+    else if (arg === '--privacy-sensitive') input.privacySensitive = true;
+    else if (arg === '--allow-cloud') input.allowCloud = true;
+    else if (arg === '--customer-data') input.customerData = true;
+    else if (arg === '--semantic-cache-hit') input.semanticCacheHit = true;
+    else if (arg === '--equivalent-repeat') input.equivalentRepeat = true;
+    else if (arg === '--rubric-failed') input.rubricFailed = true;
+    else if (arg === '--missing-evidence') input.missingEvidence = true;
+    else if (arg === '--structured-dataset') input.structuredDataset = true;
+    else if (arg === '--missing-provenance') input.missingProvenance = true;
+    else if (arg.startsWith('--risk=')) input.risk = arg.slice('--risk='.length);
+    else if (arg.startsWith('--ambiguity=')) input.ambiguity = Number(arg.slice('--ambiguity='.length));
+    else if (arg.startsWith('--labels=')) input.labelCount = Number(arg.slice('--labels='.length));
+    else if (arg.startsWith('--latency-ms=')) input.latencyBudgetMs = Number(arg.slice('--latency-ms='.length));
+    else if (arg.startsWith('--batch-rows=')) input.batchRows = Number(arg.slice('--batch-rows='.length));
+  }
+  return input;
+}
+
+module.exports = {
+  DEFAULT_CONFIG_PATH,
+  explainClassifierRoute,
+  loadClassifierRoutingConfig,
+  routeClassifier,
+};
+
+if (require.main === module) {
+  const decision = explainClassifierRoute(parseArgs(process.argv.slice(2)));
+  process.stdout.write(`${JSON.stringify(decision, null, 2)}\n`);
+}

package/scripts/cli-feedback.js

@@ -29,6 +29,7 @@ const G = '\x1b[32m';
 const R = '\x1b[31m';
 const C = '\x1b[36m';
 const M = '\x1b[35m';
+const Y = '\x1b[33m';
 const D = '\x1b[90m';
 const BD = '\x1b[1m';
 const RST = '\x1b[0m';
@@ -73,7 +74,15 @@ function processInlineFeedback({ signal, context, chatHistory, whatWentWrong, wh
   const recentLesson = getRecentLesson();
   const stats = getLessonStats();
 
-  return { feedbackResult, distillResult, recentLesson, stats };
+  // 4. If the user wrote an explicit "never …" / "always …" directive, surface
+  //    an OFFER (never auto-act): "never" on a thumbs-down → offer force-gate now.
+  let forceGateHint = null;
+  try {
+    const { suggestForceGate } = require('./imperative-detector');
+    forceGateHint = suggestForceGate({ signal, text: whatWentWrong || whatWorked || context });
+  } catch { /* detector optional; never block capture on it */ }
+
+  return { feedbackResult, distillResult, recentLesson, stats, forceGateHint };
 }
 
 /**
@@ -100,6 +109,13 @@ function formatCliOutput(result) {
     lines.push(`${R}Feedback not accepted: ${(result.feedbackResult && result.feedbackResult.reason) || 'unknown'}${RST}`);
   }
 
+  // Explicit-directive offer (e.g. "never …" → offer immediate force-gate).
+  if (result.forceGateHint && result.forceGateHint.message) {
+    const color = result.forceGateHint.kind === 'force-gate-offer' ? Y : D;
+    lines.push('');
+    lines.push(`${color}💡 ${result.forceGateHint.message}${RST}`);
+  }
+
   // Distilled lesson (if thumbs down)
   if (result.distillResult) {
     lines.push('');

package/scripts/commercial-offer.js

@@ -67,11 +67,11 @@ function buildCaptureReceipt({ signal, feedbackId, memoryId, actionType } = {})
     memoryId ? `  Local memory   : ${memoryId}` : '  Local memory   : saved locally',
     actionType ? `  Rule pressure  : ${actionType}` : '  Rule pressure  : available for promotion',
     '  Free today     : this proof protects this local machine',
-    '  Pro sync       : keep this lesson, rule, and dashboard synced across machines and agent runtimes',
+    '  Pro recall     : keep this lesson searchable, exportable, and visible',
     '  Next proof     : npx thumbgate stats',
     '  Cost proof     : npx thumbgate cost',
     '',
-    `  Solo Pro       : ${PRO_PRICE_LABEL} for hosted sync, search, dashboard, and exports`,
+    `  Solo Pro       : ${PRO_PRICE_LABEL} for recall, dashboard, adapters, and exports`,
     `  Upgrade        : ${trackedProUrl('cli_capture_receipt', actionType || normalizedSignal.toLowerCase())}`,
     `  Enterprise     : ${ENTERPRISE_PRICE_LABEL}; start with one repeated workflow failure`,
     '                   https://thumbgate.ai/#workflow-sprint-intake',
@@ -105,7 +105,7 @@ function buildStatsReceipt(stats = {}) {
     lines.push(`  Failure pressure   : ${negatives} negative ${pluralize(negatives, 'signal')}`);
   }
   lines.push('  Show the buyer     : npx thumbgate cost');
-  lines.push('  Pro sync value     : keep these lessons/rules visible across laptops, CI, containers, and agent runtimes');
+  lines.push('  Pro recall value   : keep lessons/rules searchable, exportable, and visible');
   lines.push(`  Solo Pro           : ${trackedProUrl('cli_stats_receipt', 'proof_seen')}`);
   lines.push('  Enterprise         : https://thumbgate.ai/#workflow-sprint-intake');
   lines.push('');