groove-dev 0.27.140 → 0.27.141

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

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/cli",
-  "version": "0.27.140",
+  "version": "0.27.141",
   "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.141",
   "description": "GROOVE daemon — agent orchestration engine",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",

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

@@ -3231,8 +3231,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 +3244,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 +6989,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/journalist.js

@@ -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) || '';
+
+    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 ---
 
   /**

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)\]|\b(save|append|update|delete|view|doc|link|read)\b(?=\s+#[\w/.-])/i);
     if (!cmdMatch) return null;
-    const command = cmdMatch[1].toLowerCase();
-    const rest = text.slice(cmdMatch[0].length).trim();
+    const command = (cmdMatch[1] || cmdMatch[2]).toLowerCase();
+    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/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 } });

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

@@ -1976,6 +1976,10 @@ For normal file edits within your scope, proceed without review.
    * Resume a completed agent's session with a new message.
    * Uses --resume SESSION_ID for zero cold-start continuation.
    * Falls back to full spawn if no session ID available.
+   *
+   * If the agent has been idle for longer than IDLE_CONTEXT_THRESHOLD,
+   * spawns fresh with the full conversation thread instead of --resume.
+   * This avoids degraded context from internal compaction.
    */
   async resume(agentId, message) {
     const { registry, locks } = this.daemon;
@@ -1996,6 +2000,23 @@ For normal file edits within your scope, proceed without review.
       return this.daemon.rotator.rotate(agentId, { additionalPrompt: message });
     }
 
+    // Context-aware idle resume: if the agent has been idle long enough for
+    // internal compaction to degrade context, spawn fresh with the full
+    // conversation thread instead of resuming the compacted session.
+    const IDLE_CONTEXT_THRESHOLD_MS = 5 * 60_000; // 5 minutes (matches prompt cache TTL)
+    const idleMs = agent.lastActivity
+      ? Date.now() - new Date(agent.lastActivity).getTime()
+      : Infinity;
+
+    if (idleMs > IDLE_CONTEXT_THRESHOLD_MS && this.daemon.journalist) {
+      const resumePrompt = this.daemon.journalist.buildConversationResumePrompt(agent, message);
+      if (resumePrompt) {
+        console.log(`[Groove] Agent ${agent.name} idle ${Math.round(idleMs / 60000)}min — using conversation-thread resume`);
+        // Use rotation machinery but with our richer prompt instead of handoff brief
+        return this._conversationResume(agentId, agent, resumePrompt);
+      }
+    }
+
     const provider = getProvider(agent.provider || 'claude-code');
     if (!provider?.buildResumeCommand) {
       return this.daemon.rotator.rotate(agentId, { additionalPrompt: message });
@@ -2125,6 +2146,61 @@ For normal file edits within your scope, proceed without review.
     return newAgent;
   }
 
+  /**
+   * Conversation-thread resume: spawns a fresh agent with the full
+   * user↔assistant conversation as context instead of using --resume
+   * on a potentially compacted session. Used when idle > threshold.
+   */
+  async _conversationResume(agentId, agent, resumePrompt) {
+    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 = await this.spawn({
+      role: config.role,
+      scope: config.scope,
+      provider: config.provider,
+      model: config.model,
+      prompt: resumePrompt,
+      permission: config.permission || 'full',
+      workingDir: config.workingDir,
+      name: config.name,
+      teamId: config.teamId,
+      isRotation: true,
+    });
+
+    // Carry cumulative token count for tracking
+    if (config.tokensUsed > 0) {
+      registry.update(newAgent.id, { tokensUsed: config.tokensUsed });
+    }
+
+    if (this.daemon.timeline) {
+      this.daemon.timeline.recordEvent('conversation_resume', {
+        agentId: newAgent.id,
+        oldAgentId: agentId,
+        agentName: newAgent.name,
+        role: config.role,
+        idleMinutes: Math.round((Date.now() - new Date(config.lastActivity).getTime()) / 60000),
+      });
+    }
+
+    this.daemon.broadcast({
+      type: 'rotation:complete',
+      agentId: newAgent.id,
+      agentName: newAgent.name,
+      oldAgentId: agentId,
+      reason: 'conversation_resume',
+      tokensSaved: 0,
+    });
+
+    return newAgent;
+  }
+
   async _resumeAgentLoop(agentId, agent, message, provider) {
     const { registry, locks } = this.daemon;
     const config = { ...agent };

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

@@ -112,6 +112,12 @@ export function validateAgentConfig(config) {
     if (!isNaN(v) && v >= 0 && v <= 100) verbosity = Math.round(v);
   }
 
+  const validEffort = ['min', 'low', 'default', 'high', 'max'];
+  const effort = validEffort.includes(config.effort) ? config.effort : undefined;
+
+  const validRouting = ['fixed', 'auto', 'auto-floor'];
+  const routingMode = validRouting.includes(config.routingMode) ? config.routingMode : undefined;
+
   // Return sanitized config (only known fields)
   return {
     role: config.role,
@@ -131,6 +137,8 @@ export function validateAgentConfig(config) {
     reasoningEffort: numericReasoningEffort ?? reasoningEffort,
     temperature,
     verbosity,
+    effort,
+    routingMode,
     labPresetId: (typeof config.labPresetId === 'string' && config.labPresetId.length <= 64) ? config.labPresetId : undefined,
     keeperTags: Array.isArray(config.keeperTags) ? config.keeperTags.filter(t => typeof t === 'string').slice(0, 20) : undefined,
   };