thumbgate 0.9.9 → 0.9.11

package/scripts/telemetry-analytics.js

@@ -10,7 +10,7 @@ const {
 } = require('./analytics-window');
 const {
   getLegacyFeedbackDir,
-  getRlhfFeedbackDir,
+  getFallbackFeedbackDir,
   resolveFallbackArtifactPath,
 } = require('./feedback-paths');
 
@@ -20,8 +20,8 @@ function shouldIncludeLegacyTelemetry() {
   if (
     process.env._TEST_LEGACY_FEEDBACK_DIR ||
     process.env.THUMBGATE_LEGACY_FEEDBACK_DIR ||
-    process.env._TEST_RLHF_FEEDBACK_DIR ||
-    process.env.THUMBGATE_RLHF_FEEDBACK_DIR
+    process.env._TEST_THUMBGATE_FALLBACK_FEEDBACK_DIR ||
+    process.env.THUMBGATE_FALLBACK_FEEDBACK_DIR
   ) {
     return true;
   }
@@ -121,7 +121,7 @@ function getTelemetrySourceDiagnostics(feedbackDir) {
     fileName: TELEMETRY_FILE_NAME,
     primaryPath,
     legacyPath,
-    rlhfPath: path.join(getRlhfFeedbackDir({ feedbackDir }), TELEMETRY_FILE_NAME),
+    fallbackPath: path.join(getFallbackFeedbackDir({ feedbackDir }), TELEMETRY_FILE_NAME),
     legacyFeedbackPath: path.join(getLegacyFeedbackDir({ feedbackDir }), TELEMETRY_FILE_NAME),
     primaryExists,
     legacyExists,

package/scripts/tessl-export.js

@@ -235,7 +235,7 @@ function exportTiles({
 }
 
 function verifyTiles(options = {}) {
-  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rlhf-tessl-verify-'));
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'thumbgate-tessl-verify-'));
 
   try {
     const results = exportTiles({

package/scripts/test-coverage.js

@@ -16,6 +16,7 @@ const COVERAGE_INCLUDE_GLOBS = [
 const COVERAGE_EXCLUDE_GLOBS = [
   'tests/**/*.js',
 ];
+let cachedCoverageFilterSupport;
 
 function findCoverageTestFiles({
   dir = TESTS_DIR,
@@ -39,29 +40,35 @@ function findCoverageTestFiles({
   return files.sort();
 }
 
-function supportsCoveragePatternFlags({
-  spawn = spawnSync,
-} = {}) {
+function detectCoverageFilterSupport({ spawn = spawnSync } = {}) {
+  if (spawn === spawnSync && cachedCoverageFilterSupport !== undefined) {
+    return cachedCoverageFilterSupport;
+  }
+
   const result = spawn(process.execPath, ['--help'], {
     encoding: 'utf8',
   });
+  const helpText = `${result.stdout || ''}\n${result.stderr || ''}`;
+  const supported = helpText.includes('--test-coverage-include') && helpText.includes('--test-coverage-exclude');
 
-  if (result.error) {
-    return false;
+  if (spawn === spawnSync) {
+    cachedCoverageFilterSupport = supported;
   }
 
-  const help = `${result.stdout || ''}\n${result.stderr || ''}`;
-  return help.includes('--test-coverage-include') && help.includes('--test-coverage-exclude');
+  return supported;
 }
 
-function buildCoverageArgs(files, { supportsPatternFlags = true } = {}) {
+function buildCoverageArgs(files, { spawn = spawnSync, supportsFilters } = {}) {
   const args = [
     '--test',
     '--test-concurrency=1',
     '--experimental-test-coverage',
   ];
 
-  if (supportsPatternFlags) {
+  const useFilterFlags = supportsFilters === undefined
+    ? detectCoverageFilterSupport({ spawn })
+    : supportsFilters;
+  if (useFilterFlags) {
     args.push(
       ...COVERAGE_INCLUDE_GLOBS.flatMap((pattern) => ['--test-coverage-include', pattern]),
       ...COVERAGE_EXCLUDE_GLOBS.flatMap((pattern) => ['--test-coverage-exclude', pattern]),
@@ -76,17 +83,17 @@ function runCoverage({
   files = findCoverageTestFiles(),
   cwd = PROJECT_ROOT,
   spawn = spawnSync,
-  supportsPatternFlags = supportsCoveragePatternFlags({ spawn }),
+  supportsFilters,
 } = {}) {
   if (files.length === 0) {
     return {
       exitCode: 1,
       error: 'No test files found for coverage run.',
-      args: buildCoverageArgs(files, { supportsPatternFlags }),
+      args: buildCoverageArgs(files, { spawn, supportsFilters }),
     };
   }
 
-  const args = buildCoverageArgs(files, { supportsPatternFlags });
+  const args = buildCoverageArgs(files, { spawn, supportsFilters });
   const result = spawn(process.execPath, args, {
     cwd,
     env: process.env,
@@ -113,8 +120,8 @@ module.exports = {
   COVERAGE_INCLUDE_GLOBS,
   PROJECT_ROOT,
   TESTS_DIR,
+  detectCoverageFilterSupport,
   findCoverageTestFiles,
   buildCoverageArgs,
   runCoverage,
-  supportsCoveragePatternFlags,
 };

package/scripts/thumbgate-search.js

@@ -144,7 +144,7 @@ function getRuleResults(query, limit) {
   return searchPreventionRulesSync(query, limit).map(mapRuleResult);
 }
 
-function searchRlhf({ query, source = 'all', limit = 10, signal = null } = {}) {
+function searchThumbgate({ query, source = 'all', limit = 10, signal = null } = {}) {
   const trimmedQuery = String(query || '').trim();
   if (!trimmedQuery) {
     throw new Error('query is required');
@@ -185,5 +185,5 @@ module.exports = {
   VALID_SOURCES,
   normalizeSearchSource: normalizeSource,
   normalizeSearchSignal: normalizeSignal,
-  searchRlhf,
+  searchThumbgate,
 };

package/scripts/tool-registry.js

@@ -121,7 +121,7 @@ const TOOLS = [
     },
   }),
   readOnlyTool({
-    name: 'search_rlhf',
+    name: 'search_thumbgate',
     description: 'Search raw ThumbGate state across feedback logs, ContextFS memory, and prevention rules.',
     inputSchema: {
       type: 'object',
@@ -512,6 +512,89 @@ const TOOLS = [
       },
     },
   }),
+  destructiveTool({
+    name: 'set_task_scope',
+    description: 'Declare or clear the current task scope so ThumbGate can compare affected files and diffs against the approved path set.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        taskId: { type: 'string', description: 'Optional stable task identifier (ticket, issue, or work item id)' },
+        summary: { type: 'string', description: 'Short summary of the task being worked' },
+        allowedPaths: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Glob patterns that define the allowed file scope for this task',
+        },
+        protectedPaths: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Optional protected-file globs that require explicit approval before editing or publishing',
+        },
+        repoPath: { type: 'string', description: 'Optional repo root used when evaluating git diff scope' },
+        localOnly: { type: 'boolean', description: 'When true, also marks the task as local-only' },
+        clear: { type: 'boolean', description: 'Clear the current task scope instead of setting one' },
+      },
+    },
+  }),
+  readOnlyTool({
+    name: 'get_scope_state',
+    description: 'Return the active task scope and any unexpired protected-file approvals.',
+    inputSchema: {
+      type: 'object',
+      properties: {},
+    },
+  }),
+  destructiveTool({
+    name: 'set_branch_governance',
+    description: 'Declare or clear branch and release governance so PR, merge, release, and publish actions can be evaluated against explicit workflow state.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        branchName: { type: 'string', description: 'Optional branch name the governance applies to' },
+        baseBranch: { type: 'string', description: 'Protected base branch for merge and release operations (defaults to main)' },
+        prRequired: { type: 'boolean', description: 'Whether this lane must go through a pull request (defaults to true)' },
+        prNumber: { type: 'string', description: 'Optional pull request number once a PR exists' },
+        prUrl: { type: 'string', description: 'Optional pull request URL once a PR exists' },
+        queueRequired: { type: 'boolean', description: 'Whether the target branch requires a merge queue' },
+        localOnly: { type: 'boolean', description: 'When true, PR, merge, release, and publish actions are blocked for this lane' },
+        releaseVersion: { type: 'string', description: 'Expected package version for release or publish actions' },
+        releaseEvidence: { type: 'string', description: 'Optional evidence or release plan note for the governed version' },
+        releaseSensitiveGlobs: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Optional custom globs that define release-sensitive files for this branch lane',
+        },
+        clear: { type: 'boolean', description: 'Clear the current branch governance state instead of setting it' },
+      },
+    },
+  }),
+  readOnlyTool({
+    name: 'get_branch_governance',
+    description: 'Return the active branch and release governance state.',
+    inputSchema: {
+      type: 'object',
+      properties: {},
+    },
+  }),
+  destructiveTool({
+    name: 'approve_protected_action',
+    description: 'Grant a time-limited approval for edits or publish actions that touch protected files.',
+    inputSchema: {
+      type: 'object',
+      required: ['pathGlobs', 'reason'],
+      properties: {
+        pathGlobs: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Protected-file globs covered by this approval',
+        },
+        reason: { type: 'string', description: 'Why this protected-file action is approved' },
+        evidence: { type: 'string', description: 'Optional supporting evidence or approval note' },
+        taskId: { type: 'string', description: 'Optional task id this approval is tied to' },
+        ttlMs: { type: 'number', description: 'Optional approval lifetime in milliseconds (defaults to 1 hour, max 24 hours)' },
+      },
+    },
+  }),
   destructiveTool({
     name: 'track_action',
     description: 'Record a verification action in the current session (for example figma_verified or tests_passed). Session actions expire after one hour.',
@@ -535,6 +618,20 @@ const TOOLS = [
       },
     },
   }),
+  readOnlyTool({
+    name: 'check_operational_integrity',
+    description: 'Evaluate whether the current repo state is safe for PR, merge, release, and publish operations.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        repoPath: { type: 'string', description: 'Optional repository path to inspect' },
+        baseBranch: { type: 'string', description: 'Protected base branch to compare against (defaults to main)' },
+        command: { type: 'string', description: 'Optional git, PR, or publish command to evaluate against the current governance state' },
+        requirePrForReleaseSensitive: { type: 'boolean', description: 'When true, release-sensitive changes on non-base branches require an open PR' },
+        requireVersionNotBehindBase: { type: 'boolean', description: 'When true, release-sensitive changes cannot lag behind the base branch package version' },
+      },
+    },
+  }),
   destructiveTool({
     name: 'register_claim_gate',
     description: 'Register a custom claim verification rule in local runtime state without editing tracked repo config.',

package/scripts/train_from_feedback.py

@@ -246,7 +246,7 @@ def is_positive(entry: Dict) -> bool:
     """Determine if a feedback entry is positive."""
     if entry.get("reward", 0) > 0:
         return True
-    # rlhf uses signal field: 'positive' or 'negative'
+    # ThumbGate uses signal field: 'positive' or 'negative'
     signal = entry.get("signal", "").lower()
     if signal in ("positive", "up", "thumbsup"):
         return True

package/scripts/user-profile.js

@@ -12,11 +12,11 @@ function getProfilePath() {
   if (process.env.THUMBGATE_FEEDBACK_DIR) {
     return path.join(process.env.THUMBGATE_FEEDBACK_DIR, PROFILE_FILENAME);
   }
-  const localRlhf = path.join(process.cwd(), '.rlhf');
-  if (fs.existsSync(localRlhf)) {
-    return path.join(localRlhf, PROFILE_FILENAME);
+  const localFallback = path.join(process.cwd(), '.thumbgate');
+  if (fs.existsSync(localFallback)) {
+    return path.join(localFallback, PROFILE_FILENAME);
   }
-  return path.join(os.homedir(), '.rlhf', PROFILE_FILENAME);
+  return path.join(os.homedir(), '.thumbgate', PROFILE_FILENAME);
 }
 
 function loadProfile() {

package/scripts/validate-feedback.js

@@ -8,7 +8,7 @@
  * 3. Anomaly detection (suspicious patterns, sensitive data)
  * 4. Self-correction (auto-correct fixable errors)
  *
- * Ported from Subway_RN_Demo with rlhf schema adaptations:
+ * Ported from Subway_RN_Demo with ThumbGate schema adaptations:
  * - Uses 'signal' (not 'feedback') with values 'positive'/'negative'
  * - Uses 'id' as required field (not 'source')
  * - THUMBGATE_FEEDBACK_DIR env var for path resolution

package/scripts/vector-store.js

@@ -18,7 +18,7 @@ let _lancedbLoader = null;
 const _pipelineCache = new Map();
 let _lastEmbeddingProfile = null;
 let _pipelineLoader = null;
-const TABLE_NAME = 'rlhf_memories';
+const TABLE_NAME = 'thumbgate_memories';
 
 async function getLanceDB() {
   if (!_lancedb) {

package/scripts/verification-loop.js

@@ -17,7 +17,7 @@ const {
 const { getEffectiveSetting } = require('./evolution-state');
 
 const MAX_RETRIES = 3;
-const DEFAULT_MODEL_PATH = path.join(__dirname, '..', '.rlhf', 'verification-model.json');
+const DEFAULT_MODEL_PATH = path.join(__dirname, '..', '.thumbgate', 'verification-model.json');
 
 /**
  * Run a single verification step against prevention rules.

package/scripts/verify-run.js

@@ -230,7 +230,7 @@ function recordVerifyWorkflowRun(mode = 'quick', cwd = process.cwd(), feedbackDi
 }
 
 function runVerify(mode = 'quick', baseEnv = process.env, cwd = process.cwd()) {
-  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'rlhf-verify-'));
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'thumbgate-verify-'));
   const env = {
     ...baseEnv,
     THUMBGATE_PROOF_DIR: path.join(tempRoot, 'proof-adapters'),

package/scripts/weekly-auto-post.js

@@ -15,7 +15,7 @@ const os = require('os');
 const { generateWeeklyStatsPost } = require('./daily-digest');
 const { createSchedule } = require('./schedule-manager');
 
-const POSTS_DIR = path.join(os.homedir(), '.rlhf', 'weekly-posts');
+const POSTS_DIR = path.join(os.homedir(), '.thumbgate', 'weekly-posts');
 
 function ensureDir(p) { if (!fs.existsSync(p)) fs.mkdirSync(p, { recursive: true }); }
 

package/skills/{rlhf-feedback → thumbgate-feedback}/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: rlhf-feedback
+name: thumbgate-feedback
 description: >
   Capture thumbs up/down feedback into structured memories and prevention rules.
   Require one sentence of why before claiming memory promotion.