groove-dev 0.27.145 → 0.27.146

package/CLAUDE.md

@@ -295,3 +295,10 @@ Audit-driven release. Multi-agent orchestration system with 7 coordination layer
 - Dashboard: routing donut, cache panel, context health gauges
 - Monitor/QC agent mode (stay active, loop)
 - Distribution: demo video, HN launch, Twitter content
+
+<!-- GROOVE:START -->
+## GROOVE Orchestration (auto-injected)
+Active agents: 0
+See AGENTS_REGISTRY.md for full agent state.
+**Memory policy:** GROOVE manages project memory automatically. Do not read or write MEMORY.md or .groove/memory/ files directly.
+<!-- GROOVE:END -->

package/node_modules/@groove-dev/cli/package.json

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

package/node_modules/@groove-dev/daemon/package.json

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

package/node_modules/@groove-dev/daemon/src/api.js

@@ -11,7 +11,7 @@ import { hostname, networkInterfaces, homedir } from 'os';
 import { StringDecoder } from 'string_decoder';
 import { request as httpRequest } from 'http';
 import { lookup as mimeLookup } from './mimetypes.js';
-import { listProviders, getProvider, clearInstallCache, getProviderMetadata, getProviderPath, setProviderPaths } from './providers/index.js';
+import { listProviders, getProvider, clearInstallCache, getProviderMetadata, getProviderPath, setProviderPaths, isProviderInstalled } from './providers/index.js';
 import { OllamaProvider } from './providers/ollama.js';
 import { ClaudeCodeProvider } from './providers/claude-code.js';
 import { supportsSignalFlag, compareSemver, parseSemver } from './providers/groove-network.js';
