groove-dev 0.27.175 → 0.27.180

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

@@ -28,7 +28,17 @@ export const QUALITY_MULTIPLIERS = {
   highQuality: 1.5,
 };
 
-export const OBSERVATION_TOKEN_LIMIT = 4096;
+// Hard ceiling on step.content, shared by the client trimmer (envelope-builder)
+// and the ingest validator (envelope-schema). These MUST stay equal: the
+// validator rejects the whole envelope when exceeded, which drops the entire
+// session — so the client must trim to exactly this before building.
+export const MAX_STEP_CONTENT_CHARS = 100_000;
+export const MAX_TOKEN_COUNT = 100_000;
+
+// Per-observation budget, in estimated tokens (~4 chars/token). Kept safely
+// under MAX_STEP_CONTENT_CHARS so a parser-truncated observation plus its
+// "[TRUNCATED …]" suffix still fits without a second trim downstream.
+export const OBSERVATION_TOKEN_LIMIT = 24_000;
 export const TIER_A_MIN_QUALITY = 70;
 export const TIER_B_MIN_QUALITY = 50;
 export const TRAINING_MIN_STEPS = 5;

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

@@ -1,6 +1,12 @@
 // FSL-1.1-Apache-2.0 — see LICENSE
 
-import { SUPPORTED_PROVIDERS, MODEL_TIERS, TRAINING_EXCLUSION_REASONS } from './constants.js';
+import {
+  SUPPORTED_PROVIDERS,
+  MODEL_TIERS,
+  TRAINING_EXCLUSION_REASONS,
+  MAX_STEP_CONTENT_CHARS,
+  MAX_TOKEN_COUNT,
+} from './constants.js';
 
 export const STEP_TYPES = ['thought', 'action', 'observation', 'correction', 'resolution', 'error', 'coordination', 'edit', 'instruction', 'clarification', 'approval', 'delegate', 'yield'];
 const VALID_QUALITY_TIERS = ['TIER_A', 'TIER_B', 'TIER_C'];
@@ -10,8 +16,10 @@ 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;
+// Sourced from shared constants — the client trims to the same value before
+// building envelopes. Keeping one definition prevents the drift that silently
+// truncated observations at 10k while the validator allowed more.
+const MAX_STEP_CONTENT_LENGTH = MAX_STEP_CONTENT_CHARS;
 const MAX_STEP_NUMBER = 50_000;
 const SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1000;
 const ONE_HOUR_MS = 60 * 60 * 1000;

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

@@ -3,7 +3,7 @@
 import { describe, it } from 'node:test';
 import assert from 'node:assert/strict';
 import { EnvelopeBuilder } from '../../client/envelope-builder.js';
