groove-dev 0.27.26 → 0.27.28

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

@@ -95,6 +95,7 @@ export class CodexProvider extends Provider {
     if (agent.prompt) args.push(agent.prompt);
 
     this._currentModel = agent.model;
+    this._sessionInputTokens = 0;
 
     return {
       command: 'codex',
@@ -109,6 +110,11 @@ export class CodexProvider extends Provider {
     return { command: 'codex', args, env: {} };
   }
 
+  _getMaxContext() {
+    const model = CodexProvider.models.find((m) => m.id === this._currentModel);
+    return model?.maxContext || 200000;
+  }
+
   switchModel(agent, newModel) {
     return false; // Codex doesn't support mid-session model switch
   }
@@ -175,36 +181,48 @@ export class CodexProvider extends Provider {
 
       case 'item.completed': {
         const item = event.item || {};
+
+        // Accumulate usage for intermediate context estimation.
+        // Codex only reports full contextUsage at turn.completed — without this,
+        // the rotator sees stale contextUsage between turns and never triggers.
+        if (event.usage) {
+          this._sessionInputTokens += event.usage.input_tokens || 0;
+        }
+
+        let result = null;
         if (item.type === 'agent_message') {
-          return {
+          result = {
             type: 'activity', subtype: 'assistant',
             data: [{ type: 'text', text: item.text || '' }],
           };
-        }
-        if (item.type === 'command_execution') {
+        } else if (item.type === 'command_execution') {
           const output = (item.aggregated_output || '').slice(0, 2000);
-          return {
+          result = {
             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') {
+        } else if (item.type === 'todo_list') {
           const steps = (item.items || []).map((s) => `${s.completed ? '✓' : '○'} ${s.text}`).join('\n');
-          return {
+          result = {
             type: 'activity', subtype: 'assistant',
             data: [{ type: 'text', text: steps }],
           };
-        }
-        if (item.type === 'file_edit' || item.type === 'file_write' || item.type === 'file_read') {
-          return {
+        } else if (item.type === 'file_edit' || item.type === 'file_write' || item.type === 'file_read') {
+          result = {
             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;
+
+        // Attach intermediate context estimate so all 7 layers see Codex progress
+        if (result && this._sessionInputTokens > 0) {
+          result.contextUsage = this._sessionInputTokens / this._getMaxContext();
+        }
+
+        return result;
       }
 
       case 'turn.completed': {
@@ -215,11 +233,15 @@ export class CodexProvider extends Provider {
         const outputTokens = usage.output_tokens || 0;
         const cachedTokens = usage.cached_input_tokens || 0;
         const totalTokens = inputTokens + outputTokens;
+        const cacheCreationTokens = cachedTokens > 0 ? Math.max(0, inputTokens - cachedTokens) : 0;
 
         const model = CodexProvider.models.find((m) => m.id === this._currentModel);
         const pricing = model?.pricing;
         const maxContext = model?.maxContext || 200000;
 
+        // Sync accumulator to actual cumulative value from turn completion
+        this._sessionInputTokens = inputTokens;
+
         let estimatedCostUsd = 0;
         if (pricing) {
           const newInput = inputTokens - cachedTokens;
@@ -235,6 +257,7 @@ export class CodexProvider extends Provider {
           inputTokens,
           outputTokens,
           cacheReadTokens: cachedTokens,
+          cacheCreationTokens,
           contextUsage: inputTokens / maxContext,
           estimatedCostUsd,
           costSource: pricing ? 'calculated' : 'estimated',

package/packages/daemon/src/rotator.js

@@ -31,6 +31,7 @@ export class Rotator extends EventEmitter {
     this.rotationHistory = [];
     this.rotating = new Set();
     this.lastRotationTime = new Map(); // agentId -> timestamp of last rotation
+    this._lastContextState = new Map(); // agentId -> { contextUsage, timestamp }
     this.enabled = false;
     this.liveScores = {};
     this.scoreHistory = {};
@@ -180,6 +181,25 @@ export class Rotator extends EventEmitter {
           continue;
         }
 
+        // Stale context fallback — safety net for providers (like Codex) that don't
+        // report intermediate contextUsage. If contextUsage hasn't changed in 120+
+        // seconds but tokens are being consumed, estimate from total tokens.
+        const knownCtx = this._lastContextState.get(agent.id);
+        if (!knownCtx || knownCtx.contextUsage !== agent.contextUsage) {
+          this._lastContextState.set(agent.id, { contextUsage: agent.contextUsage, timestamp: Date.now() });
+        } else if (agent.tokensUsed > 0 && (Date.now() - knownCtx.timestamp) >= 120_000) {
+          const providerClass = getProvider(agent.provider)?.constructor;
+          const models = providerClass?.models || [];
+          const model = models.find((m) => m.id === agent.model) || models[0];
+          const maxContext = model?.maxContext || 200000;
+          const estimatedContext = agent.tokensUsed / maxContext;
+          if (estimatedContext >= HARD_CEILING) {
+            console.log(`  Rotator: ${agent.name} estimated context ${Math.round(estimatedContext * 100)}% (stale contextUsage fallback)`);
+            await this.rotate(agent.id, { reason: 'estimated_context_ceiling' });
+            continue;
+          }
+        }
+
         // Cooldown — skip threshold/quality rotation if recently rotated
         if (this._isOnCooldown(agent.id)) continue;
 
@@ -274,7 +294,7 @@ export class Rotator extends EventEmitter {
           oldTokens: agent.tokensUsed,
           contextUsage: agent.contextUsage,
           brief: brief.slice(0, 4000),
-        }, agent.workingDir);
+        }, agent.workingDir, agent.teamId);
       }
 
       const record = {
@@ -312,6 +332,7 @@ export class Rotator extends EventEmitter {
           workingDir: agent.workingDir,
           name: agent.name,
           teamId: agent.teamId,
+          isRotation: true,
         });
       } catch (spawnErr) {
         // Spawn failed — re-add old agent so the user can see and retry.
@@ -499,6 +520,7 @@ export class Rotator extends EventEmitter {
     const naturalCompactions = this.rotationHistory.filter((r) => r.reason === 'natural_compaction').length;
     const hardCeilingRotations = this.rotationHistory.filter((r) => r.reason === 'hard_ceiling').length;
     const tokenCeilingRotations = this.rotationHistory.filter((r) => r.reason === 'token_ceiling').length;
+    const estimatedCeilingRotations = this.rotationHistory.filter((r) => r.reason === 'estimated_context_ceiling').length;
     return {
       enabled: this.enabled,
       totalRotations,
@@ -508,6 +530,7 @@ export class Rotator extends EventEmitter {
       naturalCompactions,
       hardCeilingRotations,
       tokenCeilingRotations,
+      estimatedCeilingRotations,
       rotating: Array.from(this.rotating),
       liveScores: this.liveScores,
       scoreHistory: this.scoreHistory,