groove-dev 0.25.21 → 0.26.2

package/packages/daemon/src/process.js

@@ -5,6 +5,7 @@ import { spawn as cpSpawn } from 'child_process';
 import { createWriteStream, mkdirSync, chmodSync, existsSync, readFileSync, unlinkSync } from 'fs';
 import { resolve } from 'path';
 import { getProvider, getInstalledProviders } from './providers/index.js';
+import { AgentLoop } from './agent-loop.js';
 import { validateAgentConfig } from './validate.js';
 
 // Role-specific prompt prefixes — applied during spawn regardless of entry point
@@ -195,8 +196,9 @@ export class ProcessManager {
     }
 
     // Resolve auto model routing before registering
+    // Treat missing/null/empty model as 'auto' — GUI sends empty string for "Auto" option
     let resolvedModel = config.model;
-    const isAutoRouted = config.model === 'auto';
+    const isAutoRouted = !config.model || config.model === 'auto';
 
     // Register the agent in the registry
     const agent = registry.add({
@@ -210,7 +212,7 @@ export class ProcessManager {
       const { router } = this.daemon;
       router.setMode(agent.id, 'auto');
       const rec = router.recommend(agent.id);
-      if (rec) {
+      if (rec?.model?.id) {
         resolvedModel = rec.model.id;
         registry.update(agent.id, { model: resolvedModel, routingMode: 'auto', routingReason: rec.reason });
       }
@@ -316,6 +318,71 @@ For normal file edits within your scope, proceed without review.
       }
     }
 
+    // Set up log capture (shared between CLI and agent loop paths)
+    const logDir = resolve(this.daemon.grooveDir, 'logs');
+    mkdirSync(logDir, { recursive: true });
+    const logPath = resolve(logDir, `${sanitizeFilename(agent.name)}.log`);
+    const logStream = createWriteStream(logPath, { flags: 'a', mode: 0o600 });
+
+    // ─── Agent Loop path (local models with built-in agentic runtime) ───
+    if (provider.constructor.useAgentLoop) {
+      const loopConfig = provider.getLoopConfig(spawnConfig);
+      logStream.write(`[${new Date().toISOString()}] GROOVE agent-loop: model=${loopConfig.model} api=${loopConfig.apiBase}\n`);
+
+      const loop = new AgentLoop({ daemon: this.daemon, agent, loopConfig, logStream });
+      this.handles.set(agent.id, { loop, logStream });
+      registry.update(agent.id, { status: 'running' });
+
+      // Record spawn lifecycle event
+      if (this.daemon.timeline) {
+        this.daemon.timeline.recordEvent('spawn', {
+          agentId: agent.id, agentName: agent.name, role: agent.role,
+          provider: agent.provider, model: loopConfig.model,
+        });
+      }
+
+      // Wire output events — ProcessManager handles subsystem feeding + GUI broadcast
+      loop.on('output', (output) => {
+        this._handleAgentOutput(agent.id, output);
+      });
+
+      // Wire exit — same lifecycle as CLI agents (timeline, broadcast, journalist, phase2)
+      loop.on('exit', ({ code, signal, status }) => {
+        logStream.write(`[${new Date().toISOString()}] Agent loop exited: status=${status}\n`);
+        logStream.end();
+        this.handles.delete(agent.id);
+        registry.update(agent.id, { status, pid: null });
+
+        if (this.daemon.timeline) {
+          const agentData = registry.get(agent.id);
+          const evtType = status === 'completed' ? 'complete' : status === 'crashed' ? 'crash' : 'kill';
+          this.daemon.timeline.recordEvent(evtType, {
+            agentId: agent.id, agentName: agent.name, role: agent.role,
+            finalTokens: agentData?.tokensUsed || 0, costUsd: agentData?.costUsd || 0,
+          });
+        }
+
+        this.daemon.broadcast({ type: 'agent:exit', agentId: agent.id, code: code || 0, signal, status });
+        if (this.daemon.integrations) this.daemon.integrations.refreshMcpJson();
+        if (status === 'completed' && this.daemon.journalist) this.daemon.journalist.cycle().catch(() => {});
+        this._checkPhase2(agent.id);
+      });
+
+      // Wire errors — broadcast to GUI for display
+      loop.on('error', ({ message }) => {
+        this.daemon.broadcast({
+          type: 'agent:output', agentId: agent.id,
+          data: { type: 'activity', subtype: 'error', data: message },
+        });
+      });
+
+      // Start the agent loop with the fully assembled prompt
+      loop.start(spawnConfig.prompt);
+      return agent;
+    }
+
+    // ─── CLI Spawn path (Claude Code, Codex, Gemini, Ollama CLI) ────────
+
     // Write MCP config for agent integrations (command/args only, no secrets)
     // Credentials are injected via process environment below
     let integrationEnv = {};
@@ -327,12 +394,6 @@ For normal file edits within your scope, proceed without review.
     const spawnCmd = provider.buildSpawnCommand(spawnConfig);
     const { command, args, env, stdin: stdinData } = spawnCmd;
 
-    // Set up log capture
-    const logDir = resolve(this.daemon.grooveDir, 'logs');
-    mkdirSync(logDir, { recursive: true });
-    const logPath = resolve(logDir, `${sanitizeFilename(agent.name)}.log`);
-    const logStream = createWriteStream(logPath, { flags: 'a', mode: 0o600 });
-
     // Log the spawn command (mask anything that looks like an API key)
     const maskArg = (a) => /^(sk-|AIza|key-|token-)/.test(a) ? '***' : a;
     const safeArgs = args.map((a) => maskArg(a.includes(' ') ? `"${a}"` : a));
@@ -519,6 +580,60 @@ For normal file edits within your scope, proceed without review.
     return agent;
   }
 
+  /**
+   * Shared output handler for agent loop events.
+   * Feeds registry, token tracker, classifier, router, and broadcasts to GUI.
+   */
+  _handleAgentOutput(agentId, output) {
+    const { registry, tokens, classifier, router } = this.daemon;
+    const agent = registry.get(agentId);
+    if (!agent) return;
+
+    // Feed classifier for complexity tracking (informs model routing)
+    classifier.addEvent(agentId, output);
+
+    const updates = { lastActivity: new Date().toISOString() };
+
+    // Token tracking — feed subsystems with full breakdown
+    if (output.tokensUsed !== undefined && output.tokensUsed > 0) {
+      updates.tokensUsed = agent.tokensUsed + output.tokensUsed;
+      tokens.record(agentId, {
+        tokens: output.tokensUsed,
+        inputTokens: output.inputTokens,
+        outputTokens: output.outputTokens,
+        cacheReadTokens: output.cacheReadTokens,
+        cacheCreationTokens: output.cacheCreationTokens,
+        model: output.model,
+        estimatedCostUsd: output.estimatedCostUsd,
+      });
+      const tier = classifier.classify(agentId);
+      router.recordUsage(agentId, output.model || agent.model, output.tokensUsed, tier);
+    }
+
+    // Session result data (cost, duration, turns)
+    if (output.type === 'result') {
+      tokens.recordResult(agentId, {
+        costUsd: output.cost, durationMs: output.duration, turns: output.turns,
+      });
+      if (output.cost) updates.costUsd = (agent.costUsd || 0) + output.cost;
+      if (output.duration) updates.durationMs = output.duration;
+      if (output.turns) updates.turns = output.turns;
+    }
+
+    // Context window usage (0-1 scale) — drives rotation threshold
+    if (output.contextUsage !== undefined) {
+      updates.contextUsage = output.contextUsage;
+    }
+
+    // Session ID for resume support
+    if (output.sessionId) {
+      updates.sessionId = output.sessionId;
+    }
+
+    registry.update(agentId, updates);
+    this.daemon.broadcast({ type: 'agent:output', agentId, data: output });
+  }
+
   /**
    * Check if a completed/crashed agent was the last phase 1 agent in a team.
    * If so, auto-spawn the phase 2 (QC/finisher) agents.
@@ -735,8 +850,19 @@ For normal file edits within your scope, proceed without review.
       return;
     }
 
-    const { proc, logStream } = handle;
+    const { proc, loop, logStream } = handle;
+
+    // Agent loop path — clean async stop
+    if (loop) {
+      await loop.stop();
+      // Exit handler already fired; finish cleanup
+      this.handles.delete(agentId);
+      this.daemon.registry.remove(agentId);
+      this.daemon.locks.release(agentId);
+      return;
+    }
 
+    // CLI process path
     return new Promise((resolveKill) => {
       // Give the process 5s to exit gracefully
       const forceTimer = setTimeout(() => {
@@ -764,6 +890,31 @@ For normal file edits within your scope, proceed without review.
     });
   }
 
+  /**
+   * Send a message to a running agent loop.
+   * Returns true if the message was sent, false if the agent doesn't have an active loop.
+   */
+  async sendMessage(agentId, message) {
+    const handle = this.handles.get(agentId);
+    if (!handle?.loop) return false;
+
+    const { loop } = handle;
+    if (!loop.running) return false;
+
+    // Fire and forget — the loop processes the message asynchronously
+    // and emits output events that flow through the normal handler
+    loop.sendMessage(message).catch(() => {});
+    return true;
+  }
+
+  /**
+   * Check if an agent is using the agent loop runtime (vs CLI process).
+   */
+  hasAgentLoop(agentId) {
+    const handle = this.handles.get(agentId);
+    return !!(handle?.loop);
+  }
+
   async killAll() {
     const ids = Array.from(this.handles.keys());
     await Promise.all(ids.map((id) => this.kill(id)));

package/packages/daemon/src/providers/codex.js

@@ -1,7 +1,10 @@
 // GROOVE — Codex Provider (OpenAI)
 // FSL-1.1-Apache-2.0 — see LICENSE
 
-import { execSync } from 'child_process';
+import { execSync, spawn } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
+import { resolve } from 'path';
+import { homedir } from 'os';
 import { Provider } from './base.js';
 
 export class CodexProvider extends Provider {
@@ -10,6 +13,8 @@ export class CodexProvider extends Provider {
   static command = 'codex';
   static authType = 'api-key';
   static envKey = 'OPENAI_API_KEY';
+  // Auth hint — Codex uses its own auth system, not just env vars
+  static authHint = 'Codex requires `codex login` — run: echo "YOUR_KEY" | codex login --with-api-key';
   static models = [
     { id: 'gpt-5.4-pro', name: 'GPT-5.4 Pro', tier: 'heavy', pricing: { input: 0.015, output: 0.06 } },
     { id: 'gpt-5.4', name: 'GPT-5.4', tier: 'heavy', pricing: { input: 0.005, output: 0.02 } },
@@ -32,6 +37,51 @@ export class CodexProvider extends Provider {
     return 'npm i -g @openai/codex';
   }
 
+  /**
+   * Check if Codex has valid authentication.
+   * Codex uses its own auth at ~/.codex/auth.json (NOT just OPENAI_API_KEY env var).
+   * Users must run: codex login (ChatGPT) or: echo "key" | codex login --with-api-key
+   */
+  /**
+   * Auto-login to Codex CLI when user saves an API key in GROOVE.
+   * Pipes the key to `codex login --with-api-key` so users don't need
+   * to know about Codex's separate auth system.
+   */
+  static async onKeySet(key) {
+    if (!CodexProvider.isInstalled()) return { ok: false, error: 'Codex not installed' };
+    return new Promise((res) => {
+      const proc = spawn('codex', ['login', '--with-api-key'], {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        timeout: 15000,
+      });
+      let stderr = '';
+      proc.stderr.on('data', (d) => { stderr += d.toString(); });
+      proc.stdin.write(key);
+      proc.stdin.end();
+      proc.on('exit', (code) => {
+        res(code === 0
+          ? { ok: true, message: 'Codex authenticated via API key' }
+          : { ok: false, error: stderr.slice(-200) || `codex login failed (exit ${code})` });
+      });
+      proc.on('error', (err) => res({ ok: false, error: err.message }));
+      setTimeout(() => { try { proc.kill(); } catch {} res({ ok: false, error: 'Timeout' }); }, 15000);
+    });
+  }
+
+  static isAuthenticated() {
+    const authPath = resolve(homedir(), '.codex', 'auth.json');
+    if (!existsSync(authPath)) return { authenticated: false, reason: 'No auth found. Run: codex login' };
+    try {
+      const auth = JSON.parse(readFileSync(authPath, 'utf8'));
+      if (auth.auth_mode === 'chatgpt' && auth.tokens?.id_token) return { authenticated: true, method: 'chatgpt' };
+      if (auth.auth_mode === 'api-key' && auth.OPENAI_API_KEY) return { authenticated: true, method: 'api-key' };
+      if (auth.OPENAI_API_KEY) return { authenticated: true, method: 'api-key' };
+      return { authenticated: false, reason: 'Auth expired or missing. Run: codex login' };
+    } catch {
+      return { authenticated: false, reason: 'Auth file corrupted. Run: codex login' };
+    }
+  }
+
   buildSpawnCommand(agent) {
     // Use 'codex exec' for non-interactive (headless) operation
     const args = ['exec'];

package/packages/daemon/src/providers/gemini.js

@@ -40,12 +40,13 @@ export class GeminiProvider extends Provider {
     // Without this, Gemini in headless mode can only output text
     args.push('--yolo');
 
-    if (agent.prompt) args.push(agent.prompt);
-
+    // Pass prompt via stdin to avoid OS arg length limits
+    // (intro context + role prompt + skill content can be very long)
     return {
       command: 'gemini',
       args,
       env: agent.apiKey ? { GEMINI_API_KEY: agent.apiKey } : {},
+      stdin: agent.prompt || undefined,
     };
   }
 

package/packages/daemon/src/providers/index.js

@@ -5,12 +5,14 @@ import { ClaudeCodeProvider } from './claude-code.js';
 import { CodexProvider } from './codex.js';
 import { GeminiProvider } from './gemini.js';
 import { OllamaProvider } from './ollama.js';
+import { LocalProvider } from './local.js';
 
 const providers = {
   'claude-code': new ClaudeCodeProvider(),
   'codex': new CodexProvider(),
   'gemini': new GeminiProvider(),
   'ollama': new OllamaProvider(),
+  'local': new LocalProvider(),
 };
 
 export function getProvider(name) {
@@ -24,6 +26,8 @@ export function listProviders() {
     installed: p.constructor.isInstalled(),
     authType: p.constructor.authType,
     envKey: p.constructor.envKey || null,
+    authHint: p.constructor.authHint || null,
+    authStatus: p.constructor.isAuthenticated?.() || null,
     models: p.constructor.models,
     installCommand: p.constructor.installCommand(),
     canHotSwap: p.switchModel ? p.switchModel() : false,

package/packages/daemon/src/providers/local.js

@@ -0,0 +1,183 @@
+// GROOVE — Local Model Provider (Agent Loop Runtime)
+// FSL-1.1-Apache-2.0 — see LICENSE
+//
+// Manages local inference backends (Ollama API, llama-server, any OpenAI-compatible endpoint).
+// Unlike CLI providers (Claude Code, Codex, Gemini), this provider uses GROOVE's built-in
+// agent loop instead of spawning a child process. Set via `useAgentLoop = true`.
+
+import { execSync } from 'child_process';
+import { Provider } from './base.js';
+import { OllamaProvider } from './ollama.js';
+
+// Context window sizes for models commonly run locally
+// These are the *effective* context sizes used by default (not theoretical max)
+const CONTEXT_WINDOWS = {
+  // Qwen 2.5 Coder family — 32K default (can extend to 128K with YaRN)
+  'qwen2.5-coder:7b': 32768,
+  'qwen2.5-coder:14b': 32768,
+  'qwen2.5-coder:32b': 32768,
+  'qwen3-coder-next': 32768,
+  // DeepSeek family — large native context
+  'deepseek-r1:7b': 65536,
+  'deepseek-r1:14b': 65536,
+  'deepseek-r1:32b': 65536,
+  'deepseek-coder-v2:16b': 65536,
+  // Llama 3.1 — 128K context
+  'llama3.1:8b': 131072,
+  'llama3.1:70b': 131072,
+  // Mistral family
+  'mistral:7b': 32768,
+  'mixtral:8x7b': 32768,
+  'codestral': 32768,
+  'devstral-small-2': 32768,
+  // Google
+  'gemma4:12b': 32768,
+  'gemma4:26b': 32768,
+  'codegemma': 8192,
+  // Microsoft
+  'phi3:mini': 128000,
+  'phi3:medium': 128000,
+};
+
+const DEFAULT_CONTEXT_WINDOW = 32768;
+
+// Models known to support native tool/function calling via the OpenAI API format
+const TOOL_CALLING_MODELS = new Set([
+  'qwen2.5-coder', 'qwen3-coder-next',
+  'llama3.1', 'llama3.3',
+  'mistral', 'mixtral', 'codestral', 'devstral-small-2',
+  'gemma4',
+  'phi3',
+]);
+
+export class LocalProvider extends Provider {
+  static name = 'local';
+  static displayName = 'Local Models (Agent Loop)';
+  static command = 'ollama';
+  static authType = 'local';
+  static useAgentLoop = true;
+
+  static get models() {
+    return OllamaProvider.models;
+  }
+
+  static get catalog() {
+    return OllamaProvider.catalog;
+  }
+
+  static isInstalled() {
+    return LocalProvider._hasOllama() || LocalProvider._hasLlamaServer();
+  }
+
+  static _hasOllama() {
+    try {
+      execSync('which ollama', { stdio: 'ignore' });
+      return true;
+    } catch { return false; }
+  }
+
+  static _hasLlamaServer() {
+    try {
+      execSync('which llama-server', { stdio: 'ignore' });
+      return true;
+    } catch { return false; }
+  }
+
+  static installCommand() {
+    return OllamaProvider.installCommand();
+  }
+
+  static hardwareRequirements() {
+    return OllamaProvider.hardwareRequirements();
+  }
+
+  static getSystemHardware() {
+    return OllamaProvider.getSystemHardware();
+  }
+
+  static getInstalledModels() {
+    return OllamaProvider.getInstalledModels();
+  }
+
+  /**
+   * Get configuration for the agent loop runtime.
+   * Called by ProcessManager when useAgentLoop is true.
+   */
+  getLoopConfig(agent) {
+    const model = agent.model || 'qwen2.5-coder:7b';
+    const contextWindow = this.getContextWindow(model);
+
+    // Determine API endpoint
+    let apiBase = 'http://localhost:11434/v1'; // Ollama's OpenAI-compatible endpoint (default)
+
+    // Custom endpoint override from agent config or daemon config
+    if (agent.apiBase) {
+      apiBase = agent.apiBase;
+    }
+
+    return {
+      apiBase,
+      model,
+      contextWindow,
+      temperature: 0.1,
+      maxResponseTokens: 4096,
+      stream: true,
+      headers: {},
+      apiKey: agent.apiKey || null,
+      introContext: agent.introContext || '',
+    };
+  }
+
+  getContextWindow(modelId) {
+    if (!modelId) return DEFAULT_CONTEXT_WINDOW;
+    // Exact match first
+    if (CONTEXT_WINDOWS[modelId]) return CONTEXT_WINDOWS[modelId];
+    // Prefix match (e.g., 'qwen2.5-coder:7b-q4' matches 'qwen2.5-coder:7b')
+    for (const [key, value] of Object.entries(CONTEXT_WINDOWS)) {
+      if (modelId.startsWith(key)) return value;
+    }
+    return DEFAULT_CONTEXT_WINDOW;
+  }
+
+  /**
+   * Check if a model supports native tool/function calling through the API.
+   * Models without native support would need prompt-based tool injection (future).
+   */
+  supportsToolCalling(modelId) {
+    if (!modelId) return false;
+    const base = modelId.split(':')[0];
+    return TOOL_CALLING_MODELS.has(base);
+  }
+
+  // --- Provider interface (backward compat) ---
+
+  buildSpawnCommand(agent) {
+    // Not used when useAgentLoop is true, but required by interface
+    const model = agent.model || 'qwen2.5-coder:7b';
+    return {
+      command: 'ollama', args: ['run', model],
+      env: { OLLAMA_API_BASE: 'http://localhost:11434' },
+      stdin: agent.prompt || undefined,
+    };
+  }
+
+  buildHeadlessCommand(prompt, model) {
+    const m = model || 'qwen2.5-coder:7b';
+    return { command: 'ollama', args: ['run', m], env: {}, stdin: prompt };
+  }
+
+  switchModel() {
+    return false; // Needs rotation for model switch
+  }
+
+  parseOutput(line) {
+    const trimmed = (line || '').trim();
+    if (!trimmed) return null;
+    // Try to parse structured log entries from agent loop
+    try {
+      const entry = JSON.parse(trimmed);
+      if (entry.type) return entry;
+    } catch { /* plain text */ }
+    return { type: 'activity', data: trimmed };
+  }
+}

package/packages/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', 'name', 'routingMode', 'routingReason', 'sessionId', 'skills', 'integrations', 'workingDir', 'effort', 'costUsd', 'durationMs', 'turns', 'inputTokens', 'outputTokens', 'teamId'];
+    const SAFE_FIELDS = ['status', 'pid', 'tokensUsed', 'contextUsage', 'lastActivity', 'model', 'provider', 'name', 'routingMode', 'routingReason', 'sessionId', 'skills', 'integrations', 'workingDir', 'effort', 'costUsd', 'durationMs', 'turns', 'inputTokens', 'outputTokens', 'teamId'];
     for (const key of Object.keys(updates)) {
       if (SAFE_FIELDS.includes(key)) {
         agent[key] = updates[key];