groove-dev 0.27.92 → 0.27.94

package/node_modules/moe-training/server/routes/ingest.js

@@ -0,0 +1,96 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { Router } from 'express';
+import { v4 as uuidv4 } from 'uuid';
+
+const MAX_ENVELOPES_PER_SESSION = 200;
+
+export function createIngestRoutes(verifier, storage, stitcher, scorer, enrichment, ledger, sessionRegistry) {
+  const router = Router();
+
+  router.post('/v1/training/ingest', async (req, res) => {
+    const envelope = req.body;
+
+    if (!envelope || !envelope.session_id) {
+      return res.status(400).json({ accepted: false, reason: 'malformed request: missing envelope or session_id' });
+    }
+
+    if (envelope.type === 'SESSION_CLOSE') {
+      const closeResult = verifier.verifyClose(envelope);
+      if (!closeResult.valid) {
+        return res.json({ accepted: false, reason: closeResult.reason });
+      }
+
+      // Server-generated envelope_id
+      const envelopeId = `env_${uuidv4()}`;
+      envelope.envelope_id = envelopeId;
+
+      // Dedup check
+      if (sessionRegistry.isEnvelopeProcessed(envelopeId)) {
+        return res.json({ accepted: false, reason: 'duplicate envelope' });
+      }
+
+      try {
+        storage.store(envelope);
+      } catch (err) {
+        if (err.message === 'STORAGE_QUOTA_EXCEEDED') {
+          return res.status(507).json({ accepted: false, reason: 'storage quota exceeded' });
+        }
+        throw err;
+      }
+
+      sessionRegistry.recordProcessedEnvelope(envelopeId, envelope.session_id);
+
+      try {
+        const stitched = stitcher.stitch(envelope.session_id);
+        if (stitched) {
+          const enriched = await enrichment.enrich(stitched);
+          const scoreResult = scorer.score(enriched);
+          const contributorId = stitched.contributor_id;
+          if (contributorId) {
+            ledger.credit(contributorId, envelope.session_id, scoreResult);
+          }
+        }
+      } catch (err) {
+        console.error(`[ingest] stitching/scoring error for session ${envelope.session_id}:`, err.message);
+      }
+
+      return res.json({ accepted: true, envelope_id: envelopeId });
+    }
+
+    // Per-session envelope limit
+    if (!sessionRegistry.checkEnvelopeCount(envelope.session_id, MAX_ENVELOPES_PER_SESSION)) {
+      return res.status(429).json({ accepted: false, reason: `session envelope limit exceeded (max ${MAX_ENVELOPES_PER_SESSION})` });
+    }
+
+    const result = verifier.verify(envelope);
+    if (!result.valid) {
+      return res.json({ accepted: false, reason: result.reason });
+    }
+
+    // Server-generated envelope_id
+    const envelopeId = `env_${uuidv4()}`;
+    envelope.envelope_id = envelopeId;
+
+    // Dedup check
+    if (sessionRegistry.isEnvelopeProcessed(envelopeId)) {
+      return res.json({ accepted: false, reason: 'duplicate envelope' });
+    }
+
+    try {
+      storage.store(envelope);
+    } catch (err) {
+      if (err.message === 'STORAGE_QUOTA_EXCEEDED') {
+        return res.status(507).json({ accepted: false, reason: 'storage quota exceeded' });
+      }
+      throw err;
+    }
+
+    sessionRegistry.recordProcessedEnvelope(envelopeId, envelope.session_id);
+    sessionRegistry.incrementEnvelopeCount(envelope.session_id);
+
+    res.json({ accepted: true, envelope_id: envelopeId });
+  });
+
+  return router;
+}

package/node_modules/moe-training/server/routes/sessions.js

