thumbgate 0.9.14 → 1.0.0

package/scripts/context-manager.js

@@ -0,0 +1,330 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Context Manager — Unified Context-Augmented Generation (CAG) Orchestrator
+ *
+ * Single entry point that assembles a normalized context object from:
+ *   - Session state (primer / handoff)
+ *   - User profile (role, preferences, agent type)
+ *   - Relevant lessons (per-action retrieval)
+ *   - Prevention rules / pre-tool guards
+ *   - Context pack (ContextFS retrieval)
+ *   - Code-graph impact (optional, for coding tasks)
+ *
+ * Implements tiered graceful degradation:
+ *   Tier 1 (full)  — session + lessons + rules + context pack + code-graph
+ *   Tier 2 (warm)  — lessons + rules + context pack (no session)
+ *   Tier 3 (cold)  — prevention rules + global defaults only
+ *
+ * Role-aware filtering shapes output by agent type and license tier.
+ */
+
+const {
+  ensureContextFs,
+  constructContextPack,
+  readSessionHandoff,
+  recordProvenance,
+} = require('./contextfs');
+const { retrieveRelevantLessons } = require('./lesson-retrieval');
+const { evaluatePretool } = require('./hybrid-feedback-context');
+const { loadProfile } = require('./user-profile');
+const {
+  analyzeCodeGraphImpact,
+  formatCodeGraphRecallSection,
+} = require('./codegraph-context');
+
+// ---------------------------------------------------------------------------
+// Agent capability profiles — shapes what context each agent type receives
+// ---------------------------------------------------------------------------
+
+const AGENT_PROFILES = {
+  claude: {
+    maxLessons: 8,
+    includeCodeGraph: true,
+    includeStructuredRules: true,
+    contextBudget: 10000,
+  },
+  cursor: {
+    maxLessons: 5,
+    includeCodeGraph: true,
+    includeStructuredRules: true,
+    contextBudget: 6000,
+  },
+  forgecode: {
+    maxLessons: 5,
+    includeCodeGraph: false,
+    includeStructuredRules: true,
+    contextBudget: 6000,
+  },
+  codex: {
+    maxLessons: 6,
+    includeCodeGraph: true,
+    includeStructuredRules: true,
+    contextBudget: 8000,
+  },
+  default: {
+    maxLessons: 5,
+    includeCodeGraph: false,
+    includeStructuredRules: true,
+    contextBudget: 6000,
+  },
+};
+
+function getAgentProfile(agentType) {
+  const key = String(agentType || 'default').toLowerCase();
+  return AGENT_PROFILES[key] || AGENT_PROFILES.default;
+}
+
+// ---------------------------------------------------------------------------
+// Tier assembly helpers
+// ---------------------------------------------------------------------------
+
+function assembleSession() {
+  try {
+    return readSessionHandoff();
+  } catch {
+    return null;
+  }
+}
+
+function assembleLessons(query, agentProfile, options = {}) {
+  try {
+    return retrieveRelevantLessons(
+      options.toolName || '',
+      query,
+      { maxResults: agentProfile.maxLessons, feedbackDir: options.feedbackDir },
+    );
+  } catch {
+    return [];
+  }
+}
+
+function assembleGuards(toolName, toolInput) {
+  try {
+    return evaluatePretool(toolName || '', toolInput || {});
+  } catch {
+    return { mode: 'allow', reason: 'guard-unavailable' };
+  }
+}
+
+function assembleContextPack(query, agentProfile) {
+  try {
+    ensureContextFs();
+    return constructContextPack({
+      query,
+      maxItems: Math.min(8, Math.ceil(agentProfile.contextBudget / 1000)),
+      maxChars: agentProfile.contextBudget,
+    });
+  } catch {
+    return null;
+  }
+}
+
+function assembleCodeGraph(query, repoPath, agentProfile) {
+  if (!agentProfile.includeCodeGraph) return null;
+  try {
+    const impact = analyzeCodeGraphImpact({
+      intentId: null,
+      context: query,
+      repoPath,
+    });
+    return formatCodeGraphRecallSection(impact) || null;
+  } catch {
+    return null;
+  }
+}
+
+function assembleUserProfile() {
+  try {
+    const profile = loadProfile();
+    if (!profile || !profile.entries || profile.entries.length === 0) return null;
+    return {
+      entries: profile.entries,
+      charCount: profile.charCount || 0,
+    };
+  } catch {
+    return null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Tier classification
+// ---------------------------------------------------------------------------
+
+function classifyTier(components) {
+  const hasSession = !!components.session;
+  const hasLessons = components.lessons && components.lessons.length > 0;
+  const hasPack = !!components.contextPack;
+
+  if (hasSession && (hasLessons || hasPack)) return 'full';
+  if (hasLessons || hasPack) return 'warm';
+  return 'cold';
+}
+
+// ---------------------------------------------------------------------------
+// Main orchestrator
+// ---------------------------------------------------------------------------
+
+/**
+ * Assemble a unified context object for a given query.
+ *
+ * @param {Object} params
+ * @param {string} params.query - Task description / context query
+ * @param {string} [params.toolName] - Current tool being invoked (for lesson retrieval)
+ * @param {Object} [params.toolInput] - Current tool input (for guard evaluation)
+ * @param {string} [params.agentType] - Agent type: claude, cursor, forgecode, codex
+ * @param {string} [params.repoPath] - Repo path for code-graph analysis
+ * @param {string} [params.feedbackDir] - Override feedback directory
+ * @returns {Object} Normalized context object
+ */
+function assembleUnifiedContext(params = {}) {
+  const {
+    query = '',
+    toolName,
+    toolInput,
+    agentType,
+    repoPath,
+    feedbackDir,
+  } = params;
+
+  const agentProfile = getAgentProfile(agentType);
+
+  // Assemble all components — each is fault-tolerant
+  const session = assembleSession();
+  const userProfile = assembleUserProfile();
+  const lessons = assembleLessons(query, agentProfile, { toolName, feedbackDir });
+  const guards = assembleGuards(toolName, toolInput);
+  const contextPack = assembleContextPack(query, agentProfile);
+  const codeGraph = assembleCodeGraph(query, repoPath, agentProfile);
+
+  const components = { session, userProfile, lessons, guards, contextPack, codeGraph };
+  const tier = classifyTier(components);
+
+  const result = {
+    tier,
+    agentType: agentType || 'default',
+    agentProfile: {
+      maxLessons: agentProfile.maxLessons,
+      contextBudget: agentProfile.contextBudget,
+      includeCodeGraph: agentProfile.includeCodeGraph,
+    },
+    session: session || null,
+    userProfile: userProfile || null,
+    lessons,
+    guards,
+    contextPack: contextPack ? {
+      packId: contextPack.packId,
+      itemCount: Array.isArray(contextPack.items) ? contextPack.items.length : 0,
+      items: (contextPack.items || []).slice(0, 5).map((item) => ({
+        id: item.id,
+        namespace: item.namespace,
+        title: item.title,
+        tags: item.tags || [],
+        score: item.score,
+      })),
+      visibility: contextPack.visibility || null,
+      cached: !!(contextPack.cache && contextPack.cache.hit),
+    } : null,
+    codeGraph: codeGraph || null,
+    assembledAt: new Date().toISOString(),
+  };
+
+  // Record provenance for audit trail
+  try {
+    recordProvenance({
+      type: 'unified_context_assembled',
+      tier,
+      agentType: result.agentType,
+      lessonCount: lessons.length,
+      guardDecision: guards.mode || 'allow',
+      hasSession: !!session,
+      hasUserProfile: !!userProfile,
+      hasCodeGraph: !!codeGraph,
+      packId: result.contextPack ? result.contextPack.packId : null,
+    });
+  } catch {
+    // Provenance write failure must never break context assembly
+  }
+
+  return result;
+}
+
+// ---------------------------------------------------------------------------
+// Formatting for MCP tool response
+// ---------------------------------------------------------------------------
+
+function formatUnifiedContext(ctx) {
+  const lines = [];
+
+  lines.push(`## Unified Context (Tier: ${ctx.tier})`);
+  lines.push(`Agent: ${ctx.agentType} | Assembled: ${ctx.assembledAt}`);
+  lines.push('');
+
+  // Session
+  if (ctx.session) {
+    lines.push('### Session');
+    if (ctx.session.lastTask) lines.push(`Last task: ${ctx.session.lastTask}`);
+    if (ctx.session.nextStep) lines.push(`Next step: ${ctx.session.nextStep}`);
+    if (ctx.session.blockers && ctx.session.blockers.length > 0) {
+      lines.push(`Blockers: ${ctx.session.blockers.join(', ')}`);
+    }
+    lines.push('');
+  }
+
+  // User profile
+  if (ctx.userProfile) {
+    lines.push('### User Profile');
+    ctx.userProfile.entries.slice(0, 3).forEach((entry) => {
+      lines.push(`- ${entry.slice(0, 120)}`);
+    });
+    lines.push('');
+  }
+
+  // Guards
+  if (ctx.guards && ctx.guards.mode !== 'allow') {
+    lines.push(`### Guard: ${ctx.guards.mode.toUpperCase()}`);
+    lines.push(ctx.guards.reason || 'No reason provided');
+    lines.push('');
+  }
+
+  // Lessons
+  if (ctx.lessons && ctx.lessons.length > 0) {
+    lines.push(`### Lessons (${ctx.lessons.length})`);
+    ctx.lessons.forEach((lesson) => {
+      const signal = lesson.signal === 'negative' ? '[-]' : '[+]';
+      lines.push(`${signal} ${lesson.title || lesson.id} (score: ${lesson.relevanceScore})`);
+      if (lesson.rule) {
+        lines.push(`  Rule: IF ${lesson.rule.condition || '?'} THEN ${lesson.rule.action || '?'}`);
+      }
+    });
+    lines.push('');
+  }
+
+  // Context pack
+  if (ctx.contextPack) {
+    lines.push(`### Context Pack (${ctx.contextPack.itemCount} items)`);
+    ctx.contextPack.items.forEach((item) => {
+      lines.push(`- [${item.namespace}] ${item.title} (score: ${item.score})`);
+    });
+    if (ctx.contextPack.cached) lines.push('(cached)');
+    lines.push('');
+  }
+
+  // Code graph
+  if (ctx.codeGraph) {
+    lines.push('### Code Graph Impact');
+    lines.push(ctx.codeGraph);
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
+module.exports = {
+  assembleUnifiedContext,
+  formatUnifiedContext,
+  getAgentProfile,
+  AGENT_PROFILES,
+  classifyTier,
+};

package/scripts/dashboard.js

@@ -523,7 +523,7 @@ function computeInstrumentationReadiness(analytics, billing) {
   const cli = telemetry.cli || {};
 
   return {
-    plausibleConfigured: /\/js\/analytics\.js/.test(landingPage),
+    plausibleConfigured: /plausible\.io\/js\/script\.js|\/js\/analytics\.js/.test(landingPage),
     ga4Configured: Boolean(runtimeConfig.gaMeasurementId),
     googleSearchConsoleConfigured: Boolean(runtimeConfig.googleSiteVerification),
     softwareApplicationSchemaPresent: /"@type": "SoftwareApplication"/.test(landingPage),

package/scripts/distribution-surfaces.js

@@ -6,6 +6,7 @@ const path = require('node:path');
 const ROOT = path.join(__dirname, '..');
 const PRODUCTHUNT_URL = 'https://www.producthunt.com/products/thumbgate';
 const CLAUDE_PLUGIN_LATEST_ASSET_NAME = 'thumbgate-claude-desktop.mcpb';
+const CLAUDE_PLUGIN_NEXT_ASSET_NAME = 'thumbgate-claude-desktop-next.mcpb';
 
 function readJson(root, relativePath) {
   return JSON.parse(fs.readFileSync(path.join(root, relativePath), 'utf8'));
@@ -24,6 +25,14 @@ function getClaudePluginVersionedAssetName(version = getPackageVersion(ROOT)) {
   return `thumbgate-claude-desktop-v${normalized}.mcpb`;
 }
 
+function isPrereleaseVersion(version = getPackageVersion(ROOT)) {
+  return /^\d+\.\d+\.\d+-[0-9A-Za-z.-]+$/.test(String(version || '').trim());
+}
+
+function getClaudePluginChannelAssetName(version = getPackageVersion(ROOT)) {
+  return isPrereleaseVersion(version) ? CLAUDE_PLUGIN_NEXT_ASSET_NAME : CLAUDE_PLUGIN_LATEST_ASSET_NAME;
+}
+
 function getClaudePluginLatestDownloadUrl(root = ROOT) {
   return `${getRepositoryUrl(root)}/releases/latest/download/${CLAUDE_PLUGIN_LATEST_ASSET_NAME}`;
 }
@@ -35,10 +44,13 @@ function getClaudePluginVersionedDownloadUrl(root = ROOT, version = getPackageVe
 
 module.exports = {
   CLAUDE_PLUGIN_LATEST_ASSET_NAME,
+  CLAUDE_PLUGIN_NEXT_ASSET_NAME,
   PRODUCTHUNT_URL,
+  getClaudePluginChannelAssetName,
   getClaudePluginLatestDownloadUrl,
   getClaudePluginVersionedAssetName,
   getClaudePluginVersionedDownloadUrl,
   getPackageVersion,
   getRepositoryUrl,
+  isPrereleaseVersion,
 };

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/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"