thumbgate 0.9.13 → 1.0.0

package/scripts/ensure-repo-bootstrap.js

@@ -5,12 +5,13 @@ const fs = require('fs');
 const path = require('path');
 
 const REPO_ROOT = path.resolve(process.argv[2] || process.cwd());
-const RLHF_ENTRY = {
+const THUMBGATE_ENTRY = {
   command: 'npx',
   args: ['-y', 'thumbgate@latest', 'serve'],
 };
-const LEGACY_SERVER_NAMES = ['thumbgate', 'rlhf_feedback_loop'];
-const INFO_EXCLUDE_ENTRIES = ['.rlhf/', '.thumbgate/', '.mcp.json'];
+const MCP_SERVER_KEY = 'thumbgate';
+const LEGACY_SERVER_NAMES = ['rlhf', 'mcp-memory-gateway', 'rlhf_feedback_loop'];
+const INFO_EXCLUDE_ENTRIES = ['.thumbgate/', '.mcp.json'];
 
 function readJson(filePath) {
   try {
@@ -36,11 +37,11 @@ function writeJsonIfChanged(filePath, value) {
   return true;
 }
 
-function mergeRlhfEntry(entry = {}) {
+function mergeThumbgateEntry(entry = {}) {
   return {
     ...entry,
-    command: RLHF_ENTRY.command,
-    args: RLHF_ENTRY.args.slice(),
+    command: THUMBGATE_ENTRY.command,
+    args: THUMBGATE_ENTRY.args.slice(),
   };
 }
 
@@ -49,7 +50,7 @@ function ensureMcpJson(repoRoot) {
   const existing = readJson(filePath);
   const config = existing && typeof existing === 'object' ? existing : {};
   config.mcpServers = config.mcpServers && typeof config.mcpServers === 'object' ? config.mcpServers : {};
-  config.mcpServers.rlhf = mergeRlhfEntry(config.mcpServers.rlhf);
+  config.mcpServers[MCP_SERVER_KEY] = mergeThumbgateEntry(config.mcpServers[MCP_SERVER_KEY]);
   for (const legacyName of LEGACY_SERVER_NAMES) {
     delete config.mcpServers[legacyName];
   }
@@ -63,13 +64,13 @@ function ensureClaudeSettings(repoRoot) {
     return false;
   }
   const hasRelevantServer =
-    Boolean(existing.mcpServers && existing.mcpServers.rlhf) ||
+    Boolean(existing.mcpServers && existing.mcpServers[MCP_SERVER_KEY]) ||
     LEGACY_SERVER_NAMES.some((name) => Boolean(existing.mcpServers && existing.mcpServers[name]));
   if (!hasRelevantServer) {
     return false;
   }
   existing.mcpServers = existing.mcpServers && typeof existing.mcpServers === 'object' ? existing.mcpServers : {};
-  existing.mcpServers.rlhf = mergeRlhfEntry(existing.mcpServers.rlhf);
+  existing.mcpServers[MCP_SERVER_KEY] = mergeThumbgateEntry(existing.mcpServers[MCP_SERVER_KEY]);
   for (const legacyName of LEGACY_SERVER_NAMES) {
     delete existing.mcpServers[legacyName];
   }
@@ -106,19 +107,19 @@ function ensureInfoExclude(repoRoot) {
   return true;
 }
 
-function ensureRlhfDir(repoRoot) {
-  const rlhfDir = path.join(repoRoot, '.rlhf');
-  if (fs.existsSync(rlhfDir)) {
+function ensureThumbgateDir(repoRoot) {
+  const thumbgateDir = path.join(repoRoot, '.thumbgate');
+  if (fs.existsSync(thumbgateDir)) {
     return false;
   }
-  fs.mkdirSync(rlhfDir, { recursive: true });
+  fs.mkdirSync(thumbgateDir, { recursive: true });
   return true;
 }
 
 function main() {
   const results = {
     repoRoot: REPO_ROOT,
-    createdRlhfDir: ensureRlhfDir(REPO_ROOT),
+    createdThumbgateDir: ensureThumbgateDir(REPO_ROOT),
     updatedMcpJson: ensureMcpJson(REPO_ROOT),
     updatedClaudeSettings: ensureClaudeSettings(REPO_ROOT),
     updatedInfoExclude: ensureInfoExclude(REPO_ROOT),

package/scripts/feedback-history-distiller.js

@@ -79,7 +79,13 @@ function readJsonlTail(filePath, limit = DEFAULT_HISTORY_LIMIT) {
 }
 
 function resolveFeedbackDir(feedbackDir) {
-  return resolveSharedFeedbackDir({ feedbackDir });
+  if (feedbackDir) {
+    return resolveSharedFeedbackDir({ feedbackDir });
+  }
+  const env = { ...process.env };
+  delete env.INIT_CWD;
+  delete env.PWD;
+  return resolveSharedFeedbackDir({ env });
 }
 
 function getConversationPaths(feedbackDir) {

package/scripts/feedback-loop.js

@@ -146,8 +146,8 @@ function updateStatuslineWithLesson({ accepted, signal, memoryId, feedbackId, le
   } catch { /* statusline update is best-effort */ }
 }
 
-function getFeedbackPaths() {
-  return resolveFeedbackPaths();
+function getFeedbackPaths(options = {}) {
+  return resolveFeedbackPaths(options);
 }
 
 function getContextFsModule() {
@@ -1673,8 +1673,8 @@ function writePreventionRules(filePath, minOccurrences = 2) {
   return { path: outPath, markdown };
 }
 
-function feedbackSummary(recentN = 20) {
-  const { FEEDBACK_LOG_PATH } = getFeedbackPaths();
+function feedbackSummary(recentN = 20, options = {}) {
+  const { FEEDBACK_LOG_PATH } = getFeedbackPaths(options);
   const entries = readJSONL(FEEDBACK_LOG_PATH);
   if (entries.length === 0) {
     return '## Feedback Summary\nNo feedback recorded yet.';
@@ -1794,6 +1794,10 @@ function runTests() {
   const tmpDir = fs.mkdtempSync(path.join(require('os').tmpdir(), 'thumbgate-loop-test-'));
   const localFeedbackLog = path.join(tmpDir, 'feedback-log.jsonl');
   process.env.THUMBGATE_FEEDBACK_DIR = tmpDir;
+  const savedInitCwd = process.env.INIT_CWD;
+  process.env.INIT_CWD = savedInitCwd || process.cwd();
+
+  assert(getFeedbackPaths().FEEDBACK_DIR === tmpDir, 'explicit feedback dir wins over npm INIT_CWD');
 
   appendJSONL(localFeedbackLog, { signal: 'positive', tags: ['testing'], skill: 'verify' });
   appendJSONL(localFeedbackLog, { signal: 'negative', tags: ['testing'], skill: 'verify' });
@@ -1845,6 +1849,8 @@ function runTests() {
 
   fs.rmSync(tmpDir, { recursive: true, force: true });
   delete process.env.THUMBGATE_FEEDBACK_DIR;
+  if (savedInitCwd === undefined) delete process.env.INIT_CWD;
+  else process.env.INIT_CWD = savedInitCwd;
   console.log(`\nResults: ${passed} passed, ${failed} failed\n`);
   process.exit(failed > 0 ? 1 : 0);
 }

package/scripts/feedback-paths.js

@@ -43,14 +43,139 @@ function dirExists(dirPath) {
   }
 }
 
+function getHomeDir(options = {}) {
+  const env = options.env || process.env;
+  return options.home || env.HOME || env.USERPROFILE || HOME;
+}
+
+function normalizeDir(dirPath) {
+  if (!dirPath) return null;
+  try {
+    return path.resolve(String(dirPath));
+  } catch {
+    return null;
+  }
+}
+
+function isWithinDir(candidate, parent) {
+  const normalizedCandidate = normalizeDir(candidate);
+  const normalizedParent = normalizeDir(parent);
+  if (!normalizedCandidate || !normalizedParent) return false;
+  const relative = path.relative(normalizedParent, normalizedCandidate);
+  return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+
+function getRuntimeDir(options = {}) {
+  return path.join(getHomeDir(options), '.thumbgate', 'runtime');
+}
+
+function getActiveProjectStatePath(options = {}) {
+  return path.join(getRuntimeDir(options), 'active-project.json');
+}
+
+function isTransientProjectDir(dirPath, options = {}) {
+  const normalizedDir = normalizeDir(dirPath);
+  if (!normalizedDir) return true;
+  if (!dirExists(normalizedDir)) return true;
+
+  const runtimeDir = getRuntimeDir(options);
+  if (isWithinDir(normalizedDir, runtimeDir)) return true;
+
+  return normalizedDir.includes(`${path.sep}.npm${path.sep}_npx${path.sep}`)
+    || /thumbgate-published-cli-/i.test(normalizedDir);
+}
+
+function readActiveProjectState(options = {}) {
+  const statePath = getActiveProjectStatePath(options);
+  try {
+    const parsed = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+    if (!parsed || !parsed.projectDir) return null;
+    if (isTransientProjectDir(parsed.projectDir, options)) return null;
+    return {
+      ...parsed,
+      projectDir: normalizeDir(parsed.projectDir),
+    };
+  } catch {
+    return null;
+  }
+}
+
+function writeActiveProjectState(projectDir, options = {}) {
+  const normalizedDir = normalizeDir(projectDir);
+  if (isTransientProjectDir(normalizedDir, options)) return null;
+
+  const payload = {
+    projectDir: normalizedDir,
+    projectName: path.basename(normalizedDir) || 'default',
+    updatedAt: new Date().toISOString(),
+  };
+
+  const statePath = getActiveProjectStatePath(options);
+  fs.mkdirSync(path.dirname(statePath), { recursive: true });
+  fs.writeFileSync(statePath, JSON.stringify(payload, null, 2));
+  return payload;
+}
+
+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(),
+  ]);
+  const isTransientExecution = cwdCandidates.length > 0
+    && cwdCandidates.every((candidate) => isTransientProjectDir(candidate, options));
+  const candidates = uniquePaths([
+    options.projectDir,
+    env.THUMBGATE_PROJECT_DIR,
+    env.CLAUDE_PROJECT_DIR,
+    isTransientExecution && stored && stored.projectDir,
+    env.INIT_CWD,
+    ...cwdCandidates,
+    !isTransientExecution && stored && stored.projectDir,
+  ]);
+
+  for (const candidate of candidates) {
+    if (!candidate) continue;
+    if (!isTransientProjectDir(candidate, options)) {
+      return normalizeDir(candidate);
+    }
+  }
+
+  return normalizeDir(options.cwd || env.PWD || PROJECT_ROOT) || PROJECT_ROOT;
+}
+
 function getProjectName(cwd = process.cwd()) {
   return path.basename(cwd || PROJECT_ROOT) || 'default';
 }
 
+function hasDirectProjectScope(options = {}) {
+  const env = options.env || process.env;
+  return Boolean(
+    options.explicitProjectDir
+    || env.THUMBGATE_PROJECT_DIR
+    || env.CLAUDE_PROJECT_DIR
+  );
+}
+
+function hasExplicitProjectScope(options = {}) {
+  return Boolean(hasDirectProjectScope(options) || readActiveProjectState(options));
+}
+
 function getExplicitFeedbackDir(options = {}) {
   const env = options.env || process.env;
   if (options.feedbackDir) return options.feedbackDir;
-  if (env.THUMBGATE_FEEDBACK_DIR) return env.THUMBGATE_FEEDBACK_DIR;
+  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)) {
+    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');
   }
@@ -58,30 +183,29 @@ function getExplicitFeedbackDir(options = {}) {
 }
 
 function getThumbgateFeedbackDir(options = {}) {
-  const cwd = options.cwd || process.cwd();
-  return path.join(cwd, '.thumbgate');
+  const projectDir = resolveProjectDir(options);
+  return path.join(projectDir, '.thumbgate');
 }
 
 function getFallbackFeedbackDir(options = {}) {
   const env = options.env || process.env;
   if (env._TEST_THUMBGATE_FALLBACK_FEEDBACK_DIR) return env._TEST_THUMBGATE_FALLBACK_FEEDBACK_DIR;
   if (env.THUMBGATE_FALLBACK_FEEDBACK_DIR) return env.THUMBGATE_FALLBACK_FEEDBACK_DIR;
-  const cwd = options.cwd || process.cwd();
-  return path.join(cwd, '.thumbgate-compat');
+  const projectDir = resolveProjectDir(options);
+  return path.join(projectDir, '.thumbgate-compat');
 }
 
 function getLegacyFeedbackDir(options = {}) {
   const env = options.env || process.env;
   if (env._TEST_LEGACY_FEEDBACK_DIR) return env._TEST_LEGACY_FEEDBACK_DIR;
   if (env.THUMBGATE_LEGACY_FEEDBACK_DIR) return env.THUMBGATE_LEGACY_FEEDBACK_DIR;
-  const cwd = options.cwd || process.cwd();
-  return path.join(cwd, '.claude', 'memory', 'feedback');
+  const projectDir = resolveProjectDir(options);
+  return path.join(projectDir, '.claude', 'memory', 'feedback');
 }
 
 function getGlobalFeedbackDir(options = {}) {
-  const cwd = options.cwd || process.cwd();
-  const home = options.home || HOME;
-  return path.join(home, '.thumbgate', 'projects', getProjectName(cwd));
+  const projectDir = resolveProjectDir(options);
+  return path.join(getHomeDir(options), '.thumbgate', 'projects', getProjectName(projectDir));
 }
 
 function resolveFeedbackDir(options = {}) {
@@ -133,13 +257,21 @@ module.exports = {
   PROJECT_ROOT,
   HOME,
   buildFeedbackPathsFromDir,
+  getActiveProjectStatePath,
   getFeedbackPaths,
   getGlobalFeedbackDir,
+  getHomeDir,
   getLegacyFeedbackDir,
   getFallbackFeedbackDir,
+  getRuntimeDir,
   getThumbgateFeedbackDir,
+  hasDirectProjectScope,
+  hasExplicitProjectScope,
+  readActiveProjectState,
   listFallbackFeedbackDirs,
   listFeedbackArtifactPaths,
+  resolveProjectDir,
   resolveFallbackArtifactPath,
   resolveFeedbackDir,
+  writeActiveProjectState,
 };

package/scripts/feedback-root-consolidator.js

@@ -29,6 +29,19 @@ const CONSOLIDATED_ARTIFACTS = [
   'workflow-sprint-leads.jsonl',
 ];
 
+function getScopedProjectOptions(options = {}) {
+  if (options.feedbackDir) return options;
+
+  const projectDir = options.projectDir || options.cwd;
+  if (!projectDir) return options;
+
+  return {
+    ...options,
+    projectDir,
+    explicitProjectDir: true,
+  };
+}
+
 function ensureParentDir(filePath) {
   fs.mkdirSync(path.dirname(filePath), { recursive: true });
 }
@@ -194,11 +207,11 @@ function consolidateArtifact(fileName, options = {}) {
 }
 
 function consolidateFeedbackRoot(options = {}) {
-  const feedbackDir = options.feedbackDir
-    || process.env.THUMBGATE_FEEDBACK_DIR
-    || getThumbgateFeedbackDir(options);
+  const scopedOptions = getScopedProjectOptions(options);
+  const feedbackDir = scopedOptions.feedbackDir
+    || getThumbgateFeedbackDir(scopedOptions);
   const artifacts = CONSOLIDATED_ARTIFACTS.map((fileName) => consolidateArtifact(fileName, {
-    ...options,
+    ...scopedOptions,
     feedbackDir,
   }));
   const sourceRoots = Array.from(new Set(
@@ -229,6 +242,7 @@ module.exports = {
   consolidateArtifact,
   consolidateFeedbackRoot,
   dedupeJsonlRows,
+  getScopedProjectOptions,
   mergeCheckoutSessionsPayloads,
   mergeKeyStorePayloads,
 };

package/scripts/gates-engine.js

@@ -11,6 +11,9 @@ const {
   DEFAULT_BASE_BRANCH,
   evaluateOperationalIntegrity,
 } = require('./operational-integrity');
+const {
+  evaluateWorkflowSentinel,
+} = require('./workflow-sentinel');
 
 /**
  * Computes the SHA-256 hash of an executable binary to prevent path-based bypasses.
@@ -764,6 +767,16 @@ function buildReasoning(gate, toolName, toolInput, extras = {}) {
     steps.push(`Memory guard matched (${extras.memoryGuard.source}): ${extras.memoryGuard.reason}`);
   }
 
+  if (extras.workflowSentinel) {
+    steps.push(`Workflow sentinel risk: ${extras.workflowSentinel.band} (${extras.workflowSentinel.riskScore})`);
+    if (extras.workflowSentinel.blastRadius && extras.workflowSentinel.blastRadius.summary) {
+      steps.push(`Workflow sentinel blast radius: ${extras.workflowSentinel.blastRadius.summary}`);
+    }
+    for (const remediation of (extras.workflowSentinel.remediations || []).slice(0, 3)) {
+      steps.push(`Workflow sentinel remediation: ${remediation.title} — ${remediation.action}`);
+    }
+  }
+
   // 5. Unless condition status
   if (gate.unless) {
     steps.push(`Bypassable via satisfy_gate("${gate.unless}") — not currently satisfied`);
@@ -973,6 +986,39 @@ function evaluateMemoryGuard(toolName, toolInput = {}) {
   };
 }
 
+function buildSentinelGateResult(report) {
+  return {
+    decision: report.decision,
+    gate: 'workflow-sentinel',
+    message: `${report.summary} ${report.blastRadius.summary}`,
+    severity: report.decision === 'deny' ? 'critical' : 'high',
+    reasoning: Array.isArray(report.reasoning) ? report.reasoning.slice() : [],
+    sentinel: report,
+  };
+}
+
+function enrichResultWithSentinel(result, report) {
+  if (!result || !report || report.decision === 'allow') {
+    return result;
+  }
+
+  const next = {
+    ...result,
+    reasoning: Array.isArray(result.reasoning) ? result.reasoning.slice() : [],
+    sentinel: report,
+  };
+
+  if (report.blastRadius && report.blastRadius.summary) {
+    next.message = `${result.message} Workflow sentinel: ${report.blastRadius.summary}`;
+  }
+
+  next.reasoning = next.reasoning.concat(
+    Array.isArray(report.reasoning) ? report.reasoning : []
+  );
+
+  return next;
+}
+
 async function checkMetricCondition(metricCondition) {
   if (!metricCondition) return true;
   const { getBusinessMetrics } = require('./semantic-layer');
@@ -1058,20 +1104,40 @@ async function evaluateGatesAsync(toolName, toolInput, configPath) {
     }
   }
 
+  const sentinelReport = evaluateWorkflowSentinel(toolName, toolInput, {
+    governanceState: loadGovernanceState(),
+  });
   const memoryGuard = evaluateMemoryGuard(toolName, toolInput);
   if (memoryGuard) {
-    recordStat(memoryGuard.gate, 'block');
+    const enrichedMemoryGuard = enrichResultWithSentinel(memoryGuard, sentinelReport);
+    recordStat(enrichedMemoryGuard.gate, 'block');
     const auditRecord = recordAuditEvent({
       toolName,
       toolInput,
       decision: 'deny',
-      gateId: memoryGuard.gate,
-      message: memoryGuard.message,
-      severity: memoryGuard.severity,
+      gateId: enrichedMemoryGuard.gate,
+      message: enrichedMemoryGuard.message,
+      severity: enrichedMemoryGuard.severity,
       source: 'gates-engine',
     });
     auditToFeedback(auditRecord);
-    return memoryGuard;
+    return enrichedMemoryGuard;
+  }
+
+  if (sentinelReport && sentinelReport.decision !== 'allow') {
+    const sentinelResult = buildSentinelGateResult(sentinelReport);
+    recordStat(sentinelResult.gate, sentinelResult.decision === 'deny' ? 'block' : 'warn');
+    const auditRecord = recordAuditEvent({
+      toolName,
+      toolInput,
+      decision: sentinelResult.decision,
+      gateId: sentinelResult.gate,
+      message: sentinelResult.message,
+      severity: sentinelResult.severity,
+      source: 'workflow-sentinel',
+    });
+    auditToFeedback(auditRecord);
+    return sentinelResult;
   }
 
   // Audit trail: record allow (no gate matched)
@@ -1124,20 +1190,40 @@ function evaluateGates(toolName, toolInput, configPath) {
     }
   }
 
+  const sentinelReport = evaluateWorkflowSentinel(toolName, toolInput, {
+    governanceState: loadGovernanceState(),
+  });
   const memoryGuard = evaluateMemoryGuard(toolName, toolInput);
   if (memoryGuard) {
-    recordStat(memoryGuard.gate, 'block');
+    const enrichedMemoryGuard = enrichResultWithSentinel(memoryGuard, sentinelReport);
+    recordStat(enrichedMemoryGuard.gate, 'block');
     const auditRecord = recordAuditEvent({
       toolName,
       toolInput,
       decision: 'deny',
-      gateId: memoryGuard.gate,
-      message: memoryGuard.message,
-      severity: memoryGuard.severity,
+      gateId: enrichedMemoryGuard.gate,
+      message: enrichedMemoryGuard.message,
+      severity: enrichedMemoryGuard.severity,
       source: 'gates-engine',
     });
     auditToFeedback(auditRecord);
-    return memoryGuard;
+    return enrichedMemoryGuard;
+  }
+
+  if (sentinelReport && sentinelReport.decision !== 'allow') {
+    const sentinelResult = buildSentinelGateResult(sentinelReport);
+    recordStat(sentinelResult.gate, sentinelResult.decision === 'deny' ? 'block' : 'warn');
+    const auditRecord = recordAuditEvent({
+      toolName,
+      toolInput,
+      decision: sentinelResult.decision,
+      gateId: sentinelResult.gate,
+      message: sentinelResult.message,
+      severity: sentinelResult.severity,
+      source: 'workflow-sentinel',
+    });
+    auditToFeedback(auditRecord);
+    return sentinelResult;
   }
 
   // Audit trail: record allow

package/scripts/hook-auto-capture.sh

@@ -10,7 +10,7 @@ PROMPT_GUARD="$SCRIPT_DIR/prompt-guard.js"
 ACTIVE_CWD="${CLAUDE_PROJECT_DIR:-${PWD:-$(pwd)}}"
 FEEDBACK_DIR="$(node -e "const path = require('path'); const { resolveFeedbackDir } = require(path.join(process.argv[1], 'feedback-paths.js')); process.stdout.write(resolveFeedbackDir({ cwd: process.argv[2] || process.cwd(), feedbackDir: process.env.THUMBGATE_FEEDBACK_DIR || undefined }));" "$SCRIPT_DIR" "$ACTIVE_CWD" 2>/dev/null)"
 if [ -z "$FEEDBACK_DIR" ]; then
-  FEEDBACK_DIR="${THUMBGATE_FEEDBACK_DIR:-$ACTIVE_CWD/.rlhf}"
+  FEEDBACK_DIR="${THUMBGATE_FEEDBACK_DIR:-$ACTIVE_CWD/.thumbgate}"
 fi
 FEEDBACK_LOG="$FEEDBACK_DIR/feedback-log.jsonl"
 MEMORY_LOG="$FEEDBACK_DIR/memory-log.jsonl"