rlhf-feedback-loop 0.5.0

package/scripts/prove-subway-upgrades.js

@@ -0,0 +1,250 @@
+'use strict';
+/**
+ * Phase 11: Subway Upgrades — Proof Gate
+ *
+ * Validates all SUBW-01 through SUBW-05 requirements.
+ * Runs Jest tests in Subway (via execSync) to produce pass/fail evidence.
+ *
+ * Usage:
+ *   node scripts/prove-subway-upgrades.js
+ *
+ * Produces:
+ *   proof/subway-upgrades/subway-upgrades-report.json
+ *   proof/subway-upgrades/subway-upgrades-report.md
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const PROOF_DIR = path.join(__dirname, '..', 'proof', 'subway-upgrades');
+const REPORT_JSON = path.join(PROOF_DIR, 'subway-upgrades-report.json');
+const REPORT_MD = path.join(PROOF_DIR, 'subway-upgrades-report.md');
+
+const SUBWAY_ROOT = path.join(__dirname, '..', '..', '..', 'Subway_RN_Demo');
+
+function run() {
+  const results = { passed: 0, failed: 0, requirements: {} };
+
+  const checks = [
+    {
+      id: 'SUBW-01',
+      desc: 'LanceDB vector store ported to Subway — upsert + search verified by Jest (vector-store.test.js)',
+      fn: () => {
+        // Verify the Subway vector-store.js exists
+        const vsPath = path.join(SUBWAY_ROOT, '.claude', 'scripts', 'feedback', 'vector-store.js');
+        if (!fs.existsSync(vsPath)) throw new Error(`Missing: ${vsPath}`);
+
+        // Load and verify exports
+        const vs = require(vsPath);
+        if (typeof vs.upsertFeedback !== 'function') throw new Error('upsertFeedback not exported');
+        if (typeof vs.searchSimilar !== 'function') throw new Error('searchSimilar not exported');
+        if (vs.TABLE_NAME !== 'rlhf_memories') throw new Error(`TABLE_NAME must be rlhf_memories, got ${vs.TABLE_NAME}`);
+
+        // Run Jest tests
+        const out = execSync(
+          'node --experimental-vm-modules node_modules/.bin/jest --watchman=false --config jest.governance.config.js --testPathPattern=vector-store --forceExit',
+          {
+            cwd: SUBWAY_ROOT,
+            encoding: 'utf8',
+            stdio: 'pipe',
+            env: { ...process.env, RLHF_VECTOR_STUB_EMBED: 'true', NODE_OPTIONS: '--experimental-vm-modules' },
+          }
+        );
+        if (out.includes('FAIL ')) throw new Error(`Jest tests failed:\n${out.slice(-300)}`);
+      },
+    },
+    {
+      id: 'SUBW-02',
+      desc: 'DPO optimizer ported to Subway — buildPreferencePairs + applyDpoAdjustments + dpoLogRatio exported',
+      fn: () => {
+        const dpoPath = path.join(SUBWAY_ROOT, '.claude', 'scripts', 'feedback', 'dpo-optimizer.js');
+        if (!fs.existsSync(dpoPath)) throw new Error(`Missing: ${dpoPath}`);
+
+        // Clear cache for fresh load
+        delete require.cache[require.resolve(dpoPath)];
+        const dpo = require(dpoPath);
+        if (typeof dpo.dpoLogRatio !== 'function') throw new Error('dpoLogRatio not exported');
+        if (typeof dpo.buildPreferencePairs !== 'function') throw new Error('buildPreferencePairs not exported');
+        if (typeof dpo.applyDpoAdjustments !== 'function') throw new Error('applyDpoAdjustments not exported');
+        if (typeof dpo.run !== 'function') throw new Error('run not exported');
+
+        // Verify dpoLogRatio math
+        const adj = dpo.dpoLogRatio(1.0, 0.5);
+        if (typeof adj !== 'number') throw new Error('dpoLogRatio must return number');
+        if (adj <= 0) throw new Error('dpoLogRatio(1.0, 0.5) should be positive (chosen > rejected)');
+
+        // Run Jest tests
+        const out = execSync(
+          'node --experimental-vm-modules node_modules/.bin/jest --watchman=false --config jest.governance.config.js --testPathPattern=dpo-optimizer --forceExit',
+          {
+            cwd: SUBWAY_ROOT,
+            encoding: 'utf8',
+            stdio: 'pipe',
+          }
+        );
+        if (out.includes('FAIL ')) throw new Error(`Jest tests failed:\n${out.slice(-300)}`);
+      },
+    },
+    {
+      id: 'SUBW-03',
+      desc: 'Thompson Sampling JS module ported to Subway — updateModel updates alpha/beta posteriors',
+      fn: () => {
+        const tsPath = path.join(SUBWAY_ROOT, '.claude', 'scripts', 'feedback', 'thompson-sampling.js');
+        if (!fs.existsSync(tsPath)) throw new Error(`Missing: ${tsPath}`);
+
+        delete require.cache[require.resolve(tsPath)];
+        const ts = require(tsPath);
+        if (typeof ts.timeDecayWeight !== 'function') throw new Error('timeDecayWeight not exported');
+        if (typeof ts.loadModel !== 'function') throw new Error('loadModel not exported');
+        if (typeof ts.saveModel !== 'function') throw new Error('saveModel not exported');
+        if (typeof ts.updateModel !== 'function') throw new Error('updateModel not exported');
+        if (typeof ts.getReliability !== 'function') throw new Error('getReliability not exported');
+        if (typeof ts.samplePosteriors !== 'function') throw new Error('samplePosteriors not exported');
+
+        // Verify alpha update
+        const model = ts.createInitialModel();
+        const beforeAlpha = model.categories.testing.alpha;
+        ts.updateModel(model, { signal: 'positive', timestamp: new Date().toISOString(), categories: ['testing'] });
+        if (model.categories.testing.alpha <= beforeAlpha) throw new Error('alpha should increase on positive signal');
+
+        // Run Jest tests
+        const out = execSync(
+          'node --experimental-vm-modules node_modules/.bin/jest --watchman=false --config jest.governance.config.js --testPathPattern=thompson-sampling --forceExit',
+          {
+            cwd: SUBWAY_ROOT,
+            encoding: 'utf8',
+            stdio: 'pipe',
+          }
+        );
+        if (out.includes('FAIL ')) throw new Error(`Jest tests failed:\n${out.slice(-300)}`);
+      },
+    },
+    {
+      id: 'SUBW-04',
+      desc: 'Self-healing GH Action workflows exist in Subway .github/workflows/',
+      fn: () => {
+        const monitorPath = path.join(SUBWAY_ROOT, '.github', 'workflows', 'self-healing-monitor.yml');
+        const autoFixPath = path.join(SUBWAY_ROOT, '.github', 'workflows', 'self-healing-auto-fix.yml');
+        if (!fs.existsSync(monitorPath)) throw new Error(`Missing: ${monitorPath}`);
+        if (!fs.existsSync(autoFixPath)) throw new Error(`Missing: ${autoFixPath}`);
+
+        // Verify key fields in monitor workflow
+        const monitorContent = fs.readFileSync(monitorPath, 'utf-8');
+        if (!monitorContent.includes('self-healing-check.js')) {
+          throw new Error('self-healing-monitor.yml must reference self-healing-check.js');
+        }
+        if (!monitorContent.includes('self-heal.js')) {
+          throw new Error('self-healing-monitor.yml must reference self-heal.js');
+        }
+
+        // Verify auto-fix workflow
+        const autoFixContent = fs.readFileSync(autoFixPath, 'utf-8');
+        if (!autoFixContent.includes('self-heal.js')) {
+          throw new Error('self-healing-auto-fix.yml must reference self-heal.js');
+        }
+      },
+    },
+    {
+      id: 'SUBW-05',
+      desc: 'All Phase 11 Subway Jest tests pass with 0 failures (vector-store, dpo-optimizer, thompson-sampling)',
+      fn: () => {
+        // Use combined stderr+stdout to capture Jest output (it writes to stderr)
+        let out = '';
+        try {
+          out = execSync(
+            'npx jest --watchman=false --config jest.governance.config.js --testPathPattern="vector-store|dpo-optimizer|thompson-sampling" --forceExit 2>&1',
+            {
+              cwd: SUBWAY_ROOT,
+              encoding: 'utf8',
+              env: { ...process.env, RLHF_VECTOR_STUB_EMBED: 'true', NODE_OPTIONS: '--experimental-vm-modules' },
+            }
+          );
+        } catch (err) {
+          // execSync throws on non-zero exit — capture output from err.stdout/stderr
+          out = (err.stdout || '') + (err.stderr || '');
+          // If there are actual test failures in the output, throw; otherwise re-check
+          const failMatch = out.match(/Tests:\s+(\d+) failed/);
+          if (failMatch && parseInt(failMatch[1], 10) > 0) {
+            throw new Error(`${failMatch[1]} Jest test failure(s):\n${out.slice(-500)}`);
+          }
+        }
+        // Verify at least 25 tests passed
+        const passMatch = out.match(/Tests:\s+.*?(\d+) passed/);
+        const passCnt = passMatch ? parseInt(passMatch[1], 10) : 0;
+        if (passCnt < 25) throw new Error(`Expected >= 25 tests passing, got ${passCnt}`);
+      },
+    },
+  ];
+
+  console.log('Phase 11: Subway Upgrades — Proof Gate\n');
+  console.log('Checking requirements:\n');
+
+  for (const check of checks) {
+    try {
+      check.fn();
+      results.passed++;
+      results.requirements[check.id] = { status: 'pass', desc: check.desc };
+      console.log(`  PASS  ${check.id}: ${check.desc}`);
+    } catch (err) {
+      results.failed++;
+      results.requirements[check.id] = {
+        status: 'fail',
+        desc: check.desc,
+        error: err.message,
+      };
+      console.error(`  FAIL  ${check.id}: ${err.message}`);
+    }
+  }
+
+  // Write proof artifacts
+  fs.mkdirSync(PROOF_DIR, { recursive: true });
+
+  const report = {
+    phase: '11-subway-upgrades',
+    generatedAt: new Date().toISOString(),
+    passed: results.passed,
+    failed: results.failed,
+    total: checks.length,
+    requirements: results.requirements,
+  };
+
+  fs.writeFileSync(REPORT_JSON, JSON.stringify(report, null, 2) + '\n');
+
+  const md = [
+    '# Phase 11: Subway Upgrades — Proof Report',
+    '',
+    `Generated: ${report.generatedAt}`,
+    `Result: ${results.passed}/${checks.length} passed`,
+    '',
+    '## Requirements',
+    '',
+    ...Object.entries(results.requirements).map(([id, r]) => {
+      const checkbox = r.status === 'pass' ? '[x]' : '[ ]';
+      const errLine = r.error ? `\n  - Error: \`${r.error}\`` : '';
+      return `- ${checkbox} **${id}**: ${r.desc}${errLine}`;
+    }),
+    '',
+    '## Evidence',
+    '',
+    '- `Subway/.claude/scripts/feedback/vector-store.js` — LanceDB upsert + semantic search (3-level PATH from root)',
+    '- `Subway/.claude/scripts/feedback/dpo-optimizer.js` — Offline batch DPO optimization (sibling requires)',
+    '- `Subway/.claude/scripts/feedback/thompson-sampling.js` — Beta-Bernoulli posteriors with inline parseTimestamp',
+    '- `Subway/.github/workflows/self-healing-monitor.yml` — Scheduled health check + issue creation',
+    '- `Subway/.github/workflows/self-healing-auto-fix.yml` — Scheduled self-heal + remediation PR',
+    '- `Subway/scripts/__tests__/vector-store.test.js` — 6 Jest tests (NODE_OPTIONS=--experimental-vm-modules)',
+    '- `Subway/scripts/__tests__/dpo-optimizer.test.js` — 7 Jest tests',
+    '- `Subway/scripts/__tests__/thompson-sampling.test.js` — 10 Jest tests',
+    '',
+  ].join('\n');
+
+  fs.writeFileSync(REPORT_MD, md);
+
+  console.log(`\nPhase 11 proof: ${results.passed} passed, ${results.failed} failed`);
+  console.log(`Report: ${REPORT_JSON}`);
+
+  if (results.failed > 0) process.exit(1);
+}
+
+run();

package/scripts/prove-training-export.js

@@ -0,0 +1,324 @@
+#!/usr/bin/env node
+/**
+ * prove-training-export.js
+ *
+ * Smoke-test gate for Phase 10: Training Export
+ * Verifies all export formats + DPO validation gate work end-to-end.
+ * Writes machine-readable JSON + human-readable markdown to proof/.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const ROOT = path.join(__dirname, '..');
+const PROOF_DIR = path.join(ROOT, 'proof');
+
+function ensureDir(d) {
+  if (!fs.existsSync(d)) fs.mkdirSync(d, { recursive: true });
+}
+
+function runTests() {
+  try {
+    const output = execSync('node --test tests/training-export.test.js', {
+      cwd: ROOT,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    return output;
+  } catch (err) {
+    return err.stdout || err.stderr || String(err);
+  }
+}
+
+function parseTestOutput(output) {
+  const passMatch = output.match(/ℹ pass (\d+)/);
+  const failMatch = output.match(/ℹ fail (\d+)/);
+  const passed = passMatch ? parseInt(passMatch[1], 10) : 0;
+  const failed = failMatch ? parseInt(failMatch[1], 10) : 0;
+  return { passed, failed };
+}
+
+function makeFeedbackEntry(overrides) {
+  return {
+    id: `fb_${Date.now()}_test`,
+    timestamp: new Date().toISOString(),
+    signal: 'positive',
+    feedback: 'up',
+    reward: 1,
+    context: 'Test context for smoke test',
+    tags: ['testing'],
+    richContext: { domain: 'testing', outcomeCategory: 'quick-success' },
+    ...overrides,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Smoke test: PyTorch JSON export (XPRT-01)
+// ---------------------------------------------------------------------------
+function smokePyTorchExport() {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'prove-xprt1-'));
+  try {
+    delete require.cache[require.resolve('./export-training.js')];
+    const m = require('./export-training.js');
+
+    fs.mkdirSync(path.join(tmpDir, 'training-data'), { recursive: true });
+
+    const entries = [
+      makeFeedbackEntry({ context: 'Implemented TDD correctly' }),
+      makeFeedbackEntry({ signal: 'negative', feedback: 'down', reward: -1, context: 'Skipped validation' }),
+    ];
+    fs.writeFileSync(
+      path.join(tmpDir, 'feedback-log.jsonl'),
+      entries.map((e) => JSON.stringify(e)).join('\n')
+    );
+
+    const outPath = path.join(tmpDir, 'pytorch.json');
+    const result = m.exportPyTorchJSON(tmpDir, outPath);
+
+    if (!fs.existsSync(result.outputPath)) throw new Error('Output file not created');
+    const data = JSON.parse(fs.readFileSync(result.outputPath, 'utf-8'));
+    if (!data.metadata) throw new Error('Missing metadata');
+    if (data.metadata.format !== 'pytorch-dpo') throw new Error('Wrong format');
+    if (!Array.isArray(data.pairs)) throw new Error('Missing pairs array');
+    if (!Array.isArray(data.sequences)) throw new Error('Missing sequences array');
+
+    // Verify pair structure when pairs exist
+    if (data.pairs.length > 0) {
+      const pair = data.pairs[0];
+      if (!('prompt' in pair)) throw new Error('pair missing prompt');
+      if (!('chosen' in pair)) throw new Error('pair missing chosen');
+      if (!('rejected' in pair)) throw new Error('pair missing rejected');
+    }
+
+    return { passed: true, pairCount: result.pairCount, format: data.metadata.format };
+  } catch (err) {
+    return { passed: false, error: err.message };
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Smoke test: CSV export (XPRT-02)
+// ---------------------------------------------------------------------------
+function smokeCsvExport() {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'prove-xprt2-'));
+  try {
+    delete require.cache[require.resolve('./export-training.js')];
+    const m = require('./export-training.js');
+
+    fs.mkdirSync(path.join(tmpDir, 'training-data'), { recursive: true });
+
+    const entries = [
+      makeFeedbackEntry({ context: 'Works great' }),
+      makeFeedbackEntry({ signal: 'negative', feedback: 'down', reward: -1, context: 'Has issues' }),
+    ];
+    fs.writeFileSync(
+      path.join(tmpDir, 'feedback-log.jsonl'),
+      entries.map((e) => JSON.stringify(e)).join('\n')
+    );
+
+    const outPath = path.join(tmpDir, 'summary.csv');
+    const result = m.exportCSV(tmpDir, outPath);
+
+    if (!fs.existsSync(result.outputPath)) throw new Error('CSV not created');
+    const csv = fs.readFileSync(result.outputPath, 'utf-8');
+    const lines = csv.split('\n');
+    const headers = lines[0].split(',');
+
+    const required = ['id', 'timestamp', 'signal', 'reward', 'context'];
+    for (const h of required) {
+      if (!headers.includes(h)) throw new Error(`CSV missing column: ${h}`);
+    }
+    if (result.rowCount !== 2) throw new Error(`Expected 2 rows, got ${result.rowCount}`);
+
+    return { passed: true, rowCount: result.rowCount, headers };
+  } catch (err) {
+    return { passed: false, error: err.message };
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Smoke test: Action analysis (XPRT-03)
+// ---------------------------------------------------------------------------
+function smokeActionAnalysis() {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'prove-xprt3-'));
+  try {
+    delete require.cache[require.resolve('./export-training.js')];
+    const m = require('./export-training.js');
+
+    fs.mkdirSync(path.join(tmpDir, 'training-data'), { recursive: true });
+    fs.writeFileSync(path.join(tmpDir, 'feedback-log.jsonl'), '');
+
+    const outPath = path.join(tmpDir, 'actions.json');
+    const { report } = m.exportActionAnalysis(tmpDir, outPath);
+
+    if (!report.summary) throw new Error('Missing summary');
+    if (!report.actionPatterns) throw new Error('Missing actionPatterns');
+    if (!Array.isArray(report.topFailureModes)) throw new Error('Missing topFailureModes');
+    if (!Array.isArray(report.recommendations)) throw new Error('Missing recommendations');
+
+    return { passed: true, fields: Object.keys(report) };
+  } catch (err) {
+    return { passed: false, error: err.message };
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Smoke test: validateMemoryStructure gate (XPRT-04)
+// ---------------------------------------------------------------------------
+function smokeValidateMemoryStructure() {
+  try {
+    delete require.cache[require.resolve('./export-training.js')];
+    const m = require('./export-training.js');
+
+    // Valid entry
+    const valid = m.validateMemoryStructure({
+      title: 'SUCCESS: Test passed',
+      content: 'The implementation was correct and tests verified.',
+      category: 'learning',
+      tags: ['testing'],
+    });
+    if (!valid.valid) throw new Error('Valid entry rejected: ' + valid.issues.join(', '));
+
+    // Missing 'chosen' in DPO export
+    const missingChosen = m.validateMemoryStructure({
+      title: 'PREFERENCE: Good vs bad',
+      content: 'Comparison of approaches.',
+      category: 'preference',
+      tags: ['arch'],
+      _dpoExport: true,
+      prompt: 'Which approach?',
+      // chosen is missing
+      rejected: 'The bad approach',
+    });
+    if (missingChosen.valid) throw new Error('Should have rejected missing chosen field');
+    if (!missingChosen.issues.some((i) => i.includes('chosen'))) {
+      throw new Error('Issue should mention chosen field');
+    }
+
+    return {
+      passed: true,
+      validEntryAccepted: valid.valid,
+      missingChosenRejected: !missingChosen.valid,
+      missingChosenIssues: missingChosen.issues,
+    };
+  } catch (err) {
+    return { passed: false, error: err.message };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+async function main() {
+  console.log('Running Phase 10: Training Export proof gate...\n');
+
+  const testOutput = runTests();
+  const { passed: testsPassed, failed: testsFailed } = parseTestOutput(testOutput);
+
+  const pytorch = smokePyTorchExport();
+  const csv = smokeCsvExport();
+  const actions = smokeActionAnalysis();
+  const gate = smokeValidateMemoryStructure();
+
+  const allPassed = testsFailed === 0 && pytorch.passed && csv.passed && actions.passed && gate.passed;
+
+  const report = {
+    phase: 10,
+    name: 'Training Export',
+    requirements: ['XPRT-01', 'XPRT-02', 'XPRT-03', 'XPRT-04', 'XPRT-05'],
+    generatedAt: new Date().toISOString(),
+    testResults: {
+      passed: testsPassed,
+      failed: testsFailed,
+      suiteFile: 'tests/training-export.test.js',
+    },
+    smokeTests: {
+      pytorchExport: pytorch,
+      csvExport: csv,
+      actionAnalysis: actions,
+      validateMemoryStructure: gate,
+    },
+    overallPassed: allPassed,
+  };
+
+  ensureDir(PROOF_DIR);
+  const jsonPath = path.join(PROOF_DIR, 'training-export-report.json');
+  const mdPath = path.join(PROOF_DIR, 'training-export-report.md');
+
+  fs.writeFileSync(jsonPath, JSON.stringify(report, null, 2));
+
+  const status = allPassed ? 'PASSED' : 'FAILED';
+  const md = `# Phase 10: Training Export — Proof Report
+
+**Status:** ${status}
+**Generated:** ${report.generatedAt}
+**Requirements:** ${report.requirements.join(', ')}
+
+## Test Results
+
+| Suite | Passed | Failed |
+|-------|--------|--------|
+| training-export.test.js | ${testsPassed} | ${testsFailed} |
+
+## Smoke Tests
+
+### PyTorch JSON Export (XPRT-01)
+- Passed: ${pytorch.passed}
+${pytorch.passed ? `- Pair count: ${pytorch.pairCount}\n- Format: ${pytorch.format}` : `- Error: ${pytorch.error}`}
+
+### CSV Summary Export (XPRT-02)
+- Passed: ${csv.passed}
+${csv.passed ? `- Row count: ${csv.rowCount}\n- Headers: ${csv.headers ? csv.headers.join(', ') : 'N/A'}` : `- Error: ${csv.error}`}
+
+### Action Analysis Report (XPRT-03)
+- Passed: ${actions.passed}
+${actions.passed ? `- Report fields: ${actions.fields ? actions.fields.join(', ') : 'N/A'}` : `- Error: ${actions.error}`}
+
+### DPO Export Gate — validateMemoryStructure (XPRT-04)
+- Passed: ${gate.passed}
+${gate.passed ? `- Valid entry accepted: ${gate.validEntryAccepted}\n- Missing 'chosen' field rejected: ${gate.missingChosenRejected}` : `- Error: ${gate.error}`}
+
+## Requirements Coverage
+
+| Requirement | Description | Status |
+|-------------|-------------|--------|
+| XPRT-01 | PyTorch JSON export with prompt/chosen/rejected pairs | ${pytorch.passed ? 'PASS' : 'FAIL'} |
+| XPRT-02 | CSV summary export with correct headers and escaping | ${csv.passed ? 'PASS' : 'FAIL'} |
+| XPRT-03 | Action analysis report from feedback sequences | ${actions.passed ? 'PASS' : 'FAIL'} |
+| XPRT-04 | validateMemoryStructure() gates DPO export | ${gate.passed ? 'PASS' : 'FAIL'} |
+| XPRT-05 | All export features have unit tests (${testsPassed} tests, ${testsFailed} failures) | ${testsFailed === 0 ? 'PASS' : 'FAIL'} |
+
+## Files Created
+
+- \`scripts/export-training.js\` — PyTorch JSON, CSV, action analysis exports + validateMemoryStructure gate
+- \`tests/training-export.test.js\` — ${testsPassed} unit tests covering all formats, gate rejection, edge cases
+- \`scripts/prove-training-export.js\` — This proof gate script
+`;
+
+  fs.writeFileSync(mdPath, md);
+
+  console.log(`Status: ${status}`);
+  console.log(`Tests: ${testsPassed} passed, ${testsFailed} failed`);
+  console.log(`PyTorch smoke: ${pytorch.passed ? 'PASS' : 'FAIL'}`);
+  console.log(`CSV smoke: ${csv.passed ? 'PASS' : 'FAIL'}`);
+  console.log(`Action analysis smoke: ${actions.passed ? 'PASS' : 'FAIL'}`);
+  console.log(`validateMemoryStructure gate: ${gate.passed ? 'PASS' : 'FAIL'}`);
+  console.log(`\nReport written to: ${mdPath}`);
+
+  process.exit(allPassed ? 0 : 1);
+}
+
+main().catch((err) => {
+  console.error('prove-training-export failed:', err.message);
+  process.exit(1);
+});