groove-dev 0.27.86 → 0.27.88

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

@@ -16,7 +16,7 @@ import { OllamaProvider } from './providers/ollama.js';
 import { ClaudeCodeProvider } from './providers/claude-code.js';
 import { supportsSignalFlag, compareSemver, parseSemver } from './providers/groove-network.js';
 import { ConsentManager } from '../../../moe-training/client/index.js';
-import { validateAgentConfig } from './validate.js';
+import { validateAgentConfig, validateReasoningEffort, validateVerbosity } from './validate.js';
 import { ROLE_INTEGRATIONS, wrapWithRoleReminder } from './process.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -72,6 +72,9 @@ async function _executeApprovalRetry(daemon, approval) {
   }
 }
 
+const FILE_READ_TOOLS = new Set(['Read', 'read_file']);
+const FILE_WRITE_TOOLS = new Set(['Write', 'Edit', 'write_file', 'edit_file', 'create_file']);
+
 export function createApi(app, daemon) {
   _daemon = daemon;
 
@@ -325,6 +328,14 @@ export function createApi(app, daemon) {
       }
     }
 
+    // Track file operations for the files-touched API
+    if (targets.length > 0) {
+      const op = FILE_WRITE_TOOLS.has(toolName) ? 'write' : FILE_READ_TOOLS.has(toolName) ? 'read' : null;
+      if (op) {
+        for (const t of targets) daemon.registry.trackFileOp(agentId, t, op);
+      }
+    }
+
     daemon.audit.log('knock.allowed', { agentId, toolName, targets });
     res.json({ allow: true });
   });
