thumbgate 1.30.0 → 1.34.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/feedback-schema.js

@@ -31,6 +31,9 @@ const {
 } = require('./feedback-quality');
 
 const INFERRED_TAG_RULES = [
+  { tag: 'claw-style', keywords: ['claw', 'enterprise-claw', 'openshell', 'dynamic-tool', 'screen-interaction', 'computer-use'] },
+  { tag: 'hybrid-inference', keywords: ['hybrid', 'cloud-escalation', 'local-route', 'hybrid-route', 'perplexity-pc'] },
+  { tag: 'agent-identity', keywords: ['agent identity', 'audit trail', 'identity separation', 'agent-credential'] },
   { tag: 'thumbgate', keywords: ['thumbgate', 'feedback-loop', 'statusline', 'dashboard', 'mcp'] },
   { tag: 'testing', keywords: ['test', 'testing', 'jest', 'coverage', 'verify', 'verification'] },
   { tag: 'security', keywords: ['security', 'secret', 'credential', 'token', 'auth'] },

package/scripts/file-ledger-lock.js

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Cross-process lock for append-only local ledgers.
+ *
+ * `mkdir` is the atomic acquisition primitive. An owner record prevents a
+ * crashed process from permanently wedging the control plane, while a nonce
+ * check prevents an old owner from deleting a replacement lock.
+ */
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const DEFAULT_STALE_MS = 30 * 1000;
+
+function withFileLedgerLock(lockPath, callback, options = {}) {
+  const resolvedLockPath = path.resolve(lockPath);
+  fs.mkdirSync(path.dirname(resolvedLockPath), { recursive: true });
+  const owner = acquireLock(resolvedLockPath, options);
+  try {
+    if (typeof options.beforeCallback === 'function') options.beforeCallback();
+    return callback();
+  } finally {
+    releaseOwnedLock(resolvedLockPath, owner);
+  }
+}
+
+function acquireLock(lockPath, options) {
+  const now = options.now || new Date();
+  const staleMs = positiveNumber(options.lockStaleMs, DEFAULT_STALE_MS);
+  const owner = {
+    schemaVersion: 'thumbgate-ledger-lock-v1',
+    pid: process.pid,
+    nonce: crypto.randomUUID(),
+    acquiredAt: now.toISOString(),
+  };
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    try {
+      fs.mkdirSync(lockPath);
+      writeOwner(lockPath, owner);
+      return owner;
+    } catch (error) {
+      if (error.code !== 'EEXIST') throw error;
+      if (!recoverStaleLock(lockPath, now, staleMs)) {
+        throw lockError(options, 'ledger is busy; deny and retry only after the active writer finishes');
+      }
+    }
+  }
+  throw lockError(options, 'ledger lock could not be acquired after stale-lock recovery');
+}
+
+function recoverStaleLock(lockPath, now, staleMs) {
+  const observed = readOwner(lockPath);
+  const ageMs = lockAgeMs(lockPath, observed, now);
+  if (ageMs < staleMs || processIsAlive(observed?.pid)) return false;
+
+  // Rename is atomic. If another process already recovered or replaced the
+  // lock, this attempt loses harmlessly and acquisition is retried.
+  const quarantine = `${lockPath}.stale-${process.pid}-${crypto.randomUUID()}`;
+  try {
+    fs.renameSync(lockPath, quarantine);
+  } catch (error) {
+    if (['ENOENT', 'EEXIST'].includes(error.code)) return true;
+    throw error;
+  }
+  fs.rmSync(quarantine, { recursive: true, force: true });
+  return true;
+}
+
+function writeOwner(lockPath, owner) {
+  const target = path.join(lockPath, 'owner.json');
+  const temporary = `${target}.tmp-${process.pid}-${owner.nonce}`;
+  fs.writeFileSync(temporary, `${JSON.stringify(owner)}\n`, { encoding: 'utf8', mode: 0o600 });
+  fs.renameSync(temporary, target);
+}
+
+function readOwner(lockPath) {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(lockPath, 'owner.json'), 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function lockAgeMs(lockPath, owner, now) {
+  const recorded = Date.parse(owner?.acquiredAt || '');
+  if (Number.isFinite(recorded)) return Math.max(0, now.getTime() - recorded);
+  try {
+    return Math.max(0, now.getTime() - fs.statSync(lockPath).mtimeMs);
+  } catch {
+    return Number.POSITIVE_INFINITY;
+  }
+}
+
+function processIsAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code !== 'ESRCH';
+  }
+}
+
+function releaseOwnedLock(lockPath, owner) {
+  const recorded = readOwner(lockPath);
+  if (!recorded || recorded.nonce !== owner.nonce) return;
+  try { fs.unlinkSync(path.join(lockPath, 'owner.json')); } catch (error) {
+    if (error.code !== 'ENOENT') return;
+  }
+  try { fs.rmdirSync(lockPath); } catch { /* a replacement owner wins */ }
+}
+
+function positiveNumber(value, fallback) {
+  const number = Number(value);
+  return Number.isFinite(number) && number > 0 ? number : fallback;
+}
+
+function lockError(options, message) {
+  return typeof options.errorFactory === 'function'
+    ? options.errorFactory(message)
+    : Object.assign(new Error(message), { code: 'THUMBGATE_LEDGER_BUSY' });
+}
+
+module.exports = {
+  DEFAULT_STALE_MS,
+  withFileLedgerLock,
+};

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