thumbgate 1.30.0 → 1.31.0

package/scripts/feedback-loop.js

@@ -21,6 +21,7 @@ const {
   buildClarificationMessage,
   isGenericFeedbackText,
   normalizeFeedbackText,
+  scoreFeedbackReward,
 } = require('./feedback-quality');
 const {
   buildRubricEvaluation,
@@ -1613,6 +1614,14 @@ function captureFeedback(params) {
     return firewallBlocked;
   }
 
+  // Grade the correction the operator actually wrote, and persist it with the
+  // entry. assessFeedbackActionability already answered the binary question
+  // (promotable at all); this is the graded one, and without computing it here
+  // the scorer would be reachable-but-never-called — the same defect class it
+  // was added to help detect.
+  const rewardScore = scoreFeedbackReward(feedbackEvent);
+  if (rewardScore) feedbackEvent.rewardScore = rewardScore;
+
   appendJSONL(FEEDBACK_LOG_PATH, feedbackEvent);
   emitAnonymousFeedbackPing(signal);
 
@@ -2243,20 +2252,100 @@ function buildPreventionRules(minOccurrences = 2, options = {}) {
     return Math.exp(-lambda * daysSince);
   }
 
+  // CEO contract tags beat generic richContext.domain=general so honesty/overclaim
+  // whatToChange is not drowned by hook noise in the "general" bucket.
+  const PRIORITY_DOMAIN_TAGS = [
+    'honesty',
+    'overclaim',
+    'completion-claim',
+    'production-truth',
+    'false-completion',
+    'pr-hygiene',
+    'ceo-feedback',
+  ];
+  const GENERIC_TAGS = new Set([
+    'feedback',
+    'negative',
+    'positive',
+    'entity:Customer',
+    'thumbs-down',
+    'thumbs-up',
+  ]);
+
+  function isNoiseTitle(title) {
+    const t = String(title || '');
+    return /hookEventName|user_prompt_submit|"sessionId"/i.test(t);
+  }
+
+  function extractAvoidLine(content) {
+    return String(content || '')
+      .split('\n')
+      .find((l) => l.toLowerCase().startsWith('how to avoid:')) || null;
+  }
+
+  function domainKeyForMemory(m) {
+    const tags = Array.isArray(m.tags) ? m.tags : [];
+    for (const tag of PRIORITY_DOMAIN_TAGS) {
+      if (tags.includes(tag)) return tag;
+    }
+    const rcDomain = m.richContext && m.richContext.domain;
+    if (rcDomain && rcDomain !== 'unknown' && rcDomain !== 'general') {
+      return rcDomain;
+    }
+    return tags.find((t) => !GENERIC_TAGS.has(t)) || 'general';
+  }
+
+  function pickBestMemory(items) {
+    let best = items[items.length - 1];
+    let bestScore = -Infinity;
+    items.forEach((m, index) => {
+      let score = index;
+      if (isNoiseTitle(m.title)) score -= 1000;
+      const avoid = extractAvoidLine(m.content);
+      if (avoid) score += 100;
+      if (avoid && /never/i.test(avoid)) score += 50;
+      if ((m.tags || []).some((t) => PRIORITY_DOMAIN_TAGS.includes(t))) score += 40;
+      if ((m.occurrences || 1) > 1) score += 10;
+      if (score >= bestScore) {
+        bestScore = score;
+        best = m;
+      }
+    });
+    return best;
+  }
+
   const buckets = {};
   const rubricBuckets = {};
   const diagnosisBuckets = {};
   const repeatedViolationBuckets = {};
+  const priorityContracts = [];
   for (const m of memories) {
-    const key = (m.richContext && m.richContext.domain && m.richContext.domain !== 'unknown')
-      ? m.richContext.domain
-      : (m.tags || []).find((t) => !['feedback', 'negative', 'positive'].includes(t)) || 'general';
+    if (isNoiseTitle(m.title) && !extractAvoidLine(m.content)) {
+      // Skip pure hook-noise shells with no actionable avoid line.
+      continue;
+    }
+    const key = domainKeyForMemory(m);
     if (!buckets[key]) buckets[key] = { items: [], weightedCount: 0 };
     const w = decayWeight(m);
     const occ = m.occurrences || 1;
     buckets[key].items.push(m);
     buckets[key].weightedCount += w * occ;
 
+    const tags = Array.isArray(m.tags) ? m.tags : [];
+    const avoid = extractAvoidLine(m.content);
+    if (
+      avoid
+      && tags.some((t) => PRIORITY_DOMAIN_TAGS.includes(t))
+    ) {
+      priorityContracts.push({
+        id: m.id,
+        tags: tags.filter((t) => PRIORITY_DOMAIN_TAGS.includes(t)),
+        rule: avoid.replace(/^How to avoid:\s*/i, ''),
+        title: m.title,
+        occurrences: occ,
+      });
+    }
+
     const failed = m.rubricSummary && Array.isArray(m.rubricSummary.failingCriteria)
       ? m.rubricSummary.failingCriteria
       : [];
@@ -2294,18 +2383,37 @@ function buildPreventionRules(minOccurrences = 2, options = {}) {
 
   const lines = ['# Prevention Rules', '', 'Generated from negative feedback memories (time-weighted, half-life: ' + decayHalfLifeDays + 'd).'];
 
+  // High-priority CEO contracts: always emit actionable whatToChange (threshold 1).
+  if (priorityContracts.length > 0) {
+    lines.push('');
+    lines.push('## High-Priority Contracts');
+    const seen = new Set();
+    priorityContracts
+      .sort((a, b) => (b.occurrences || 1) - (a.occurrences || 1))
+      .forEach((c) => {
+        const dedupe = c.rule.slice(0, 120);
+        if (seen.has(dedupe)) return;
+        seen.add(dedupe);
+        lines.push(`- **[${c.tags.join(', ')}]** ${c.rule}`);
+        lines.push(`  - Source: ${c.title}`);
+      });
+  }
+
   Object.entries(buckets)
     .sort((a, b) => b[1].weightedCount - a[1].weightedCount)
     .forEach(([domain, { items, weightedCount }]) => {
       const effectiveOccurrences = Math.round(weightedCount);
-      if (effectiveOccurrences < resolvedMinOccurrences) return;
-      const latest = items[items.length - 1];
-      const avoid = (latest.content || '').split('\n').find((l) => l.toLowerCase().startsWith('how to avoid:')) || 'How to avoid: Investigate and prevent recurrence';
+      // Priority domains promote with a single solid memory (CEO contracts).
+      const threshold = PRIORITY_DOMAIN_TAGS.includes(domain) ? 1 : resolvedMinOccurrences;
+      if (effectiveOccurrences < threshold) return;
+      const best = pickBestMemory(items);
+      const avoid = extractAvoidLine(best.content)
+        || 'How to avoid: Investigate and prevent recurrence';
       lines.push('');
       lines.push(`## ${domain}`);
       lines.push(`- Recurrence count: ${items.length} (weighted: ${weightedCount.toFixed(1)})`);
       lines.push(`- Rule: ${avoid.replace(/^How to avoid:\s*/i, '')}`);
-      lines.push(`- Latest mistake: ${latest.title}`);
+      lines.push(`- Latest mistake: ${best.title}`);
     });
 
   const rubricEntries = Object.entries(rubricBuckets)

package/scripts/feedback-paths.js

@@ -78,6 +78,15 @@ function isTransientProjectDir(dirPath, options = {}) {
   if (!normalizedDir) return true;
   if (!dirExists(normalizedDir)) return true;
 
+  // MCP hosts and desktop launchers commonly start global servers from `/` or
+  // the user's home directory. Those are launcher contexts, not projects. If
+  // they win resolution they create `projects/default` / `~/.thumbgate` split
+  // stores and make the same lesson corpus depend on which client started the
+  // process. A durable active-project state is a better signal.
+  if (normalizedDir === path.parse(normalizedDir).root) return true;
+  const homeDir = normalizeDir(getHomeDir(options));
+  if (homeDir && normalizedDir === homeDir) return true;
+
   const runtimeDir = getRuntimeDir(options);
   if (isWithinDir(normalizedDir, runtimeDir)) return true;
 
@@ -119,11 +128,12 @@ function writeActiveProjectState(projectDir, options = {}) {
 function resolveProjectDir(options = {}) {
   const env = options.env || process.env;
   const stored = options.includeStored === false ? null : readActiveProjectState(options);
-  const cwdCandidates = uniquePaths([
-    options.cwd,
-    env.PWD,
-    process.cwd(),
-  ]);
+  // An injected cwd is authoritative for callers that resolve on behalf of a
+  // different process. Mixing in this Node process's cwd can silently route a
+  // global launcher back into ThumbGate's own checkout during diagnostics.
+  const cwdCandidates = uniquePaths(options.cwd
+    ? [options.cwd]
+    : [env.PWD, process.cwd()]);
   const isTransientExecution = cwdCandidates.length > 0
     && cwdCandidates.every((candidate) => isTransientProjectDir(candidate, options));
   const candidates = uniquePaths([
@@ -167,15 +177,12 @@ function getExplicitFeedbackDir(options = {}) {
   const env = options.env || process.env;
   if (options.feedbackDir) return options.feedbackDir;
   if (options.skipExplicitFeedbackDir) return null;
-  // A caller-provided feedback root should stay authoritative over stored
-  // active-project state so isolated CLI/test commands do not drift into a
-  // different project. Only direct project overrides suppress it.
-  if (env.THUMBGATE_FEEDBACK_DIR && !hasDirectProjectScope(options)) {
+  // An explicit storage root is the strongest storage instruction. Project
+  // metadata may still identify the project, but it must not redirect writes
+  // out of an isolated test/runtime directory.
+  if (env.THUMBGATE_FEEDBACK_DIR) {
     return env.THUMBGATE_FEEDBACK_DIR;
   }
-  if (hasDirectProjectScope(options)) {
-    return null;
-  }
   if (env.RAILWAY_VOLUME_MOUNT_PATH) {
     return path.join(env.RAILWAY_VOLUME_MOUNT_PATH, 'feedback');
   }
@@ -221,7 +228,19 @@ function resolveFeedbackDir(options = {}) {
   const localLegacy = getLegacyFeedbackDir(options);
   if (dirExists(localLegacy)) return localLegacy;
 
-  return getGlobalFeedbackDir(options);
+  // Existing installations may only have the pre-1.31 basename-scoped store.
+  // Preserve that corpus instead of silently switching to an empty directory.
+  // New projects never create this legacy global shape, so same-basename
+  // projects remain isolated going forward.
+  const globalLegacy = getGlobalFeedbackDir(options);
+  if (dirExists(globalLegacy)) return globalLegacy;
+
+  const projectDir = resolveProjectDir(options);
+  // New real projects select their collision-free local store before it is
+  // created, preventing the old first-write flip from global to local.
+  if (!isTransientProjectDir(projectDir, options)) return localThumbgate;
+
+  return globalLegacy;
 }
 
 function getFeedbackPaths(options = {}) {

package/scripts/feedback-quality.js

@@ -154,6 +154,58 @@ function isGenericFeedbackText(value, signal) {
   return rules.some((pattern) => pattern.test(normalized));
 }
 
+/**
+ * Score a captured feedback entry with the reward rubric in judge-reward-function.
+ *
+ * `assessFeedbackActionability` answers a binary question — is this promotable at
+ * all. This answers the graded one: how good is the correction the operator wrote.
+ * A 👎 whose whatToChange is "be better" and a 👎 that says "run npm test before
+ * claiming green, see commit abc123" are both promotable; only one of them makes a
+ * useful prevention rule.
+ *
+ * Deterministic by construction. `buildCompositeReward` runs its Boolean rubric
+ * first and only consults an LLM judge if one is injected; we deliberately inject
+ * none, so this returns `scoringMode: 'deterministic_only'` and costs nothing. That
+ * matters: ANTHROPIC_API_KEY is frequently absent, and a scorer that silently
+ * degrades to nothing is worse than one that never claimed the LLM path.
+ *
+ * Reporting only — nothing here gates promotion. Wiring a fresh quality signal
+ * straight into enforcement would change which lessons become blocking rules, and
+ * that decision deserves its own change with its own evidence.
+ *
+ * @returns {{score: number, label: string, scoringMode: string, dimensions: object, passed: boolean}|null}
+ *   null when there is no corrective text worth scoring.
+ */
+function scoreFeedbackReward(params = {}) {
+  const signal = normalizeFeedbackSignal(params.signal);
+  const prediction = normalizeFeedbackText(
+    signal === 'positive'
+      ? (params.whatWorked || params.context)
+      : (params.whatToChange || params.whatWentWrong || params.context),
+  );
+  if (!prediction) return null;
+
+  // Lazy-require: judge-reward-function is a leaf, but feedback-quality is required
+  // by feedback-loop and three other modules — keep the import cost off that path
+  // until someone actually asks for a score.
+  let buildCompositeReward;
+  try {
+    ({ buildCompositeReward } = require('./judge-reward-function'));
+  } catch {
+    return null;
+  }
+  if (typeof buildCompositeReward !== 'function') return null;
+
+  const reward = buildCompositeReward({ prediction });
+  return {
+    score: reward.score,
+    label: reward.label,
+    scoringMode: reward.scoringMode || 'deterministic_only',
+    dimensions: reward.deterministic ? reward.deterministic.dimensions : {},
+    passed: Boolean(reward.deterministic && reward.deterministic.passed),
+  };
+}
+
 function assessFeedbackActionability(params = {}) {
   const signal = normalizeFeedbackSignal(params.signal);
   const primaryFields = signal === 'positive'
@@ -222,4 +274,5 @@ module.exports = {
   isGenericFeedbackText,
   assessFeedbackActionability,
   buildClarificationMessage,
+  scoreFeedbackReward,
 };

package/scripts/filesystem-search.js

@@ -154,14 +154,19 @@ function scoreRecord(queryTokens, queryText, record) {
 // ---------------------------------------------------------------------------
 
 function searchFeedbackLog(queryText, limit = 5, options = {}) {
-  const logPath = path.join(options.feedbackDir || getFeedbackDir(), 'feedback-log.jsonl');
+  const feedbackDir = options.feedbackDir || getFeedbackDir();
+  const logPath = path.join(feedbackDir, 'feedback-log.jsonl');
   let records = readJsonl(logPath);
 
-  // SQLite fallback: if JSONL is empty/tiny, pull records from the lesson DB
-  if (records.length <= 1) {
+  // SQLite fallback is allowed only inside the exact selected feedback root.
+  // Falling back through lesson-db's ambient default can cross project/tenant
+  // boundaries when a sparse project has zero or one JSONL row.
+  const lessonDbPath = path.join(feedbackDir, 'lessons.sqlite');
+  if (records.length <= 1 && fs.existsSync(lessonDbPath)) {
+    let db = null;
     try {
       const { initDB } = require('./lesson-db');
-      const db = initDB();
+      db = initDB(lessonDbPath);
       const rows = db.prepare('SELECT * FROM lessons ORDER BY timestamp DESC LIMIT 500').all();
       if (rows.length > records.length) {
         records = rows.map((r) => ({
@@ -171,12 +176,17 @@ function searchFeedbackLog(queryText, limit = 5, options = {}) {
           title: r.title || r.context,
           tags: r.tags ? JSON.parse(r.tags) : [],
           timestamp: r.timestamp,
-          whatWentWrong: r.what_went_wrong,
-          whatWorked: r.what_worked,
-          whatToChange: r.what_to_change,
+          whatWentWrong: r.whatWentWrong ?? r.what_went_wrong,
+          whatWorked: r.whatWorked ?? r.what_worked,
+          whatToChange: r.whatToChange ?? r.what_to_change,
         }));
       }
     } catch { /* lesson-db not available */ }
+    finally {
+      if (db) {
+        try { db.close(); } catch { /* best-effort close */ }
+      }
+    }
   }
 
   // Wildcard query: return all records sorted by recency

package/scripts/gates-engine.js

@@ -1236,11 +1236,28 @@ const COMMAND_WRAPPERS = new Set([
 ]);
 const ENV_ASSIGNMENT_PREFIX = /^[A-Za-z_][A-Za-z0-9_]*=(?:"[^"]*"|'[^']*'|[^\s]*)\s+/;
 const WRAPPER_HEAD = /^([A-Za-z_][\w.-]*)\s+/;
+const LITERAL_COMMAND_SUBSTITUTION_HEADS = [
+  /^\$\(\s*printf\s+(?:(?:['"]?%s['"]?)\s+)?(['"]?)([A-Za-z_][\w.-]*)\1\s*\)\s+/,
+  /^\$\(\s*echo\s+(['"]?)([A-Za-z_][\w.-]*)\1\s*\)\s+/,
+  /^\$\(\s*(?:command\s+-v|which)\s+(['"]?)([A-Za-z_][\w.-]*)\1\s*\)\s+/,
+];
+
+function canonicalizeLiteralCommandSubstitutionHead(segment) {
+  for (const pattern of LITERAL_COMMAND_SUBSTITUTION_HEADS) {
+    const match = String(segment || '').match(pattern);
+    if (match) return `${match[2]} ${String(segment).slice(match[0].length)}`;
+  }
+  return segment;
+}
 
 function canonicalizeSegmentHead(segment) {
   let text = String(segment || '').trim();
   for (let i = 0; i < 12; i += 1) {
     const before = text;
+    // Resolve only literal, side-effect-free command-position substitutions.
+    // Never execute or guess arbitrary shell; this closes common `$(printf git)`
+    // and `$(command -v git)` spellings while keeping matching deterministic.
+    text = canonicalizeLiteralCommandSubstitutionHead(text);
     text = text.replace(ENV_ASSIGNMENT_PREFIX, '');
     const wrapper = text.match(WRAPPER_HEAD);
     if (wrapper && COMMAND_WRAPPERS.has(wrapper[1].toLowerCase())) {

package/scripts/harness-tool-names.js

@@ -0,0 +1,70 @@
+'use strict';
+
+/**
+ * Harness tool names -> canonical gate-engine names.
+ *
+ * Policy gates match Claude Code's vocabulary (Bash, Write, Edit, MultiEdit). Other
+ * harnesses use their own: Cline's .clinerules instructs the agent to gate-check
+ * `execute_command`, `write_to_file`, `replace_in_file` and `browser_action`.
+ * Forwarding those through unchanged meant every gate silently missed — a strict
+ * `gate_check` on `{tool_name: "execute_command", command: "rm -rf /"}` returned ALLOW,
+ * which is precisely the scenario the adapter advertises as protected.
+ *
+ * Argument keys differ too: Cline writes use `path`, Claude Code uses `file_path`.
+ */
+
+const TOOL_NAME_MAP = new Map(Object.entries({
+  // Cline / Roo Code
+  execute_command: 'Bash',
+  write_to_file: 'Write',
+  replace_in_file: 'Edit',
+  apply_diff: 'Edit',
+  insert_content: 'Edit',
+  search_and_replace: 'Edit',
+  // OpenCode / generic MCP
+  bash: 'Bash',
+  shell: 'Bash',
+  run_command: 'Bash',
+  edit_file: 'Edit',
+  write_file: 'Write',
+  create_file: 'Write',
+  str_replace_editor: 'Edit',
+  // Cursor
+  run_terminal_cmd: 'Bash',
+}));
+
+const ARG_KEY_MAP = new Map(Object.entries({
+  path: 'file_path',
+  filePath: 'file_path',
+  target_file: 'file_path',
+  cmd: 'command',
+  shell_command: 'command',
+  diff: 'new_string',
+}));
+
+function canonicalizeToolName(toolName) {
+  const raw = String(toolName || '').trim();
+  if (!raw) return raw;
+  return TOOL_NAME_MAP.get(raw) || TOOL_NAME_MAP.get(raw.toLowerCase()) || raw;
+}
+
+function canonicalizeToolInput(toolInput) {
+  if (!toolInput || typeof toolInput !== 'object' || Array.isArray(toolInput)) return toolInput || {};
+  const out = {};
+  for (const [key, value] of Object.entries(toolInput)) {
+    const canonicalKey = ARG_KEY_MAP.get(key) || key;
+    // Never let a mapped key clobber one the caller already supplied canonically.
+    if (canonicalKey in out) continue;
+    out[canonicalKey] = value;
+  }
+  return out;
+}
+
+function canonicalizeToolCall(toolName, toolInput) {
+  return {
+    toolName: canonicalizeToolName(toolName),
+    toolInput: canonicalizeToolInput(toolInput),
+  };
+}
+
+module.exports = { canonicalizeToolCall, canonicalizeToolName, canonicalizeToolInput, TOOL_NAME_MAP, ARG_KEY_MAP };

package/scripts/hook-runtime.js

@@ -51,13 +51,20 @@ function resolveCliCommand(subcommand) {
 }
 
 function resolveCodexCliCommand(subcommand) {
+  // Codex hooks live in user-global config. Pinning them to a disposable source
+  // worktree breaks every hook as soon as normal post-merge cleanup removes it.
+  // The stable @latest launcher stays offline at configuration time and survives
+  // cleanup. Checkout-pinned hooks remain available as an explicit dev override.
+  if (isSourceCheckout(PKG_ROOT) && process.env.THUMBGATE_CODEX_USE_SOURCE_RUNTIME === '1') {
+    return `node ${shellQuote(path.join(PKG_ROOT, 'bin', 'cli.js'))} ${subcommand}`;
+  }
+  if (isSourceCheckout(PKG_ROOT)) {
+    return publishedCliShellCommand('latest', [subcommand]);
+  }
   const version = packageVersion();
   if (publishedHookCommandsAvailable(version)) {
     return publishedCliShellCommand('latest', [subcommand]);
   }
-  if (isSourceCheckout(PKG_ROOT)) {
-    return `node ${shellQuote(path.join(PKG_ROOT, 'bin', 'cli.js'))} ${subcommand}`;
-  }
   return publishedCliShellCommand('latest', [subcommand]);
 }
 

package/scripts/lesson-db.js

@@ -15,14 +15,16 @@
 const path = require('node:path');
 const fs = require('node:fs');
 const { readJsonl } = require('./fs-utils');
+const { resolveFeedbackDir } = require('./feedback-paths');
 
-const PROJECT_ROOT = path.join(__dirname, '..');
-const DEFAULT_DB_PATH = path.join(PROJECT_ROOT, '.claude', 'memory', 'lessons.sqlite');
+function resolveDefaultDbPath(options = {}) {
+  return path.join(resolveFeedbackDir(options), 'lessons.sqlite');
+}
 
 /** @returns {import('better-sqlite3').Database} */
 function initDB(dbPath) {
   const Database = require('better-sqlite3');
-  const resolvedPath = dbPath || process.env.LESSON_DB_PATH || DEFAULT_DB_PATH;
+  const resolvedPath = dbPath || process.env.LESSON_DB_PATH || resolveDefaultDbPath();
 
   // Ensure parent directory exists
   const dir = path.dirname(resolvedPath);
@@ -643,7 +645,7 @@ function safeParseTags(tagsStr) {
   }
 }
 
-module.exports = {
+const lessonDbApi = {
   initDB,
   upsertLesson,
   upsertSession,
@@ -655,5 +657,14 @@ module.exports = {
   getStats,
   getStatsFromDB,
   backfillFromJsonl,
-  DEFAULT_DB_PATH,
+  resolveDefaultDbPath,
 };
+
+// Preserve the public property while resolving it at access time so callers
+// cannot cache a package-checkout path before project selection is known.
+Object.defineProperty(lessonDbApi, 'DEFAULT_DB_PATH', {
+  enumerable: true,
+  get: resolveDefaultDbPath,
+});
+
+module.exports = lessonDbApi;