groove-dev 0.27.91 → 0.27.92

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

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

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

@@ -3332,7 +3332,14 @@ Keep responses concise. Help them think, don't lecture them about the system the
       let agentConfigs;
       let projectDir = null;
       let previewBlock = null;
-      if (Array.isArray(raw)) {
+
+      // Frontend Team Builder override — if body.agents is provided, use it
+      // instead of the planner's recommended-team.json
+      if (Array.isArray(req.body?.agents) && req.body.agents.length > 0) {
+        agentConfigs = req.body.agents;
+        projectDir = raw.projectDir || null;
+        previewBlock = raw.preview || null;
+      } else if (Array.isArray(raw)) {
         agentConfigs = raw;
       } else if (raw && Array.isArray(raw.agents)) {
         agentConfigs = raw.agents;
@@ -3383,6 +3390,23 @@ Keep responses concise. Help them think, don't lecture them about the system the
         });
       }
 
+      // Team-level overrides from the pre-planner config panel
+      const teamProvider = req.body?.teamProvider || undefined;
+      const teamModel = req.body?.teamModel || undefined;
+      const teamReasoningEffort = req.body?.teamReasoningEffort != null ? Number(req.body.teamReasoningEffort) : undefined;
+      const teamTemperature = req.body?.teamTemperature != null ? Number(req.body.teamTemperature) : undefined;
+      const teamVerbosity = req.body?.teamVerbosity != null ? Number(req.body.teamVerbosity) : undefined;
+
+      if (teamProvider || teamModel) {
+        for (const c of agentConfigs) {
+          if (teamProvider) c.provider = teamProvider;
+          if (teamModel) c.model = teamModel;
+          if (teamReasoningEffort !== undefined) c.reasoningEffort = teamReasoningEffort;
+          if (teamTemperature !== undefined) c.temperature = teamTemperature;
+          if (teamVerbosity !== undefined) c.verbosity = teamVerbosity;
+        }
+      }
+
       // Separate phase 1 (builders) and phase 2 (QC/finisher)
       const phase1 = agentConfigs.filter((a) => !a.phase || a.phase === 1);
       let phase2 = agentConfigs.filter((a) => a.phase === 2);
@@ -3450,6 +3474,9 @@ Keep responses concise. Help them think, don't lecture them about the system the
               workingDir: existing.workingDir || projectWorkingDir,
               name: existing.name,
               integrationApproval: config.integrationApproval || existing.integrationApproval || undefined,
+              reasoningEffort: config.reasoningEffort,
+              temperature: config.temperature,
+              verbosity: config.verbosity,
             });
             validated.teamId = defaultTeamId;
             const newAgent = await daemon.processes.spawn(validated);
@@ -3466,12 +3493,15 @@ Keep responses concise. Help them think, don't lecture them about the system the
               role: config.role,
               scope: normalizeScope(config.scope || [], config.workingDir || projectWorkingDir),
               prompt,
-              provider: config.provider || undefined,
+              provider: config.provider || daemon.config?.defaultProvider || undefined,
               model: config.model || daemon.config?.defaultModel || 'auto',
               permission: config.permission || 'auto',
               workingDir: config.workingDir || projectWorkingDir,
               name: config.name || undefined,
               integrationApproval: config.integrationApproval || undefined,
+              reasoningEffort: config.reasoningEffort,
+              temperature: config.temperature,
+              verbosity: config.verbosity,
             });
             validated.teamId = defaultTeamId;
             const agent = await daemon.processes.spawn(validated);
@@ -3506,8 +3536,9 @@ Keep responses concise. Help them think, don't lecture them about the system the
             waitFor: phase1Ids,
             agents: phase2.map((c) => ({
               role: c.role, scope: c.scope || [], prompt: c.prompt || '',
-              provider: c.provider || undefined, model: c.model || 'auto',
+              provider: c.provider || daemon.config?.defaultProvider || undefined, model: c.model || daemon.config?.defaultModel || 'auto',
               permission: c.permission || 'auto',
+              reasoningEffort: c.reasoningEffort, temperature: c.temperature, verbosity: c.verbosity,
               workingDir: c.workingDir || projectWorkingDir,
               name: c.name || undefined,
               teamId: defaultTeamId,
@@ -3540,6 +3571,200 @@ Keep responses concise. Help them think, don't lecture them about the system the
     }
   });
 