@@ -0,0 +1,43 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { Router } from 'express';
+
+export function createSessionRoutes(sessionRegistry) {
+  const router = Router();
+
+  router.post('/v1/sessions/open', (req, res) => {
+    const { session_id, public_key, provider, model, machine_fingerprint, app_version_hash, groove_version } = req.body;
+
+    if (!session_id || !public_key || !provider || !model || !machine_fingerprint || !app_version_hash || !groove_version) {
+      return res.status(400).json({ error: 'missing required fields', required: ['session_id', 'public_key', 'provider', 'model', 'machine_fingerprint', 'app_version_hash', 'groove_version'] });
+    }
+
+    const result = sessionRegistry.openSession(session_id, public_key, provider, model, machine_fingerprint, app_version_hash, groove_version);
+
+    if (result.rateLimited) {
+      return res.status(429).json({ error: 'rate limited: too many sessions from this machine' });
+    }
+
+    res.json({ server_public_key: result.serverPublicKey });
+  });
+
+  router.post('/v1/sessions/close', (req, res) => {
+    const { session_id } = req.body;
+    if (!session_id) {
+      return res.status(400).json({ error: 'missing session_id' });
+    }
+
+    const session = sessionRegistry.getSession(session_id);
+    if (!session) {
+      return res.status(404).json({ error: 'unknown session_id' });
+    }
+    if (session.status === 'closed') {
+      return res.json({ closed: true, already_closed: true });
+    }
+
+    sessionRegistry.closeSession(session_id);
+    res.json({ closed: true });
+  });
+
+  return router;
+}

package/node_modules/moe-training/server/routes/stats.js

@@ -0,0 +1,31 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { Router } from 'express';
+
+export function createStatsRoutes(centralStats) {
+  const router = Router();
+
+  router.get('/v1/stats/summary', (_req, res) => {
+    res.json(centralStats.summary());
+  });
+
+  router.get('/v1/stats/daily', (req, res) => {
+    const days = parseInt(req.query.days, 10) || 7;
+    res.json(centralStats.dailyGrowth(days));
+  });
+
+  router.get('/v1/stats/models', (_req, res) => {
+    res.json(centralStats.modelBreakdown());
+  });
+
+  router.get('/v1/stats/providers', (_req, res) => {
+    res.json(centralStats.providerBreakdown());
+  });
+
+  router.get('/v1/stats/leaderboard', (req, res) => {
+    const limit = parseInt(req.query.limit, 10) || 10;
+    res.json(centralStats.topContributors(limit));
+  });
+
+  return router;
+}

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

@@ -0,0 +1,63 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+export class TrajectoryScorer {
+  constructor(constants) {
+    this.modelTiers = constants.MODEL_TIERS || {};
+    this.multipliers = constants.QUALITY_MULTIPLIERS || {};
+  }
+
+  score(stitchedTrajectory) {
+    const steps = stitchedTrajectory.trajectory_log || [];
+    const metadata = stitchedTrajectory.metadata || {};
+
+    // DERIVE from actual steps — never trust client-reported outcome
+    const correctionSteps = steps.filter(s => s.type === 'correction').length;
+    const coordinationSteps = steps.filter(s => s.type === 'coordination').length;
+    const errorSteps = steps.filter(s => s.type === 'error').length;
+    const resolutionSteps = steps.filter(s => s.type === 'resolution').length;
+    const errorsRecovered = Math.min(errorSteps, resolutionSteps);
+
+    const basePoints = Math.min(steps.length, 5000);
+
+    const modelEngine = metadata.model_engine || '';
+    const modelMultiplier = this.modelTiers[modelEngine] || 1;
+
+    // Correction bonus: 10x on ACTUAL correction steps, capped at 30% of trajectory
+    const maxCorrectionSteps = Math.floor(steps.length * 0.3);
+    const cappedCorrectionSteps = Math.min(correctionSteps, maxCorrectionSteps);
+    const correctionBonus = cappedCorrectionSteps * (this.multipliers.correction || 10);
+
+    // Coordination bonus: 5x on ACTUAL coordination steps, capped at 20% of trajectory
+    const maxCoordSteps = Math.floor(steps.length * 0.2);
+    const cappedCoordSteps = Math.min(coordinationSteps, maxCoordSteps);
+    const coordinationBonus = cappedCoordSteps * (this.multipliers.coordination || 5);
+
+    // Error recovery: 3x if errors AND resolutions exist in the trajectory
+    const errorRecoveryBonus = errorsRecovered > 0 ? Math.min(errorsRecovered, errorSteps) * (this.multipliers.errorRecovery || 3) : 0;
+
+    // Complexity bonus: only if validated value
+    const validComplexity = ['light', 'medium', 'heavy'];
+    const complexityBonus = validComplexity.includes(metadata.task_complexity) && metadata.task_complexity === 'heavy'
+      ? basePoints * 1
+      : 0;
+
+    // Quality bonus: server-derived from trajectory completeness
+    const hasResolution = resolutionSteps > 0;
+    const reasonableLength = steps.length >= 5 && steps.length <= 5000;
+    const subtotal = (basePoints * modelMultiplier) + correctionBonus + coordinationBonus + errorRecoveryBonus + complexityBonus;
+    const qualityBonus = (hasResolution && reasonableLength) ? Math.floor(subtotal * 0.1) : 0;
+
+    const totalPoints = subtotal + qualityBonus;
+
+    return {
+      basePoints,
+      modelMultiplier,
+      correctionBonus,
+      coordinationBonus,
+      errorRecoveryBonus,
+      complexityBonus,
+      qualityBonus,
+      totalPoints,
+    };
+  }
+}

