thumbgate 1.35.0 → 1.37.1

package/scripts/qwen38-max-cost-optimizer.js

@@ -0,0 +1,401 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Qwen3.8-Max & Alibaba Cloud Token Plan Cost Optimizer
+ *
+ * Pricing sources (2026): OpenRouter Qwen3.8-Max, Claude platform pricing
+ * (Sonnet 5 intro through 2026-08-31 then $3/$15), Gemini 2.5 tiered ranges.
+ * Token Plan 2x promo modeled as 0.5× effective cost when useTokenPlanPromo.
+ */
+
+const PRICING_TABLE = Object.freeze({
+  'qwen3.8-max': {
+    inputPerM: 2.00,
+    outputPerM: 6.00,
+    label: 'Qwen3.8-Max (OpenRouter / Model Studio)',
+    contextWindow: 1_000_000,
+  },
+  // Token Plan list prices from Alibaba Model Studio (approx mid of published ranges).
+  'qwen3.7-plus': { inputPerM: 0.64, outputPerM: 2.56, label: 'Qwen3.7-Plus (Model Studio)' },
+  'qwen3.6-flash': { inputPerM: 0.50, outputPerM: 2.50, label: 'Qwen3.6-Flash (Model Studio)' },
+  'claude-sonnet-5-intro': {
+    inputPerM: 2.00,
+    outputPerM: 10.00,
+    label: 'Claude Sonnet 5 (Intro through 2026-08-31)',
+  },
+  'claude-sonnet-4.6': { inputPerM: 3.00, outputPerM: 15.00, label: 'Claude Sonnet 4.6' },
+  'claude-sonnet-5-standard': {
+    inputPerM: 3.00,
+    outputPerM: 15.00,
+    label: 'Claude Sonnet 5 (Post-Aug 31, 2026)',
+  },
+  // Conservative (high) end of Gemini 2.5 Pro published range for apples-to-apples "worst case Gemini".
+  'gemini-2.5-pro': {
+    inputPerM: 2.50,
+    outputPerM: 15.00,
+    label: 'Gemini 2.5 Pro (high tier of $1.25–2.50 / $10–15)',
+    inputPerMLow: 1.25,
+    outputPerMLow: 10.00,
+  },
+  'gemini-2.5-flash': { inputPerM: 0.30, outputPerM: 2.50, label: 'Gemini 2.5 Flash' },
+});
+
+/** After this date Claude Sonnet 5 uses standard $3/$15 (not intro $2/$10). */
+const CLAUDE_SONNET_5_INTRO_ENDS = '2026-09-01';
+
+/**
+ * Recommend flash vs plus vs max for a workload (pairs with adapters/qwen resolveQwenRoleRoute).
+ */
+function recommendQwenTier(workload, options = {}) {
+  const id = String(workload || 'pretool-gating').toLowerCase();
+  if (id.includes('long') || id.includes('claw') || id.includes('autonomous')) {
+    return {
+      modelKey: 'qwen3.8-max',
+      reason: 'Long-horizon / claw-style work benefits from flagship reasoning.',
+      costSample: calculateTokenCost('qwen3.8-max', options.inputTokensM || 1, options.outputTokensM || 1),
+    };
+  }
+  if (id.includes('cheap') || id.includes('pretool') || id.includes('gate') || id.includes('flash')) {
+    return {
+      modelKey: 'qwen3.6-flash',
+      reason: 'Gate and triage paths should stay on Flash under Token Plan.',
+      costSample: calculateTokenCost('qwen3.6-flash', options.inputTokensM || 1, options.outputTokensM || 1),
+    };
+  }
+  return {
+    modelKey: 'qwen3.7-plus',
+    reason: 'Default balanced coding / vision path.',
+    costSample: calculateTokenCost('qwen3.7-plus', options.inputTokensM || 1, options.outputTokensM || 1),
+  };
+}
+
+function calculateTokenCost(modelKey, inputTokensM = 1, outputTokensM = 1) {
+  const model = PRICING_TABLE[modelKey];
+  if (!model) {
+    throw new Error(`Unknown model key: ${modelKey}`);
+  }
+  const inputCost = inputTokensM * model.inputPerM;
+  const outputCost = outputTokensM * model.outputPerM;
+  return {
+    modelKey,
+    label: model.label,
+    inputCost,
+    outputCost,
+    totalCost: inputCost + outputCost,
+  };
+}
+
+function applyTokenPlanPromo(totalCostUsd, useTokenPlanPromo) {
+  if (!useTokenPlanPromo) return Number(totalCostUsd);
+  // Limited-time 2x usage-per-credit → model as 0.5× effective $ for same work.
+  return Number(totalCostUsd) * 0.5;
+}
+
+function calculateQwenSavingsVsClaude(options = {}) {
+  const inputM = options.inputTokensM || 1;
+  const outputM = options.outputTokensM || 1;
+  const useTokenPlanPromo = Boolean(options.useTokenPlanPromo);
+  const claudeKey = options.claudeModelKey || 'claude-sonnet-4.6';
+
+  const qwenBase = calculateTokenCost('qwen3.8-max', inputM, outputM);
+  const claude = calculateTokenCost(claudeKey, inputM, outputM);
+
+  const qwenEffectiveTotal = applyTokenPlanPromo(qwenBase.totalCost, useTokenPlanPromo);
+  const rawSavingsUsd = claude.totalCost - qwenEffectiveTotal;
+  const savingsPercent = Number(((rawSavingsUsd / claude.totalCost) * 100).toFixed(1));
+
+  return {
+    inputTokensM: inputM,
+    outputTokensM: outputM,
+    useTokenPlanPromo,
+    claudeModelKey: claudeKey,
+    qwenCostUsd: Number(qwenEffectiveTotal.toFixed(2)),
+    claudeCostUsd: Number(claude.totalCost.toFixed(2)),
+    savingsUsd: Number(rawSavingsUsd.toFixed(2)),
+    savingsPercent,
+    recommendation: savingsPercent > 50
+      ? 'ROUTE_HIGH_VOLUME_TO_QWEN38_MAX'
+      : 'EVALUATE_HYBRID_ROUTING',
+  };
+}
+
+function calculateCostPerSuccessfulOutcome(options = {}) {
+  const {
+    modelKey,
+    inputTokensM = 1,
+    outputTokensM = 1,
+    successRate,
+    sampleSize,
+    costMultiplier = 1,
+    minimumSampleSize = 20,
+  } = options;
+
+  if (!Number.isFinite(successRate) || successRate <= 0 || successRate > 1) {
+    throw new Error('successRate must be greater than 0 and less than or equal to 1');
+  }
+  if (!Number.isInteger(sampleSize) || sampleSize < 0) {
+    throw new Error('sampleSize must be a non-negative integer');
+  }
+  if (!Number.isFinite(costMultiplier) || costMultiplier <= 0 || costMultiplier > 1) {
+    throw new Error('costMultiplier must be greater than 0 and less than or equal to 1');
+  }
+
+  const tokenCost = calculateTokenCost(modelKey, inputTokensM, outputTokensM);
+  const effectiveCostUsd = tokenCost.totalCost * costMultiplier;
+  return {
+    modelKey,
+    sampleSize,
+    successRate,
+    telemetryQualified: sampleSize >= minimumSampleSize,
+    effectiveCostUsd: Number(effectiveCostUsd.toFixed(4)),
+    costPerSuccessfulOutcomeUsd: Number((effectiveCostUsd / successRate).toFixed(4)),
+  };
+}
+
+function recommendQwenByCostPerSuccess(options = {}) {
+  const minimumSampleSize = options.minimumSampleSize ?? 20;
+  const minimumSavingsPercent = options.minimumSavingsPercent ?? 15;
+  const incumbent = calculateCostPerSuccessfulOutcome({
+    modelKey: options.incumbentModelKey || 'claude-sonnet-5-standard',
+    inputTokensM: options.inputTokensM,
+    outputTokensM: options.outputTokensM,
+    successRate: options.incumbentSuccessRate,
+    sampleSize: options.incumbentSampleSize,
+    minimumSampleSize,
+  });
+  const qwen = calculateCostPerSuccessfulOutcome({
+    modelKey: 'qwen3.8-max',
+    inputTokensM: options.inputTokensM,
+    outputTokensM: options.outputTokensM,
+    successRate: options.qwenSuccessRate,
+    sampleSize: options.qwenSampleSize,
+    costMultiplier: options.verifiedTokenPlanMultiplier ?? 1,
+    minimumSampleSize,
+  });
+
+  if (!incumbent.telemetryQualified || !qwen.telemetryQualified) {
+    return { recommendation: 'HOLD_INCUMBENT', reason: 'INSUFFICIENT_OUTCOME_TELEMETRY', incumbent, qwen };
+  }
+
+  const savingsPercent = Number((
+    ((incumbent.costPerSuccessfulOutcomeUsd - qwen.costPerSuccessfulOutcomeUsd)
+      / incumbent.costPerSuccessfulOutcomeUsd) * 100
+  ).toFixed(1));
+  const routeToQwen = savingsPercent >= minimumSavingsPercent;
+  return {
+    recommendation: routeToQwen ? 'ROUTE_HIGH_VOLUME_TO_QWEN38_MAX' : 'HOLD_INCUMBENT',
+    reason: routeToQwen ? 'LOWER_VERIFIED_COST_PER_SUCCESS' : 'SAVINGS_BELOW_THRESHOLD',
+    savingsPercent,
+    minimumSavingsPercent,
+    incumbent,
+    qwen,
+  };
+}
+
+/**
+ * Full stack snapshot for the dual-lane policy (volume → Qwen, quality → Claude/Gemini).
+ */
+function compareStackPricing(options = {}) {
+  const inputM = options.inputTokensM || 1;
+  const outputM = options.outputTokensM || 1;
+  const useTokenPlanPromo = Boolean(options.useTokenPlanPromo);
+  const asOf = options.asOf || new Date().toISOString().slice(0, 10);
+
+  const rows = [
+    'qwen3.8-max',
+    'qwen3.7-plus',
+    'qwen3.6-flash',
+    'claude-sonnet-5-intro',
+    'claude-sonnet-5-standard',
+    'claude-sonnet-4.6',
+    'gemini-2.5-pro',
+    'gemini-2.5-flash',
+  ].map((key) => {
+    const base = calculateTokenCost(key, inputM, outputM);
+    const effective = key.startsWith('qwen')
+      ? applyTokenPlanPromo(base.totalCost, useTokenPlanPromo)
+      : base.totalCost;
+    return {
+      modelKey: key,
+      label: base.label,
+      inputCost: base.inputCost,
+      outputCost: base.outputCost,
+      totalCost: base.totalCost,
+      effectiveCost: Number(effective.toFixed(4)),
+    };
+  });
+
+  const qwen = rows.find((r) => r.modelKey === 'qwen3.8-max');
+  const claudePost = rows.find((r) => r.modelKey === 'claude-sonnet-5-standard');
+  const outputSavingsVsClaudePost = claudePost.outputCost > 0
+    ? Number((((claudePost.outputCost - qwen.outputCost) / claudePost.outputCost) * 100).toFixed(1))
+    : 0;
+
+  return {
+    asOf,
+    inputTokensM: inputM,
+    outputTokensM: outputM,
+    useTokenPlanPromo,
+    claudeSonnet5IntroEnds: CLAUDE_SONNET_5_INTRO_ENDS,
+    claudeSonnet5OnIntroPricing: asOf < CLAUDE_SONNET_5_INTRO_ENDS,
+    rows,
+    highlights: {
+      qwenOutputPerM: PRICING_TABLE['qwen3.8-max'].outputPerM,
+      claudeStandardOutputPerM: PRICING_TABLE['claude-sonnet-5-standard'].outputPerM,
+      outputTokenSavingsPercentVsClaudeStandard: outputSavingsVsClaudePost,
+      note: 'Qwen3.8-Max $6/M output vs Claude $15/M is the primary cash lever; Token Plan promo stacks further.',
+    },
+  };
+}
+
+/**
+ * Practical dual-stack policy from cost analysis:
+ * - high-volume / bulk / automation → Qwen (Flash for gates, Max for long agentic)
+ * - high-stakes reasoning / architecture / quality-critical → Claude or Gemini
+ * - local preferred when privacyRoute=local or sensitive
+ */
+function recommendCostQualitySplit(task = {}, options = {}) {
+  const tags = Array.isArray(task.tags) ? task.tags.map((t) => String(t).toLowerCase()) : [];
+  const type = String(task.type || task.workload || '').toLowerCase();
+  const risk = String(task.riskLevel || 'medium').toLowerCase();
+  const costPrimary = task.costPriority === 'primary'
+    || tags.includes('cost-sensitive')
+    || tags.includes('high-volume')
+    || tags.includes('bulk')
+    || tags.includes('automation')
+    || Boolean(task.highVolume);
+  const qualityCritical = risk === 'high'
+    || tags.includes('architecture')
+    || tags.includes('reasoning-critical')
+    || tags.includes('quality-critical')
+    || type.includes('architecture')
+    || type.includes('complex-debugging');
+  const longHorizon = tags.includes('long-horizon')
+    || type.includes('long-trace')
+    || Boolean(task.longHorizon)
+    || (Number(task.contextTokens) || 0) >= 128000;
+  const sensitive = task.privacyRoute === 'local'
+    || Boolean(task.sensitive)
+    || tags.includes('pii')
+    || tags.includes('secrets');
+
+  const useTokenPlanPromo = Boolean(options.useTokenPlanPromo);
+  const volume = {
+    inputTokensM: options.inputTokensM || 1,
+    outputTokensM: options.outputTokensM || 1,
+  };
+  const vsClaude = calculateQwenSavingsVsClaude({
+    ...volume,
+    useTokenPlanPromo,
+    claudeModelKey: options.claudeModelKey || 'claude-sonnet-5-standard',
+  });
+
+  if (sensitive) {
+    return {
+      lane: 'local-or-private',
+      primaryProvider: 'local',
+      primaryModel: options.localModel || null,
+      fallbackProvider: null,
+      reason: 'Sensitive / privacyRoute=local — do not send bulk payloads to Model Studio without explicit allow.',
+      savings: vsClaude,
+      requiresBudgetApproval: false,
+    };
+  }
+
+  if (qualityCritical && !costPrimary) {
+    return {
+      lane: 'quality',
+      primaryProvider: options.qualityProvider || 'anthropic',
+      primaryModel: options.qualityModel || 'claude-sonnet-5-standard',
+      fallbackProvider: 'gemini',
+      fallbackModel: 'gemini-2.5-pro',
+      reason: 'High-stakes reasoning — keep Claude/Gemini; do not force Qwen solely for price.',
+      savings: vsClaude,
+      requiresBudgetApproval: false,
+    };
+  }
+
+  if (costPrimary || longHorizon) {
+    const telemetry = options.outcomeTelemetry;
+    if (!telemetry) {
+      return {
+        lane: 'quality',
+        primaryProvider: options.qualityProvider || 'anthropic',
+        primaryModel: options.qualityModel || 'claude-sonnet-5-standard',
+        fallbackProvider: 'model-studio',
+        fallbackModel: 'qwen3.8-max',
+        reason: 'Hold incumbent until Qwen and incumbent have qualified task-outcome telemetry.',
+        savings: vsClaude,
+        requiresBudgetApproval: false,
+        routingEvidence: { recommendation: 'HOLD_INCUMBENT', reason: 'INSUFFICIENT_OUTCOME_TELEMETRY' },
+      };
+    }
+    const routingEvidence = recommendQwenByCostPerSuccess({
+      ...volume,
+      ...telemetry,
+      verifiedTokenPlanMultiplier: useTokenPlanPromo ? 0.5 : 1,
+    });
+    if (routingEvidence.recommendation !== 'ROUTE_HIGH_VOLUME_TO_QWEN38_MAX') {
+      return {
+        lane: 'quality',
+        primaryProvider: options.qualityProvider || 'anthropic',
+        primaryModel: options.qualityModel || 'claude-sonnet-5-standard',
+        fallbackProvider: 'model-studio',
+        fallbackModel: 'qwen3.8-max',
+        reason: 'Hold incumbent because Qwen has not proven lower cost per successful outcome.',
+        savings: vsClaude,
+        requiresBudgetApproval: false,
+        routingEvidence,
+      };
+    }
+    const qwenTier = recommendQwenTier(
+      longHorizon ? 'long-trace-review' : (type.includes('gate') || type.includes('pretool') ? 'pretool-gating' : 'cheap-fast-path'),
+      volume,
+    );
+    return {
+      lane: 'cost-volume',
+      primaryProvider: 'model-studio',
+      primaryModel: qwenTier.modelKey,
+      candidateId: qwenTier.modelKey === 'qwen3.8-max'
+        ? 'alibaba/qwen3.8-max'
+        : qwenTier.modelKey === 'qwen3.6-flash'
+          ? 'alibaba/qwen3.6-flash'
+          : 'alibaba/qwen3.7-plus',
+      fallbackProvider: options.qualityProvider || 'anthropic',
+      fallbackModel: options.qualityModel || 'claude-sonnet-5-standard',
+      reason: longHorizon
+        ? 'Long / high-output agentic work: Qwen3.8-Max for output-token savings; keep Claude as quality fallback.'
+        : 'High-volume cost-sensitive work: route to Qwen under Token Plan; escalate quality-critical to Claude/Gemini.',
+      savings: vsClaude,
+      requiresBudgetApproval: true,
+      qwenTier,
+      routingEvidence,
+    };
+  }
+
+  return {
+    lane: 'balanced',
+    primaryProvider: 'model-studio',
+    primaryModel: 'qwen3.7-plus',
+    candidateId: 'alibaba/qwen3.7-plus',
+    fallbackProvider: 'anthropic',
+    fallbackModel: 'claude-sonnet-5-standard',
+    reason: 'Default: Plus for coding throughput; quality fallback on failure or high risk.',
+    savings: vsClaude,
+    requiresBudgetApproval: true,
+  };
+}
+
+module.exports = {
+  PRICING_TABLE,
+  CLAUDE_SONNET_5_INTRO_ENDS,
+  calculateTokenCost,
+  calculateQwenSavingsVsClaude,
+  calculateCostPerSuccessfulOutcome,
+  recommendQwenByCostPerSuccess,
+  recommendQwenTier,
+  compareStackPricing,
+  recommendCostQualitySplit,
+  applyTokenPlanPromo,
+};

