groove-dev 0.27.119 → 0.27.120

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

@@ -128,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/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.119",
+  "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.119",
+  "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

@@ -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
@@ -3477,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;
@@ -3500,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.',
         }];
       }
@@ -3556,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,
@@ -3581,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,
@@ -3624,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,

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

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,

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

@@ -697,6 +697,28 @@ export class ProcessManager {
       }
     }
 
+    // Validate provider is both installed and authenticated — fall back if not
+    const isProviderAuthed = (name) => {
+      const p = getProvider(name);
+      if (!p || !p.constructor.isInstalled()) return false;
+      const authType = p.constructor.authType;
+      if (authType === 'local' || authType === 'none') return true;
+      if (authType === 'api-key') return !!this.daemon.credentials?.hasKey(name);
+      if (authType === 'subscription') {
+        const status = p.constructor.isAuthenticated?.();
+        return status?.authenticated === true;
+      }
+      return true;
+    };
+
+    if (!isProviderAuthed(providerName)) {
+      const priority = ['claude-code', 'gemini', 'codex', 'local', 'ollama'];
+      const fallback = priority.find(p => p !== providerName && isProviderAuthed(p));
+      if (fallback) {
+        providerName = fallback;
+      }
+    }
+
     const provider = getProvider(providerName);
     if (!provider) {
       throw new Error(`Unknown provider: ${providerName}`);
@@ -717,7 +739,11 @@ export class ProcessManager {
     if (config.model && config.model !== 'auto' && provider.constructor.models) {
       const valid = provider.constructor.models.some(m => m.id === config.model);
       if (!valid) {
-        throw new Error(`Model '${config.model}' is not available for ${provider.constructor.displayName}. Available: ${provider.constructor.models.map(m => m.id).join(', ')}`);
+        const fallback = provider.constructor.models[0];
+        if (fallback) {
+          console.log(`[Groove] Model '${config.model}' not available for ${provider.constructor.displayName}, falling back to '${fallback.id}'`);
+          config.model = fallback.id;
+        }
       }
     }
 
@@ -1099,6 +1125,26 @@ For normal file edits within your scope, proceed without review.
       }
     }
 
+    // Best-effort Codex auth recovery: refresh ~/.codex/auth.json if stale
+    const agentProviderName = agent.provider || config.provider;
+    if (agentProviderName === 'codex') {
+      const codexMeta = getProvider('codex');
+      if (codexMeta?.constructor?.isAuthenticated) {
+        const authStatus = codexMeta.constructor.isAuthenticated();
+        if (!authStatus?.authenticated && this.daemon.credentials?.hasKey('codex')) {
+          const storedKey = this.daemon.credentials.getKey('codex');
+          if (storedKey && codexMeta.constructor.onKeySet) {
+            try {
+              const result = await codexMeta.constructor.onKeySet(storedKey);
+              logStream.write(`[${new Date().toISOString()}] Codex auth recovery: ${result?.ok ? 'success' : result?.error || 'failed'}\n`);
+            } catch (e) {
+              logStream.write(`[${new Date().toISOString()}] Codex auth recovery error: ${e.message}\n`);
+            }
+          }
+        }
+      }
+    }
+
     // Spawn the process (use pipe for stdin if provider needs to send prompt via stdin)
     const spawnCwd = [providerCwd, agent.workingDir, this.daemon.projectDir].find(d => d && existsSync(d)) || this.daemon.projectDir;
     const proc = cpSpawn(command, args, {

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

@@ -358,6 +358,39 @@ export class Teams {
     }
   }
 
+  promote(id) {
+    const team = this.teams.get(id);
+    if (!team) throw new Error('Team not found');
+    if (team.mode === 'production') throw new Error('Team is already in production mode');
+
+    const oldDir = team.workingDir;
+    const targetDir = this.daemon.projectDir;
+
+    const entries = readdirSync(oldDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name === '.groove') continue;
+      const src = resolve(oldDir, entry.name);
+      const dest = resolve(targetDir, entry.name);
+      cpSync(src, dest, { recursive: true, force: true });
+    }
+
+    rmSync(oldDir, { recursive: true, force: true });
+
+    team.workingDir = targetDir;
+    team.mode = 'production';
+
+    const agents = this.daemon.registry.getAll().filter((a) => a.teamId === id);
+    for (const agent of agents) {
+      if (agent.workingDir === oldDir) {
+        this.daemon.registry.update(agent.id, { workingDir: targetDir });
+      }
+    }
+
+    this._save();
+    this.daemon.broadcast({ type: 'team:updated', team });
+    return team;
+  }
+
   // Backward compat stubs
   onAgentChange() {}
   getActiveTeam() { return this.getDefault()?.name || null; }