groove-dev 0.27.102 → 0.27.104

package/node_modules/moe-training/client/parsers/grok.js

@@ -1,5 +1,23 @@
 // FSL-1.1-Apache-2.0 — see LICENSE
 
+import { OBSERVATION_TOKEN_LIMIT } from '../../shared/constants.js';
+
+function estimateTokens(text) {
+  if (!text) return 0;
+  return Math.ceil(text.length / 4);
+}
+
+function truncateObservation(text) {
+  if (!text || typeof text !== 'string') return { content: text || '', truncated: false, original_token_count: estimateTokens(text) };
+  const originalTokens = estimateTokens(text);
+  if (originalTokens <= OBSERVATION_TOKEN_LIMIT) {
+    return { content: text, truncated: false, original_token_count: originalTokens };
+  }
+  const charLimit = OBSERVATION_TOKEN_LIMIT * 4;
+  const truncated = text.slice(0, charLimit) + `\n[TRUNCATED — original output was ${originalTokens} tokens]`;
+  return { content: truncated, truncated: true, original_token_count: originalTokens };
+}
+
 export class GrokParser {
   // TODO: Grok agentic CLI not yet available. Wire up when headless CLI is built.
   parseEvent(_jsonEvent) {

package/node_modules/moe-training/client/step-classifier.js

@@ -38,7 +38,7 @@ export class StepClassifier {
 
     const content = step.content || '';
 
-    if ((step.type === 'action' || step.type === 'observation') && ERROR_SIGNAL_RE.test(content)) {
+    if ((step.type === 'action' || step.type === 'observation') && step.is_error !== false && ERROR_SIGNAL_RE.test(content)) {
       step.type = 'error';
     }
 

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

@@ -8,7 +8,17 @@ 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 { DomainTagger } from './domain-tagger.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;
 
@@ -24,7 +34,7 @@ export class TrajectoryCapture {
     this._contexts = new Map();
   }
 
-  init() {
+  async init() {
     if (!ConsentManager.isCaptureEnabled()) {
       this._enabled = false;
       return;
@@ -34,6 +44,8 @@ export class TrajectoryCapture {
     this._attestation = new SessionAttestation(this._centralCommandUrl);
     this._transmissionQueue = new TransmissionQueue(this._centralCommandUrl);
     this._transmissionQueue.start();
+    this._domainTagger = new DomainTagger();
+    await this._domainTagger.init();
     this._offlineRetryTimer = setInterval(() => {
       this._retryOfflineQueue();
     }, OFFLINE_RETRY_INTERVAL_MS);
@@ -56,6 +68,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 +91,7 @@ export class TrajectoryCapture {
       startTime,
       chunkTimer: null,
       allSteps: [],
+      revisionRounds: 0,
     };
 
     ctx.chunkTimer = setInterval(() => {
@@ -115,10 +129,6 @@ export class TrajectoryCapture {
       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) {
@@ -126,6 +136,8 @@ export class TrajectoryCapture {
     const ctx = this._contexts.get(agentId);
     if (!ctx) return;
 
+    ctx.revisionRounds++;
+
     const classified = ctx.classifier.classifyUserMessage(text);
     if (!classified) return;
 
@@ -185,6 +197,7 @@ export class TrajectoryCapture {
       ...ev,
     };
 
+    ctx.totalTokens += ev.token_count;
     if (ev.type === 'error') ctx.errorsEncountered++;
     ctx.allSteps.push(step);
 
@@ -238,22 +251,42 @@ 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);
+
+    if (this._domainTagger) {
+      const role = ctx.metadata.agent_role || '';
+      const firstPrompt = ctx.allSteps.find((s) => s.type === 'thought')?.content || '';
+      const thoughtSteps = ctx.allSteps.filter((s) => s.type === 'thought');
+      const routingText = DomainTagger.buildRoutingText(role, firstPrompt, thoughtSteps);
+      ctx.metadata.domain_tags = await this._domainTagger.tag(routingText);
+    }
+
+    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 +302,74 @@ 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 || ctx.errorsEncountered <= ctx.errorsRecovered) && userInterventions === 0 && status === 'SUCCESS') {
+      const reason = ctx.errorsEncountered > 0 ? 'high_quality_errors_recovered' : 'high_quality_no_errors';
+      return { tier: 'TIER_A', reason };
+    }
+    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/node_modules/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/node_modules/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/node_modules/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/node_modules/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 };