groove-dev 0.27.93 → 0.27.96

package/node_modules/moe-training/client/trajectory-capture.js

@@ -0,0 +1,307 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { randomUUID } from 'node:crypto';
+import { ConsentManager } from './consent.js';
+import { PIIScrubber } from './scrubber.js';
+import { getParser } from './parsers/index.js';
+import { StepClassifier } from './step-classifier.js';
+import { EnvelopeBuilder } from './envelope-builder.js';
+import { SessionAttestation } from './session-attestation.js';
+import { TransmissionQueue } from './transmission-queue.js';
+import { CHUNK_TIMEOUT_MS, CENTRAL_COMMAND_URL } from '../shared/constants.js';
+
+const OFFLINE_RETRY_INTERVAL_MS = 60_000;
+
+export class TrajectoryCapture {
+  constructor(options = {}) {
+    this._centralCommandUrl = options.centralCommandUrl || CENTRAL_COMMAND_URL;
+    this._grooveVersion = options.grooveVersion || '0.0.0';
+    this._enabled = false;
+    this._scrubber = null;
+    this._attestation = null;
+    this._transmissionQueue = null;
+    this._offlineRetryTimer = null;
+    this._contexts = new Map();
+  }
+
+  init() {
+    if (!ConsentManager.isCaptureEnabled()) {
+      this._enabled = false;
+      return;
+    }
+    this._enabled = true;
+    this._scrubber = new PIIScrubber();
+    this._attestation = new SessionAttestation(this._centralCommandUrl);
+    this._transmissionQueue = new TransmissionQueue(this._centralCommandUrl);
+    this._transmissionQueue.start();
+    this._offlineRetryTimer = setInterval(() => {
+      this._retryOfflineQueue();
+    }, OFFLINE_RETRY_INTERVAL_MS);
+  }
+
+  async onAgentSpawn(agentId, provider, model, role, teamSize) {
+    if (!this._enabled) return;
+
+    const parser = getParser(provider);
+    if (!parser) return;
+
+    const sessionId = `sess_${randomUUID()}`;
+    const contributorId = ConsentManager.getOrCreateUserId();
+    const metadata = {
+      model_engine: model,
+      provider,
+      agent_role: role,
+      agent_id: agentId,
+      task_complexity: 'medium',
+      team_size: teamSize || 1,
+      session_quality: 0,
+      groove_version: this._grooveVersion,
+    };
+
+    const builder = new EnvelopeBuilder(sessionId, contributorId, metadata);
+    const classifier = new StepClassifier();
+    const startTime = Date.now();
+
+    const ctx = {
+      sessionId,
+      parser,
+      builder,
+      classifier,
+      metadata,
+      stepCount: 0,
+      chunkCount: 0,
+      totalTokens: 0,
+      errorsEncountered: 0,
+      errorsRecovered: 0,
+      filesModified: 0,
+      coordinationEvents: 0,
+      startTime,
+      chunkTimer: null,
+      allSteps: [],
+    };
+
+    ctx.chunkTimer = setInterval(() => {
+      this._flushContext(agentId);
+    }, CHUNK_TIMEOUT_MS);
+
+    this._contexts.set(agentId, ctx);
+
+    await this._attestation.openSession(sessionId, metadata);
+  }
+
+  onStdoutLine(agentId, jsonLine) {
+    if (!this._enabled) return;
+    const ctx = this._contexts.get(agentId);
+    if (!ctx) return;
+
+    let jsonEvent;
+    try {
+      jsonEvent = typeof jsonLine === 'string' ? JSON.parse(jsonLine) : jsonLine;
+    } catch {
+      return;
+    }
+
+    const parsed = ctx.parser.parseEvent(jsonEvent);
+    if (!parsed) return;
+
+    const events = Array.isArray(parsed) ? parsed : [parsed];
+    for (const event of events) {
+      this._processStep(agentId, ctx, event);
+    }
+
+    if ((!ctx.metadata.model_engine || ctx.metadata.model_engine === 'auto') &&
+        typeof ctx.parser.extractModel === 'function') {
+      const resolved = ctx.parser.extractModel(jsonEvent);
+      if (resolved) ctx.metadata.model_engine = resolved;
+    }
+
+    const tokens = ctx.parser.extractTokens(jsonEvent);
+    if (tokens) {
+      ctx.totalTokens += (tokens.input || 0) + (tokens.output || 0);
+    }
+  }
+
+  onUserMessage(agentId, text) {
+    if (!this._enabled) return;
+    const ctx = this._contexts.get(agentId);
+    if (!ctx) return;
+
+    const classified = ctx.classifier.classifyUserMessage(text);
+    if (!classified) return;
+
+    this._processStep(agentId, ctx, classified);
+  }
+
+  onCoordinationEvent(agentId, event) {
+    if (!this._enabled) return;
+    const ctx = this._contexts.get(agentId);
+    if (!ctx) return;
+
+    const classified = ctx.classifier.classifyCoordinationEvent(event);
+    ctx.coordinationEvents++;
+    this._processStep(agentId, ctx, classified);
+  }
+
+  async onAgentComplete(agentId, outcome) {
+    await this._closeAgent(agentId, outcome?.status || 'SUCCESS', outcome);
+  }
+
+  async onAgentCrash(agentId, error) {
+    await this._closeAgent(agentId, 'CRASH', { error: error?.message || String(error) });
+  }
+
+  async shutdown() {
+    if (this._offlineRetryTimer) clearInterval(this._offlineRetryTimer);
+    for (const agentId of this._contexts.keys()) {
+      await this._closeAgent(agentId, 'SHUTDOWN');
+    }
+    if (this._transmissionQueue) {
+      await this._transmissionQueue.stop();
+    }
+  }
+
+  _processStep(agentId, ctx, event) {
+    const classified = ctx.classifier.onStep(event);
+    const ev = classified || event;
+
+    if (ev.content && typeof ev.content === 'string') {
+      ev.content = this._scrubber.scrub(ev.content);
+    }
+
+    if (ev.arguments && typeof ev.arguments === 'object') {
+      ev.arguments = this._scrubObject(ev.arguments);
+    }
+
+    if (!ev.token_count || ev.token_count < 2) {
+      const text = ev.content || '';
+      const argsLen = ev.arguments ? JSON.stringify(ev.arguments).length : 0;
+      ev.token_count = Math.max(1, Math.ceil((text.length + argsLen) / 4));
+    }
+
+    const step = {
+      step: ++ctx.stepCount,
+      type: ev.type,
+      timestamp: Date.now() / 1000,
+      ...ev,
+    };
+
+    if (ev.type === 'error') ctx.errorsEncountered++;
+    ctx.allSteps.push(step);
+
+    const envelope = ctx.builder.addStep(step);
+    if (envelope) {
+      this._signAndTransmit(ctx.sessionId, envelope);
+      ctx.chunkCount++;
+    }
+  }
+
+  _computeQuality(ctx) {
+    let score = 50;
+    const types = new Set();
+    let hasCorrection = false;
+
+    for (const step of ctx.allSteps) {
+      if (step.type) types.add(step.type);
+      if (step.type === 'correction') hasCorrection = true;
+    }
+
+    if (hasCorrection) score += 10;
+    if (ctx.coordinationEvents > 0) score += 10;
+    if (ctx.errorsRecovered > 0) score += 10;
+    if (ctx.stepCount >= 20) score += 10;
+    if (types.size >= 3) score += 10;
+
+    return Math.min(score, 100);
+  }
+
+  _flushContext(agentId) {
+    const ctx = this._contexts.get(agentId);
+    if (!ctx) return;
+    ctx.metadata.session_quality = this._computeQuality(ctx);
+    const envelope = ctx.builder.flush();
+    if (envelope) {
+      this._signAndTransmit(ctx.sessionId, envelope);
+      ctx.chunkCount++;
+    }
+  }
+
+  async _closeAgent(agentId, status, extra) {
+    const ctx = this._contexts.get(agentId);
+    if (!ctx) return;
+
+    if (ctx.chunkTimer) clearInterval(ctx.chunkTimer);
+
+    this._flushContext(agentId);
+
+    const hasRecovery = StepClassifier.detectErrorRecovery(ctx.allSteps);
+    if (hasRecovery) ctx.errorsRecovered++;
+
+    ctx.metadata.session_quality = this._computeQuality(ctx);
+
+    const closeEnvelope = ctx.builder.buildSessionClose({
+      status,
+      session_quality: ctx.metadata.session_quality,
+      user_interventions: StepClassifier.countUserInterventions(ctx.allSteps),
+      total_steps: ctx.stepCount,
+      total_chunks: ctx.chunkCount,
+      total_tokens: ctx.totalTokens,
+      duration_seconds: Math.round((Date.now() - ctx.startTime) / 1000),
+      files_modified: extra?.files_modified || ctx.filesModified,
+      errors_encountered: ctx.errorsEncountered,
+      errors_recovered: ctx.errorsRecovered,
+      coordination_events: ctx.coordinationEvents,
+    });
+
+    this._signAndTransmit(ctx.sessionId, closeEnvelope);
+
+    try {
+      await this._transmissionQueue.waitForDrain();
+    } catch {
+      // drain timeout
+    }
+
+    try {
+      await this._attestation.closeSession(ctx.sessionId);
+    } catch {
+      // fail silent
+    }
+
+    this._contexts.delete(agentId);
+  }
+
+  async _retryOfflineQueue() {
+    if (!this._enabled || !this._transmissionQueue || this._transmissionQueue.offlineQueueSize === 0) return;
+    try {
+      const res = await fetch(`${this._centralCommandUrl}/health`, {
+        signal: AbortSignal.timeout(5_000),
+      });
+      if (res.ok) {
+        this._transmissionQueue.replayOfflineQueue(this._attestation);
+      }
+    } catch {
+      // still unreachable
+    }
+  }
+
+  _scrubObject(obj) {
+    if (typeof obj === 'string') return this._scrubber.scrub(obj);
+    if (Array.isArray(obj)) return obj.map((v) => this._scrubObject(v));
+    if (obj && typeof obj === 'object') {
+      const out = {};
+      for (const [k, v] of Object.entries(obj)) {
+        out[k] = this._scrubObject(v);
+      }
+      return out;
+    }
+    return obj;
+  }
+
+  _signAndTransmit(sessionId, envelope) {
+    try {
+      const signed = this._attestation.signEnvelope(sessionId, envelope);
+      this._transmissionQueue.enqueue(signed);
+    } catch {
+      // fail silent
+    }
+  }
+}

