groove-dev 0.27.118 → 0.27.120

package/moe-training/client/trajectory-capture.js

@@ -34,6 +34,12 @@ export class TrajectoryCapture {
     this._offlineRetryTimer = null;
     this._contexts = new Map();
     this._shutdown = false;
+    this._onEnvelopeSent = null;
+  }
+
+  set onEnvelopeSent(fn) {
+    this._onEnvelopeSent = typeof fn === 'function' ? fn : null;
+    if (this._transmissionQueue) this._transmissionQueue.onSent = this._onEnvelopeSent;
   }
 
   async init() {
@@ -46,6 +52,7 @@ export class TrajectoryCapture {
     this._scrubber = new PIIScrubber();
     this._attestation = new SessionAttestation(this._centralCommandUrl);
     this._transmissionQueue = new TransmissionQueue(this._centralCommandUrl);
+    if (this._onEnvelopeSent) this._transmissionQueue.onSent = this._onEnvelopeSent;
     this._transmissionQueue.start();
     this._domainTagger = new DomainTagger();
     await this._domainTagger.init();
@@ -121,6 +128,61 @@ export class TrajectoryCapture {
     await this._attestation.openSession(sessionId, metadata);
   }
 
+  onChatTurnStart(conversationId, provider, model, message) {
+    if (!this._enabled) return null;
+
+    const agentId = `chat-api-${conversationId}-${Date.now()}`;
+    const sessionId = `sess_${randomUUID()}`;
+    const contributorId = ConsentManager.getOrCreateUserId();
+    const metadata = {
+      model_engine: model,
+      provider,
+      agent_role: 'chat',
+      agent_id: agentId,
+      task_complexity: 'medium',
+      team_size: 1,
+      session_quality: 0,
+      groove_version: this._grooveVersion,
+      leaf_context: null,
+    };
+
+    const builder = new EnvelopeBuilder(sessionId, contributorId, metadata);
+    const classifier = new StepClassifier();
+
+    const ctx = {
+      sessionId,
+      parser: null,
+      builder,
+      classifier,
+      metadata,
+      stepCount: 0,
+      chunkCount: 0,
+      totalTokens: 0,
+      errorsEncountered: 0,
+      errorsRecovered: 0,
+      filesModified: 0,
+      coordinationEvents: 0,
+      startTime: Date.now(),
+      chunkTimer: null,
+      allSteps: [],
+      revisionRounds: 0,
+    };
+
+    this._contexts.set(agentId, ctx);
+
+    if (message && typeof message === 'string' && message.trim()) {
+      this._processStep(agentId, ctx, {
+        type: 'instruction',
+        content: message.slice(0, USER_MESSAGE_MAX_CHARS),
+        source: 'user',
+      });
+    }
+
+    this._attestation.openSession(sessionId, metadata).catch(() => {});
+
+    return agentId;
+  }
+
   onStdoutLine(agentId, jsonLine) {
     if (!this._enabled) return;
     const ctx = this._contexts.get(agentId);

package/moe-training/client/transmission-queue.js

@@ -10,6 +10,7 @@ export class TransmissionQueue {
     this._offlineQueue = [];
     this._running = false;
     this._drainPromise = null;
+    this._onSent = null;
 
     if (process.env.NODE_ENV === 'production' && !centralCommandUrl.startsWith('https://')) {
       console.warn('[TransmissionQueue] WARNING: centralCommandUrl does not use HTTPS in production');
@@ -20,6 +21,10 @@ export class TransmissionQueue {
     return this._offlineQueue.length;
   }
 
+  set onSent(fn) {
+    this._onSent = typeof fn === 'function' ? fn : null;
+  }
+
   enqueue(signedEnvelope) {
     if (this._queue.length >= this._maxSize) return;
     if (signedEnvelope?.attestation?.session_hmac === 'OFFLINE') {
@@ -86,6 +91,7 @@ export class TransmissionQueue {
           });
           if (res.ok) {
             success = true;
+            if (this._onSent) this._onSent(envelope);
             break;
           }
         } catch {

package/moe-training/test/client/trajectory-capture.test.js

@@ -354,6 +354,69 @@ describe('TrajectoryCapture — planner/conversational eligibility', () => {
   });
 });
 
+describe('TrajectoryCapture — API chat capture via onChatTurnStart', () => {
+  function makeChatTc() {
+    const tc = makeTc();
+    tc._enabled = true;
+    tc._scrubber = { scrub: (s) => s };
+    tc._attestation = { openSession: async () => {}, closeSession: async () => {}, signEnvelope: (sid, e) => e };
+    tc._transmissionQueue = { enqueue: () => {}, waitForDrain: async () => {} };
+    tc._domainTagger = null;
+    return tc;
+  }
+
+  it('returns a synthetic agent ID and creates context', () => {
+    const tc = makeChatTc();
+    const agentId = tc.onChatTurnStart('conv-123', 'claude-code', 'opus', 'What is React?');
+    assert.ok(agentId);
+    assert.ok(agentId.startsWith('chat-api-conv-123-'));
+    const ctx = tc._contexts.get(agentId);
+    assert.ok(ctx);
+    assert.equal(ctx.metadata.agent_role, 'chat');
+    assert.equal(ctx.metadata.provider, 'claude-code');
+    assert.equal(ctx.metadata.model_engine, 'opus');
+  });
+
+  it('records the user message as an instruction step', () => {
+    const tc = makeChatTc();
+    const agentId = tc.onChatTurnStart('conv-456', 'claude-code', 'opus', 'Explain hooks');
+    const ctx = tc._contexts.get(agentId);
+    assert.equal(ctx.stepCount, 1);
+    assert.equal(ctx.allSteps[0].type, 'instruction');
+    assert.ok(ctx.allSteps[0].content.includes('Explain hooks'));
+  });
+
+  it('works with onParsedOutput and onAgentComplete', async () => {
+    const tc = makeChatTc();
+    const agentId = tc.onChatTurnStart('conv-789', 'claude-code', 'opus', 'Tell me about React');
+
+    tc.onParsedOutput(agentId, { type: 'activity', subtype: 'assistant', data: 'React is a UI library' });
+    tc.onParsedOutput(agentId, { type: 'result', data: 'React is a UI library' });
+
+    const ctx = tc._contexts.get(agentId);
+    assert.equal(ctx.stepCount, 3);
+    assert.equal(ctx.allSteps[1].type, 'thought');
+    assert.equal(ctx.allSteps[2].type, 'resolution');
+
+    await tc.onAgentComplete(agentId, { status: 'SUCCESS' });
+    assert.equal(tc._contexts.has(agentId), false);
+  });
+
+  it('returns null when disabled', () => {
+    const tc = makeChatTc();
+    tc._enabled = false;
+    const agentId = tc.onChatTurnStart('conv-000', 'claude-code', 'opus', 'Hello');
+    assert.equal(agentId, null);
+  });
+
+  it('context has no parser (not needed for API chat)', () => {
+    const tc = makeChatTc();
+    const agentId = tc.onChatTurnStart('conv-nop', 'claude-code', 'opus', 'Hello');
+    const ctx = tc._contexts.get(agentId);
+    assert.equal(ctx.parser, null);
+  });
+});
+
 describe('TrajectoryCapture — initial prompt capture', () => {
   function makeSpawnTc() {
     const tc = makeTc();

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

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/cli",
-  "version": "0.27.118",
+  "version": "0.27.120",
   "description": "GROOVE CLI — manage AI coding agents from your terminal",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",

package/node_modules/@groove-dev/cli/src/commands/start.js

@@ -3,12 +3,13 @@
 
 import { existsSync } from 'fs';
 import { resolve } from 'path';
+import { homedir } from 'os';
 import { Daemon } from '@groove-dev/daemon';
 import chalk from 'chalk';
 import { runSetupWizard, saveKeysViaDaemon } from '../setup.js';
 
 export async function start(options) {
-  const grooveDir = process.env.GROOVE_DIR || resolve(process.cwd(), '.groove');
+  const grooveDir = process.env.GROOVE_DIR || resolve(homedir(), '.groove');
   const isFirstRun = !existsSync(resolve(grooveDir, 'config.json'));
 
   // ── First-run interactive wizard ────────────────────────────

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

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/daemon",
-  "version": "0.27.118",
+  "version": "0.27.120",
   "description": "GROOVE daemon — agent orchestration engine",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",

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, validateReasoningEffort, validateVerbosity } from './validate.js';
+import { validateAgentConfig, validateReasoningEffort, validateVerbosity, validateTeamMode } from './validate.js';
 import { ROLE_INTEGRATIONS, wrapWithRoleReminder } from './process.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -1092,8 +1092,8 @@ export function createApi(app, daemon) {
 
   app.post('/api/teams', (req, res) => {
     try {
-      const team = daemon.teams.create(req.body.name, req.body.workingDir);
-      daemon.audit.log('team.create', { id: team.id, name: team.name, workingDir: team.workingDir });
+      const team = daemon.teams.create(req.body.name, { mode: req.body.mode });
+      daemon.audit.log('team.create', { id: team.id, name: team.name, mode: team.mode, workingDir: team.workingDir });
       res.status(201).json(team);
     } catch (err) {
       res.status(400).json({ error: err.message });
@@ -1147,6 +1147,16 @@ export function createApi(app, daemon) {
     }
   });
 
+  app.post('/api/teams/:id/promote', (req, res) => {
+    try {
+      const team = daemon.teams.promote(req.params.id);
+      daemon.audit.log('team.promote', { id: team.id, name: team.name });
+      res.json(team);
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
   // --- Conversations ---
 
   app.get('/api/conversations', (req, res) => {
@@ -2957,8 +2967,8 @@ Keep responses concise. Help them think, don't lecture them about the system the
 
     try {
       const stat = statSync(result.fullPath);
-      if (stat.size > 5 * 1024 * 1024) {
-        return res.status(400).json({ error: 'File too large (>5MB)' });
+      if (stat.size > 50 * 1024 * 1024) {
+        return res.status(400).json({ error: 'File too large (>50MB)' });
       }
 
       // Binary detection: check first 8KB for null bytes
@@ -2990,8 +3000,8 @@ Keep responses concise. Help them think, don't lecture them about the system the
     if (typeof content !== 'string') {
       return res.status(400).json({ error: 'content must be a string' });
     }
-    if (content.length > 5 * 1024 * 1024) {
-      return res.status(400).json({ error: 'Content too large (>5MB)' });
+    if (content.length > 50 * 1024 * 1024) {
+      return res.status(400).json({ error: 'Content too large (>50MB)' });
     }
 
     try {
@@ -3435,6 +3445,7 @@ Keep responses concise. Help them think, don't lecture them about the system the
       const plannerAgent = found.agentId ? daemon.registry.get(found.agentId) : null;
       const baseDir = plannerAgent?.workingDir || daemon.config?.defaultWorkingDir || daemon.projectDir;
       const plannerProvider = plannerAgent?.provider || undefined;
+      const plannerModel = plannerAgent?.model || undefined;
 
       // Use the planner's teamId so launched agents join the correct team.
       // Priority: explicit from frontend > agent that wrote the file > most recent planner > default
@@ -3447,9 +3458,17 @@ Keep responses concise. Help them think, don't lecture them about the system the
       }
       const defaultTeamId = launchTeamId || daemon.teams.getDefault()?.id || null;
 
+      // Determine team build mode
+      let launchMode;
+      try { launchMode = validateTeamMode(req.body?.mode || raw.mode); } catch { launchMode = 'sandbox'; }
+
       // If planner specified a project directory, create it and use it as workingDir
+      // Production mode: always use projectDir directly, skip subdirectory creation
       let projectWorkingDir = baseDir;
-      if (projectDir) {
+      if (launchMode === 'production') {
+        projectWorkingDir = daemon.projectDir;
+        console.log(`[Groove] Production mode — working in project root: ${projectWorkingDir}`);
+      } else if (projectDir) {
         // Sanitize: kebab-case, no path traversal
         const safeName = String(projectDir).replace(/[^a-zA-Z0-9_-]/g, '-').slice(0, 64);
         projectWorkingDir = resolve(baseDir, safeName);
@@ -3469,6 +3488,15 @@ Keep responses concise. Help them think, don't lecture them about the system the
         });
       }
 
+      function resolveProviderAndModel(cfgProvider, cfgModel, fallbackProvider, fallbackModel) {
+        const provider = cfgProvider || plannerProvider || daemon.config?.defaultProvider || fallbackProvider || undefined;
+        if (cfgModel) return { provider, model: cfgModel };
+        if (!cfgProvider && plannerProvider && plannerProvider !== daemon.config?.defaultProvider) {
+          return { provider, model: plannerModel || 'auto' };
+        }
+        return { provider, model: daemon.config?.defaultModel || fallbackModel || 'auto' };
+      }
+
       // Team-level overrides from the pre-planner config panel
       const teamProvider = req.body?.teamProvider || undefined;
       const teamModel = req.body?.teamModel || undefined;
@@ -3492,10 +3520,12 @@ Keep responses concise. Help them think, don't lecture them about the system the
 
       // Safety net: if planner forgot the QC agent, auto-add one
       if (phase2.length === 0 && phase1.length >= 2) {
+        const { provider: qcProvider, model: qcModel } = resolveProviderAndModel(teamProvider, teamModel);
         phase2 = [{
           name: 'qc-agent',
           role: 'fullstack', phase: 2, scope: [],
-          provider: teamProvider || plannerProvider || daemon.config?.defaultProvider || undefined,
+          provider: qcProvider,
+          model: qcModel,
           prompt: 'QC Senior Dev: All builder agents have completed. Audit their changes for correctness, fix any issues, run tests, and verify the project builds cleanly (npm run build). Do NOT start long-running dev servers — just verify the build succeeds. Commit all changes. IMPORTANT: Do NOT delete files from other projects or directories outside this project.',
         }];
       }
@@ -3548,8 +3578,7 @@ Keep responses concise. Help them think, don't lecture them about the system the
               role: existing.role,
               scope: normalizeScope(config.scope || existing.scope || [], existing.workingDir || projectWorkingDir),
               prompt,
-              provider: config.provider || plannerProvider || daemon.config?.defaultProvider || existing.provider || undefined,
-              model: config.model || existing.model || daemon.config?.defaultModel || 'auto',
+              ...resolveProviderAndModel(config.provider, config.model, existing.provider, existing.model),
               permission: config.permission || existing.permission || 'auto',
               workingDir: existing.workingDir || projectWorkingDir,
               name: existing.name,
@@ -3573,8 +3602,7 @@ 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 || plannerProvider || daemon.config?.defaultProvider || undefined,
-              model: config.model || daemon.config?.defaultModel || 'auto',
+              ...resolveProviderAndModel(config.provider, config.model),
               permission: config.permission || 'auto',
               workingDir: config.workingDir || projectWorkingDir,
               name: config.name || undefined,
@@ -3616,7 +3644,7 @@ 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 || plannerProvider || daemon.config?.defaultProvider || undefined, model: c.model || daemon.config?.defaultModel || 'auto',
+              ...resolveProviderAndModel(c.provider, c.model),
               permission: c.permission || 'auto',
               reasoningEffort: c.reasoningEffort, temperature: c.temperature, verbosity: c.verbosity,
               workingDir: c.workingDir || projectWorkingDir,
@@ -4990,6 +5018,7 @@ Keep responses concise. Help them think, don't lecture them about the system the
       'port', 'journalistInterval', 'rotationThreshold', 'autoRotation',
       'qcThreshold', 'maxAgents', 'defaultProvider', 'defaultWorkingDir',
       'onboardingDismissed', 'defaultModel', 'defaultChatProvider', 'defaultChatModel',
+      'dataSharingDismissed',
     ];
     for (const key of Object.keys(req.body)) {
       if (!ALLOWED_KEYS.includes(key)) {

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

@@ -387,10 +387,19 @@ export class ConversationManager {
     const effectiveReasoningEffort = reasoningEffort || conv.reasoningEffort || null;
     const effectiveVerbosity = verbosity || conv.verbosity || null;
 
+    // Trajectory capture for training data
+    const tc = this.daemon.trajectoryCapture;
+    let tcAgentId = null;
+    let tcResponseText = '';
+    if (tc) {
+      try { tcAgentId = tc.onChatTurnStart(id, providerName, modelId, message); } catch { /* never block chat */ }
+    }
+
     // Try direct API streaming first (sub-second latency)
     const controller = provider.streamChat(
       messages, modelId, apiKey,
       (text) => {
+        if (tcAgentId) tcResponseText += text;
         this.daemon.broadcast({
           type: 'conversation:chunk',
           data: { conversationId: id, text },
@@ -402,6 +411,15 @@ export class ConversationManager {
           this._save();
         }
         this._getStreamingProcesses().delete(id);
+        if (tcAgentId && tc) {
+          try {
+            tc.onParsedOutput(tcAgentId, { type: 'activity', subtype: 'assistant', data: tcResponseText });
+            tc.onParsedOutput(tcAgentId, { type: 'result', data: tcResponseText });
+            tc.onAgentComplete(tcAgentId, { status: 'SUCCESS' });
+            const count = (this.daemon.state.get('training_sessions_captured') || 0) + 1;
+            this.daemon.state.set('training_sessions_captured', count);
+          } catch { /* never block chat */ }
+        }
         this.daemon.broadcast({
           type: 'conversation:complete',
           data: { conversationId: id },
@@ -409,6 +427,9 @@ export class ConversationManager {
       },
       (err) => {
         this._getStreamingProcesses().delete(id);
+        if (tcAgentId && tc) {
+          try { tc.onAgentCrash(tcAgentId, err); } catch { /* never block chat */ }
+        }
         this.daemon.broadcast({
           type: 'conversation:error',
           data: { conversationId: id, error: err.message },
@@ -430,6 +451,9 @@ export class ConversationManager {
     const prompt = this._buildHistoryPrompt(history, message);
     const headlessCmd = provider.buildHeadlessCommand(prompt, modelId);
     if (!headlessCmd) {
+      if (tcAgentId && tc) {
+        try { tc.onAgentCrash(tcAgentId, new Error('No API key for chat')); } catch { /* never block chat */ }
+      }
       this.daemon.broadcast({
         type: 'conversation:error',
         data: { conversationId: id, error: `${providerName} requires an API key for chat` },
@@ -450,6 +474,9 @@ export class ConversationManager {
 
     proc.on('error', (err) => {
       this._getStreamingProcesses().delete(id);
+      if (tcAgentId && tc) {
+        try { tc.onAgentCrash(tcAgentId, err); } catch { /* never block chat */ }
+      }
       this.daemon.broadcast({
         type: 'conversation:error',
         data: { conversationId: id, error: err.message },
@@ -461,6 +488,14 @@ export class ConversationManager {
       proc.stdin.end();
     }
 
+    const emitChunk = (text) => {
+      if (tcAgentId) tcResponseText += text;
+      this.daemon.broadcast({
+        type: 'conversation:chunk',
+        data: { conversationId: id, text },
+      });
+    };
+
     proc.stdout.on('data', (data) => {
       const text = data.toString();
       const lines = text.split('\n');
@@ -473,64 +508,51 @@ export class ConversationManager {
           if (json.type === 'assistant' && json.message?.content) {
             for (const block of json.message.content) {
               if (block.type === 'text' && block.text) {
-                this.daemon.broadcast({
-                  type: 'conversation:chunk',
-                  data: { conversationId: id, text: block.text },
-                });
+                emitChunk(block.text);
               }
             }
             continue;
           }
           if (json.type === 'content_block_delta' && json.delta?.text) {
-            this.daemon.broadcast({
-              type: 'conversation:chunk',
-              data: { conversationId: id, text: json.delta.text },
-            });
+            emitChunk(json.delta.text);
             continue;
           }
           if (json.type === 'result' && json.result) continue;
           if (json.type === 'token' && json.text != null) {
-            this.daemon.broadcast({
-              type: 'conversation:chunk',
-              data: { conversationId: id, text: json.text },
-            });
+            emitChunk(json.text);
             continue;
           }
           if ((json.type === 'done' || json.type === 'complete' || json.type === 'result') && json.text) {
-            this.daemon.broadcast({
-              type: 'conversation:chunk',
-              data: { conversationId: id, text: json.text },
-            });
+            emitChunk(json.text);
             continue;
           }
           if (json.content?.[0]?.text) {
-            this.daemon.broadcast({
-              type: 'conversation:chunk',
-              data: { conversationId: id, text: json.content[0].text },
-            });
+            emitChunk(json.content[0].text);
             continue;
           }
         } catch { /* not JSON */ }
 
         if (!trimmed.startsWith('{')) {
-          this.daemon.broadcast({
-            type: 'conversation:chunk',
-            data: { conversationId: id, text: trimmed },
-          });
+          emitChunk(trimmed);
         }
       }
     });
 
-    proc.on('error', (err) => {
-      this._getStreamingProcesses().delete(id);
-      this.daemon.broadcast({
-        type: 'conversation:error',
-        data: { conversationId: id, error: err.message },
-      });
-    });
-
     proc.on('exit', (code) => {
       this._getStreamingProcesses().delete(id);
+      if (tcAgentId && tc) {
+        try {
+          tc.onParsedOutput(tcAgentId, { type: 'activity', subtype: 'assistant', data: tcResponseText });
+          tc.onParsedOutput(tcAgentId, { type: 'result', data: tcResponseText });
+          if (code === 0 || code === null) {
+            tc.onAgentComplete(tcAgentId, { status: 'SUCCESS' });
+          } else {
+            tc.onAgentCrash(tcAgentId, new Error(`Exit code ${code}`));
+          }
+          const count = (this.daemon.state.get('training_sessions_captured') || 0) + 1;
+          this.daemon.state.set('training_sessions_captured', count);
+        } catch { /* never block chat */ }
+      }
       this.daemon.broadcast({
         type: 'conversation:complete',
         data: { conversationId: id, exitCode: code },

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

@@ -5,6 +5,7 @@ import { createServer as createHttpServer, request as httpProxyRequest } from 'h
 import { createServer as createNetServer } from 'net';
 import { execFileSync } from 'child_process';
 import { resolve } from 'path';
+import { homedir } from 'os';
 import { readFileSync, writeFileSync, unlinkSync, existsSync, mkdirSync, readdirSync, rmdirSync, rmSync, statSync } from 'fs';
 import express from 'express';
 import { WebSocketServer } from 'ws';
@@ -94,7 +95,7 @@ export class Daemon {
     this.port = options.port !== undefined ? options.port : (parseInt(process.env.GROOVE_PORT, 10) || DEFAULT_PORT);
     this.host = resolveHost(options.host);
     this.projectDir = options.projectDir || process.cwd();
-    this.grooveDir = options.grooveDir || resolve(this.projectDir, '.groove');
+    this.grooveDir = options.grooveDir || resolve(homedir(), '.groove');
     this.pidFile = resolve(this.grooveDir, 'daemon.pid');
 
     // Ensure .groove directories exist
@@ -686,6 +687,10 @@ export class Daemon {
         centralCommandUrl: process.env.GROOVE_CENTRAL_URL || 'https://api.groovedev.ai',
         grooveVersion: version,
       });
+      this.trajectoryCapture.onEnvelopeSent = () => {
+        const count = (this.state.get('training_envelopes_sent') || 0) + 1;
+        this.state.set('training_envelopes_sent', count);
+      };
       this.trajectoryCapture.init();
     } catch (e) {
       // Training capture is never critical

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

@@ -16,10 +16,10 @@ export class Introducer {
   generateContext(newAgent, options = {}) {
     const { taskNegotiation, hasTask, isRotation } = options;
     const agents = this.daemon.registry.getAll();
-    // Only include ACTIVE agents — not completed/killed ones from previous sessions
-    // Completed agents' work is captured in the journalist's project map, not here
+    // Only include ACTIVE agents from the SAME TEAM — never leak cross-team state
     const others = agents.filter((a) => a.id !== newAgent.id &&
-      (a.status === 'running' || a.status === 'starting'));
+      (a.status === 'running' || a.status === 'starting') &&
+      a.teamId === newAgent.teamId);
 
     const lines = [
       `# GROOVE Agent Context`,
@@ -475,7 +475,6 @@ export class Introducer {
     const agents = this.daemon.registry.getAll();
 
     if (agents.length === 0) {
-      // Clean up if no agents
       const regPath = resolve(projectDir, 'AGENTS_REGISTRY.md');
       if (existsSync(regPath)) {
         writeFileSync(regPath, '');
@@ -483,25 +482,39 @@ export class Introducer {
       return;
     }
 
-    const lines = [
-      `# AGENTS REGISTRY`,
-      ``,
-      `*Auto-generated by GROOVE. Do not edit manually.*`,
-      ``,
-      `| ID | Name | Role | Provider | Directory | Scope | Status |`,
-      `|----|------|------|----------|-----------|-------|--------|`,
-    ];
-
+    // Group agents by team so each team's registry only shows its own agents
+    const teamGroups = new Map();
     for (const a of agents) {
-      const scope = a.scope?.length > 0 ? `\`${a.scope.join('`, `')}\`` : '-';
-      const dir = a.workingDir ? escapeMd(a.workingDir) : '-';
-      lines.push(`| ${escapeMd(a.id)} | ${escapeMd(a.name)} | ${escapeMd(a.role)} | ${escapeMd(a.provider)} | ${dir} | ${scope} | ${escapeMd(a.status)} |`);
+      const tid = a.teamId || '_default';
+      if (!teamGroups.has(tid)) teamGroups.set(tid, []);
+      teamGroups.get(tid).push(a);
     }
 
-    lines.push('');
-    lines.push(`*Updated: ${new Date().toISOString()}*`);
+    // Write a scoped registry into each team's workingDir
+    for (const [teamId, teamAgents] of teamGroups) {
+      const team = teamId !== '_default' ? this.daemon.teams?.get(teamId) : null;
+      const dir = team?.workingDir || projectDir;
+
+      const lines = [
+        `# AGENTS REGISTRY`,
+        ``,
+        `*Auto-generated by GROOVE. Do not edit manually.*`,
+        ``,
+        `| ID | Name | Role | Provider | Directory | Scope | Status |`,
+        `|----|------|------|----------|-----------|-------|--------|`,
+      ];
+
+      for (const a of teamAgents) {
+        const scope = a.scope?.length > 0 ? `\`${a.scope.join('`, `')}\`` : '-';
+        const agentDir = a.workingDir ? escapeMd(a.workingDir) : '-';
+        lines.push(`| ${escapeMd(a.id)} | ${escapeMd(a.name)} | ${escapeMd(a.role)} | ${escapeMd(a.provider)} | ${agentDir} | ${scope} | ${escapeMd(a.status)} |`);
+      }
 
-    writeFileSync(resolve(projectDir, 'AGENTS_REGISTRY.md'), lines.join('\n'));
+      lines.push('');
+      lines.push(`*Updated: ${new Date().toISOString()}*`);
+
+      writeFileSync(resolve(dir, 'AGENTS_REGISTRY.md'), lines.join('\n'));
+    }
   }
 
   injectGrooveSection(projectDir) {
@@ -510,7 +523,19 @@ export class Introducer {
     // clobbering the user's content.
     const claudeMdPath = resolve(projectDir, 'CLAUDE.md');
     const agents = this.daemon.registry.getAll();
-    const running = agents.filter((a) => a.status === 'running');
+
+    // Only show agents that belong to this project directory — exclude agents
+    // from teams with their own isolated workingDir (sandbox teams)
+    const isolatedDirs = new Set();
+    if (this.daemon.teams) {
+      for (const team of this.daemon.teams.list()) {
+        if (team.workingDir && team.workingDir !== projectDir) {
+          isolatedDirs.add(team.workingDir);
+        }
+      }
+    }
+    const running = agents.filter((a) => a.status === 'running' &&
+      !isolatedDirs.has(a.workingDir));
 
     const grooveContent = [
       GROOVE_SECTION_START,