package/node_modules/moe-training/server/session-registry.js

@@ -0,0 +1,156 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import Database from 'better-sqlite3';
+import { mkdirSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { generateECDHKeypair, deriveSharedSecret } from '../shared/crypto.js';
+
+export class SessionRegistry {
+  constructor(dbPath = './data/sessions.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.db.pragma('foreign_keys = ON');
+    this._createTables();
+  }
+
+  _createTables() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS sessions (
+        session_id TEXT PRIMARY KEY,
+        server_private_key TEXT NOT NULL,
+        server_public_key TEXT NOT NULL,
+        shared_secret TEXT NOT NULL,
+        client_public_key TEXT NOT NULL,
+        provider TEXT NOT NULL,
+        model TEXT NOT NULL,
+        machine_fingerprint TEXT NOT NULL,
+        app_version_hash TEXT NOT NULL,
+        groove_version TEXT NOT NULL,
+        expected_sequence INTEGER DEFAULT 0,
+        envelope_count INTEGER DEFAULT 0,
+        status TEXT DEFAULT 'active',
+        created_at TEXT NOT NULL,
+        closed_at TEXT
+      )
+    `);
+
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS processed_envelopes (
+        envelope_id TEXT PRIMARY KEY,
+        session_id TEXT NOT NULL,
+        processed_at TEXT NOT NULL
+      )
+    `);
+
+    // Migration: add envelope_count if table exists but column doesn't
+    try {
+      this.db.prepare('SELECT envelope_count FROM sessions LIMIT 1').get();
+    } catch {
+      try { this.db.exec('ALTER TABLE sessions ADD COLUMN envelope_count INTEGER DEFAULT 0'); } catch { /* already exists */ }
+    }
+  }
+
+  openSession(sessionId, clientPublicKey, provider, model, machineFingerprint, appVersionHash, grooveVersion) {
+    if (this.rateLimitCheck(machineFingerprint)) {
+      return { rateLimited: true };
+    }
+
+    const keypair = generateECDHKeypair();
+    const sharedSecret = deriveSharedSecret(keypair.privateKey, clientPublicKey);
+
+    this.db.prepare(`
+      INSERT INTO sessions (session_id, server_private_key, server_public_key, shared_secret,
+        client_public_key, provider, model, machine_fingerprint, app_version_hash,
+        groove_version, expected_sequence, envelope_count, status, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, 0, 'active', ?)
+    `).run(
+      sessionId, keypair.privateKey, keypair.publicKey, sharedSecret,
+      clientPublicKey, provider, model, machineFingerprint, appVersionHash,
+      grooveVersion, new Date().toISOString()
+    );
+
+    return { serverPublicKey: keypair.publicKey };
+  }
+
+  getSession(sessionId) {
+    return this.db.prepare('SELECT * FROM sessions WHERE session_id = ?').get(sessionId) || null;
+  }
+
+  checkAndIncrementSequence(sessionId, expectedSequence) {
+    const txn = this.db.transaction(() => {
+      const row = this.db.prepare(
+        "SELECT expected_sequence FROM sessions WHERE session_id = ? AND status = 'active'"
+      ).get(sessionId);
+
+      if (!row) {
+        return { valid: false, reason: 'session not found or not active' };
+      }
+
+      if (row.expected_sequence !== expectedSequence) {
+        return { valid: false, reason: `sequence mismatch: expected ${row.expected_sequence}, got ${expectedSequence}` };
+      }
+
+      this.db.prepare(
+        'UPDATE sessions SET expected_sequence = expected_sequence + 1 WHERE session_id = ?'
+      ).run(sessionId);
+
+      return { valid: true };
+    });
+
+    return txn.immediate();
+  }
+
+  incrementSequence(sessionId) {
+    const result = this.db.prepare(`
+      UPDATE sessions SET expected_sequence = expected_sequence + 1
+      WHERE session_id = ? RETURNING expected_sequence
+    `).get(sessionId);
+    return result ? result.expected_sequence : null;
+  }
+
+  checkEnvelopeCount(sessionId, max = 200) {
+    const row = this.db.prepare('SELECT envelope_count FROM sessions WHERE session_id = ?').get(sessionId);
+    if (!row) return false;
+    return row.envelope_count < max;
+  }
+
+  incrementEnvelopeCount(sessionId) {
+    this.db.prepare('UPDATE sessions SET envelope_count = envelope_count + 1 WHERE session_id = ?').run(sessionId);
+  }
+
+  isEnvelopeProcessed(envelopeId) {
+    const row = this.db.prepare('SELECT 1 FROM processed_envelopes WHERE envelope_id = ?').get(envelopeId);
+    return !!row;
+  }
+
+  recordProcessedEnvelope(envelopeId, sessionId) {
+    this.db.prepare(
+      'INSERT OR IGNORE INTO processed_envelopes (envelope_id, session_id, processed_at) VALUES (?, ?, ?)'
+    ).run(envelopeId, sessionId, new Date().toISOString());
+  }
+
+  closeSession(sessionId) {
+    this.db.prepare(`
+      UPDATE sessions SET status = 'closed', closed_at = ? WHERE session_id = ?
+    `).run(new Date().toISOString(), sessionId);
+  }
+
+  getActiveSessions() {
+    return this.db.prepare("SELECT * FROM sessions WHERE status = 'active'").all();
+  }
+
+  rateLimitCheck(machineFingerprint) {
+    const oneHourAgo = new Date(Date.now() - 3600_000).toISOString();
+    const row = this.db.prepare(`
+      SELECT COUNT(*) as cnt FROM sessions
+      WHERE machine_fingerprint = ? AND created_at > ?
+    `).get(machineFingerprint, oneHourAgo);
+    return row.cnt >= 20;
+  }
+
+  close() {
+    this.db.close();
+  }
+}

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

