groove-dev 0.27.102 → 0.27.103

package/node_modules/moe-training/client/edit-normalizer.js

@@ -0,0 +1,188 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+const APPLY_PATCH_RE = /apply_patch/;
+const BEGIN_PATCH_RE = /^\*{3}\s*Begin Patch\s*$/;
+const END_PATCH_RE = /^\*{3}\s*End Patch\s*$/;
+const ADD_FILE_RE = /^\*{3}\s*Add File:\s*(.+)$/;
+const UPDATE_FILE_RE = /^\*{3}\s*Update File:\s*(.+)$/;
+const DELETE_FILE_RE = /^\*{3}\s*Delete File:\s*(.+)$/;
+const HUNK_HEADER_RE = /^@@@.*@@@/;
+
+export class EditNormalizer {
+  detectApplyPatch(actionContent) {
+    const text = extractText(actionContent);
+    if (!text) return false;
+    return APPLY_PATCH_RE.test(text);
+  }
+
+  normalize(actionContent, timestamp, startStep) {
+    const text = extractText(actionContent);
+    if (!text) return [];
+
+    const patchBody = extractPatchBody(text);
+    if (!patchBody) return [];
+
+    const sections = parseSections(patchBody);
+    const edits = [];
+    let step = startStep || 1;
+
+    for (const section of sections) {
+      if (section.type === 'add') {
+        edits.push({
+          step: step++,
+          type: 'edit',
+          timestamp: timestamp || Date.now() / 1000,
+          file_path: section.filePath,
+          edit_type: 'create',
+          content: section.content,
+          old_string: null,
+          new_string: null,
+          token_count: estimateTokens(section.content),
+        });
+      } else if (section.type === 'update') {
+        const hunks = parseHunks(section.lines);
+        for (const hunk of hunks) {
+          edits.push({
+            step: step++,
+            type: 'edit',
+            timestamp: timestamp || Date.now() / 1000,
+            file_path: section.filePath,
+            edit_type: 'modify',
+            content: null,
+            old_string: hunk.oldString,
+            new_string: hunk.newString,
+            token_count: estimateTokens(hunk.oldString + hunk.newString),
+          });
+        }
+      } else if (section.type === 'delete') {
+        edits.push({
+          step: step++,
+          type: 'edit',
+          timestamp: timestamp || Date.now() / 1000,
+          file_path: section.filePath,
+          edit_type: 'delete',
+          content: null,
+          old_string: section.content || null,
+          new_string: null,
+          token_count: estimateTokens(section.content || ''),
+        });
+      }
+    }
+
+    return edits;
+  }
+}
+
+function extractText(actionContent) {
+  if (typeof actionContent === 'string') return actionContent;
+  if (actionContent?.arguments?.command) return actionContent.arguments.command;
+  if (actionContent?.content) return actionContent.content;
+  return null;
+}
+
+function extractPatchBody(text) {
+  const lines = text.split('\n');
+  let startIdx = -1;
+  let endIdx = -1;
+
+  for (let i = 0; i < lines.length; i++) {
+    if (BEGIN_PATCH_RE.test(lines[i].trim())) {
+      startIdx = i + 1;
+    }
+    if (END_PATCH_RE.test(lines[i].trim())) {
+      endIdx = i;
+    }
+  }
+
+  if (startIdx === -1) return null;
+  if (endIdx === -1) endIdx = lines.length;
+
+  return lines.slice(startIdx, endIdx).join('\n');
+}
+
+function parseSections(body) {
+  const lines = body.split('\n');
+  const sections = [];
+  let current = null;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+
+    let match;
+    if ((match = ADD_FILE_RE.exec(trimmed))) {
+      if (current) sections.push(current);
+      current = { type: 'add', filePath: match[1].trim(), lines: [], content: '' };
+    } else if ((match = UPDATE_FILE_RE.exec(trimmed))) {
+      if (current) sections.push(current);
+      current = { type: 'update', filePath: match[1].trim(), lines: [] };
+    } else if ((match = DELETE_FILE_RE.exec(trimmed))) {
+      if (current) sections.push(current);
+      current = { type: 'delete', filePath: match[1].trim(), lines: [], content: '' };
+    } else if (current) {
+      current.lines.push(line);
+    }
+  }
+
+  if (current) sections.push(current);
+
+  for (const section of sections) {
+    if (section.type === 'add' || section.type === 'delete') {
+      section.content = section.lines.join('\n').trim();
+    }
+  }
+
+  return sections;
+}
+
+function parseHunks(lines) {
+  const hunks = [];
+  let inHunk = false;
+  let oldLines = [];
+  let newLines = [];
+
+  for (const line of lines) {
+    if (HUNK_HEADER_RE.test(line.trim())) {
+      if (inHunk && (oldLines.length > 0 || newLines.length > 0)) {
+        hunks.push(buildHunk(oldLines, newLines));
+      }
+      inHunk = true;
+      oldLines = [];
+      newLines = [];
+      continue;
+    }
+
+    if (!inHunk && (line.startsWith('-') || line.startsWith('+') || line.startsWith(' '))) {
+      inHunk = true;
+    }
+
+    if (!inHunk) continue;
+
+    if (line.startsWith('-')) {
+      oldLines.push(line.slice(1));
+    } else if (line.startsWith('+')) {
+      newLines.push(line.slice(1));
+    } else if (line.startsWith(' ')) {
+      oldLines.push(line.slice(1));
+      newLines.push(line.slice(1));
+    }
+  }
+
+  if (inHunk && (oldLines.length > 0 || newLines.length > 0)) {
+    hunks.push(buildHunk(oldLines, newLines));
+  }
+
+  return hunks;
+}
+
+function buildHunk(oldLines, newLines) {
+  return {
+    oldString: oldLines.join('\n'),
+    newString: newLines.join('\n'),
+  };
+}
+
+export function estimateTokens(text) {
+  if (!text) return 0;
+  return Math.max(1, Math.ceil(text.length / 4));
+}

