groove-dev 0.27.140 → 0.27.142

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

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/cli",
-  "version": "0.27.140",
+  "version": "0.27.142",
   "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/integrations-registry.json

@@ -432,10 +432,10 @@
     "icon": "elevenlabs",
     "tags": ["voice", "tts", "audio", "speech"],
     "roles": ["creative", "cmo", "support"],
-    "npmPackage": "elevenlabs-mcp",
+    "npmPackage": "@angelogiacco/elevenlabs-mcp-server",
     "transport": "stdio",
     "command": "npx",
-    "args": ["-y", "elevenlabs-mcp"],
+    "args": ["-y", "@angelogiacco/elevenlabs-mcp-server"],
     "authType": "api-key",
     "envKeys": [
       { "key": "ELEVENLABS_API_KEY", "label": "API Key", "required": true }
@@ -491,10 +491,10 @@
     "icon": "hubspot",
     "tags": ["crm", "sales", "contacts", "marketing"],
     "roles": ["cmo", "analyst", "support"],
-    "npmPackage": "hubspot-mcp",
+    "npmPackage": "@hubspot/mcp-server",
     "transport": "stdio",
     "command": "npx",
-    "args": ["-y", "hubspot-mcp"],
+    "args": ["-y", "@hubspot/mcp-server"],
     "authType": "api-key",
     "envKeys": [
       { "key": "HUBSPOT_ACCESS_TOKEN", "label": "Private App Token", "required": true }
@@ -701,10 +701,10 @@
     "icon": "mixpanel",
     "tags": ["analytics", "events", "funnels", "users"],
     "roles": ["analyst", "cmo", "cfo"],
-    "npmPackage": "mixpanel-mcp",
+    "npmPackage": "@mercuryml/mcp-mixpanel",
     "transport": "stdio",
     "command": "npx",
-    "args": ["-y", "mixpanel-mcp"],
+    "args": ["-y", "@mercuryml/mcp-mixpanel"],
     "authType": "api-key",
     "envKeys": [
       { "key": "MIXPANEL_API_SECRET", "label": "API Secret", "required": true }
@@ -761,10 +761,10 @@
     "icon": "airtable",
     "tags": ["database", "spreadsheet", "content", "crm"],
     "roles": ["ea", "cmo", "analyst"],
-    "npmPackage": "airtable-mcp",
+    "npmPackage": "airtable-mcp-server",
     "transport": "stdio",
     "command": "npx",
-    "args": ["-y", "airtable-mcp"],
+    "args": ["-y", "airtable-mcp-server"],
     "authType": "api-key",
     "envKeys": [
       { "key": "AIRTABLE_API_KEY", "label": "Personal Access Token", "required": true }
@@ -823,10 +823,10 @@
     "icon": "intercom",
     "tags": ["chat", "support", "messaging", "customers"],
     "roles": ["support", "cmo"],
-    "npmPackage": "intercom-mcp",
+    "npmPackage": "@pipeworx/mcp-intercom",
     "transport": "stdio",
     "command": "npx",
-    "args": ["-y", "intercom-mcp"],
+    "args": ["-y", "@pipeworx/mcp-intercom"],
     "authType": "api-key",
     "envKeys": [
       { "key": "INTERCOM_ACCESS_TOKEN", "label": "Access Token", "required": true }
@@ -853,10 +853,10 @@
     "icon": "twilio",
     "tags": ["sms", "voice", "phone", "whatsapp"],
     "roles": ["ea", "support", "cmo"],
-    "npmPackage": "twilio-mcp",
+    "npmPackage": "@twilio-alpha/mcp",
     "transport": "stdio",
     "command": "npx",
-    "args": ["-y", "twilio-mcp"],
+    "args": ["-y", "@twilio-alpha/mcp"],
     "authType": "api-key",
     "envKeys": [
       { "key": "TWILIO_ACCOUNT_SID", "label": "Account SID", "placeholder": "AC...", "required": true },
@@ -939,37 +939,5 @@
     "rating": 0,
     "ratingCount": 0,
     "verified": "community"
-  },
-  {
-    "id": "plaid",
-    "name": "Plaid",
-    "description": "Bank connections and financial data",
-    "category": "finance",
-    "icon": "plaid",
-    "tags": ["banking", "transactions", "finance", "accounts"],
-    "roles": ["cfo", "analyst"],
-    "npmPackage": "plaid-mcp",
-    "transport": "stdio",
-    "command": "npx",
-    "args": ["-y", "plaid-mcp"],
-    "authType": "api-key",
-    "envKeys": [
-      { "key": "PLAID_CLIENT_ID", "label": "Client ID", "required": true },
-      { "key": "PLAID_SECRET", "label": "Secret", "required": true },
-      { "key": "PLAID_ENV", "label": "Environment", "placeholder": "sandbox", "required": false }
-    ],
-    "setupUrl": "https://dashboard.plaid.com/team/keys",
-    "setupSteps": [
-      "Click the link below to open Plaid team keys",
-      "Copy your Client ID and Secret",
-      "Use 'sandbox' environment for testing"
-    ],
-    "requiresApproval": [],
-    "agentInstructions": "## Plaid Integration\n\nYou have Plaid connected via GROOVE.\n\n### API\n`POST http://localhost:31415/api/integrations/plaid/exec`\nBody: `{\"tool\": \"<tool>\", \"params\": {...}}`\n\n### Common Tools\n- `get_accounts` — params: {access_token}\n- `get_transactions` — params: {access_token, start_date, end_date}\n- `get_balance` — params: {access_token}\n\n### Rules\n- Use sandbox environment for testing\n- Never expose access_tokens in output",
-    "featured": false,
-    "downloads": 0,
-    "rating": 0,
-    "ratingCount": 0,
-    "verified": "community"
   }
 ]

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

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

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

@@ -460,13 +460,14 @@ export function createApi(app, daemon) {
   // Discoveries (error → fix pairs)
   app.get('/api/memory/discoveries', (req, res) => {
     const role = req.query.role;
+    const teamId = req.query.teamId;
     const limit = Math.min(parseInt(req.query.limit) || 100, 500);
-    res.json({ discoveries: daemon.memory.listDiscoveries({ role, limit }) });
+    res.json({ discoveries: daemon.memory.listDiscoveries({ role, teamId, limit }) });
   });
 
   app.post('/api/memory/discoveries', (req, res) => {
-    const { agentId, role, trigger, fix, outcome } = req.body || {};
-    const result = daemon.memory.addDiscovery({ agentId, role, trigger, fix, outcome });
+    const { agentId, role, trigger, fix, outcome, teamId } = req.body || {};
+    const result = daemon.memory.addDiscovery({ agentId, role, trigger, fix, outcome, teamId });
     if (!result.added && result.error) {
       return res.status(400).json(result);
     }
@@ -3171,11 +3172,21 @@ Keep responses concise. Help them think, don't lecture them about the system the
 
   function validateFilePath(relPath, projectDir) {
     if (!relPath || typeof relPath !== 'string') return { error: 'path is required' };
-    if (relPath.startsWith('/') || relPath.includes('..') || relPath.includes('\0')) {
-      return { error: 'Invalid path' };
+    if (relPath.includes('\0')) return { error: 'Invalid path' };
+
+    let fullPath;
+    if (relPath.startsWith('/')) {
+      if (relPath.includes('..')) return { error: 'Invalid path' };
+      if (!relPath.startsWith(projectDir + '/') && relPath !== projectDir) {
+        return { error: 'Path outside project' };
+      }
+      fullPath = relPath;
+    } else {
+      if (relPath.includes('..')) return { error: 'Invalid path' };
+      fullPath = resolve(projectDir, relPath);
+      if (!fullPath.startsWith(projectDir)) return { error: 'Path outside project' };
     }
-    const fullPath = resolve(projectDir, relPath);
-    if (!fullPath.startsWith(projectDir)) return { error: 'Path outside project' };
+
     // Symlink resolution — ensure real path is also within project
     try {
       const realPath = realpathSync(fullPath);
@@ -3231,8 +3242,11 @@ Keep responses concise. Help them think, don't lecture them about the system the
       const raw = readdirSync(fullPath, { withFileTypes: true });
       const entries = [];
 
+      const HIDDEN_DIRS = new Set(['.git', 'node_modules', '.groove', '.next', '.nuxt', '__pycache__', '.venv', 'dist', '.cache']);
+      const HIDDEN_FILES = new Set(['.DS_Store']);
+
       const dirs = raw.filter((e) => {
-        if (e.name === '.DS_Store') return false;
+        if (HIDDEN_FILES.has(e.name) || HIDDEN_DIRS.has(e.name)) return false;
         if (e.isDirectory()) return true;
         if (e.isSymbolicLink()) {
           try { return statSync(resolve(fullPath, e.name)).isDirectory(); }
@@ -3241,7 +3255,7 @@ Keep responses concise. Help them think, don't lecture them about the system the
         return false;
       }).sort((a, b) => a.name.localeCompare(b.name));
       const files = raw.filter((e) => {
-        if (e.name === '.DS_Store') return false;
+        if (HIDDEN_FILES.has(e.name)) return false;
         if (e.isFile()) return true;
         if (e.isSymbolicLink()) {
           try { return statSync(resolve(fullPath, e.name)).isFile(); }
@@ -6986,30 +7000,93 @@ Keep responses concise. Help them think, don't lecture them about the system the
   app.post('/api/lab/inference', async (req, res) => {
     try {
       const params = validateLabInferenceParams(req.body);
+      const rt = daemon.modelLab.getRuntime(params.runtimeId);
+      if (!rt) throw new Error('Runtime not found');
+
+      const url = new URL(`${rt.endpoint}/v1/chat/completions`);
+      const reqHeaders = { 'Content-Type': 'application/json' };
+      if (rt.apiKey) reqHeaders['Authorization'] = `Bearer ${rt.apiKey}`;
+
+      const body = {
+        model: params.model,
+        messages: params.messages,
+        stream: true,
+      };
+      const pb = params.parameters || {};
+      if (pb.temperature !== undefined) body.temperature = pb.temperature;
+      if (pb.top_p !== undefined) body.top_p = pb.top_p;
+      if (pb.top_k !== undefined) body.top_k = pb.top_k;
+      if (pb.repeat_penalty !== undefined) body.repeat_penalty = pb.repeat_penalty;
+      if (pb.max_tokens !== undefined) body.max_tokens = pb.max_tokens;
+      if (pb.stop !== undefined) body.stop = pb.stop;
+      if (pb.frequency_penalty !== undefined) body.frequency_penalty = pb.frequency_penalty;
+      if (pb.presence_penalty !== undefined) body.presence_penalty = pb.presence_penalty;
+
+      const payload = JSON.stringify(body);
+
+      // Use Node http module directly — Electron's fetch has stream issues
+      const { request: httpRequest } = await import('http');
+      const upstream = await new Promise((resolve, reject) => {
+        const r = httpRequest({
+          hostname: url.hostname,
+          port: url.port,
+          path: url.pathname,
+          method: 'POST',
+          headers: { ...reqHeaders, 'Content-Length': Buffer.byteLength(payload) },
+          timeout: 300000,
+        }, resolve);
+        r.on('error', reject);
+        r.on('timeout', () => { r.destroy(); reject(new Error('Upstream timeout')); });
+        r.write(payload);
+        r.end();
+      });
+
+      if (upstream.statusCode !== 200) {
+        let errMsg = `HTTP ${upstream.statusCode}`;
+        try {
+          const chunks = [];
+          for await (const c of upstream) chunks.push(c);
+          const data = JSON.parse(Buffer.concat(chunks).toString());
+          errMsg = data.error?.message || errMsg;
+        } catch { /* ignore */ }
+        throw new Error(errMsg);
+      }
 
+      // Pipe raw OpenAI-compatible SSE straight to client
       res.setHeader('Content-Type', 'text/event-stream');
       res.setHeader('Cache-Control', 'no-cache');
       res.setHeader('Connection', 'keep-alive');
       res.setHeader('X-Accel-Buffering', 'no');
-      res.flushHeaders();
-
-      let closed = false;
-      req.on('close', () => { closed = true; });
-
-      await daemon.modelLab.streamInference(params, (event) => {
-        if (!closed) res.write(`data: ${JSON.stringify(event)}\n\n`);
-      });
-
-      if (!closed) {
-        res.write('data: [DONE]\n\n');
-        res.end();
+      upstream.pipe(res);
+
+      // Collect content for session persistence
+      if (params.sessionId) {
+        let full = '';
+        upstream.on('data', (chunk) => {
+          const text = chunk.toString('utf8');
+          for (const line of text.split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed.startsWith('data: ')) continue;
+            const d = trimmed.slice(6);
+            if (d === '[DONE]') continue;
+            try {
+              const p = JSON.parse(d);
+              const c = p.choices?.[0]?.delta?.content;
+              if (c) full += c;
+            } catch { /* skip */ }
+          }
+        });
+        upstream.on('end', () => {
+          if (full) daemon.modelLab._appendToSession(params.sessionId, params.messages, { role: 'assistant', content: full });
+        });
       }
+
+      req.on('close', () => { upstream.destroy(); });
     } catch (err) {
       if (!res.headersSent) {
         res.status(400).json({ error: err.message });
       } else {
-        res.write(`data: ${JSON.stringify({ type: 'error', error: err.message })}\n\n`);
-        res.end();
+        try { res.end(); } catch { /* ignore */ }
       }
     }
   });

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

@@ -127,6 +127,16 @@ export class IntegrationStore {
     if (this._isInstalled(integrationId)) throw new Error(`Integration already installed: ${integrationId}`);
 
     if (entry.npmPackage) {
+      // Pre-validate: check the package exists on npm before attempting install
+      try {
+        execFileSync('npm', ['view', entry.npmPackage, 'version'], {
+          stdio: 'pipe',
+          timeout: 10_000,
+        });
+      } catch {
+        throw new Error(`Package ${entry.npmPackage} is not available on npm. Use the agent-assisted install flow instead.`);
+      }
+
       try {
         execFileSync('npm', ['install', '--legacy-peer-deps', entry.npmPackage], {
           cwd: this.integrationsDir,

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

@@ -437,7 +437,7 @@ export class Introducer {
         }
 
         if (!isLightPlanner && (hasTask || isRotation)) {
-          const discoveries = this.daemon.memory.getDiscoveriesMarkdown(newAgent.role, 8, 600, newAgent.scope);
+          const discoveries = this.daemon.memory.getDiscoveriesMarkdown(newAgent.role, 8, 600, newAgent.scope, newAgent.teamId);
           if (discoveries) {
             parts.push(`### Known Fixes for ${newAgent.role} Role\n${discoveries}`);
           }

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

@@ -877,7 +877,7 @@ export class Journalist {
     const entries = agentLog?.entries || [];
 
     // Layer 7 memory: discoveries (inline, not pointer — agents lose context with pointers), constraints, specializations
-    const discoveries = this.daemon.memory?.getDiscoveriesMarkdown(agent.role, 10, 1500) || '';
+    const discoveries = this.daemon.memory?.getDiscoveriesMarkdown(agent.role, 10, 1500, agent.scope, agent.teamId) || '';
     const constraints = this.daemon.memory?.getConstraintsMarkdown(2000) || '';
     const specialization = this.daemon.memory?.getSpecialization(agent.id);
     const specLine = specialization?.avgQualityScore != null
@@ -994,6 +994,175 @@ export class Journalist {
     return brief;
   }
 
+  // --- Conversation Thread Extraction (for idle resume) ---
+
+  /**
+   * Extract the actual user↔assistant conversation from stream-json logs.
+   * Returns the dialogue in chronological order — user messages interleaved
+   * with Claude's text responses. This preserves the "why" context that
+   * handoff briefs lose through summarization.
+   *
+   * Budget: keeps recent turns verbatim, summarizes oldest if over maxChars.
+   */
+  extractConversationThread(agent, { maxChars = 60000 } = {}) {
+    const logPath = resolve(this.daemon.grooveDir, 'logs', `${agent.name}.log`);
+    if (!existsSync(logPath)) return null;
+
+    let content;
+    try {
+      content = readFileSync(logPath, 'utf8');
+    } catch { return null; }
+
+    const lines = content.split('\n');
+    const turns = []; // { role: 'user'|'assistant', text, timestamp }
+
+    for (const line of lines) {
+      if (!line.trim() || line.startsWith('[')) continue;
+      try {
+        const data = JSON.parse(line);
+
+        // User messages
+        if (data.type === 'user' && data.message?.content) {
+          const msgContent = data.message.content;
+          let text = '';
+          if (typeof msgContent === 'string') {
+            text = msgContent;
+          } else if (Array.isArray(msgContent)) {
+            // Extract text blocks, skip tool_result blocks (noise)
+            text = msgContent
+              .filter((b) => b.type === 'text' && b.text)
+              .map((b) => b.text)
+              .join('\n');
+          }
+          if (text.trim().length > 5) {
+            turns.push({ role: 'user', text: text.trim(), timestamp: data.timestamp });
+          }
+        }
+
+        // Assistant text responses (what Claude said — the reasoning/explanations)
+        if (data.type === 'assistant' && data.message?.content) {
+          const blocks = Array.isArray(data.message.content) ? data.message.content : [];
+          const textParts = blocks
+            .filter((b) => b.type === 'text' && b.text && b.text.trim().length > 20)
+            .map((b) => b.text.trim());
+          if (textParts.length > 0) {
+            turns.push({ role: 'assistant', text: textParts.join('\n'), timestamp: data.timestamp });
+          }
+        }
+      } catch { /* skip non-JSON */ }
+    }
+
+    if (turns.length === 0) return null;
+
+    // Deduplicate consecutive same-role turns (merge them)
+    const merged = [];
+    for (const turn of turns) {
+      const last = merged[merged.length - 1];
+      if (last && last.role === turn.role) {
+        last.text += '\n' + turn.text;
+      } else {
+        merged.push({ ...turn });
+      }
+    }
+
+    // Build the thread — keep recent turns verbatim, truncate old ones if over budget
+    let thread = '';
+    const formatted = merged.map((t) => {
+      const label = t.role === 'user' ? 'USER' : 'CLAUDE';
+      return `[${label}]:\n${t.text}`;
+    });
+
+    // Start from the end (most recent) and work backwards to fill budget
+    const recentFirst = [...formatted].reverse();
+    const kept = [];
+    let totalLen = 0;
+
+    for (const entry of recentFirst) {
+      if (totalLen + entry.length > maxChars) {
+        // Truncate this entry to fit remaining budget
+        const remaining = maxChars - totalLen;
+        if (remaining > 200) {
+          kept.push(entry.slice(0, remaining) + '\n[...truncated]');
+        }
+        break;
+      }
+      kept.push(entry);
+      totalLen += entry.length;
+    }
+
+    // Reverse back to chronological order
+    kept.reverse();
+    thread = kept.join('\n\n---\n\n');
+
+    return thread;
+  }
+
+  /**
+   * Build a full context-resume prompt that preserves the conversation
+   * thread so a fresh agent picks up where the previous session left off.
+   */
+  buildConversationResumePrompt(agent, userMessage) {
+    const thread = this.extractConversationThread(agent);
+    if (!thread) return null;
+
+    const constraints = this.daemon.memory?.getConstraintsMarkdown(2000) || '';
+    const discoveries = this.daemon.memory?.getDiscoveriesMarkdown(agent.role, 5, 1000, agent.scope, agent.teamId) || '';
+
+    let prompt = [
+      `# Session Context Resume`,
+      ``,
+      `You are continuing a session that went idle. Below is the full conversation`,
+      `from your previous session — your actual exchanges with the user. Pick up`,
+      `exactly where you left off. The user's new message follows at the end.`,
+      ``,
+      `Role: ${agent.role} | Provider: ${agent.provider} | Scope: ${agent.scope?.join(', ') || 'unrestricted'}`,
+      agent.workingDir ? `Working directory: ${agent.workingDir}` : '',
+      ``,
+      constraints ? `## Project Constraints\n\n${constraints}\n` : '',
+      discoveries ? `## Known Issues & Fixes\n\n${discoveries}\n` : '',
+      `## Previous Conversation\n\n${thread}`,
+      ``,
+      `---`,
+      ``,
+      `## New Message From User`,
+      ``,
+      userMessage,
+      ``,
+      `Continue seamlessly from the conversation above. You have the full context of what was discussed, what was tried, what worked and what didn't. Do not ask the user to repeat anything.`,
+    ].filter(Boolean).join('\n');
+
+    // Hard cap at 80K chars (~20K tokens) to leave plenty of room in context window
+    if (prompt.length > 80000) {
+      // Re-extract with smaller budget and rebuild
+      const smallerThread = this.extractConversationThread(agent, { maxChars: 40000 });
+      if (smallerThread) {
+        prompt = [
+          `# Session Context Resume`,
+          ``,
+          `You are continuing a session that went idle. Below is the conversation`,
+          `from your previous session (older turns summarized to fit). Pick up`,
+          `exactly where you left off.`,
+          ``,
+          `Role: ${agent.role} | Scope: ${agent.scope?.join(', ') || 'unrestricted'}`,
+          agent.workingDir ? `Working directory: ${agent.workingDir}` : '',
+          ``,
+          constraints ? `## Project Constraints\n\n${constraints}\n` : '',
+          `## Previous Conversation\n\n${smallerThread}`,
+          ``,
+          `---`,
+          ``,
+          `## New Message From User`,
+          ``,
+          userMessage,
+          ``,
+          `Continue seamlessly. Do not ask the user to repeat anything.`,
+        ].filter(Boolean).join('\n');
+      }
+    }
+
+    return prompt;
+  }
+
   // --- Workspace Grouping ---
 
   /**
@@ -1183,6 +1352,7 @@ export class Journalist {
             this.daemon.memory.addDiscovery({
               agentId: agent.id,
               role: agent.role,
+              teamId: agent.teamId || null,
               trigger: trigger.slice(0, 300),
               fix: fix.slice(0, 500),
               outcome: 'success',

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

@@ -254,10 +254,10 @@ export class Keeper {
   // ── Command parser ────────────────────────────────────────
 
   static parseCommand(text) {
-    const cmdMatch = text.match(/^\s*\[(save|append|update|delete|view|doc|link|read|instruct)\]\s*/i);
+    const cmdMatch = text.match(/\[(save|append|update|delete|view|doc|link|read|instruct)\]/i);
     if (!cmdMatch) return null;
     const command = cmdMatch[1].toLowerCase();
-    const rest = text.slice(cmdMatch[0].length).trim();
+    const rest = text.slice(cmdMatch.index + cmdMatch[0].length).trim();
 
     if (command === 'instruct') {
       return { command, tags: [], extra: null };

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

@@ -261,7 +261,7 @@ export class MemoryStore {
 
   // --- Discoveries (error → fix pairs) ---
 
-  addDiscovery({ agentId, role, trigger, fix, outcome = 'success' }) {
+  addDiscovery({ agentId, role, trigger, fix, outcome = 'success', teamId }) {
     if (!trigger || !fix) return { added: false, error: 'trigger and fix required' };
     if (outcome !== 'success') return { added: false, reason: 'only successes stored' };
 
@@ -277,6 +277,7 @@ export class MemoryStore {
       ts: new Date().toISOString(),
       agentId: agentId || null,
       role: role || 'unknown',
+      teamId: teamId || null,
       trigger: truncate(String(trigger).trim(), 300),
       fix: truncate(String(fix).trim(), 500),
       outcome,
@@ -298,7 +299,7 @@ export class MemoryStore {
     }
   }
 
-  listDiscoveries({ role, limit = 100 } = {}) {
+  listDiscoveries({ role, teamId, limit = 100 } = {}) {
     if (!existsSync(this.discoveriesPath)) return [];
     try {
       const lines = readFileSync(this.discoveriesPath, 'utf8').split('\n').filter(Boolean);
@@ -306,7 +307,9 @@ export class MemoryStore {
       for (const line of lines) {
         try {
           const e = JSON.parse(line);
-          if (!role || e.role === role) entries.push(e);
+          if (role && e.role !== role) continue;
+          if (teamId && e.teamId && e.teamId !== teamId) continue;
+          entries.push(e);
         } catch { /* skip malformed */ }
       }
       return entries.slice(-limit).reverse(); // newest first
@@ -328,8 +331,8 @@ export class MemoryStore {
     } catch { /* best-effort */ }
   }
 
-  getDiscoveriesMarkdown(role, limit = 20, maxChars = 4000, scope) {
-    let entries = this.listDiscoveries({ role, limit: limit * 3 });
+  getDiscoveriesMarkdown(role, limit = 20, maxChars = 4000, scope, teamId) {
+    let entries = this.listDiscoveries({ role, teamId, limit: limit * 3 });
     if (entries.length === 0) return '';
 
     if (scope && Array.isArray(scope) && scope.length > 0) {

package/node_modules/@groove-dev/daemon/src/model-lab.js

@@ -95,6 +95,17 @@ export class ModelLab {
   removeRuntime(id) {
     const rt = this.runtimes.get(id);
     if (!rt) return null;
+
+    // Stop the llama-server process if this is a local model runtime
+    if (rt._localModelId) {
+      const mm = this.daemon.modelManager;
+      const ls = this.daemon.llamaServer;
+      if (mm && ls) {
+        const modelPath = mm.getModelPath(rt._localModelId);
+        if (modelPath) ls.stopServer(modelPath).catch(() => {});
+      }
+    }
+
     this.runtimes.delete(id);
     this._saveRuntimes();
     this.daemon.broadcast({ type: 'lab:runtime:removed', data: { id } });