package/node_modules/moe-training/client/transmission-queue.js

@@ -0,0 +1,104 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { MAX_QUEUE_SIZE } from '../shared/constants.js';
+
+export class TransmissionQueue {
+  constructor(centralCommandUrl, maxSize = MAX_QUEUE_SIZE) {
+    this._centralCommandUrl = centralCommandUrl;
+    this._maxSize = maxSize;
+    this._queue = [];
+    this._offlineQueue = [];
+    this._running = false;
+    this._drainPromise = null;
+
+    if (process.env.NODE_ENV === 'production' && !centralCommandUrl.startsWith('https://')) {
+      console.warn('[TransmissionQueue] WARNING: centralCommandUrl does not use HTTPS in production');
+    }
+  }
+
+  get offlineQueueSize() {
+    return this._offlineQueue.length;
+  }
+
+  enqueue(signedEnvelope) {
+    if (this._queue.length >= this._maxSize) return;
+    if (signedEnvelope?.attestation?.session_hmac === 'OFFLINE') {
+      this._offlineQueue.push(signedEnvelope);
+      return;
+    }
+    this._queue.push(signedEnvelope);
+    if (this._running) this._kick();
+  }
+
+  replayOfflineQueue(sessionAttestation) {
+    const pending = this._offlineQueue.splice(0);
+    for (const envelope of pending) {
+      const sessionId = envelope.session_id;
+      const resigned = sessionAttestation.signEnvelope(sessionId, envelope);
+      if (resigned?.attestation?.session_hmac === 'OFFLINE') {
+        this._offlineQueue.push(resigned);
+        continue;
+      }
+      this._queue.push(resigned);
+    }
+    if (this._running && this._queue.length > 0) this._kick();
+  }
+
+  start() {
+    if (this._running) return;
+    this._running = true;
+    this._kick();
+  }
+
+  async waitForDrain() {
+    while (this._queue.length > 0 || this._drainPromise) {
+      if (this._drainPromise) await this._drainPromise;
+      else await new Promise((r) => setTimeout(r, 50));
+    }
+  }
+
+  async stop() {
+    this._running = false;
+    if (this._drainPromise) {
+      await this._drainPromise;
+    }
+  }
+
+  _kick() {
+    if (this._drainPromise) return;
+    this._drainPromise = this._drain().finally(() => {
+      this._drainPromise = null;
+    });
+  }
+
+  async _drain() {
+    while (this._running && this._queue.length > 0) {
+      const envelope = this._queue[0];
+      let success = false;
+
+      for (let attempt = 0; attempt < 5; attempt++) {
+        try {
+          const res = await fetch(`${this._centralCommandUrl}/v1/training/ingest`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(envelope),
+            signal: AbortSignal.timeout(30_000),
+          });
+          if (res.ok) {
+            success = true;
+            break;
+          }
+        } catch {
+          // network error
+        }
+
+        if (!this._running) return;
+        const delay = Math.min(1000 * Math.pow(2, attempt), 60_000);
+        await new Promise((r) => setTimeout(r, delay));
+        if (!this._running) return;
+      }
+
+      this._queue.shift();
+    }
+  }
+}

