groove-dev 0.27.25 → 0.27.27

package/node_modules/@groove-dev/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/node_modules/@groove-dev/daemon/test/introducer.test.js

@@ -163,6 +163,69 @@ describe('Introducer', () => {
     });
   });
 
+  describe('hasTask gate — cross-team contamination fix', () => {
+    it('should NOT inject handoffs for agents spawned without a prompt', () => {
+      const grooveDir = join(tmpDir, '.groove');
+      mkdirSync(grooveDir, { recursive: true });
+      const memory = new MemoryStore(grooveDir);
+      memory.appendHandoffBrief('planner', {
+        brief: 'Old team planner work that should not leak',
+        reason: 'completed',
+      });
+      memory.addDiscovery({ role: 'planner', trigger: 'some error', fix: 'some fix', outcome: 'success' });
+      memory.addConstraint({ text: 'Always use ESM', category: 'pattern' });
+
+      const daemon = { registry, projectDir: tmpDir, grooveDir, memory };
+      const intro = new Introducer(daemon);
+
+      const agent = registry.add({ role: 'planner', scope: [] });
+      // hasTask=false, isRotation=false — simulates a fresh spawn with no prompt
+      const ctx = intro.generateContext(agent, { hasTask: false, isRotation: false });
+
+      // Constraints should ALWAYS be injected (project knowledge)
+      assert.ok(ctx.includes('Always use ESM'), 'constraints should always be injected');
+      // Handoffs and discoveries should NOT be injected
+      assert.ok(!ctx.includes('Old team planner work'), 'handoffs must not leak to promptless agents');
+      assert.ok(!ctx.includes('Known Fixes'), 'discoveries must not be injected for promptless agents');
+    });
+
+    it('should inject handoffs for agents spawned WITH a prompt (hasTask=true)', () => {
+      const grooveDir = join(tmpDir, '.groove');
+      mkdirSync(grooveDir, { recursive: true });
+      const memory = new MemoryStore(grooveDir);
+      memory.appendHandoffBrief('backend', {
+        brief: 'Previous backend handoff',
+        reason: 'completed',
+      });
+
+      const daemon = { registry, projectDir: tmpDir, grooveDir, memory };
+      const intro = new Introducer(daemon);
+
+      const agent = registry.add({ role: 'backend', scope: [] });
+      const ctx = intro.generateContext(agent, { hasTask: true });
+
+      assert.ok(ctx.includes('Recent Handoff History'), 'handoffs should be injected when hasTask=true');
+    });
+
+    it('should inject handoffs for rotation replacements (isRotation=true)', () => {
+      const grooveDir = join(tmpDir, '.groove');
+      mkdirSync(grooveDir, { recursive: true });
+      const memory = new MemoryStore(grooveDir);
+      memory.appendHandoffBrief('backend', {
+        brief: 'Rotation handoff content',
+        reason: 'context_threshold',
+      });
+
+      const daemon = { registry, projectDir: tmpDir, grooveDir, memory };
+      const intro = new Introducer(daemon);
+
+      const agent = registry.add({ role: 'backend', scope: [] });
+      const ctx = intro.generateContext(agent, { hasTask: false, isRotation: true });
+
+      assert.ok(ctx.includes('Recent Handoff History'), 'handoffs should be injected for rotations');
+    });
+  });
+
   describe('CLAUDE.md injection', () => {
     it('should inject GROOVE section into existing CLAUDE.md', () => {
       writeFileSync(join(tmpDir, 'CLAUDE.md'), '# My Project\n\nSome content.\n');

package/node_modules/@groove-dev/daemon/test/journalist.test.js

@@ -311,6 +311,112 @@ describe('Journalist', () => {
     });
   });
 
+  describe('requestSynthesis', () => {
+    it('should debounce multiple calls within 10s into a single cycle', async () => {
+      const { daemon } = createMockDaemon();
+      const journalist = new Journalist(daemon);
+
+      let cycleCalls = 0;
+      journalist.cycle = async () => { cycleCalls++; };
+
+      journalist.requestSynthesis('completion');
+      journalist.requestSynthesis('spawn');
+      journalist.requestSynthesis('rotation');
+
+      assert.equal(cycleCalls, 0, 'cycle should not fire immediately');
+
+      // Wait for debounce to fire
+      await new Promise((r) => setTimeout(r, 11_000));
+      assert.equal(cycleCalls, 1, 'only one cycle should fire after debounce');
+
+      journalist.stop();
+    });
+
+    it('should track the latest reason', () => {
+      const { daemon } = createMockDaemon();
+      const journalist = new Journalist(daemon);
+      journalist.cycle = async () => {};
+
+      journalist.requestSynthesis('completion');
+      journalist.requestSynthesis('rotation');
+
+      assert.equal(journalist._debounceReason, 'rotation');
+      journalist.stop();
+    });
+  });
+
+  describe('ensureFresh', () => {
+    it('should skip synthesis when lastCycleAt is recent', async () => {
+      const { daemon } = createMockDaemon();
+      const journalist = new Journalist(daemon);
+
+      let cycleCalled = false;
+      journalist.cycle = async () => { cycleCalled = true; };
+      journalist.lastCycleAt = Date.now() - 5000; // 5s ago
+
+      await journalist.ensureFresh(30000);
+      assert.equal(cycleCalled, false, 'should skip when recent');
+    });
+
+    it('should trigger synthesis when lastCycleAt is stale', async () => {
+      const { daemon } = createMockDaemon();
+      const journalist = new Journalist(daemon);
+
+      let cycleCalled = false;
+      journalist.cycle = async () => { cycleCalled = true; };
+      journalist.lastCycleAt = Date.now() - 60_000; // 60s ago
+
+      await journalist.ensureFresh(30000);
+      assert.equal(cycleCalled, true, 'should trigger when stale');
+    });
+
+    it('should trigger synthesis when lastCycleAt is null', async () => {
+      const { daemon } = createMockDaemon();
+      const journalist = new Journalist(daemon);
+
+      let cycleCalled = false;
+      journalist.cycle = async () => { cycleCalled = true; };
+
+      await journalist.ensureFresh(30000);
+      assert.equal(cycleCalled, true, 'should trigger when never synthesized');
+    });
+  });
+
+  describe('model tier selection', () => {
+    it('should prefer medium tier over light tier for synthesis', () => {
+      // Verify the callHeadless model selection logic by checking the source
+      // The constructor picks medium first, falling back to light
+      const { daemon } = createMockDaemon();
+      const journalist = new Journalist(daemon);
+
+      // Simulate provider model selection logic matching callHeadless
+      const models = [
+        { id: 'haiku', tier: 'light' },
+        { id: 'sonnet', tier: 'medium' },
+        { id: 'opus', tier: 'heavy' },
+      ];
+
+      const selected = models.find((m) => m.tier === 'medium')
+        || models.find((m) => m.tier === 'light')
+        || models[0];
+
+      assert.equal(selected.id, 'sonnet', 'should select medium tier (Sonnet)');
+    });
+
+    it('should fall back to light tier when medium is unavailable', () => {
+      const models = [
+        { id: 'haiku', tier: 'light' },
+        { id: 'opus', tier: 'heavy' },
+      ];
+
+      const selected = models.find((m) => m.tier === 'medium')
+        || models.find((m) => m.tier === 'light')
+        || models[0];
+
+      assert.equal(selected.id, 'haiku', 'should fall back to light tier');
+    });
+  });
+
   describe('_extractConstraints', () => {
     it('should no-op since auto-extraction is disabled', () => {
       const { daemon, grooveDir } = createMockDaemon();

package/node_modules/@groove-dev/daemon/test/memory.test.js

@@ -181,6 +181,55 @@ describe('MemoryStore', () => {
       assert.ok(!rootRoles.includes('frontend'));
       assert.ok(wsRoles.includes('frontend'));
     });
+
+    it('scopes chains by teamId — different teams produce different files', () => {
+      memory.appendHandoffBrief('planner', { brief: 'team-A planner work' }, null, 'team-A');
+      memory.appendHandoffBrief('planner', { brief: 'team-B planner work' }, null, 'team-B');
+
+      const chainA = memory.getHandoffChain('planner', null, 'team-A');
+      const chainB = memory.getHandoffChain('planner', null, 'team-B');
+      assert.equal(chainA.length, 1);
+      assert.equal(chainB.length, 1);
+      assert.match(chainA[0].body, /team-A planner/);
+      assert.match(chainB[0].body, /team-B planner/);
+    });
+
+    it('team-scoped chains are independent from root chains', () => {
+      memory.appendHandoffBrief('planner', { brief: 'root planner work' });
+      memory.appendHandoffBrief('planner', { brief: 'scoped planner work' }, null, 'team-X');
+
+      const rootChain = memory.getHandoffChain('planner');
+      const teamChain = memory.getHandoffChain('planner', null, 'team-X');
+      assert.equal(rootChain.length, 1);
+      assert.equal(teamChain.length, 1);
+      assert.match(rootChain[0].body, /root planner/);
+      assert.match(teamChain[0].body, /scoped planner/);
+    });
+
+    it('teamId takes priority over workingDir for chain path', () => {
+      const ws = join(tmpDir, '..', 'some-workspace');
+      memory.appendHandoffBrief('backend', { brief: 'team-scoped' }, ws, 'team-Z');
+      memory.appendHandoffBrief('backend', { brief: 'ws-scoped' }, ws);
+
+      const teamChain = memory.getHandoffChain('backend', ws, 'team-Z');
+      const wsChain = memory.getHandoffChain('backend', ws);
+      assert.equal(teamChain.length, 1);
+      assert.equal(wsChain.length, 1);
+      assert.match(teamChain[0].body, /team-scoped/);
+      assert.match(wsChain[0].body, /ws-scoped/);
+    });
+
+    it('getRecentHandoffMarkdown respects teamId', () => {
+      memory.appendHandoffBrief('planner', { brief: 'team-1 brief' }, null, 'team-1');
+      memory.appendHandoffBrief('planner', { brief: 'team-2 brief' }, null, 'team-2');
+
+      const md1 = memory.getRecentHandoffMarkdown('planner', 3, 4000, null, 'team-1');
+      const md2 = memory.getRecentHandoffMarkdown('planner', 3, 4000, null, 'team-2');
+      assert.match(md1, /team-1 brief/);
+      assert.ok(!md1.includes('team-2 brief'));
+      assert.match(md2, /team-2 brief/);
+      assert.ok(!md2.includes('team-1 brief'));
+    });
   });
 
   describe('discoveries', () => {

package/node_modules/@groove-dev/daemon/test/rotator.test.js

@@ -335,6 +335,61 @@ describe('Rotator', () => {
     assert.equal(tokenCeilingRotations.length, 0);
   });
 
+  it('should trigger estimated_context_ceiling when contextUsage is stale', async () => {
+    // Simulates a Codex agent that never reports contextUsage updates.
+    // The agent has consumed 200K tokens (100% of maxContext) but contextUsage stayed at 0.
+    const agent = {
+      id: 'cx1', name: 'codex-stale', role: 'backend', status: 'running',
+      provider: 'codex', scope: [], model: 'gpt-5.4',
+      tokensUsed: 200_000, contextUsage: 0, workingDir: '/tmp',
+      lastActivity: new Date(Date.now() - 30_000).toISOString(),
+      spawnedAt: new Date(Date.now() - 300_000).toISOString(),
+    };
+    mockDaemon.registry.agents = [agent];
+
+    // First check — records the initial contextUsage state
+    await rotator.check();
+    assert.equal(rotator.getHistory().length, 0); // No rotation yet
+
+    // Simulate 120+ seconds of stale contextUsage by backdating the timestamp
+    const state = rotator._lastContextState.get('cx1');
+    state.timestamp = Date.now() - 130_000; // 130s ago
+
+    // Second check — stale context + high tokens should trigger estimated_context_ceiling
+    await rotator.check();
+
+    const history = rotator.getHistory();
+    assert.equal(history.length, 1);
+    assert.equal(history[0].reason, 'estimated_context_ceiling');
+  });
+
+  it('should NOT trigger estimated_context_ceiling when tokens are below HARD_CEILING', async () => {
+    const agent = {
+      id: 'cx2', name: 'codex-low', role: 'backend', status: 'running',
+      provider: 'codex', scope: [], model: 'gpt-5.4',
+      tokensUsed: 50_000, contextUsage: 0, workingDir: '/tmp',
+      lastActivity: new Date(Date.now() - 30_000).toISOString(),
+      spawnedAt: new Date(Date.now() - 300_000).toISOString(),
+    };
+    mockDaemon.registry.agents = [agent];
+
+    // First check to record state
+    await rotator.check();
+    const state = rotator._lastContextState.get('cx2');
+    state.timestamp = Date.now() - 130_000;
+
+    // Second check — 50K/200K = 25%, below 80% ceiling
+    await rotator.check();
+
+    const history = rotator.getHistory();
+    assert.equal(history.length, 0);
+  });
+
+  it('should include estimatedCeilingRotations in stats', () => {
+    const stats = rotator.getStats();
+    assert.equal(stats.estimatedCeilingRotations, 0);
+  });
+
   it('should record lastRotationTime after successful rotation', async () => {
     const agent = {
       id: 'a3', name: 'backend-3', role: 'backend',
@@ -352,4 +407,48 @@ describe('Rotator', () => {
     const elapsed = Date.now() - rotator.lastRotationTime.get(newAgent.id);
     assert.ok(elapsed < 1000); // Should be very recent
   });
+
+  it('should pass isRotation flag through spawn config', async () => {
+    let spawnConfig = null;
+    mockDaemon.processes.spawn = async (config) => {
+      spawnConfig = config;
+      return { id: 'new-' + config.role, name: config.name, ...config };
+    };
+
+    const agent = {
+      id: 'a4', name: 'backend-4', role: 'backend',
+      provider: 'claude-code', scope: [], model: null,
+      tokensUsed: 3000, contextUsage: 0.9, workingDir: '/tmp',
+      teamId: 'team-1',
+    };
+    mockDaemon.registry.agents = [agent];
+
+    await rotator.rotate('a4');
+
+    assert.ok(spawnConfig, 'spawn should have been called');
+    assert.equal(spawnConfig.isRotation, true, 'isRotation must be true for rotation spawns');
+    assert.equal(spawnConfig.teamId, 'team-1', 'teamId must be passed through');
+  });
+
+  it('should pass teamId to appendHandoffBrief', async () => {
+    let appendArgs = null;
+    mockDaemon.memory.appendHandoffBrief = (role, entry, workingDir, teamId) => {
+      appendArgs = { role, workingDir, teamId };
+      return true;
+    };
+
+    const agent = {
+      id: 'a5', name: 'backend-5', role: 'backend',
+      provider: 'claude-code', scope: [], model: null,
+      tokensUsed: 3000, contextUsage: 0.9, workingDir: '/tmp',
+      teamId: 'team-alpha',
+    };
+    mockDaemon.registry.agents = [agent];
+
+    await rotator.rotate('a5');
+
+    assert.ok(appendArgs, 'appendHandoffBrief should have been called');
+    assert.equal(appendArgs.teamId, 'team-alpha');
+    assert.equal(appendArgs.role, 'backend');
+  });
 });

package/node_modules/@groove-dev/gui/package.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "groove-dev",
-  "version": "0.27.25",
+  "version": "0.27.27",
   "description": "Open-source agent orchestration layer — the AI company OS. Local model agent engine (GGUF/Ollama/llama-server), HuggingFace model browser, MCP integrations (Slack, Gmail, Stripe, 15+), agent scheduling (cron), business roles (CMO, CFO, EA). GUI dashboard, multi-agent coordination, zero cold-start, infinite sessions. Works with Claude Code, Codex, Gemini CLI, Ollama, any local model.",
   "license": "FSL-1.1-Apache-2.0",
   "author": "Groove Dev <hello@groovedev.ai> (https://groovedev.ai)",

package/packages/cli/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@groove-dev/cli",
-  "version": "0.27.7",
-  "description": "GROOVE CLI \u2014 manage AI coding agents from your terminal",
+  "version": "0.27.27",
+  "description": "GROOVE CLI — manage AI coding agents from your terminal",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",
   "bin": {
@@ -13,4 +13,4 @@
     "chalk": "^5.3.0"
   },
   "private": true
-}
+}

package/packages/daemon/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/daemon",
-  "version": "0.27.7",
+  "version": "0.27.27",
   "description": "GROOVE daemon — agent orchestration engine",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",

package/packages/daemon/src/introducer.js

@@ -14,7 +14,7 @@ export class Introducer {
   }
 
   generateContext(newAgent, options = {}) {
-    const { taskNegotiation, hasTask } = 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
@@ -353,13 +353,13 @@ export class Introducer {
           parts.push(`### Constraints (read carefully)\n${constraints}`);
         }
 
-        if (hasTask) {
-          const discoveries = this.daemon.memory.getDiscoveriesMarkdown(newAgent.role, 15, 1000);
+        if (hasTask || isRotation) {
+          const discoveries = this.daemon.memory.getDiscoveriesMarkdown(newAgent.role, 8, 600, newAgent.scope);
           if (discoveries) {
             parts.push(`### Known Fixes for ${newAgent.role} Role\n${discoveries}`);
           }
 
-          const handoffs = this.daemon.memory.getRecentHandoffMarkdown(newAgent.role, 2, 1000, newAgent.workingDir);
+          const handoffs = this.daemon.memory.getRecentHandoffMarkdown(newAgent.role, 2, 1000, newAgent.workingDir, newAgent.teamId);
           if (handoffs) {
             parts.push(`### Recent Handoff History\n${handoffs}`);
           }
@@ -367,9 +367,9 @@ export class Introducer {
 
         if (parts.length > 0) {
           memorySection = `\n## Project Memory (auto-generated)\n\n${parts.join('\n\n')}\n`;
-          // Hard budget: 4K chars total
-          if (memorySection.length > 4000) {
-            memorySection = memorySection.slice(0, 3997) + '...';
+          // Hard budget: 3K chars total
+          if (memorySection.length > 3000) {
+            memorySection = memorySection.slice(0, 2997) + '...';
           }
         }
       }

package/packages/daemon/src/journalist.js

@@ -6,8 +6,9 @@ import { resolve } from 'path';
 import { execFile, spawn as cpSpawn } from 'child_process';
 import { getProvider, getInstalledProviders } from './providers/index.js';
 
-const DEFAULT_INTERVAL = 120_000; // 2 minutes
+const DEFAULT_INTERVAL = 300_000; // 5 minutes (safety-net fallback; event-driven triggers handle the normal case)
 const MAX_LOG_CHARS = 100_000; // ~25k tokens budget for synthesis input (captures 80-90% of recent activity)
+const DEBOUNCE_MS = 10_000; // requestSynthesis debounce window
 
 export class Journalist {
   constructor(daemon) {
@@ -19,6 +20,8 @@ export class Journalist {
     this.synthesizing = false;
     this.lastSynthesis = null; // last synthesis result text
     this.history = []; // recent synthesis summaries
+    this._debounceTimer = null;
+    this._debounceReason = null;
   }
 
   start(intervalMs = DEFAULT_INTERVAL) {
@@ -51,6 +54,33 @@ export class Journalist {
       clearInterval(this.interval);
       this.interval = null;
     }
+    if (this._debounceTimer) {
+      clearTimeout(this._debounceTimer);
+      this._debounceTimer = null;
+    }
+  }
+
+  requestSynthesis(reason = 'unknown') {
+    if (this._debounceTimer) {
+      this._debounceReason = reason;
+      return;
+    }
+    this._debounceReason = reason;
+    this._debounceTimer = setTimeout(() => {
+      const r = this._debounceReason;
+      this._debounceTimer = null;
+      this._debounceReason = null;
+      this.cycle().catch((err) => {
+        console.error(`  Journalist requestSynthesis(${r}) failed:`, err.message);
+      });
+    }, DEBOUNCE_MS);
+  }
+
+  async ensureFresh(maxAgeMs = 30000) {
+    if (this.lastCycleAt && (Date.now() - this.lastCycleAt) < maxAgeMs) {
+      return;
+    }
+    await this.cycle();
   }
 
   async cycle() {
@@ -454,11 +484,11 @@ export class Journalist {
     }
     const provider = getProvider(providerId);
 
-    // Pick the lightest model for synthesis (cheapest/fastest)
-    const lightModel = provider.constructor.models?.find((m) => m.tier === 'light')
-      || provider.constructor.models?.find((m) => m.tier === 'medium')
+    // Pick medium tier for higher-quality synthesis (fewer but better cycles)
+    const selectedModel = provider.constructor.models?.find((m) => m.tier === 'medium')
+      || provider.constructor.models?.find((m) => m.tier === 'light')
       || provider.constructor.models?.[0];
-    const modelId = lightModel?.id || null;
+    const modelId = selectedModel?.id || null;
 
     const headlessCmd = provider.buildHeadlessCommand(prompt, modelId);
     const { command, args, env, stdin: stdinData } = headlessCmd;
@@ -749,7 +779,7 @@ export class Journalist {
     // Pull recent rotation history from persistent memory (Layer 7).
     // Gives the new agent causal continuity: what the last 3 agents struggled
     // with, decided, and solved — not just what the current session did.
-    const recentChain = this.daemon.memory?.getRecentHandoffMarkdown(agent.role, 3, 3000, agent.workingDir) || '';
+    const recentChain = this.daemon.memory?.getRecentHandoffMarkdown(agent.role, 3, 3000, agent.workingDir, agent.teamId) || '';
 
     // Pull the user's recent messages scoped to this agent
     const agentFeedback = this.getUserFeedback(agent.id).slice(-5);

package/packages/daemon/src/memory.js

@@ -12,6 +12,7 @@
 import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, appendFileSync, statSync } from 'fs';
 import { resolve, relative } from 'path';
 import { createHash } from 'crypto';
+import { minimatch } from 'minimatch';
 
 const MAX_CONSTRAINTS = 50;
 const MAX_HANDOFF_ROTATIONS = 25;
@@ -141,7 +142,12 @@ export class MemoryStore {
     return safeName(rel);
   }
 
-  _chainPath(role, workingDir) {
+  _chainPath(role, workingDir, teamId) {
+    if (teamId) {
+      const dir = resolve(this.handoffDir, safeName(teamId));
+      mkdirSync(dir, { recursive: true });
+      return resolve(dir, `${safeName(role)}.md`);
+    }
     const slug = this._workspaceSlug(workingDir);
     if (slug) {
       const dir = resolve(this.handoffDir, slug);
@@ -151,8 +157,8 @@ export class MemoryStore {
     return resolve(this.handoffDir, `${safeName(role)}.md`);
   }
 
-  getHandoffChain(role, workingDir) {
-    const path = this._chainPath(role, workingDir);
+  getHandoffChain(role, workingDir, teamId) {
+    const path = this._chainPath(role, workingDir, teamId);
     if (!existsSync(path)) return [];
     try {
       const content = readFileSync(path, 'utf8');
@@ -173,9 +179,9 @@ export class MemoryStore {
     }
   }
 
-  appendHandoffBrief(role, entry, workingDir) {
+  appendHandoffBrief(role, entry, workingDir, teamId) {
     if (!role || !entry) return false;
-    const chain = this.getHandoffChain(role, workingDir);
+    const chain = this.getHandoffChain(role, workingDir, teamId);
     const nextN = (chain[0]?.rotationN || 0) + 1;
 
     const block = [
@@ -203,15 +209,15 @@ export class MemoryStore {
     }
 
     try {
-      writeFileSync(this._chainPath(role, workingDir), lines.join('\n'));
+      writeFileSync(this._chainPath(role, workingDir, teamId), lines.join('\n'));
       return true;
     } catch {
       return false;
     }
   }
 
-  getRecentHandoffMarkdown(role, count = 3, maxChars = 4000, workingDir) {
-    const chain = this.getHandoffChain(role, workingDir);
+  getRecentHandoffMarkdown(role, count = 3, maxChars = 4000, workingDir, teamId) {
+    const chain = this.getHandoffChain(role, workingDir, teamId);
     if (chain.length === 0) return '';
     const recent = chain.slice(0, count);
     const out = recent.map((e) => e.body || '').join('\n\n---\n\n');
@@ -300,9 +306,22 @@ export class MemoryStore {
     } catch { /* best-effort */ }
   }
 
-  getDiscoveriesMarkdown(role, limit = 20, maxChars = 4000) {
-    const entries = this.listDiscoveries({ role, limit });
+  getDiscoveriesMarkdown(role, limit = 20, maxChars = 4000, scope) {
+    let entries = this.listDiscoveries({ role, limit: limit * 3 });
     if (entries.length === 0) return '';
+
+    if (scope && Array.isArray(scope) && scope.length > 0) {
+      const filtered = entries.filter((d) => {
+        const file = d.fix || '';
+        const rel = file.startsWith(this.projectDir + '/') ? file.slice(this.projectDir.length + 1) : file;
+        return scope.some((pattern) => minimatch(rel, pattern, { dot: true }));
+      });
+      if (filtered.length >= 3) {
+        entries = filtered;
+      }
+    }
+
+    entries = entries.slice(0, limit);
     const lines = entries.map((d) => `- When \`${d.trigger}\` → fix: ${d.fix}`);
     return truncate(lines.join('\n'), maxChars);
   }