thumbgate 1.29.1 → 1.30.0

package/scripts/judge-reward-function.js

@@ -12,6 +12,7 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
+const { validateStructuredOutput } = require('./tool-contract-validator');
 
 const DEFAULT_CRITERIA = [
   {
@@ -117,15 +118,19 @@ function buildCompositeReward(sample = {}, options = {}) {
   }
 
   const judge = runJudgeSafely(sample, options.judge);
-  const judgeScore = judge.ok ? judge.score : 0.5;
-  const score = round((deterministic.score * 0.65) + (judgeScore * 0.35));
+  const score = judge.ok
+    ? round((deterministic.score * 0.65) + (judge.score * 0.35))
+    : deterministic.score;
   return {
     score,
-    label: rewardLabel(score),
+    label: judge.ok ? rewardLabel(score) : 'deterministic_only',
     deterministic,
     judge,
-    failureMode: judge.ok ? [] : ['judge_error_neutral_reward'],
-    recommendation: rewardRecommendation(score),
+    scoringMode: judge.ok ? 'deterministic_plus_llm_judge' : 'deterministic_only',
+    failureMode: judge.ok ? [] : [judge.available ? 'judge_error' : 'judge_unavailable'],
+    recommendation: judge.ok
+      ? rewardRecommendation(score)
+      : 'Use deterministic results only; do not represent unavailable judge evidence as a neutral judgment.',
   };
 }
 
@@ -148,7 +153,8 @@ function buildPreferenceJudgment(a, b, options = {}) {
 function buildJudgeReadinessReport(samples = [], options = {}) {
   const rewards = samples.map((sample) => buildCompositeReward(sample, options));
   const blocked = rewards.filter((reward) => reward.label === 'deterministic_block');
-  const neutralFallbacks = rewards.filter((reward) => reward.failureMode.includes('judge_error_neutral_reward'));
+  const neutralFallbacks = rewards.filter((reward) =>
+    reward.failureMode.includes('judge_error') || reward.failureMode.includes('judge_unavailable'));
   return {
     generatedAt: new Date().toISOString(),
     samples: samples.length,
@@ -186,7 +192,7 @@ function measureJudgeConsistency(samples = [], judge = null, options = {}) {
 
 function evaluateCriterion(id, prediction, sample, { requiresJson }) {
   if (id === 'schema_valid') {
-    return evaluateSchemaCriterion(prediction, requiresJson);
+    return evaluateSchemaCriterion(prediction, requiresJson, sample.outputSchema);
   }
   if (id === 'grounded_evidence') {
     return hasGroundedEvidence(prediction);
@@ -203,14 +209,17 @@ function evaluateCriterion(id, prediction, sample, { requiresJson }) {
   return true;
 }
 
-function evaluateSchemaCriterion(prediction, requiresJson) {
+function evaluateSchemaCriterion(prediction, requiresJson, outputSchema) {
   if (!requiresJson) return true;
-  try {
-    JSON.parse(prediction);
-    return true;
-  } catch {
-    return false;
+  if (!outputSchema) {
+    try {
+      JSON.parse(prediction);
+      return true;
+    } catch {
+      return false;
+    }
   }
+  return validateStructuredOutput(prediction, outputSchema).valid;
 }
 
 function hasGroundedEvidence(prediction) {
@@ -253,9 +262,10 @@ function buildCriterionReason(id, pass) {
 function runJudgeSafely(sample, judge) {
   if (typeof judge !== 'function') {
     return {
-      ok: true,
-      score: 0.5,
-      rationale: 'No external judge configured; deterministic checks carried the reward.',
+      ok: false,
+      available: false,
+      score: null,
+      rationale: 'No external judge configured; only deterministic checks are evidence.',
       raw: null,
     };
   }
@@ -264,6 +274,7 @@ function runJudgeSafely(sample, judge) {
     const score = clamp(Number(result.score ?? result), 0, 1);
     return {
       ok: true,
+      available: true,
       score,
       rationale: result.rationale || 'Judge returned a bounded score.',
       raw: result,
@@ -271,8 +282,9 @@ function runJudgeSafely(sample, judge) {
   } catch (err) {
     return {
       ok: false,
-      score: 0.5,
-      rationale: `Judge failed; returned neutral reward. ${err.message}`,
+      available: true,
+      score: null,
+      rationale: `Judge failed; deterministic checks remain authoritative. ${err.message}`,
       raw: null,
     };
   }

package/scripts/lesson-inference.js

@@ -170,6 +170,20 @@ function isPositiveSignal(signal) {
   return signal === 'positive' || signal === 'up';
 }
 
+function isHumanReviewedLesson(lesson = {}) {
+  return (lesson.metadata?.reviewOrigin || lesson.reviewOrigin) === 'human';
+}
+
+function dedupeHumanReviewedLessons(lessons = []) {
+  const byFeedback = new Map();
+  for (const lesson of lessons) {
+    if (isHumanReviewedLesson(lesson) && lesson.feedbackId) {
+      byFeedback.set(lesson.feedbackId, lesson);
+    }
+  }
+  return [...byFeedback.values()];
+}
+
 function selectStatusbarLesson() {
   const lessons = readJsonl(getLessonsPath())
     .slice()
@@ -242,10 +256,14 @@ function searchLessons({ query = '', limit = 10, signal } = {}) {
  */
 function getLessonStats() {
   const lessons = readJsonl(getLessonsPath());
-  const positive = lessons.filter((l) => l.signal === 'positive' || l.signal === 'up').length;
-  const negative = lessons.filter((l) => l.signal === 'negative' || l.signal === 'down').length;
-  const avgConfidence = lessons.length > 0 ? Math.round(lessons.reduce((s, l) => s + (l.confidence || 0), 0) / lessons.length) : 0;
-  return { total: lessons.length, positive, negative, avgConfidence };
+  const humanReviewed = dedupeHumanReviewedLessons(lessons);
+  const positive = humanReviewed.filter((lesson) => isPositiveSignal(lesson.signal)).length;
+  const negative = humanReviewed.filter((lesson) => isNegativeSignal(lesson.signal)).length;
+  const avgConfidence = humanReviewed.length > 0
+    ? Math.round(humanReviewed.reduce((sum, lesson) => sum + (lesson.confidence || 0), 0) / humanReviewed.length)
+    : 0;
+  return { total: positive + negative, positive, negative, avgConfidence,
+    rawTotal: lessons.length, excludedTotal: lessons.length - humanReviewed.length };
 }
 
 // ---------------------------------------------------------------------------
@@ -650,6 +668,7 @@ async function inferStructuredLessonLLM(conversationWindow, signal, context) {
 module.exports = {
   inferFromSurroundingMessages, createLesson, getRecentLesson,
   searchLessons, getLessonStats, getStatusbarLessonData, getAllLessonsForContext,
+  isHumanReviewedLesson,
   getLessonsPath, getRecentLessonPath,
   selectStatusbarLesson, getLessonKind, stripLessonPrefix,
   formatLessonTimestamp, buildStatusbarLessonLabel,

package/scripts/lesson-retrieval.js

@@ -14,6 +14,63 @@
 
 const RECENCY_DECAY_DAYS = 30;
 const RERANK_CANDIDATE_POOL = 50; // bi-encoder retrieves this many; reranker picks topK
+const MAX_RETRIEVAL_MEMORY_CHARS = 20000;
+
+// Line cap for reading the memory log during retrieval.
+//
+// This was 200, which quietly made relevance irrelevant. Retrieval scores memories and keeps
+// anything over 0.1, but it only ever SAW the newest 200 entries — so once 200 newer lessons
+// existed, the single most relevant lesson in the corpus became unreachable no matter how well
+// it matched. Measured on a synthetic corpus where the best-scoring lesson (0.183, threshold
+// 0.1) is the oldest entry:
+//
+//     corpus   150 -> found
+//     corpus   201 -> NOT found        <- cliff, purely from recency
+//     corpus 2,000 -> NOT found
+//
+// A firewall that forgets its oldest lessons forgets the ones it learned the hard way.
+//
+// The cap exists for cost, so it is set from measurement rather than taste. Worst case (every
+// entry scoring above threshold, so nothing filters out early):
+//
+//     200 entries 2.6 ms/call | 5,000 entries 2.6 ms/call | 20,000 entries 4.2 ms/call
+//
+// 5,000 therefore costs nothing measurable against the old 200 while covering realistic
+// corpora with wide headroom. Override with THUMBGATE_RETRIEVAL_MAX_LINES if a machine ever
+// grows past it.
+const MAX_RETRIEVAL_MEMORY_LINES = Math.max(
+  1,
+  Number(process.env.THUMBGATE_RETRIEVAL_MAX_LINES) || 5000,
+);
+
+function isRetrievableMemory(memory, options = {}) {
+  if (!memory || typeof memory !== 'object') return false;
+  const { looksLikeTransportBlob } = require('./feedback-sanitizer');
+  const title = String(memory.title || '');
+  const content = String(memory.content || '');
+  const combined = `${title}\n${content}`.trim();
+  const maxChars = Number.isFinite(options.maxMemoryChars)
+    ? Math.max(1, options.maxMemoryChars)
+    : MAX_RETRIEVAL_MEMORY_CHARS;
+  if (!combined || combined.length > maxChars) return false;
+  return !looksLikeTransportBlob(title)
+    && !looksLikeTransportBlob(content)
+    && !looksLikeTransportBlob(combined);
+}
+
+function selectRetrievalMemories(memories = [], options = {}) {
+  let selected = memories.filter((memory) => isRetrievableMemory(memory, options));
+  if (options.requireScope && !options.scope) {
+    throw new Error('Scoped lesson retrieval requires scope');
+  }
+  if (options.scope) {
+    const { selectRecordsForScope } = require('./memory-scope-readiness');
+    selected = selectRecordsForScope(selected, options.scope, {
+      includeShared: options.includeShared !== false,
+    }).allowed;
+  }
+  return selected;
+}
 
 function retrieveRelevantLessons(toolName, actionContext, options = {}) {
   const { maxResults = 5, feedbackDir } = options;
@@ -24,7 +81,10 @@ function retrieveRelevantLessons(toolName, actionContext, options = {}) {
     ? { MEMORY_LOG_PATH: pathMod.join(feedbackDir, 'memory-log.jsonl') }
     : getFeedbackPaths();
 
-  const memories = readJSONL(paths.MEMORY_LOG_PATH, { maxLines: 200 });
+  const memories = selectRetrievalMemories(
+    readJSONL(paths.MEMORY_LOG_PATH, { maxLines: MAX_RETRIEVAL_MEMORY_LINES }),
+    options,
+  );
   if (memories.length === 0) return [];
 
   const actionSig = buildActionSignature(toolName, actionContext);
@@ -92,13 +152,16 @@ function reciprocalRankFusion(rankedLists = [], options = {}) {
     .sort((a, b) => b.score - a.score);
 }
 
-function loadMemories(feedbackDir) {
+function loadMemories(feedbackDir, options = {}) {
   const { getFeedbackPaths, readJSONL } = require('./feedback-loop');
   const pathMod = require('path');
   const paths = feedbackDir
     ? { MEMORY_LOG_PATH: pathMod.join(feedbackDir, 'memory-log.jsonl') }
     : getFeedbackPaths();
-  return readJSONL(paths.MEMORY_LOG_PATH, { maxLines: 200 });
+  return selectRetrievalMemories(
+    readJSONL(paths.MEMORY_LOG_PATH, { maxLines: MAX_RETRIEVAL_MEMORY_LINES }),
+    options,
+  );
 }
 
 function shapeLesson(m) {
@@ -140,7 +203,7 @@ async function retrieveRelevantLessonsAsync(toolName, actionContext, options = {
     return retrieveRelevantLessons(toolName, actionContext, options);
   }
 
-  const memories = loadMemories(feedbackDir);
+  const memories = loadMemories(feedbackDir, options);
   if (memories.length === 0) return [];
 
   const actionSig = buildActionSignature(toolName, actionContext);
@@ -482,4 +545,8 @@ module.exports = {
   filterTopP,
   resolveTopP,
   dedupeSupersededLessons,
+  isRetrievableMemory,
+  selectRetrievalMemories,
+  MAX_RETRIEVAL_MEMORY_CHARS,
+  MAX_RETRIEVAL_MEMORY_LINES,
 };

package/scripts/lesson-search.js

@@ -4,6 +4,7 @@ const path = require('node:path');
 const { readJSONL, getFeedbackPaths } = require('./feedback-loop');
 const { buildMemoryLifecycleView, scoreHybridMemoryMatch } = require('./agent-memory-lifecycle');
 const { loadOptionalModule } = require('./private-core-boundary');
+const { selectRetrievalMemories } = require('./lesson-retrieval');
 
 const HIGH_RISK_TAGS = new Set([
   'billing',
@@ -481,7 +482,8 @@ function searchLessons(query = '', options = {}) {
   const sqliteResults = tryFts5Search(query, options);
   if (sqliteResults) return sqliteResults;
 
-  const memories = readJSONL(MEMORY_LOG_PATH);
+  const allMemories = readJSONL(MEMORY_LOG_PATH);
+  const memories = selectRetrievalMemories(allMemories, options);
   const feedbackEntries = readJSONL(FEEDBACK_LOG_PATH);
   const feedbackById = new Map(feedbackEntries.map((entry) => [entry.id, entry]));
   const parsedLimit = Number(options.limit || 10);
@@ -534,9 +536,12 @@ function searchLessons(query = '', options = {}) {
     filters: {
       category: category || null,
       tags: requiredTags,
+      scope: options.scope || null,
+      requireScope: options.requireScope === true,
     },
     feedbackDir: FEEDBACK_DIR,
     totalLessons: memories.length,
+    excludedLessons: allMemories.length - memories.length,
     returned: Math.min(limit, results.length),
     results: results.slice(0, limit),
     backend: 'jsonl-jaccard',
@@ -548,6 +553,10 @@ function searchLessons(query = '', options = {}) {
  * or not opted in. Set LESSON_DB_SEARCH=1 to enable FTS5 as primary backend.
  */
 function tryFts5Search(query, options) {
+  // The SQLite index does not currently carry the complete four-field scope
+  // contract. Fall back to JSONL whenever isolation is requested rather than
+  // silently searching across tenants or sessions.
+  if (options.scope || options.requireScope) return null;
   if (!process.env.LESSON_DB_SEARCH && !options.useFts5) return null;
   try {
     const { initDB, searchLessons: fts5Search, getStats } = require('./lesson-db');
@@ -567,11 +576,24 @@ function tryFts5Search(query, options) {
         .map((tag) => tag.trim())
         .filter(Boolean);
 
-    const rows = fts5Search(db, query || '', {
-      limit,
+    const candidateRows = fts5Search(db, query || '', {
+      limit: Math.max(limit * 5, 50),
       signal,
       tags: requiredTags.length > 0 ? requiredTags : undefined,
     });
+    const retrievableRows = selectRetrievalMemories(
+      candidateRows.map((row) => ({
+        ...row,
+        title: row.context || '',
+        content: [
+          row.whatWentWrong,
+          row.whatToChange,
+          row.whatWorked,
+        ].filter(Boolean).join('\n'),
+      })),
+      options,
+    );
+    const rows = retrievableRows.slice(0, limit);
 
     return {
       query: String(query || ''),
@@ -581,6 +603,7 @@ function tryFts5Search(query, options) {
         tags: requiredTags,
       },
       totalLessons: stats.total,
+      excludedLessons: candidateRows.length - retrievableRows.length,
       returned: rows.length,
       results: rows.map((row) => ({
         id: row.id,

package/scripts/mcp-config.js

@@ -193,17 +193,37 @@ function publishedCliAvailable(pkgVersion) {
   return cliAvailabilityCache.get(pkgVersion);
 }
 
+/**
+ * Project-scope entries land in COMMITTED, SHARED config (.mcp.json / .cursor/mcp.json —
+ * init's own banner says the file serves every agent on the repo). A machine-absolute path
+ * there is a bug by construction: run init on machine A (or a Cowork sandbox with a home
+ * like /Users/busy-clever-newton) and the committed config breaks for every other machine,
+ * teammate, and CI runner. Observed for real on 2026-07-29.
+ *
+ * So: absolute paths may only ever go to HOME-scope config (machine-local by definition).
+ * Project scope gets a repo-relative path when the project IS the ThumbGate checkout
+ * (dogfooding unpublished source still works — project MCP servers launch with cwd at the
+ * project root), and the portable npx launcher otherwise.
+ */
+function relativeLocalMcpEntry(pkgRoot, targetDir) {
+  const rel = path.relative(targetDir, resolveLocalServerPath(pkgRoot, 'project'));
+  // Committed config must be separator-portable too.
+  return { command: 'node', args: [rel.split(path.sep).join('/')] };
+}
+
 function resolveMcpEntry({ pkgRoot, pkgVersion, scope = 'project', targetDir = pkgRoot }) {
   if (!isSourceCheckout(pkgRoot)) {
     return codexAutoUpdateMcpEntry();
   }
-  if (scope === 'home' && publishedCliAvailable(pkgVersion)) {
-    return codexAutoUpdateMcpEntry();
+  if (scope === 'home') {
+    if (publishedCliAvailable(pkgVersion)) return codexAutoUpdateMcpEntry();
+    return localMcpEntry(pkgRoot, scope);
   }
-  if (scope === 'project' && !isSameCheckoutFamily(pkgRoot, targetDir) && publishedCliAvailable(pkgVersion)) {
-    return codexAutoUpdateMcpEntry();
+  // scope === 'project': this is going into shared, committed config.
+  if (isSameCheckoutFamily(pkgRoot, targetDir)) {
+    return relativeLocalMcpEntry(pkgRoot, targetDir);
   }
-  return localMcpEntry(pkgRoot, scope);
+  return codexAutoUpdateMcpEntry();
 }
 
 module.exports = {
@@ -214,6 +234,7 @@ module.exports = {
   localMcpEntry,
   parseWorktreePaths,
   portableMcpEntry,
+  relativeLocalMcpEntry,
   resolveGitCommonDir,
   resolveLocalServerPath,
   resolveMcpEntry,

package/scripts/mcp-oauth.js

@@ -29,6 +29,7 @@ const crypto = require('crypto');
 const AUTH_CODE_TTL_MS = 60 * 1000; // 1 minute
 const ACCESS_TOKEN_TTL_MS = 60 * 60 * 1000; // 1 hour
 const DEFAULT_SCOPE = 'mcp:read mcp:write';
+const SUPPORTED_SCOPES = Object.freeze(['mcp:read', 'mcp:write']);
 
 // Upper bounds on the in-memory store. The registration and authorization
 // endpoints are reachable pre-auth, so without a cap a malicious caller could
@@ -160,6 +161,27 @@ function getClient(store, clientId) {
   return store.clients.get(clientId) || null;
 }
 
+function normalizeScopes(scope = DEFAULT_SCOPE, allowedScopes = SUPPORTED_SCOPES) {
+  const requested = [...new Set(String(scope || DEFAULT_SCOPE).split(/\s+/).filter(Boolean))];
+  const supported = new Set(SUPPORTED_SCOPES);
+  const allowed = new Set(allowedScopes || SUPPORTED_SCOPES);
+  const invalid = requested.filter((candidate) => !supported.has(candidate));
+  const disallowed = requested.filter((candidate) => supported.has(candidate) && !allowed.has(candidate));
+  return {
+    valid: requested.length > 0 && invalid.length === 0 && disallowed.length === 0,
+    scopes: requested,
+    scope: requested.join(' '),
+    invalid,
+    disallowed,
+  };
+}
+
+function scopeAllows(session, requiredScope) {
+  if (!session || !requiredScope) return false;
+  const normalized = normalizeScopes(session.scope, SUPPORTED_SCOPES);
+  return normalized.valid && normalized.scopes.includes(requiredScope);
+}
+
 // ---------------------------------------------------------------------------
 // Authorization code (PKCE S256)
 // ---------------------------------------------------------------------------
@@ -169,20 +191,30 @@ function getClient(store, clientId) {
  * token will act as (resolved by the authorize step once the user consents).
  */
 function createAuthorizationCode(store, {
-  clientId, redirectUri, codeChallenge, codeChallengeMethod, scope, boundKey, state, resource,
+  clientId, redirectUri, codeChallenge, codeChallengeMethod, scope, allowedScopes, boundKey, state, resource,
 } = {}) {
   const client = getClient(store, clientId);
   if (!client) return { error: 'invalid_client' };
   if (!client.redirect_uris.includes(redirectUri)) return { error: 'invalid_request', error_description: 'redirect_uri mismatch' };
   if (codeChallengeMethod !== 'S256') return { error: 'invalid_request', error_description: 'code_challenge_method must be S256' };
   if (!codeChallenge || String(codeChallenge).length < 16) return { error: 'invalid_request', error_description: 'code_challenge required' };
+  const normalizedScopes = normalizeScopes(scope, allowedScopes || SUPPORTED_SCOPES);
+  if (!normalizedScopes.valid) {
+    return {
+      error: 'invalid_scope',
+      error_description: [
+        normalizedScopes.invalid.length > 0 ? `unsupported: ${normalizedScopes.invalid.join(', ')}` : '',
+        normalizedScopes.disallowed.length > 0 ? `not permitted: ${normalizedScopes.disallowed.join(', ')}` : '',
+      ].filter(Boolean).join('; ') || 'scope is required',
+    };
+  }
 
   const code = randomToken(24);
   capInsert(store.codes, code, {
     clientId,
     redirectUri,
     codeChallenge,
-    scope: scope || DEFAULT_SCOPE,
+    scope: normalizedScopes.scope,
     boundKey: boundKey || '',
     resource: resource || '', // RFC 8707 resource indicator (the MCP server URL)
     expiresAt: now() + AUTH_CODE_TTL_MS,
@@ -287,6 +319,9 @@ module.exports = {
   AUTH_CODE_TTL_MS,
   ACCESS_TOKEN_TTL_MS,
   DEFAULT_SCOPE,
+  SUPPORTED_SCOPES,
+  normalizeScopes,
+  scopeAllows,
   MAX_CLIENTS,
   MAX_CODES,
   MAX_TOKENS,