thumbgate 1.3.0 → 1.4.1

package/scripts/lesson-inference.js

@@ -17,6 +17,7 @@
 const fs = require('fs');
 const path = require('path');
 const { resolveFeedbackDir } = require('./feedback-paths');
+const { ensureParentDir, readJsonl } = require('./fs-utils');
 const {
   buildStableId,
   extractFilePaths,
@@ -39,15 +40,6 @@ function getLessonBaseUrl() {
 function getLessonsPath() { return path.join(getFeedbackDir(), LESSONS_FILE); }
 function getRecentLessonPath() { return path.join(getFeedbackDir(), RECENT_LESSON_FILE); }
 
-function readJsonl(fp) {
-  if (!fs.existsSync(fp)) return [];
-  const raw = fs.readFileSync(fp, 'utf-8').trim();
-  if (!raw) return [];
-  return raw.split('\n').map((l) => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
-}
-
-function ensureDir(p) { const d = path.dirname(p); if (!fs.existsSync(d)) fs.mkdirSync(d, { recursive: true }); }
-
 // ---------------------------------------------------------------------------
 // 1. Surrounding Message Context Extraction
 // ---------------------------------------------------------------------------
@@ -146,7 +138,7 @@ function createLesson({ feedbackId, signal, inferredLesson, triggerMessage, prio
   lesson.link = `${getLessonBaseUrl()}/lessons#${lesson.id}`;
 
   const lessonsPath = getLessonsPath();
-  ensureDir(lessonsPath);
+  ensureParentDir(lessonsPath);
   fs.appendFileSync(lessonsPath, JSON.stringify(lesson) + '\n');
 
   // Update recent lesson for statusbar
@@ -165,6 +157,55 @@ function getRecentLesson() {
   try { return JSON.parse(fs.readFileSync(p, 'utf-8')); } catch { return null; }
 }
 
+function isNegativeSignal(signal) {
+  return signal === 'negative' || signal === 'down';
+}
+
+function isPositiveSignal(signal) {
+  return signal === 'positive' || signal === 'up';
+}
+
+function selectStatusbarLesson() {
+  const lessons = readJsonl(getLessonsPath())
+    .slice()
+    .sort((a, b) => new Date(b.createdAt || 0) - new Date(a.createdAt || 0));
+  const latestNegative = lessons.find((lesson) => isNegativeSignal(lesson.signal));
+  if (latestNegative) return latestNegative;
+  const latestPositive = lessons.find((lesson) => isPositiveSignal(lesson.signal));
+  if (latestPositive) return latestPositive;
+  return getRecentLesson();
+}
+
+function getLessonKind(lesson = {}) {
+  const normalizedTitle = String(lesson.lesson || '').trim();
+  if (isNegativeSignal(lesson.signal) || /^MISTAKE:/i.test(normalizedTitle)) return 'mistake';
+  if (isPositiveSignal(lesson.signal) || /^SUCCESS:/i.test(normalizedTitle)) return 'success';
+  if (/^LEARNING:/i.test(normalizedTitle)) return 'learning';
+  if (/^PREFERENCE:/i.test(normalizedTitle)) return 'preference';
+  return 'lesson';
+}
+
+function stripLessonPrefix(lessonText = '') {
+  return String(lessonText || '').replace(/^(MISTAKE|SUCCESS|LEARNING|PREFERENCE):\s*/i, '').trim();
+}
+
+function formatLessonTimestamp(createdAt = '') {
+  const parsed = new Date(createdAt);
+  if (!Number.isFinite(parsed.getTime())) return '';
+  return parsed.toISOString().slice(0, 16).replace('T', ' ') + 'Z';
+}
+
+function buildStatusbarLessonLabel(lesson = {}) {
+  const kind = getLessonKind(lesson);
+  const prefix = kind === 'mistake'
+    ? 'Latest mistake'
+    : kind === 'success'
+      ? 'Latest success'
+      : 'Latest lesson';
+  const timestamp = formatLessonTimestamp(lesson.createdAt);
+  return timestamp ? `${prefix} ${timestamp}` : prefix;
+}
+
 /**
  * Search lessons by query text.
  */
@@ -196,6 +237,59 @@ function getLessonStats() {
   return { total: lessons.length, positive, negative, avgConfidence };
 }
 
+// ---------------------------------------------------------------------------
+// 2b. Context Stuffing — dump all lessons for injection into agent context
+// ---------------------------------------------------------------------------
+
+/**
+ * Returns ALL lessons condensed for context-window injection.
+ * Bypasses RAG/search — just stuff everything into context.
+ * For most projects (20-200 lessons), this is 1K-10K tokens.
+ * @param {object} opts
+ * @param {number} opts.maxTokenBudget - approximate token budget (default 10000)
+ * @param {string} opts.signal - filter by 'positive' or 'negative'
+ * @param {string} opts.format - 'compact' (default) or 'full'
+ * @returns {{ lessons: string, count: number, truncated: boolean }}
+ */
+function getAllLessonsForContext({ maxTokenBudget = 10000, signal, format = 'compact' } = {}) {
+  let lessons = readJsonl(getLessonsPath());
+  if (signal) lessons = lessons.filter((l) => l.signal === signal || (signal === 'negative' && l.signal === 'down') || (signal === 'positive' && l.signal === 'up'));
+
+  // Sort by confidence descending — most important lessons first
+  lessons.sort((a, b) => (b.confidence || 0) - (a.confidence || 0));
+
+  const lines = [];
+  let approxTokens = 0;
+  let truncated = false;
+
+  for (const l of lessons) {
+    let line;
+    if (format === 'compact') {
+      const sig = l.signal === 'positive' || l.signal === 'up' ? 'DO' : 'AVOID';
+      line = `[${sig}] ${l.lesson || l.inferredLesson || ''}`;
+    } else {
+      line = JSON.stringify({ signal: l.signal, lesson: l.lesson || l.inferredLesson, confidence: l.confidence, tags: l.tags, createdAt: l.createdAt });
+    }
+
+    const lineTokens = Math.ceil(line.length / 4); // rough token estimate
+    if (approxTokens + lineTokens > maxTokenBudget) {
+      truncated = true;
+      break;
+    }
+
+    lines.push(line);
+    approxTokens += lineTokens;
+  }
+
+  return {
+    lessons: lines.join('\n'),
+    count: lines.length,
+    totalAvailable: lessons.length,
+    truncated,
+    approxTokens,
+  };
+}
+
 // ---------------------------------------------------------------------------
 // 3. Statusbar Data Provider
 // ---------------------------------------------------------------------------
@@ -205,19 +299,21 @@ function getLessonStats() {
  * Returns the most recent lesson with link, formatted for display.
  */
 function getStatusbarLessonData() {
-  const recent = getRecentLesson();
+  const recent = selectStatusbarLesson();
   if (!recent) return { hasLesson: false, text: null, link: null };
 
-  const emoji = (recent.signal === 'negative' || recent.signal === 'down') ? '👎' : '👍';
-  const truncated = recent.lesson.length > 60 ? recent.lesson.slice(0, 57) + '...' : recent.lesson;
+  const normalizedLesson = stripLessonPrefix(recent.lesson || '');
+  const truncated = normalizedLesson.length > 48 ? normalizedLesson.slice(0, 45) + '...' : normalizedLesson;
 
   return {
     hasLesson: true,
-    text: `${emoji} ${truncated}`,
+    text: truncated,
     link: recent.link,
     lessonId: recent.id,
     confidence: recent.confidence,
     createdAt: recent.createdAt,
+    label: buildStatusbarLessonLabel(recent),
+    kind: getLessonKind(recent),
   };
 }
 
@@ -306,10 +402,92 @@ function consumePhrase(lower, original, phrases) {
   return null;
 }
 
+// ---------------------------------------------------------------------------
+// 6. LLM-Powered Structured Lesson Extraction
+// ---------------------------------------------------------------------------
+
+const LLM_LESSON_SYSTEM_PROMPT = `You are a lesson extraction engine for an AI coding agent safety system called ThumbGate.
+
+Given a conversation window and a feedback signal (positive or negative), extract a structured lesson.
+
+Return ONLY valid JSON matching this exact schema:
+{
+  "trigger": { "condition": "<when this lesson applies>", "type": "<one of: debugging, implementation, question, error-report, constraint>" },
+  "action": { "type": "<do or avoid>", "description": "<specific action to take or avoid>" },
+  "confidence": <0.0 to 1.0>,
+  "scope": "<global, file-level, or project-level>",
+  "tags": ["<relevant tags>"]
+}
+
+Guidelines:
+- Be specific and actionable. "Avoid: editing files without reading them first" is better than "Avoid: bad edits".
+- confidence should reflect how clear the lesson is from the conversation context.
+- tags should include tool names, file types, or domain areas mentioned.
+- Do NOT include any text outside the JSON object.`;
+
+async function inferStructuredLessonLLM(conversationWindow, signal, context) {
+  const { isAvailable, callClaude, MODELS } = require('./llm-client');
+  if (!isAvailable()) return null;
+
+  const normalizedWindow = Array.isArray(conversationWindow) ? conversationWindow : [];
+  if (normalizedWindow.length === 0 && !context) return null;
+
+  const windowText = normalizedWindow
+    .slice(-10)
+    .map((m) => `[${m.role}]: ${(m.content || '').slice(0, 400)}`)
+    .join('\n')
+    .slice(0, 4000);
+
+  const userPrompt = [
+    `Signal: ${signal === 'positive' || signal === 'up' ? 'positive (thumbs up — something worked well)' : 'negative (thumbs down — something went wrong)'}`,
+    context ? `User context: ${context}` : '',
+    `\nConversation:\n${windowText}`,
+  ].filter(Boolean).join('\n');
+
+  const raw = await callClaude({
+    systemPrompt: LLM_LESSON_SYSTEM_PROMPT,
+    userPrompt,
+    model: MODELS.FAST,
+    maxTokens: 512,
+  });
+
+  if (!raw) return null;
+
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed.trigger || !parsed.action) return null;
+
+    const filePaths = extractFilePaths(normalizedWindow);
+    const toolCalls = extractToolCalls(normalizedWindow);
+    const errorPatterns = extractErrors(normalizedWindow);
+    const userMessages = normalizedWindow.filter((m) => m.role === 'user');
+    const assistantMessages = normalizedWindow.filter((m) => m.role === 'assistant');
+    const lastUser = userMessages[userMessages.length - 1]?.content || '';
+    const lastAssistant = assistantMessages[assistantMessages.length - 1]?.content || '';
+
+    return {
+      format: 'if-then-v1-llm',
+      trigger: parsed.trigger,
+      action: parsed.action,
+      signal: signal === 'positive' || signal === 'up' ? 'positive' : 'negative',
+      confidence: Math.max(0, Math.min(1, Number(parsed.confidence) || 0.5)),
+      scope: parsed.scope || inferScope(filePaths, toolCalls),
+      examples: [{ userIntent: lastUser.slice(0, 300), assistantAction: lastAssistant.slice(0, 300), outcome: signal === 'positive' || signal === 'up' ? 'approved' : 'rejected' }],
+      metadata: { toolsUsed: toolCalls, filesInvolved: filePaths.slice(0, 10), errorPatterns: errorPatterns.slice(0, 5), conversationLength: normalizedWindow.length, inferredAt: new Date().toISOString(), llmModel: MODELS.FAST },
+      tags: Array.isArray(parsed.tags) ? parsed.tags : [],
+    };
+  } catch {
+    return null;
+  }
+}
+
 module.exports = {
   inferFromSurroundingMessages, createLesson, getRecentLesson,
-  searchLessons, getLessonStats, getStatusbarLessonData,
+  searchLessons, getLessonStats, getStatusbarLessonData, getAllLessonsForContext,
   getLessonsPath, getRecentLessonPath,
-  inferStructuredLesson, extractTrigger, extractAction, extractToolCalls,
+  selectStatusbarLesson, getLessonKind, stripLessonPrefix,
+  formatLessonTimestamp, buildStatusbarLessonLabel,
+  inferStructuredLesson, inferStructuredLessonLLM,
+  extractTrigger, extractAction, extractToolCalls,
   extractFilePaths, extractErrors, calculateConfidence, inferScope,
 };

package/scripts/lesson-retrieval.js

@@ -3,11 +3,10 @@
 
 /**
  * Per-action lesson retrieval.
- * Given a tool name + context, returns the top-K most relevant lessons
- * using keyword matching + recency decay + signal weighting.
+ * v2: backward retrieval + bigram Jaccard fuzzy matching
  */
 
-const RECENCY_DECAY_DAYS = 30; // lessons older than this get down-weighted
+const RECENCY_DECAY_DAYS = 30;
 
 function retrieveRelevantLessons(toolName, actionContext, options = {}) {
   const { maxResults = 5, feedbackDir } = options;
@@ -20,13 +19,13 @@ function retrieveRelevantLessons(toolName, actionContext, options = {}) {
   const memories = readJSONL(paths.MEMORY_LOG_PATH, { maxLines: 200 });
   if (memories.length === 0) return [];
 
-  // Score each memory against the current action
+  const actionSig = buildActionSignature(toolName, actionContext);
+
   const scored = memories.map((mem) => ({
     ...mem,
-    relevanceScore: scoreRelevance(mem, toolName, actionContext),
+    relevanceScore: scoreRelevance(mem, toolName, actionContext, actionSig),
   }));
 
-  // Sort by relevance, return top-K
   return scored
     .filter((m) => m.relevanceScore > 0.1)
     .sort((a, b) => b.relevanceScore - a.relevanceScore)
@@ -42,43 +41,74 @@ function retrieveRelevantLessons(toolName, actionContext, options = {}) {
     }));
 }
 
-function scoreRelevance(memory, toolName, actionContext) {
+function buildActionSignature(toolName, actionContext) {
+  const toolLower = (toolName || '').toLowerCase();
+  const contextLower = (actionContext || '').toLowerCase();
+  const sigPaths = extractPaths(actionContext);
+  const tokens = tokenize(contextLower);
+  const ngramSet = textBigrams(contextLower);
+  return { toolLower, contextLower, paths: sigPaths, tokens, ngramSet };
+}
+
+function textBigrams(text) {
+  const normalized = (text || '')
+    .toLowerCase()
+    .replace(/[^a-z0-9\s]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+  const set = new Set();
+  for (let i = 0; i < normalized.length - 1; i++) {
+    set.add(normalized.slice(i, i + 2));
+  }
+  return set;
+}
+
+function bigramJaccard(setA, setB) {
+  if (setA.size === 0 && setB.size === 0) return 1;
+  if (setA.size === 0 || setB.size === 0) return 0;
+  let intersection = 0;
+  for (const item of setA) {
+    if (setB.has(item)) intersection++;
+  }
+  const union = setA.size + setB.size - intersection;
+  return union === 0 ? 0 : intersection / union;
+}
+
+function scoreRelevance(memory, toolName, actionContext, actionSig) {
+  const sig = actionSig || buildActionSignature(toolName, actionContext);
   let score = 0;
 
-  const memText = `${memory.title || ''} ${memory.content || ''} ${(memory.tags || []).join(' ')}`.toLowerCase();
-  const contextLower = (actionContext || '').toLowerCase();
-  const toolLower = (toolName || '').toLowerCase();
+  const memText = ((memory.title || '') + ' ' + (memory.content || '') + ' ' + (memory.tags || []).join(' ')).toLowerCase();
 
-  // 1. Tool name match (high weight)
-  if (memory.metadata?.toolsUsed?.some((t) => t.toLowerCase() === toolLower)) score += 0.4;
-  if (memText.includes(toolLower)) score += 0.2;
+  if (memory.metadata?.toolsUsed?.some((t) => t.toLowerCase() === sig.toolLower)) score += 0.4;
+  if (memText.includes(sig.toolLower)) score += 0.2;
 
-  // 2. File path overlap
-  const contextPaths = extractPaths(actionContext);
   const memPaths = memory.metadata?.filesInvolved || extractPaths(memText);
-  const pathOverlap = contextPaths.filter((p) =>
+  const pathOverlap = sig.paths.filter((p) =>
     memPaths.some((mp) => mp.includes(p) || p.includes(mp)),
   );
   if (pathOverlap.length > 0) score += 0.3;
 
-  // 3. Keyword overlap (TF-IDF-lite)
-  const contextTokens = tokenize(contextLower);
   const memTokens = tokenize(memText);
-  const overlap = contextTokens.filter((t) => memTokens.includes(t));
+  const overlap = sig.tokens.filter((t) => memTokens.includes(t));
   score += Math.min(overlap.length * 0.05, 0.3);
 
-  // 4. Signal weighting — negative lessons are more important to surface
+  // Fuzzy n-gram matching (only when there is already signal)
+  if (score > 0) {
+    const memBigrams = textBigrams(memText);
+    const fuzzyScore = bigramJaccard(sig.ngramSet, memBigrams);
+    score += fuzzyScore * 0.2;
+  }
+
   if (memory.tags?.includes('negative')) score += 0.1;
 
-  // 5. Recency decay
   if (memory.timestamp) {
     const ageMs = Date.now() - new Date(memory.timestamp).getTime();
     const ageDays = ageMs / (1000 * 60 * 60 * 24);
     const decay = Math.max(0, 1 - ageDays / RECENCY_DECAY_DAYS);
-    score *= 0.5 + 0.5 * decay; // 50% base + 50% recency
+    score *= 0.5 + 0.5 * decay;
   }
 
-  // 6. Structured rule bonus — IF/THEN rules are more actionable
   if (memory.structuredRule) score += 0.15;
 
   return score;
@@ -92,4 +122,10 @@ function tokenize(text) {
   return (text || '').split(/[\s.,;:!?()\[\]{}"'`]+/).filter((t) => t.length > 3);
 }
 
-module.exports = { retrieveRelevantLessons, scoreRelevance };
+module.exports = {
+  retrieveRelevantLessons,
+  scoreRelevance,
+  buildActionSignature,
+  textBigrams,
+  bigramJaccard,
+};

package/scripts/llm-client.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+'use strict';
+
+const MODELS = {
+  FAST: 'claude-haiku-4-5-20251001',
+  SMART: 'claude-sonnet-4-6',
+};
+
+const DEFAULT_MODEL = MODELS.FAST;
+const DEFAULT_MAX_TOKENS = 1024;
+
+let _client = null;
+
+function isAvailable() {
+  return Boolean(process.env.ANTHROPIC_API_KEY);
+}
+
+function getClient() {
+  if (_client) return _client;
+  if (!isAvailable()) return null;
+  try {
+    const Anthropic = require('@anthropic-ai/sdk');
+    _client = new Anthropic();
+    return _client;
+  } catch {
+    return null;
+  }
+}
+
+function stripCodeFences(text) {
+  if (!text) return text;
+  const fenced = text.match(/^```(?:json)?\s*\n?([\s\S]*?)```\s*$/);
+  return fenced ? fenced[1].trim() : text.trim();
+}
+
+async function callClaude({ systemPrompt, userPrompt, model, maxTokens } = {}) {
+  const client = getClient();
+  if (!client) return null;
+
+  try {
+    const response = await client.messages.create({
+      model: model || DEFAULT_MODEL,
+      max_tokens: maxTokens || DEFAULT_MAX_TOKENS,
+      system: systemPrompt || undefined,
+      messages: [{ role: 'user', content: userPrompt }],
+    });
+
+    const text = response.content
+      .filter((b) => b.type === 'text')
+      .map((b) => b.text)
+      .join('');
+
+    return stripCodeFences(text);
+  } catch {
+    return null;
+  }
+}
+
+module.exports = { isAvailable, callClaude, stripCodeFences, MODELS };

package/scripts/managed-lesson-agent.js

@@ -0,0 +1,183 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { resolveFeedbackDir } = require('./feedback-paths');
+const { parseFeedbackFile, classifySignal, analyzeWithLLM, analyze, promoteToGates } = require('./feedback-to-rules');
+const { inferStructuredLessonLLM, inferStructuredLesson, createLesson } = require('./lesson-inference');
+const { isAvailable } = require('./llm-client');
+
+const MAX_ENTRIES_PER_RUN = 20;
+const DELAY_BETWEEN_CALLS_MS = 500;
+const MANIFEST_DIR = path.join(os.homedir(), '.thumbgate');
+const MANIFEST_PATH = path.join(MANIFEST_DIR, 'managed-agent-runs.jsonl');
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function getProcessedIds() {
+  if (!fs.existsSync(MANIFEST_PATH)) return new Set();
+  const ids = new Set();
+  for (const line of fs.readFileSync(MANIFEST_PATH, 'utf8').split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const run = JSON.parse(trimmed);
+      if (Array.isArray(run.processedIds)) {
+        for (const id of run.processedIds) ids.add(id);
+      }
+    } catch { /* skip */ }
+  }
+  return ids;
+}
+
+function writeManifest(manifest) {
+  fs.mkdirSync(MANIFEST_DIR, { recursive: true });
+  fs.appendFileSync(MANIFEST_PATH, JSON.stringify(manifest) + '\n');
+}
+
+function getManagedAgentStatus() {
+  if (!fs.existsSync(MANIFEST_PATH)) return null;
+  const lines = fs.readFileSync(MANIFEST_PATH, 'utf8').split('\n').filter(Boolean);
+  if (lines.length === 0) return null;
+  try {
+    const last = JSON.parse(lines[lines.length - 1]);
+    return {
+      lastRun: last.runAt,
+      entriesProcessed: last.entriesProcessed,
+      lessonsCreated: last.lessonsCreated,
+      gatesPromoted: last.gatesPromoted,
+      model: last.model,
+      durationMs: last.durationMs,
+      totalRuns: lines.length,
+    };
+  } catch {
+    return null;
+  }
+}
+
+async function runManagedAgent({ dryRun = false, limit, model } = {}) {
+  const startTime = Date.now();
+  const feedbackDir = resolveFeedbackDir();
+  const logPath = path.join(feedbackDir, 'feedback-log.jsonl');
+  const entries = parseFeedbackFile(logPath);
+
+  if (entries.length === 0) {
+    return { entriesProcessed: 0, lessonsCreated: 0, gatesPromoted: 0, model: 'none', durationMs: 0, message: 'No feedback entries found' };
+  }
+
+  const processedIds = getProcessedIds();
+  const pending = entries
+    .filter((e) => {
+      const id = e.id || e.feedbackId || e.timestamp;
+      return id && !processedIds.has(id);
+    })
+    .slice(0, limit || MAX_ENTRIES_PER_RUN);
+
+  if (pending.length === 0) {
+    return { entriesProcessed: 0, lessonsCreated: 0, gatesPromoted: 0, model: 'none', durationMs: Date.now() - startTime, message: 'All entries already processed' };
+  }
+
+  const useLLM = isAvailable();
+  const modelUsed = useLLM ? 'claude-haiku-4-5' : 'heuristic';
+  let lessonsCreated = 0;
+  const newProcessedIds = [];
+
+  for (const entry of pending) {
+    const id = entry.id || entry.feedbackId || entry.timestamp;
+    const signal = classifySignal(entry);
+    if (!signal) {
+      newProcessedIds.push(id);
+      continue;
+    }
+
+    const window = Array.isArray(entry.conversationWindow) ? entry.conversationWindow : [];
+    const context = entry.context || '';
+
+    let structuredLesson = null;
+    if (useLLM) {
+      structuredLesson = await inferStructuredLessonLLM(window, signal, context);
+      if (structuredLesson && !dryRun) {
+        await sleep(DELAY_BETWEEN_CALLS_MS);
+      }
+    }
+
+    if (!structuredLesson) {
+      structuredLesson = inferStructuredLesson(window, signal, context);
+    }
+
+    if (!dryRun && structuredLesson) {
+      try {
+        createLesson({
+          feedbackId: id,
+          signal,
+          inferredLesson: structuredLesson.action?.description || '',
+          triggerMessage: structuredLesson.examples?.[0]?.assistantAction || '',
+          priorSummary: '',
+          confidence: structuredLesson.confidence || 0.5,
+          tags: structuredLesson.tags || entry.tags || [],
+          metadata: { ...structuredLesson.metadata, managedAgent: true, format: structuredLesson.format },
+        });
+        lessonsCreated++;
+      } catch { /* lesson creation is best-effort */ }
+    } else if (dryRun && structuredLesson) {
+      lessonsCreated++;
+    }
+
+    newProcessedIds.push(id);
+  }
+
+  // Rule generation pass
+  let gatesPromoted = 0;
+  if (useLLM) {
+    const llmIssues = await analyzeWithLLM(entries);
+    if (llmIssues && llmIssues.length > 0) {
+      if (!dryRun) {
+        promoteToGates(llmIssues);
+      }
+      gatesPromoted = llmIssues.filter((i) => i.severity === 'critical').length;
+    }
+  } else {
+    const report = analyze(entries);
+    gatesPromoted = report.recurringIssues.filter((i) => i.severity === 'critical').length;
+  }
+
+  const manifest = {
+    runAt: new Date().toISOString(),
+    entriesProcessed: pending.length,
+    lessonsCreated,
+    gatesPromoted,
+    model: modelUsed,
+    dryRun,
+    durationMs: Date.now() - startTime,
+    processedIds: newProcessedIds,
+  };
+
+  if (!dryRun) {
+    writeManifest(manifest);
+  }
+
+  return manifest;
+}
+
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  const dryRun = args.includes('--dry-run');
+  const limitFlag = args.find((a) => a.startsWith('--limit'));
+  const limit = limitFlag ? Number(args[args.indexOf(limitFlag) + 1]) || MAX_ENTRIES_PER_RUN : undefined;
+
+  runManagedAgent({ dryRun, limit })
+    .then((result) => {
+      console.log(JSON.stringify(result, null, 2));
+      process.exit(0);
+    })
+    .catch((err) => {
+      console.error('Managed agent error:', err.message);
+      process.exit(1);
+    });
+}
+
+module.exports = { runManagedAgent, getManagedAgentStatus };