groove-dev 0.27.26 → 0.27.28

package/node_modules/@groove-dev/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);
   }

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

@@ -266,6 +266,18 @@ IMPORTANT: Do not use markdown formatting like ** or ### in your output. Write i
 `,
 };
 
+// Role-to-integration mapping — recommended integrations per role for onboarding preflight
+export const ROLE_INTEGRATIONS = {
+  ea: ['gmail', 'google-calendar'],
+  cmo: ['gmail', 'slack', 'hubspot'],
+  cfo: ['stripe', 'google-sheets'],
+  support: ['gmail', 'slack', 'zendesk'],
+  analyst: ['google-sheets', 'postgres', 'mixpanel'],
+  home: ['home-assistant'],
+  slides: ['google-slides'],
+  creative: ['google-docs'],
+};
+
 // Permission-level prompt instructions
 // "auto" = PM reviews risky ops via API. "full" = no reviews, max speed.
 const PERMISSION_PROMPTS = {
@@ -427,12 +439,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 +615,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 +801,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 +1185,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 +1386,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/node_modules/@groove-dev/daemon/src/providers/claude-code.js

@@ -1,7 +1,7 @@
 // GROOVE — Claude Code Provider
 // FSL-1.1-Apache-2.0 — see LICENSE
 
-import { execSync } from 'child_process';
+import { execSync, spawn as cpSpawn } from 'child_process';
 import { writeFileSync, readFileSync, existsSync } from 'fs';
 import { resolve } from 'path';
 import { homedir } from 'os';
@@ -223,4 +223,29 @@ export class ClaudeCodeProvider extends Provider {
 
     return merged;
   }
+
+  static getAuthStatus() {
+    try {
+      const out = execSync('claude auth status --json', { encoding: 'utf8', timeout: 10_000, stdio: ['pipe', 'pipe', 'pipe'] });
+      const data = JSON.parse(out);
+      return {
+        authenticated: true,
+        authMethod: data.authMethod || data.auth_method || 'unknown',
+        email: data.email || null,
+        subscriptionType: data.subscriptionType || data.subscription_type || null,
+        orgName: data.orgName || data.org_name || null,
+      };
+    } catch (err) {
+      return { authenticated: false, error: err.message };
+    }
+  }
+
+  static triggerLogin() {
+    const child = cpSpawn('claude', ['auth', 'login', '--claudeai'], {
+      detached: true,
+      stdio: 'ignore',
+    });
+    child.unref();
+    return { pid: child.pid };
+  }
 }

package/node_modules/@groove-dev/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/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', () => {