package/node_modules/moe-training/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "moe-training",
+  "private": true,
+  "version": "0.1.0",
+  "type": "module",
+  "description": "MoE TrajectoryCapture client — captures agent session data into structured Trajectory Envelopes",
+  "license": "FSL-1.1-Apache-2.0",
+  "exports": {
+    ".": "./client/index.js",
+    "./shared/*": "./shared/*.js"
+  },
+  "scripts": {
+    "test": "node --test test/**/*.test.js",
+    "start:server": "node server/index.js"
+  },
+  "dependencies": {
+    "better-sqlite3": "^12.9.0",
+    "uuid": "^9.0.0",
+    "express": "^4.18.0"
+  }
+}

package/node_modules/moe-training/server/enrichment.js

@@ -0,0 +1,24 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+// TODO: LLM-as-a-Judge — classify each step's cognitive target
+//   (syntactic/semantic/strategic/corrective/coordinative)
+//   using a small model call after stitching
+
+// TODO: Model fingerprint verification — confirm the claimed model_engine
+//   matches the output style using an LLM classifier
+
+// TODO: Quality assessment — score trajectory coherence, tool usage
+//   efficiency, and error recovery patterns
+
+export class EnrichmentPipeline {
+  async enrich(stitchedTrajectory) {
+    return {
+      ...stitchedTrajectory,
+      enrichment: {
+        cognitive_target: 'pending',
+        model_verified: 'pending',
+        quality_assessment: 'pending',
+      },
+    };
+  }
+}