+  // --- Team Templates ---
+
+  const BUILT_IN_TEMPLATES = {
+    'dev-team': {
+      name: 'Dev Team', description: 'Frontend + Backend + QC', icon: 'code',
+      roles: [{ role: 'frontend' }, { role: 'backend' }, { role: 'fullstack', phase: 2 }],
+    },
+    'full-stack': {
+      name: 'Full Stack', description: 'Frontend, Backend, DevOps, Testing + QC', icon: 'layers',
+      roles: [{ role: 'frontend' }, { role: 'backend' }, { role: 'devops' }, { role: 'testing' }, { role: 'fullstack', phase: 2 }],
+    },
+    'marketing': {
+      name: 'Marketing', description: 'CMO, Creative, Analyst', icon: 'megaphone',
+      roles: [{ role: 'cmo' }, { role: 'creative' }, { role: 'analyst' }],
+    },
+    'business': {
+      name: 'Business', description: 'CFO, CMO, Analyst', icon: 'briefcase',
+      roles: [{ role: 'cfo' }, { role: 'cmo' }, { role: 'analyst' }],
+    },
+    'security-audit': {
+      name: 'Security Audit', description: 'Security, Backend + QC', icon: 'shield',
+      roles: [{ role: 'security' }, { role: 'backend' }, { role: 'fullstack', phase: 2 }],
+    },
+    'docs': {
+      name: 'Documentation', description: 'Docs + Frontend', icon: 'file-text',
+      roles: [{ role: 'docs' }, { role: 'frontend' }],
+    },
+  };
+
+  function getCustomTemplatesDir() {
+    return resolve(homedir(), '.groove', 'team-templates');
+  }
+
+  function loadCustomTemplates() {
+    const dir = getCustomTemplatesDir();
+    if (!existsSync(dir)) return {};
+    const templates = {};
+    try {
+      for (const file of readdirSync(dir).filter(f => f.endsWith('.json'))) {
+        try {
+          const data = JSON.parse(readFileSync(resolve(dir, file), 'utf8'));
+          const key = file.replace(/\.json$/, '');
+          templates[key] = { ...data, custom: true };
+        } catch { /* skip malformed */ }
+      }
+    } catch { /* dir read failed */ }
+    return templates;
+  }
+
+  app.get('/api/team-templates', (req, res) => {
+    const custom = loadCustomTemplates();
+    const all = {};
+    for (const [k, v] of Object.entries(BUILT_IN_TEMPLATES)) {
+      all[k] = { ...v, builtIn: true };
+    }
+    for (const [k, v] of Object.entries(custom)) {
+      all[k] = v;
+    }
+    res.json(all);
+  });
+
+  app.post('/api/team-templates', (req, res) => {
+    const { name, description, icon, roles, settings } = req.body || {};
+    if (!name || typeof name !== 'string' || name.length > 64) {
+      return res.status(400).json({ error: 'name is required (max 64 chars)' });
+    }
+    if (!Array.isArray(roles) || roles.length === 0) {
+      return res.status(400).json({ error: 'roles array is required' });
+    }
+    const key = name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 64);
+    if (!key) return res.status(400).json({ error: 'Invalid template name' });
+    if (BUILT_IN_TEMPLATES[key]) {
+      return res.status(409).json({ error: 'Cannot overwrite built-in template' });
+    }
+    const dir = getCustomTemplatesDir();
+    mkdirSync(dir, { recursive: true });
+    const template = { name, description: description || '', icon: icon || 'users', roles, settings: settings || {} };
+    writeFileSync(resolve(dir, `${key}.json`), JSON.stringify(template, null, 2));
+    daemon.audit.log('team-template.save', { key, roles: roles.length });
+    res.status(201).json({ key, ...template, custom: true });
+  });
+
+  app.delete('/api/team-templates/:name', (req, res) => {
+    const key = req.params.name;
+    if (BUILT_IN_TEMPLATES[key]) {
+      return res.status(403).json({ error: 'Cannot delete built-in template' });
+    }
+    const file = resolve(getCustomTemplatesDir(), `${key}.json`);
+    if (!existsSync(file)) return res.status(404).json({ error: 'Template not found' });
+    try {
+      unlinkSync(file);
+      daemon.audit.log('team-template.delete', { key });
+      res.json({ ok: true });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // --- Team Builder Launch ---
+
+  app.post('/api/team-builder/launch', async (req, res) => {
+    try {
+      const { task, roles, settings, launchMode } = req.body || {};
+      if (!Array.isArray(roles) || roles.length === 0) {
+        return res.status(400).json({ error: 'roles array is required' });
+      }
+      const mode = launchMode || 'direct';
+      const teamSettings = settings || {};
+      const teamProvider = teamSettings.provider || daemon.config?.defaultProvider || undefined;
+      const teamModel = teamSettings.model || daemon.config?.defaultModel || undefined;
+
+      const defaultTeamId = req.body.teamId || daemon.teams.getDefault()?.id || null;
+      const baseDir = daemon.config?.defaultWorkingDir || daemon.projectDir;
+
+      if (mode === 'plan-first') {
+        // Spawn a headless planner to generate per-agent prompts, then auto-launch
+        const plannerConfig = validateAgentConfig({
+          role: 'planner',
+          prompt: task || 'Analyze the codebase and create a plan for the team.',
+          provider: teamProvider,
+          model: teamModel,
+          workingDir: baseDir,
+        });
+        plannerConfig.teamId = defaultTeamId;
+        const planner = await daemon.processes.spawn(plannerConfig);
+        daemon.audit.log('team-builder.plan-first', { plannerId: planner.id, roles: roles.length });
+        return res.status(202).json({ mode: 'plan-first', plannerId: planner.id, message: 'Planner spawned — team will launch when plan is ready' });
+      }
+
+      const spawned = [];
+      const failed = [];
+      const phase1Agents = roles.filter(r => !r.phase || r.phase === 1);
+      const phase2Agents = roles.filter(r => r.phase === 2);
+      const phase1Ids = [];
+
+      for (const roleDef of phase1Agents) {
+        try {
+          let prompt = roleDef.prompt || '';
+          if (task && mode === 'direct') {
+            prompt = task + (prompt ? '\n\n' + prompt : '');
+          }
+
+          const agentConfig = validateAgentConfig({
+            role: roleDef.role,
+            name: roleDef.name || undefined,
+            scope: roleDef.scope || [],
+            prompt: mode === 'await' ? '' : prompt,
+            provider: roleDef.provider || teamProvider,
+            model: roleDef.model || teamModel,
+            reasoningEffort: roleDef.reasoningEffort ?? teamSettings.reasoningEffort,
+            temperature: roleDef.temperature ?? teamSettings.temperature,
+            verbosity: roleDef.verbosity ?? teamSettings.verbosity,
+            workingDir: baseDir,
+          });
+          agentConfig.teamId = defaultTeamId;
+          const agent = await daemon.processes.spawn(agentConfig);
+          spawned.push({ id: agent.id, name: agent.name, role: agent.role });
+          phase1Ids.push(agent.id);
+        } catch (err) {
+          failed.push({ role: roleDef.role, error: err.message });
+        }
+      }
+
+      if (phase2Agents.length > 0 && phase1Ids.length > 0) {
+        daemon._pendingPhase2 = daemon._pendingPhase2 || [];
+        daemon._pendingPhase2.push({
+          waitFor: phase1Ids,
+          agents: phase2Agents.map(r => ({
+            role: r.role, scope: r.scope || [], prompt: r.prompt || '',
+            provider: r.provider || teamProvider || daemon.config?.defaultProvider || undefined,
+            model: r.model || teamModel || daemon.config?.defaultModel || 'auto',
+            reasoningEffort: r.reasoningEffort ?? teamSettings.reasoningEffort,
+            temperature: r.temperature ?? teamSettings.temperature,
+            verbosity: r.verbosity ?? teamSettings.verbosity,
+            workingDir: baseDir,
+            name: r.name || undefined,
+            teamId: defaultTeamId,
+          })),
+        });
+      }
+
+      daemon.audit.log('team-builder.launch', {
+        mode, phase1: spawned.length, phase2Pending: phase2Agents.length,
+        failed: failed.length, task: task ? task.slice(0, 100) : null,
+      });
+      res.json({
+        mode, launched: spawned.length, phase2Pending: phase2Agents.length,
+        agents: spawned, failed,
+      });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
   // Preview service — one-click View Site for completed teams
   app.get('/api/preview', (req, res) => {
     res.json({ previews: daemon.preview?.list() || [] });

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

@@ -103,6 +103,7 @@ export class Introducer {
       lines.push(`- NEVER kill the daemon process ("kill <pid>", "pkill groove", "killall node")`);
       lines.push(`- NEVER run "./promote.sh", "./promote-local.sh", or any publish/deploy script`);
       lines.push(`- NEVER start long-running dev servers that block process exit (vite dev, npm start, next dev)`);
+      lines.push(`- NEVER open files in a browser. No "open index.html", "open http://...", "xdg-open", or any command that launches a browser window. GROOVE has its own preview system — the user will view the site there.`);
       lines.push(`If code changes require a daemon restart to take effect, state that in your output so the user can restart manually. Do NOT restart it yourself.`);
 
       // User feedback from previous tasks — critical context about what the user
@@ -195,6 +196,18 @@ export class Introducer {
       lines.push(`GROOVE_PROJECT_MAP.md contains a structural overview of this project. This is BACKGROUND INFORMATION ONLY — it is NOT your task. Do not treat existing files or previous work as something you should continue or improve unless the user explicitly asks you to.`);
     }
 
+    // CLAUDE.md parity — non-Claude providers don't read CLAUDE.md natively,
+    // so inject its project content (minus the GROOVE section) into introContext
+    if (newAgent.provider && newAgent.provider !== 'claude-code') {
+      const claudeMdContent = this._loadClaudeMd(newAgent.workingDir);
+      if (claudeMdContent) {
+        lines.push('');
+        lines.push('## Project Context (from CLAUDE.md)');
+        lines.push('');
+        lines.push(claudeMdContent);
+      }
+    }
+
     // Codebase structure injection — give agents instant orientation
     const structureSummary = this.daemon.indexer?.getStructureSummary();
     if (structureSummary) {
@@ -381,6 +394,35 @@ export class Introducer {
     return lines.join('\n') + memorySection;
   }
 
+  _loadClaudeMd(workingDir) {
+    // Walk up from agent workingDir to find CLAUDE.md
+    let dir = workingDir || this.daemon.projectDir;
+    let claudePath = null;
+    for (let i = 0; i < 5; i++) {
+      const candidate = resolve(dir, 'CLAUDE.md');
+      if (existsSync(candidate)) { claudePath = candidate; break; }
+      const parent = resolve(dir, '..');
+      if (parent === dir) break;
+      dir = parent;
+    }
+    if (!claudePath) return null;
+    try {
+      let content = readFileSync(claudePath, 'utf8').trim();
+      // Strip the GROOVE:START to GROOVE:END section to avoid duplicating coordination data
+      const startIdx = content.indexOf(GROOVE_SECTION_START);
+      const endIdx = content.indexOf(GROOVE_SECTION_END);
+      if (startIdx !== -1 && endIdx !== -1) {
+        content = (content.slice(0, startIdx) + content.slice(endIdx + GROOVE_SECTION_END.length)).trim();
+      }
+      if (content.length > 8000) {
+        content = content.slice(0, 8000) + '\n\n*(truncated — read full file for details)*';
+      }
+      return content || null;
+    } catch {
+      return null;
+    }
+  }
+
   loadArchitectureDoc() {
     const projectDir = this.daemon.projectDir;
     const candidates = [

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

@@ -92,6 +92,7 @@ Key behaviors:
 - Checking the Zustand store (stores/groove.js) for existing state before adding new state
 - Reading app.css for existing animations and utility classes before creating new ones
 When making visual changes, always read app.css for the color palette and existing patterns first.
+NEVER open files in a browser (no "open index.html", "open http://...", "xdg-open"). GROOVE has its own preview system.
 
 `,
   backend: `You are a Backend agent. You build and modify daemon services, API endpoints, and system logic. Focus on:
@@ -114,6 +115,7 @@ 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 open files in a browser. No "open index.html", "open http://...", "xdg-open", or any command that launches a browser. GROOVE has its own preview system.
 - 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.
@@ -226,7 +228,7 @@ For MODE 1 (team creation):
   "agents": [
     { "role": "frontend", "phase": 1, "scope": ["src/components/**", "src/views/**"], "prompt": "Build the frontend: [specific tasks]" },
     { "role": "backend", "phase": 1, "scope": ["src/api/**", "src/server/**"], "prompt": "Build the backend: [specific tasks]" },
-    { "role": "fullstack", "phase": 2, "scope": [], "prompt": "QC Senior Dev: Audit all changes from phase 1 agents. Verify correctness, fix issues, run tests, verify the build compiles (npm run build). Do NOT start long-running dev servers. Commit all changes." }
+    { "role": "fullstack", "phase": 2, "scope": [], "prompt": "QC Senior Dev: Audit all changes from phase 1 agents. Verify correctness, fix issues, run tests, verify the build compiles (npm run build). Do NOT start long-running dev servers. Do NOT open files in a browser — no 'open' commands. Commit all changes." }
   ],
   "preview": {
     "kind": "dev-server",
@@ -701,6 +703,7 @@ For normal file edits within your scope, proceed without review.
 
     // ─── Agent Loop path (local models with built-in agentic runtime) ───
     if (provider.constructor.useAgentLoop) {
+      provider.normalizeConfig(spawnConfig);
       const loopConfig = provider.getLoopConfig(spawnConfig);
       logStream.write(`[${new Date().toISOString()}] GROOVE agent-loop: model=${loopConfig.model} api=${loopConfig.apiBase}\n`);
 
@@ -813,6 +816,7 @@ For normal file edits within your scope, proceed without review.
       integrationEnv = this.daemon.integrations.getSpawnEnv(config.integrations);
     }
 
+    provider.normalizeConfig(spawnConfig);
     const spawnCmd = provider.buildSpawnCommand(spawnConfig);
     const { command: rawCommand, args, env, stdin: stdinData, cwd: providerCwd } = spawnCmd;
     const command = resolveProviderCommand(agent.provider || config.provider) || rawCommand;

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

@@ -29,6 +29,10 @@ export class Provider {
     return false; // Default: no hot-swap, needs rotation
   }
 
+  normalizeConfig(config) {
+    return config;
+  }
+
   parseOutput(line) {
     return null;
   }

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

@@ -70,6 +70,14 @@ export class ClaudeCodeProvider extends Provider {
     return 'npm i -g @anthropic-ai/claude-code';
   }
 
+  normalizeConfig(config) {
+    if (typeof config.reasoningEffort === 'number') {
+      const e = config.reasoningEffort;
+      config.effort = e <= 20 ? 'none' : e <= 40 ? 'low' : e <= 60 ? 'medium' : e <= 80 ? 'high' : 'xhigh';
+    }
+    return config;
+  }
+
   buildSpawnCommand(agent) {
     // Claude Code interactive mode:
     //   claude [options] [prompt]

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

@@ -107,28 +107,54 @@ export class CodexProvider extends Provider {
     }
   }
 
+  normalizeConfig(config) {
+    if (typeof config.reasoningEffort === 'number') {
+      config.reasoningEffort = config.reasoningEffort <= 33 ? 'low' : config.reasoningEffort <= 66 ? 'medium' : 'high';
+    }
+    if (typeof config.verbosity === 'number') {
+      config.verbosity = config.verbosity <= 33 ? 'low' : config.verbosity <= 66 ? 'medium' : 'high';
+    }
+    return config;
+  }
+
   buildSpawnCommand(agent) {
     const args = ['exec'];
 
     if (agent.model) args.push('--model', agent.model);
+    if (agent.reasoningEffort) args.push('--reasoning-effort', agent.reasoningEffort);
 
     args.push('--json');
     args.push('--dangerously-bypass-approvals-and-sandbox');
 
     if (agent.workingDir) args.push('-C', agent.workingDir);
 
-    if (agent.prompt) args.push(agent.prompt);
+    const fullPrompt = this.buildFullPrompt(agent);
 
     this._currentModel = agent.model;
     this._sessionInputTokens = 0;
 
+    // Pipe prompt via stdin to avoid ARG_MAX with large introContext
     return {
       command: 'codex',
       args,
       env: agent.apiKey ? { OPENAI_API_KEY: agent.apiKey } : {},
+      stdin: fullPrompt || undefined,
     };
   }
 
+  buildFullPrompt(agent) {
+    const parts = [];
+    if (agent.introContext) parts.push(agent.introContext);
+    if (agent.prompt) parts.push(`## Your Task\n\n${agent.prompt}`);
+    if (agent.scope && agent.scope.length > 0) {
+      parts.push(
+        `## Scope Rules\n\nYou MUST only modify files matching these patterns: ${agent.scope.join(', ')}. ` +
+        `Do not touch files outside your scope — other agents own them.`
+      );
+    }
+    return parts.join('\n\n');
+  }
+
   buildHeadlessCommand(prompt, model) {
     const args = ['exec', '--json', prompt];
     if (model) args.push('--model', model);
@@ -244,7 +270,7 @@ export class CodexProvider extends Provider {
     try {
       event = JSON.parse(trimmed);
     } catch {
-      return { type: 'activity', data: trimmed };
+      return null;
     }
 
     switch (event.type) {
@@ -345,8 +371,11 @@ export class CodexProvider extends Provider {
         const outputTokens = usage.output_tokens || 0;
         const cachedTokens = usage.cached_input_tokens || 0;
         const reasoningTokens = usage.output_tokens_details?.reasoning_tokens || 0;
-        const totalTokens = inputTokens + outputTokens;
-        const cacheCreationTokens = cachedTokens > 0 ? Math.max(0, inputTokens - cachedTokens) : 0;
+        // OpenAI includes cached tokens IN input_tokens; Anthropic does not.
+        // Subtract cached to get new-processing-only count, matching Claude's convention.
+        const newInputTokens = Math.max(0, inputTokens - cachedTokens);
+        const totalTokens = newInputTokens + outputTokens;
+        const cacheCreationTokens = cachedTokens > 0 ? newInputTokens : 0;
 
         const model = CodexProvider.models.find((m) => m.id === this._currentModel);
         const pricing = model?.pricing;

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

@@ -67,10 +67,23 @@ export class GeminiProvider extends Provider {
       command: 'gemini',
       args,
       env: agent.apiKey ? { GEMINI_API_KEY: agent.apiKey } : {},
-      stdin: agent.prompt || undefined,
+      stdin: this.buildFullPrompt(agent) || undefined,
     };
   }
 
+  buildFullPrompt(agent) {
+    const parts = [];
+    if (agent.introContext) parts.push(agent.introContext);
+    if (agent.prompt) parts.push(`## Your Task\n\n${agent.prompt}`);
+    if (agent.scope && agent.scope.length > 0) {
+      parts.push(
+        `## Scope Rules\n\nYou MUST only modify files matching these patterns: ${agent.scope.join(', ')}. ` +
+        `Do not touch files outside your scope — other agents own them.`
+      );
+    }
+    return parts.join('\n\n');
+  }
+
   buildHeadlessCommand(prompt, model) {
     const args = ['--output-format', 'stream-json', '-p', prompt];
     if (model) args.push('--model', model);

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

@@ -55,12 +55,19 @@ export class GrokProvider extends Provider {
     return null; // No CLI
   }
 
+  normalizeConfig(config) {
+    if (typeof config.temperature !== 'number' && typeof config.reasoningEffort === 'number') {
+      config.temperature = 0.1 + (100 - config.reasoningEffort) * 0.008;
+    }
+    return config;
+  }
+
   getLoopConfig(agent) {
     return {
       apiBase: 'https://api.x.ai/v1',
       model: agent.model,
       contextWindow: 131072,
-      temperature: 0.1,
+      temperature: typeof agent.temperature === 'number' ? agent.temperature : 0.1,
       maxResponseTokens: 16384,
       stream: true,
       apiKey: agent.apiKey,

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

@@ -127,6 +127,13 @@ export class LocalProvider extends Provider {
    * Get configuration for the agent loop runtime.
    * Called by ProcessManager when useAgentLoop is true.
    */
+  normalizeConfig(config) {
+    if (typeof config.temperature !== 'number' && typeof config.reasoningEffort === 'number') {
+      config.temperature = 0.1 + (100 - config.reasoningEffort) * 0.008;
+    }
+    return config;
+  }
+
   getLoopConfig(agent) {
     const model = agent.model || 'qwen2.5-coder:7b';
     const contextWindow = this.getContextWindow(model);
@@ -143,7 +150,7 @@ export class LocalProvider extends Provider {
       apiBase,
       model,
       contextWindow,
-      temperature: 0.1,
+      temperature: typeof agent.temperature === 'number' ? agent.temperature : 0.1,
       maxResponseTokens: 4096,
       stream: true,
       headers: {},