thumbgate 1.27.16 → 1.27.18

package/scripts/gemini-embedding-policy.js

@@ -122,7 +122,7 @@ function resolveGeminiEmbeddingConfig(env = process.env) {
 
   return {
     enabled,
-    provider: provider === 'coreai' ? 'coreai' : (enabled ? 'gemini' : 'local'),
+    provider: enabled ? 'gemini' : 'local',
     model: String(env.THUMBGATE_GEMINI_EMBED_MODEL || GEMINI_EMBEDDING_2_MODEL).trim() || GEMINI_EMBEDDING_2_MODEL,
     apiKey,
     apiBaseUrl: trimTrailingSlashes(env.THUMBGATE_GEMINI_API_BASE_URL || 'https://generativelanguage.googleapis.com/v1beta'),
@@ -171,7 +171,6 @@ function buildGeminiEmbeddingRolloutPlan(args = {}) {
     },
     rolloutSteps: [
       'Keep local embeddings as the default offline path.',
-      'For Apple Silicon developers, route local queries through Core AI (AOT compiled models) to bypass CPU overhead.',
       'Enable Gemini Embedding 2 only when a Gemini API key is present.',
       'Use task-specific query/document prefixes at index and retrieval time.',
       'Start at 768 dimensions, then benchmark 1536 only if recall misses show up.',

package/scripts/hook-runtime.js

@@ -7,7 +7,6 @@ const {
   publishedCliAvailable,
 } = require('./mcp-config');
 const { publishedCliShellCommand } = require('./published-cli');
-const { shimInstalled, shimPath } = require('./install-shim');
 
 const PKG_ROOT = path.join(__dirname, '..');
 const featureSupportCache = new Map();
@@ -34,39 +33,34 @@ function publishedHookCommandsAvailable(version) {
   return available;
 }
 
-function resolveCliCommand(subcommand) {
-  // Source checkout: always use direct node command for development
-  if (isSourceCheckout(PKG_ROOT)) {
-    return `node ${shellQuote(path.join(PKG_ROOT, 'bin', 'cli.js'))} ${subcommand}`;
-  }
-  // Prefer stable shim — always resolves @latest, survives version bumps
-  if (shimInstalled()) {
-    return `${shellQuote(shimPath())} ${subcommand}`;
-  }
+function resolveCliBaseCommand() {
   const version = packageVersion();
   if (publishedHookCommandsAvailable(version)) {
-    return publishedCliShellCommand(version, [subcommand]);
+    return publishedCliShellCommand(version);
+  }
+  if (isSourceCheckout(PKG_ROOT)) {
+    return `node ${shellQuote(path.join(PKG_ROOT, 'bin', 'cli.js'))}`;
   }
-  return publishedCliShellCommand(version, [subcommand]);
+  return publishedCliShellCommand(version);
 }
 
-function resolveCodexCliCommand(subcommand) {
+function resolveCodexCliBaseCommand() {
   const version = packageVersion();
   if (publishedHookCommandsAvailable(version)) {
-    return publishedCliShellCommand('latest', [subcommand], { preferInstalled: false });
+    return publishedCliShellCommand('latest', [], { preferInstalled: false });
   }
   if (isSourceCheckout(PKG_ROOT)) {
-    return `node ${shellQuote(path.join(PKG_ROOT, 'bin', 'cli.js'))} ${subcommand}`;
+    return `node ${shellQuote(path.join(PKG_ROOT, 'bin', 'cli.js'))}`;
   }
-  return publishedCliShellCommand('latest', [subcommand], { preferInstalled: false });
+  return publishedCliShellCommand('latest', [], { preferInstalled: false });
 }
 
 function buildPortableHookCommand(subcommand) {
-  return resolveCliCommand(subcommand);
+  return `${resolveCliBaseCommand()} ${subcommand}`;
 }
 
 function buildCodexPortableHookCommand(subcommand) {
-  return resolveCodexCliCommand(subcommand);
+  return `${resolveCodexCliBaseCommand()} ${subcommand}`;
 }
 
 function preToolHookCommand() {
@@ -121,8 +115,8 @@ module.exports = {
   packageVersion,
   publishedHookCommandsAvailable,
   preToolHookCommand,
-  resolveCodexCliCommand,
-  resolveCliCommand,
+  resolveCodexCliBaseCommand,
+  resolveCliBaseCommand,
   sessionStartHookCommand,
   statuslineCommand,
   userPromptHookCommand,

package/scripts/hook-thumbgate-cache-updater.js

@@ -6,27 +6,11 @@
  * Also used directly by the CLI to refresh statusline counters after feedback capture.
  */
 
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
+const fs = require('fs');
+const path = require('path');
 const { resolveFeedbackDir } = require('./feedback-paths');
-const {
-  getAggregateStatuslineCachePath,
-  shouldAggregateFeedback,
-} = require('./feedback-aggregate');
 
 function getCachePath() {
-  const explicitFeedbackDir = process.env.THUMBGATE_FEEDBACK_DIR;
-  if (shouldAggregateFeedback() && explicitFeedbackDir) {
-    try {
-      if (path.resolve(explicitFeedbackDir).startsWith(path.resolve(os.tmpdir()) + path.sep)) {
-        return path.join(resolveFeedbackDir(), 'statusline_cache.json');
-      }
-    } catch {
-      return path.join(resolveFeedbackDir(), 'statusline_cache.json');
-    }
-  }
-  if (shouldAggregateFeedback()) return getAggregateStatuslineCachePath();
   return path.join(resolveFeedbackDir(), 'statusline_cache.json');
 }
 

package/scripts/hybrid-feedback-context.js

@@ -18,11 +18,6 @@ const fs = require('fs');
 const path = require('path');
 const { resolveFeedbackDir } = require('./feedback-paths');
 const { readJsonl } = require('./fs-utils');
-const {
-  TRANSPORT_WORDS,
-  sanitizeFeedbackText,
-  transportWordsOnly,
-} = require('./feedback-sanitizer');
 
 // ---------------------------------------------------------------------------
 // Paths
@@ -56,7 +51,6 @@ const STOPWORDS = new Set([
   'has', 'had', 'not', 'but', 'they', 'you', 'can', 'will', 'all', 'any',
   'one', 'its', 'our', 'also', 'more', 'very', 'just', 'into', 'been',
   'bash', 'edit', 'write', 'tool', 'hook', 'clear',
-  ...TRANSPORT_WORDS,
 ]);
 
 const NEG = new Set([
@@ -80,7 +74,7 @@ const HYBRID_JSONL_READ_LIMIT = 400;
  */
 function normalize(text) {
   if (!text || typeof text !== 'string') return '';
-  return sanitizeFeedbackText(text)
+  return text
     .replace(/\/Users\/[^\s/]+/g, '/Users/redacted')
     .replace(/:\d{4,5}\b/g, ':PORT')
     .toLowerCase()
@@ -103,9 +97,7 @@ function stripFeedbackPrefix(text) {
  * Compose normalize + stripFeedbackPrefix.
  */
 function normalizePatternText(text) {
-  const normalized = normalize(stripFeedbackPrefix(text));
-  if (transportWordsOnly(normalized)) return '';
-  return normalized;
+  return normalize(stripFeedbackPrefix(text));
 }
 
 /**
@@ -133,104 +125,6 @@ function classify(entry) {
   return 'neutral';
 }
 
-function isHookPromptEnvelope(context) {
-  if (!context || typeof context !== 'string') return false;
-  try {
-    const parsed = JSON.parse(context);
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return false;
-    return Boolean(
-      parsed.prompt &&
-      (
-        parsed.hookEventName ||
-        parsed.hook_event_name ||
-        parsed.workspaceRoot ||
-        parsed.workspace_root ||
-        parsed.session_id ||
-        parsed.sessionId ||
-        parsed.transcript_path ||
-        parsed.transcriptPath
-      )
-    );
-  } catch (_) {
-    return false;
-  }
-}
-
-function patternContext(entry) {
-  const context = entry && entry.context ? String(entry.context) : '';
-  if (!context) return '';
-  const hasExplicitFeedback = Boolean(
-    entry.whatWentWrong ||
-    entry.what_went_wrong ||
-    entry.whatToChange ||
-    entry.what_to_change ||
-    entry.failureType ||
-    (Array.isArray(entry.tags) && entry.tags.length > 0) ||
-    entry.structuredRule
-  );
-  if (isHookPromptEnvelope(context) && !hasExplicitFeedback) return '';
-  if (isHookPromptEnvelope(context) && hasExplicitFeedback) {
-    return '';
-  }
-  return context;
-}
-
-/**
- * Check if the feedback entry is an automated enforcement log (e.g. from gates engine)
- * rather than real developer/user feedback.
- */
-function isAutomatedFeedback(entry) {
-  const tags = entry.tags || [];
-  if (tags.includes('auto-capture') || tags.includes('gates-engine') || tags.includes('audit-trail')) {
-    return true;
-  }
-  const context = String(entry.context || entry.whatWentWrong || '').toLowerCase();
-  return context.includes('gate "') || context.includes('blocked tool') || context.includes('warned tool');
-}
-
-
-function isHookPromptEnvelope(context) {
-  if (!context || typeof context !== 'string') return false;
-  try {
-    const parsed = JSON.parse(context);
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return false;
-    return Boolean(
-      parsed.prompt &&
-      (
-        parsed.hookEventName ||
-        parsed.hook_event_name ||
-        parsed.workspaceRoot ||
-        parsed.workspace_root ||
-        parsed.session_id ||
-        parsed.sessionId ||
-        parsed.transcript_path ||
-        parsed.transcriptPath
-      )
-    );
-  } catch (_) {
-    return false;
-  }
-}
-
-function patternContext(entry) {
-  const context = entry && entry.context ? String(entry.context) : '';
-  if (!context) return '';
-  const hasExplicitFeedback = Boolean(
-    entry.whatWentWrong ||
-    entry.what_went_wrong ||
-    entry.whatToChange ||
-    entry.what_to_change ||
-    entry.failureType ||
-    (Array.isArray(entry.tags) && entry.tags.length > 0) ||
-    entry.structuredRule
-  );
-  if (isHookPromptEnvelope(context) && !hasExplicitFeedback) return '';
-  if (isHookPromptEnvelope(context) && hasExplicitFeedback) {
-    return '';
-  }
-  return context;
-}
-
 /**
  * Extract ms from a timestamp value. Returns 0 on failure.
  */
@@ -318,15 +212,13 @@ function buildHybridState(opts) {
     if (cls === 'positive') positive++;
     if (cls === 'negative') {
       negative++;
-      // Track tool-level negative counts (exclude automated gate logs)
-      if (!isAutomatedFeedback(entry)) {
-        const toolName = inferToolName(entry.toolName || entry.tool_name || 'unknown', entry.context || '');
-        toolNegatives[toolName] = (toolNegatives[toolName] || 0) + 1;
-      }
+      // Track tool-level negative counts
+      const toolName = inferToolName(entry.toolName || entry.tool_name || 'unknown', entry.context || '');
+      toolNegatives[toolName] = (toolNegatives[toolName] || 0) + 1;
 
       // Build pattern from context / whatWentWrong / what_went_wrong
       const rawText = [
-        patternContext(entry),
+        entry.context || '',
         entry.whatWentWrong || entry.what_went_wrong || '',
         entry.whatToChange || entry.what_to_change || '',
         entry.failureType || '',
@@ -362,13 +254,11 @@ function buildHybridState(opts) {
 
   // Process attributed feedback separately to track attributed tool counts
   for (const entry of attributedEntries) {
-    if (classify(entry) !== 'negative') continue; // skip pruned/positive
-    if (isAutomatedFeedback(entry)) continue; // skip automated gate blocks
     const toolName = inferToolName(entry.toolName || entry.tool_name || entry.attributed_tool || 'unknown', entry.context || '');
     toolNegativesAttributed[toolName] = (toolNegativesAttributed[toolName] || 0) + 1;
 
     const rawText = [
-      patternContext(entry),
+      entry.context || '',
       entry.whatWentWrong || entry.what_went_wrong || '',
       ...(Array.isArray(entry.tags) ? entry.tags : []),
       ...(entry.richContext && Array.isArray(entry.richContext.filePaths) ? entry.richContext.filePaths : []),
@@ -730,36 +620,12 @@ function evaluatePretool(toolName, toolInput, opts) {
 
   // Slow path: build live state (also used when compiled guards are stale)
   const state = buildHybridState({
-    feedbackDir: o.feedbackDir,
     feedbackLogPath: o.feedbackLogPath,
     attributedFeedbackPath: o.attributedFeedbackPath,
   });
   return evaluatePretoolFromState(state, toolName, toolInput);
 }
 
-// Claw-style agent support (high-ROI for EnterpriseClaw / OpenShell agents from Automation Anywhere / Nvidia)
-// Extends hybrid context for claw_action_type (file, screen, dynamic-tool, orchestration), agent_identity, hybrid_route.
-// Use in evaluatePretool calls from claw-aware MCP/hooks: pass {clawContext: {actionType: 'dynamic-tool-creation', agentId: '...', route: 'local/cloud'}} in opts.
-function evaluateClawPretool(toolName, toolInput, clawContext, opts) {
-  const o = opts || {};
-  const claw = clawContext || {};
-  // Merge claw metadata into toolInput for gate evaluation (so templates like block-dynamic-tool-creation can match)
-  const enrichedInput = {
-    ...(typeof toolInput === 'object' ? toolInput : { raw: toolInput }),
-    _claw: {
-      actionType: claw.actionType || 'unknown',
-      agentId: claw.agentId || 'unknown',
-      hybridRoute: claw.hybridRoute || 'unknown',
-      screenInteraction: !!claw.screenInteraction,
-      fileAccess: !!claw.fileAccess,
-    }
-  };
-  const result = evaluatePretool(toolName, JSON.stringify(enrichedInput), o);
-  // Tag result with claw metadata for logging/feedback
-  result.clawContext = claw;
-  return result;
-}
-
 // ---------------------------------------------------------------------------
 // CLI main()
 // ---------------------------------------------------------------------------
@@ -808,7 +674,6 @@ function main() {
 module.exports = {
   buildHybridState,
   evaluatePretool,
-  evaluateClawPretool,
   compileGuardArtifact,
   writeGuardArtifact,
   readGuardArtifact,

package/scripts/lesson-inference.js

@@ -18,7 +18,6 @@ const fs = require('fs');
 const path = require('path');
 const { resolveFeedbackDir } = require('./feedback-paths');
 const { ensureParentDir, readJsonl } = require('./fs-utils');
-const { redactSecretsDeep } = require('./secret-redaction');
 const {
   buildStableId,
   extractFilePaths,
@@ -138,19 +137,15 @@ function createLesson({ feedbackId, signal, inferredLesson, triggerMessage, prio
   // Stable link: dashboard deep-link to this lesson
   lesson.link = `${getLessonBaseUrl()}/lessons#${lesson.id}`;
 
-  // Redact secrets before persisting — lesson text is derived from conversation content that may
-  // have captured a pasted credential. See scripts/secret-redaction.js.
-  const redactedLesson = redactSecretsDeep(lesson);
-
   const lessonsPath = getLessonsPath();
   ensureParentDir(lessonsPath);
-  fs.appendFileSync(lessonsPath, JSON.stringify(redactedLesson) + '\n');
+  fs.appendFileSync(lessonsPath, JSON.stringify(lesson) + '\n');
 
   // Update recent lesson for statusbar
   const recentPath = getRecentLessonPath();
-  fs.writeFileSync(recentPath, JSON.stringify(redactedLesson, null, 2) + '\n');
+  fs.writeFileSync(recentPath, JSON.stringify(lesson, null, 2) + '\n');
 
-  return redactedLesson;
+  return lesson;
 }
 
 /**

package/scripts/lesson-search.js

@@ -2,7 +2,6 @@
 
 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 HIGH_RISK_TAGS = new Set([
@@ -412,8 +411,7 @@ function scoreLesson(queryText, memory, parsed, sourceFeedback) {
   const score = jaccardSimilarity(queryTokens, lessonTokens)
     + substringBoost(queryText, lessonText)
     + recencyScore(memory.timestamp)
-    + (memory.category === 'error' ? 0.05 : 0)
-    + Math.min(0.2, scoreHybridMemoryMatch(queryText, memory).score * 0.1);
+    + (memory.category === 'error' ? 0.05 : 0);
 
   return {
     score,
@@ -429,7 +427,6 @@ function buildLessonResult(memory, sourceFeedback, options = {}) {
   const { score, matchedTokens } = scoreLesson(options.query || '', memory, parsed, sourceFeedback);
   const harnessRecommendations = buildHarnessRecommendations(memory, parsed, sourceFeedback, ruleMatches, gateMatches);
   const lifecycle = buildLifecycle(memory, parsed, sourceFeedback, ruleMatches, gateMatches, harnessRecommendations);
-  const memoryLifecycle = buildMemoryLifecycleView(memory, { query: options.query || '' });
 
   return {
     id: memory.id,
@@ -455,7 +452,6 @@ function buildLessonResult(memory, sourceFeedback, options = {}) {
     systemResponse: {
       promotedToMemory: true,
       lifecycle,
-      memoryLifecycle,
       diagnosis: memory.diagnosis || null,
       sourceFeedback: sourceFeedback
         ? {
@@ -593,14 +589,6 @@ function tryFts5Search(query, options) {
         tags: row.tags,
         importance: row.importance,
         timestamp: row.timestamp,
-        memoryLifecycle: buildMemoryLifecycleView({
-          title: row.context,
-          content: [row.whatWentWrong, row.whatToChange, row.whatWorked].filter(Boolean).join('\n'),
-          domain: row.domain,
-          tags: row.tags,
-          importance: row.importance,
-          timestamp: row.timestamp,
-        }, { query: query || '' }),
       })),
       backend: 'sqlite-fts5',
     };
@@ -630,10 +618,6 @@ function formatLessonSearchResults(payload) {
   payload.results.forEach((result, index) => {
     lines.push(`${index + 1}. ${result.title}`);
     lines.push(`   Category: ${result.category} | Tags: ${result.tags.join(', ') || 'none'} | Score: ${result.score}`);
-    if (result.systemResponse.memoryLifecycle) {
-      const memoryLifecycle = result.systemResponse.memoryLifecycle;
-      lines.push(`   Memory: scope=${memoryLifecycle.scope} | decay=${memoryLifecycle.decay.state} | hybrid=${memoryLifecycle.retrievalHints.hybridScore}`);
-    }
     if (result.lesson.summary) {
       lines.push(`   Lesson: ${result.lesson.summary}`);
     }

package/scripts/license.js

@@ -80,6 +80,7 @@ module.exports = {
   verifyLicense,
   isProLicensed,
   activateLicense,
+  generateLicenseKey,
   isValidKey,
   VALID_PREFIXES,
   LICENSE_PATH,