thumbgate 1.26.0 → 1.26.2

package/scripts/repeat-metric.js

@@ -0,0 +1,121 @@
+'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 gateId fires twice within one session
+// bucket. That is exactly "a pre-action gate fire that stopped a tool call the
+// agent had already been blocked on", i.e. a repeat attempt prevented before it
+// could round-trip and execute.
+// ---------------------------------------------------------------------------
+
+const gatesEngine = require('./gates-engine');
+
+/**
+ * Derive a per-gate { firstBlocks, repeatBlocks } split from the raw stats.
+ *
+ * recordStat() records, per session bucket, which gates have fired
+ * (stats.sessionFiredGates[sessionKey][gateId] === true). The FIRST fire of a
+ * gate in a bucket marks the flag; every subsequent fire in that same bucket
+ * increments stats.recurringBlocks. So for each gate:
+ *   firstBlocks  = number of distinct session buckets the gate fired in
+ *   repeatBlocks = (total block+warn events for the gate) - firstBlocks
+ *
+ * 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 sessionFiredGates = (stats && stats.sessionFiredGates) || {};
+  const rawByGate = (stats && stats.byGate) || {};
+
+  // Count distinct session buckets each gate fired in => firstBlocks.
+  const firstBlocksByGate = {};
+  for (const sessionKey of Object.keys(sessionFiredGates)) {
+    const fired = sessionFiredGates[sessionKey] || {};
+    for (const gateId of Object.keys(fired)) {
+      if (fired[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),
+  ]);
+
+  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/silent-failure-cluster.js

@@ -4,7 +4,14 @@
 /**
  * Silent-Failure Clustering — Unsupervised candidate source for the meta-agent loop
  *
- * Off by default. Enabled with: THUMBGATE_SILENT_FAILURE_CLUSTERING=1
+ * Default-ON since 2026-05-21. Opt-out with: THUMBGATE_SILENT_FAILURE_CLUSTERING=0
+ * (or set NODE_ENV=test to skip in test runs). Was opt-in for the initial
+ * landing of PR #2285; flipped to default-on because the entire point is to
+ * cover the case where users never give thumbs-down — keeping it opt-in
+ * means lazy users (the ones who need it most) never benefit. Bounded risk:
+ * candidates still flow through meta-agent-loop's existing fp-rate eval, so
+ * a noisy cluster can't auto-promote to a real gate without passing the
+ * same precision/recall thresholds as LLM-generated candidates.
  *
  * Problem: ThumbGate's HITL loop only learns from explicit thumbs-down. Tool calls
  * that fail without user feedback (exit_code != 0, regex-matched error in output,
@@ -460,9 +467,20 @@ function generateSilentFailureCandidates(opts = {}) {
 // CLI
 // ---------------------------------------------------------------------------
 
+/**
+ * Resolve the enabled state. Default ON. Explicit "0" or "false" opts out;
+ * NODE_ENV=test also opts out to keep test runs deterministic.
+ */
+function isSilentFailureClusteringEnabled(env = process.env) {
+  if (env.NODE_ENV === 'test') return false;
+  const raw = (env.THUMBGATE_SILENT_FAILURE_CLUSTERING || '').toLowerCase();
+  if (raw === '0' || raw === 'false' || raw === 'off' || raw === 'no') return false;
+  return true;
+}
+
 async function main() {
-  if (process.env.THUMBGATE_SILENT_FAILURE_CLUSTERING !== '1') {
-    process.stdout.write('silent-failure-cluster: disabled (set THUMBGATE_SILENT_FAILURE_CLUSTERING=1 to enable)\n');
+  if (!isSilentFailureClusteringEnabled()) {
+    process.stdout.write('silent-failure-cluster: disabled (THUMBGATE_SILENT_FAILURE_CLUSTERING=0 or NODE_ENV=test)\n');
     return;
   }
 
@@ -492,6 +510,7 @@ if (require.main === module) {
 
 module.exports = {
   generateSilentFailureCandidates,
+  isSilentFailureClusteringEnabled,
   // exported for testing
   redactSecrets,
   normalizePaths,

package/scripts/tool-registry.js

@@ -895,6 +895,56 @@ const TOOLS = [
       },
     },
   }),
+  destructiveTool({
+    name: 'detect_noop',
+    title: 'Detect No-op Action',
+    description: 'Detect whether a tool call was a no-op (state unchanged) or identical to a prior attempt in the session — a cheap repeat-loop signal. Records the action attempt state for repeat detection.',
+    inputSchema: {
+      type: 'object',
+      required: ['actionId'],
+      properties: {
+        actionId: { type: 'string', description: 'Stable identifier for the action being checked (e.g. the file path or command being attempted)' },
+        kind: { type: 'string', enum: ['file', 'command'], description: 'Action kind: file edit/write or command execution' },
+        filePath: { type: 'string', description: 'Path of the file the action targets (file kind)' },
+        beforeContent: { type: 'string', description: 'File content before the action (file kind)' },
+        afterContent: { type: 'string', description: 'File content after the action (file kind)' },
+        exitCode: { type: 'number', description: 'Command exit code (command kind)' },
+        stdout: { type: 'string', description: 'Command stdout (command kind)' },
+        stderr: { type: 'string', description: 'Command stderr (command kind)' },
+        sessionId: { type: 'string', description: 'Optional session id used to scope repeat-attempt detection' },
+      },
+    },
+  }),
+  destructiveTool({
+    name: 'record_action_receipt',
+    title: 'Record Action Receipt',
+    description: 'Pair a tracked tool call with its outcome (diff, exit code, test result) so a promoted lesson encodes "this action -> this outcome", not just a thumbs signal. Appends to the action-receipts log.',
+    inputSchema: {
+      type: 'object',
+      required: ['actionId'],
+      properties: {
+        actionId: { type: 'string', description: 'Identifier of the tracked action this receipt pairs with' },
+        toolName: { type: 'string', description: 'Name of the tool that was invoked' },
+        toolInput: { type: 'object', description: 'Structured input the tool was called with' },
+        diff: { type: 'string', description: 'Optional unified diff or change summary produced by the action' },
+        exitCode: { type: 'number', description: 'Optional command exit code outcome' },
+        testOutcome: { type: 'string', description: 'Optional test outcome (e.g. passed, failed, 12/12)' },
+        stateHash: { type: 'string', description: 'Optional post-action state hash (from detect_noop)' },
+      },
+    },
+  }),
+  readOnlyTool({
+    name: 'get_action_receipts',
+    title: 'Get Action Receipts',
+    description: 'Read outcome-paired action receipts. Returns the receipt for a specific actionId, or the most recent receipts when no actionId is given.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        actionId: { type: 'string', description: 'Optional action id to fetch the matching receipt for' },
+        limit: { type: 'number', description: 'Max number of recent receipts to return when no actionId is given (default 20)' },
+      },
+    },
+  }),
   readOnlyTool({
     name: 'verify_claim',
     description: 'Check whether a claim has enough tracked evidence before the agent asserts it.',