groove-dev 0.27.102 → 0.27.103

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

@@ -8,7 +8,16 @@ 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';
+import {
+  CHUNK_TIMEOUT_MS,
+  CENTRAL_COMMAND_URL,
+  TIER_A_MIN_QUALITY,
+  TIER_B_MIN_QUALITY,
+  TRAINING_MIN_STEPS,
+  TRAINING_MIN_TOKENS,
+  TRAINING_MIN_DURATION,
+  TRAINING_EXCLUSION_REASONS,
+} from '../shared/constants.js';
 
 const OFFLINE_RETRY_INTERVAL_MS = 60_000;
 
@@ -56,6 +65,7 @@ export class TrajectoryCapture {
       team_size: teamSize || 1,
       session_quality: 0,
       groove_version: this._grooveVersion,
+      leaf_context: null,
     };
 
     const builder = new EnvelopeBuilder(sessionId, contributorId, metadata);
@@ -78,6 +88,7 @@ export class TrajectoryCapture {
       startTime,
       chunkTimer: null,
       allSteps: [],
+      revisionRounds: 0,
     };
 
     ctx.chunkTimer = setInterval(() => {
@@ -126,6 +137,8 @@ export class TrajectoryCapture {
     const ctx = this._contexts.get(agentId);
     if (!ctx) return;
 
+    ctx.revisionRounds++;
+
     const classified = ctx.classifier.classifyUserMessage(text);
     if (!classified) return;
 
@@ -238,22 +251,34 @@ export class TrajectoryCapture {
 
     ctx.metadata.session_quality = this._computeQuality(ctx);
 
+    const userInterventions = StepClassifier.countUserInterventions(ctx.allSteps);
+    const durationSeconds = Math.round((Date.now() - ctx.startTime) / 1000);
+
+    const { tier, reason: tierReason } = this._computeQualityTier(ctx, status, userInterventions);
+    const { eligible, exclusionReason } = this._computeTrainingEligibility(ctx, durationSeconds);
+
     const closeEnvelope = ctx.builder.buildSessionClose({
       status,
       session_quality: ctx.metadata.session_quality,
-      user_interventions: StepClassifier.countUserInterventions(ctx.allSteps),
+      quality_tier: tier,
+      quality_tier_reason: tierReason,
+      user_interventions: userInterventions,
       total_steps: ctx.stepCount,
       total_chunks: ctx.chunkCount,
       total_tokens: ctx.totalTokens,
-      duration_seconds: Math.round((Date.now() - ctx.startTime) / 1000),
+      duration_seconds: durationSeconds,
       files_modified: extra?.files_modified || ctx.filesModified,
       errors_encountered: ctx.errorsEncountered,
       errors_recovered: ctx.errorsRecovered,
       coordination_events: ctx.coordinationEvents,
+      training_eligible: eligible,
+      training_exclusion_reason: exclusionReason,
     });
 
     this._signAndTransmit(ctx.sessionId, closeEnvelope);
 
+    this._emitUserFeedback(ctx, status, userInterventions);
+
     try {
       await this._transmissionQueue.waitForDrain();
     } catch {
@@ -269,6 +294,73 @@ export class TrajectoryCapture {
     this._contexts.delete(agentId);
   }
 
+  _computeQualityTier(ctx, status, userInterventions) {
+    const quality = ctx.metadata.session_quality;
+    if (quality >= TIER_A_MIN_QUALITY && ctx.errorsEncountered === 0 && userInterventions === 0 && status === 'SUCCESS') {
+      return { tier: 'TIER_A', reason: 'high_quality_no_errors' };
+    }
+    if (status !== 'SUCCESS') {
+      return { tier: 'TIER_C', reason: 'non_success_status' };
+    }
+    if (quality >= TIER_B_MIN_QUALITY || (ctx.errorsEncountered > 0 && ctx.errorsRecovered === ctx.errorsEncountered)) {
+      return { tier: 'TIER_B', reason: quality >= TIER_B_MIN_QUALITY ? 'moderate_quality' : 'errors_recovered' };
+    }
+    return { tier: 'TIER_C', reason: quality < TIER_B_MIN_QUALITY ? 'low_quality' : 'unrecovered_errors' };
+  }
+
+  _computeTrainingEligibility(ctx, durationSeconds) {
+    if (ctx.stepCount < TRAINING_MIN_STEPS) {
+      return { eligible: false, exclusionReason: 'too_few_steps' };
+    }
+    const hasAction = ctx.allSteps.some((s) => s.type === 'action' && s.tool);
+    if (!hasAction) {
+      return { eligible: false, exclusionReason: 'no_actions' };
+    }
+    const hasObservation = ctx.allSteps.some((s) => s.type === 'observation' && s.content);
+    if (!hasObservation) {
+      return { eligible: false, exclusionReason: 'no_observations' };
+    }
+    if (ctx.totalTokens < TRAINING_MIN_TOKENS) {
+      return { eligible: false, exclusionReason: 'insufficient_tokens' };
+    }
+    if (durationSeconds < TRAINING_MIN_DURATION) {
+      return { eligible: false, exclusionReason: 'too_short' };
+    }
+    return { eligible: true, exclusionReason: null };
+  }
+
+  _emitUserFeedback(ctx, status, userInterventions) {
+    let signal;
+    let context;
+
+    if (status === 'SUCCESS' && userInterventions === 0 && ctx.revisionRounds === 0) {
+      signal = 'accepted';
+      context = 'session completed successfully with no user interventions';
+    } else if (status === 'SUCCESS' && ctx.revisionRounds > 0) {
+      signal = 'iterated';
+      context = `user requested ${ctx.revisionRounds} revision(s) before completion`;
+    } else {
+      return;
+    }
+
+    const feedbackEnvelope = {
+      envelope_id: `env_${randomUUID()}`,
+      session_id: ctx.sessionId,
+      type: 'USER_FEEDBACK',
+      attestation: { session_hmac: '', sequence: 0, app_version_hash: '' },
+      feedback: {
+        signal,
+        timestamp: Date.now() / 1000,
+        context,
+        target_step: ctx.stepCount,
+        revision_rounds: ctx.revisionRounds,
+        delta_summary: null,
+      },
+    };
+
+    this._signAndTransmit(ctx.sessionId, feedbackEnvelope);
+  }
+
   async _retryOfflineQueue() {
     if (!this._enabled || !this._transmissionQueue || this._transmissionQueue.offlineQueueSize === 0) return;
     try {

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

@@ -15,6 +15,32 @@ export function createIngestRoutes(verifier, storage, stitcher, scorer, enrichme
       return res.status(400).json({ accepted: false, reason: 'malformed request: missing envelope or session_id' });
     }
 
+    if (envelope.type === 'USER_FEEDBACK') {
+      const feedbackResult = verifier.verifyFeedback(envelope);
+      if (!feedbackResult.valid) {
+        return res.json({ accepted: false, reason: feedbackResult.reason });
+      }
+
+      const envelopeId = `env_${uuidv4()}`;
+      envelope.envelope_id = envelopeId;
+
+      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);
+      return res.json({ accepted: true, envelope_id: envelopeId });
+    }
+
     if (envelope.type === 'SESSION_CLOSE') {
       const closeResult = verifier.verifyClose(envelope);
       if (!closeResult.valid) {

package/moe-training/server/verifier.js

@@ -99,4 +99,38 @@ export class EnvelopeVerifier {
     this.sessionRegistry.closeSession(sessionId);
     return { valid: true };
   }
+
+  verifyFeedback(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' };
+
+    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' };
+    }
+
+    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' };
+
+    const schemaResult = validateEnvelope(envelope);
+    if (!schemaResult.valid) {
+      return { valid: false, reason: `schema validation failed: ${schemaResult.reason || schemaResult.errors?.join(', ')}` };
+    }
+
+    return { valid: true };
+  }
 }

package/moe-training/shared/constants.js

@@ -13,6 +13,7 @@ export const MODEL_TIERS = {
   'claude-opus-4-7': 5,
   'claude-sonnet-4-6': 3,
   'gpt-4.5': 5,
+  'gpt-5.5': 5,
   'o3': 5,
   'o4-mini': 2,
   'gemini-2.5-pro': 3,
@@ -27,4 +28,12 @@ export const QUALITY_MULTIPLIERS = {
   highQuality: 1.5,
 };
 
+export const OBSERVATION_TOKEN_LIMIT = 4096;
+export const TIER_A_MIN_QUALITY = 70;
+export const TIER_B_MIN_QUALITY = 50;
+export const TRAINING_MIN_STEPS = 5;
+export const TRAINING_MIN_TOKENS = 500;
+export const TRAINING_MIN_DURATION = 10;
+export const TRAINING_EXCLUSION_REASONS = ['too_few_steps', 'no_actions', 'no_observations', 'insufficient_tokens', 'too_short'];
+
 export const CENTRAL_COMMAND_URL = process.env.GROOVE_CENTRAL_URL || 'https://api.groovedev.ai';

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

@@ -1,8 +1,10 @@
 // FSL-1.1-Apache-2.0 — see LICENSE
 
-import { SUPPORTED_PROVIDERS, MODEL_TIERS } from './constants.js';
+import { SUPPORTED_PROVIDERS, MODEL_TIERS, TRAINING_EXCLUSION_REASONS } from './constants.js';
 
-export const STEP_TYPES = ['thought', 'action', 'observation', 'correction', 'resolution', 'error', 'coordination'];
+export const STEP_TYPES = ['thought', 'action', 'observation', 'correction', 'resolution', 'error', 'coordination', 'edit'];
+const VALID_QUALITY_TIERS = ['TIER_A', 'TIER_B', 'TIER_C'];
+const VALID_FEEDBACK_SIGNALS = ['accepted', 'modified', 'rejected', 'iterated'];
 
 const VALID_MODEL_ENGINES = Object.keys(MODEL_TIERS);
 const VALID_COMPLEXITIES = ['light', 'medium', 'heavy'];
@@ -61,6 +63,10 @@ export function validateEnvelope(envelope) {
     return validateSessionClose(envelope);
   }
 
+  if (envelope.type === 'USER_FEEDBACK') {
+    return validateUserFeedback(envelope);
+  }
+
   if (!envelope.session_id || typeof envelope.session_id !== 'string') {
     errors.push('Missing or invalid session_id');
   }
@@ -123,6 +129,43 @@ export function validateEnvelope(envelope) {
       }
     }
     // session_quality is ignored from client — server derives quality
+    if (m.domain_tags !== undefined && m.domain_tags !== null) {
+      if (typeof m.domain_tags !== 'object') {
+        errors.push('metadata.domain_tags must be an object or null');
+      } else {
+        for (const level of ['primary', 'secondary', 'tertiary']) {
+          const tag = m.domain_tags[level];
+          if (!tag || typeof tag !== 'object') {
+            errors.push(`metadata.domain_tags.${level} must be an object`);
+          } else {
+            if (typeof tag.domain !== 'string' || tag.domain.length === 0) {
+              errors.push(`metadata.domain_tags.${level}.domain must be a non-empty string`);
+            }
+            if (typeof tag.confidence !== 'number' || tag.confidence < 0 || tag.confidence > 1) {
+              errors.push(`metadata.domain_tags.${level}.confidence must be a number 0-1`);
+            }
+          }
+        }
+      }
+    }
+    if (m.leaf_context !== undefined && m.leaf_context !== null) {
+      if (typeof m.leaf_context !== 'object') {
+        errors.push('metadata.leaf_context must be an object or null');
+      } else {
+        if (!m.leaf_context.leaf_id || typeof m.leaf_context.leaf_id !== 'string') {
+          errors.push('metadata.leaf_context.leaf_id must be a non-empty string');
+        }
+        if (!m.leaf_context.leaf_version || typeof m.leaf_context.leaf_version !== 'string') {
+          errors.push('metadata.leaf_context.leaf_version must be a non-empty string');
+        }
+        if (typeof m.leaf_context.confidence_at_route !== 'number' || m.leaf_context.confidence_at_route < 0 || m.leaf_context.confidence_at_route > 1) {
+          errors.push('metadata.leaf_context.confidence_at_route must be a number 0-1');
+        }
+        if (!m.leaf_context.chassis_model || typeof m.leaf_context.chassis_model !== 'string') {
+          errors.push('metadata.leaf_context.chassis_model must be a non-empty string');
+        }
+      }
+    }
   }
 
   // Trajectory log validation
@@ -161,6 +204,14 @@ export function validateEnvelope(envelope) {
           errors.push(`step.token_count must be 0-${MAX_TOKEN_COUNT} at index ${i}`);
         }
       }
+      if (step.truncated !== undefined && typeof step.truncated !== 'boolean') {
+        errors.push(`step.truncated must be a boolean at index ${i}`);
+      }
+      if (step.original_token_count !== undefined) {
+        if (typeof step.original_token_count !== 'number' || step.original_token_count < 0 || step.original_token_count > MAX_TOKEN_COUNT) {
+          errors.push(`step.original_token_count must be 0-${MAX_TOKEN_COUNT} at index ${i}`);
+        }
+      }
     }
   }
 
@@ -214,6 +265,81 @@ function validateSessionClose(envelope) {
         }
       }
     }