@@ -0,0 +1,129 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { readFileSync, statSync } from 'node:fs';
+
+const MAX_FILE_SIZE = 100 * 1024 * 1024; // 100MB
+const MAX_LINES_PER_FILE = 100_000;
+
+export class CentralStats {
+  constructor(storage, ledger, sessionRegistry) {
+    this.storage = storage;
+    this.ledger = ledger;
+    this.sessionRegistry = sessionRegistry;
+  }
+
+  summary() {
+    const storageStats = this.storage.getTotalStats();
+    const activeSessions = this.sessionRegistry.getActiveSessions().length;
+    const totalPointsAwarded = this.ledger.getTotalPointsAwarded();
+
+    return {
+      totalEnvelopes: storageStats.totalEnvelopes,
+      totalSteps: storageStats.totalSteps,
+      totalSessions: storageStats.uniqueSessions,
+      activeSessions,
+      uniqueContributors: storageStats.uniqueContributors,
+      storageSizeMb: storageStats.storageSizeMb,
+      totalPointsAwarded,
+    };
+  }
+
+  dailyGrowth(days = 7) {
+    days = Math.max(1, Math.min(365, Number(days) || 7));
+    const storageDaily = this.storage.getDailyStats(days);
+    const creditDaily = this.ledger.getDailyCredits(days);
+
+    const creditMap = {};
+    for (const c of creditDaily) {
+      creditMap[c.date] = { points: c.totalPoints, sessions: c.totalSessions };
+    }
+
+    return storageDaily.map(d => ({
+      date: d.date,
+      envelopes: d.envelopeCount,
+      steps: d.stepCount,
+      sessions: creditMap[d.date]?.sessions || 0,
+      points: creditMap[d.date]?.points || 0,
+    }));
+  }
+
+  modelBreakdown() {
+    const files = this.storage._listFiles();
+    const models = {};
+
+    for (const file of files) {
+      try {
+        const stat = statSync(file);
+        if (stat.size > MAX_FILE_SIZE) continue;
+      } catch { continue; }
+
+      try {
+        const lines = readFileSync(file, 'utf-8').split('\n').filter(Boolean);
+        const capped = lines.slice(0, MAX_LINES_PER_FILE);
+        for (const line of capped) {
+          try {
+            const env = JSON.parse(line);
+            const model = env.metadata?.model_engine || 'unknown';
+            if (!models[model]) models[model] = { sessions: new Set(), steps: 0, points: 0 };
+            models[model].sessions.add(env.session_id);
+            models[model].steps += env.trajectory_log?.length || 0;
+          } catch { /* skip */ }
+        }
+      } catch { /* skip file */ }
+    }
+
+    const total = Object.values(models).reduce((sum, m) => sum + m.steps, 0) || 1;
+    const result = {};
+    for (const [model, data] of Object.entries(models)) {
+      result[model] = {
+        sessions: data.sessions.size,
+        steps: data.steps,
+        points: data.points,
+        percentage: +((data.steps / total) * 100).toFixed(1),
+      };
+    }
+    return result;
+  }
+
+  providerBreakdown() {
+    const files = this.storage._listFiles();
+    const providers = {};
+
+    for (const file of files) {
+      try {
+        const stat = statSync(file);
+        if (stat.size > MAX_FILE_SIZE) continue;
+      } catch { continue; }
+
+      try {
+        const lines = readFileSync(file, 'utf-8').split('\n').filter(Boolean);
+        const capped = lines.slice(0, MAX_LINES_PER_FILE);
+        for (const line of capped) {
+          try {
+            const env = JSON.parse(line);
+            const provider = env.metadata?.provider || 'unknown';
+            if (!providers[provider]) providers[provider] = { sessions: new Set(), steps: 0, points: 0 };
+            providers[provider].sessions.add(env.session_id);
+            providers[provider].steps += env.trajectory_log?.length || 0;
+          } catch { /* skip */ }
+        }
+      } catch { /* skip file */ }
+    }
+
+    const result = {};
+    for (const [provider, data] of Object.entries(providers)) {
+      result[provider] = { sessions: data.sessions.size, steps: data.steps, points: data.points };
+    }
+    return result;
+  }
+
+  topContributors(limit = 10) {
+    limit = Math.max(1, Math.min(1000, Number(limit) || 10));
+    const leaders = this.ledger.getLeaderboard(limit);
+    return leaders.map(l => ({
+      contributor_id: l.contributor_id.slice(0, 8) + '...',
+      total_points: l.total_points,
+      total_sessions: l.total_sessions,
+    }));
+  }
+}

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

