groove-dev 0.27.7 → 0.27.11

package/node_modules/@groove-dev/daemon/src/gateways/manager.js

@@ -816,18 +816,31 @@ export class GatewayManager {
 
       // Register phase 2 for auto-spawn
       if (phase2.length > 0 && phase1Ids.length > 0) {
-        this.daemon._pendingPhase2 = this.daemon._pendingPhase2 || [];
-        this.daemon._pendingPhase2.push({
-          waitFor: phase1Ids,
-          agents: phase2.map((c) => ({
-            role: c.role, scope: c.scope || [], prompt: c.prompt || '',
-            provider: c.provider || 'claude-code', model: c.model || 'auto',
-            permission: c.permission || 'auto',
-            workingDir: c.workingDir || defaultDir,
-            name: c.name || undefined,
-            teamId: defaultTeamId,
-          })),
-        });
+        // Dedup: if a running idle fullstack already exists in this team,
+        // skip the phase2 queue — _triggerIdleQC will notify it when phase 1 completes
+        const teamAgents = this.daemon.registry.getAll().filter((a) => a.teamId === defaultTeamId);
+        const existingQC = teamAgents.find((a) =>
+          a.role === 'fullstack' &&
+          (a.status === 'running' || a.status === 'starting')
+        );
+        const qcIsIdle = existingQC && (this.daemon.journalist?.getAgentFiles(existingQC) || []).length === 0;
+
+        if (existingQC && qcIsIdle) {
+          this.daemon.audit.log('phase2.skipQueue', { existingQC: existingQC.id, name: existingQC.name, reason: 'idle fullstack exists', source: 'gateway' });
+        } else {
+          this.daemon._pendingPhase2 = this.daemon._pendingPhase2 || [];
+          this.daemon._pendingPhase2.push({
+            waitFor: phase1Ids,
+            agents: phase2.map((c) => ({
+              role: c.role, scope: c.scope || [], prompt: c.prompt || '',
+              provider: c.provider || 'claude-code', model: c.model || 'auto',
+              permission: c.permission || 'auto',
+              workingDir: c.workingDir || defaultDir,
+              name: c.name || undefined,
+              teamId: defaultTeamId,
+            })),
+          });
+        }
       }
 
       this.daemon.audit.log('team.launch', {

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

@@ -36,8 +36,10 @@ import { MemoryStore } from './memory.js';
 import { TerminalManager } from './terminal-pty.js';
 import { GatewayManager } from './gateways/manager.js';
 import { McpManager } from './mcp-manager.js';
+import { TunnelManager } from './tunnel-manager.js';
 import { ModelManager } from './model-manager.js';
 import { LlamaServerManager } from './llama-server.js';
+import { RepoImporter } from './repo-import.js';
 import { isFirstRun, runFirstTimeSetup, loadConfig, saveConfig, printWelcome } from './firstrun.js';
 
 const DEFAULT_PORT = 31415;
@@ -137,6 +139,8 @@ export class Daemon {
     this.modelManager = new ModelManager(this);
     this.llamaServer = new LlamaServerManager(this);
     this.mcpManager = new McpManager(this);
+    this.tunnelManager = new TunnelManager(this);
+    this.repoImporter = new RepoImporter(this);
 
     // HTTP + WebSocket server
     this.app = express();
@@ -450,6 +454,9 @@ export class Daemon {
     this.fileWatcher.unwatchAll();
     this.terminalManager.killAll();
 
+    // Disconnect all SSH tunnels
+    this.tunnelManager.shutdown();
+
     // Kill all agent processes, stop MCP servers, and stop inference servers
     await this.processes.killAll();
     this.mcpManager.stopAll();

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

@@ -37,6 +37,17 @@ export class Introducer {
       lines.push(`You have no file scope restrictions.`);
     }
 
+    // Sandbox boundary for imported repos
+    if (newAgent.workingDir) {
+      const sandboxPath = resolve(newAgent.workingDir, '.groove', 'sandbox.json');
+      if (existsSync(sandboxPath)) {
+        lines.push('');
+        lines.push(`## HARD BOUNDARY`);
+        lines.push('');
+        lines.push(`You MUST NOT read, write, or modify ANY file outside \`${newAgent.workingDir}/\`. This is a sandboxed imported repo. If setup instructions require changes outside this directory, ask the user first.`);
+      }
+    }
+
     lines.push('');
 
     if (others.length === 0) {
@@ -249,7 +260,13 @@ export class Introducer {
         lines.push('');
         lines.push(`## Integrations (${integrationSections.length} connected)`);
         lines.push('');
-        lines.push('You have integrations connected via GROOVE. To use them, make HTTP POST requests:');
+        lines.push('These integrations are ALREADY INSTALLED, AUTHENTICATED, AND READY TO USE. You do NOT need to:');
+        lines.push('- Ask the user for any API keys, OAuth tokens, or credentials for these services');
+        lines.push('- Set up authentication or run any auth flows');
+        lines.push('- Direct the user to any external auth pages');
+        lines.push('The user has already configured everything. Just use the tools.');
+        lines.push('');
+        lines.push('To use them, make HTTP POST requests:');
         lines.push('```');
         lines.push('POST http://localhost:31415/api/integrations/{id}/exec');
         lines.push('Body: {"tool": "tool_name", "params": {...}}');
@@ -257,14 +274,65 @@ export class Introducer {
         lines.push('To discover available tools: `GET http://localhost:31415/api/integrations/{id}/tools`');
         lines.push('');
         lines.push('**Approval gates:** Some tools require human approval (e.g., sending emails, creating charges).');
-        lines.push('If you get a `requiresApproval: true` response with an `approvalId`, tell the user the action');
-        lines.push('needs approval in the GROOVE GUI. Do NOT retry until the user confirms it has been approved.');
-        lines.push('To retry: include `"approvalId": "<id>"` in your next exec request body.');
+        lines.push('If you get a `requiresApproval: true` response, the action has been queued for user approval.');
+        lines.push('GROOVE will show the user an approval modal and auto-execute the action once approved.');
+        lines.push('Do NOT tell the user to approve anything. Do NOT retry the request yourself. Just wait — you will receive a message confirming the result once the action is approved and executed.');
         lines.push('');
         lines.push(integrationSections.join('\n\n'));
       }
     }
 
+    // GitHub repo import — teach agents to use the tracked import API
+    // Attached repos — only inject repos explicitly attached to this agent
+    if (newAgent.repos && newAgent.repos.length > 0 && this.daemon.repoImporter) {
+      const repoSections = [];
+      for (const importId of newAgent.repos) {
+        const manifest = this.daemon.repoImporter.getImport(importId);
+        if (manifest && manifest.status === 'active') {
+          const stack = manifest.stackInfo ? ` (${manifest.stackInfo.runtime || 'unknown'})` : '';
+          repoSections.push(`- **${manifest.name || manifest.repo}**${stack}: \`${manifest.clonedTo}\` — import ID: ${manifest.id}`);
+        }
+      }
+      if (repoSections.length > 0) {
+        lines.push('');
+        lines.push(`## Attached Repositories (${repoSections.length})`);
+        lines.push('');
+        lines.push('These repos are cloned and attached to you. Use the paths below — do NOT re-clone them:');
+        lines.push(...repoSections);
+        lines.push('');
+        lines.push('If you spawn processes or modify config files for these repos, register them:');
+        lines.push('- `POST http://localhost:31415/api/repos/{importId}/process` with `{ "pid": <number>, "command": "description" }`');
+      }
+    }
+
+    // Lightweight import API reference for cloning new repos
+    lines.push('');
+    lines.push('## GitHub Repo Import');
+    lines.push('');
+    lines.push('To clone a NEW GitHub repo, use: `POST http://localhost:31415/api/repos/import` with `{ "repoUrl": "...", "targetPath": "~/Projects/name", "createTeam": true }`. Do NOT run `git clone` directly.');
+
+    // Surface stored API keys so agents know what's available in their environment
+    const KEY_MAP = { codex: 'OPENAI_API_KEY', gemini: 'GEMINI_API_KEY', ollama: 'OLLAMA_API_KEY' };
+    try {
+      const credProviders = this.daemon.credentials?.listProviders() || [];
+      if (credProviders.length > 0) {
+        lines.push('');
+        lines.push('## Available API Keys');
+        lines.push('');
+        lines.push('GROOVE has API keys stored and injected into your environment. Do NOT ask the user for these:');
+        for (const cp of credProviders) {
+          const envVar = KEY_MAP[cp.provider];
+          if (envVar) {
+            lines.push(`- **${cp.provider}**: available as \`${envVar}\` in your environment`);
+          } else {
+            lines.push(`- **${cp.provider}**: stored in GROOVE credentials`);
+          }
+        }
+        lines.push('');
+        lines.push('If a third-party tool needs one of these keys, it is already in your environment — do not ask the user to provide it.');
+      }
+    } catch { /* credentials not available */ }
+
     return lines.join('\n');
   }
 

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

@@ -138,7 +138,7 @@ export class Journalist {
     for (const agent of agents) {
       const logPath = resolve(this.daemon.grooveDir, 'logs', `${agent.name}.log`);
       if (!existsSync(logPath)) {
-        result[agent.id] = { agent, entries: [] };
+        result[agent.id] = { agent, entries: [], explorationEntries: [] };
         continue;
       }
 
@@ -147,10 +147,10 @@ export class Journalist {
         const size = Buffer.byteLength(content);
         this.lastLogSizes[agent.id] = size;
 
-        const entries = this.filterLog(content, agent);
-        result[agent.id] = { agent, entries };
+        const { entries, explorationEntries } = this.filterLog(content, agent);
+        result[agent.id] = { agent, entries, explorationEntries };
       } catch {
-        result[agent.id] = { agent, entries: [] };
+        result[agent.id] = { agent, entries: [], explorationEntries: [] };
       }
     }
 
@@ -160,7 +160,9 @@ export class Journalist {
   filterLog(rawLog, agent) {
     // 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.
     const entries = [];
+    const explorationEntries = [];
     const lines = rawLog.split('\n');
     const toolResults = new Map(); // tool_use_id -> result text
 
@@ -198,8 +200,17 @@ export class Journalist {
               if (block.type === 'tool_use') {
                 const tool = block.name;
 
-                // Skip exploration tools — reads/searches are noise for synthesis
-                if (tool === 'Read' || tool === 'Glob' || tool === 'Grep') continue;
+                // Track exploration tools separately — they're noise for synthesis
+                // but valuable for handoff briefs (what files/patterns were examined)
+                if (tool === 'Read' || tool === 'Glob' || tool === 'Grep') {
+                  explorationEntries.push({
+                    type: 'exploration',
+                    tool,
+                    input: this.summarizeToolInput(tool, block.input),
+                    timestamp: data.timestamp,
+                  });
+                  continue;
+                }
 
                 const entry = {
                   type: 'tool',
@@ -223,10 +234,11 @@ export class Journalist {
 
                 entries.push(entry);
               } else if (block.type === 'text' && block.text) {
-                // Only keep substantial reasoning (decisions, conclusions)
-                // Short fragments like "Let me check..." are noise
+                // Keep reasoning that contains decisions or conclusions.
+                // Under 50 chars is noise ("Let me check...", "OK"), but 50-200
+                // often contains key decisions like "Using X instead of Y".
                 const text = block.text.trim();
-                if (text.length > 200) {
+                if (text.length > 50) {
                   entries.push({ type: 'thinking', text: text.slice(0, 2000), timestamp: data.timestamp });
                 }
               }
@@ -250,7 +262,7 @@ export class Journalist {
       }
     }
 
-    return entries;
+    return { entries, explorationEntries };
   }
 
   summarizeToolInput(toolName, input) {
@@ -260,6 +272,12 @@ export class Journalist {
         return input.file_path || input.path || '';
       case 'Edit':
         return input.file_path || input.path || '';
+      case 'Read':
+        return input.file_path || input.path || '';
+      case 'Grep':
+        return `${input.pattern || ''}${input.path ? ' in ' + input.path : ''}`;
+      case 'Glob':
+        return input.pattern || '';
       case 'Bash':
         return (input.command || '').slice(0, 150);
       default:
@@ -653,10 +671,11 @@ export class Journalist {
 
   // --- Handoff Brief for Context Rotation ---
 
-  async generateHandoffBrief(agent) {
+  async generateHandoffBrief(agent, options = {}) {
     const filteredLogs = this.collectFilteredLogs([agent]);
     const agentLog = filteredLogs[agent.id];
     const entries = agentLog?.entries || [];
+    const explorationEntries = agentLog?.explorationEntries || [];
 
     // Get current project map — scoped to agent's workspace if applicable
     const mapPath = resolve(this.daemon.projectDir, 'GROOVE_PROJECT_MAP.md');
@@ -684,6 +703,33 @@ export class Journalist {
       .slice(-3)
       .join('\n');
 
+    // Build exploration summary — what files/patterns were examined
+    const explorationSummary = explorationEntries
+      .map((e) => `- ${e.tool}: ${e.input}`)
+      .slice(-20)
+      .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) || '';
+    const specialization = this.daemon.memory?.getSpecialization(agent.id);
+    const specLine = specialization?.avgQualityScore != null
+      ? `- 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.
@@ -700,11 +746,15 @@ export class Journalist {
       ? agentFeedback.map((fb) => `- "${fb.message}"`).join('\n')
       : '';
 
+    // Rotation reason for the new agent
+    const rotationTrigger = `- Rotation trigger: ${options.reason || 'manual'}${options.qualityScore ? ` (quality: ${options.qualityScore}/100)` : ''}`;
+
     return [
       `# Session Continuation`,
       ``,
       `You are **${agent.name}** (role: ${agent.role}). This is an internal context refresh — `,
       `the conversation with the user is ongoing and must feel seamless to them. They cannot see this brief.`,
+      rotationTrigger,
       ``,
       `## CRITICAL: Finish What You Were Doing`,
       ``,
@@ -729,6 +779,7 @@ export class Journalist {
       `- Scope: ${agent.scope?.join(', ') || 'unrestricted'}`,
       `- Provider: ${agent.provider}`,
       agent.workingDir ? `- Working directory: ${agent.workingDir}` : '',
+      specLine,
       ``,
       `## Session State`,
       `- Tokens used before refresh: ${agent.tokensUsed}`,
@@ -737,6 +788,10 @@ export class Journalist {
       toolSummary ? `### Recent tool calls (what you were doing)\n${toolSummary}\n` : '',
       resultSummary ? `### Last results\n${resultSummary}\n` : '',
       errorSummary ? `### Unresolved errors\n${errorSummary}\n` : '',
+      fileChangesSummary ? `## Files Modified\n\n${fileChangesSummary}\n` : '',
+      explorationSummary ? `## Exploration Context\n\n${explorationSummary}\n` : '',
+      discoveries ? `## Known Issues & Fixes\n\n${discoveries}\n` : '',
+      constraints ? `## Project Constraints\n\n${constraints}\n` : '',
       `## Current Project State`,
       ``,
       projectMap ? projectMap.slice(0, 10000) : 'No project map available yet.',

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

@@ -2,7 +2,7 @@
 // FSL-1.1-Apache-2.0 — see LICENSE
 
 import { spawn as cpSpawn } from 'child_process';
-import { createWriteStream, mkdirSync, chmodSync, existsSync, readFileSync, unlinkSync, readdirSync, copyFileSync } from 'fs';
+import { createWriteStream, mkdirSync, chmodSync, existsSync, readFileSync, writeFileSync, unlinkSync, readdirSync, copyFileSync } from 'fs';
 import { resolve, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { getProvider, getInstalledProviders } from './providers/index.js';
@@ -66,6 +66,19 @@ Do NOT write code unless explicitly asked. Use your MCP tools (database queries,
 - Researching topics to produce accurate, substantive writing
 You CAN use code tools to create and edit text files, markdown documents, and structured content. For best results, apply a writing skill from the Marketplace that matches your task.
 
+`,
+  chat: `You are a Chat agent — a conversational companion, friend, and assistant. You are warm, curious, and genuinely engaged. You can discuss anything: ideas, philosophy, science, culture, coding, life.
+
+Your primary mode is conversation, but you can still perform ANY task the user asks — code, research, analysis, writing. When no task is given, lean into being a great conversational partner.
+
+Key behaviors:
+- Be genuinely interested in the user's thoughts
+- Ask thoughtful follow-up questions
+- Share perspectives and explore ideas together
+- Match the user's energy — playful, serious, philosophical, technical
+- Remember context within the conversation
+- Be honest and direct, not sycophantic
+
 `,
   frontend: `You are a Frontend agent. You build and modify UI components, views, and state management. Focus on:
 - Writing clean React/JSX with Tailwind CSS classes — zero inline styles unless dynamic
@@ -351,6 +364,23 @@ export class ProcessManager {
       }
     }
 
+    // Create empty personality file for this agent
+    const personalityDir = resolve(this.daemon.grooveDir, 'personalities');
+    mkdirSync(personalityDir, { recursive: true });
+    const personalityFile = resolve(personalityDir, `${agent.name}.md`);
+    if (!existsSync(personalityFile)) {
+      if (config.personality) {
+        const templateFile = resolve(personalityDir, `${config.personality}.md`);
+        if (existsSync(templateFile)) {
+          copyFileSync(templateFile, personalityFile);
+        } else {
+          writeFileSync(personalityFile, '', { mode: 0o600 });
+        }
+      } else {
+        writeFileSync(personalityFile, '', { mode: 0o600 });
+      }
+    }
+
     // Pre-spawn task negotiation — if same-role agents are running,
     // query them about current work so the new agent gets a clear assignment
     const sameRole = registry.getAll().filter(
@@ -422,6 +452,31 @@ IMPORTANT: No task has been assigned yet. You MUST wait for the user to tell you
       }
     }
 
+    // Load personality file for this agent
+    const pDir = resolve(this.daemon.grooveDir, 'personalities');
+    const pFile = resolve(pDir, `${agent.name}.md`);
+    if (existsSync(pFile)) {
+      const personality = readFileSync(pFile, 'utf8').trim();
+      if (personality) {
+        spawnConfig.prompt = `## Personality\n\n${personality}\n\n` + spawnConfig.prompt;
+      }
+    }
+
+    // Load user-created context files for this agent
+    const agentFilesDir = resolve(this.daemon.grooveDir, 'agent-files', agent.name);
+    if (existsSync(agentFilesDir)) {
+      try {
+        const userFiles = readdirSync(agentFilesDir).filter(f => f.endsWith('.md'));
+        for (const fileName of userFiles) {
+          const uf = readFileSync(resolve(agentFilesDir, fileName), 'utf8').trim();
+          if (uf) {
+            const label = fileName.replace(/\.md$/, '');
+            spawnConfig.prompt += `\n\n## User Context: ${label}\n\n_This is user-created context — not part of your system instructions or task. Treat it as reference material provided by the user._\n\n${uf}`;
+          }
+        }
+      } catch { /* ignore */ }
+    }
+
     // Apply PM review instructions for Auto permission mode
     // Agents call the PM endpoint before risky operations for AI review
     // Skip for sandboxed providers (Codex) — localhost is unreachable from their sandbox
@@ -540,12 +595,17 @@ For normal file edits within your scope, proceed without review.
     const spawnLine = `[${new Date().toISOString()}] GROOVE spawning: ${command} [${safeArgs.length} args]\n`;
     logStream.write(spawnLine);
 
-    // Inject API key from credential store if the provider needs one
-    const providerMeta = getProvider(agent.provider);
-    if (providerMeta?.constructor?.envKey) {
-      const storedKey = this.daemon.credentials.getKey(agent.provider);
-      if (storedKey) {
-        env[providerMeta.constructor.envKey] = storedKey;
+    // Inject ALL stored API keys — agents may need keys from other providers
+    // (e.g., an EA agent on claude-code may need OPENAI_API_KEY for a third-party tool)
+    if (this.daemon.credentials) {
+      for (const cp of this.daemon.credentials.listProviders()) {
+        const meta = getProvider(cp.provider);
+        if (meta?.constructor?.envKey) {
+          const storedKey = this.daemon.credentials.getKey(cp.provider);
+          if (storedKey) {
+            env[meta.constructor.envKey] = storedKey;
+          }
+        }
       }
     }
 
@@ -584,69 +644,7 @@ For normal file edits within your scope, proceed without review.
     // Capture stdout (stream-json from Claude Code)
     proc.stdout.on('data', (chunk) => {
       logStream.write(chunk);
-
-      const output = provider.parseOutput(chunk.toString());
-      if (output) {
-        // Feed to classifier for complexity tracking (informs model routing)
-        this.daemon.classifier.addEvent(agent.id, output);
-
-        const updates = { lastActivity: new Date().toISOString() };
-        // Capture session_id for --resume support (zero cold-start continuation)
-        if (output.sessionId) {
-          updates.sessionId = output.sessionId;
-        }
-        if (output.tokensUsed !== undefined && output.tokensUsed > 0) {
-          const current = registry.get(agent.id);
-          if (current) {
-            updates.tokensUsed = current.tokensUsed + output.tokensUsed;
-            // Feed token tracker with full breakdown for savings calculations
-            this.daemon.tokens.record(agent.id, {
-              tokens: output.tokensUsed,
-              inputTokens: output.inputTokens,
-              outputTokens: output.outputTokens,
-              cacheReadTokens: output.cacheReadTokens,
-              cacheCreationTokens: output.cacheCreationTokens,
-              model: output.model,
-              estimatedCostUsd: output.estimatedCostUsd,
-            });
-            // Feed router cost log for tier tracking
-            const tier = this.daemon.classifier.classify(agent.id);
-            this.daemon.router.recordUsage(agent.id, output.model || current.model, output.tokensUsed, tier);
-          }
-        }
-        // Record session result data (cost, duration, turns)
-        if (output.type === 'result') {
-          this.daemon.tokens.recordResult(agent.id, {
-            costUsd: output.cost, durationMs: output.duration, turns: output.turns,
-          });
-          const resultUpdates = {};
-          if (output.cost) resultUpdates.costUsd = (registry.get(agent.id)?.costUsd || 0) + output.cost;
-          if (output.duration) resultUpdates.durationMs = output.duration;
-          if (output.turns) resultUpdates.turns = output.turns;
-          if (Object.keys(resultUpdates).length > 0) registry.update(agent.id, resultUpdates);
-        }
-        if (output.contextUsage !== undefined) {
-          updates.contextUsage = output.contextUsage;
-
-          const peak = this.peakContextUsage.get(agent.id) || 0;
-          if (output.contextUsage > peak) {
-            this.peakContextUsage.set(agent.id, output.contextUsage);
-          } else if (peak >= COMPACTION_MIN_PEAK) {
-            const drop = peak - output.contextUsage;
-            if (drop >= COMPACTION_DROP_THRESHOLD * peak) {
-              this.daemon.rotator.recordNaturalCompaction(agent, peak, output.contextUsage);
-              this.peakContextUsage.set(agent.id, output.contextUsage);
-            }
-          }
-        }
-        registry.update(agent.id, updates);
-
-        this.daemon.broadcast({
-          type: 'agent:output',
-          agentId: agent.id,
-          data: output,
-        });
-      }
+      this._processStdoutChunk(agent.id, provider, chunk);
     });
 
     // Capture stderr — collect for crash reporting
@@ -763,6 +761,33 @@ For normal file edits within your scope, proceed without review.
    * Shared output handler for agent loop events.
    * Feeds registry, token tracker, classifier, router, and broadcasts to GUI.
    */
+  // Buffer stdout across chunks and parse each complete stream-json line
+  // separately. Two bugs this fixes:
+  //   1. A JSON line can span chunk boundaries — parsing each chunk in isolation
+  //      drops the partial line, so big assistant turns vanish.
+  //   2. A single assistant msg_id emits multiple JSON lines (thinking, text,
+  //      tool_use), and parseOutput merges all events in its input into one
+  //      output — keeping only the first activity's content. Text blocks after
+  //      a thinking block got silently dropped, which is why long planner
+  //      plans never reached chat.
+  _processStdoutChunk(agentId, provider, chunk) {
+    const handle = this.handles.get(agentId);
+    if (!handle) return;
+
+    handle.stdoutBuffer = (handle.stdoutBuffer || '') + chunk.toString();
+    const lastNewline = handle.stdoutBuffer.lastIndexOf('\n');
+    if (lastNewline === -1) return;
+
+    const complete = handle.stdoutBuffer.slice(0, lastNewline + 1);
+    handle.stdoutBuffer = handle.stdoutBuffer.slice(lastNewline + 1);
+
+    for (const line of complete.split('\n')) {
+      if (!line) continue;
+      const output = provider.parseOutput(line);
+      if (output) this._handleAgentOutput(agentId, output);
+    }
+  }
+
   _handleAgentOutput(agentId, output) {
     const { registry, tokens, classifier, router } = this.daemon;
     const agent = registry.get(agentId);
@@ -862,6 +887,38 @@ For normal file edits within your scope, proceed without review.
         // so QC also waits for instructions instead of auditing nothing
         for (const config of group.agents) {
           if (phase1Idle) config.prompt = '';
+
+          // Dedup: check if team already has an agent with this role
+          const teamId = config.teamId || this.daemon.teams.getDefault()?.id || null;
+          const existing = teamId ? registry.getAll().find((a) =>
+            a.teamId === teamId && a.role === config.role && a.id !== undefined
+          ) : null;
+
+          if (existing && (existing.status === 'running' || existing.status === 'starting')) {
+            // Agent already active — reuse it instead of spawning a duplicate
+            if (config.prompt) {
+              this.sendMessage(existing.id, config.prompt).catch((err) => {
+                console.error(`[Groove] Phase 2 reuse message failed for ${existing.name}: ${err.message}`);
+              });
+            }
+            this.daemon.audit.log('phase2.reuse', { id: existing.id, name: existing.name, role: existing.role });
+            this.daemon.broadcast({
+              type: 'phase2:spawned',
+              agentId: existing.id,
+              name: existing.name,
+              role: existing.role,
+              reused: true,
+            });
+            continue;
+          }
+
+          if (existing && (existing.status === 'completed' || existing.status === 'stopped' || existing.status === 'crashed' || existing.status === 'killed')) {
+            // Previous agent finished — remove it and respawn with the same name
+            config.name = existing.name;
+            registry.remove(existing.id);
+            this.daemon.locks.release(existing.id);
+          }
+
           try {
             const validated = validateAgentConfig(config);
             if (!validated.teamId) validated.teamId = this.daemon.teams.getDefault()?.id || null;
@@ -1079,40 +1136,7 @@ For normal file edits within your scope, proceed without review.
     // Same stdout/stderr/exit handling as spawn
     proc.stdout.on('data', (chunk) => {
       logStream.write(chunk);
-      const output = provider.parseOutput(chunk.toString());
-      if (output) {
-        this.daemon.classifier.addEvent(newAgent.id, output);
-        const updates = { lastActivity: new Date().toISOString() };
-        if (output.sessionId) updates.sessionId = output.sessionId;
-        if (output.tokensUsed !== undefined && output.tokensUsed > 0) {
-          const current = registry.get(newAgent.id);
-          if (current) {
-            updates.tokensUsed = current.tokensUsed + output.tokensUsed;
-            this.daemon.tokens.record(newAgent.id, {
-              tokens: output.tokensUsed,
-              inputTokens: output.inputTokens,
-              outputTokens: output.outputTokens,
-              cacheReadTokens: output.cacheReadTokens,
-              cacheCreationTokens: output.cacheCreationTokens,
-              model: output.model,
-              estimatedCostUsd: output.estimatedCostUsd,
-            });
-          }
-        }
-        if (output.type === 'result') {
-          this.daemon.tokens.recordResult(newAgent.id, {
-            costUsd: output.cost, durationMs: output.duration, turns: output.turns,
-          });
-          const resultUpdates = {};
-          if (output.cost) resultUpdates.costUsd = (registry.get(newAgent.id)?.costUsd || 0) + output.cost;
-          if (output.duration) resultUpdates.durationMs = output.duration;
-          if (output.turns) resultUpdates.turns = output.turns;
-          if (Object.keys(resultUpdates).length > 0) registry.update(newAgent.id, resultUpdates);
-        }
-        if (output.contextUsage !== undefined) updates.contextUsage = output.contextUsage;
-        registry.update(newAgent.id, updates);
-        this.daemon.broadcast({ type: 'agent:output', agentId: newAgent.id, data: output });
-      }
+      this._processStdoutChunk(newAgent.id, provider, chunk);
     });
 
     proc.stderr.on('data', (chunk) => { logStream.write(`[stderr] ${chunk}`); });

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

@@ -51,7 +51,7 @@ export class Registry extends EventEmitter {
     if (!agent) return null;
 
     // Only allow known fields to prevent prototype pollution
-    const SAFE_FIELDS = ['status', 'pid', 'tokensUsed', 'contextUsage', 'lastActivity', 'model', 'provider', 'name', 'routingMode', 'routingReason', 'sessionId', 'skills', 'integrations', 'workingDir', 'effort', 'costUsd', 'durationMs', 'turns', 'inputTokens', 'outputTokens', 'teamId', 'permission', 'scope', 'integrationApproval'];
+    const SAFE_FIELDS = ['status', 'pid', 'tokensUsed', 'contextUsage', 'lastActivity', 'model', 'provider', 'name', 'routingMode', 'routingReason', 'sessionId', 'skills', 'integrations', 'repos', 'workingDir', 'effort', 'costUsd', 'durationMs', 'turns', 'inputTokens', 'outputTokens', 'teamId', 'permission', 'scope', 'integrationApproval', 'personality'];
     for (const key of Object.keys(updates)) {
       if (SAFE_FIELDS.includes(key)) {
         agent[key] = updates[key];