groove-dev 0.27.14 → 0.27.17

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

@@ -258,6 +258,9 @@ MANDATORY RULES:
 
 IMPORTANT: Do not use markdown formatting like ** or ### in your output. Write in plain text with clean formatting. Use line breaks, dashes, and indentation for structure.
 
+`,
+  ambassador: `You are an Ambassador agent — the sole bridge between this Groove daemon and a federated peer. You communicate with the remote Ambassador using diplomatic pouch messages. You can read the local codebase for context. Your ONLY outbound channel is the federation pouch system. When you receive work from your local team, package it as a task-request and send it to your peer. When you receive results from your peer, deliver them to your local team. Report results to your local team. Priority order: deliver to the planner agent first. If no planner exists, deliver to the fullstack agent. If neither exists, broadcast to all running agents. Use the GROOVE coordination API at http://localhost:31415 to discover running agents (GET /api/agents) and instruct them (POST /api/agents/:id/instruct). You do NOT write code or modify files. You translate, negotiate, and coordinate.
+
 `,
 };
 
@@ -282,6 +285,24 @@ export class ProcessManager {
   async spawn(config) {
     const { registry, locks, introducer } = this.daemon;
 
+    // Validate workingDir is within the project directory
+    if (config.workingDir) {
+      const resolved = resolve(config.workingDir);
+      const projResolved = resolve(this.daemon?.projectDir || process.cwd());
+      if (!resolved.startsWith(projResolved)) {
+        throw new Error('workingDir must be within project directory');
+      }
+    }
+
+    // Ambassador spawn guard: one ambassador per federation peer
+    if (config.role === 'ambassador') {
+      const peerId = config.peerId || config.metadata?.peerId;
+      if (!peerId) throw new Error('Ambassador agents require a peerId');
+      if (this.daemon.federation?.ambassadors?.hasAmbassadorForPeer(peerId)) {
+        throw new Error(`Ambassador already exists for peer ${peerId}`);
+      }
+    }
+
     // Clean stale recommended-team.json when spawning a new planner
     if (config.role === 'planner') {
       const dirs = [this.daemon.grooveDir];
@@ -350,6 +371,15 @@ export class ProcessManager {
       locks.register(agent.id, agent.scope);
     }
 
+    // Register ambassador with federation system
+    if (config.role === 'ambassador') {
+      const peerId = config.peerId || config.metadata?.peerId;
+      if (peerId && this.daemon.federation?.ambassadors) {
+        this.daemon.federation.ambassadors.registerAmbassador(peerId, agent.id);
+        registry.update(agent.id, { metadata: { ...agent.metadata, peerId } });
+      }
+    }
+
     // For slides-role agents, write the baked-in layout engine into the working
     // directory. The agent imports it as `./groove-slides.cjs`. Core layout rules
     // (Y-cursor, fitFontSize, collision/bounds/wrap gates) ship with Groove so
@@ -393,7 +423,7 @@ export class ProcessManager {
     }
 
     // Generate introduction context (team awareness + negotiation)
-    const introContext = introducer.generateContext(agent, { taskNegotiation });
+    const introContext = introducer.generateContext(agent, { taskNegotiation, hasTask: !!config.prompt });
 
     // Track cold-start savings — agent gets context from planner/journalist/team
     // instead of exploring the codebase from scratch
@@ -557,6 +587,7 @@ For normal file edits within your scope, proceed without review.
           const files = this.daemon.journalist?.getAgentFiles(agent) || [];
           if (files.length > 0) this._triggerIdleQC(agent);
           this._processHandoffs(agent);
+          this._writeCompletionHandoff(agent);
         }
       });
 
@@ -595,13 +626,14 @@ 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 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)
+    // Inject only the API key for the agent's own provider — least-privilege principle
+    // (avoids leaking unrelated credentials into agent environments)
     if (this.daemon.credentials) {
-      for (const cp of this.daemon.credentials.listProviders()) {
-        const meta = getProvider(cp.provider);
+      const agentProvider = agent.provider || config.provider;
+      if (agentProvider) {
+        const meta = getProvider(agentProvider);
         if (meta?.constructor?.envKey) {
-          const storedKey = this.daemon.credentials.getKey(cp.provider);
+          const storedKey = this.daemon.credentials.getKey(agentProvider);
           if (storedKey) {
             env[meta.constructor.envKey] = storedKey;
           }
@@ -700,6 +732,12 @@ For normal file edits within your scope, proceed without review.
         this.daemon.integrations.refreshMcpJson();
       }
 
+      // Extract recommended-team.json from planner text output if it wasn't written to disk.
+      // Non-Claude providers (Codex, Gemini) may embed the JSON in text rather than using Write.
+      if (finalStatus === 'completed' && agent.role === 'planner') {
+        this._extractRecommendedTeam(agent, logPath);
+      }
+
       // Trigger journalist synthesis immediately on completion so the project
       // map is fresh for the next agent that spawns (don't wait for 120s cycle)
       if (finalStatus === 'completed' && this.daemon.journalist) {
@@ -714,8 +752,8 @@ For normal file edits within your scope, proceed without review.
       if (finalStatus === 'completed') {
         const files = this.daemon.journalist?.getAgentFiles(agent) || [];
         if (files.length > 0) this._triggerIdleQC(agent);
-        // Process cross-scope handoff requests from this agent
         this._processHandoffs(agent);
+        this._writeCompletionHandoff(agent);
       }
 
       // Update Layer 7 specialization profile for this agent's session
@@ -783,8 +821,12 @@ For normal file edits within your scope, proceed without review.
 
     for (const line of complete.split('\n')) {
       if (!line) continue;
-      const output = provider.parseOutput(line);
-      if (output) this._handleAgentOutput(agentId, output);
+      try {
+        const output = provider.parseOutput(line);
+        if (output) this._handleAgentOutput(agentId, output);
+      } catch (err) {
+        console.error(`[Groove] parseOutput error for ${agentId}: ${err.message}`);
+      }
     }
   }
 
@@ -849,6 +891,27 @@ For normal file edits within your scope, proceed without review.
     this.daemon.broadcast({ type: 'agent:output', agentId, data: output });
   }
 
+  _extractRecommendedTeam(agent, logPath) {
+    try {
+      const workDir = agent.workingDir || this.daemon.projectDir;
+      const grooveDir = resolve(workDir, '.groove');
+      const targetPath = resolve(grooveDir, 'recommended-team.json');
+
+      if (existsSync(targetPath)) return;
+
+      const log = readFileSync(logPath, 'utf8');
+      const match = log.match(/\{[\s\S]*?"agents"\s*:\s*\[[\s\S]*?\]\s*\}/);
+      if (!match) return;
+
+      let parsed;
+      try { parsed = JSON.parse(match[0]); } catch { return; }
+      if (!parsed || !Array.isArray(parsed.agents) || parsed.agents.length === 0) return;
+
+      if (!existsSync(grooveDir)) mkdirSync(grooveDir, { recursive: true });
+      writeFileSync(targetPath, JSON.stringify(parsed, null, 2));
+    } catch { /* best effort */ }
+  }
+
   /**
    * 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.
@@ -993,6 +1056,46 @@ For normal file edits within your scope, proceed without review.
     });
   }
 
+  _writeCompletionHandoff(agent) {
+    if (!this.daemon.memory || !this.daemon.journalist) return;
+    try {
+      const agentData = this.daemon.registry.get(agent.id);
+      const filteredLogs = this.daemon.journalist.collectFilteredLogs([agent]);
+      const agentLog = filteredLogs[agent.id];
+      const entries = agentLog?.entries || [];
+      const files = this.daemon.journalist.getAgentFiles(agent) || [];
+
+      const toolSummary = entries
+        .filter(e => e.type === 'tool')
+        .map(e => `- ${e.tool}: ${e.input}`)
+        .slice(-15)
+        .join('\n');
+
+      const errorSummary = entries
+        .filter(e => e.type === 'error')
+        .map(e => `- ${e.text}`)
+        .slice(-5)
+        .join('\n');
+
+      const brief = [
+        `Agent ${agent.name} (${agent.role}) completed.`,
+        agent.prompt ? `Task: ${agent.prompt.slice(0, 300)}` : '',
+        files.length > 0 ? `\nFiles modified:\n${files.slice(0, 15).map(f => '- ' + f).join('\n')}` : '',
+        toolSummary ? `\nRecent actions:\n${toolSummary}` : '',
+        errorSummary ? `\nErrors encountered:\n${errorSummary}` : '',
+      ].filter(Boolean).join('\n');
+
+      this.daemon.memory.appendHandoffBrief(agent.role, {
+        timestamp: new Date().toISOString(),
+        agentId: agent.id,
+        reason: 'completed',
+        oldTokens: agentData?.tokensUsed || 0,
+        contextUsage: agentData?.contextUsage || 0,
+        brief: brief.slice(0, 4000),
+      }, agent.workingDir);
+    } catch { /* best-effort */ }
+  }
+
   /**
    * Process handoff files in .groove/handoffs/.
    * Agents write handoff requests when they need cross-scope work from a teammate.
@@ -1002,6 +1105,9 @@ For normal file edits within your scope, proceed without review.
     const handoffsDir = resolve(this.daemon.grooveDir, 'handoffs');
     if (!existsSync(handoffsDir)) return;
 
+    const MAX_HANDOFFS_PER_ROLE = 3;
+    if (!this.daemon._handoffCounts) this.daemon._handoffCounts = new Map();
+
     const registry = this.daemon.registry;
     let files;
     try { files = readdirSync(handoffsDir); } catch { return; }
@@ -1011,6 +1117,14 @@ For normal file edits within your scope, proceed without review.
       const targetRole = file.replace(/\.md$/, '');
       const filePath = resolve(handoffsDir, file);
 
+      const roleKey = `${sourceAgent.teamId}:${targetRole}`;
+      const count = this.daemon._handoffCounts.get(roleKey) || 0;
+      if (count >= MAX_HANDOFFS_PER_ROLE) {
+        console.warn(`[Groove] Handoff to ${targetRole} skipped — cycle cap reached (${count}/${MAX_HANDOFFS_PER_ROLE})`);
+        try { unlinkSync(filePath); } catch {}
+        continue;
+      }
+
       let content;
       try { content = readFileSync(filePath, 'utf8').trim(); } catch { continue; }
       if (!content) { try { unlinkSync(filePath); } catch {} continue; }
@@ -1029,6 +1143,8 @@ For normal file edits within your scope, proceed without review.
         continue;
       }
 
+      this.daemon._handoffCounts.set(roleKey, count + 1);
+
       // Wake the target agent with the handoff request
       const message = `Cross-scope handoff from ${sourceAgent.name} (${sourceAgent.role}):\n\n${content}`;
       this.daemon.processes.resume(target.id, message).then((newAgent) => {
@@ -1072,13 +1188,12 @@ For normal file edits within your scope, proceed without review.
     const config = { ...agent };
     const sessionId = agent.sessionId;
 
-    // Kill if still running, or remove if dead
+    // Stop if running, then remove old entry so we can re-register with same name
     if (this.handles.has(agentId)) {
       await this.kill(agentId);
-    } else {
-      locks.release(agentId);
-      registry.remove(agentId);
     }
+    registry.remove(agentId);
+    locks.release(agentId);
 
     // Build resume command
     const { command, args, env } = provider.buildResumeCommand(sessionId, message, config.model);
@@ -1199,11 +1314,19 @@ For normal file edits within your scope, proceed without review.
 
   async kill(agentId) {
     this.peakContextUsage.delete(agentId);
+
+    // Unregister ambassador if this agent was one
+    const agent = this.daemon.registry.get(agentId);
+    if (agent?.role === 'ambassador' && agent?.metadata?.peerId) {
+      this.daemon.federation?.ambassadors?.unregisterAmbassador(agent.metadata.peerId);
+    }
+
     const handle = this.handles.get(agentId);
 
     if (!handle) {
-      // Not running — just clean up registry
-      this.daemon.registry.remove(agentId);
+      // Not running — release locks but keep agent in registry.
+      // Spawn's exit handler already set the terminal status.
+      // Callers that want removal must call registry.remove() explicitly.
       this.daemon.locks.release(agentId);
       return;
     }
@@ -1213,24 +1336,19 @@ For normal file edits within your scope, proceed without review.
     // 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);
+      // Loop exit handler already updated status and cleaned handles
       this.daemon.locks.release(agentId);
       return;
     }
 
-    // CLI process path
+    // CLI process path — spawn's exit handler sets status='killed' for SIGTERM
     return new Promise((resolveKill) => {
-      // Give the process 5s to exit gracefully
       const forceTimer = setTimeout(() => {
         try { proc.kill('SIGKILL'); } catch {}
       }, 5000);
 
       proc.on('exit', () => {
         clearTimeout(forceTimer);
-        this.handles.delete(agentId);
-        this.daemon.registry.remove(agentId);
         this.daemon.locks.release(agentId);
         resolveKill();
       });
@@ -1241,7 +1359,6 @@ For normal file edits within your scope, proceed without review.
         // Already dead
         clearTimeout(forceTimer);
         this.handles.delete(agentId);
-        this.daemon.registry.remove(agentId);
         this.daemon.locks.release(agentId);
         resolveKill();
       }

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

@@ -6,6 +6,7 @@ export class Provider {
   static displayName = 'Base Provider';
   static command = '';
   static authType = 'none'; // 'subscription' | 'api-key' | 'local' | 'none'
+  static managesOwnContext = false; // true if provider compacts context internally (e.g. Claude Code)
   static models = [];
 
   static isInstalled() {

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

@@ -11,6 +11,7 @@ export class ClaudeCodeProvider extends Provider {
   static displayName = 'Claude Code';
   static command = 'claude';
   static authType = 'subscription';
+  static managesOwnContext = true; // Claude Code compacts context internally (~25-37% → 2-8%)
   static models = [
     { id: 'claude-opus-4-6', name: 'Claude Opus 4.6', tier: 'heavy', contextWindow: 1_000_000 },
     { id: 'claude-sonnet-4-6', name: 'Claude Sonnet 4.6', tier: 'medium', contextWindow: 200_000 },

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

@@ -16,12 +16,12 @@ export class CodexProvider extends Provider {
   // 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 } },
-    { id: 'gpt-5.4-mini', name: 'GPT-5.4 Mini', tier: 'medium', pricing: { input: 0.001, output: 0.004 } },
-    { id: 'gpt-5.4-nano', name: 'GPT-5.4 Nano', tier: 'light', pricing: { input: 0.0004, output: 0.0016 } },
-    { id: 'gpt-5-mini', name: 'GPT-5 Mini', tier: 'medium', pricing: { input: 0.0005, output: 0.002 } },
-    { id: 'gpt-5-nano', name: 'GPT-5 Nano', tier: 'light', pricing: { input: 0.0001, output: 0.0004 } },
+    { id: 'gpt-5.4-pro', name: 'GPT-5.4 Pro', tier: 'heavy', maxContext: 200000, pricing: { input: 0.015, output: 0.06 } },
+    { id: 'gpt-5.4', name: 'GPT-5.4', tier: 'heavy', maxContext: 200000, pricing: { input: 0.005, output: 0.02 } },
+    { id: 'gpt-5.4-mini', name: 'GPT-5.4 Mini', tier: 'medium', maxContext: 200000, pricing: { input: 0.001, output: 0.004 } },
+    { id: 'gpt-5.4-nano', name: 'GPT-5.4 Nano', tier: 'light', maxContext: 200000, pricing: { input: 0.0004, output: 0.0016 } },
+    { id: 'gpt-5-mini', name: 'GPT-5 Mini', tier: 'medium', maxContext: 200000, pricing: { input: 0.0005, output: 0.002 } },
+    { id: 'gpt-5-nano', name: 'GPT-5 Nano', tier: 'light', maxContext: 200000, pricing: { input: 0.0001, output: 0.0004 } },
   ];
 
   static isInstalled() {
@@ -83,16 +83,19 @@ export class CodexProvider extends Provider {
   }
 
   buildSpawnCommand(agent) {
-    // Use 'codex exec' for non-interactive (headless) operation
     const args = ['exec'];
 
     if (agent.model) args.push('--model', agent.model);
 
-    // Full autonomous operation — no approval prompts, no sandbox
+    args.push('--json');
     args.push('--dangerously-bypass-approvals-and-sandbox');
 
+    if (agent.workingDir) args.push('-C', agent.workingDir);
+
     if (agent.prompt) args.push(agent.prompt);
 
+    this._currentModel = agent.model;
+
     return {
       command: 'codex',
       args,
@@ -101,7 +104,7 @@ export class CodexProvider extends Provider {
   }
 
   buildHeadlessCommand(prompt, model) {
-    const args = ['exec', prompt];
+    const args = ['exec', '--json', prompt];
     if (model) args.push('--model', model);
     return { command: 'codex', args, env: {} };
   }
@@ -120,33 +123,126 @@ export class CodexProvider extends Provider {
   }
 
   parseOutput(line) {
-    // Codex outputs plain text and stderr logging
     const trimmed = line.trim();
     if (!trimmed) return null;
 
-    // Try to parse JSON (codex may output structured data in some modes)
+    let event;
     try {
-      const data = JSON.parse(trimmed);
-      if (data.usage?.total_tokens) {
-        const tokens = data.usage.total_tokens;
+      event = JSON.parse(trimmed);
+    } catch {
+      return { type: 'activity', data: trimmed };
+    }
+
+    switch (event.type) {
+      case 'thread.started':
+        return { type: 'activity', subtype: 'assistant', sessionId: event.thread_id, data: [{ type: 'text', text: '' }] };
+
+      case 'turn.started':
+        return null;
+
+      case 'item.started': {
+        const item = event.item || {};
+        if (item.type === 'command_execution') {
+          return {
+            type: 'activity', subtype: 'assistant',
+            data: [{ type: 'tool_use', id: item.id || 'exec', name: 'Bash', input: { command: item.command } }],
+          };
+        }
+        if (item.type === 'todo_list') {
+          const steps = (item.items || []).map((s) => s.text).join(', ');
+          return {
+            type: 'activity', subtype: 'assistant',
+            data: [{ type: 'tool_use', id: item.id || 'plan', name: 'Plan', input: { steps } }],
+          };
+        }
+        if (item.type === 'file_edit' || item.type === 'file_write') {
+          return {
+            type: 'activity', subtype: 'assistant',
+            data: [{ type: 'tool_use', id: item.id || 'edit', name: item.type === 'file_write' ? 'Write' : 'Edit', input: { path: item.path || item.file || '' } }],
+          };
+        }
+        if (item.type === 'file_read') {
+          return {
+            type: 'activity', subtype: 'assistant',
+            data: [{ type: 'tool_use', id: item.id || 'read', name: 'Read', input: { path: item.path || item.file || '' } }],
+          };
+        }
         return {
-          type: 'activity', data: trimmed, tokensUsed: tokens,
-          estimatedCostUsd: CodexProvider.estimateCost(tokens, data.model),
-          costSource: 'estimated',
+          type: 'activity', subtype: 'assistant',
+          data: [{ type: 'tool_use', id: item.id || 'tool', name: item.type || 'Tool', input: {} }],
         };
       }
-    } catch { /* plain text */ }
 
-    // Estimate tokens from text length (~4 chars per token)
-    // Not perfect but gives visibility into activity and burn rate
-    const estimatedTokens = Math.ceil(trimmed.length / 4);
+      case 'item.completed': {
+        const item = event.item || {};
+        if (item.type === 'agent_message') {
+          return {
+            type: 'activity', subtype: 'assistant',
+            data: [{ type: 'text', text: item.text || '' }],
+          };
+        }
+        if (item.type === 'command_execution') {
+          const output = (item.aggregated_output || '').slice(0, 2000);
+          return {
+            type: 'activity', subtype: 'assistant',
+            data: [
+              { type: 'tool_use', id: item.id || 'exec', name: 'Bash', input: { command: item.command } },
+              ...(output ? [{ type: 'text', text: output }] : []),
+            ],
+          };
+        }
+        if (item.type === 'todo_list') {
+          const steps = (item.items || []).map((s) => `${s.completed ? '✓' : '○'} ${s.text}`).join('\n');
+          return {
+            type: 'activity', subtype: 'assistant',
+            data: [{ type: 'text', text: steps }],
+          };
+        }
+        if (item.type === 'file_edit' || item.type === 'file_write' || item.type === 'file_read') {
+          return {
+            type: 'activity', subtype: 'assistant',
+            data: [{ type: 'tool_use', id: item.id || 'file', name: item.type === 'file_read' ? 'Read' : item.type === 'file_write' ? 'Write' : 'Edit', input: { path: item.path || item.file || '' } }],
+          };
+        }
+        return null;
+      }
 
-    return {
-      type: 'activity',
-      data: trimmed,
-      tokensUsed: estimatedTokens,
-      estimatedCostUsd: 0, // Can't estimate without knowing the model here
-      costSource: 'estimated',
-    };
+      case 'turn.completed': {
+        const usage = event.usage;
+        if (!usage) return null;
+
+        const inputTokens = usage.input_tokens || 0;
+        const outputTokens = usage.output_tokens || 0;
+        const cachedTokens = usage.cached_input_tokens || 0;
+        const totalTokens = inputTokens + outputTokens;
+
+        const model = CodexProvider.models.find((m) => m.id === this._currentModel);
+        const pricing = model?.pricing;
+        const maxContext = model?.maxContext || 200000;
+
+        let estimatedCostUsd = 0;
+        if (pricing) {
+          const newInput = inputTokens - cachedTokens;
+          estimatedCostUsd = (newInput / 1000) * pricing.input
+            + (cachedTokens / 1000) * pricing.input * 0.5
+            + (outputTokens / 1000) * pricing.output;
+        }
+
+        return {
+          type: 'activity', subtype: 'assistant',
+          data: [{ type: 'text', text: '' }],
+          tokensUsed: totalTokens,
+          inputTokens,
+          outputTokens,
+          cacheReadTokens: cachedTokens,
+          contextUsage: inputTokens / maxContext,
+          estimatedCostUsd,
+          costSource: pricing ? 'calculated' : 'estimated',
+        };
+      }
+
+      default:
+        return null;
+    }
   }
 }

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

@@ -11,11 +11,11 @@ export class GeminiProvider extends Provider {
   static authType = 'api-key';
   static envKey = 'GEMINI_API_KEY';
   static models = [
-    { id: 'gemini-3.1-pro-preview', name: 'Gemini 3.1 Pro', tier: 'heavy', pricing: { input: 0.00125, output: 0.01 } },
-    { id: 'gemini-3-flash-preview', name: 'Gemini 3 Flash', tier: 'medium', pricing: { input: 0.00015, output: 0.0006 } },
-    { id: 'gemini-3.1-flash-lite-preview', name: 'Gemini 3.1 Flash Lite', tier: 'light', pricing: { input: 0.000075, output: 0.0003 } },
-    { id: 'gemini-2.5-pro', name: 'Gemini 2.5 Pro', tier: 'heavy', pricing: { input: 0.00125, output: 0.01 } },
-    { id: 'gemini-2.5-flash', name: 'Gemini 2.5 Flash', tier: 'medium', pricing: { input: 0.00015, output: 0.0006 } },
+    { id: 'gemini-3.1-pro-preview', name: 'Gemini 3.1 Pro', tier: 'heavy', maxContext: 1000000, pricing: { input: 0.00125, output: 0.01 } },
+    { id: 'gemini-3-flash-preview', name: 'Gemini 3 Flash', tier: 'medium', maxContext: 1000000, pricing: { input: 0.00015, output: 0.0006 } },
+    { id: 'gemini-3.1-flash-lite-preview', name: 'Gemini 3.1 Flash Lite', tier: 'light', maxContext: 1000000, pricing: { input: 0.000075, output: 0.0003 } },
+    { id: 'gemini-2.5-pro', name: 'Gemini 2.5 Pro', tier: 'heavy', maxContext: 1000000, pricing: { input: 0.00125, output: 0.01 } },
+    { id: 'gemini-2.5-flash', name: 'Gemini 2.5 Flash', tier: 'medium', maxContext: 1000000, pricing: { input: 0.00015, output: 0.0006 } },
   ];
 
   static isInstalled() {
@@ -36,12 +36,12 @@ export class GeminiProvider extends Provider {
 
     if (agent.model) args.push('--model', agent.model);
 
-    // YOLO mode — auto-approve all tool calls (file writes, shell commands)
-    // Without this, Gemini in headless mode can only output text
     args.push('--yolo');
+    args.push('--output-format', 'stream-json');
+    args.push('-p', '');
+
+    this._currentModel = agent.model;
 
-    // Pass prompt via stdin to avoid OS arg length limits
-    // (intro context + role prompt + skill content can be very long)
     return {
       command: 'gemini',
       args,
@@ -51,7 +51,7 @@ export class GeminiProvider extends Provider {
   }
 
   buildHeadlessCommand(prompt, model) {
-    const args = ['-p', prompt];
+    const args = ['--output-format', 'stream-json', '-p', prompt];
     if (model) args.push('--model', model);
     return { command: 'gemini', args, env: {} };
   }
@@ -71,12 +71,99 @@ export class GeminiProvider extends Provider {
   parseOutput(line) {
     const trimmed = line.trim();
     if (!trimmed) return null;
-    // Estimate tokens from output length (~4 chars per token)
-    const estimatedTokens = Math.ceil(trimmed.length / 4);
-    return {
-      type: 'activity', data: trimmed, tokensUsed: estimatedTokens,
-      estimatedCostUsd: 0,
-      costSource: 'estimated',
-    };
+
+    let event;
+    try {
+      event = JSON.parse(trimmed);
+    } catch {
+      return { type: 'activity', data: trimmed };
+    }
+
+    switch (event.type) {
+      case 'agent_start':
+        return { type: 'activity', subtype: 'assistant', sessionId: event.streamId, data: [{ type: 'text', text: '' }] };
+
+      case 'session_update':
+        return null;
+
+      case 'message': {
+        if (event.role === 'user') return null;
+        const raw = event.content;
+        const parts = Array.isArray(raw) ? raw : (typeof raw === 'string' ? [{ text: raw }] : raw ? [raw] : []);
+        const blocks = parts.map((p) => {
+          if (p.type === 'thought') return { type: 'text', text: p.thought || '' };
+          return { type: 'text', text: p.text || '' };
+        }).filter((b) => b.text);
+        if (!blocks.length) return null;
+        return { type: 'activity', subtype: 'assistant', data: blocks };
+      }
+
+      case 'tool_request': {
+        const toolName = (event.name || '').includes('shell') || (event.name || '').includes('exec')
+          ? 'Bash' : event.name || 'Tool';
+        const input = event.name === 'Bash' || (event.name || '').includes('shell')
+          ? { command: typeof event.args === 'string' ? event.args : JSON.stringify(event.args || {}) }
+          : (event.args || {});
+        return {
+          type: 'activity', subtype: 'assistant',
+          data: [{ type: 'tool_use', id: event.requestId || 'tool', name: toolName, input }],
+        };
+      }
+
+      case 'tool_response': {
+        const rawContent = event.content;
+        const contentParts = Array.isArray(rawContent) ? rawContent : (typeof rawContent === 'string' ? [{ text: rawContent }] : rawContent ? [rawContent] : []);
+        const content = contentParts.map((p) => p.text || '').join('').slice(0, 2000);
+        const toolName = (event.name || '').includes('shell') || (event.name || '').includes('exec')
+          ? 'Bash' : event.name || 'Tool';
+        return {
+          type: 'activity', subtype: 'assistant',
+          data: [
+            { type: 'tool_use', id: event.requestId || 'tool', name: toolName, input: {} },
+            ...(content ? [{ type: 'text', text: content }] : []),
+          ],
+        };
+      }
+
+      case 'usage': {
+        const inputTokens = event.inputTokens || 0;
+        const outputTokens = event.outputTokens || 0;
+        const cachedTokens = event.cachedTokens || 0;
+        const totalTokens = inputTokens + outputTokens;
+
+        const model = GeminiProvider.models.find((m) => m.id === this._currentModel);
+        const pricing = model?.pricing;
+        const maxContext = model?.maxContext || 1000000;
+
+        let estimatedCostUsd = 0;
+        if (pricing) {
+          const newInput = inputTokens - cachedTokens;
+          estimatedCostUsd = (newInput / 1000) * pricing.input
+            + (cachedTokens / 1000) * pricing.input * 0.5
+            + (outputTokens / 1000) * pricing.output;
+        }
+
+        return {
+          type: 'activity', subtype: 'assistant',
+          data: [{ type: 'text', text: '' }],
+          tokensUsed: totalTokens,
+          inputTokens,
+          outputTokens,
+          cacheReadTokens: cachedTokens,
+          contextUsage: inputTokens / maxContext,
+          estimatedCostUsd,
+          costSource: pricing ? 'calculated' : 'estimated',
+        };
+      }
+
+      case 'agent_end':
+        return { type: 'activity', subtype: 'assistant', data: [{ type: 'text', text: '' }] };
+
+      case 'error':
+        return { type: 'activity', subtype: 'assistant', data: [{ type: 'text', text: `Error: ${event.message || 'unknown'}` }] };
+
+      default:
+        return null;
+    }
   }
 }