+    if (envelope.outcome.quality_tier !== undefined && envelope.outcome.quality_tier !== null) {
+      if (!VALID_QUALITY_TIERS.includes(envelope.outcome.quality_tier)) {
+        errors.push(`outcome.quality_tier must be one of: ${VALID_QUALITY_TIERS.join(', ')}`);
+      }
+    }
+    if (envelope.outcome.quality_tier_reason !== undefined && envelope.outcome.quality_tier_reason !== null) {
+      if (typeof envelope.outcome.quality_tier_reason !== 'string' || envelope.outcome.quality_tier_reason.length > 200) {
+        errors.push('outcome.quality_tier_reason must be a string, max 200 characters');
+      }
+    }
+    if (envelope.outcome.training_eligible !== undefined && envelope.outcome.training_eligible !== null) {
+      if (typeof envelope.outcome.training_eligible !== 'boolean') {
+        errors.push('outcome.training_eligible must be a boolean');
+      }
+    }
+    if (envelope.outcome.training_exclusion_reason !== undefined && envelope.outcome.training_exclusion_reason !== null) {
+      if (!TRAINING_EXCLUSION_REASONS.includes(envelope.outcome.training_exclusion_reason)) {
+        errors.push(`outcome.training_exclusion_reason must be one of: ${TRAINING_EXCLUSION_REASONS.join(', ')}`);
+      }
+    }
+  }
+
+  return { valid: errors.length === 0, errors };
+}
+
+function validateUserFeedback(envelope) {
+  const errors = [];
+
+  if (!envelope.session_id || typeof envelope.session_id !== 'string') {
+    errors.push('Missing or invalid session_id');
+  }
+  if (envelope.type !== 'USER_FEEDBACK') {
+    errors.push('Invalid type for USER_FEEDBACK envelope');
+  }
+
+  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');
+    }
+  }
+
+  if (!envelope.feedback || typeof envelope.feedback !== 'object') {
+    errors.push('Missing feedback');
+  } else {
+    const f = envelope.feedback;
+    if (!VALID_FEEDBACK_SIGNALS.includes(f.signal)) {
+      errors.push(`feedback.signal must be one of: ${VALID_FEEDBACK_SIGNALS.join(', ')}`);
+    }
+    if (typeof f.timestamp !== 'number') {
+      errors.push('feedback.timestamp must be a number');
+    }
+    if (f.context !== undefined && f.context !== null && typeof f.context !== 'string') {
+      errors.push('feedback.context must be a string or null');
+    }
+    if (f.target_step !== undefined && f.target_step !== null) {
+      if (typeof f.target_step !== 'number' || !Number.isInteger(f.target_step) || f.target_step < 0) {
+        errors.push('feedback.target_step must be a non-negative integer');
+      }
+    }
+    if (f.revision_rounds !== undefined && f.revision_rounds !== null) {
+      if (typeof f.revision_rounds !== 'number' || !Number.isInteger(f.revision_rounds) || f.revision_rounds < 0) {
+        errors.push('feedback.revision_rounds must be a non-negative integer');
+      }
+    }
+    if (f.delta_summary !== undefined && f.delta_summary !== null && typeof f.delta_summary !== 'string') {
+      errors.push('feedback.delta_summary must be a string or null');
+    }
   }
 
   return { valid: errors.length === 0, errors };