package/scripts/radware-threat-defense.js

@@ -0,0 +1,280 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Radware-inspired threat defense for ThumbGate PreToolUse.
+ *
+ * Steals process (not product) from Radware Bot Manager / AI DDoS defense:
+ *   detect → challenge → block severity ladder, real-time interdiction,
+ *   adaptive rate circuit breaker.
+ *
+ * Vectors:
+ * 1. ShadowLeak — secondary egress / parameter stuffing exfiltration
+ * 2. ZombieAgent — indirect prompt injection hijacking agent loops
+ * 3. Token-drain bursts — sub-minute volumetric circuit breaker
+ *
+ * Reference: Radware Global Threat Analysis Report 2026 (RWI-6283);
+ * Bot Manager Essentials (detect / challenge / mitigate).
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+
+const SHADOWLEAK_PATTERNS = [
+  // Bounded classes — avoid nested quantifiers on attacker-controlled input (CodeQL js/polynomial-redos).
+  /!\[[^\]\n]{0,200}\]\(https?:\/\/[^)\s]{1,300}\?(?:data|token|key|cookie|leak|mem|secret)=[^)\s]{0,300}\)/i,
+  /\bcurl[ \t][^|\r\n]{0,500}(?:-d|--data|-F)[ \t][^|\r\n]{0,400}(?:token|secret|password|credential|env|auth)/i,
+  /\b(?:fetch|axios|request)\s*\(\s*[`'"]https?:\/\/[^`'"]{0,300}(?:exfil|leak|webhook|collect)/i,
+];
+
+const ZOMBIEAGENT_PATTERNS = [
+  /\b(?:system\s*override|act\s*as\s*zombie|unrestricted\s*agent|drop\s*prior\s*instructions|ignore\s*all\s*guardrails)\b/i,
+  /\b(?:execute\s*without\s*approval|silently\s*forward\s*to|covert\s*execution|bypass\s*firewall)\b/i,
+];
+
+/** Bot Manager–style “suspicious automation” — challenge, do not hard-block. */
+const SUSPICIOUS_BOT_PATTERNS = [
+  /\b(?:scrape\s+all|mass[- ]scrape|credential\s*stuff|ato\s*attack|account\s*takeover\s*spray)\b/i,
+  /\b(?:headless\s+flood|burst\s+tool\s+calls|token\s*drain\s*loop)\b/i,
+];
+
+const SEVERITY_RANK = {
+  none: 0,
+  low: 1,
+  medium: 2,
+  high: 3,
+  critical: 4,
+};
+
+const ACTION_FOR_SEVERITY = {
+  none: 'allow',
+  low: 'detect',
+  medium: 'challenge',
+  high: 'block',
+  critical: 'block',
+};
+
+function defaultHistoryPath() {
+  const root = process.env.THUMBGATE_HOME
+    || path.join(os.homedir(), '.thumbgate');
+  return path.join(root, 'radware-call-history.json');
+}
+
+function loadCallTimestamps(historyPath = defaultHistoryPath()) {
+  try {
+    const raw = fs.readFileSync(historyPath, 'utf8');
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed.timestamps) ? parsed.timestamps.filter((n) => Number.isFinite(n)) : [];
+  } catch {
+    return [];
+  }
+}
+
+function persistCallTimestamp(historyPath = defaultHistoryPath(), now = Date.now()) {
+  // Never pollute operator history from the node:test runner or CI matrices —
+  // those call evaluateGates hundreds of times and would false-trip the breaker.
+  if (
+    process.env.NODE_TEST
+    || process.env.NODE_TEST_CONTEXT
+    || process.env.CI
+    || process.env.GITHUB_ACTIONS
+    || process.env.npm_lifecycle_event === 'test'
+  ) {
+    return loadCallTimestamps(historyPath);
+  }
+  const timestamps = loadCallTimestamps(historyPath)
+    .filter((ts) => ts >= now - 120000)
+    .concat(now);
+  fs.mkdirSync(path.dirname(historyPath), { recursive: true });
+  fs.writeFileSync(historyPath, JSON.stringify({ timestamps }, null, 2));
+  return timestamps;
+}
+
+/**
+ * Bot Manager severity ladder: detect → challenge → block.
+ * @param {string|object} payload
+ * @param {object} [options]
+ */
+function evaluateThreat(payload, options = {}) {
+  const raw = typeof payload === 'string' ? payload : JSON.stringify(payload || '');
+  // Hard length cap before regex evaluation (ReDoS defense-in-depth).
+  const text = raw.length > 20000 ? raw.slice(0, 20000) : raw;
+  const detections = [];
+  let severity = 'none';
+  let threatType = null;
+
+  for (const pattern of SHADOWLEAK_PATTERNS) {
+    if (pattern.test(text)) {
+      detections.push({
+        type: 'ShadowLeak',
+        pattern: pattern.source,
+        description: 'Sensitive data exfiltration via secondary egress or parameter stuffing',
+      });
+      threatType = 'ShadowLeak';
+      severity = 'critical';
+      break;
+    }
+  }
+
+  for (const pattern of ZOMBIEAGENT_PATTERNS) {
+    if (pattern.test(text)) {
+      detections.push({
+        type: 'ZombieAgent',
+        pattern: pattern.source,
+        description: 'Indirect prompt injection attempting agent loop hijacking',
+      });
+      threatType = threatType ? `${threatType}+ZombieAgent` : 'ZombieAgent';
+      severity = 'critical';
+      break;
+    }
+  }
+
+  if (severity === 'none') {
+    for (const pattern of SUSPICIOUS_BOT_PATTERNS) {
+      if (pattern.test(text)) {
+        detections.push({
+          type: 'SuspiciousBot',
+          pattern: pattern.source,
+          description: 'Bot Manager–style suspicious automation; challenge before allow',
+        });
+        threatType = 'SuspiciousBot';
+        severity = 'medium';
+        break;
+      }
+    }
+  }
+
+  const action = ACTION_FOR_SEVERITY[severity] || 'allow';
+  const blocked = action === 'block';
+  const challenged = action === 'challenge';
+
+  return {
+    verdict: blocked ? 'DENY' : challenged ? 'CHALLENGE' : detections.length ? 'DETECT' : 'ALLOW',
+    blocked,
+    challenged,
+    action,
+    threatType,
+    severity,
+    severityRank: SEVERITY_RANK[severity] || 0,
+    confidence: blocked || challenged ? 0.99 : 1.0,
+    detections,
+    evaluatedAt: new Date().toISOString(),
+    receipt: blocked
+      ? `threat_defense_interdicted=true:type=${threatType || 'unknown'}:action=block`
+      : challenged
+        ? `threat_defense_challenge=true:type=${threatType || 'unknown'}:action=challenge`
+        : detections.length
+          ? `threat_defense_detect=true:type=${threatType || 'unknown'}:action=detect`
+          : 'threat_defense_passed=true',
+  };
+}
+
+/**
+ * Volumetric token-drain circuit breaker (Radware AI DDoS / Bot Manager mitigate).
+ * @param {Array<number>} callTimestamps
+ * @param {object} [limits]
+ */
+function checkRateBurst(callTimestamps = [], limits = {}) {
+  const maxPerMinute = limits.maxPerMinute || 60;
+  const now = limits.now || Date.now();
+  const oneMinuteAgo = now - 60000;
+  const recentCalls = callTimestamps.filter((ts) => ts >= oneMinuteAgo);
+  const tripped = recentCalls.length >= maxPerMinute;
+
+  return {
+    tripped,
+    callCount: recentCalls.length,
+    maxPerMinute,
+    verdict: tripped ? 'CIRCUIT_OPEN' : 'NORMAL',
+    severity: tripped ? 'high' : 'none',
+    action: tripped ? 'block' : 'allow',
+    message: tripped
+      ? `Rate burst limit exceeded (${recentCalls.length}/${maxPerMinute} calls/min). Circuit breaker open.`
+      : 'Rate within safe operational envelope.',
+  };
+}
+
+/**
+ * Combined pretool defense used by harness-selector.
+ * Persists call history so the circuit breaker is live, not declarative theater.
+ */
+function evaluatePretoolDefense(payload, options = {}) {
+  const historyPath = options.historyPath || defaultHistoryPath();
+  const now = options.now || Date.now();
+  const record = options.record !== false;
+  const timestamps = record
+    ? persistCallTimestamp(historyPath, now)
+    : loadCallTimestamps(historyPath);
+  const threat = evaluateThreat(payload, options);
+  const burst = checkRateBurst(timestamps, {
+    maxPerMinute: options.maxPerMinute || 60,
+    now,
+  });
+
+  if (burst.tripped && (SEVERITY_RANK[burst.severity] || 0) >= (SEVERITY_RANK[threat.severity] || 0)) {
+    return {
+      ...threat,
+      verdict: 'DENY',
+      blocked: true,
+      challenged: false,
+      action: 'block',
+      severity: 'high',
+      severityRank: SEVERITY_RANK.high,
+      threatType: threat.threatType ? `${threat.threatType}+RateBurst` : 'RateBurst',
+      rateBurst: burst,
+      selectHarness: true,
+      receipt: `threat_defense_interdicted=true:type=RateBurst:action=block`,
+    };
+  }
+
+  return {
+    ...threat,
+    rateBurst: burst,
+    selectHarness: threat.blocked || threat.challenged || threat.severity !== 'none',
+  };
+}
+
+function handleDoctor(stdout = process.stdout) {
+  stdout.write('Radware / Bot Manager Threat Defense Doctor Check:\n');
+  stdout.write('  ✓ ShadowLeak data exfiltration firewall loaded\n');
+  stdout.write('  ✓ ZombieAgent indirect prompt injection interdiction ready\n');
+  stdout.write('  ✓ Suspicious-bot challenge ladder (detect→challenge→block)\n');
+  stdout.write('  ✓ Algorithmic token-drain circuit breaker operational\n');
+  return 0;
+}
+
+function mainCli(args = process.argv.slice(2), stdout = process.stdout) {
+  if (args.includes('--doctor')) {
+    return handleDoctor(stdout);
+  }
+  if (args.includes('--eval') || args.includes('--check')) {
+    const inputIdx = Math.max(args.indexOf('--eval'), args.indexOf('--check')) + 1;
+    const input = args[inputIdx] || '';
+    const res = evaluatePretoolDefense(input, { record: false });
+    stdout.write(`${JSON.stringify(res, null, 2)}\n`);
+    return res.blocked ? 1 : 0;
+  }
+  stdout.write('Usage: radware-threat-defense [--doctor | --eval <payload>]\n');
+  return 0;
+}
+
+if (path.resolve(process.argv[1] || '') === path.resolve(__filename)) {
+  process.exit(mainCli());
+}
+
+module.exports = {
+  evaluateThreat,
+  evaluatePretoolDefense,
+  checkRateBurst,
+  loadCallTimestamps,
+  persistCallTimestamp,
+  defaultHistoryPath,
+  handleDoctor,
+  mainCli,
+  SHADOWLEAK_PATTERNS,
+  ZOMBIEAGENT_PATTERNS,
+  SUSPICIOUS_BOT_PATTERNS,
+  ACTION_FOR_SEVERITY,
+  SEVERITY_RANK,
+};