@@ -1100,14 +1111,19 @@ export function createApi(app, daemon) {
 
   app.post('/api/conversations', async (req, res) => {
     try {
-      const { provider, model, title, mode } = req.body;
+      const { provider, model, title, mode, reasoning_effort, verbosity } = req.body;
       if (!provider || typeof provider !== 'string') {
         return res.status(400).json({ error: 'provider is required' });
       }
       if (mode && mode !== 'api' && mode !== 'agent') {
         return res.status(400).json({ error: 'mode must be "api" or "agent"' });
       }
-      const conversation = await daemon.conversations.create(provider, model, title, mode || 'api');
+      const validatedEffort = validateReasoningEffort(reasoning_effort);
+      const validatedVerbosity = validateVerbosity(verbosity);
+      const conversation = await daemon.conversations.create(provider, model, title, mode || 'api', {
+        reasoningEffort: validatedEffort,
+        verbosity: validatedVerbosity,
+      });
       daemon.audit.log('conversation.create', { id: conversation.id, provider, model, mode: conversation.mode });
       res.status(201).json(conversation);
     } catch (err) {
@@ -1139,6 +1155,11 @@ export function createApi(app, daemon) {
         }
         await daemon.conversations.setMode(req.params.id, req.body.mode);
       }
+      if (req.body.reasoning_effort !== undefined || req.body.verbosity !== undefined) {
+        const validatedEffort = req.body.reasoning_effort !== undefined ? validateReasoningEffort(req.body.reasoning_effort) : undefined;
+        const validatedVerbosity = req.body.verbosity !== undefined ? validateVerbosity(req.body.verbosity) : undefined;
+        daemon.conversations.updateReasoningSettings(req.params.id, validatedEffort, validatedVerbosity);
+      }
       daemon.audit.log('conversation.update', { id: req.params.id, provider: req.body.provider, model: req.body.model, mode: req.body.mode });
       res.json(daemon.conversations.get(req.params.id));
     } catch (err) {
@@ -1160,10 +1181,13 @@ export function createApi(app, daemon) {
 
   app.post('/api/conversations/:id/message', async (req, res) => {
     try {
-      const { message, history } = req.body;
+      const { message, history, reasoning_effort, verbosity } = req.body;
       if (!message || typeof message !== 'string' || !message.trim()) {
         return res.status(400).json({ error: 'message is required' });
       }
+      const validatedEffort = validateReasoningEffort(reasoning_effort);
+      const validatedVerbosity = validateVerbosity(verbosity);
+
       const conv = daemon.conversations.get(req.params.id);
       if (!conv) return res.status(404).json({ error: 'Conversation not found' });
 
@@ -1172,7 +1196,10 @@ export function createApi(app, daemon) {
 
       // API mode — lightweight headless streaming, no agent spawned
       if (conv.mode === 'api' || !conv.agentId) {
-        await daemon.conversations.sendMessage(req.params.id, message.trim(), history || []);
+        await daemon.conversations.sendMessage(req.params.id, message.trim(), history || [], {
+          reasoningEffort: validatedEffort,
+          verbosity: validatedVerbosity,
+        });
         daemon.audit.log('conversation.message', { id: req.params.id, mode: 'api' });
         return res.json({ status: 'streaming', mode: 'api' });
       }
@@ -3064,6 +3091,87 @@ Keep responses concise. Help them think, don't lecture them about the system the
     });
   });
 
+  // Files touched by an agent during its session
+  app.get('/api/agents/:id/files-touched', (req, res) => {
+    const agent = daemon.registry.get(req.params.id);
+    if (!agent) return res.status(404).json({ error: 'Agent not found' });
+    const files = daemon.registry.getFilesTouched(req.params.id);
+    res.json({ files, total: files.length });
+  });
+
+  // Git diff — structured diff for a file, an agent's touched files, or all uncommitted changes
+  app.get('/api/files/git-diff', (req, res) => {
+    const rootDir = getEditorRoot();
+    if (!rootDir) return res.status(400).json({ error: 'Editor root not set' });
+
+    let paths = [];
+
+    if (req.query.path) {
+      const result = validateFilePath(req.query.path, rootDir);
+      if (result.error) return res.status(400).json({ error: result.error });
+      paths = [req.query.path];
+    } else if (req.query.agentId) {
+      const agent = daemon.registry.get(req.query.agentId);
+      if (!agent) return res.status(404).json({ error: 'Agent not found' });
+      paths = daemon.registry.getFilesTouched(req.query.agentId).map(f => f.path);
+      if (paths.length === 0) return res.json({ diffs: [] });
+      // Validate each path
+      for (const p of paths) {
+        if (p.startsWith('/') || p.includes('..') || p.includes('\0')) {
+          return res.status(400).json({ error: 'Invalid path in agent files' });
+        }
+      }
+    }
+
+    const args = ['diff'];
+    const cachedArgs = ['diff', '--cached'];
+    if (paths.length > 0) {
+      args.push('--', ...paths);
+      cachedArgs.push('--', ...paths);
+    }
+
+    try {
+      const unstaged = execFileSync('git', args, { cwd: rootDir, timeout: 15000, maxBuffer: 10 * 1024 * 1024 }).toString();
+      const staged = execFileSync('git', cachedArgs, { cwd: rootDir, timeout: 15000, maxBuffer: 10 * 1024 * 1024 }).toString();
+      const combined = (staged + '\n' + unstaged).trim();
+      const diffs = parseDiffOutput(combined);
+      res.json({ diffs });
+    } catch (err) {
+      if (err.status !== undefined) {
+        return res.json({ diffs: [] });
+      }
+      res.status(500).json({ error: 'Failed to compute diff' });
+    }
+  });
+
+  function parseDiffOutput(raw) {
+    if (!raw) return [];
+    const fileDiffs = raw.split(/^diff --git /m).filter(Boolean);
+    return fileDiffs.map(chunk => {
+      const lines = chunk.split('\n');
+      const headerMatch = lines[0]?.match(/a\/(.+?) b\/(.+)/);
+      const filePath = headerMatch ? headerMatch[2] : 'unknown';
+      let status = 'modified';
+      if (lines.some(l => l.startsWith('new file'))) status = 'added';
+      else if (lines.some(l => l.startsWith('deleted file'))) status = 'deleted';
+      let additions = 0, deletions = 0;
+      const hunks = [];
+      let currentHunk = null;
+      for (const line of lines) {
+        if (line.startsWith('@@')) {
+          if (currentHunk) hunks.push(currentHunk);
+          currentHunk = { header: line, lines: [] };
+        } else if (currentHunk) {
+          currentHunk.lines.push(line);
+          if (line.startsWith('+') && !line.startsWith('+++')) additions++;
+          else if (line.startsWith('-') && !line.startsWith('---')) deletions++;
+        }
+      }
+      if (currentHunk) hunks.push(currentHunk);
+      return { path: filePath, status, hunks, additions, deletions, content: 'diff --git ' + chunk };
+    });
+  }
+
   // File search — fuzzy filename matching for quick-open (Ctrl+P)
   app.get('/api/files/search', (req, res) => {
     const query = req.query.q;
@@ -4172,10 +4280,10 @@ Keep responses concise. Help them think, don't lecture them about the system the
 
   app.post('/api/tunnels', (req, res) => {
     try {
-      const { name, host, user, port, sshKeyPath, autoStart, autoConnect } = req.body;
+      const { name, host, user, port, sshKeyPath, autoStart, autoConnect, projectDir } = req.body;
       if (!name || typeof name !== 'string') return res.status(400).json({ error: 'name is required (string)' });
       if (!host || typeof host !== 'string') return res.status(400).json({ error: 'host is required (string)' });
-      const result = daemon.tunnelManager.save({ name, host, user, port, sshKeyPath, autoStart, autoConnect });
+      const result = daemon.tunnelManager.save({ name, host, user, port, sshKeyPath, autoStart, autoConnect, projectDir });
       res.json(result);
     } catch (err) {
       res.status(400).json({ error: err.message });

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

@@ -55,7 +55,7 @@ export class ConversationManager {
     return null;
   }
 
-  async create(provider, model, title, mode = 'api') {
+  async create(provider, model, title, mode = 'api', options = {}) {
     if (!provider && this.daemon.config?.defaultChatProvider) {
       provider = this.daemon.config.defaultChatProvider;
     }
@@ -90,6 +90,9 @@ export class ConversationManager {
       provider,
       model: model || null,
       mode: mode === 'agent' ? 'agent' : 'api',
+      reasoningEffort: options.reasoningEffort || null,
+      verbosity: options.verbosity || null,
+      previousResponseId: null,
       createdAt: now,
       updatedAt: now,
       pinned: false,
@@ -218,6 +221,17 @@ export class ConversationManager {
     return conv;
   }
 
+  updateReasoningSettings(id, reasoningEffort, verbosity) {
+    const conv = this.conversations.get(id);
+    if (!conv) throw new Error('Conversation not found');
+    if (reasoningEffort !== undefined) conv.reasoningEffort = reasoningEffort || null;
+    if (verbosity !== undefined) conv.verbosity = verbosity || null;
+    conv.updatedAt = new Date().toISOString();
+    this._save();
+    this.daemon.broadcast({ type: 'conversation:updated', data: conv });
+    return conv;
+  }
+
   async setMode(id, mode) {
     const conv = this.conversations.get(id);
     if (!conv) throw new Error('Conversation not found');
@@ -302,7 +316,7 @@ export class ConversationManager {
     } catch { return null; }
   }
 
-  async sendMessage(id, message, history) {
+  async sendMessage(id, message, history, { reasoningEffort, verbosity } = {}) {
     const conv = this.conversations.get(id);
     if (!conv) throw new Error('Conversation not found');
     if (conv.mode !== 'api') throw new Error('sendMessage only works in API mode');
@@ -331,6 +345,9 @@ export class ConversationManager {
 
     const apiKey = this._getApiKey(providerName);
 
+    const effectiveReasoningEffort = reasoningEffort || conv.reasoningEffort || null;
+    const effectiveVerbosity = verbosity || conv.verbosity || null;
+
     // Try direct API streaming first (sub-second latency)
     const controller = provider.streamChat(
       messages, modelId, apiKey,
@@ -340,7 +357,11 @@ export class ConversationManager {
           data: { conversationId: id, text },
         });
       },
-      () => {
+      (result) => {
+        if (result?.responseId) {
+          conv.previousResponseId = result.responseId;
+          this._save();
+        }
         this._getStreamingProcesses().delete(id);
         this.daemon.broadcast({
           type: 'conversation:complete',
@@ -354,6 +375,11 @@ export class ConversationManager {
           data: { conversationId: id, error: err.message },
         });
       },
+      {
+        reasoningEffort: effectiveReasoningEffort,
+        verbosity: effectiveVerbosity,
+        previousResponseId: conv.previousResponseId,
+      },
     );
 
     if (controller) {

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

@@ -999,7 +999,9 @@ For normal file edits within your scope, proceed without review.
       // Preview launch: when every agent in this team is in a terminal state,
       // kick off the one-click preview (dev server or static serve) the planner
       // staged in the team plan. Fires once per team launch.
-      if (finalStatus === 'completed' && agent.teamId) {
+      // Fire on any terminal status so crashed QC agents don't block preview
+      // when builders completed successfully.
+      if (agent.teamId) {
         this._checkPreviewReady(agent.teamId);
       }
 
@@ -1198,6 +1200,9 @@ For normal file edits within your scope, proceed without review.
    * Fire the one-click preview when the whole team has finished building.
    * Requirements:
    *   - The daemon has a preview plan stashed for this team (planner wrote one).
+   *   - If the team plan has multiple phases, at least one agent from the highest
+   *     phase exists in the registry AND is in a terminal state (prevents launching
+   *     before QC finishes — _checkPhase2 consumes _pendingPhase2 before we run).
    *   - No pending phase 2 groups for this team (QC hasn't spawned yet).
    *   - Every non-planner team agent is in a terminal state.
    *   - At least one non-planner agent completed successfully.
@@ -1219,6 +1224,56 @@ For normal file edits within your scope, proceed without review.
       return;
     }
 
+    // Multi-phase guard: read the team plan to detect phase 2 (QC) agents.
+    // _checkPhase2 runs before this method and consumes _pendingPhase2, so the
+    // pending-group check below may pass even though QC hasn't registered yet.
+    let maxPhase = 1;
+    const maxPhaseRoles = new Set();
+    const expectedRoleCounts = {};
+    const searchPaths = [];
+    if (plan.workingDir) searchPaths.push(resolve(plan.workingDir, '.groove', 'recommended-team.json'));
+    const plannerAgent = this.daemon.registry.getAll().find(a => a.role === 'planner' && a.teamId === teamId);
+    if (plannerAgent?.workingDir) searchPaths.push(resolve(plannerAgent.workingDir, '.groove', 'recommended-team.json'));
+    searchPaths.push(resolve(this.daemon.grooveDir, 'recommended-team.json'));
+
+    for (const planPath of searchPaths) {
+      if (!existsSync(planPath)) continue;
+      try {
+        const raw = JSON.parse(readFileSync(planPath, 'utf8'));
+        const configs = Array.isArray(raw) ? raw : (raw?.agents || []);
+        if (configs.length === 0) continue;
+        for (const cfg of configs) {
+          const phase = typeof cfg.phase === 'number' ? cfg.phase : 1;
+          if (phase > maxPhase) maxPhase = phase;
+        }
+        if (maxPhase > 1) {
+          for (const cfg of configs) {
+            if (cfg.role === 'planner') continue;
+            const role = cfg.role || 'fullstack';
+            const phase = typeof cfg.phase === 'number' ? cfg.phase : 1;
+            expectedRoleCounts[role] = (expectedRoleCounts[role] || 0) + 1;
+            if (phase === maxPhase) maxPhaseRoles.add(role);
+          }
+        }
+        break;
+      } catch { /* malformed, try next */ }
+    }
+
+    if (maxPhase > 1) {
+      const terminalSet = new Set(['completed', 'crashed', 'stopped', 'killed']);
+      const allTeamAgents = this.daemon.registry.getAll().filter(
+        a => a.teamId === teamId && a.role !== 'planner'
+      );
+      for (const role of maxPhaseRoles) {
+        const actual = allTeamAgents.filter(a => a.role === role).length;
+        if (actual < (expectedRoleCounts[role] || 0)) return;
+      }
+      const anyMaxPhaseTerminal = allTeamAgents.some(
+        a => maxPhaseRoles.has(a.role) && terminalSet.has(a.status)
+      );
+      if (!anyMaxPhaseTerminal) return;
+    }
+
     const pendingPhase2 = this.daemon._pendingPhase2 || [];
     for (const group of pendingPhase2) {
       for (const id of group.waitFor) {

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

@@ -153,22 +153,31 @@ export class CodexProvider extends Provider {
     return (inputTokens / 1000) * model.pricing.input + (outputTokens / 1000) * model.pricing.output;
   }
 
-  streamChat(messages, model, apiKey, onChunk, onDone, onError) {
+  streamChat(messages, model, apiKey, onChunk, onDone, onError, { reasoningEffort, verbosity, previousResponseId } = {}) {
     if (!apiKey) return null;
     const controller = new AbortController();
     let finished = false;
-    const finish = () => { if (!finished) { finished = true; onDone(); } };
-    fetch('https://api.openai.com/v1/chat/completions', {
+    let responseId = null;
+    const finish = () => { if (!finished) { finished = true; onDone({ responseId }); } };
+
+    const effort = reasoningEffort || 'medium';
+    const verb = verbosity || 'medium';
+    const body = {
+      model: model || 'gpt-5.5',
+      input: previousResponseId ? [messages[messages.length - 1]] : messages,
+      stream: true,
+      reasoning: { effort },
+      text: { format: { type: 'text' }, verbosity: verb },
+    };
+    if (previousResponseId) body.previous_response_id = previousResponseId;
+
+    fetch('https://api.openai.com/v1/responses', {
       method: 'POST',
       headers: {
         'Authorization': `Bearer ${apiKey}`,
         'Content-Type': 'application/json',
       },
-      body: JSON.stringify({
-        model: model || 'gpt-5.4-mini',
-        messages,
-        stream: true,
-      }),
+      body: JSON.stringify(body),
       signal: controller.signal,
     }).then((res) => {
       if (!res.ok) {
@@ -176,8 +185,11 @@ export class CodexProvider extends Provider {
       }
       return parseSSEStream(res, (event) => {
         if (event.done) { finish(); return; }
-        const content = event.choices?.[0]?.delta?.content;
-        if (content) onChunk(content);
+        if (event.type === 'response.output_text.delta') {
+          if (event.delta) onChunk(event.delta);
+        } else if (event.type === 'response.completed') {
+          responseId = event.response?.id || null;
+        }
       });
     }).then(() => {
       finish();
@@ -313,6 +325,10 @@ export class CodexProvider extends Provider {
           };
         }
 
+        if (result && item.phase !== undefined) {
+          result.phase = item.phase;
+        }
+
         // Attach intermediate context estimate so all 7 layers see Codex progress
         if (result && this._sessionInputTokens > 0) {
           result.contextUsage = this._sessionInputTokens / this._getMaxContext();
@@ -328,6 +344,7 @@ export class CodexProvider extends Provider {
         const inputTokens = usage.input_tokens || 0;
         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;
 
@@ -352,6 +369,7 @@ export class CodexProvider extends Provider {
           tokensUsed: totalTokens,
           inputTokens,
           outputTokens,
+          reasoningTokens,
           cacheReadTokens: cachedTokens,
           cacheCreationTokens,
           contextUsage: inputTokens / maxContext,

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

@@ -43,6 +43,7 @@ export class Registry extends EventEmitter {
       lastActivity: null,
       tokensUsed: 0,
       contextUsage: 0,
+      filesTouched: {},
     };
 
     this.agents.set(agent.id, agent);
@@ -94,6 +95,35 @@ export class Registry extends EventEmitter {
     return this.getAll().filter((a) => a.teamId === teamId);
   }
 
+  trackFileOp(id, filePath, op) {
+    const agent = this.agents.get(id);
+    if (!agent) return;
+    if (!agent.filesTouched) agent.filesTouched = {};
+    const entry = agent.filesTouched[filePath] || { reads: 0, writes: 0, lastOp: null };
+    if (op === 'read') entry.reads++;
+    else entry.writes++;
+    entry.lastOp = new Date().toISOString();
+    agent.filesTouched[filePath] = entry;
+
+    const keys = Object.keys(agent.filesTouched);
+    if (keys.length > 5000) {
+      const sorted = keys
+        .map((k) => ({ k, t: agent.filesTouched[k].lastOp || '' }))
+        .sort((a, b) => a.t.localeCompare(b.t));
+      for (let i = 0; i < keys.length - 5000; i++) {
+        delete agent.filesTouched[sorted[i].k];
+      }
+    }
+  }
+
+  getFilesTouched(id) {
+    const agent = this.agents.get(id);
+    if (!agent || !agent.filesTouched) return [];
+    return Object.entries(agent.filesTouched)
+      .map(([path, info]) => ({ path, reads: info.reads, writes: info.writes, lastOp: info.lastOp }))
+      .sort((a, b) => (b.lastOp || '').localeCompare(a.lastOp || ''));
+  }
+
   restore(agents) {
     for (const agent of agents) {
       agent.status = 'stopped';

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

@@ -90,6 +90,9 @@ export function validateAgentConfig(config) {
 
   const personality = (typeof config.personality === 'string' && config.personality.length > 0 && config.personality.length <= 64 && NAME_PATTERN.test(config.personality)) ? config.personality : undefined;
 
+  const reasoningEffort = config.reasoning_effort !== undefined && config.reasoning_effort !== null
+    ? validateReasoningEffort(config.reasoning_effort) : undefined;
+
   // Return sanitized config (only known fields)
   return {
     role: config.role,
@@ -106,6 +109,7 @@ export function validateAgentConfig(config) {
     integrationApproval,
     repos,
     personality,
+    reasoningEffort,
   };
 }
 
@@ -195,6 +199,25 @@ export function validateGatewayConfig(config) {
   };
 }
 
+const VALID_REASONING_EFFORTS = ['none', 'low', 'medium', 'high', 'xhigh'];
+const VALID_VERBOSITIES = ['low', 'medium'];
+
+export function validateReasoningEffort(value) {
+  if (value === null || value === undefined) return null;
+  if (typeof value !== 'string' || !VALID_REASONING_EFFORTS.includes(value)) {
+    throw new Error(`Invalid reasoning_effort: must be one of ${VALID_REASONING_EFFORTS.join(', ')}`);
+  }
+  return value;
+}
+
+export function validateVerbosity(value) {
+  if (value === null || value === undefined) return null;
+  if (typeof value !== 'string' || !VALID_VERBOSITIES.includes(value)) {
+    throw new Error(`Invalid verbosity: must be one of ${VALID_VERBOSITIES.join(', ')}`);
+  }
+  return value;
+}
+
 export function escapeMd(text) {
   if (!text) return '';
   // Escape markdown special chars that could break table rendering or inject formatting.