groove-dev 0.27.26 → 0.27.27

package/packages/daemon/src/process.js

@@ -427,12 +427,18 @@ export class ProcessManager {
       taskNegotiation = await this.negotiateTaskSplit(agent, sameRole);
     }
 
-    // Generate introduction context (team awareness + negotiation)
-    // Always pass hasTask: true so Layer 7 discoveries and handoff history
-    // are injected for ALL agents, not just those with explicit prompts.
-    // Without this, first-generation agents spawned with just a role never
-    // receive prior discoveries and repeat mistakes Layer 7 already captured.
-    const introContext = introducer.generateContext(agent, { taskNegotiation, hasTask: true });
+    // Compute hasTask from actual prompt content — agents spawned without a
+    // prompt should NOT receive handoff history (prevents cross-team contamination).
+    // Discoveries + constraints are always injected (project knowledge).
+    // Handoffs are injected only when the agent has a real task or is a rotation.
+    const hasTask = !!(config.prompt && config.prompt.trim().length > 0);
+    const isRotation = !!(config.isRotation);
+    const introContext = introducer.generateContext(agent, { taskNegotiation, hasTask, isRotation });
+
+    // Ensure the project map is fresh before the new agent reads CLAUDE.md
+    if (this.daemon.journalist) {
+      await this.daemon.journalist.ensureFresh(30000);
+    }
 
     // Track cold-start savings — agent gets context from planner/journalist/team
     // instead of exploring the codebase from scratch
@@ -597,7 +603,7 @@ For normal file edits within your scope, proceed without review.
 
         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(() => {});
+        if (status === 'completed' && this.daemon.journalist) this.daemon.journalist.requestSynthesis('completion');
         this._checkPhase2(agent.id);
 
         // Auto-trigger idle QC + process cross-scope handoffs
@@ -783,10 +789,9 @@ For normal file edits within your scope, proceed without review.
         }
       }
 
-      // Trigger journalist synthesis immediately on completion so the project
-      // map is fresh for the next agent that spawns (don't wait for 120s cycle)
+      // Trigger journalist synthesis on completion (event-driven, debounced)
       if (finalStatus === 'completed' && this.daemon.journalist) {
-        this.daemon.journalist.cycle().catch(() => {});
+        this.daemon.journalist.requestSynthesis('completion');
       }
 
       // Phase 2 auto-spawn: check if all phase 1 agents for a team are done
@@ -1168,7 +1173,7 @@ For normal file edits within your scope, proceed without review.
         oldTokens: agentData?.tokensUsed || 0,
         contextUsage: agentData?.contextUsage || 0,
         brief: brief.slice(0, 4000),
-      }, agent.workingDir);
+      }, agent.workingDir, agent.teamId);
     } catch { /* best-effort */ }
   }
 
@@ -1369,7 +1374,7 @@ For normal file edits within your scope, proceed without review.
       registry.update(newAgent.id, { status: finalStatus, pid: null });
       this.daemon.broadcast({ type: 'agent:exit', agentId: newAgent.id, code, signal, status: finalStatus });
       if (finalStatus === 'completed' && this.daemon.journalist) {
-        this.daemon.journalist.cycle().catch(() => {});
+        this.daemon.journalist.requestSynthesis('completion');
       }
     });
 

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,

package/packages/gui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/gui",
-  "version": "0.27.26",
+  "version": "0.27.27",
   "description": "GROOVE GUI — visual agent control plane",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",

package/MUST_FIX_ISSUES.md

