groove-dev 0.27.27 → 0.27.29

package/CLAUDE.md

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

package/README.md

@@ -7,6 +7,20 @@ The open-source orchestration layer for AI coding tools. Spawn teams of agents,
 [![npm](https://img.shields.io/npm/v/groove-dev)](https://www.npmjs.com/package/groove-dev)
 [![License](https://img.shields.io/badge/license-FSL--1.1--Apache--2.0-blue)](LICENSE)
 
+## Get Started
+
+### Download the App
+
+No terminal needed. Download, install, open a project folder.
+
+- [**macOS** (.dmg)](https://github.com/grooveai-dev/groove/releases/latest) — Intel and Apple Silicon
+- [**Windows** (.exe)](https://github.com/grooveai-dev/groove/releases/latest) — one-click installer
+- [**Linux** (.AppImage)](https://github.com/grooveai-dev/groove/releases/latest) — x64 and ARM
+
+Everything is bundled — daemon, GUI, auto-updates. No Node.js required.
+
+### Developer Install
+
 ```bash
 npm i -g groove-dev
 groove start
@@ -16,6 +30,20 @@ The GUI opens at `http://localhost:31415`. On a VPS? groove detects it and tells
 
 ---
 
+## Desktop App
+
+The desktop app is the easiest way to use groove — no terminal, no dependencies, no setup.
+
+- **Full GUI dashboard** — agent tree, chat, editor, telemetry, marketplace, all in one window
+- **Bundled daemon** — starts automatically when you open a project, stops when you close it
+- **System tray** — quick access to recent projects, daemon status, and controls
+- **Automatic updates** — new versions install silently in the background
+- **Multi-workspace** — open any project folder; manages one daemon per project
+- **Platform support** — macOS (Intel + Apple Silicon), Windows (x64 + ARM64), Linux (x64 + ARM64)
+- **No dependencies** — everything is bundled. No Node.js, no terminal knowledge needed
+
+---
+
 ## The Problem
 
 AI coding agents waste your money and lose their way:

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

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

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

@@ -9,7 +9,9 @@ import { spawn, execFile } from 'child_process';
 import { lookup as mimeLookup } from './mimetypes.js';
 import { listProviders, getProvider } from './providers/index.js';
 import { OllamaProvider } from './providers/ollama.js';
+import { ClaudeCodeProvider } from './providers/claude-code.js';
 import { validateAgentConfig } from './validate.js';
+import { ROLE_INTEGRATIONS } from './process.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkgVersion = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
@@ -179,6 +181,88 @@ export function createApi(app, daemon) {
     res.json({ ok: true });
   });
 
+  // --- Role-to-Integration Mapping ---
+
+  app.get('/api/roles/integrations', (req, res) => {
+    const roleFilter = req.query.role;
+    const entries = roleFilter ? { [roleFilter]: ROLE_INTEGRATIONS[roleFilter] || [] } : ROLE_INTEGRATIONS;
+    const result = {};
+    for (const [role, ids] of Object.entries(entries)) {
+      result[role] = (ids || []).map((id) => {
+        const status = daemon.integrations.getStatus(id);
+        const entry = daemon.integrations.registry.find((r) => r.id === id);
+        return {
+          id,
+          name: entry?.name || id,
+          installed: status?.installed || false,
+          configured: status?.configured || false,
+          authenticated: status?.authenticated || false,
+        };
+      });
+    }
+    if (roleFilter) return res.json(result[roleFilter] || []);
+    res.json(result);
+  });
+
+  app.post('/api/agents/preflight', (req, res) => {
+    const { role, integrations } = req.body || {};
+    if (!role || !Array.isArray(integrations)) {
+      return res.status(400).json({ error: 'role and integrations[] required' });
+    }
+    const issues = [];
+    for (const id of integrations) {
+      const status = daemon.integrations.getStatus(id);
+      const entry = daemon.integrations.registry.find((r) => r.id === id);
+      const name = entry?.name || id;
+      if (!status || !status.installed) {
+        issues.push({ integrationId: id, name, problem: 'not_installed' });
+      } else if (!status.configured) {
+        issues.push({ integrationId: id, name, problem: 'not_configured' });
+      } else if (!status.authenticated) {
+        issues.push({ integrationId: id, name, problem: 'not_authenticated' });
+      }
+    }
+    res.json({ ready: issues.length === 0, issues });
+  });
+
+  // --- Agent Integration Attach/Detach ---
+
+  app.post('/api/agents/:id/integrations/:integrationId', (req, res) => {
+    const agent = daemon.registry.get(req.params.id);
+    if (!agent) return res.status(404).json({ error: 'Agent not found' });
+
+    const integrationId = req.params.integrationId;
+    const status = daemon.integrations.getStatus(integrationId);
+    if (!status || !status.installed) {
+      return res.status(400).json({ error: `Integration not installed: ${integrationId}` });
+    }
+
+    const integrations = new Set(agent.integrations || []);
+    integrations.add(integrationId);
+    const updated = Array.from(integrations);
+
+    daemon.registry.update(req.params.id, { integrations: updated });
+    daemon.integrations.writeMcpJson(daemon.integrations.getActiveIntegrations());
+    daemon.integrations.refreshMcpJson();
+    daemon.audit.log('agent.integration.attach', { agentId: req.params.id, integrationId });
+    daemon.broadcast({ type: 'agent:integration:attach', agentId: req.params.id, integrationId });
+    res.json({ ok: true, integrations: updated });
+  });
+
+  app.delete('/api/agents/:id/integrations/:integrationId', (req, res) => {
+    const agent = daemon.registry.get(req.params.id);
+    if (!agent) return res.status(404).json({ error: 'Agent not found' });
+
+    const integrationId = req.params.integrationId;
+    const integrations = (agent.integrations || []).filter((id) => id !== integrationId);
+
+    daemon.registry.update(req.params.id, { integrations });
+    daemon.integrations.refreshMcpJson();
+    daemon.audit.log('agent.integration.detach', { agentId: req.params.id, integrationId });
+    daemon.broadcast({ type: 'agent:integration:detach', agentId: req.params.id, integrationId });
+    res.json({ ok: true, integrations });
+  });
+
   // Lock management
   app.get('/api/locks', (req, res) => {
     res.json(daemon.locks.getAll());
@@ -307,10 +391,25 @@ export function createApi(app, daemon) {
     // Enrich with credential status
     for (const p of providers) {
       p.hasKey = daemon.credentials.hasKey(p.id);
+      if (p.id === 'claude-code') {
+        p.authStatus = ClaudeCodeProvider.getAuthStatus();
+      }
     }
     res.json(providers);
   });
 
+  // --- Claude Code Auth ---
+
+  app.get('/api/providers/claude-code/auth', (req, res) => {
+    res.json(ClaudeCodeProvider.getAuthStatus());
+  });
+
+  app.post('/api/providers/claude-code/login', (req, res) => {
+    ClaudeCodeProvider.triggerLogin();
+    daemon.audit.log('claude-code.login.started', {});
+    res.json({ ok: true });
+  });
+
   // --- Ollama ---
 
   app.get('/api/providers/ollama/hardware', (req, res) => {

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

@@ -166,7 +166,7 @@ export class Journalist {
     return false;
   }
 
-  collectFilteredLogs(agents) {
+  collectFilteredLogs(agents, { since } = {}) {
     const result = {};
 
     for (const agent of agents) {
@@ -181,7 +181,7 @@ export class Journalist {
         const size = Buffer.byteLength(content);
         this.lastLogSizes[agent.id] = size;
 
-        const { entries, explorationEntries } = this.filterLog(content, agent);
+        const { entries, explorationEntries } = this.filterLog(content, agent, { since });
         result[agent.id] = { agent, entries, explorationEntries };
       } catch {
         result[agent.id] = { agent, entries: [], explorationEntries: [] };
@@ -191,7 +191,7 @@ export class Journalist {
     return result;
   }
 
-  filterLog(rawLog, agent) {
+  filterLog(rawLog, agent, { since } = {}) {
     // Parse stream-json lines and extract meaningful events.
     // Focus on PROGRESS (writes, edits, commands with results) not EXPLORATION (reads, greps).
     // Exploration tools are tracked separately so handoff briefs can include what was examined.
@@ -200,12 +200,15 @@ export class Journalist {
     const lines = rawLog.split('\n');
     const toolResults = new Map(); // tool_use_id -> result text
 
+    const sinceDate = since ? new Date(since) : null;
+
     // First pass: collect tool results (and error flags) so we can attach them to tool calls
     const toolErrors = new Set(); // tool_use_ids that returned errors
     for (const line of lines) {
       if (!line.trim() || line.startsWith('[')) continue;
       try {
         const data = JSON.parse(line);
+        if (sinceDate && data.timestamp && new Date(data.timestamp) < sinceDate) continue;
         if (data.type === 'user' && data.message?.content) {
           const content = Array.isArray(data.message.content) ? data.message.content : [];
           for (const block of content) {
@@ -227,6 +230,7 @@ export class Journalist {
 
       try {
         const data = JSON.parse(line);
+        if (sinceDate && data.timestamp && new Date(data.timestamp) < sinceDate) continue;
 
         // Tool use — only keep WRITES, EDITS, and COMMANDS (progress, not exploration)
         if (data.type === 'assistant' && data.message?.content) {
@@ -415,6 +419,56 @@ export class Journalist {
     return parts.join('\n');
   }
 
+  buildRotationSynthesisPrompt(agent, entries, options = {}) {
+    const dir = agent.workingDir ? `\nWorking directory: ${agent.workingDir}` : '';
+    const reason = options.reason || 'manual rotation';
+
+    const parts = [
+      'You are briefing the next AI agent taking over this exact role.',
+      `The previous agent (${agent.name}, role: ${agent.role}) is being rotated out.`,
+      `Scope: ${agent.scope?.join(', ') || 'unrestricted'}${dir}`,
+      `Rotation reason: ${reason}`,
+      '',
+      'Analyze the session log below and produce a structured handoff brief.',
+      '',
+      'Output EXACTLY these sections:',
+      '',
+      '## Accomplishments',
+      '(What was completed. Name files, functions, and line numbers.)',
+      '',
+      '## In Progress',
+      '(What was actively being worked on when rotation happened.)',
+      '',
+      '## Key Decisions',
+      '(Architectural or implementation choices made and why.)',
+      '',
+      '## Blockers/Errors',
+      '(Unresolved errors, failed attempts, things that did not work.)',
+      '',
+      '## Next Steps',
+      '(What should be done next, in priority order.)',
+      '',
+      'Be specific. Name files, functions, and line numbers. Do not summarize vaguely.',
+      'Keep your response under 2000 characters.',
+      '',
+      '---',
+      '',
+      `### Session Log for ${agent.name} (${agent.role})`,
+      '',
+    ];
+
+    let totalChars = 0;
+    const cap = 30_000;
+    for (const entry of entries.slice(-200)) {
+      const line = this.formatEntry(entry);
+      if (totalChars + line.length > cap) break;
+      parts.push(line);
+      totalChars += line.length;
+    }
+
+    return parts.join('\n');
+  }
+
   formatEntry(entry) {
     switch (entry.type) {
       case 'tool': {
@@ -739,35 +793,10 @@ export class Journalist {
   // --- Handoff Brief for Context Rotation ---
 
   async generateHandoffBrief(agent, options = {}) {
-    const filteredLogs = this.collectFilteredLogs([agent]);
+    const filteredLogs = this.collectFilteredLogs([agent], { since: agent.spawnedAt });
     const agentLog = filteredLogs[agent.id];
     const entries = agentLog?.entries || [];
 
-    const errorSummary = entries
-      .filter((e) => e.type === 'error')
-      .map((e) => `- ${e.text}`)
-      .slice(-10)
-      .join('\n');
-
-    const resultSummary = entries
-      .filter((e) => e.type === 'result')
-      .map((e) => e.text)
-      .slice(-3)
-      .join('\n');
-
-    // Build file changes section — group Edit/Write operations by file path
-    const fileChanges = {};
-    for (const e of entries.filter((e) => e.type === 'tool' && (e.tool === 'Edit' || e.tool === 'Write'))) {
-      const file = e.input || 'unknown';
-      if (!fileChanges[file]) fileChanges[file] = [];
-      if (e.diff) fileChanges[file].push(e.diff);
-      else fileChanges[file].push(e.tool === 'Write' ? 'created' : 'modified');
-    }
-    const fileChangesSummary = Object.entries(fileChanges)
-      .map(([file, changes]) => `- **${file}**: ${changes.slice(0, 3).join('; ')}`)
-      .slice(0, 20)
-      .join('\n');
-
     // Layer 7 memory: discoveries, constraints, specializations
     const discoveries = this.daemon.memory?.getDiscoveriesMarkdown(agent.role, 10, 2000) || '';
     const constraints = this.daemon.memory?.getConstraintsMarkdown(2000) || '';
@@ -776,26 +805,58 @@ export class Journalist {
       ? `- Quality profile: ${specialization.avgQualityScore}/100 across ${specialization.sessionCount} sessions`
       : '';
 
-    // Pull recent rotation history from persistent memory (Layer 7).
-    // Gives the new agent causal continuity: what the last 3 agents struggled
-    // with, decided, and solved — not just what the current session did.
     const recentChain = this.daemon.memory?.getRecentHandoffMarkdown(agent.role, 3, 3000, agent.workingDir, agent.teamId) || '';
 
-    // Pull the user's recent messages scoped to this agent
     const agentFeedback = this.getUserFeedback(agent.id).slice(-5);
     const conversationSummary = agentFeedback.length > 0
       ? agentFeedback.map((fb) => `- "${fb.message}"`).join('\n')
       : '';
 
-    // Compact last 5 tool calls (not full output, just tool + target)
-    const recentTools = entries
-      .filter((e) => e.type === 'tool' || e.type === 'error')
-      .slice(-5)
-      .map((e) => `- ${e.type === 'error' ? 'ERROR ' : ''}${e.tool}: ${(e.input || '').slice(0, 80)}`)
-      .join('\n');
+    // Try AI-synthesized session summary
+    let sessionSummary = '';
+    try {
+      const prompt = this.buildRotationSynthesisPrompt(agent, entries, options);
+      sessionSummary = await this.callHeadless(prompt, { trackAs: '__rotation__' });
+    } catch {
+      // Fallback: structural summary from raw logs
+      const errorSummary = entries
+        .filter((e) => e.type === 'error')
+        .map((e) => `- ${e.text}`)
+        .slice(-10)
+        .join('\n');
+
+      const resultSummary = entries
+        .filter((e) => e.type === 'result')
+        .map((e) => e.text)
+        .slice(-3)
+        .join('\n');
+
+      const fileChanges = {};
+      for (const e of entries.filter((e) => e.type === 'tool' && (e.tool === 'Edit' || e.tool === 'Write'))) {
+        const file = e.input || 'unknown';
+        if (!fileChanges[file]) fileChanges[file] = [];
+        if (e.diff) fileChanges[file].push(e.diff);
+        else fileChanges[file].push(e.tool === 'Write' ? 'created' : 'modified');
+      }
+      const fileChangesSummary = Object.entries(fileChanges)
+        .map(([file, changes]) => `- **${file}**: ${changes.slice(0, 3).join('; ')}`)
+        .slice(0, 20)
+        .join('\n');
+
+      const recentTools = entries
+        .filter((e) => e.type === 'tool' || e.type === 'error')
+        .slice(-5)
+        .map((e) => `- ${e.type === 'error' ? 'ERROR ' : ''}${e.tool}: ${(e.input || '').slice(0, 80)}`)
+        .join('\n');
+
+      const fallbackParts = [];
+      if (errorSummary) fallbackParts.push(`## Unresolved Errors\n\n${errorSummary}`);
+      if (recentTools) fallbackParts.push(`## Last 5 Tool Calls\n\n${recentTools}`);
+      if (fileChangesSummary) fallbackParts.push(`## Files Modified\n\n${fileChangesSummary}`);
+      if (resultSummary) fallbackParts.push(`## Accomplishments\n\n${resultSummary}`);
+      sessionSummary = fallbackParts.join('\n\n');
+    }
 
-    // Brief priority: errors > constraints > recent tools > accomplishments
-    // The rotator already wraps this with session continuation context
     return [
       `# Handoff Brief — ${agent.name} (${agent.role})`,
       ``,
@@ -804,13 +865,10 @@ export class Journalist {
       `Rotation: ${options.reason || 'manual'}${options.qualityScore ? ` (quality: ${options.qualityScore}/100)` : ''} | Tokens: ${agent.tokensUsed}`,
       specLine,
       ``,
-      errorSummary ? `## Unresolved Errors (fix these first)\n\n${errorSummary}\n` : '',
+      sessionSummary ? `## Session Summary\n\n${sessionSummary}\n` : '',
       constraints ? `## Project Constraints (must follow)\n\n${constraints}\n` : '',
       discoveries ? `## Known Issues & Fixes\n\n${discoveries}\n` : '',
       conversationSummary ? `## Recent User Messages\n\n${conversationSummary}\n` : '',
-      recentTools ? `## Last 5 Tool Calls\n\n${recentTools}\n` : '',
-      fileChangesSummary ? `## Files Modified\n\n${fileChangesSummary}\n` : '',
-      resultSummary ? `## Accomplishments\n\n${resultSummary}\n` : '',
       recentChain ? `## Rotation History\n\n${recentChain}\n` : '',
       agent.prompt ? `## Original Task\n\n${agent.prompt}\n` : '',
       ``,

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

@@ -266,6 +266,18 @@ IMPORTANT: Do not use markdown formatting like ** or ### in your output. Write i
 `,
 };
 
+// Role-to-integration mapping — recommended integrations per role for onboarding preflight
+export const ROLE_INTEGRATIONS = {
+  ea: ['gmail', 'google-calendar'],
+  cmo: ['gmail', 'slack', 'hubspot'],
+  cfo: ['stripe', 'google-sheets'],
+  support: ['gmail', 'slack', 'zendesk'],
+  analyst: ['google-sheets', 'postgres', 'mixpanel'],
+  home: ['home-assistant'],
+  slides: ['google-slides'],
+  creative: ['google-docs'],
+};
+
 // Permission-level prompt instructions
 // "auto" = PM reviews risky ops via API. "full" = no reviews, max speed.
 const PERMISSION_PROMPTS = {

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

@@ -1,7 +1,7 @@
 // GROOVE — Claude Code Provider
 // FSL-1.1-Apache-2.0 — see LICENSE
 
-import { execSync } from 'child_process';
+import { execSync, spawn as cpSpawn } from 'child_process';
 import { writeFileSync, readFileSync, existsSync } from 'fs';
 import { resolve } from 'path';
 import { homedir } from 'os';
@@ -223,4 +223,29 @@ export class ClaudeCodeProvider extends Provider {
 
     return merged;
   }
+
+  static getAuthStatus() {
+    try {
+      const out = execSync('claude auth status --json', { encoding: 'utf8', timeout: 10_000, stdio: ['pipe', 'pipe', 'pipe'] });
+      const data = JSON.parse(out);
+      return {
+        authenticated: true,
+        authMethod: data.authMethod || data.auth_method || 'unknown',
+        email: data.email || null,
+        subscriptionType: data.subscriptionType || data.subscription_type || null,
+        orgName: data.orgName || data.org_name || null,
+      };
+    } catch (err) {
+      return { authenticated: false, error: err.message };
+    }
+  }
+
+  static triggerLogin() {
+    const child = cpSpawn('claude', ['auth', 'login', '--claudeai'], {
+      detached: true,
+      stdio: 'ignore',
+    });
+    child.unref();
+    return { pid: child.pid };
+  }
 }

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

@@ -201,7 +201,7 @@ describe('Journalist', () => {
       assert.ok(brief.includes('src/api/**'));
       assert.ok(brief.includes('5000'));
       assert.ok(brief.includes('Build the auth API'));
-      assert.ok(brief.includes('Write'));
+      assert.ok(brief.includes('Session Summary') || brief.includes('Write'));
     });
 
     it('instructs the agent to deliver the output, not passively wait', async () => {