package/moe-training/test/client/domain-tagger.test.js

@@ -0,0 +1,203 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { describe, it, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { DomainTagger, cosineSimilarity } from '../../client/domain-tagger.js';
+
+describe('DomainTagger', () => {
+  let tagger;
+
+  beforeEach(async () => {
+    tagger = new DomainTagger();
+    await tagger.init();
+  });
+
+  it('initializes in keyword mode when no embedding service is configured', async () => {
+    assert.equal(tagger.ready, true);
+    assert.equal(tagger.mode, 'keyword');
+  });
+
+  it('tags Python-related routing text', async () => {
+    const text = DomainTagger.buildRoutingText(
+      'Fix Python unit tests',
+      'The pytest suite is failing on the Django model validators',
+      [{ content: 'I need to check the pytest output and fix the failing tests' }]
+    );
+    const result = await tagger.tag(text);
+    assert.notEqual(result, null);
+    assert.equal(result.primary.domain, 'python');
+    assert.ok(result.primary.confidence > 0);
+  });
+
+  it('tags React/frontend routing text', async () => {
+    const text = DomainTagger.buildRoutingText(
+      'Build a React component with Tailwind CSS',
+      'Create a new JSX component using hooks and styled with Tailwind',
+      [{ content: 'I will use useState and useEffect hooks for this component' }]
+    );
+    const result = await tagger.tag(text);
+    assert.notEqual(result, null);
+    assert.equal(result.primary.domain, 'react_frontend');
+    assert.ok(result.primary.confidence > 0);
+  });
+
+  it('tags Rust routing text', async () => {
+    const text = DomainTagger.buildRoutingText(
+      'Fix Rust ownership error',
+      'The cargo build fails with a borrow checker lifetime error in main.rs',
+      [{ content: 'I need to check the struct impl and fix the lifetime annotation' }]
+    );
+    const result = await tagger.tag(text);
+    assert.notEqual(result, null);
+    assert.equal(result.primary.domain, 'rust');
+  });
+
+  it('tags DevOps/Docker routing text', async () => {
+    const text = DomainTagger.buildRoutingText(
+      'Fix Dockerfile build',
+      'The Docker compose deployment fails on Kubernetes with nginx config errors',
+      [{ content: 'Let me check the Dockerfile and the helm chart' }]
+    );
+    const result = await tagger.tag(text);
+    assert.notEqual(result, null);
+    assert.equal(result.primary.domain, 'devops_docker');
+  });
+
+  it('tags database-related routing text', async () => {
+    const text = DomainTagger.buildRoutingText(
+      'Optimize SQL query',
+      'The PostgreSQL SELECT query with JOIN is slow, need to add an index',
+      [{ content: 'I will check the query plan and add the missing index' }]
+    );
+    const result = await tagger.tag(text);
+    assert.notEqual(result, null);
+    assert.equal(result.primary.domain, 'postgresql_database');
+  });
+
+  it('tags ML/data science routing text', async () => {
+    const text = DomainTagger.buildRoutingText(
+      'Train neural network model',
+      'Fine-tune the PyTorch transformer model on the new dataset with huggingface',
+      [{ content: 'I will set up the training loop with epoch tracking and loss metrics' }]
+    );
+    const result = await tagger.tag(text);
+    assert.notEqual(result, null);
+    assert.equal(result.primary.domain, 'data_science_ml');
+  });
+
+  it('returns all three tag levels with correct structure', async () => {
+    const text = 'Build a React component with TypeScript and Tailwind CSS for the frontend';
+    const result = await tagger.tag(text);
+    assert.notEqual(result, null);
+    assert.ok(result.primary);
+    assert.ok(result.secondary);
+    assert.ok(result.tertiary);
+    assert.equal(typeof result.primary.domain, 'string');
+    assert.equal(typeof result.primary.confidence, 'number');
+    assert.equal(typeof result.secondary.domain, 'string');
+    assert.equal(typeof result.secondary.confidence, 'number');
+    assert.equal(typeof result.tertiary.domain, 'string');
+    assert.equal(typeof result.tertiary.confidence, 'number');
+  });
+
+  it('primary confidence >= secondary >= tertiary', async () => {
+    const text = 'Build a React JSX component with hooks and CSS styling for the frontend DOM';
+    const result = await tagger.tag(text);
+    assert.notEqual(result, null);
+    assert.ok(result.primary.confidence >= result.secondary.confidence);
+    assert.ok(result.secondary.confidence >= result.tertiary.confidence);
+  });
+
+  it('returns null for empty or missing input', async () => {
+    assert.equal(await tagger.tag(''), null);
+    assert.equal(await tagger.tag(null), null);
+    assert.equal(await tagger.tag(undefined), null);
+  });
+
+  it('returns null for unrecognizable content', async () => {
+    const result = await tagger.tag('asdfghjkl 12345 zzzzz');
+    assert.equal(result, null);
+  });
+
+  it('returns null when not initialized', async () => {
+    const uninit = new DomainTagger();
+    const result = await uninit.tag('Build a Python Django app');
+    assert.equal(result, null);
+  });
+
+  it('gracefully degrades when embedding service is unreachable', async () => {
+    const taggerHttp = new DomainTagger({ serviceUrl: 'http://localhost:99999/v1/embeddings' });
+    await taggerHttp.init();
+    assert.equal(taggerHttp.ready, true);
+    assert.equal(taggerHttp.mode, 'keyword');
+    const result = await taggerHttp.tag('Build a Python Flask API');
+    assert.notEqual(result, null);
+    assert.equal(result.primary.domain, 'python');
+  });
+
+  it('does not block on tag failure — returns null', async () => {
+    const start = Date.now();
+    const brokenTagger = new DomainTagger({ serviceUrl: 'http://localhost:99999/v1/embeddings' });
+    await brokenTagger.init();
+    const result = await brokenTagger.tag('anything');
+    const elapsed = Date.now() - start;
+    assert.ok(elapsed < 10_000, `tag() took ${elapsed}ms, should not block`);
+    assert.ok(result !== undefined);
+  });
+});
+
+describe('DomainTagger.buildRoutingText', () => {
+  it('combines task title, prompt, and thought steps', () => {
+    const text = DomainTagger.buildRoutingText(
+      'Fix bug',
+      'The server crashes on startup',
+      [{ content: 'Let me check the logs' }, { content: 'I see the error' }]
+    );
+    assert.ok(text.includes('Fix bug'));
+    assert.ok(text.includes('The server crashes on startup'));
+    assert.ok(text.includes('Let me check the logs'));
+    assert.ok(text.includes('I see the error'));
+  });
+
+  it('limits to first 2 thought steps', () => {
+    const text = DomainTagger.buildRoutingText(
+      'Task',
+      'Prompt',
+      [{ content: 'Step 1' }, { content: 'Step 2' }, { content: 'Step 3' }]
+    );
+    assert.ok(text.includes('Step 1'));
+    assert.ok(text.includes('Step 2'));
+    assert.ok(!text.includes('Step 3'));
+  });
+
+  it('handles missing parts gracefully', () => {
+    assert.equal(DomainTagger.buildRoutingText(null, null, []), '');
+    assert.ok(DomainTagger.buildRoutingText('Title', null, []).includes('Title'));
+    assert.ok(DomainTagger.buildRoutingText(null, 'Prompt', []).includes('Prompt'));
+  });
+});
+
+describe('cosineSimilarity', () => {
+  it('returns 1 for identical vectors', () => {
+    const v = [1, 2, 3, 4, 5];
+    assert.ok(Math.abs(cosineSimilarity(v, v) - 1) < 0.0001);
+  });
+
+  it('returns 0 for orthogonal vectors', () => {
+    assert.ok(Math.abs(cosineSimilarity([1, 0], [0, 1])) < 0.0001);
+  });
+
+  it('returns -1 for opposite vectors', () => {
+    assert.ok(Math.abs(cosineSimilarity([1, 0], [-1, 0]) - (-1)) < 0.0001);
+  });
+
+  it('returns 0 for mismatched lengths', () => {
+    assert.equal(cosineSimilarity([1, 2], [1, 2, 3]), 0);
+  });
+
+  it('returns 0 for null/empty inputs', () => {
+    assert.equal(cosineSimilarity(null, [1, 2]), 0);
+    assert.equal(cosineSimilarity([1, 2], null), 0);
+    assert.equal(cosineSimilarity([], []), 0);
+  });
+});