-import { CHUNK_SIZE } from '../../shared/constants.js';
+import { CHUNK_SIZE, MAX_STEP_CONTENT_CHARS } from '../../shared/constants.js';
 
 const metadata = {
   model_engine: 'claude-opus-4-6',
@@ -74,12 +74,48 @@ describe('EnvelopeBuilder', () => {
     assert.deepEqual(close.outcome, outcome);
   });
 
-  it('truncates step content at 10000 characters', () => {
+  it('leaves content under the ingest ceiling untouched', () => {
     const builder = new EnvelopeBuilder('sess_1', 'user_1', metadata);
-    const longContent = 'x'.repeat(15_000);
-    builder.addStep({ step: 1, type: 'thought', timestamp: 123, content: longContent });
-    const envelope = builder.flush();
-    assert.equal(envelope.trajectory_log[0].content.length, 10_000);
+    builder.addStep({ step: 1, type: 'thought', timestamp: 123, content: 'x'.repeat(15_000) });
+    const step = builder.flush().trajectory_log[0];
+    assert.equal(step.content.length, 15_000);
+    assert.ok(!step.truncated);
+  });
+
+  it('truncates step content at MAX_STEP_CONTENT_CHARS', () => {
+    const builder = new EnvelopeBuilder('sess_1', 'user_1', metadata);
+    builder.addStep({ step: 1, type: 'thought', timestamp: 123, content: 'x'.repeat(150_000) });
+    const step = builder.flush().trajectory_log[0];
+    assert.equal(step.content.length, MAX_STEP_CONTENT_CHARS);
+  });
+
+  // Regression: a trim that doesn't flag itself looks like complete data to
+  // downstream training and silently corrupts the corpus.
+  it('never truncates silently — always sets truncated + original_token_count', () => {
+    const builder = new EnvelopeBuilder('sess_1', 'user_1', metadata);
+    builder.addStep({ step: 1, type: 'observation', timestamp: 123, content: 'x'.repeat(150_000) });
+    const step = builder.flush().trajectory_log[0];
+    assert.equal(step.truncated, true);
+    assert.equal(step.original_token_count, 37_500); // 150k chars / 4
+  });
+
+  it('preserves a parser-supplied original_token_count when trimming again', () => {
+    const builder = new EnvelopeBuilder('sess_1', 'user_1', metadata);
+    builder.addStep({
+      step: 1, type: 'observation', timestamp: 123,
+      content: 'x'.repeat(150_000), truncated: true, original_token_count: 99_000,
+    });
+    const step = builder.flush().trajectory_log[0];
+    // The parser saw the true original; our count only sees what survived it.
+    assert.equal(step.original_token_count, 99_000);
+  });
+
+  it('output always satisfies the ingest validator', () => {
+    const builder = new EnvelopeBuilder('sess_1', 'user_1', metadata);
+    builder.addStep({ step: 1, type: 'observation', timestamp: 123, content: 'x'.repeat(500_000) });
+    const step = builder.flush().trajectory_log[0];
+    assert.ok(step.content.length <= MAX_STEP_CONTENT_CHARS,
+      'client must trim to the validator ceiling or the whole session is rejected');
   });
 
   it('caps token_count at 100000', () => {

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

@@ -3,7 +3,7 @@
 import { describe, it } from 'node:test';
 import assert from 'node:assert/strict';
 import { validateEnvelope, STEP_TYPES } from '../../shared/envelope-schema.js';
-import { TRAINING_EXCLUSION_REASONS } from '../../shared/constants.js';
+import { TRAINING_EXCLUSION_REASONS, MAX_STEP_CONTENT_CHARS } from '../../shared/constants.js';
 
 const VALID_HMAC = 'a'.repeat(64);
 const VALID_APP_HASH = 'b'.repeat(64);
@@ -113,12 +113,19 @@ describe('envelope-schema', () => {
     assert.ok(result.errors.some(e => e.includes('500')));
   });
 
-  it('rejects step with content > 10KB', () => {
+  it('accepts step content up to MAX_STEP_CONTENT_CHARS', () => {
     const env = validEnvelope();
-    env.trajectory_log[0].content = 'x'.repeat(10_001);
+    env.trajectory_log[0].content = 'x'.repeat(MAX_STEP_CONTENT_CHARS);
+    const result = validateEnvelope(env);
+    assert.ok(!result.errors.some(e => e.includes('step.content exceeds')));
+  });
+
+  it('rejects step content over MAX_STEP_CONTENT_CHARS', () => {
+    const env = validEnvelope();
+    env.trajectory_log[0].content = 'x'.repeat(MAX_STEP_CONTENT_CHARS + 1);
     const result = validateEnvelope(env);
     assert.equal(result.valid, false);
-    assert.ok(result.errors.some(e => e.includes('10000')));
+    assert.ok(result.errors.some(e => e.includes(String(MAX_STEP_CONTENT_CHARS))));
   });
 
   it('rejects step with token_count > 100,000', () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "groove-dev",
-  "version": "0.27.175",
+  "version": "0.27.180",
   "description": "Open-source agent orchestration layer — the AI company OS. Local model agent engine (GGUF/Ollama/llama-server), HuggingFace model browser, MCP integrations (Slack, Gmail, Stripe, 15+), agent scheduling (cron), business roles (CMO, CFO, EA). GUI dashboard, multi-agent coordination, zero cold-start, infinite sessions. Works with Claude Code, Codex, Gemini CLI, Ollama, any local model.",
   "license": "FSL-1.1-Apache-2.0",
   "author": "Groove Dev <hello@groovedev.ai> (https://groovedev.ai)",

package/packages/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/cli",
-  "version": "0.27.175",
+  "version": "0.27.180",
   "description": "GROOVE CLI — manage AI coding agents from your terminal",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",

package/packages/daemon/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/daemon",
-  "version": "0.27.175",
+  "version": "0.27.180",
   "description": "GROOVE daemon — agent orchestration engine",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",

package/packages/daemon/src/api.js

@@ -28,6 +28,7 @@ import { registerFileRoutes, resetEditorRoot } from './routes/files.js';
 import { registerNetworkRoutes } from './routes/network.js';
 import { registerScheduleRoutes } from './routes/schedules.js';
 import { registerInnerChatRoutes } from './routes/innerchat.js';
+import { registerAutoAgentRoutes } from './routes/auto-agents.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkgVersion = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
@@ -127,7 +128,7 @@ export function createApi(app, daemon) {
     next();
   });
 
-  app.use(express.json({ limit: '6mb' }));
+  app.use(express.json({ limit: '100mb' }));
 
   // Health check
   app.get('/api/health', (req, res) => {
@@ -177,6 +178,7 @@ export function createApi(app, daemon) {
   registerNetworkRoutes(app, daemon);
   registerScheduleRoutes(app, daemon);
   registerInnerChatRoutes(app, daemon);
+  registerAutoAgentRoutes(app, daemon);
 
 
   // Token usage

package/packages/daemon/src/autostate.js

@@ -0,0 +1,198 @@
+// GROOVE — Auto Agent State Persistence
+// FSL-1.1-Apache-2.0 — see LICENSE
+//
+// Manages the persistent state layer for autonomous agents:
+//   .groove/auto/<agentDefId>/
+//     state.json    — phase, cycle, history, champion
+//     journal.jsonl — append-only accumulated knowledge
+//     roadmap.md    — staged goals with graduation criteria
+//     prompt.md     — system prompt (identity + tools + rules)
+//     runs/         — per-run logs and output
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync, appendFileSync, readdirSync, renameSync, copyFileSync, statSync, rmSync } from 'fs';
+import { resolve } from 'path';
+import { randomUUID } from 'crypto';
+
+const MAX_HISTORY = 200;
+const MAX_JOURNAL_ENTRIES = 500;
+
+function safeJsonParse(str, fallback) {
+  try { return JSON.parse(str); } catch { return fallback; }
+}
+
+function safeDict(obj, key) {
+  const v = obj?.[key];
+  return v && typeof v === 'object' && !Array.isArray(v) ? v : {};
+}
+
+export class AutoState {
+  constructor(grooveDir) {
+    this.baseDir = resolve(grooveDir, 'auto');
+    mkdirSync(this.baseDir, { recursive: true });
+  }
+
+  _agentDir(defId) {
+    const dir = resolve(this.baseDir, defId);
+    mkdirSync(dir, { recursive: true });
+    mkdirSync(resolve(dir, 'runs'), { recursive: true });
+    return dir;
+  }
+
+  // --- State (state.json) ---
+
+  getState(defId) {
+    const p = resolve(this._agentDir(defId), 'state.json');
+    if (!existsSync(p)) return this._defaultState();
+    return safeJsonParse(readFileSync(p, 'utf8'), this._defaultState());
+  }
+
+  setState(defId, updates) {
+    const dir = this._agentDir(defId);
+    const p = resolve(dir, 'state.json');
+    const bak = resolve(dir, 'state.json.bak');
+    const current = this.getState(defId);
+
+    const merged = { ...current };
+    const allowed = ['phase', 'phase_note', 'cycle', 'current_run', 'champion', 'paused', 'error'];
+    for (const key of allowed) {
+      if (key in updates) merged[key] = updates[key];
+    }
+    merged.updatedAt = new Date().toISOString();
+
+    if (existsSync(p)) {
+      try { copyFileSync(p, bak); } catch { /* best effort */ }
+    }
+    const tmp = resolve(dir, `state.${randomUUID().slice(0, 8)}.tmp`);
+    writeFileSync(tmp, JSON.stringify(merged, null, 2));
+    renameSync(tmp, p);
+    return merged;
+  }
+
+  appendHistory(defId, entry) {
+    const state = this.getState(defId);
+    if (!Array.isArray(state.history)) state.history = [];
+    state.history.push({
+      ...entry,
+      timestamp: new Date().toISOString(),
+    });
+    if (state.history.length > MAX_HISTORY) {
+      state.history = state.history.slice(-MAX_HISTORY);
+    }
+    this.setState(defId, { history: state.history });
+    return state.history;
+  }
+
+  _defaultState() {
+    return {
+      phase: 'idle',
+      phase_note: '',
+      cycle: 0,
+      current_run: null,
+      champion: null,
+      history: [],
+      paused: false,
+      error: null,
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    };
+  }
+
+  // --- Journal (journal.jsonl) ---
+
+  getJournal(defId, { limit = 50, since } = {}) {
+    const p = resolve(this._agentDir(defId), 'journal.jsonl');
+    if (!existsSync(p)) return [];
+    const lines = readFileSync(p, 'utf8').trim().split('\n').filter(Boolean);
+    let entries = lines.map(l => safeJsonParse(l, null)).filter(Boolean);
+    if (since) {
+      entries = entries.filter(e => e.timestamp >= since);
+    }
+    return entries.slice(-limit);
+  }
+
+  appendJournal(defId, entry) {
+    const p = resolve(this._agentDir(defId), 'journal.jsonl');
+    const record = {
+      ...entry,
+      timestamp: new Date().toISOString(),
+    };
+    appendFileSync(p, JSON.stringify(record) + '\n');
+    this._pruneJournal(defId);
+    return record;
+  }
+
+  _pruneJournal(defId) {
+    const p = resolve(this._agentDir(defId), 'journal.jsonl');
+    if (!existsSync(p)) return;
+    const lines = readFileSync(p, 'utf8').trim().split('\n').filter(Boolean);
+    if (lines.length > MAX_JOURNAL_ENTRIES) {
+      writeFileSync(p, lines.slice(-MAX_JOURNAL_ENTRIES).join('\n') + '\n');
+    }
+  }
+
+  // --- Roadmap (roadmap.md) ---
+
+  getRoadmap(defId) {
+    const p = resolve(this._agentDir(defId), 'roadmap.md');
+    if (!existsSync(p)) return '';
+    return readFileSync(p, 'utf8');
+  }
+
+  setRoadmap(defId, content) {
+    const p = resolve(this._agentDir(defId), 'roadmap.md');
+    writeFileSync(p, content);
+  }
+
+  // --- Prompt (prompt.md) ---
+
+  getPrompt(defId) {
+    const p = resolve(this._agentDir(defId), 'prompt.md');
+    if (!existsSync(p)) return '';
+    return readFileSync(p, 'utf8');
+  }
+
+  setPrompt(defId, content) {
+    const p = resolve(this._agentDir(defId), 'prompt.md');
+    writeFileSync(p, content);
+  }
+
+  // --- Run Logs ---
+
+  logRun(defId, runId, data) {
+    const dir = resolve(this._agentDir(defId), 'runs');
+    const p = resolve(dir, `${runId}.json`);
+    writeFileSync(p, JSON.stringify(data, null, 2));
+  }
+
+  getRunLog(defId, runId) {
+    const p = resolve(this._agentDir(defId), 'runs', `${runId}.json`);
+    if (!existsSync(p)) return null;
+    return safeJsonParse(readFileSync(p, 'utf8'), null);
+  }
+
+  listRuns(defId, { limit = 20 } = {}) {
+    const dir = resolve(this._agentDir(defId), 'runs');
+    if (!existsSync(dir)) return [];
+    const files = readdirSync(dir)
+      .filter(f => f.endsWith('.json'))
+      .map(f => {
+        const stat = statSync(resolve(dir, f));
+        return { runId: f.replace('.json', ''), mtime: stat.mtimeMs };
+      })
+      .sort((a, b) => b.mtime - a.mtime)
+      .slice(0, limit);
+    return files.map(f => {
+      const data = safeJsonParse(readFileSync(resolve(dir, `${f.runId}.json`), 'utf8'), {});
+      return { runId: f.runId, ...data };
+    });
+  }
+
+  // --- Cleanup ---
+
+  deleteAll(defId) {
+    const dir = resolve(this.baseDir, defId);
+    if (existsSync(dir)) {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  }
+}

package/packages/daemon/src/index.js

@@ -47,6 +47,8 @@ import { RepoImporter } from './repo-import.js';
 import { ConversationManager } from './conversations.js';
 import { Toys } from './toys.js';
 import { InnerChat } from './innerchat.js';
+import { AutoState } from './autostate.js';
+import { Orchestrator } from './orchestrator.js';
 import { TrajectoryCapture, ConsentManager } from '../../../moe-training/client/index.js';
 import { isFirstRun, runFirstTimeSetup, loadConfig, saveConfig, printWelcome } from './firstrun.js';
 import { bindDaemon as bindGrooveNetworkDaemon } from './providers/groove-network.js';
@@ -160,6 +162,8 @@ export class Daemon {
     this.modelLab = new ModelLab(this);
     this.toys = new Toys(this);
     this.innerchat = new InnerChat(this);
+    this.autoState = new AutoState(this.grooveDir);
+    this.orchestrator = new Orchestrator(this);
     this.trajectoryCapture = null;
 
     // Hook teams.delete to clean up agent-loop session files
@@ -613,6 +617,7 @@ export class Daemon {
         this.journalist.start();
         this.rotator.start();
         this.scheduler.start();
+        this.orchestrator.start();
         this.timeline.start();
         this.gateways.start();
         this.federation.initialize();
@@ -837,6 +842,7 @@ export class Daemon {
     this.journalist.stop();
     this.rotator.stop();
     this.scheduler.stop();
+    this.orchestrator.stop();
     this.timeline.stop();
     if (this._gcInterval) clearInterval(this._gcInterval);
     if (this._stateSaveInterval) clearInterval(this._stateSaveInterval);