thumbgate 1.27.19 → 1.27.20

package/scripts/qa-scenario-planner.js

@@ -0,0 +1,136 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+
+const RUNTIME_PATTERNS = [
+  { pattern: /^public\/.*\.(html|css|js)$/i, surface: 'browser', reason: 'public UI asset changed' },
+  { pattern: /^src\/api\//i, surface: 'api', reason: 'API route or server behavior changed' },
+  { pattern: /^bin\//i, surface: 'cli', reason: 'CLI entrypoint changed' },
+  { pattern: /^scripts\/(dashboard|pro-local-dashboard|.*gate|.*scanner|.*reward|.*routing).*\.js$/i, surface: 'agent-runtime', reason: 'agent runtime or gate behavior changed' },
+  { pattern: /^adapters\//i, surface: 'agent-adapter', reason: 'agent adapter changed' },
+  { pattern: /^plugins\//i, surface: 'plugin', reason: 'plugin install path changed' },
+  { pattern: /^package\.json$/i, surface: 'package', reason: 'package manifest changed' },
+];
+
+const SKIP_PATTERNS = [
+  /^README\.md$/i,
+  /^docs\//i,
+  /^reports\//i,
+  /^proof\//i,
+  /^tests\/.*\.test\.js$/i,
+  /^\.claude\/implementation-notes\//i,
+];
+
+function normalizeFiles(files = []) {
+  return Array.from(new Set(files
+    .map((file) => String(file || '').trim().replace(/^\.?\//, ''))
+    .filter(Boolean)));
+}
+
+function classifyFile(file) {
+  for (const entry of RUNTIME_PATTERNS) {
+    if (entry.pattern.test(file)) return { ...entry, file };
+  }
+  for (const pattern of SKIP_PATTERNS) {
+    if (pattern.test(file)) return { surface: 'skip', reason: 'no runtime impact', file };
+  }
+  return { surface: 'focused', reason: 'unknown runtime impact; run focused checks', file };
+}
+
+function parseChangedFilesFromDiff(diff = '') {
+  const files = [];
+  for (const line of String(diff || '').split('\n')) {
+    const match = line.match(/^diff --git a\/(.+?) b\/(.+)$/);
+    if (match) files.push(match[2]);
+  }
+  return normalizeFiles(files);
+}
+
+function planQaScenario(input = {}) {
+  const files = normalizeFiles(input.files || parseChangedFilesFromDiff(input.diff || ''));
+  const classifications = files.map(classifyFile);
+  const surfaces = Array.from(new Set(classifications.map((entry) => entry.surface)));
+  const runtimeChanges = classifications.filter((entry) => entry.surface !== 'skip');
+  const skipOnly = files.length > 0 && runtimeChanges.length === 0;
+
+  const recommendedRunner = chooseRunner(surfaces, input);
+  const userScenario = buildUserScenario(runtimeChanges, input);
+  return {
+    name: 'thumbgate-user-impact-qa-scenario',
+    status: skipOnly ? 'skip' : 'actionable',
+    files,
+    classifications,
+    recommendedRunner,
+    userScenario,
+    commands: buildCommands(recommendedRunner, runtimeChanges),
+    regressionPolicy: skipOnly
+      ? 'skip durable QA; no runtime-impact files changed'
+      : 'if the QA agent finds a deterministic failure, convert it into a focused regression test before opening a fix PR',
+    transientFailurePolicy: 'doctor the browser/computer-use runner once, retry once, then label as infrastructure-flaky instead of product-regression',
+  };
+}
+
+function chooseRunner(surfaces, input = {}) {
+  if (input.forceComputerUse || surfaces.includes('plugin') || surfaces.includes('agent-adapter')) return 'computer-use-qa';
+  if (surfaces.includes('browser') || surfaces.includes('api')) return 'browser-qa';
+  if (surfaces.includes('cli') || surfaces.includes('agent-runtime') || surfaces.includes('package')) return 'focused-node-qa';
+  if (surfaces.every((surface) => surface === 'skip')) return 'skip';
+  return 'focused-node-qa';
+}
+
+function buildUserScenario(runtimeChanges, input = {}) {
+  if (runtimeChanges.length === 0) return 'No user-impact scenario required; changed files are docs, tests, reports, or proof artifacts only.';
+  const surfaces = Array.from(new Set(runtimeChanges.map((entry) => entry.surface)));
+  if (surfaces.includes('browser') || surfaces.includes('api')) {
+    return 'Open the affected page as a user, perform the primary CTA or dashboard action, verify visible state changes, then check the related API response.';
+  }
+  if (surfaces.includes('plugin') || surfaces.includes('agent-adapter')) {
+    return 'Install or reload the affected agent integration, run one thumbs-up and one thumbs-down capture, then verify the next risky action is gated.';
+  }
+  if (surfaces.includes('cli')) {
+    return 'Run the changed CLI command with --help and one realistic command path, then verify exit code, JSON output, and no stale command copy.';
+  }
+  return input.scenario || 'Run the focused test for the changed runtime surface, then verify the behavior with one realistic operator workflow.';
+}
+
+function buildCommands(runner, runtimeChanges) {
+  if (runner === 'skip') return [];
+  const commands = ['npm test -- --test-concurrency=1'];
+  if (runner === 'browser-qa') commands.push('npx playwright test tests/e2e --project=chromium');
+  if (runner === 'computer-use-qa') commands.push('node scripts/qa-scenario-planner.js --doctor-runner');
+  if (runtimeChanges.some((entry) => entry.surface === 'package')) commands.push('npm pack --dry-run');
+  return commands;
+}
+
+function parseArgs(argv = process.argv.slice(2)) {
+  const args = {};
+  for (const arg of argv) {
+    if (arg === '--json') args.json = true;
+    else if (arg === '--doctor-runner') args.doctorRunner = true;
+    else if (arg.startsWith('--files=')) args.files = arg.slice('--files='.length).split(',');
+    else if (arg.startsWith('--diff-file=')) args.diff = fs.readFileSync(arg.slice('--diff-file='.length), 'utf8');
+    else if (arg.startsWith('--scenario=')) args.scenario = arg.slice('--scenario='.length);
+  }
+  return args;
+}
+
+if (require.main === module) {
+  const args = parseArgs();
+  if (args.doctorRunner) {
+    console.log('QA runner doctor: verify browser/computer-use target, screenshot capture, and network reachability before blaming product code.');
+    process.exit(0);
+  }
+  const report = planQaScenario(args);
+  if (args.json) console.log(JSON.stringify(report, null, 2));
+  else {
+    console.log(`${report.status.toUpperCase()}: ${report.userScenario}`);
+    for (const command of report.commands) console.log(`- ${command}`);
+  }
+}
+
+module.exports = {
+  classifyFile,
+  parseChangedFilesFromDiff,
+  planQaScenario,
+};

package/scripts/repeat-metric.js

@@ -0,0 +1,137 @@
+'use strict';
+
+// ---------------------------------------------------------------------------
+// repeat-metric — first-class "repeat-attempts blocked before execution" metric
+//
+// This module exposes data ThumbGate already collects in gate-stats state. It
+// does NOT write to disk; it is a pure function over gates-engine.loadStats().
+//
+// The headline number is stats.recurringBlocks — incremented by recordStat()
+// in gates-engine.js every time the same gate blocks/warns the same sanitized
+// action fingerprint within one session bucket. That is "a pre-action gate fire
+// that stopped a tool call the agent had already been blocked on", rather than
+// merely "the same noisy gate fired again."
+// ---------------------------------------------------------------------------
+
+const gatesEngine = require('./gates-engine');
+
+/**
+ * Derive a per-gate { firstBlocks, repeatBlocks } split from the raw stats.
+ *
+ * Modern stats record, per session bucket, which sanitized action fingerprints
+ * each gate fired on:
+ *   stats.sessionFiredActions[sessionKey][gateId][fingerprint] === true
+ *
+ * firstBlocks is the count of distinct first action fingerprints. Legacy stats
+ * without fingerprints fall back to the old per-session-gate split.
+ *
+ * total block+warn events come from stats.byGate[id] (blocked + warned), which
+ * recordStat() also maintains. repeatBlocks is clamped to >= 0 to stay robust
+ * against partially-written / legacy state.
+ *
+ * @param {object} stats raw object returned by gates-engine.loadStats()
+ * @returns {Object<string,{firstBlocks:number, repeatBlocks:number}>}
+ */
+function computeByGateSplit(stats) {
+  const byGate = {};
+  const sessionFiredActions = (stats && stats.sessionFiredActions) || {};
+  const sessionFiredGates = (stats && stats.sessionFiredGates) || {};
+  const rawByGate = (stats && stats.byGate) || {};
+
+  // Count distinct action fingerprints each gate fired on => firstBlocks.
+  const firstBlocksByGate = {};
+  const gatesWithActionStats = new Set();
+  for (const sessionKey of Object.keys(sessionFiredActions)) {
+    const fired = sessionFiredActions[sessionKey] || {};
+    for (const gateId of Object.keys(fired)) {
+      const fingerprints = fired[gateId] || {};
+      const count = Object.values(fingerprints).filter(Boolean).length;
+      if (count > 0) {
+        gatesWithActionStats.add(gateId);
+        firstBlocksByGate[gateId] = (firstBlocksByGate[gateId] || 0) + count;
+      }
+    }
+  }
+
+  // Legacy fallback: old stats only tracked gate fired per session bucket.
+  for (const sessionKey of Object.keys(sessionFiredGates)) {
+    const fired = sessionFiredGates[sessionKey] || {};
+    for (const gateId of Object.keys(fired)) {
+      if (fired[gateId] && !gatesWithActionStats.has(gateId)) {
+        firstBlocksByGate[gateId] = (firstBlocksByGate[gateId] || 0) + 1;
+      }
+    }
+  }
+
+  // Union of every gate id we know about from either source.
+  const gateIds = new Set([
+    ...Object.keys(rawByGate),
+    ...Object.keys(firstBlocksByGate),
+    ...Object.keys(sessionFiredActions).flatMap((sessionKey) => Object.keys(sessionFiredActions[sessionKey] || {})),
+  ]);
+
+  for (const gateId of gateIds) {
+    const gateStat = rawByGate[gateId] || {};
+    const totalFires = (gateStat.blocked || 0) + (gateStat.warned || 0);
+    const firstBlocks = firstBlocksByGate[gateId] || 0;
+    // Repeat fires are total fires beyond the first fire per session bucket.
+    const repeatBlocks = Math.max(0, totalFires - firstBlocks);
+    byGate[gateId] = { firstBlocks, repeatBlocks };
+  }
+
+  return byGate;
+}
+
+/**
+ * Compute the repeat-attempts-blocked-before-execution metric.
+ *
+ * Pure read of gates-engine.loadStats(); no disk writes.
+ *
+ * @returns {{
+ *   repeatBlocksBeforeExecution: number,
+ *   recurringBlocks: number,
+ *   totalBlocked: number,
+ *   byGate: Object<string,{firstBlocks:number, repeatBlocks:number}>
+ * }}
+ */
+function computeRepeatMetric() {
+  let stats;
+  try {
+    stats = gatesEngine.loadStats() || {};
+  } catch (_) {
+    stats = {};
+  }
+
+  const recurringBlocks = Number(stats.recurringBlocks || 0);
+  const totalBlocked = Number(stats.blocked || 0);
+
+  return {
+    // Headline: a pre-action block that stopped a tool call the agent had
+    // already been blocked on this session.
+    repeatBlocksBeforeExecution: recurringBlocks,
+    recurringBlocks,
+    totalBlocked,
+    byGate: computeByGateSplit(stats),
+  };
+}
+
+/**
+ * Add a `repeat` sub-key to a gate-stats object WITHOUT mutating the original.
+ *
+ * Takes the object returned by gate-stats.calculateStats() or
+ * dashboard.computeGateStats() and returns a shallow copy with the repeat
+ * metric attached. The caller's file does not need to import any internals.
+ *
+ * @param {object} gateStatsObject
+ * @returns {object} copy of gateStatsObject with `.repeat`
+ */
+function mergeRepeatMetricIntoGateStats(gateStatsObject) {
+  const base = gateStatsObject && typeof gateStatsObject === 'object' ? gateStatsObject : {};
+  return Object.assign({}, base, { repeat: computeRepeatMetric() });
+}
+
+module.exports = {
+  computeRepeatMetric,
+  mergeRepeatMetricIntoGateStats,
+  computeByGateSplit,
+};

package/scripts/secret-fixture-tokens.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const FIXTURE_TOKENS = {
+  awsAccessKeyId: '__TG_FIXTURE_AWS_ACCESS_KEY_ID__',
+  githubPat: '__TG_FIXTURE_GITHUB_PAT__',
+  openAiLegacyKey: '__TG_FIXTURE_OPENAI_LEGACY_KEY__',
+  openAiProjectKey: '__TG_FIXTURE_OPENAI_PROJECT_KEY__',
+  rsaPrivateKeyHeader: '__TG_FIXTURE_RSA_PRIVATE_KEY_HEADER__',
+  ecPrivateKeyHeader: '__TG_FIXTURE_EC_PRIVATE_KEY_HEADER__',
+  privateKeyHeader: '__TG_FIXTURE_PRIVATE_KEY_HEADER__',
+};
+
+function buildAwsAccessKeyId() {
+  return ['AKIA', 'IOSFODNN7EXAMPLE'].join('');
+}
+
+function buildGitHubPat() {
+  return ['gh', 'p_', 'x'.repeat(36)].join('');
+}
+
+function buildOpenAiLegacyKey() {
+  return ['sk', '-', 'abcdefghijklmnopqrstuvwxyz01234567890'].join('');
+}
+
+function buildOpenAiProjectKey() {
+  return ['sk', '-proj-', 'abcdefghijklmnopqrstuvwxyz01234567890'].join('');
+}
+
+function buildPemHeader(prefix = '') {
+  return ['-----BEGIN ', prefix, 'PRIVATE KEY-----'].join('');
+}
+
+function fixtureReplacements() {
+  return [
+    [FIXTURE_TOKENS.awsAccessKeyId, buildAwsAccessKeyId()],
+    [FIXTURE_TOKENS.githubPat, buildGitHubPat()],
+    [FIXTURE_TOKENS.openAiLegacyKey, buildOpenAiLegacyKey()],
+    [FIXTURE_TOKENS.openAiProjectKey, buildOpenAiProjectKey()],
+    [FIXTURE_TOKENS.rsaPrivateKeyHeader, buildPemHeader('RSA ')],
+    [FIXTURE_TOKENS.ecPrivateKeyHeader, buildPemHeader('EC ')],
+    [FIXTURE_TOKENS.privateKeyHeader, buildPemHeader('')],
+  ];
+}
+
+function expandFixturePlaceholders(value) {
+  let expanded = String(value || '');
+  for (const [token, replacement] of fixtureReplacements()) {
+    expanded = expanded.split(token).join(replacement);
+  }
+  return expanded;
+}
+
+module.exports = {
+  FIXTURE_TOKENS,
+  buildAwsAccessKeyId,
+  buildGitHubPat,
+  buildOpenAiLegacyKey,
+  buildOpenAiProjectKey,
+  buildPemHeader,
+  expandFixturePlaceholders,
+};

package/scripts/secret-redaction.js

@@ -0,0 +1,166 @@
+'use strict';
+
+/**
+ * secret-redaction.js — the single, canonical secret-redaction helper.
+ *
+ * WHY THIS EXISTS
+ * On 2026-06-10 a live Stripe `sk_live_` key was found in plaintext inside a captured
+ * `.thumbgate/conversation-window.jsonl`. ThumbGate must never become a secret-leak vector:
+ * secrets must be redacted (a) before any conversation/feedback/memory record lands on disk,
+ * and (b) before any training/analytics dataset is exported or shared.
+ *
+ * This module is the ONE place that owns redaction-at-rest. Capture writers and dataset
+ * exporters all call into it instead of each rolling their own. It is intentionally separate
+ * from `secret-scanner.js`: that module is the PreToolUse *scan/block* layer and deliberately
+ * tolerates `sk_test_`/`test_token` inside commands. For data persisted to disk we redact
+ * test-mode secrets too — a `sk_test_` key is still a credential we should not store.
+ *
+ * NOT REDACTED ON PURPOSE
+ *   - Stripe publishable keys (`pk_live_`, `pk_test_`) are public by design. No pattern matches
+ *     them, and the generic `key=value` pattern keys on `api_key|secret|token|...`, never on a
+ *     bare `publishable_key`, so they are preserved verbatim.
+ *
+ * Properties:
+ *   - Idempotent: re-redacting already-redacted text is a no-op (the `[REDACTED:id]` marker
+ *     contains characters outside every value charset).
+ *   - Non-mutating: `redactSecretsDeep` returns a redacted copy; inputs are untouched.
+ */
+
+const REDACTED = (id) => `[REDACTED:${id}]`;
+
+// Identifier names that denote a credential, used by the generic `key = value` pattern. Kept as
+// two small matchers (instead of one mega-alternation) so the assignment regex stays simple.
+const SECRET_KEY_NAME = /(?:api[_-]?key|secret|token|password|passwd|credential|private[_-]?key|access[_-]?token|client[_-]?secret)/i;
+// Public identifiers whose values are not secrets (e.g. Stripe publishable `pk_*` keys). Excluded
+// so `publishable_key = pk_live_…` is preserved verbatim.
+const PUBLIC_KEY_NAME = /publishable|public/i;
+
+/**
+ * Ordered list of redaction patterns. Order matters: the most specific provider patterns run
+ * before the broad `key=value` fallback so a known secret keeps its precise label. Every regex
+ * is `g` (and case-insensitive where appropriate) so all occurrences are replaced.
+ *
+ * `replace` may be a string or a function `(match, ...groups) => string`.
+ */
+const SECRET_REDACTION_PATTERNS = [
+  // PEM / OpenSSH private key blocks — redact the whole block.
+  {
+    id: 'private_key_block',
+    label: 'Private key block',
+    regex: /-----BEGIN (?:RSA |EC |OPENSSH |DSA |PGP )?PRIVATE KEY-----[\s\S]+?-----END (?:RSA |EC |OPENSSH |DSA |PGP )?PRIVATE KEY-----/g,
+  },
+
+  // Stripe secret-bearing keys. Publishable keys (pk_*) are intentionally absent.
+  { id: 'stripe_live_secret', label: 'Stripe live secret key', regex: /\bsk_live_[A-Za-z0-9]{8,}/g },
+  { id: 'stripe_test_secret', label: 'Stripe test secret key', regex: /\bsk_test_[A-Za-z0-9]{8,}/g },
+  { id: 'stripe_restricted_live', label: 'Stripe restricted live key', regex: /\brk_live_[A-Za-z0-9]{8,}/g },
+  { id: 'stripe_restricted_test', label: 'Stripe restricted test key', regex: /\brk_test_[A-Za-z0-9]{8,}/g },
+  { id: 'stripe_webhook_secret', label: 'Stripe webhook signing secret', regex: /\bwhsec_[A-Za-z0-9]{8,}/g },
+
+  // Anthropic / OpenAI. Run before the legacy `sk-` pattern so the precise label wins.
+  { id: 'anthropic_api_key', label: 'Anthropic API key', regex: /\bsk-ant-[A-Za-z0-9_-]{16,}/g },
+  { id: 'openai_project_key', label: 'OpenAI project key', regex: /\bsk-proj-[A-Za-z0-9_-]{16,}/g },
+  { id: 'openai_api_key', label: 'OpenAI API key', regex: /\bsk-[A-Za-z0-9]{20,}/g },
+
+  // GitHub tokens.
+  { id: 'github_pat', label: 'GitHub personal access token', regex: /\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{16,}/g },
+  { id: 'github_fine_grained_pat', label: 'GitHub fine-grained token', regex: /\bgithub_pat_\w{20,}/g },
+
+  // Slack tokens.
+  { id: 'slack_token', label: 'Slack token', regex: /\bxox[abprs]-[A-Za-z0-9-]{10,}/g },
+
+  // Google API key.
+  { id: 'google_api_key', label: 'Google API key', regex: /\bAIza[0-9A-Za-z_-]{35}/g },
+
+  // AWS access key id (long-lived AKIA + temporary ASIA).
+  { id: 'aws_access_key', label: 'AWS access key id', regex: /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g },
+
+  // JSON Web Tokens.
+  {
+    id: 'jwt',
+    label: 'JSON Web Token',
+    regex: /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9._-]{8,}\.[A-Za-z0-9._-]{8,}/g,
+  },
+
+  // `Authorization: Bearer <token>` style. Keep the scheme word, redact the credential.
+  {
+    id: 'bearer_token',
+    label: 'Bearer token',
+    regex: /\b(Bearer|Token)\s+[a-z0-9._~+/=-]{16,}/gi,
+    replace: (_m, scheme) => `${scheme} ${REDACTED('bearer_token')}`,
+  },
+
+  // Generic `<name> = <value>` / `<name>: "<value>"` assignment with a 16+ char whitespace-free
+  // value. A simple matcher finds every assignment; the replace fn redacts only when the name is a
+  // credential (SECRET_KEY_NAME) and not a public identifier (PUBLIC_KEY_NAME), so `publishable_key`
+  // is preserved. Runs last so provider-specific labels are preferred.
+  {
+    id: 'secret_assignment',
+    label: 'Secret assignment',
+    regex: /\b([\w.-]{2,40})(\s*[:=]\s*["']?)([A-Za-z0-9._+=~/-]{16,})(["']?)/g,
+    replace: (match, key, pre, _value, post) =>
+      (SECRET_KEY_NAME.test(key) && !PUBLIC_KEY_NAME.test(key))
+        ? `${key}${pre}${REDACTED('secret_assignment')}${post}`
+        : match,
+  },
+];
+
+/**
+ * Redact secrets from a single string. Returns the input unchanged when it is not a non-empty
+ * string. Each pattern's lastIndex is reset before use so the module-level (stateful, `g`-flag)
+ * regexes are safe to reuse across calls.
+ *
+ * @param {string} text
+ * @returns {string}
+ */
+function redactSecrets(text) {
+  if (typeof text !== 'string' || text.length === 0) return text;
+  let out = text;
+  for (const pattern of SECRET_REDACTION_PATTERNS) {
+    pattern.regex.lastIndex = 0;
+    const replacement = pattern.replace || REDACTED(pattern.id);
+    out = out.replace(pattern.regex, replacement);
+  }
+  return out;
+}
+
+/**
+ * Returns true if `text` contains at least one redactable secret.
+ * @param {string} text
+ * @returns {boolean}
+ */
+function containsSecret(text) {
+  if (typeof text !== 'string' || text.length === 0) return false;
+  return SECRET_REDACTION_PATTERNS.some((pattern) => {
+    pattern.regex.lastIndex = 0;
+    return pattern.regex.test(text);
+  });
+}
+
+/**
+ * Recursively redact every string contained in `value`. Objects and arrays are deep-copied so
+ * the input is never mutated; non-string primitives pass through untouched. Object keys are left
+ * as-is (only values are redacted).
+ *
+ * @param {*} value
+ * @returns {*} redacted copy
+ */
+function redactSecretsDeep(value) {
+  if (typeof value === 'string') return redactSecrets(value);
+  if (Array.isArray(value)) return value.map((item) => redactSecretsDeep(item));
+  if (value && typeof value === 'object') {
+    const out = {};
+    for (const [key, val] of Object.entries(value)) {
+      out[key] = redactSecretsDeep(val);
+    }
+    return out;
+  }
+  return value;
+}
+
+module.exports = {
+  SECRET_REDACTION_PATTERNS,
+  redactSecrets,
+  redactSecretsDeep,
+  containsSecret,
+};

package/scripts/self-harness-optimizer.js

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+/**
+ * Self-Harness Optimizer
+ * 
+ * Implements the continuous self-improving loop from the "Self-Harness" paradigm (arXiv:2606.09498):
+ * 1. Weakness Mining: Reads auto-promoted gates from repeated failures (.thumbgate/auto-promoted-gates.json)
+ * 2. Harness Proposal: Generates technical rules and injects them directly into system prompts (AGENTS.md & GEMINI.md)
+ * 3. Validation: Runs quick test suites to ensure prompt updates do not introduce regressions.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const ROOT = path.join(__dirname, '..');
+const GATES_PATH = path.join(ROOT, '.thumbgate', 'auto-promoted-gates.json');
+const AGENTS_MD_PATH = path.join(ROOT, 'AGENTS.md');
+const GEMINI_MD_PATH = path.join(ROOT, 'GEMINI.md');
+
+const RULE_SECTION_HEADER = '## 🛡️ Self-Harness Prevention Rules (Auto-Generated)';
+
+function readGates() {
+  if (!fs.existsSync(GATES_PATH)) return [];
+  try {
+    const data = JSON.parse(fs.readFileSync(GATES_PATH, 'utf-8'));
+    return Array.isArray(data.gates) ? data.gates : [];
+  } catch (err) {
+    console.error('Failed to parse auto-promoted-gates.json:', err);
+    return [];
+  }
+}
+
+function generateRuleSection(gates) {
+  if (gates.length === 0) {
+    return `${RULE_SECTION_HEADER}\n\n- No active auto-generated prevention rules at this time.\n`;
+  }
+
+  const lines = [
+    RULE_SECTION_HEADER,
+    '',
+    '> [!IMPORTANT]',
+    '> The following rules were automatically derived from execution failures and thumbs-down feedback.',
+    '> You MUST follow these constraints strictly to prevent repeated errors.',
+    ''
+  ];
+
+  gates.forEach(gate => {
+    // Extract rule message or pattern
+    const ruleText = gate.message ? gate.message.replace('Automatically blocked due to repeated failures: ', '') : `NEVER match pattern: ${gate.pattern}`;
+    lines.push(`- **Rule [${gate.id}]**: ${ruleText}`);
+  });
+
+  lines.push('');
+  return lines.join('\n');
+}
+
+function updatePromptFile(filePath, newSection) {
+  if (!fs.existsSync(filePath)) {
+    console.warn(`Prompt file not found: ${filePath}`);
+    return null;
+  }
+
+  const content = fs.readFileSync(filePath, 'utf-8');
+  const backup = content;
+
+  let newContent;
+  const index = content.indexOf(RULE_SECTION_HEADER);
+  if (index !== -1) {
+    // Replace existing section till the end or next major section
+    const before = content.substring(0, index);
+    const remainder = content.substring(index);
+    
+    // Find next header (e.g. '## ')
+    const nextHeaderIndex = remainder.slice(RULE_SECTION_HEADER.length).search(/\n## /);
+    if (nextHeaderIndex !== -1) {
+      const after = remainder.substring(RULE_SECTION_HEADER.length + nextHeaderIndex + 1);
+      newContent = before + newSection + after;
+    } else {
+      newContent = before + newSection;
+    }
+  } else {
+    // Append to the end of the file
+    newContent = content.trim() + '\n\n' + newSection;
+  }
+
+  fs.writeFileSync(filePath, newContent, 'utf-8');
+  return backup;
+}
+
+function validateAndRollback(backups) {
+  console.log('Running quick validation suite...');
+  try {
+    execSync('npm run verify:quick', { cwd: ROOT, stdio: 'inherit' });
+    console.log('✅ Validation succeeded! No regressions detected.');
+    
+    // Auto-commit prompt updates to git if validation succeeds
+    try {
+      execSync('git add AGENTS.md GEMINI.md', { cwd: ROOT, stdio: 'ignore' });
+      execSync('git commit -m "chore(prompt): auto-update self-harness prevention rules [auto-commit]"', { cwd: ROOT, stdio: 'ignore' });
+      console.log('✅ Prompt updates auto-committed to git.');
+    } catch (gitErr) {
+      console.warn('⚠️ Git commit failed or no changes to commit:', gitErr.message);
+    }
+    
+    return true;
+  } catch (err) {
+    console.error('❌ Validation failed! Reverting prompt changes.');
+    for (const [filePath, backupContent] of Object.entries(backups)) {
+      if (backupContent) {
+        fs.writeFileSync(filePath, backupContent, 'utf-8');
+        console.log(`Reverted: ${path.basename(filePath)}`);
+      }
+    }
+    return false;
+  }
+}
+
+function main() {
+  console.log('Mining weaknesses from auto-promoted gates...');
+  const gates = readGates();
+  console.log(`Found ${gates.length} active gates.`);
+
+  const newSection = generateRuleSection(gates);
+  const backups = {};
+
+  console.log('Updating AGENTS.md...');
+  backups[AGENTS_MD_PATH] = updatePromptFile(AGENTS_MD_PATH, newSection);
+
+  console.log('Updating GEMINI.md...');
+  backups[GEMINI_MD_PATH] = updatePromptFile(GEMINI_MD_PATH, newSection);
+
+  const success = validateAndRollback(backups);
+  if (!success) {
+    process.exit(1);
+  }
+  console.log('Self-Harness optimization complete.');
+}
+
+if (require.main === module) {
+  main();
+}