@@ -0,0 +1,69 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+export class TrajectoryStitcher {
+  constructor(storage) {
+    this.storage = storage;
+  }
+
+  stitch(sessionId) {
+    const envelopes = this.storage.getSessionEnvelopes(sessionId);
+    if (!envelopes.length) return null;
+
+    const chunks = envelopes
+      .filter(e => e.type !== 'SESSION_CLOSE')
+      .sort((a, b) => (a.chunk_sequence ?? 0) - (b.chunk_sequence ?? 0));
+
+    const closeEnvelope = envelopes.find(e => e.type === 'SESSION_CLOSE');
+    const firstChunk = chunks[0];
+    if (!firstChunk) return null;
+
+    const allSteps = [];
+    for (const chunk of chunks) {
+      if (Array.isArray(chunk.trajectory_log)) {
+        allSteps.push(...chunk.trajectory_log);
+      }
+    }
+
+    allSteps.sort((a, b) => a.step - b.step);
+
+    const toolsUsed = new Set();
+    const stepTypeCounts = {};
+    let totalTokens = 0;
+
+    for (const step of allSteps) {
+      if (step.tool) toolsUsed.add(step.tool);
+      stepTypeCounts[step.type] = (stepTypeCounts[step.type] || 0) + 1;
+      totalTokens += step.token_count || 0;
+    }
+
+    return {
+      session_id: sessionId,
+      contributor_id: firstChunk.contributor_id,
+      metadata: firstChunk.metadata || {},
+      trajectory_log: allSteps,
+      outcome: closeEnvelope?.outcome || null,
+      total_steps: allSteps.length,
+      total_tokens: totalTokens,
+      unique_tools_used: [...toolsUsed],
+      step_type_distribution: stepTypeCounts,
+      total_chunks: chunks.length,
+    };
+  }
+
+  linkCoordination(trajectory) {
+    if (!trajectory || !trajectory.trajectory_log) return trajectory;
+
+    const coordSteps = trajectory.trajectory_log.filter(s => s.type === 'coordination' && s.coordination_id);
+
+    for (const step of coordSteps) {
+      step.coordination_partner = {
+        coordination_id: step.coordination_id,
+        direction: step.direction,
+        target_agent: step.target_agent || null,
+        linked: true,
+      };
+    }
+
+    return trajectory;
+  }
+}