groove-dev 0.27.75 → 0.27.78

package/packages/daemon/src/api.js

@@ -15,6 +15,7 @@ import { listProviders, getProvider, clearInstallCache, getProviderMetadata, get
 import { OllamaProvider } from './providers/ollama.js';
 import { ClaudeCodeProvider } from './providers/claude-code.js';
 import { supportsSignalFlag, compareSemver, parseSemver } from './providers/groove-network.js';
+import { ConsentManager } from '../../../moe-training/client/index.js';
 import { validateAgentConfig } from './validate.js';
 import { ROLE_INTEGRATIONS, wrapWithRoleReminder } from './process.js';
 
@@ -4402,6 +4403,81 @@ Keep responses concise. Help them think, don't lecture them about the system the
     res.json({ ok: true });
   });
 
+  // --- Training Data ---
+
+  app.get('/api/training/status', (req, res) => {
+    let userId = null;
+    try { userId = ConsentManager.isCaptureEnabled() ? ConsentManager.getOrCreateUserId() : null; } catch (e) { /* no db yet */ }
+    res.json({
+      optedIn: !!daemon.config.training_opt_in,
+      userId: userId ? userId.substring(0, 8) + '...' : null,
+      captureActive: !!daemon.trajectoryCapture,
+      sessionsCaptured: daemon.state.get('training_sessions_captured') || 0,
+      envelopesSent: daemon.state.get('training_envelopes_sent') || 0,
+    });
+  });
+
+  app.post('/api/training/opt-in', async (req, res) => {
+    const { enabled } = req.body;
+    if (typeof enabled !== 'boolean') return res.status(400).json({ error: 'enabled must be boolean' });
+
+    daemon.config.training_opt_in = enabled;
+    const { saveConfig } = await import('./firstrun.js');
+    saveConfig(daemon.grooveDir, daemon.config);
+
+    if (enabled) {
+      const userId = ConsentManager.getOrCreateUserId();
+      const consent = new ConsentManager();
+      try {
+        consent.recordConsent(userId, true, '1.0');
+      } finally {
+        consent.close();
+      }
+      await daemon._initTrajectoryCapture();
+      daemon.state.set('training_enrolled_at', new Date().toISOString());
+    } else {
+      if (daemon.trajectoryCapture) {
+        try { await daemon.trajectoryCapture.shutdown(); } catch (e) { /* */ }
+        daemon.trajectoryCapture = null;
+      }
+      try {
+        const userId = ConsentManager.getOrCreateUserId();
+        const consent = new ConsentManager();
+        try {
+          consent.revokeConsent(userId);
+        } finally {
+          consent.close();
+        }
+      } catch (e) { /* no user_id yet */ }
+    }
+
+    daemon.broadcast({ type: 'training:status', data: { optedIn: enabled, captureActive: !!daemon.trajectoryCapture } });
+    if (daemon.audit) daemon.audit.log('training.consent', { opt_in: enabled });
+    res.json({ ok: true, optedIn: enabled });
+  });
+
+  app.post('/api/training/opt-in/delete', async (req, res) => {
+    try {
+      daemon.config.training_opt_in = false;
+      const { saveConfig } = await import('./firstrun.js');
+      saveConfig(daemon.grooveDir, daemon.config);
+      if (daemon.trajectoryCapture) {
+        try { await daemon.trajectoryCapture.shutdown(); } catch (e) { /* */ }
+        daemon.trajectoryCapture = null;
+      }
+      try {
+        const userId = ConsentManager.getOrCreateUserId();
+        const consent = new ConsentManager();
+        try { consent.revokeConsent(userId); } finally { consent.close(); }
+      } catch (e) { /* */ }
+      daemon.broadcast({ type: 'training:status', data: { optedIn: false, captureActive: false } });
+      if (daemon.audit) daemon.audit.log('training.delete', {});
+      res.json({ ok: true, deleted: true });
+    } catch (e) {
+      res.status(500).json({ error: 'Failed to delete data' });
+    }
+  });
+
   // --- Config ---
 
   app.get('/api/config', (req, res) => {
@@ -4419,6 +4495,7 @@ Keep responses concise. Help them think, don't lecture them about the system the
       'port', 'journalistInterval', 'rotationThreshold', 'autoRotation',
       'qcThreshold', 'maxAgents', 'defaultProvider', 'defaultWorkingDir',
       'onboardingDismissed', 'defaultModel', 'defaultChatProvider', 'defaultChatModel',
+      'training_opt_in',
     ];
     for (const key of Object.keys(req.body)) {
       if (!ALLOWED_KEYS.includes(key)) {

package/packages/daemon/src/index.js

@@ -43,6 +43,7 @@ import { LlamaServerManager } from './llama-server.js';
 import { RepoImporter } from './repo-import.js';
 import { ConversationManager } from './conversations.js';
 import { Toys } from './toys.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';
 import { setProviderPaths } from './providers/index.js';
@@ -151,6 +152,17 @@ export class Daemon {
     this.tunnelManager = new TunnelManager(this);
     this.repoImporter = new RepoImporter(this);
     this.toys = new Toys(this);
+    this.trajectoryCapture = null;
+
+    // Hook teams.delete to clean up agent-loop session files
+    const originalTeamDelete = this.teams.delete.bind(this.teams);
+    this.teams.delete = (id) => {
+      const agents = this.registry.getAll().filter(a => a.teamId === id);
+      const agentIds = agents.map(a => a.id);
+      const result = originalTeamDelete(id);
+      if (agentIds.length > 0) this.state.cleanupSessions(agentIds);
+      return result;
+    };
 
     // Subscription state (populated by Electron IPC or direct auth)
     this.authToken = null;
@@ -390,6 +402,20 @@ export class Daemon {
         client.send(payload);
       }
     }
+    if (this.trajectoryCapture && message.type) {
+      try {
+        if (['approval:request', 'approval:resolved', 'conflict:detected', 'qc:activated'].includes(message.type)) {
+          const agentId = message.data?.agentId || message.agentId;
+          if (agentId) {
+            this.trajectoryCapture.onCoordinationEvent(agentId, {
+              type: message.type,
+              data: message.data,
+              timestamp: Date.now(),
+            });
+          }
+        }
+      } catch (e) { /* fail silent */ }
+    }
   }
 
   async setAuthToken(token) {
@@ -527,6 +553,17 @@ export class Daemon {
     const purged = this.locks.purgeOrphans(runningIds);
     if (purged > 0) console.log(`  Purged ${purged} orphaned lock(s) from previous session`);
 
+    // Mark agents with saved agent-loop sessions as resumable
+    const resumableIds = new Set(this.state.getResumableSessions());
+    if (resumableIds.size > 0) {
+      for (const agent of this.registry.getAll()) {
+        if (resumableIds.has(agent.id) && (agent.status === 'running' || agent.status === 'idle' || agent.status === 'completed')) {
+          this.registry.update(agent.id, { status: 'completed', hasSession: true, pid: null });
+        }
+      }
+      console.log(`  ${resumableIds.size} agent-loop session(s) marked as resumable`);
+    }
+
     // Migrate old agents without teamId to default team
     this.teams.migrateAgents();
 
@@ -542,6 +579,7 @@ export class Daemon {
         printWelcome(this.port, this.host, this._firstRun);
 
         // Start background services
+        this._initTrajectoryCapture().catch(() => {});
         this.journalist.start();
         this.rotator.start();
         this.scheduler.start();
@@ -627,6 +665,23 @@ export class Daemon {
     });
   }
 
+  async _initTrajectoryCapture() {
+    if (!this.config.training_opt_in) return;
+    try {
+      if (ConsentManager.isCaptureEnabled()) {
+        const pkgPath = new URL('../package.json', import.meta.url);
+        const version = JSON.parse(readFileSync(pkgPath, 'utf8')).version;
+        this.trajectoryCapture = new TrajectoryCapture({
+          centralCommandUrl: process.env.GROOVE_CENTRAL_URL || 'https://api.groovedev.ai',
+          grooveVersion: version,
+        });
+        this.trajectoryCapture.init();
+      }
+    } catch (e) {
+      // Training capture is never critical
+    }
+  }
+
   _startGarbageCollector() {
     // Run once on startup, then every 24 hours
     this._gc();
@@ -737,6 +792,12 @@ export class Daemon {
     // Disconnect all SSH tunnels
     this.tunnelManager.shutdown();
 
+    // Shut down training capture
+    if (this.trajectoryCapture) {
+      try { await this.trajectoryCapture.shutdown(); } catch (e) { /* fail silent */ }
+      this.trajectoryCapture = null;
+    }
+
     // Kill all agent processes, stop MCP servers, and stop inference servers
     await this.processes.killAll();
     if (this.preview) await this.preview.killAll();

package/packages/daemon/src/journalist.js

@@ -540,27 +540,76 @@ export class Journalist {
   }
 
   async callHeadless(prompt, { trackAs = '__journalist__' } = {}) {
-    // Find the best available provider for headless synthesis
-    // Priority: claude-code (cheapest via Haiku) > gemini > codex > ollama
-    const priority = ['claude-code', 'gemini', 'codex', 'ollama'];
+    const priority = ['claude-code', 'gemini', 'codex', 'grok', 'ollama'];
     const installed = getInstalledProviders();
-    const providerId = priority.find((p) => installed.some((i) => i.id === p));
-    if (!providerId) {
-      throw new Error('No provider available for synthesis');
+
+    for (const providerId of priority) {
+      if (!installed.some((i) => i.id === providerId)) continue;
+
+      const provider = getProvider(providerId);
+      if (!provider) continue;
+
+      const selectedModel = provider.constructor.models?.find((m) => m.tier === 'medium')
+        || provider.constructor.models?.find((m) => m.tier === 'light')
+        || provider.constructor.models?.[0];
+      const modelId = selectedModel?.id || null;
+
+      // Try CLI headless command first
+      const headlessCmd = provider.buildHeadlessCommand(prompt, modelId);
+      if (headlessCmd) {
+        try {
+          return await this._execHeadlessCmd(headlessCmd, trackAs, modelId);
+        } catch {
+          continue;
+        }
+      }
+
+      // Fallback: streamChat for API-only providers (e.g. Grok)
+      if (typeof provider.streamChat === 'function') {
+        const apiKey = this.daemon.credentials?.getKey(providerId);
+        if (!apiKey) continue;
+
+        try {
+          const text = await new Promise((resolve, reject) => {
+            let collected = '';
+            const ctrl = provider.streamChat(
+              [{ role: 'user', content: prompt }],
+              modelId,
+              apiKey,
+              (chunk) => { collected += chunk; },
+              () => resolve(collected),
+              (err) => reject(err),
+            );
+            if (!ctrl) reject(new Error('streamChat unavailable'));
+          });
+
+          if (text) {
+            const estimatedInputTokens = Math.ceil(prompt.length / 4);
+            const estimatedOutputTokens = Math.ceil(text.length / 4);
+            if (this.daemon?.tokens) {
+              this.daemon.tokens.record(trackAs, {
+                tokens: estimatedInputTokens + estimatedOutputTokens,
+                inputTokens: estimatedInputTokens,
+                outputTokens: estimatedOutputTokens,
+                model: modelId,
+                estimatedCostUsd: 0,
+              });
+            }
+            return text;
+          }
+        } catch {
+          continue;
+        }
+      }
     }
-    const provider = getProvider(providerId);
 
-    // Pick medium tier for higher-quality synthesis (fewer but better cycles)
-    const selectedModel = provider.constructor.models?.find((m) => m.tier === 'medium')
-      || provider.constructor.models?.find((m) => m.tier === 'light')
-      || provider.constructor.models?.[0];
-    const modelId = selectedModel?.id || null;
+    throw new Error('No provider available for synthesis');
+  }
 
-    const headlessCmd = provider.buildHeadlessCommand(prompt, modelId);
+  _execHeadlessCmd(headlessCmd, trackAs, modelId) {
     const { command, args, env, stdin: stdinData } = headlessCmd;
 
     return new Promise((resolve, reject) => {
-      // Use spawn with stdin pipe if provider needs it (e.g., Ollama)
       if (stdinData) {
         let stdout = '';
         const proc = cpSpawn(command, args, {
@@ -576,7 +625,6 @@ export class Journalist {
           clearTimeout(timer);
           if (code !== 0) return reject(new Error(`Headless exited with code ${code}`));
           this._recordHeadlessUsage(stdout, trackAs, modelId);
-          // Process stdout same as execFile path below
           const lines = stdout.split('\n');
           for (const line of lines) {
             try {
@@ -590,17 +638,14 @@ export class Journalist {
         return;
       }
 
-      const proc = execFile(command, args, {
+      execFile(command, args, {
         env: { ...process.env, ...env },
         cwd: this.daemon.projectDir,
         maxBuffer: 1024 * 1024 * 5,
         timeout: 60_000,
       }, (err, stdout, stderr) => {
         if (err) return reject(err);
-
         this._recordHeadlessUsage(stdout, trackAs, modelId);
-
-        // Parse stream-json output to extract the result text
         const lines = stdout.split('\n');
         for (const line of lines) {
           try {
@@ -610,8 +655,6 @@ export class Journalist {
             }
           } catch { /* skip */ }
         }
-
-        // Fallback: return raw stdout
         resolve(stdout);
       });
     });

package/packages/daemon/src/preview.js

@@ -168,6 +168,20 @@ export class PreviewService {
     if (!command) {
       return Promise.resolve({ launched: false, reason: 'no_command' });
     }
+    // If command references an npm script, verify it exists in package.json
+    const npmRunMatch = command.match(/npm\s+run\s+(\S+)/);
+    if (npmRunMatch) {
+      const scriptName = npmRunMatch[1];
+      const pkgPath = resolve(baseDir, 'package.json');
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+        if (!pkg.scripts || !pkg.scripts[scriptName]) {
+          return Promise.resolve({ launched: false, reason: 'no_dev_script' });
+        }
+      } catch {
+        return Promise.resolve({ launched: false, reason: 'no_dev_script' });
+      }
+    }
     const urlPattern = preview.urlPattern
       ? new RegExp(preview.urlPattern)
       : /https?:\/\/(localhost|127\.0\.0\.1|0\.0\.0\.0):\d+/;

package/packages/daemon/src/process.js

@@ -114,6 +114,9 @@ CRITICAL — NEVER DO THESE:
 - NEVER kill the daemon process. No "kill <pid>", "pkill groove", "killall node", etc.
 - NEVER run "./promote.sh", "./promote-local.sh", or any publish/deploy script.
 - NEVER start long-running dev servers (vite dev, npm start, next dev, etc.).
+- NEVER use 'git add -f' or 'git add --force' to bypass .gitignore. If a file is gitignored, it should stay gitignored. Only stage files that git tracks normally. If .gitignore prevents staging, report it in your output — do NOT force-add.
+- NEVER use 'git push --force' or 'git push -f'. Force-pushing can destroy shared history.
+- NEVER modify .gitignore to include files that were previously excluded.
 
 Restarting the daemon destroys ALL other agents currently running in other teams. Verification is done via "npm run build" and "npm test", which exit cleanly. If code changes require a daemon restart to take effect, report that in your output so the user can restart manually — do NOT do it yourself.
 
@@ -463,6 +466,15 @@ export class ProcessManager {
       model: isAutoRouted ? null : config.model, // Set after routing
     });
 
+    if (this.daemon.trajectoryCapture) {
+      try {
+        const teamSize = registry.getAll().filter(a => a.status === 'active' || a.status === 'running' || a.status === 'starting').length;
+        this.daemon.trajectoryCapture.onAgentSpawn(
+          agent.id, providerName, config.model || null, config.role, teamSize
+        ).catch(() => {});
+      } catch (e) { /* fail silent */ }
+    }
+
     // Auto-route: let the router pick the model based on role/complexity
     if (isAutoRouted) {
       const { router } = this.daemon;
@@ -666,6 +678,12 @@ For normal file edits within your scope, proceed without review.
     const logPath = resolve(logDir, `${sanitizeFilename(agent.name)}.log`);
     const logStream = createWriteStream(logPath, { flags: 'a', mode: 0o600 });
 
+    // Inject API key from credential store for agent-loop providers
+    if (provider.constructor.useAgentLoop && this.daemon.credentials) {
+      const storedKey = this.daemon.credentials.getKey(providerName);
+      if (storedKey) spawnConfig.apiKey = storedKey;
+    }
+
     // ─── Agent Loop path (local models with built-in agentic runtime) ───
     if (provider.constructor.useAgentLoop) {
       const loopConfig = provider.getLoopConfig(spawnConfig);
@@ -875,6 +893,22 @@ For normal file edits within your scope, proceed without review.
         });
       }
 
+      if (this.daemon.trajectoryCapture) {
+        try {
+          if (finalStatus === 'completed') {
+            this.daemon.trajectoryCapture.onAgentComplete(agent.id, {
+              status: 'SUCCESS', exit_code: code, signal,
+            });
+          } else {
+            this.daemon.trajectoryCapture.onAgentCrash(agent.id,
+              signal ? 'Killed by signal ' + signal : 'Exit code ' + code
+            );
+          }
+          const count = (this.daemon.state.get('training_sessions_captured') || 0) + 1;
+          this.daemon.state.set('training_sessions_captured', count);
+        } catch (e) { /* fail silent */ }
+      }
+
       this.daemon.broadcast({
         type: 'agent:exit',
         agentId: agent.id,
@@ -1022,6 +1056,12 @@ For normal file edits within your scope, proceed without review.
       } catch (err) {
         console.error(`[Groove] parseOutput error for ${agentId}: ${err.message}`);
       }
+      if (this.daemon.trajectoryCapture) {
+        try {
+          const parsed = JSON.parse(line);
+          this.daemon.trajectoryCapture.onStdoutLine(agentId, parsed);
+        } catch (e) { /* fail silent — non-JSON lines are expected */ }
+      }
     }
   }
 
@@ -1161,7 +1201,7 @@ For normal file edits within your scope, proceed without review.
     const workingDir = plan.workingDir;
     preview.launch(teamId, workingDir, plan.preview).then((result) => {
       if (!result.launched) {
-        const intentionalSkips = new Set(['no_preview', 'cli', 'none']);
+        const intentionalSkips = new Set(['no_preview', 'cli', 'none', 'no_command', 'no_dev_script']);
         if (intentionalSkips.has(result.reason)) {
           console.log(`[Groove] Preview for team ${teamId} intentionally skipped: ${result.reason}`);
           return;
@@ -1497,6 +1537,15 @@ For normal file edits within your scope, proceed without review.
     const agent = registry.get(agentId);
     if (!agent) throw new Error(`Agent ${agentId} not found`);
 
+    // Agent-loop providers: resume from saved session file
+    const resumeProvider = getProvider(agent.provider || 'claude-code');
+    if (resumeProvider?.constructor?.useAgentLoop) {
+      const sessionPath = resolve(this.daemon.grooveDir, 'sessions', `${agentId}.json`);
+      if (existsSync(sessionPath)) {
+        return this._resumeAgentLoop(agentId, agent, message, resumeProvider);
+      }
+    }
+
     // If no session ID, fall back to rotation (handoff brief)
     if (!agent.sessionId) {
       return this.daemon.rotator.rotate(agentId, { additionalPrompt: message });
@@ -1642,6 +1691,155 @@ For normal file edits within your scope, proceed without review.
     return newAgent;
   }
 
+  async _resumeAgentLoop(agentId, agent, message, provider) {
+    const { registry, locks } = this.daemon;
+    const config = { ...agent };
+
+    if (this.handles.has(agentId)) {
+      await this.kill(agentId);
+    }
+    registry.remove(agentId);
+    locks.release(agentId);
+
+    const newAgent = registry.add({
+      role: config.role,
+      scope: config.scope,
+      provider: config.provider,
+      model: config.model,
+      prompt: config.prompt,
+      permission: config.permission,
+      workingDir: config.workingDir || undefined,
+      name: config.name,
+      teamId: config.teamId,
+    });
+
+    if (config.tokensUsed > 0) {
+      registry.update(newAgent.id, { tokensUsed: config.tokensUsed });
+    }
+
+    if (newAgent.scope?.length > 0) {
+      locks.register(newAgent.id, newAgent.scope, newAgent.workingDir);
+    }
+
+    // Move session file from old agent ID to new agent ID
+    const sessionsDir = resolve(this.daemon.grooveDir, 'sessions');
+    const oldSessionPath = resolve(sessionsDir, `${agentId}.json`);
+    const newSessionPath = resolve(sessionsDir, `${newAgent.id}.json`);
+    if (oldSessionPath !== newSessionPath && existsSync(oldSessionPath)) {
+      try {
+        mkdirSync(sessionsDir, { recursive: true });
+        copyFileSync(oldSessionPath, newSessionPath);
+        unlinkSync(oldSessionPath);
+      } catch { /* AgentLoop will start fresh if file is missing */ }
+    }
+
+    const logDir = resolve(this.daemon.grooveDir, 'logs');
+    mkdirSync(logDir, { recursive: true });
+    const logPath = resolve(logDir, `${sanitizeFilename(newAgent.name)}.log`);
+    const logStream = createWriteStream(logPath, { flags: 'a', mode: 0o600 });
+    logStream.write(`[${new Date().toISOString()}] GROOVE resuming agent-loop session\n`);
+
+    // Inject API key
+    const spawnConfig = { ...newAgent, ...config };
+    if (this.daemon.credentials) {
+      const storedKey = this.daemon.credentials.getKey(newAgent.provider);
+      if (storedKey) spawnConfig.apiKey = storedKey;
+    }
+
+    const loopConfig = provider.getLoopConfig(spawnConfig);
+    const loop = new AgentLoop({ daemon: this.daemon, agent: newAgent, loopConfig, logStream });
+
+    this.handles.set(newAgent.id, { loop, logStream });
+    registry.update(newAgent.id, { status: 'running' });
+
+    if (this.daemon.timeline) {
+      this.daemon.timeline.recordEvent('spawn', {
+        agentId: newAgent.id, agentName: newAgent.name, role: newAgent.role,
+        provider: newAgent.provider, model: loopConfig.model,
+      });
+    }
+
+    loop.on('output', (output) => {
+      this._handleAgentOutput(newAgent.id, output);
+    });
+
+    loop.on('exit', ({ code, signal, status }) => {
+      logStream.write(`[${new Date().toISOString()}] Agent loop exited: status=${status}\n`);
+      logStream.end();
+      this.handles.delete(newAgent.id);
+
+      const throttle = this._streamThrottle.get(newAgent.id);
+      if (throttle?.timer) clearTimeout(throttle.timer);
+      this._streamThrottle.delete(newAgent.id);
+      this.peakContextUsage.delete(newAgent.id);
+      this.pendingMessages.delete(newAgent.id);
+      registry.update(newAgent.id, { status, pid: null });
+
+      const agentData = registry.get(newAgent.id);
+
+      if (this.daemon.timeline) {
+        const evtType = status === 'completed' ? 'complete' : status === 'crashed' ? 'crash' : 'kill';
+        this.daemon.timeline.recordEvent(evtType, {
+          agentId: newAgent.id, agentName: newAgent.name, role: newAgent.role,
+          finalTokens: agentData?.tokensUsed || 0, costUsd: agentData?.costUsd || 0,
+        });
+      }
+
+      this.daemon.broadcast({ type: 'agent:exit', agentId: newAgent.id, code: code || 0, signal, status });
+      if (this.daemon.integrations) this.daemon.integrations.refreshMcpJson();
+
+      if (status === 'completed' && this.daemon.journalist) {
+        const turns = agentData?.turns || 0;
+        const tok = agentData?.tokensUsed || 0;
+        if (turns > 1 || tok >= 100) this.daemon.journalist.requestSynthesis('completion');
+      }
+      this._checkPhase2(newAgent.id);
+
+      if (status === 'completed') {
+        const files = this.daemon.journalist?.getAgentFiles(newAgent) || [];
+        if (files.length > 0) this._triggerIdleQC(newAgent);
+        this._processHandoffs(newAgent);
+        if (this._rotatingAgents.has(newAgent.id)) {
+          this._rotatingAgents.delete(newAgent.id);
+        } else {
+          this._writeCompletionHandoff(newAgent).catch(err =>
+            console.error(`[Groove] Completion handoff failed for ${newAgent.name}:`, err.message));
+        }
+      }
+    });
+
+    loop.on('error', ({ message: errMsg }) => {
+      this.daemon.broadcast({
+        type: 'agent:output', agentId: newAgent.id,
+        data: { type: 'activity', subtype: 'error', data: errMsg },
+      });
+    });
+
+    loop.start();
+    loop.sendMessage(message);
+
+    this.daemon.broadcast({
+      type: 'rotation:complete',
+      agentId: newAgent.id,
+      agentName: newAgent.name,
+      oldAgentId: agentId,
+      reason: 'resume',
+      tokensSaved: 0,
+    });
+
+    return newAgent;
+  }
+
+  cleanupTeamSessions(teamId) {
+    const { registry } = this.daemon;
+    const teamAgents = registry.getAll().filter(a => a.teamId === teamId);
+    const sessionsDir = resolve(this.daemon.grooveDir, 'sessions');
+    for (const agent of teamAgents) {
+      const sessionPath = resolve(sessionsDir, `${agent.id}.json`);
+      try { if (existsSync(sessionPath)) unlinkSync(sessionPath); } catch { /* non-fatal */ }
+    }
+  }
+
   /**
    * Stop the agent's current work without killing the agent.
    * The process is terminated but the agent stays in the registry with its
@@ -1749,6 +1947,10 @@ For normal file edits within your scope, proceed without review.
     const agent = this.daemon.registry.get(agentId);
     const wrapped = agent ? wrapWithRoleReminder(agent.role, message) : message;
 
+    if (this.daemon.trajectoryCapture) {
+      try { this.daemon.trajectoryCapture.onUserMessage(agentId, message); } catch (e) { /* fail silent */ }
+    }
+
     loop.sendMessage(wrapped).catch(() => {});
     return true;
   }

package/packages/daemon/src/providers/grok.js

@@ -37,6 +37,7 @@ export class GrokProvider extends Provider {
     { id: 'grok-3-mini', name: 'Grok 3 Mini', tier: 'light', maxContext: 131072, pricing: { input: 0.0003, output: 0.0005 } },
     { id: 'grok-imagine-image', name: 'Grok Imagine', tier: 'medium', type: 'image', pricing: { perImage: 0.07 } },
   ];
+  static useAgentLoop = true;
 
   static isInstalled() {
     return true; // API-only, no CLI needed
@@ -54,6 +55,20 @@ export class GrokProvider extends Provider {
     return null; // No CLI
   }
 
+  getLoopConfig(agent) {
+    return {
+      apiBase: 'https://api.x.ai/v1',
+      model: agent.model || 'grok-4-1-fast',
+      contextWindow: 131072,
+      temperature: 0.1,
+      maxResponseTokens: 16384,
+      stream: true,
+      apiKey: agent.apiKey,
+      headers: {},
+      introContext: agent.introContext || '',
+    };
+  }
+
   switchModel() {
     return false;
   }

package/packages/daemon/src/state.js

@@ -1,12 +1,13 @@
 // GROOVE — State Persistence
 // FSL-1.1-Apache-2.0 — see LICENSE
 
-import { readFileSync, existsSync } from 'fs';
+import { readFileSync, existsSync, readdirSync, unlinkSync } from 'fs';
 import { writeFile } from 'node:fs/promises';
 import { resolve } from 'path';
 
 export class StateManager {
   constructor(grooveDir) {
+    this.grooveDir = grooveDir;
     this.path = resolve(grooveDir, 'state.json');
     this.data = {};
   }
@@ -32,4 +33,22 @@ export class StateManager {
   set(key, value) {
     this.data[key] = value;
   }
+
+  getResumableSessions() {
+    const sessionsDir = resolve(this.grooveDir, 'sessions');
+    if (!existsSync(sessionsDir)) return [];
+    try {
+      return readdirSync(sessionsDir)
+        .filter(f => f.endsWith('.json'))
+        .map(f => f.replace('.json', ''));
+    } catch { return []; }
+  }
+
+  cleanupSessions(agentIds) {
+    const sessionsDir = resolve(this.grooveDir, 'sessions');
+    for (const id of agentIds) {
+      const sessionPath = resolve(sessionsDir, `${id}.json`);
+      try { if (existsSync(sessionPath)) unlinkSync(sessionPath); } catch { /* non-fatal */ }
+    }
+  }
 }