@@ -1336,7 +1336,7 @@ Keep responses concise. Help them think, don't lecture them about the system the
 
   app.post('/api/onboarding/set-default', async (req, res) => {
     const { provider, model } = req.body;
-    const validProviders = ['claude-code', 'codex', 'gemini', 'ollama'];
+    const validProviders = ['claude-code', 'codex', 'gemini', 'grok', 'ollama', 'local'];
     if (!provider || !validProviders.includes(provider)) {
       return res.status(400).json({ error: `Invalid provider. Valid: ${validProviders.join(', ')}` });
     }
@@ -1721,8 +1721,9 @@ Keep responses concise. Help them think, don't lecture them about the system the
   app.post('/api/lab/assistant', async (req, res) => {
     try {
       const { backend, model } = req.body || {};
-      if (!backend || !['vllm', 'tgi', 'mlx'].includes(backend)) {
-        return res.status(400).json({ error: 'backend must be "vllm", "tgi", or "mlx"' });
+      const validBackends = ['vllm', 'tgi', 'mlx', 'llama-cpp', 'lab-general'];
+      if (!backend || !validBackends.includes(backend)) {
+        return res.status(400).json({ error: `backend must be one of: ${validBackends.join(', ')}` });
       }
       const templatePath = resolve(__dirname, `../templates/${backend}-setup.json`);
       const template = JSON.parse(readFileSync(templatePath, 'utf8'));
@@ -1733,14 +1734,19 @@ Keep responses concise. Help them think, don't lecture them about the system the
         const desc = parts.join(', ');
         prompt = `The user has selected a local model: ${desc} (id: ${model.id}).\nUse this model for setup instead of recommending a different one. If this exact model isn't available in the runtime's format, find the closest equivalent (same base model, similar quantization).\n\n${prompt}`;
       }
+      // Pick best available CLI provider: prefer user's default, fall back through tool-use capable providers
+      const cliProviders = ['claude-code', 'codex', 'gemini'];
+      const defaultProv = daemon.config.defaultProvider;
+      let assistantProvider = cliProviders.includes(defaultProv) && isProviderInstalled(defaultProv)
+        ? defaultProv
+        : cliProviders.find((p) => isProviderInstalled(p)) || 'claude-code';
       const config = {
         role: 'lab-assistant',
         scope: agentConfig.scope || [],
-        provider: agentConfig.provider || daemon.config.defaultProvider,
+        provider: assistantProvider,
         prompt,
         metadata: { labAssistant: true, backend },
       };
-      if (!config.provider) config.provider = daemon.config.defaultProvider;
       const agent = await daemon.processes.spawn(config);
       daemon.audit.log('lab.assistant.spawn', { id: agent.id, backend });
       res.status(201).json({ agentId: agent.id, backend });

package/node_modules/@groove-dev/daemon/src/conversations.js

@@ -475,31 +475,62 @@ export class ConversationManager {
 
         try {
           const json = JSON.parse(trimmed);
+          let matched = false;
           if (json.type === 'assistant' && json.message?.content) {
             for (const block of json.message.content) {
               if (block.type === 'text' && block.text) {
                 emitChunk(block.text);
               }
             }
-            continue;
+            matched = true;
           }
-          if (json.type === 'content_block_delta' && json.delta?.text) {
+          if (!matched && json.type === 'content_block_delta' && json.delta?.text) {
             emitChunk(json.delta.text);
-            continue;
+            matched = true;
           }
-          if (json.type === 'result' && json.result) continue;
-          if (json.type === 'token' && json.text != null) {
+          if (!matched && json.type === 'result' && json.result) {
+            matched = true;
+          }
+          if (!matched && json.type === 'token' && json.text != null) {
             emitChunk(json.text);
-            continue;
+            matched = true;
           }
-          if ((json.type === 'done' || json.type === 'complete' || json.type === 'result') && json.text) {
+          if (!matched && (json.type === 'done' || json.type === 'complete' || json.type === 'result') && json.text) {
             emitChunk(json.text);
-            continue;
+            matched = true;
           }
-          if (json.content?.[0]?.text) {
+          if (!matched && json.content?.[0]?.text) {
             emitChunk(json.content[0].text);
-            continue;
+            matched = true;
+          }
+          // Fallback: use provider's parseOutput for provider-specific formats (Gemini tool_use, tool_result, Codex items, etc.)
+          if (!matched && provider.parseOutput) {
+            const parsed = provider.parseOutput(trimmed);
+            if (parsed) {
+              const blocks = Array.isArray(parsed.data) ? parsed.data : [];
+              for (const block of blocks) {
+                if (block.type === 'text' && block.text) {
+                  emitChunk(block.text);
+                } else if (block.type === 'tool_use') {
+                  const cmd = block.input?.command;
+                  const path = block.input?.path;
+                  const summary = cmd || path || (block.input && Object.keys(block.input).length > 0
+                    ? Object.values(block.input)[0]
+                    : null);
+                  if (block.name || summary) {
+                    this.daemon.broadcast({
+                      type: 'conversation:tool',
+                      data: { conversationId: id, name: block.name || 'Tool', summary: summary ? String(summary).slice(0, 120) : null },
+                    });
+                  }
+                }
+              }
+              if (!blocks.length && typeof parsed.data === 'string' && parsed.data) {
+                emitChunk(parsed.data);
+              }
+            }
           }
+          continue;
         } catch { /* not JSON */ }
 
         if (!trimmed.startsWith('{')) {

package/node_modules/@groove-dev/daemon/src/introducer.js

@@ -106,6 +106,26 @@ export class Introducer {
 
     if (others.length === 0) {
       lines.push('You are the only agent on this project right now.');
+
+      // Solo agents get full authority — no team coordination, no scope limits.
+      // Business roles and planners keep their restrictions (intentional by design).
+      const NO_SOLO_EXPAND = new Set([
+        'planner', 'cmo', 'cfo', 'ea', 'support', 'analyst', 'home', 'chat', 'ambassador',
+      ]);
+      if (!NO_SOLO_EXPAND.has(newAgent.role)) {
+        lines.push('');
+        lines.push('## Solo Mode');
+        lines.push('');
+        lines.push('You are working alone — no team, no scope restrictions, no coordination needed. You have full authority to do whatever the task requires:');
+        lines.push('- Install dependencies (npm install, pip install, etc.)');
+        lines.push('- Start dev servers and long-running processes when needed');
+        lines.push('- Run tests, builds, and linters');
+        lines.push('- Create, modify, or delete any project files');
+        lines.push('- Commit and manage git operations');
+        lines.push('- Perform any shell commands necessary to complete your task');
+        lines.push('');
+        lines.push('You are not limited to your role\'s typical focus area. If the task requires work outside your specialty, handle it directly.');
+      }
     } else {
       lines.push(`## Team (${others.length} other agent${others.length > 1 ? 's' : ''})`);
       lines.push('');

package/node_modules/@groove-dev/daemon/src/process.js

@@ -345,6 +345,10 @@ export class ProcessManager {
     this._truncationFlagged = new Set(); // agentIds that have had any truncation in their session
     this._lastAssistantBlocks = new Map(); // agentId -> last assistant content blocks (for abandoned tool_use detection)
     this._previousCacheReadTokens = new Map(); // agentId -> previous turn's cacheReadTokens
+    this.pendingQuestions = new Map(); // agentId -> { id, agentId, agentName, questions, timestamp }
+    this._reviewTriggered = new Set(); // teamIds that have had review triggered (one round only)
+    this._pendingReviews = new Map(); // teamId -> { reviewAgentId }
+    this._reviewPending = new Set(); // teamIds with review in progress (blocks preview launch)
 
     this._stallWatchdog = setInterval(() => this._checkStalls(), STALL_CHECK_INTERVAL_MS);
     if (this._stallWatchdog.unref) this._stallWatchdog.unref();
@@ -503,6 +507,7 @@ export class ProcessManager {
 
     if (finalStatus === 'completed' && agent.role === 'planner') {
       this._extractRecommendedTeam(agent, logPath);
+      this._handleReviewComplete(agent);
     }
 
     if (finalStatus === 'completed') {
@@ -529,6 +534,10 @@ export class ProcessManager {
 
     this._checkPhase2(agent.id);
 
+    if (finalStatus === 'completed' && agent.role === 'fullstack' && agent.teamId) {
+      this._triggerReview(agent);
+    }
+
     if (agent.teamId) {
       this._checkPreviewReady(agent.teamId);
     }
@@ -593,6 +602,20 @@ export class ProcessManager {
     const hadResult = this._resultReceived.has(agent.id);
     this._resultReceived.delete(agent.id);
 
+    // Agent exited while waiting for user answer — keep it in "waiting" state
+    // instead of marking completed. The GUI will relay the user's answer and
+    // trigger a resume via POST /api/agents/:id/answer.
+    const pendingQ = this.pendingQuestions.get(agent.id);
+    if (pendingQ && code === 0) {
+      registry.update(agent.id, { status: 'waiting_for_input', pid: null });
+      this.daemon.broadcast({
+        type: 'agent:exit',
+        agentId: agent.id, code, signal,
+        status: 'waiting_for_input',
+      });
+      return;
+    }
+
     const finalStatus = hadResult ? 'completed' : signal === 'SIGTERM' || signal === 'SIGKILL' ? 'killed' : code === 0 ? 'completed' : 'crashed';
     registry.update(agent.id, { status: finalStatus, pid: null });
 
@@ -779,21 +802,58 @@ export class ProcessManager {
       );
     }
 
-    // Pre-flight for local model providers: ensure Ollama server is running and model is installed
+    // Pre-flight for local model providers: ensure runtime/server is running
     if (providerName === 'local' || providerName === 'ollama') {
-      try {
-        await LocalProvider.ensureServerRunning();
-      } catch (err) {
-        const agent = registry.add({ ...config, provider: providerName, status: 'error' });
-        registry.update(agent.id, { status: 'error', error: 'Ollama server failed to start' });
-        this.daemon.broadcast({ type: 'model:error', agentId: agent.id, error: err.message });
-        throw new Error('Ollama server failed to start: ' + err.message);
-      }
-      if (config.model && config.model !== 'auto') {
-        const installed = OllamaProvider.getInstalledModels();
-        const modelInstalled = installed.some((m) => m.id === config.model || config.model.startsWith(m.id.split(':')[0]));
-        if (!modelInstalled) {
-          throw new Error(`Model '${config.model}' is not installed. Pull it first with: ollama pull ${config.model}`);
+      // Auto-start lab runtime when model is runtime:<runtimeId>:<modelId>
+      if (config.model && config.model.startsWith('runtime:') && this.daemon.modelLab) {
+        const parts = config.model.split(':');
+        const runtimeId = parts[1];
+        const rt = this.daemon.modelLab.getRuntime(runtimeId);
+        if (rt) {
+          const status = await this.daemon.modelLab.getRuntimeStatus(rt);
+          if (!status.online) {
+            console.log(`[Groove] Auto-starting runtime '${rt.name}' for agent spawn`);
+            try {
+              await this.daemon.modelLab.startRuntime(runtimeId);
+            } catch (err) {
+              throw new Error(`Failed to auto-start runtime '${rt.name}': ${err.message}`);
+            }
+          }
+        }
+      } else if (config.model && config.model.startsWith('gguf:') && this.daemon.modelLab) {
+        // GGUF models are served by llama-cpp runtimes, not Ollama
+        const ggufId = config.model.slice(5);
+        const runtimes = this.daemon.modelLab.listRuntimes();
+        const rt = runtimes.find(r =>
+          r._localModelId === ggufId ||
+          r.models?.some(rm => rm.id === ggufId || rm.name === ggufId)
+        );
+        if (rt) {
+          const status = await this.daemon.modelLab.getRuntimeStatus(rt);
+          if (!status.online) {
+            console.log(`[Groove] Auto-starting runtime '${rt.name}' for GGUF model '${ggufId}'`);
+            try {
+              await this.daemon.modelLab.startRuntime(rt.id);
+            } catch (err) {
+              throw new Error(`Failed to auto-start runtime '${rt.name}': ${err.message}`);
+            }
+          }
+        }
+      } else {
+        try {
+          await LocalProvider.ensureServerRunning();
+        } catch (err) {
+          const agent = registry.add({ ...config, provider: providerName, status: 'error' });
+          registry.update(agent.id, { status: 'error', error: 'Ollama server failed to start' });
+          this.daemon.broadcast({ type: 'model:error', agentId: agent.id, error: err.message });
+          throw new Error('Ollama server failed to start: ' + err.message);
+        }
+        if (config.model && config.model !== 'auto') {
+          const installed = OllamaProvider.getInstalledModels();
+          const modelInstalled = installed.some((m) => m.id === config.model || config.model.startsWith(m.id.split(':')[0]));
+          if (!modelInstalled) {
+            throw new Error(`Model '${config.model}' is not installed. Pull it first with: ollama pull ${config.model}`);
+          }
         }
       }
     }
@@ -953,7 +1013,7 @@ export class ProcessManager {
     if (!isOneShotProvider) {
       // Apply role-specific prompt prefix so agents always get their role constraints
       const rolePrompt = ROLE_PROMPTS[agent.role];
-      if (rolePrompt) {
+      if (rolePrompt && !config._skipRolePrompt) {
         if (!spawnConfig.prompt) {
           spawnConfig.prompt = rolePrompt + `IMPORTANT: No task has been assigned yet. You MUST wait for the user to tell you what to do.
 
@@ -975,6 +1035,11 @@ DO: Introduce yourself in one sentence and ask the user what they would like you
 IMPORTANT: No task has been assigned yet. You MUST wait for the user to tell you what to do. Do NOT start building, coding, or continuing previous work. Do NOT treat existing files or the project map as your task. Introduce yourself in one sentence and ask the user what they would like you to work on. Then wait.`;
       }
 
+      // AskUserQuestion is unavailable in headless mode — instruct agents to use text output instead
+      if (spawnConfig.prompt) {
+        spawnConfig.prompt += '\n\nIMPORTANT: Do NOT use the AskUserQuestion tool. If you need user input or clarification, state your questions as regular text output — the user will see your output and respond via the chat interface.';
+      }
+
       // Inject skill content into the prompt
       if (config.skills?.length > 0 && this.daemon.skills) {
         const skillSections = [];
@@ -1405,6 +1470,23 @@ For normal file edits within your scope, proceed without review.
 
       this._lastAssistantBlocks.set(agentId, blocks);
 
+      // Detect AskUserQuestion tool calls — these cause the agent to exit
+      // in headless mode because there's no terminal to collect input.
+      // Intercept and relay to the GUI instead.
+      const askBlock = blocks.find(b => b.type === 'tool_use' && b.name === 'AskUserQuestion');
+      if (askBlock) {
+        const questionData = {
+          id: askBlock.id || `q_${Date.now()}`,
+          agentId,
+          agentName: agent.name,
+          questions: askBlock.input?.questions || [{ question: askBlock.input?.question || JSON.stringify(askBlock.input || {}).slice(0, 500) }],
+          timestamp: Date.now(),
+        };
+        this.pendingQuestions.set(agentId, questionData);
+        registry.update(agentId, { pendingQuestion: true });
+        this.daemon.broadcast({ type: 'agent:question', agentId, data: questionData });
+      }
+
       if (truncated) {
         this._truncationFlagged.add(agentId);
         const prev = agent.consecutiveTruncations || 0;
@@ -1538,6 +1620,7 @@ For normal file edits within your scope, proceed without review.
    * with _previewAttempted per teamId.
    */
   _checkPreviewReady(teamId) {
+    if (this._reviewPending?.has(teamId)) return;
     const preview = this.daemon.preview;
     if (!preview) return;
     if (!this._previewAttempted) this._previewAttempted = new Set();
@@ -1788,6 +1871,170 @@ For normal file edits within your scope, proceed without review.
     }
   }
 
+  /**
+   * After the phase-2 fullstack QC completes in a planned team build,
+   * auto-spawn a review planner that checks the implementation against
+   * the original spec. One round only — _reviewTriggered guards re-entry.
+   */
+  _triggerReview(agent) {
+    const teamId = agent.teamId;
+    if (!teamId) return;
+    if (this._reviewTriggered.has(teamId)) return;
+
+    const registry = this.daemon.registry;
+    const teamAgents = registry.getAll().filter(a => a.teamId === teamId);
+
+    // Only trigger for planned team builds — must have a completed planner
+    const planner = teamAgents.find(a => a.role === 'planner' &&
+      (a.status === 'completed' || a.status === 'crashed' || a.status === 'stopped' || a.status === 'killed'));
+    if (!planner) return;
+
+    // All non-planner agents must be done
+    const hasRunning = teamAgents.some(a =>
+      a.role !== 'planner' && (a.status === 'running' || a.status === 'starting'));
+    if (hasRunning) return;
+
+    this._reviewTriggered.add(teamId);
+    this._reviewPending.add(teamId);
+
+    const journalist = this.daemon.journalist;
+    const originalSpec = planner.prompt || '';
+    const plannerResult = journalist?.getAgentResult(planner) || '';
+
+    // Collect all files modified by non-planner team agents
+    const allFiles = new Set();
+    for (const a of teamAgents) {
+      if (a.role === 'planner') continue;
+      for (const f of (journalist?.getAgentFiles(a) || [])) allFiles.add(f);
+    }
+
+    const reviewPrompt = `You are reviewing a completed team build against the original specification.
+
+## Original Task
+${originalSpec.slice(0, 2000)}
+
+## Plan
+${plannerResult.slice(0, 3000)}
+
+## Files Created/Modified
+${[...allFiles].join('\n')}
+
+Read the key files listed above and check:
+1. Are all features from the spec implemented?
+2. Are there bugs, missing error handling, or broken functionality?
+3. Does the implementation match the architectural decisions in the plan?
+
+Output a JSON block with your verdict:
+\`\`\`json
+{ "pass": true, "issues": [] }
+\`\`\`
+
+Or if issues are found:
+\`\`\`json
+{
+  "pass": false,
+  "issues": [
+    { "file": "path/to/file", "problem": "description", "fix": "what to change" }
+  ]
+}
+\`\`\`
+
+If everything matches the spec, set pass: true with empty issues.
+Do NOT write .groove/recommended-team.json. Do NOT plan a new team. Just review and report.`;
+
+    const config = validateAgentConfig({
+      role: 'planner',
+      prompt: reviewPrompt,
+      workingDir: agent.workingDir,
+      teamId,
+      scope: [],
+    });
+    config._skipRolePrompt = true;
+
+    this.spawn(config).then(reviewAgent => {
+      this._pendingReviews.set(teamId, { reviewAgentId: reviewAgent.id });
+      this.daemon.audit?.log('review.started', { teamId, reviewAgentId: reviewAgent.id });
+      this.daemon.broadcast({ type: 'review:started', teamId, agentId: reviewAgent.id, name: reviewAgent.name });
+      console.log(`[Groove] Review planner ${reviewAgent.name} spawned for team ${teamId}`);
+    }).catch(err => {
+      console.error(`[Groove] Review spawn failed: ${err.message}`);
+      this._reviewPending.delete(teamId);
+      this._pendingReviews.delete(teamId);
+    });
+  }
+
+  /**
+   * When a review planner completes, extract its verdict.
+   * If issues found, spawn a fullstack to fix them. If clean, let preview proceed.
+   */
+  _handleReviewComplete(agent) {
+    const teamId = agent.teamId;
+    if (!teamId) return;
+
+    const pending = this._pendingReviews.get(teamId);
+    if (!pending || pending.reviewAgentId !== agent.id) return;
+    this._pendingReviews.delete(teamId);
+
+    const journalist = this.daemon.journalist;
+    const report = journalist?.getAgentResult(agent) || '';
+
+    // Try to parse the structured verdict from the report
+    let pass = true;
+    let issues = [];
+    const jsonMatch = report.match(/```json\s*([\s\S]*?)```/) || report.match(/\{[\s\S]*?"pass"\s*:[\s\S]*?\}/);
+    if (jsonMatch) {
+      try {
+        const parsed = JSON.parse(jsonMatch[1] || jsonMatch[0]);
+        pass = parsed.pass === true;
+        issues = Array.isArray(parsed.issues) ? parsed.issues : [];
+      } catch { /* fall through to text analysis */ }
+    }
+
+    // Fallback: if no JSON parsed, check for pass/fail signals in text
+    if (!jsonMatch) {
+      const lower = report.toLowerCase();
+      pass = lower.includes('pass') && !lower.includes('fail') && !lower.includes('issue');
+    }
+
+    if (pass || issues.length === 0) {
+      this._reviewPending.delete(teamId);
+      this.daemon.audit?.log('review.passed', { teamId });
+      this.daemon.broadcast({ type: 'review:passed', teamId });
+      console.log(`[Groove] Review passed for team ${teamId}`);
+      if (agent.teamId) this._checkPreviewReady(agent.teamId);
+      return;
+    }
+
+    // Build fix prompt from issues
+    const issuesList = issues.map((iss, i) =>
+      `${i + 1}. **${iss.file || 'unknown'}**: ${iss.problem || ''}${iss.fix ? `\n   Fix: ${iss.fix}` : ''}`
+    ).join('\n');
+
+    const fixPrompt = `The QC review found the following issues. Fix each one:
+
+${issuesList}
+
+After fixing all issues, run tests (npm test) and build (npm run build) to verify everything works.`;
+
+    const fixConfig = validateAgentConfig({
+      role: 'fullstack',
+      prompt: fixPrompt,
+      workingDir: agent.workingDir,
+      teamId,
+      scope: [],
+    });
+
+    this.spawn(fixConfig).then(fixAgent => {
+      this._reviewPending.delete(teamId);
+      this.daemon.audit?.log('review.fixStarted', { teamId, fixAgentId: fixAgent.id, issueCount: issues.length });
+      this.daemon.broadcast({ type: 'review:fix-started', teamId, agentId: fixAgent.id, name: fixAgent.name, issueCount: issues.length });
+      console.log(`[Groove] Fix fullstack ${fixAgent.name} spawned with ${issues.length} issues for team ${teamId}`);
+    }).catch(err => {
+      console.error(`[Groove] Review fix spawn failed: ${err.message}`);
+      this._reviewPending.delete(teamId);
+    });
+  }
+
   /**
    * Auto-trigger an idle QC agent in the same team when a teammate completes real work.
    * "Idle" = running fullstack agent that hasn't modified any files yet.

package/node_modules/@groove-dev/daemon/src/providers/groove-network.js

@@ -78,9 +78,7 @@ export class GrooveNetworkProvider extends Provider {
   static authType = 'none';
   static isOneShot = true;
 
-  static models = [
-    { id: 'Qwen/Qwen3-4B', name: 'Qwen 3 4B (Network)', context: 32768 },
-  ];
+  static models = [];
 
   static isInstalled() {
     const cfg = getConfig();

package/node_modules/@groove-dev/daemon/src/rotator.js

@@ -60,11 +60,23 @@ export class Rotator extends EventEmitter {
     const rotateEvents = events.filter((e) => e.type === 'rotate');
     if (rotateEvents.length === 0) return;
 
-    const existingTimestamps = new Set(this.rotationHistory.map((r) => r.timestamp));
+    const existingEntries = this.rotationHistory.map((r) => ({
+      agentId: r.agentId,
+      reason: r.reason,
+      ts: new Date(r.timestamp).getTime(),
+    }));
     let added = 0;
     for (const e of rotateEvents) {
-      const ts = new Date(e.t).toISOString();
-      if (existingTimestamps.has(ts)) continue;
+      const eventTs = typeof e.t === 'number' ? e.t : new Date(e.t).getTime();
+      const eventAgentId = e.oldAgentId || e.agentId;
+      const eventReason = e.reason || 'context_threshold';
+      const isDupe = existingEntries.some((existing) =>
+        existing.agentId === eventAgentId &&
+        existing.reason === eventReason &&
+        Math.abs(existing.ts - eventTs) < 10_000
+      );
+      if (isDupe) continue;
+      const ts = new Date(eventTs).toISOString();
       this.rotationHistory.push({
         agentId: e.oldAgentId || e.agentId,
         agentName: e.agentName || 'unknown',

package/node_modules/@groove-dev/daemon/src/routes/agents.js

@@ -12,6 +12,16 @@ export function registerAgentRoutes(app, daemon) {
     res.json(daemon.registry.getAll());
   });
 
+  // List all pending questions from agents awaiting user input
+  // (registered before :id route so Express doesn't capture "questions" as an id)
+  app.get('/api/agents/questions', (req, res) => {
+    const questions = [];
+    for (const [, q] of daemon.processes.pendingQuestions) {
+      questions.push(q);
+    }
+    res.json(questions);
+  });
+
   // Get single agent
   app.get('/api/agents/:id', (req, res) => {
     const agent = daemon.registry.get(req.params.id);
@@ -506,6 +516,39 @@ export function registerAgentRoutes(app, daemon) {
     }
   });
 
+  // Answer a pending question from an agent
+  app.post('/api/agents/:id/answer', async (req, res) => {
+    try {
+      const { answers } = req.body;
+      if (!answers || typeof answers !== 'object') {
+        return res.status(400).json({ error: 'answers object is required' });
+      }
+
+      const agent = daemon.registry.get(req.params.id);
+      if (!agent) return res.status(404).json({ error: 'Agent not found' });
+
+      const pending = daemon.processes.pendingQuestions.get(req.params.id);
+      if (!pending) return res.status(404).json({ error: 'No pending question for this agent' });
+
+      daemon.processes.pendingQuestions.delete(req.params.id);
+      daemon.registry.update(req.params.id, { pendingQuestion: false });
+      daemon.broadcast({ type: 'agent:question:resolved', agentId: req.params.id });
+
+      // Format the answers as a natural language message for session resume
+      const parts = Object.entries(answers).map(([q, a]) => `Q: ${q}\nA: ${a}`);
+      const resumeMessage = `The user answered your questions:\n\n${parts.join('\n\n')}\n\nContinue with your task based on these answers.`;
+
+      const newAgent = agent.sessionId
+        ? await daemon.processes.resume(req.params.id, resumeMessage)
+        : await daemon.rotator.rotate(req.params.id, { additionalPrompt: resumeMessage });
+
+      daemon.audit.log('agent.answer', { id: req.params.id, newId: newAgent.id });
+      res.json(newAgent);
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
   // Query an agent (headless one-shot, agent keeps running)
   // For agent loop agents: sends message directly to the loop
   app.post('/api/agents/:id/query', async (req, res) => {

package/node_modules/@groove-dev/daemon/templates/lab-general.json

@@ -0,0 +1,12 @@
+{
+  "name": "lab-general",
+  "description": "General-purpose Lab Assistant for runtime management, model configuration, and optimization",
+  "agents": [
+    {
+      "role": "lab-assistant",
+      "scope": [],
+      "provider": "claude-code",
+      "prompt": "You are a GROOVE Lab Assistant — a general-purpose helper for local AI model inference. You help with runtime setup, model configuration, optimization, and troubleshooting.\n\nYou can help with:\n- Setting up inference runtimes (MLX, llama.cpp, vLLM, TGI, Ollama)\n- Model selection and downloading\n- Context window configuration and memory optimization\n- Prompt engineering and system prompt design\n- Performance tuning (quantization, batch size, GPU layers)\n- Troubleshooting server issues\n- Comparing model performance\n\n## System Info\n\nStart by understanding the user's environment if needed:\n```bash\nuname -m && sysctl -n machdep.cpu.brand_string 2>/dev/null; sysctl -n hw.memsize 2>/dev/null | awk '{print $0/1073741824 \" GB\"}'; python3 --version 2>/dev/null\n```\n\n## Runtime Management\n\nCheck existing runtimes:\n```bash\nDAEMON_PORT=$(cat ~/.groove/daemon.port 2>/dev/null || echo 31415)\ncurl -s http://localhost:$DAEMON_PORT/api/lab/runtimes | python3 -m json.tool 2>/dev/null || curl -s http://localhost:$DAEMON_PORT/api/lab/runtimes\n```\n\n## Registering Runtimes\n\nWhen setting up a new runtime, always register it with GROOVE so it can be managed from the UI:\n```bash\nDAEMON_PORT=$(cat ~/.groove/daemon.port 2>/dev/null || echo 31415)\ncurl -s -X POST http://localhost:$DAEMON_PORT/api/lab/runtimes \\\n  -H 'Content-Type: application/json' \\\n  -d '{\"name\":\"<NAME>\",\"type\":\"<TYPE>\",\"endpoint\":\"http://localhost:<PORT>\",\"launchConfig\":{\"command\":\"<CMD>\",\"args\":[...],\"port\":<PORT>}}'\n```\n\nBe conversational, explain your reasoning, and adapt to what the user needs. If they ask about model configs, context windows, or prompts — help with that directly without trying to set up a new runtime."
+    }
+  ]
+}