package/node_modules/moe-training/client/envelope-builder.js

@@ -7,7 +7,7 @@ export class EnvelopeBuilder {
   constructor(sessionId, contributorId, metadata) {
     this._sessionId = sessionId;
     this._contributorId = contributorId;
-    this._metadata = metadata;
+    this._metadata = { ...metadata, leaf_context: metadata.leaf_context ?? null };
     this._buffer = [];
     this._chunkSequence = 0;
   }

package/node_modules/moe-training/client/parsers/claude-code.js

@@ -1,15 +1,21 @@
 // FSL-1.1-Apache-2.0 — see LICENSE
 
-import { OBSERVATION_TRUNCATE_HEAD, OBSERVATION_TRUNCATE_TAIL } from '../../shared/constants.js';
+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 text;
-  const lines = text.split('\n');
-  if (lines.length <= OBSERVATION_TRUNCATE_HEAD + OBSERVATION_TRUNCATE_TAIL) return text;
-  const head = lines.slice(0, OBSERVATION_TRUNCATE_HEAD);
-  const tail = lines.slice(-OBSERVATION_TRUNCATE_TAIL);
-  const omitted = lines.length - OBSERVATION_TRUNCATE_HEAD - OBSERVATION_TRUNCATE_TAIL;
-  return [...head, `[... ${omitted} lines omitted ...]`, ...tail].join('\n');
+  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 ClaudeCodeParser {
@@ -50,10 +56,51 @@ export class ClaudeCodeParser {
           if (block.is_error) {
             results.push({ type: 'error', content: resultContent, is_error: true });
           } else {
+            const obs = truncateObservation(resultContent);
+            results.push({
+              type: 'observation',
+              content: obs.content,
+              truncated: obs.truncated,
+              original_token_count: obs.original_token_count,
+              is_error: false,
+            });
+          }
+        }
+      }
+
+      return results.length === 1 ? results[0] : results.length > 1 ? results : null;
+    }
+
+    if (jsonEvent.type === 'user') {
+      const contentBlocks = jsonEvent.message?.content;
+      if (!Array.isArray(contentBlocks)) return null;
+
+      const results = [];
+      for (const block of contentBlocks) {
+        if (block.type === 'tool_result') {
+          const toolUse = this._pendingToolUse.get(block.tool_use_id);
+          if (toolUse) this._pendingToolUse.delete(block.tool_use_id);
+
+          const resultContent = Array.isArray(block.content)
+            ? block.content.map((c) => c.text || '').join('\n')
+            : (typeof block.content === 'string' ? block.content : '');
+
+          if (block.is_error) {
+            results.push({
+              type: 'error',
+              content: resultContent,
+              is_error: true,
+              tool: toolUse?.name,
+            });
+          } else {
+            const obs = truncateObservation(resultContent);
             results.push({
               type: 'observation',
-              content: truncateObservation(resultContent),
+              content: obs.content,
+              truncated: obs.truncated,
+              original_token_count: obs.original_token_count,
               is_error: false,
+              tool: toolUse?.name,
             });
           }
         }

package/node_modules/moe-training/client/parsers/codex.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 CodexParser {
   constructor() {
     this._sessionId = null;
@@ -37,15 +55,17 @@ export class CodexParser {
           return { type: 'thought', content: item.text || '' };
         }
         if (item.type === 'command_execution') {
-          const output = (item.aggregated_output || '').slice(0, 2000);
+          const rawOutput = item.aggregated_output || '';
           if (item.exit_code !== 0) {
-            return { type: 'error', content: output || `Exit code: ${item.exit_code}` };
+            return { type: 'error', content: rawOutput.slice(0, 2000) || `Exit code: ${item.exit_code}` };
           }
-          return { type: 'observation', content: output };
+          const obs = truncateObservation(rawOutput);
+          return { type: 'observation', content: obs.content, truncated: obs.truncated, original_token_count: obs.original_token_count };
         }
         if (item.type === 'file_edit' || item.type === 'file_write' || item.type === 'file_read') {
-          const output = (item.output || item.content || '').slice(0, 2000);
-          return { type: 'observation', content: output };
+          const rawOutput = item.output || item.content || '';
+          const obs = truncateObservation(rawOutput);
+          return { type: 'observation', content: obs.content, truncated: obs.truncated, original_token_count: obs.original_token_count };
         }
         return null;
       }

package/node_modules/moe-training/client/parsers/gemini.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 GeminiParser {
   constructor() {
     this._sessionId = null;
@@ -44,8 +62,9 @@ export class GeminiParser {
       case 'tool_response': {
         const rawContent = jsonEvent.content;
         const contentParts = Array.isArray(rawContent) ? rawContent : (typeof rawContent === 'string' ? [{ text: rawContent }] : rawContent ? [rawContent] : []);
-        const content = contentParts.map((p) => p.text || '').join('').slice(0, 2000);
-        return { type: 'observation', content };
+        const rawText = contentParts.map((p) => p.text || '').join('');
+        const obs = truncateObservation(rawText);
+        return { type: 'observation', content: obs.content, truncated: obs.truncated, original_token_count: obs.original_token_count };
       }
 
       case 'error': {

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/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/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';