groove-dev 0.27.93 → 0.27.96

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

@@ -0,0 +1,147 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { mkdirSync, appendFileSync, readFileSync, readdirSync, statSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+const QUOTA_BYTES = 50 * 1024 * 1024 * 1024; // 50GB
+const WARN_BYTES = 40 * 1024 * 1024 * 1024;  // 40GB
+
+export class EnvelopeStorage {
+  constructor(basePath = './data/envelopes') {
+    this.basePath = basePath;
+    if (!existsSync(basePath)) mkdirSync(basePath, { recursive: true, mode: 0o700 });
+  }
+
+  checkQuota() {
+    const files = this._listFiles();
+    let total = 0;
+    for (const file of files) {
+      try { total += statSync(file).size; } catch { /* skip */ }
+    }
+    if (total > WARN_BYTES && total <= QUOTA_BYTES) {
+      console.warn(`[storage] WARNING: storage at ${(total / (1024 * 1024 * 1024)).toFixed(1)}GB, approaching 50GB quota`);
+    }
+    return total < QUOTA_BYTES;
+  }
+
+  store(envelope) {
+    if (!this.checkQuota()) {
+      throw new Error('STORAGE_QUOTA_EXCEEDED');
+    }
+
+    const date = new Date().toISOString().slice(0, 10);
+    const filePath = join(this.basePath, `${date}.jsonl`);
+
+    if (!existsSync(this.basePath)) {
+      mkdirSync(this.basePath, { recursive: true, mode: 0o700 });
+    }
+
+    const line = JSON.stringify(envelope) + '\n';
+    appendFileSync(filePath, line, { mode: 0o600 });
+  }
+
+  getSessionEnvelopes(sessionId) {
+    const envelopes = [];
+    const files = this._listFiles();
+
+    for (const file of files) {
+      const lines = readFileSync(file, 'utf-8').split('\n').filter(Boolean);
+      for (const line of lines) {
+        try {
+          const env = JSON.parse(line);
+          if (env.session_id === sessionId) envelopes.push(env);
+        } catch { /* skip malformed lines */ }
+      }
+    }
+
+    return envelopes.sort((a, b) => (a.chunk_sequence ?? 0) - (b.chunk_sequence ?? 0));
+  }
+
+  getDateRange(startDate, endDate) {
+    const envelopes = [];
+    const files = this._listFiles();
+
+    for (const file of files) {
+      const fileName = file.split('/').pop().replace('.jsonl', '');
+      if (fileName < startDate || fileName > endDate) continue;
+
+      const lines = readFileSync(file, 'utf-8').split('\n').filter(Boolean);
+      for (const line of lines) {
+        try {
+          envelopes.push(JSON.parse(line));
+        } catch { /* skip */ }
+      }
+    }
+
+    return envelopes;
+  }
+
+  getDailyStats(days = 7) {
+    const stats = [];
+    const files = this._listFiles();
+
+    const cutoff = new Date();
+    cutoff.setDate(cutoff.getDate() - days);
+    const cutoffStr = cutoff.toISOString().slice(0, 10);
+
+    for (const file of files) {
+      const date = file.split('/').pop().replace('.jsonl', '');
+      if (date < cutoffStr) continue;
+
+      const lines = readFileSync(file, 'utf-8').split('\n').filter(Boolean);
+      let stepCount = 0;
+      for (const line of lines) {
+        try {
+          const env = JSON.parse(line);
+          stepCount += env.trajectory_log?.length ?? 0;
+        } catch { /* skip */ }
+      }
+
+      stats.push({ date, envelopeCount: lines.length, stepCount });
+    }
+
+    return stats.sort((a, b) => a.date.localeCompare(b.date));
+  }
+
+  getTotalStats() {
+    const files = this._listFiles();
+    let totalEnvelopes = 0;
+    let totalSteps = 0;
+    let storageSizeBytes = 0;
+    const contributors = new Set();
+    const sessions = new Set();
+
+    for (const file of files) {
+      const stat = statSync(file);
+      storageSizeBytes += stat.size;
+
+      const lines = readFileSync(file, 'utf-8').split('\n').filter(Boolean);
+      totalEnvelopes += lines.length;
+
+      for (const line of lines) {
+        try {
+          const env = JSON.parse(line);
+          totalSteps += env.trajectory_log?.length ?? 0;
+          if (env.contributor_id) contributors.add(env.contributor_id);
+          if (env.session_id) sessions.add(env.session_id);
+        } catch { /* skip */ }
+      }
+    }
+
+    return {
+      totalEnvelopes,
+      totalSteps,
+      storageSizeMb: +(storageSizeBytes / 1_048_576).toFixed(2),
+      uniqueContributors: contributors.size,
+      uniqueSessions: sessions.size,
+    };
+  }
+
+  _listFiles() {
+    if (!existsSync(this.basePath)) return [];
+    return readdirSync(this.basePath)
+      .filter(f => f.endsWith('.jsonl'))
+      .map(f => join(this.basePath, f))
+      .sort();
+  }
+}

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

@@ -0,0 +1,102 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { verifyEnvelope } from '../shared/crypto.js';
+
+let validateEnvelope;
+try {
+  const schema = await import('../shared/envelope-schema.js');
+  validateEnvelope = schema.validateEnvelope;
+} catch {
+  validateEnvelope = () => ({ valid: true });
+}
+
+export class EnvelopeVerifier {
+  constructor(sessionRegistry) {
+    this.sessionRegistry = sessionRegistry;
+  }
+
+  verify(envelope) {
+    const sessionId = envelope.session_id;
+    if (!sessionId) return { valid: false, reason: 'missing session_id' };
+
+    const session = this.sessionRegistry.getSession(sessionId);
+    if (!session) return { valid: false, reason: 'unknown session_id' };
+    if (session.status !== 'active') return { valid: false, reason: 'session is closed' };
+
+    const attestation = envelope.attestation;
+    if (!attestation) return { valid: false, reason: 'missing attestation' };
+
+    if (!attestation.session_hmac || typeof attestation.session_hmac !== 'string' || attestation.session_hmac.length === 0) {
+      return { valid: false, reason: 'empty or missing HMAC' };
+    }
+
+    // HMAC covers the entire envelope EXCEPT the attestation block
+    const envelopeForHmac = { ...envelope };
+    delete envelopeForHmac.attestation;
+    const envelopeBytes = JSON.stringify(envelopeForHmac);
+
+    const hmacValid = verifyEnvelope(
+      session.shared_secret,
+      envelopeBytes,
+      attestation.sequence,
+      attestation.session_hmac
+    );
+    if (!hmacValid) return { valid: false, reason: 'HMAC verification failed' };
+
+    // Atomic sequence check + increment (prevents race conditions)
+    const seqResult = this.sessionRegistry.checkAndIncrementSequence(sessionId, attestation.sequence);
+    if (!seqResult.valid) {
+      return { valid: false, reason: seqResult.reason };
+    }
+
+    const schemaResult = validateEnvelope(envelope);
+    if (!schemaResult.valid) {
+      return { valid: false, reason: `schema validation failed: ${schemaResult.reason || schemaResult.errors?.join(', ')}` };
+    }
+
+    return { valid: true };
+  }
+
+  verifyClose(envelope) {
+    const sessionId = envelope.session_id;
+    if (!sessionId) return { valid: false, reason: 'missing session_id' };
+
+    const session = this.sessionRegistry.getSession(sessionId);
+    if (!session) return { valid: false, reason: 'unknown session_id' };
+    if (session.status !== 'active') return { valid: false, reason: 'session already closed' };
+
+    const attestation = envelope.attestation;
+    if (!attestation) return { valid: false, reason: 'missing attestation' };
+
+    if (!attestation.session_hmac || typeof attestation.session_hmac !== 'string' || attestation.session_hmac.length === 0) {
+      return { valid: false, reason: 'empty or missing HMAC' };
+    }
+
+    // HMAC covers the entire envelope EXCEPT the attestation block
+    const envelopeForHmac = { ...envelope };
+    delete envelopeForHmac.attestation;
+    const envelopeBytes = JSON.stringify(envelopeForHmac);
+
+    const hmacValid = verifyEnvelope(
+      session.shared_secret,
+      envelopeBytes,
+      attestation.sequence,
+      attestation.session_hmac
+    );
+    if (!hmacValid) return { valid: false, reason: 'HMAC verification failed' };
+
+    // Sequence check for close envelopes too
+    const seqResult = this.sessionRegistry.checkAndIncrementSequence(sessionId, attestation.sequence);
+    if (!seqResult.valid) {
+      return { valid: false, reason: seqResult.reason };
+    }
+
+    const schemaResult = validateEnvelope(envelope);
+    if (!schemaResult.valid) {
+      return { valid: false, reason: `schema validation failed: ${schemaResult.reason || schemaResult.errors?.join(', ')}` };
+    }
+
+    this.sessionRegistry.closeSession(sessionId);
+    return { valid: true };
+  }
+}

package/node_modules/moe-training/shared/constants.js

@@ -0,0 +1,30 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+export const CURRENT_CONSENT_VERSION = '1.0';
+export const CHUNK_SIZE = 200;
+export const CHUNK_TIMEOUT_MS = 300_000;
+export const MAX_QUEUE_SIZE = 10_000;
+export const OBSERVATION_TRUNCATE_HEAD = 50;
+export const OBSERVATION_TRUNCATE_TAIL = 20;
+export const SUPPORTED_PROVIDERS = ['claude-code', 'codex', 'gemini'];
+
+export const MODEL_TIERS = {
+  'claude-opus-4-6': 5,
+  'claude-opus-4-7': 5,
+  'claude-sonnet-4-6': 3,
+  'gpt-4.5': 5,
+  'o3': 5,
+  'o4-mini': 2,
+  'gemini-2.5-pro': 3,
+  'gemini-2.5-flash': 1.5,
+};
+
+export const QUALITY_MULTIPLIERS = {
+  correction: 10,
+  coordination: 5,
+  errorRecovery: 3,
+  heavyTask: 2,
+  highQuality: 1.5,
+};
+
+export const CENTRAL_COMMAND_URL = process.env.GROOVE_CENTRAL_URL || 'https://api.groovedev.ai';

package/node_modules/moe-training/shared/crypto.js

@@ -0,0 +1,45 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { createECDH, createHmac, createHash, randomBytes } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+
+export function generateECDHKeypair() {
+  const ecdh = createECDH('prime256v1');
+  ecdh.generateKeys();
+  return {
+    publicKey: ecdh.getPublicKey('base64'),
+    privateKey: ecdh.getPrivateKey('base64'),
+  };
+}
+
+export function deriveSharedSecret(privateKeyB64, otherPublicKeyB64) {
+  const ecdh = createECDH('prime256v1');
+  ecdh.setPrivateKey(Buffer.from(privateKeyB64, 'base64'));
+  const secret = ecdh.computeSecret(Buffer.from(otherPublicKeyB64, 'base64'));
+  return secret.toString('base64');
+}
+
+// envelopeBytes MUST contain ALL envelope fields EXCEPT attestation (which holds the HMAC itself).
+// Callers must strip attestation before JSON.stringify to produce envelopeBytes.
+export function signEnvelope(sharedSecretB64, envelopeBytes, sequenceNumber) {
+  const key = Buffer.from(sharedSecretB64, 'base64');
+  const seqBuf = Buffer.alloc(4);
+  seqBuf.writeUInt32BE(sequenceNumber);
+  const payload = Buffer.concat([seqBuf, Buffer.from(envelopeBytes)]);
+  return createHmac('sha256', key).update(payload).digest('hex');
+}
+
+export function verifyEnvelope(sharedSecretB64, envelopeBytes, sequenceNumber, hmac) {
+  const expected = signEnvelope(sharedSecretB64, envelopeBytes, sequenceNumber);
+  if (expected.length !== hmac.length) return false;
+  let diff = 0;
+  for (let i = 0; i < expected.length; i++) {
+    diff |= expected.charCodeAt(i) ^ hmac.charCodeAt(i);
+  }
+  return diff === 0;
+}
+
+export function computeAppHash(filePath) {
+  const content = readFileSync(filePath);
+  return createHash('sha256').update(content).digest('hex');
+}

package/node_modules/moe-training/shared/envelope-schema.js

@@ -0,0 +1,220 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { SUPPORTED_PROVIDERS, MODEL_TIERS } from './constants.js';
+
+export const STEP_TYPES = ['thought', 'action', 'observation', 'correction', 'resolution', 'error', 'coordination'];
+
+const VALID_MODEL_ENGINES = Object.keys(MODEL_TIERS);
+const VALID_COMPLEXITIES = ['light', 'medium', 'heavy'];
+const VALID_OUTCOME_STATUSES = ['SUCCESS', 'CRASH', 'KILLED'];
+const MAX_STEPS_PER_ENVELOPE = 500;
+const MAX_STEP_CONTENT_LENGTH = 10_000;
+const MAX_TOKEN_COUNT = 100_000;
+const MAX_STEP_NUMBER = 50_000;
+const SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1000;
+const ONE_HOUR_MS = 60 * 60 * 1000;
+const HEX_32 = /^[0-9a-f]{32}$/;
+const HEX_64 = /^[0-9a-f]{64}$/;
+const MAX_OUTCOME_NUMERIC = 50_000;
+
+export class EnvelopeBuilder {
+  constructor() {
+    this._steps = [];
+  }
+
+  addStep(step) {
+    this._steps.push(step);
+    return this;
+  }
+
+  build(envelopeId, sessionId, chunkSequence, contributorId, metadata) {
+    return {
+      envelope_id: envelopeId,
+      session_id: sessionId,
+      chunk_sequence: chunkSequence,
+      contributor_id: contributorId,
+      attestation: { session_hmac: '', sequence: 0, app_version_hash: '' },
+      metadata,
+      trajectory_log: [...this._steps],
+    };
+  }
+
+  static buildSessionClose(envelopeId, sessionId, outcome) {
+    return {
+      envelope_id: envelopeId,
+      session_id: sessionId,
+      type: 'SESSION_CLOSE',
+      attestation: { session_hmac: '', sequence: 0, app_version_hash: '' },
+      outcome,
+    };
+  }
+}
+
+export function validateEnvelope(envelope) {
+  const errors = [];
+
+  if (!envelope) {
+    return { valid: false, errors: ['Envelope is null or undefined'] };
+  }
+
+  if (envelope.type === 'SESSION_CLOSE') {
+    return validateSessionClose(envelope);
+  }
+
+  if (!envelope.session_id || typeof envelope.session_id !== 'string') {
+    errors.push('Missing or invalid session_id');
+  }
+  if (typeof envelope.chunk_sequence !== 'number') {
+    errors.push('Missing or invalid chunk_sequence');
+  }
+
+  // contributor_id: must be 32-char hex (UUID without dashes)
+  if (!envelope.contributor_id || typeof envelope.contributor_id !== 'string') {
+    errors.push('Missing or invalid contributor_id');
+  } else if (!HEX_32.test(envelope.contributor_id)) {
+    errors.push('contributor_id must be a 32-character hex string');
+  }
+
+  // Attestation validation
+  if (!envelope.attestation || typeof envelope.attestation !== 'object') {
+    errors.push('Missing attestation');
+  } else {
+    if (typeof envelope.attestation.session_hmac !== 'string' || !HEX_64.test(envelope.attestation.session_hmac)) {
+      errors.push('attestation.session_hmac must be exactly 64 hex characters');
+    }
+    if (typeof envelope.attestation.sequence !== 'number' || !Number.isInteger(envelope.attestation.sequence) || envelope.attestation.sequence < 0 || envelope.attestation.sequence > 1_000_000) {
+      errors.push('attestation.sequence must be a non-negative integer, max 1000000');
+    }
+    if (typeof envelope.attestation.app_version_hash !== 'string' || !HEX_64.test(envelope.attestation.app_version_hash)) {
+      errors.push('attestation.app_version_hash must be exactly 64 hex characters');
+    }
+  }
+
+  // Metadata validation
+  if (!envelope.metadata || typeof envelope.metadata !== 'object') {
+    errors.push('Missing metadata');
+  } else {
+    const m = envelope.metadata;
+    if (!m.provider || !SUPPORTED_PROVIDERS.includes(m.provider)) {
+      errors.push(`metadata.provider must be one of: ${SUPPORTED_PROVIDERS.join(', ')}`);
+    }
+    if (!m.model_engine || !VALID_MODEL_ENGINES.includes(m.model_engine)) {
+      errors.push(`metadata.model_engine must be one of: ${VALID_MODEL_ENGINES.join(', ')}`);
+    }
+    if (!m.agent_role || typeof m.agent_role !== 'string' || m.agent_role.length > 50) {
+      errors.push('metadata.agent_role must be a string, max 50 characters');
+    }
+    if (!m.agent_id || typeof m.agent_id !== 'string' || m.agent_id.length > 100) {
+      errors.push('metadata.agent_id must be a string, max 100 characters');
+    }
+    if (m.team_size !== undefined && m.team_size !== null) {
+      if (!Number.isInteger(m.team_size) || m.team_size < 1 || m.team_size > 50) {
+        errors.push('metadata.team_size must be an integer 1-50');
+      }
+    }
+    if (m.task_complexity !== undefined && m.task_complexity !== null) {
+      if (!VALID_COMPLEXITIES.includes(m.task_complexity)) {
+        errors.push('metadata.task_complexity must be light, medium, or heavy');
+      }
+    }
+    if (m.groove_version !== undefined && m.groove_version !== null) {
+      if (typeof m.groove_version !== 'string' || m.groove_version.length > 20) {
+        errors.push('metadata.groove_version must be a string, max 20 characters');
+      }
+    }
+    // session_quality is ignored from client — server derives quality
+  }
+
+  // Trajectory log validation
+  if (!Array.isArray(envelope.trajectory_log)) {
+    errors.push('Missing or invalid trajectory_log');
+  } else {
+    if (envelope.trajectory_log.length > MAX_STEPS_PER_ENVELOPE) {
+      errors.push(`trajectory_log exceeds maximum of ${MAX_STEPS_PER_ENVELOPE} steps (got ${envelope.trajectory_log.length})`);
+    }
+
+    const now = Date.now();
+    const sevenDaysAgo = now - SEVEN_DAYS_MS;
+    const futureLimit = now + ONE_HOUR_MS;
+
+    for (let i = 0; i < Math.min(envelope.trajectory_log.length, MAX_STEPS_PER_ENVELOPE); i++) {
+      const step = envelope.trajectory_log[i];
+      if (!STEP_TYPES.includes(step.type)) {
+        errors.push(`Invalid step type "${step.type}" at index ${i}`);
+      }
+      if (typeof step.step !== 'number' || !Number.isInteger(step.step) || step.step < 0 || step.step > MAX_STEP_NUMBER) {
+        errors.push(`step.step must be a non-negative integer, max ${MAX_STEP_NUMBER} at index ${i}`);
+      }
+      if (typeof step.timestamp !== 'number') {
+        errors.push(`Missing timestamp at index ${i}`);
+      } else {
+        const tsMs = step.timestamp < 1e12 ? step.timestamp * 1000 : step.timestamp;
+        if (tsMs < sevenDaysAgo || tsMs > futureLimit) {
+          errors.push(`Timestamp out of range at index ${i} (must be within last 7 days, max 1 hour in future)`);
+        }
+      }
+      if (step.content !== undefined && typeof step.content === 'string' && step.content.length > MAX_STEP_CONTENT_LENGTH) {
+        errors.push(`step.content exceeds ${MAX_STEP_CONTENT_LENGTH} characters at index ${i}`);
+      }
+      if (step.token_count !== undefined) {
+        if (typeof step.token_count !== 'number' || step.token_count < 0 || step.token_count > MAX_TOKEN_COUNT) {
+          errors.push(`step.token_count must be 0-${MAX_TOKEN_COUNT} at index ${i}`);
+        }
+      }
+    }
+  }
+
+  return { valid: errors.length === 0, errors };
+}
+
+function validateSessionClose(envelope) {
+  const errors = [];
+
+  if (!envelope.session_id || typeof envelope.session_id !== 'string') {
+    errors.push('Missing or invalid session_id');
+  }
+  if (envelope.type !== 'SESSION_CLOSE') {
+    errors.push('Invalid type for SESSION_CLOSE envelope');
+  }
+
+  // Attestation validation
+  if (!envelope.attestation || typeof envelope.attestation !== 'object') {
+    errors.push('Missing attestation');
+  } else {
+    if (typeof envelope.attestation.session_hmac !== 'string' || !HEX_64.test(envelope.attestation.session_hmac)) {
+      errors.push('attestation.session_hmac must be exactly 64 hex characters');
+    }
+    if (typeof envelope.attestation.sequence !== 'number' || !Number.isInteger(envelope.attestation.sequence) || envelope.attestation.sequence < 0 || envelope.attestation.sequence > 1_000_000) {
+      errors.push('attestation.sequence must be a non-negative integer, max 1000000');
+    }
+    if (typeof envelope.attestation.app_version_hash !== 'string' || !HEX_64.test(envelope.attestation.app_version_hash)) {
+      errors.push('attestation.app_version_hash must be exactly 64 hex characters');
+    }
+  }
+
+  // Outcome validation
+  if (!envelope.outcome || typeof envelope.outcome !== 'object') {
+    errors.push('Missing outcome');
+  } else {
+    if (!VALID_OUTCOME_STATUSES.includes(envelope.outcome.status)) {
+      errors.push(`outcome.status must be one of: ${VALID_OUTCOME_STATUSES.join(', ')}`);
+    }
+    if (typeof envelope.outcome.total_steps !== 'number' || !Number.isInteger(envelope.outcome.total_steps) || envelope.outcome.total_steps < 0 || envelope.outcome.total_steps > MAX_OUTCOME_NUMERIC) {
+      errors.push('Missing or invalid outcome.total_steps');
+    }
+    if (typeof envelope.outcome.total_chunks !== 'number' || !Number.isInteger(envelope.outcome.total_chunks) || envelope.outcome.total_chunks < 0 || envelope.outcome.total_chunks > MAX_OUTCOME_NUMERIC) {
+      errors.push('Missing or invalid outcome.total_chunks');
+    }
+    const numericFields = ['user_interventions', 'total_tokens', 'duration_seconds', 'files_modified', 'errors_encountered', 'errors_recovered', 'coordination_events'];
+    for (const field of numericFields) {
+      if (envelope.outcome[field] !== undefined) {
+        const v = envelope.outcome[field];
+        if (typeof v !== 'number' || !Number.isInteger(v) || v < 0 || v > MAX_OUTCOME_NUMERIC) {
+          errors.push(`outcome.${field} must be a non-negative integer, max ${MAX_OUTCOME_NUMERIC}`);
+        }
+      }
+    }
+  }
+
+  return { valid: errors.length === 0, errors };
+}

package/node_modules/moe-training/test/client/consent.test.js

@@ -0,0 +1,121 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync, existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { ConsentManager } from '../../client/consent.js';
+
+describe('ConsentManager', () => {
+  let tmpDir, dbPath, manager;
+
+  beforeEach(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), 'consent-test-'));
+    dbPath = join(tmpDir, 'consent.db');
+    manager = new ConsentManager(dbPath);
+  });
+
+  afterEach(() => {
+    manager.close();
+    rmSync(tmpDir, { recursive: true });
+  });
+
+  it('opt in then isOptedIn returns true', () => {
+    manager.recordConsent('user1', true, '1.0');
+    assert.equal(manager.isOptedIn('user1'), true);
+  });
+
+  it('opt out then isOptedIn returns false', () => {
+    manager.recordConsent('user1', true, '1.0');
+    manager.revokeConsent('user1');
+    assert.equal(manager.isOptedIn('user1'), false);
+  });
+
+  it('no consent record returns false', () => {
+    assert.equal(manager.isOptedIn('nonexistent'), false);
+  });
+
+  it('version mismatch returns false', () => {
+    manager.recordConsent('user1', true, '0.9');
+    assert.equal(manager.isOptedIn('user1'), false);
+  });
+
+  it('getOptedInCount counts correctly', () => {
+    manager.recordConsent('user1', true, '1.0');
+    manager.recordConsent('user2', true, '1.0');
+    manager.recordConsent('user3', false, '1.0');
+    assert.equal(manager.getOptedInCount(), 2);
+  });
+
+  it('getConsentHistory returns all records', () => {
+    manager.recordConsent('user1', true, '1.0', { source: 'ui' });
+    manager.revokeConsent('user1');
+    const history = manager.getConsentHistory('user1');
+    assert.equal(history.length, 2);
+    assert.equal(history[0].opted_in, true);
+    assert.deepEqual(history[0].metadata, { source: 'ui' });
+    assert.equal(history[1].opted_in, false);
+  });
+});
+
+describe('ConsentManager.getOrCreateUserId', () => {
+  let tmpDir, userIdPath;
+
+  beforeEach(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), 'userid-test-'));
+    userIdPath = join(tmpDir, 'user_id');
+  });
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true });
+  });
+
+  it('creates user_id file and returns id', () => {
+    const id = ConsentManager.getOrCreateUserId(userIdPath);
+    assert.ok(id.length > 0);
+    assert.ok(existsSync(userIdPath));
+  });
+
+  it('returns same id on second call', () => {
+    const id1 = ConsentManager.getOrCreateUserId(userIdPath);
+    const id2 = ConsentManager.getOrCreateUserId(userIdPath);
+    assert.equal(id1, id2);
+  });
+});
+
+describe('ConsentManager.isCaptureEnabled', () => {
+  let tmpDir;
+
+  beforeEach(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), 'capture-test-'));
+  });
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true });
+  });
+
+  it('returns false when no user_id file exists', () => {
+    const result = ConsentManager.isCaptureEnabled(join(tmpDir, 'no_file'), join(tmpDir, 'c.db'));
+    assert.equal(result, false);
+  });
+
+  it('returns false when user not opted in', () => {
+    const uidPath = join(tmpDir, 'user_id');
+    const uid = ConsentManager.getOrCreateUserId(uidPath);
+    const dbPath = join(tmpDir, 'consent.db');
+    const result = ConsentManager.isCaptureEnabled(uidPath, dbPath);
+    assert.equal(result, false);
+  });
+
+  it('returns true when user is opted in', () => {
+    const uidPath = join(tmpDir, 'user_id');
+    const uid = ConsentManager.getOrCreateUserId(uidPath);
+    const dbPath = join(tmpDir, 'consent.db');
+    const mgr = new ConsentManager(dbPath);
+    mgr.recordConsent(uid, true, '1.0');
+    mgr.close();
+    const result = ConsentManager.isCaptureEnabled(uidPath, dbPath);
+    assert.equal(result, true);
+  });
+});