@@ -1,305 +0,0 @@
-LAYER 1: ELECTRON SHELL (packages/desktop/main.js) ----------------------------------------------------
-
-The desktop app itself creates memory pressure before any agent work begins:
-
-CRITICAL - Daemon heap capped at 512MB (line 178) The daemon process managing ALL agents, the GUI server, WebSocket broadcasts, journalist synthesis, token tracking, and state persistence gets only 512MB. When GC hits this ceiling, the event loop blocks for 100-300ms. The Electron app freezes waiting for daemon responses. This is why button clicks take 5s to register.
-
-CRITICAL - Listener accumulation on window reuse (lines 862-914) When reopening a project, the home window is reused. Lines 872-873 remove close/closed listeners, but console-message, render-process-gone, and permission handlers are re-registered without removing the old ones. Each reuse adds duplicate listeners. N window reuses = N duplicate handlers firing per event.
-
-CRITICAL - IPC broadcast flooding (process.js lines 926-950) Every agent output is broadcast to all Electron windows. Throttled to 4/sec per agent, but with 4+ agents that's 16+ JSON serializations per second over IPC with no backpressure. The renderer can't keep up, and the IPC message queue grows unbounded in the main process.
-
-HIGH - Subscription polling on every window focus (lines 301, 886) Every time you click the Electron window, it triggers a subscription check to the daemon. With multiple windows, this creates constant HTTP traffic even when idle.
-
-HIGH - stdout buffer string operations (process.js lines 844-854) Per-agent stdout buffer grows to 1MB, then the "oldest half" is discarded via .indexOf() and .slice() on a multi-MB string. This runs on EVERY chunk. With streaming agents, it's constant multi-MB string allocations and GC pressure.
-
-LAYER 2: PROCESS MANAGER (packages/daemon/src/process.js) -----------------------------------------------------------
-
-HIGH - Stream throttle timers leak (lines 928-948) Each agent gets a throttle object in a Map. If agent crashes or is killed while a timer is pending, the callback still fires, broadcasting to a dead agent ID. The closure over output data never gets GC'd. Long sessions with many spawns = unbounded map growth.
-
-HIGH - Resume doesn't clean up maps (lines 1251-1367) When resuming a completed agent, peakContextUsage, pendingMessages, and _streamThrottle entries from the old agent ID are never cleared. These maps grow with every resume cycle.
-
-HIGH - Log stream file descriptor leaks (lines 545, 1284) Each spawn creates a write stream. On exit, logStream.end() is called but file descriptors aren't guaranteed released if I/O is slow. Resume creates new streams for the same agent. Long sessions accumulate hundreds of open .log file descriptors.
-
-LAYER 3: JOURNALIST (packages/daemon/src/journalist.js) ---------------------------------------------------------
-
-This is where "infinite sessions" should work. It doesn't fully deliver.
-
-CRITICAL - 40K char budget is actually 3-5K tokens (line 10) The comment says "~10k tokens budget" but 40,000 UTF-8 chars of chat-style logs is closer to 3-5K tokens. The synthesis prompt can only fit the last 20-30 agent events. In active sessions, 60-70% of recent activity is dropped from synthesis.
-
-CRITICAL - Exploration tools excluded from synthesis (lines 211-218) Read, Glob, and Grep events are filtered into a separate explorationEntries array and never included in the synthesis prompt. New agents don't know what files were examined. They re-explore the same files, wasting tokens.
-
-HIGH - Handoff brief is only 7K tokens total (lines 706-784) The brief pulls from 9 sources, each truncated:
-
--
-Errors: 10 entries x 300 chars = 3K chars
--
-Results: last 3 joined = 3K chars
--
-File changes: 20 files = 2K chars
--
-Discoveries: 10 entries = 2K chars
--
-Constraints: 2K chars
--
-User feedback: 5 x 500 = 2.5K chars
--
-Recent tools: 5 x 80 = 400 chars
--
-Rotation history: 3K chars
--
-Original task: 2K chars
-Total ~22K chars = ~7K tokens. The original agent had full context. The new agent gets a structured digest. Nuance, intermediate reasoning, and failed experiments are gone.
-
-HIGH - Only last 5 tool calls in rotation history (lines 755-760) A complex multi-file refactor needs 10-20 tool calls for context. Only the last 5 survive, each truncated to 80 chars. The handoff says "agent was editing files" but not "agent tried approach A, it failed because X, then tried B."
-
-MEDIUM - Synthesis cycle is 2 min, rotation check is 15 sec (lines 9, rotator.js:11) Rotations can happen 8x per synthesis cycle. Agent rotates at 0:15, journalist doesn't synthesize until 2:00. New agent has 1:45 of unsynthesized activity.
-
-LAYER 4: ROTATOR (packages/daemon/src/rotator.js) ---------------------------------------------------
-
-CRITICAL - 5-minute cooldown prevents fast recovery (line 16) After rotation, the new agent is locked in for 5 minutes regardless of quality. If the handoff was bad and the new agent is immediately degraded, nothing can be done until cooldown expires. Total degradation window: 8-10 minutes (3 min to detect + 5 min cooldown).
-
-HIGH - No post-rotation validation (lines 233-237) Pre-rotation session is scored and recorded. But there is NO measurement of post-rotation quality. System assumes rotation improved things without verifying. Could be making things worse.
-
-HIGH - Kill+respawn loses in-flight state (lines 278-301) Between kill and respawn: in-flight variables, cached results, classifier window, score history, and live quality tracking are all destroyed. New agent starts from the 7K-token brief only. This is a warm start, not zero cold start.
-
-HIGH - Idle check blocks quality rotation (lines 201-213) Quality rotation only fires if agent is idle 10+ seconds. If user is actively sending messages, an agent scoring 30/100 won't rotate because it's "busy." Planner agents producing bad plans while user reads output = degradation that the system ignores.
-
-MEDIUM - Handoff chain keeps only 10 rotations (memory.js line 18) At 5-minute rotations, 10 rotations = 50 minutes of history. Multi-hour tasks lose their full lineage. Agent #11 can't see what agent #1 learned.
-
-LAYER 5: ADAPTIVE THRESHOLDS (packages/daemon/src/adaptive.js) ----------------------------------------------------------------
-
-HIGH - Session scoring baseline is arbitrary (line 96) Score starts at 70. Errors cost 5 points each, repetitions cost 6. But these weights have no empirical calibration. A fatal error and a benign warning both cost 5 points. The scoring doesn't distinguish.
-
-HIGH - Asymmetric drift (+2%/-5%) (lines 8-9) Good sessions nudge threshold up slowly (+2%). Bad sessions yank it down fast (-5%). Over many sessions, thresholds oscillate unpredictably rather than converging.
-
-HIGH - Convergence detection is set but never read (lines 139-149) The profile.converged flag is computed and stored. The rotator never checks it. It's dead data.
-
-MEDIUM - No per-role quality thresholds (rotator.js line 12) QUALITY_THRESHOLD=40 applies to all roles. Planners naturally have higher error rates (exploring, revising). Backend agents on stable code have lower rates. Same threshold for both.
-
-LAYER 6: TOKEN TRACKER (packages/daemon/src/tokentracker.js) --------------------------------------------------------------
-
-HIGH - Planner token ceiling is 50M tokens (rotator.js lines 111-112) Role multiplier for planner is 10x the 5M base = 50M tokens. That's ~180K output tokens. Degradation happens long before 50M, but the safety ceiling never triggers. Planners can burn 50M tokens of garbage before forced rotation.
-
-MEDIUM - Cache hit rate is global, not per-agent (lines 205-216) If planner has 80% hit rate and fullstack has 20%, global rate is ~50%. Can't detect which agents benefit from caching.
-
-MEDIUM - Cold-start savings estimation is inflated (lines 8-14, 182-187) Per-file cost is flat (15 tokens). A 50-line config and a 10K-line monolith cost the same. Reported savings are overstated.
-
-MEDIUM - Journalist synthesis cost not tracked separately (lines 237-258) Internal overhead is tracked by __ prefix IDs, but journalist synthesis tokens may not be properly attributed.
-
-LAYER 7: MEMORY (packages/daemon/src/memory.js) -------------------------------------------------
-
-CRITICAL - Layer 7 skips first-generation agents (process.js line 431) Discoveries and handoff history are only injected when hasTask=true. hasTask = !!config.prompt. Agents spawned with just a role and no prompt never receive prior discoveries. They repeat mistakes that Layer 7 already captured.
-
-HIGH - Specializations recorded but never used (lines 310-389) Quality profiles per agent/role are stored. They are NEVER read for routing decisions. The router doesn't check "which agent specialization scores best for this file domain." It's write-only data.
-
-HIGH - Handoff briefs degrade over generations (lines 154-219) By rotation 5-10, the brief is summarizing summaries. Content degradation compounds. There's no quality scoring to flag "this was a clean rotation" vs "this was an emergency rotation."
-
-MEDIUM - No mid-session memory injection (introducer.js lines 345-381) Memory is injected once at spawn. If journalist discovers a critical fix during the agent's session, the running agent never learns it. Only the next rotated agent sees it.
-
-LAYER 8: ROUTER + CLASSIFIER (router.js, classifier.js) ---------------------------------------------------------
-
-CRITICAL - Classifier and Router are disconnected (entire design) Classifier produces tier classifications (light/medium/heavy). Router makes model decisions. But router.recommend() is called ONCE at spawn. Classifier broadcasts updates to UI only. There is NO feedback loop from classifier to router mid-session. An agent can drift from heavy to light work and stay on the expensive model for the entire session.
-
-HIGH - Default routing mode is FIXED, not AUTO (router.js line 73) Unless explicitly set, agents spawn in FIXED mode with no adaptive routing. Most agents never get auto-routing.
-
-HIGH - Cost tracking is dead code (router.js lines 125-136) recordUsage() is called, costLog accumulates data, but nothing reads the cost log. Cost data exists but never feeds back into routing decisions.
-
-MEDIUM - 200-event classifier window averages away trends (classifier.js line 39) If task complexity changes at event 190, classifier still averages across events 1-189. Recent changes are diluted.
-
-BACKBONE: API + REGISTRY + STATE (api.js, registry.js, state.js, timeline.js) -------------------------------------------------------------------------------
-
-HIGH - O(n^2) broadcast on every registry change (api.js line 224) Every agent spawn/update/remove triggers enrichAgents() on ALL agents, then broadcasts full state to ALL WebSocket clients. With 10 agents and frequent updates, this is expensive.
-
-HIGH - State saved every 30 seconds (index.js lines 518-521) If daemon crashes 29 seconds after an agent spawn, that agent is lost. State persistence should be 5s max for critical data.
-
-HIGH - Synchronous state write blocks event loop (state.js line 24) writeFileSync on every save. Blocks all other operations for the duration of the write.
-
-MEDIUM - Timeline caps at 16.7 hours (timeline.js lines 8-10) 2000 snapshots x 30s = 16.7 hours. After that, oldest snapshots are silently deleted. For multi-day sessions, early history is gone.
-
-MEDIUM - AGENTS_REGISTRY.md rewritten every 2 seconds (index.js lines 210-220) On every registry change, debounced to 2s. Also rewrites the GROOVE section of CLAUDE.md. Constant file I/O.
-
-THE DEGRADATION CASCADE -------------------------
-
-Here's what actually happens when a planner agent runs for 30+ minutes:
-
-T=0:00 - Agent spawns with role only, no prompt
-
--
-hasTask=false, so Layer 7 discoveries are SKIPPED
--
-Router defaults to FIXED mode, no auto-routing
--
-Agent starts blind to all prior learnings
-T=0:30 - Agent reads files, builds mental model
-
--
-Exploration events (Read, Glob, Grep) are filtered OUT of
-journalist synthesis
-
--
-Classifier window starts filling (200-event buffer)
-T=2:00 - First journalist synthesis cycle
-
--
-Only captures 3-5K tokens of activity (40K char budget)
--
-Exploration context excluded
-T=5:00 - Agent is productive but context window filling
-
--
-Quality score: 65 (decent but in dead zone 40-70)
--
-No rotation triggered (quality threshold is 40)
--
-No model downshift (classifier needs 40+ events)
--
-Adaptive threshold nudges up (+2%)
-T=10:00 - Context usage at 40-50%
-
--
-Agent slowing down, re-reading files
--
-Quality score drops to 55 (still in dead zone)
--
-Classifier broadcasts tier update to UI only
--
-Router does nothing (FIXED mode, no mid-session routing)
--
-Token velocity increasing but below 1.5M/5min spike
-T=15:00 - Quality score drops to 38 (below threshold!)
-
--
-But agent is "active" (user reading output), idle check fails
--
-Rotation blocked because agent isn't idle 10+ seconds
--
-Agent continues degrading
-T=18:00 - Agent finally idle, quality rotation fires
-
--
-40K char synthesis captures last 20-30 events
--
-Exploration context lost
--
-Handoff brief generated: 7K tokens
--
-Old agent killed, state destroyed
-T=18:30 - New agent spawns with brief
-
--
-Gets discoveries this time (hasTask=true from brief)
--
-But only last 10 discoveries, 4K chars
--
-Doesn't know what files previous agent explored
--
-Spends first 2-3 turns re-reading same files
--
-Cooldown: can't rotate for 5 minutes even if degraded
-T=20:00 - New agent productive but missing context
-
--
-Doesn't have previous agent's intermediate reasoning
--
-Doesn't know which approaches were tried and failed
--
-Quality score defaults to 70 (not enough data yet)
-T=30:00 - Second rotation
-
--
-Handoff brief now summarizes a summary
--
-3K chars of rotation history (3 briefs compressed)
--
-Context loss compounds
-This cycle repeats. Each rotation loses ~50-70% of useful context. By rotation 5 (roughly 90 minutes), the agent is working with heavily compressed summaries and repeating exploration the first agent already did.
-
-PRIORITY FIXES FOR TRUE INFINITE SESSIONS -------------------------------------------
-
-TIER 1 - IMMEDIATE (stop the bleeding)
-
-1.
-Increase daemon heap to 2048MB (main.js line 178)
-Change: --max-old-space-size=2048 Impact: Eliminates GC-induced freezes, fixes desktop lag
-
-1.
-Force Layer 7 injection regardless of hasTask (process.js line 431)
-Change: Always pass hasTask=true to generateContext, or remove the gate Impact: First-generation agents get prior discoveries immediately
-
-1.
-Include exploration events in synthesis (journalist.js lines 211-218)
-Change: Don't filter Read/Glob/Grep into separate array; include in main entries with lower priority Impact: New agents know what files were examined
-
-1.
-Lower planner token ceiling from 50M to 10M (rotator.js)
-Change: Reduce ROLE_MULTIPLIERS.planner from 10 to 2 Impact: Planners rotate before burning excessive tokens
-
-1.
-Clean up maps on agent removal (process.js)
-Change: Clear peakContextUsage, pendingMessages, _streamThrottle when registry.remove() is called Impact: Stops unbounded memory growth
-
-TIER 2 - HIGH PRIORITY (fix the feedback loops)
-
-1.
-Connect classifier to router mid-session
-Change: When classifier detects tier change, call router.recommend() and auto-apply if confidence is high Impact: Agents auto-downshift to cheaper models when task simplifies
-
-1.
-Reduce rotation cooldown from 5 min to 2 min for quality rotation
-Change: Separate QUALITY_COOLDOWN_MS = 2 * 60 * 1000 Impact: Degraded agents recover faster
-
-1.
-Remove idle check for severe degradation
-Change: If quality score < 25, rotate immediately regardless of idle Impact: Severely degraded agents don't persist
-
-1.
-Increase synthesis budget to 100K chars (~25K tokens)
-Change: MAX_LOG_CHARS = 100_000 Impact: Captures 80-90% of recent activity instead of 30-40%
-
-1.
-Add post-rotation validation
-Change: Compare first-10-events quality of new agent vs last-10 of old agent. If worse, flag as cold start. Impact: System knows when rotation helped vs hurt
-
-TIER 3 - MEDIUM PRIORITY (optimize the flow)
-
-1.
-Delta-only WebSocket broadcasts (api.js line 224)
-Change: Send only changed agent data, not full state Impact: Reduces IPC pressure by 80%+
-
-1.
-Use specializations for routing
-Change: When task involves files agent previously excelled at, prefer that agent Impact: Agents build on proven strengths
-
-1.
-Increase handoff chain from 10 to 25 rotations
-Change: MAX_HANDOFF_ROTATIONS = 25 Impact: 2+ hours of causal history preserved
-
-1.
-State save every 5 seconds instead of 30
-Change: setInterval at 5000 Impact: Max 5s of data loss on crash instead of 30
-
-1.
-Pre-compile minimatch patterns (lockmanager.js)
-Change: Use minimatch.makeRe() at registration, cache compiled Impact: O(n*m) regex compilation per check reduced to O(n) lookup
-
-1.
-Fix listener cleanup on window reuse (main.js)
-Change: Remove all webContents listeners before re-registering Impact: Stops listener accumulation, reduces memory pressure
-
-TIER 4 - ARCHITECTURAL (true infinite sessions)
-
-1.
-Implement incremental context patching at rotation
-Instead of regenerating full context from scratch, patch only what changed since last rotation
-
-1.
-Add mid-session memory injection
-When journalist discovers new fix, inject into running agent via instruct endpoint
-
-1.
-Implement per-role quality baselines
-Calibrate scoring weights and thresholds per role type
-
-1.
-Add degradation cascade detection
-Track if downstream agents inherit errors from upstream rotations