package/node_modules/moe-training/server/index.js

@@ -0,0 +1,119 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import express from 'express';
+import { SessionRegistry } from './session-registry.js';
+import { EnvelopeVerifier } from './verifier.js';
+import { EnvelopeStorage } from './storage.js';
+import { TrajectoryStitcher } from './stitcher.js';
+import { TrajectoryScorer } from './scoring.js';
+import { ContributorLedger } from './ledger.js';
+import { EnrichmentPipeline } from './enrichment.js';
+import { CentralStats } from './stats.js';
+import { createSessionRoutes } from './routes/sessions.js';
+import { createIngestRoutes } from './routes/ingest.js';
+import { createStatsRoutes } from './routes/stats.js';
+import { MODEL_TIERS, QUALITY_MULTIPLIERS } from '../shared/constants.js';
+
+const PORT = parseInt(process.env.GROOVE_CENTRAL_PORT, 10) || 8443;
+
+const sessionRegistry = new SessionRegistry();
+const storage = new EnvelopeStorage();
+const ledger = new ContributorLedger();
+const verifier = new EnvelopeVerifier(sessionRegistry);
+const stitcher = new TrajectoryStitcher(storage);
+const scorer = new TrajectoryScorer({ MODEL_TIERS, QUALITY_MULTIPLIERS });
+const enrichment = new EnrichmentPipeline();
+const centralStats = new CentralStats(storage, ledger, sessionRegistry);
+
+const app = express();
+
+app.use((_req, res, next) => {
+  res.header('Access-Control-Allow-Origin', '*');
+  res.header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+  res.header('Access-Control-Allow-Headers', 'Content-Type');
+  if (_req.method === 'OPTIONS') return res.sendStatus(204);
+  next();
+});
+
+app.use(express.json({ limit: '5mb' }));
+
+// Per-IP rate limiting
+const ipWindows = new Map();
+const RATE_LIMIT_PER_MINUTE = 100;
+const RATE_LIMIT_PER_HOUR = 1000;
+
+setInterval(() => {
+  const now = Date.now();
+  for (const [ip, entry] of ipWindows) {
+    if (now - entry.minuteStart > 120_000 && now - entry.hourStart > 7200_000) {
+      ipWindows.delete(ip);
+    }
+  }
+}, 300_000);
+
+app.use((req, res, next) => {
+  const ip = req.headers['x-forwarded-for']?.split(',')[0]?.trim() || req.ip;
+  const now = Date.now();
+
+  let entry = ipWindows.get(ip);
+  if (!entry) {
+    entry = { minuteCount: 0, minuteStart: now, hourCount: 0, hourStart: now };
+    ipWindows.set(ip, entry);
+  }
+
+  if (now - entry.minuteStart > 60_000) {
+    entry.minuteCount = 0;
+    entry.minuteStart = now;
+  }
+  if (now - entry.hourStart > 3600_000) {
+    entry.hourCount = 0;
+    entry.hourStart = now;
+  }
+
+  entry.minuteCount++;
+  entry.hourCount++;
+
+  if (entry.minuteCount > RATE_LIMIT_PER_MINUTE) {
+    return res.status(429).json({ error: 'Too Many Requests', retryAfter: Math.ceil((entry.minuteStart + 60_000 - now) / 1000) });
+  }
+  if (entry.hourCount > RATE_LIMIT_PER_HOUR) {
+    return res.status(429).json({ error: 'Too Many Requests', retryAfter: Math.ceil((entry.hourStart + 3600_000 - now) / 1000) });
+  }
+
+  next();
+});
+
+app.use((req, res, next) => {
+  const start = Date.now();
+  res.on('finish', () => {
+    const duration = Date.now() - start;
+    console.log(`[${new Date().toISOString()}] ${req.method} ${req.path} ${res.statusCode} ${duration}ms`);
+  });
+  next();
+});
+
+app.get('/health', (_req, res) => res.json({ status: 'ok', uptime: process.uptime() }));
+
+app.use(createSessionRoutes(sessionRegistry));
+app.use(createIngestRoutes(verifier, storage, stitcher, scorer, enrichment, ledger, sessionRegistry));
+app.use(createStatsRoutes(centralStats));
+
+const server = app.listen(PORT, () => {
+  console.log(`[central-command] listening on port ${PORT}`);
+});
+
+function shutdown() {
+  console.log('[central-command] shutting down...');
+  server.close(() => {
+    sessionRegistry.close();
+    ledger.close();
+    console.log('[central-command] shut down complete');
+    process.exit(0);
+  });
+  setTimeout(() => process.exit(1), 5000);
+}
+
+process.on('SIGTERM', shutdown);
+process.on('SIGINT', shutdown);
+
+export { app, server };

