rlhf-feedback-loop 0.6.10 → 0.6.12

package/bin/cli.js

@@ -39,23 +39,146 @@ function pkgVersion() {
 // --- Platform auto-detection helpers ---
 
 const HOME = process.env.HOME || process.env.USERPROFILE || '';
-const MCP_SERVER_ENTRY = {
-  command: 'node',
-  args: [path.relative(CWD, path.join(PKG_ROOT, 'adapters', 'mcp', 'server-stdio.js'))],
-};
+const MCP_SERVER_NAME = 'rlhf';
+const LEGACY_MCP_SERVER_NAMES = ['rlhf', 'rlhf-feedback-loop', 'rlhf_feedback_loop'];
+const PORTABLE_MCP_COMMAND = 'npx';
+const LOCAL_MCP_COMMAND = 'node';
+
+function portableMcpArgs() {
+  return ['-y', `rlhf-feedback-loop@${pkgVersion()}`, 'serve'];
+}
+
+function localServerEntryPath() {
+  return path.join(PKG_ROOT, 'adapters', 'mcp', 'server-stdio.js');
+}
+
+function shouldUseLocalServerEntry() {
+  return fs.existsSync(path.join(PKG_ROOT, '.git'));
+}
+
+function portableMcpEntry() {
+  return {
+    command: PORTABLE_MCP_COMMAND,
+    args: portableMcpArgs(),
+  };
+}
+
+function localMcpEntry() {
+  return {
+    command: LOCAL_MCP_COMMAND,
+    args: [localServerEntryPath()],
+  };
+}
+
+function mcpEntriesMatch(entry, expectedEntry) {
+  return Boolean(
+    entry &&
+    expectedEntry &&
+    entry.command === expectedEntry.command &&
+    Array.isArray(entry.args) &&
+    Array.isArray(expectedEntry.args) &&
+    entry.args.length === expectedEntry.args.length &&
+    entry.args.every((arg, index) => arg === expectedEntry.args[index])
+  );
+}
+
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function formatTomlStringArray(values) {
+  return `[${values.map((value) => JSON.stringify(value)).join(', ')}]`;
+}
+
+function canonicalMcpEntry() {
+  return shouldUseLocalServerEntry() ? localMcpEntry() : portableMcpEntry();
+}
+
+function mcpSectionBlock(name = MCP_SERVER_NAME) {
+  const entry = canonicalMcpEntry();
+  return `[mcp_servers.${name}]\ncommand = "${entry.command}"\nargs = ${formatTomlStringArray(entry.args)}\n`;
+}
+
+function upsertCodexServerConfig(content) {
+  const canonicalBlock = mcpSectionBlock();
+  const sections = LEGACY_MCP_SERVER_NAMES.map((name) => ({
+    name,
+    regex: new RegExp(`^\\[mcp_servers\\.${escapeRegExp(name)}\\]\\n[\\s\\S]*?(?=^\\[|$)`, 'm'),
+  }));
+  const matches = sections
+    .map((section) => ({ ...section, match: content.match(section.regex) }))
+    .filter((section) => section.match);
+
+  if (matches.length === 0) {
+    const prefix = content.trimEnd();
+    return {
+      changed: true,
+      content: `${prefix}${prefix ? '\n\n' : ''}${canonicalBlock}`,
+    };
+  }
+
+  let nextContent = content;
+  let changed = false;
+  let canonicalPresent = false;
+
+  for (const section of matches) {
+    const normalized = canonicalBlock;
+    const current = section.match[0];
+
+    if (section.name === MCP_SERVER_NAME) {
+      canonicalPresent = true;
+      if (current !== normalized) {
+        nextContent = nextContent.replace(section.regex, normalized);
+        changed = true;
+      }
+      continue;
+    }
+
+    nextContent = nextContent.replace(section.regex, '');
+    changed = true;
+  }
+
+  if (!canonicalPresent) {
+    const prefix = nextContent.trimEnd();
+    nextContent = `${prefix}${prefix ? '\n\n' : ''}${canonicalBlock}`;
+    changed = true;
+  }
+
+  return {
+    changed,
+    content: nextContent.endsWith('\n') ? nextContent : `${nextContent}\n`,
+  };
+}
 
 function mergeMcpJson(filePath, label) {
+  const canonicalEntry = canonicalMcpEntry();
   if (!fs.existsSync(filePath)) {
     const dir = path.dirname(filePath);
     if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(filePath, JSON.stringify({ mcpServers: { 'rlhf-feedback-loop': MCP_SERVER_ENTRY } }, null, 2) + '\n');
+    fs.writeFileSync(filePath, JSON.stringify({ mcpServers: { [MCP_SERVER_NAME]: canonicalEntry } }, null, 2) + '\n');
     console.log(`  ${label}: wrote ${path.relative(CWD, filePath)}`);
     return true;
   }
   const existing = JSON.parse(fs.readFileSync(filePath, 'utf8'));
-  if (existing.mcpServers && existing.mcpServers['rlhf-feedback-loop']) return false;
   existing.mcpServers = existing.mcpServers || {};
-  existing.mcpServers['rlhf-feedback-loop'] = MCP_SERVER_ENTRY;
+
+  let changed = false;
+  const currentEntry = existing.mcpServers[MCP_SERVER_NAME];
+  if (!mcpEntriesMatch(currentEntry, canonicalEntry)) {
+    existing.mcpServers[MCP_SERVER_NAME] = canonicalEntry;
+    changed = true;
+  }
+
+  for (const legacyName of LEGACY_MCP_SERVER_NAMES) {
+    if (legacyName === MCP_SERVER_NAME) continue;
+    if (Object.prototype.hasOwnProperty.call(existing.mcpServers, legacyName)) {
+      delete existing.mcpServers[legacyName];
+      changed = true;
+    }
+  }
+
+  if (!changed) return false;
+
   fs.writeFileSync(filePath, JSON.stringify(existing, null, 2) + '\n');
   console.log(`  ${label}: updated ${path.relative(CWD, filePath)}`);
   return true;
@@ -73,12 +196,37 @@ function whichExists(cmd) {
 }
 
 function setupClaude() {
-  return mergeMcpJson(path.join(CWD, '.mcp.json'), 'Claude Code');
+  const mcpChanged = mergeMcpJson(path.join(CWD, '.mcp.json'), 'Claude Code');
+
+  // Upsert Stop hook into .claude/settings.json for autonomous self-scoring
+  const settingsPath = path.join(CWD, '.claude', 'settings.json');
+  const stopHookCommand = 'bash scripts/hook-stop-self-score.sh';
+
+  let settings = { hooks: {} };
+  if (fs.existsSync(settingsPath)) {
+    try { settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8')); } catch (_) { /* fresh */ }
+  }
+  settings.hooks = settings.hooks || {};
+
+  const stopAlreadyPresent = (settings.hooks.Stop || [])
+    .some(entry => (entry.hooks || []).some(h => h.command === stopHookCommand));
+
+  let hooksChanged = false;
+  if (!stopAlreadyPresent) {
+    settings.hooks.Stop = settings.hooks.Stop || [];
+    settings.hooks.Stop.push({ hooks: [{ type: 'command', command: stopHookCommand }] });
+    fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+    console.log('  Claude Code: installed Stop hook in .claude/settings.json');
+    hooksChanged = true;
+  }
+
+  return mcpChanged || hooksChanged;
 }
 
 function setupCodex() {
   const configPath = path.join(HOME, '.codex', 'config.toml');
-  const block = `\n[mcp_servers.rlhf_feedback_loop]\ncommand = "node"\nargs = ["${MCP_SERVER_ENTRY.args[0]}"]\n`;
+  const block = mcpSectionBlock();
   if (!fs.existsSync(configPath)) {
     fs.mkdirSync(path.dirname(configPath), { recursive: true });
     fs.writeFileSync(configPath, block);
@@ -86,8 +234,9 @@ function setupCodex() {
     return true;
   }
   const content = fs.readFileSync(configPath, 'utf8');
-  if (content.includes('[mcp_servers.rlhf_feedback_loop]')) return false;
-  fs.appendFileSync(configPath, block);
+  const updated = upsertCodexServerConfig(content);
+  if (!updated.changed) return false;
+  fs.writeFileSync(configPath, updated.content);
   console.log('  Codex: appended MCP server to ~/.codex/config.toml');
   return true;
 }
@@ -96,9 +245,24 @@ function setupGemini() {
   const settingsPath = path.join(HOME, '.gemini', 'settings.json');
   if (fs.existsSync(settingsPath)) {
     const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
-    if (settings.mcpServers && settings.mcpServers['rlhf-feedback-loop']) return false;
     settings.mcpServers = settings.mcpServers || {};
-    settings.mcpServers['rlhf-feedback-loop'] = MCP_SERVER_ENTRY;
+    let changed = false;
+    const canonicalEntry = canonicalMcpEntry();
+
+    if (!mcpEntriesMatch(settings.mcpServers[MCP_SERVER_NAME], canonicalEntry)) {
+      settings.mcpServers[MCP_SERVER_NAME] = canonicalEntry;
+      changed = true;
+    }
+
+    for (const legacyName of LEGACY_MCP_SERVER_NAMES) {
+      if (legacyName === MCP_SERVER_NAME) continue;
+      if (Object.prototype.hasOwnProperty.call(settings.mcpServers, legacyName)) {
+        delete settings.mcpServers[legacyName];
+        changed = true;
+      }
+    }
+
+    if (!changed) return false;
     fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
     console.log('  Gemini: updated ~/.gemini/settings.json');
     return true;
@@ -320,6 +484,65 @@ function summary() {
   console.log(feedbackSummary(Number(args.recent || 20)));
 }
 
+function modelFit() {
+  const { writeModelFitReport } = require(path.join(PKG_ROOT, 'scripts', 'local-model-profile'));
+  const { reportPath, report } = writeModelFitReport();
+  console.log(JSON.stringify({ reportPath, report }, null, 2));
+}
+
+function risk() {
+  const args = parseArgs(process.argv.slice(3));
+  const riskScorer = require(path.join(PKG_ROOT, 'scripts', 'risk-scorer'));
+
+  if (args.context || args.tags || args.skill || args.domain || args['rubric-scores'] || args.guardrails) {
+    const { inferDomain } = require(path.join(PKG_ROOT, 'scripts', 'feedback-loop'));
+    const { buildRubricEvaluation } = require(path.join(PKG_ROOT, 'scripts', 'rubric-engine'));
+    const historyRows = riskScorer.readJSONL(riskScorer.sequencePathFor());
+    const tags = String(args.tags || '')
+      .split(',')
+      .map((tag) => tag.trim())
+      .filter(Boolean);
+
+    let rubric = null;
+    if (args['rubric-scores'] || args.guardrails) {
+      const evaluation = buildRubricEvaluation({
+        rubricScores: args['rubric-scores'],
+        guardrails: args.guardrails,
+      });
+      rubric = {
+        rubricId: evaluation.rubricId,
+        weightedScore: evaluation.weightedScore,
+        failingCriteria: evaluation.failingCriteria,
+        failingGuardrails: evaluation.failingGuardrails,
+        judgeDisagreements: evaluation.judgeDisagreements,
+      };
+    }
+
+    const candidate = riskScorer.buildRiskCandidate({
+      context: args.context || '',
+      tags,
+      skill: args.skill || null,
+      domain: args.domain || inferDomain(tags, args.context || ''),
+      rubric,
+      filePathCount: Number(args['file-count'] || 0),
+      errorType: args['error-type'] || null,
+    }, historyRows);
+    const model = riskScorer.loadRiskModel() || riskScorer.trainAndPersistRiskModel().model;
+    console.log(JSON.stringify({
+      prediction: riskScorer.predictRisk(model, candidate),
+      candidate,
+    }, null, 2));
+    return;
+  }
+
+  const { model, modelPath } = riskScorer.trainAndPersistRiskModel();
+  console.log(JSON.stringify({
+    modelPath,
+    metrics: model.metrics,
+    summary: riskScorer.getRiskSummary(),
+  }, null, 2));
+}
+
 function exportDpo() {
   const extraArgs = process.argv.slice(3).join(' ');
   try {
@@ -359,7 +582,7 @@ function prove() {
   const script = path.join(PKG_ROOT, 'scripts', `prove-${target}.js`);
   if (!fs.existsSync(script)) {
     console.error(`Unknown proof target: ${target}`);
-    console.error('Available: adapters, automation, attribution, lancedb, data-quality, intelligence, loop-closure, training-export');
+    console.error('Available: adapters, automation, attribution, lancedb, data-quality, intelligence, local-intelligence, loop-closure, training-export');
     process.exit(1);
   }
   try {
@@ -369,21 +592,39 @@ function prove() {
   }
 }
 
-function serve() {
-  const rlhfDir = path.join(CWD, '.rlhf');
-  if (!fs.existsSync(rlhfDir) && !fs.existsSync(path.join(CWD, '.claude', 'memory', 'feedback'))) {
-    // If not initialized, ensure global fallback exists
-    const projectName = path.basename(CWD) || 'default';
-    const globalDir = path.join(HOME, '.rlhf', 'projects', projectName);
-    if (!fs.existsSync(globalDir)) {
-      fs.mkdirSync(globalDir, { recursive: true });
-    }
+function watchCmd() {
+  const args = parseArgs(process.argv.slice(3));
+  const { watch, once } = require(path.join(PKG_ROOT, 'scripts', 'jsonl-watcher'));
+  const sourceFilter = args.source || undefined;
+  if (args.once) {
+    once(sourceFilter);
+  } else {
+    watch(sourceFilter);
   }
+}
 
+function status() {
+  const statusDashboard = require(path.join(PKG_ROOT, 'scripts', 'status-dashboard'));
+  const { getFeedbackPaths } = require(path.join(PKG_ROOT, 'scripts', 'feedback-loop'));
+  const { FEEDBACK_DIR } = getFeedbackPaths();
+  const data = statusDashboard.generateStatus(FEEDBACK_DIR);
+  // printDashboard writes directly to stdout when run as main;
+  // for CLI we call the same renderer
+  statusDashboard.printDashboard
+    ? statusDashboard.printDashboard(data)
+    : console.log(JSON.stringify(data, null, 2));
+}
+
+function serve() {
   // Start MCP server over stdio
   const mcpServer = path.join(PKG_ROOT, 'adapters', 'mcp', 'server-stdio.js');
   const { startStdioServer } = require(mcpServer);
   startStdioServer();
+  // Start watcher as a background daemon alongside MCP server
+  try {
+    const { watch } = require(path.join(PKG_ROOT, 'scripts', 'jsonl-watcher'));
+    watch();
+  } catch (_) { /* watcher is non-critical */ }
 }
 
 function install() {
@@ -392,7 +633,8 @@ function install() {
     setupClaude(),
     setupCodex(),
     setupGemini(),
-    setupCursor()
+    setupCursor(),
+    setupAmp()
   ];
   const success = results.some(r => r === true);
   if (success) {
@@ -403,6 +645,12 @@ function install() {
   }
 }
 
+function installMcp() {
+  const { installMcp: doInstall, parseFlags } = require(path.join(PKG_ROOT, 'scripts', 'install-mcp'));
+  const flags = parseFlags(process.argv.slice(3));
+  doInstall(flags);
+}
+
 function startApi() {
   const serverPath = path.join(PKG_ROOT, 'src', 'api', 'server.js');
   try {
@@ -418,21 +666,28 @@ function help() {
   console.log('');
   console.log('Commands:');
   console.log('  init                  Scaffold .rlhf/ config + MCP server in current project');
+  console.log('  install-mcp           Install RLHF MCP server into Claude Code settings (--project for local)');
   console.log('  serve                 Start MCP server (stdio) — for claude/codex/gemini mcp add');
   console.log('  capture [flags]       Capture feedback (--feedback=up|down --context="..." --tags="...")');
   console.log('  stats                 Show feedback analytics + Revenue-at-Risk');
   console.log('  summary               Human-readable feedback summary');
+  console.log('  model-fit             Detect the current local embedding profile and write evidence report');
+  console.log('  risk [flags]          Train or query the boosted local risk scorer');
   console.log('  export-dpo            Export DPO training pairs (prompt/chosen/rejected JSONL)');
   console.log('  rules                 Generate prevention rules from repeated failures');
   console.log('  self-heal             Run self-healing check and auto-fix');
   console.log('  pro                   Upgrade to Cloud Pro ($10/mo)');
-  console.log('  prove [--target=X]    Run proof harness (adapters|automation|attribution|lancedb|...)');
+  console.log('  prove [--target=X]    Run proof harness (adapters|automation|attribution|lancedb|local-intelligence|...)');
+  console.log('  watch [flags]           Watch .rlhf/ for external signals and ingest through pipeline (--once, --source=X)');
+  console.log('  status                  Show learning curve dashboard — approval trend + failure domains');
   console.log('  start-api             Start the RLHF HTTPS API server');
   console.log('  help                  Show this help message');
   console.log('');
   console.log('Examples:');
   console.log('  npx rlhf-feedback-loop init');
   console.log('  npx rlhf-feedback-loop stats');
+  console.log('  npx rlhf-feedback-loop model-fit');
+  console.log('  npx rlhf-feedback-loop risk');
   console.log('  npx rlhf-feedback-loop pro');
 }
 
@@ -443,6 +698,9 @@ switch (COMMAND) {
   case 'install':
     install();
     break;
+  case 'install-mcp':
+    installMcp();
+    break;
   case 'serve':
   case 'mcp':
     serve();
@@ -457,6 +715,12 @@ switch (COMMAND) {
   case 'summary':
     summary();
     break;
+  case 'model-fit':
+    modelFit();
+    break;
+  case 'risk':
+    risk();
+    break;
   case 'export-dpo':
   case 'dpo':
     exportDpo();
@@ -473,6 +737,12 @@ switch (COMMAND) {
   case 'prove':
     prove();
     break;
+  case 'watch':
+    watchCmd();
+    break;
+  case 'status':
+    status();
+    break;
   case 'start-api':
     startApi();
     break;

package/openapi/openapi.yaml

@@ -5,6 +5,8 @@ info:
   description: |
     Production API for feedback capture, schema-validated memory promotion,
     prevention rule generation, and DPO export.
+    Bare up/down signals are logged immediately, but the API returns
+    clarification_required until one sentence explains what worked or failed.
 servers:
   - url: https://rlhf-feedback-loop-710216278770.us-central1.run.app
 security:
@@ -32,13 +34,14 @@ components:
           type: string
     CaptureFeedbackRequest:
       type: object
-      required: [signal, context]
+      required: [signal]
       properties:
         signal:
           type: string
           enum: [up, down, positive, negative]
         context:
           type: string
+          description: One-sentence reason describing what worked or failed
         whatWentWrong:
           type: string
         whatToChange:
@@ -155,7 +158,7 @@ paths:
         '200':
           description: Feedback accepted and promoted to memory
         '422':
-          description: Feedback recorded but rejected for memory promotion
+          description: Feedback logged only; clarification required or promotion rejected
         '401':
           description: Unauthorized
   /v1/feedback/stats:

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "rlhf-feedback-loop",
-  "version": "0.6.10",
-  "description": "RLHF-ready human feedback capture and DPO data pipeline for AI agents. Optimize agentic reliability with Feedback-Driven Development (FDD): capture preference signals, enforce guardrails, and export training pairs for downstream optimization.",
-  "homepage": "https://github.com/IgorGanapolsky/rlhf-feedback-loop#readme",
+  "version": "0.6.12",
+  "description": "Feedback-Driven Development (FDD) for AI agents — capture preference signals, steer behavior via Thompson Sampling, and export KTO/DPO training pairs for downstream fine-tuning.",
+  "homepage": "https://rlhf-feedback-loop-production.up.railway.app",
   "repository": {
     "type": "git",
     "url": "https://github.com/IgorGanapolsky/rlhf-feedback-loop.git"
@@ -28,38 +28,45 @@
   ],
   "type": "commonjs",
   "scripts": {
-    "test": "npm run test:schema && npm run test:loop && npm run test:dpo && npm run test:api && npm run test:proof && npm run test:e2e && npm run test:rlaif && npm run test:attribution && npm run test:quality && npm run test:intelligence && npm run test:training-export && npm run test:deployment && npm run test:billing && npm run test:cli",
+    "test": "npm run test:schema && npm run test:loop && npm run test:dpo && npm run test:kto && npm run test:api && npm run test:proof && npm run test:e2e && npm run test:rlaif && npm run test:attribution && npm run test:quality && npm run test:intelligence && npm run test:training-export && npm run test:deployment && npm run test:workflow && npm run test:billing && npm run test:cli && npm run test:watcher",
     "test:e2e": "node --test tests/e2e-pipeline.test.js",
     "test:schema": "node scripts/feedback-schema.js --test",
     "test:loop": "node scripts/feedback-loop.js --test",
     "test:dpo": "node scripts/export-dpo-pairs.js --test",
-    "test:api": "node --test tests/api-server.test.js tests/api-auth-config.test.js tests/mcp-server.test.js tests/adapters.test.js tests/openapi-parity.test.js tests/budget-guard.test.js tests/contextfs.test.js tests/mcp-policy.test.js tests/subagent-profiles.test.js tests/intent-router.test.js tests/rubric-engine.test.js tests/self-healing-check.test.js tests/self-heal.test.js tests/feedback-schema.test.js tests/thompson-sampling.test.js tests/feedback-sequences.test.js tests/diversity-tracking.test.js tests/vector-store.test.js tests/feedback-attribution.test.js tests/hybrid-feedback-context.test.js tests/loop-closure.test.js tests/code-reasoning.test.js tests/feedback-loop.test.js tests/feedback-inbox-read.test.js tests/feedback-to-memory.test.js",
-    "test:proof": "node --test --test-concurrency=1 tests/prove-adapters.test.js tests/prove-automation.test.js tests/prove-attribution.test.js tests/prove-lancedb.test.js tests/prove-data-quality.test.js tests/prove-intelligence.test.js tests/prove-loop-closure.test.js tests/prove-subway-upgrades.test.js tests/prove-training-export.test.js",
+    "test:kto": "node --test tests/export-kto.test.js",
+    "test:api": "node --test tests/api-server.test.js tests/api-auth-config.test.js tests/mcp-server.test.js tests/adapters.test.js tests/openapi-parity.test.js tests/budget-guard.test.js tests/contextfs.test.js tests/mcp-policy.test.js tests/subagent-profiles.test.js tests/intent-router.test.js tests/rubric-engine.test.js tests/self-healing-check.test.js tests/self-heal.test.js tests/feedback-schema.test.js tests/thompson-sampling.test.js tests/feedback-sequences.test.js tests/diversity-tracking.test.js tests/vector-store.test.js tests/feedback-attribution.test.js tests/hybrid-feedback-context.test.js tests/loop-closure.test.js tests/code-reasoning.test.js tests/feedback-loop.test.js tests/feedback-inbox-read.test.js tests/feedback-to-memory.test.js tests/test-coverage.test.js tests/version-metadata.test.js tests/local-model-profile.test.js tests/risk-scorer.test.js tests/context-compaction.test.js tests/reminder-engine.test.js",
+    "test:proof": "node --test --test-concurrency=1 tests/prove-adapters.test.js tests/prove-automation.test.js tests/prove-attribution.test.js tests/prove-lancedb.test.js tests/prove-data-quality.test.js tests/prove-intelligence.test.js tests/prove-loop-closure.test.js tests/prove-subway-upgrades.test.js tests/prove-training-export.test.js tests/prove-local-intelligence.test.js tests/prove-workflow-contract.test.js",
     "test:rlaif": "node --test tests/rlaif-self-audit.test.js tests/dpo-optimizer.test.js tests/meta-policy.test.js",
     "test:attribution": "node --test tests/feedback-attribution.test.js tests/hybrid-feedback-context.test.js",
     "test:quality": "node --test tests/validate-feedback.test.js",
     "test:intelligence": "node --test tests/intelligence.test.js",
     "test:training-export": "node --test tests/training-export.test.js",
     "test:deployment": "node --test tests/deployment.test.js",
+    "test:workflow": "node --test tests/workflow-contract.test.js",
     "test:billing": "node --test tests/billing.test.js",
-    "test:cli": "node --test tests/cli.test.js",
+    "test:cli": "node --test tests/cli.test.js tests/feedback-normalize.test.js tests/install-mcp.test.js",
+    "test:coverage": "node scripts/test-coverage.js",
     "start:api": "node src/api/server.js",
     "start:mcp": "node adapters/mcp/server-stdio.js",
+    "mcp:install": "node scripts/install-mcp.js",
     "feedback:capture": "node .claude/scripts/feedback/capture-feedback.js",
     "feedback:stats": "node .claude/scripts/feedback/capture-feedback.js --stats",
     "feedback:summary": "node .claude/scripts/feedback/capture-feedback.js --summary",
     "feedback:rules": "node .claude/scripts/feedback/capture-feedback.js --rules",
     "feedback:export:dpo": "node scripts/export-dpo-pairs.js --from-local --output .claude/memory/feedback/dpo-pairs.jsonl",
+    "feedback:export:kto": "node scripts/export-kto-pairs.js --from-local --output .claude/memory/feedback/kto-pairs.jsonl",
     "budget:status": "node scripts/budget-guard.js --status",
     "diagrams:paperbanana": "bash scripts/generate-paperbanana-diagrams.sh",
     "prove:adapters": "node scripts/prove-adapters.js",
     "prove:automation": "node scripts/prove-automation.js",
+    "prove:workflow-contract": "node scripts/prove-workflow-contract.js",
     "prove:lancedb": "node scripts/prove-lancedb.js",
     "prove:rlaif": "node scripts/prove-rlaif.js",
     "prove:attribution": "node scripts/prove-attribution.js",
     "prove:data-quality": "node scripts/prove-data-quality.js",
     "prove:loop-closure": "node scripts/prove-loop-closure.js",
     "prove:intelligence": "node scripts/prove-intelligence.js",
+    "prove:local-intelligence": "node scripts/prove-local-intelligence.js",
     "prove:training-export": "node scripts/prove-training-export.js",
     "prove:v2-milestone": "node scripts/prove-v2-milestone.js",
     "feedback:export:pytorch": "node scripts/export-training.js --pytorch",
@@ -75,7 +82,15 @@
     "ml:train": "python3 scripts/train_from_feedback.py --train",
     "ml:incremental": "python3 scripts/train_from_feedback.py --incremental",
     "ml:reliability": "python3 scripts/train_from_feedback.py --reliability",
-    "ml:sample": "python3 scripts/train_from_feedback.py --sample"
+    "ml:sample": "python3 scripts/train_from_feedback.py --sample",
+    "ml:model-fit": "node scripts/local-model-profile.js",
+    "ml:risk": "node scripts/risk-scorer.js",
+    "adk:consolidate": "node scripts/adk-consolidator.js",
+    "adk:watch": "node scripts/adk-consolidator.js --watch",
+    "pr:manage": "node scripts/pr-manager.js",
+    "watch": "node scripts/jsonl-watcher.js",
+    "status": "node scripts/status-dashboard.js",
+    "test:watcher": "node --test tests/jsonl-watcher.test.js"
   },
   "keywords": [
     "rlhf",
@@ -115,10 +130,11 @@
     "node": ">=18.18.0"
   },
   "dependencies": {
+    "@google/genai": "^1.44.0",
     "@huggingface/transformers": "^3.8.1",
     "@lancedb/lancedb": "^0.26.2",
     "apache-arrow": "^18.1.0",
     "stripe": "^20.4.1"
   },
-  "mcpName": "io.github.IgorGanapolsky/rlhf-feedback-loop"
+  "mcpName": "io.github.igorganapolsky/rlhf-feedback-loop"
 }

package/scripts/a2ui-engine.js

@@ -0,0 +1,73 @@
+/**
+ * A2UI (Agent-to-User Interface) Component Definitions
+ * 
+ * Standardized schema for dynamic UI components generated by the agent.
+ * These are intended to be rendered in the Feedback Studio or as MCP Artifacts.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const COMPONENT_TYPES = {
+  REASONING_TRACE: 'reasoning-trace',   // Graph/List showing how dots were connected
+  RULE_PROPOSAL: 'rule-proposal',       // Interactive card to approve/refine a rule
+  CONFLICT_VETO: 'conflict-veto',       // UI to resolve contradicting memories
+  METRIC_DYNAMIC: 'metric-dynamic'      // Real-time custom metrics based on current task
+};
+
+/**
+ * Generate a Reasoning Trace component (A2UI)
+ * @param {string} summary - High-level synthesis
+ * @param {Array} sources - List of source logs/memories
+ * @param {Array} connections - Semantic links found
+ */
+function createReasoningTrace(summary, sources, connections) {
+  return {
+    type: COMPONENT_TYPES.REASONING_TRACE,
+    version: '1.0.0',
+    data: {
+      summary,
+      sources: sources.map(s => ({
+        id: s.id,
+        text: s.context || s.content,
+        signal: s.signal || 'neutral'
+      })),
+      graph: connections.map(c => ({
+        from: c.sourceId,
+        to: c.targetId,
+        label: c.relation
+      }))
+    },
+    actions: [
+      { id: 'view-logs', label: 'View Raw Logs', type: 'primary' }
+    ]
+  };
+}
+
+/**
+ * Generate a Rule Proposal component (A2UI)
+ */
+function createRuleProposal(pattern, suggestedRule, severity) {
+  return {
+    type: COMPONENT_TYPES.RULE_PROPOSAL,
+    version: '1.0.0',
+    data: {
+      pattern,
+      suggestedRule,
+      severity
+    },
+    actions: [
+      { id: 'approve', label: 'Approve ALWAYS/NEVER', type: 'success' },
+      { id: 'refine', label: 'Tweak Wording', type: 'secondary' },
+      { id: 'veto', label: 'Veto Rule', type: 'danger' }
+    ]
+  };
+}
+
+module.exports = {
+  COMPONENT_TYPES,
+  createReasoningTrace,
+  createRuleProposal
+};