package/node_modules/moe-training/server/ledger.js

@@ -0,0 +1,110 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import Database from 'better-sqlite3';
+import { mkdirSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+export class ContributorLedger {
+  constructor(dbPath = './data/ledger.db') {
+    const dir = join(dbPath, '..');
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true, mode: 0o700 });
+    this.db = new Database(dbPath);
+    this.db.pragma('journal_mode = WAL');
+    this._createTables();
+  }
+
+  _createTables() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS credits (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        contributor_id TEXT NOT NULL,
+        session_id TEXT NOT NULL,
+        points REAL NOT NULL,
+        base_points INTEGER NOT NULL,
+        multiplier_breakdown TEXT NOT NULL,
+        created_at TEXT NOT NULL
+      )
+    `);
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS balances (
+        contributor_id TEXT PRIMARY KEY,
+        total_points REAL NOT NULL DEFAULT 0,
+        total_sessions INTEGER NOT NULL DEFAULT 0,
+        last_credit_at TEXT,
+        trust_score REAL NOT NULL DEFAULT 1.0
+      )
+    `);
+  }
+
+  credit(contributorId, sessionId, scoreResult) {
+    const now = new Date().toISOString();
+    const breakdown = JSON.stringify({
+      modelMultiplier: scoreResult.modelMultiplier,
+      correctionBonus: scoreResult.correctionBonus,
+      coordinationBonus: scoreResult.coordinationBonus,
+      errorRecoveryBonus: scoreResult.errorRecoveryBonus,
+      complexityBonus: scoreResult.complexityBonus,
+      qualityBonus: scoreResult.qualityBonus,
+    });
+
+    const txn = this.db.transaction(() => {
+      this.db.prepare(`
+        INSERT INTO credits (contributor_id, session_id, points, base_points, multiplier_breakdown, created_at)
+        VALUES (?, ?, ?, ?, ?, ?)
+      `).run(contributorId, sessionId, scoreResult.totalPoints, scoreResult.basePoints, breakdown, now);
+
+      const existing = this.db.prepare('SELECT * FROM balances WHERE contributor_id = ?').get(contributorId);
+      if (existing) {
+        this.db.prepare(`
+          UPDATE balances SET total_points = total_points + ?, total_sessions = total_sessions + 1, last_credit_at = ?
+          WHERE contributor_id = ?
+        `).run(scoreResult.totalPoints, now, contributorId);
+      } else {
+        this.db.prepare(`
+          INSERT INTO balances (contributor_id, total_points, total_sessions, last_credit_at, trust_score)
+          VALUES (?, ?, 1, ?, 1.0)
+        `).run(contributorId, scoreResult.totalPoints, now);
+      }
+    });
+    txn();
+  }
+
+  getBalance(contributorId) {
+    return this.db.prepare('SELECT * FROM balances WHERE contributor_id = ?').get(contributorId) || null;
+  }
+
+  getLeaderboard(limit = 50) {
+    return this.db.prepare('SELECT * FROM balances ORDER BY total_points DESC LIMIT ?').all(limit);
+  }
+
+  getCreditsForContributor(contributorId, limit = 100) {
+    return this.db.prepare(
+      'SELECT * FROM credits WHERE contributor_id = ? ORDER BY created_at DESC LIMIT ?'
+    ).all(contributorId, limit);
+  }
+
+  getDailyCredits(days = 7) {
+    const cutoff = new Date();
+    cutoff.setDate(cutoff.getDate() - days);
+
+    return this.db.prepare(`
+      SELECT DATE(created_at) as date, SUM(points) as totalPoints, COUNT(*) as totalSessions
+      FROM credits WHERE created_at > ? GROUP BY DATE(created_at) ORDER BY date
+    `).all(cutoff.toISOString());
+  }
+
+  adjustTrustScore(contributorId, delta) {
+    this.db.prepare(`
+      UPDATE balances SET trust_score = MAX(0, MIN(10, trust_score + ?)) WHERE contributor_id = ?
+    `).run(delta, contributorId);
+  }
+
+  getTotalPointsAwarded() {
+    const row = this.db.prepare('SELECT COALESCE(SUM(total_points), 0) as total FROM balances').get();
+    return row.total;
+  }
+
+  close() {
+    this.db.close();
+  }
+}