@doingdev/opencode-claude-manager-plugin 0.1.57 → 0.1.59

package/dist/test/claude-manager.plugin.test.js

@@ -47,6 +47,8 @@ describe('ClaudeManagerPlugin', () => {
             sara: 'allow',
             Alex: 'allow',
             alex: 'allow',
+            BrowserQA: 'allow',
+            'browser-qa': 'allow',
             'team-planner': 'allow',
         });
     });
@@ -209,4 +211,62 @@ describe('Agent ID normalization and lookup helpers', () => {
         // CTO should NOT have direct access to plan_with_team (must delegate to team-planner)
         expect(ctoPermissions['plan_with_team']).not.toBe('allow');
     });
+    it('browser-qa agent is registered with correct permissions', async () => {
+        const plugin = await ClaudeManagerPlugin({
+            worktree: '/tmp/project',
+        });
+        const config = {};
+        await plugin.config?.(config);
+        const agents = (config.agent ?? {});
+        const { AGENT_BROWSER_QA } = await import('../src/plugin/agent-hierarchy.js');
+        const browserQa = agents[AGENT_BROWSER_QA];
+        expect(browserQa).toBeDefined();
+        expect(browserQa.permission).toBeDefined();
+        // BrowserQA should have access to claude tool
+        expect(browserQa.permission?.['claude']).toBe('allow');
+    });
+    it('browser-qa session prompt allows Playwright skill/command', async () => {
+        const { managerPromptRegistry } = await import('../src/prompts/registry.js');
+        expect(managerPromptRegistry.browserQaSessionPrompt).toContain('Playwright skill');
+        expect(managerPromptRegistry.browserQaSessionPrompt).toContain('real browser');
+        expect(managerPromptRegistry.browserQaSessionPrompt).toContain('Allowed tools');
+    });
+    it('browser-qa agent prompt mentions PLAYWRIGHT_UNAVAILABLE sentinel', async () => {
+        const { managerPromptRegistry } = await import('../src/prompts/registry.js');
+        expect(managerPromptRegistry.browserQaAgentPrompt).toContain('PLAYWRIGHT_UNAVAILABLE');
+        expect(managerPromptRegistry.browserQaAgentPrompt).toContain('Playwright');
+    });
+    it('browser-qa agent is registered in ENGINEER_AGENT_IDS', async () => {
+        const { AGENT_BROWSER_QA, ENGINEER_AGENT_IDS } = await import('../src/plugin/agent-hierarchy.js');
+        // BrowserQA should be in the engineer IDs
+        const engineerIds = Object.values(ENGINEER_AGENT_IDS);
+        expect(engineerIds).toContain('browser-qa');
+        expect(ENGINEER_AGENT_IDS['BrowserQA']).toBe(AGENT_BROWSER_QA);
+    });
+    it('browser-qa agent config has restricted write access', async () => {
+        const plugin = await ClaudeManagerPlugin({
+            worktree: '/tmp/project',
+        });
+        const config = {};
+        await plugin.config?.(config);
+        const agents = (config.agent ?? {});
+        const { AGENT_BROWSER_QA } = await import('../src/plugin/agent-hierarchy.js');
+        const browserQa = agents[AGENT_BROWSER_QA];
+        expect(browserQa).toBeDefined();
+        // Should allow claude tool (engineers can call claude)
+        expect(browserQa.permission?.['claude']).toBe('allow');
+        // Should deny most other tools
+        expect(browserQa.permission?.['read']).toBeUndefined(); // Falls back to deny
+        expect(browserQa.permission?.['write']).toBeUndefined(); // Falls back to deny
+    });
+    it('browserqa agent uses same engineer dispatch path', async () => {
+        const plugin = await ClaudeManagerPlugin({
+            worktree: '/tmp/project',
+        });
+        const config = {};
+        await plugin.config?.(config);
+        const agents = (config.agent ?? {});
+        // BrowserQA should be configured as an agent
+        expect(agents['browser-qa']).toBeDefined();
+    });
 });

package/dist/test/cto-active-team.test.js

@@ -1,12 +1,19 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+/**
+ * Tests for the session-per-team CTO model:
+ * - Each CTO session ID is its own team ID (no shared repo-global state).
+ * - Same CTO session ID recovers the same team context across restarts.
+ * - A different CTO session ID in the same worktree creates an independent team.
+ * - Engineers spawned within a CTO session resolve to that CTO's team.
+ * - CTO task permissions do not allow self-delegation.
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { mkdtemp, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { ClaudeManagerPlugin } from '../src/plugin/claude-manager.plugin.js';
-import { clearPluginServices, getActiveTeamSession } from '../src/plugin/service-factory.js';
-import { AGENT_CTO } from '../src/plugin/agent-hierarchy.js';
-import { TeamStateStore } from '../src/state/team-state-store.js';
-describe('CTO chat.message — persisted active team', () => {
+import { clearPluginServices, getOrCreatePluginServices, getSessionTeam, getWrapperSessionMapping, registerParentSession, } from '../src/plugin/service-factory.js';
+import { AGENT_CTO, ENGINEER_AGENT_IDS } from '../src/plugin/agents/index.js';
+describe('CTO chat.message — session-per-team model', () => {
     let tempRoot;
     beforeEach(async () => {
         tempRoot = await mkdtemp(join(tmpdir(), 'cto-team-'));
@@ -18,35 +25,175 @@ describe('CTO chat.message — persisted active team', () => {
             await rm(tempRoot, { recursive: true, force: true });
         }
     });
-    it('persists the active team on the first CTO message', async () => {
+    it('CTO session ID is used directly as the team ID', async () => {
         const plugin = await ClaudeManagerPlugin({ worktree: tempRoot });
         const chatMessage = plugin['chat.message'];
-        await chatMessage({ agent: AGENT_CTO, sessionID: 'session-cto-1' });
-        const store = new TeamStateStore('.claude-manager');
-        await expect(store.getActiveTeam(tempRoot)).resolves.toBe('session-cto-1');
-        expect(getActiveTeamSession(tempRoot)).toBe('session-cto-1');
-    });
-    it('a new CTO session adopts the already-persisted active team instead of overwriting it', async () => {
-        const store = new TeamStateStore('.claude-manager');
-        // Simulate a pre-existing persisted active team (e.g., from a previous process run).
-        await store.setActiveTeam(tempRoot, 'old-team-id');
+        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-session-1' });
+        expect(getSessionTeam('cto-session-1')).toBe('cto-session-1');
+    });
+    it('same CTO session ID recovers its team context after a process restart', async () => {
+        // Phase 1: CTO session 'cto-1' runs and a team record is created on disk.
+        const plugin1 = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const chatMessage1 = plugin1['chat.message'];
+        await chatMessage1({ agent: AGENT_CTO, sessionID: 'cto-1' });
+        const services1 = getOrCreatePluginServices(tempRoot);
+        await services1.orchestrator.getOrCreateTeam(tempRoot, 'cto-1'); // persist team to disk
+        expect(getSessionTeam('cto-1')).toBe('cto-1');
+        // Phase 2: Simulate a process restart (all in-memory state is lost).
+        clearPluginServices();
+        // Phase 3: The same CTO session ID resumes — it should re-register itself.
+        const plugin2 = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const chatMessage2 = plugin2['chat.message'];
+        await chatMessage2({ agent: AGENT_CTO, sessionID: 'cto-1' });
+        expect(getSessionTeam('cto-1')).toBe('cto-1');
+        // The persisted team record from Phase 1 should still be accessible.
+        const services2 = getOrCreatePluginServices(tempRoot);
+        const team = await services2.orchestrator.getOrCreateTeam(tempRoot, 'cto-1');
+        expect(team.id).toBe('cto-1');
+    });
+    it('a different CTO session ID creates an independent team, not adopting prior state', async () => {
+        // Phase 1: CTO session 'cto-1' runs.
+        const plugin1 = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const chatMessage1 = plugin1['chat.message'];
+        await chatMessage1({ agent: AGENT_CTO, sessionID: 'cto-1' });
+        const services1 = getOrCreatePluginServices(tempRoot);
+        await services1.orchestrator.getOrCreateTeam(tempRoot, 'cto-1');
+        // Phase 2: Process restart.
+        clearPluginServices();
+        // Phase 3: A brand-new CTO session 'cto-2' starts.
+        const plugin2 = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const chatMessage2 = plugin2['chat.message'];
+        await chatMessage2({ agent: AGENT_CTO, sessionID: 'cto-2' });
+        // Must use its OWN session ID as team — must NOT adopt 'cto-1'.
+        expect(getSessionTeam('cto-2')).toBe('cto-2');
+        expect(getSessionTeam('cto-1')).toBeUndefined(); // cleared by restart
+        // 'cto-1' team data remains on disk, untouched.
+        const services2 = getOrCreatePluginServices(tempRoot);
+        const team1 = await services2.teamStore.getTeam(tempRoot, 'cto-1');
+        expect(team1).not.toBeNull(); // still present
+        expect(team1.id).toBe('cto-1');
+    });
+    it('multiple chat.message calls from the same CTO session do not change the active team', async () => {
         const plugin = await ClaudeManagerPlugin({ worktree: tempRoot });
         const chatMessage = plugin['chat.message'];
-        // New CTO session with a different session ID.
-        await chatMessage({ agent: AGENT_CTO, sessionID: 'brand-new-cto-session' });
-        // The persisted active team must NOT be overwritten.
-        await expect(store.getActiveTeam(tempRoot)).resolves.toBe('old-team-id');
-        // The in-memory registry must point to the persisted team, NOT the new session.
-        expect(getActiveTeamSession(tempRoot)).toBe('old-team-id');
-    });
-    it('does not overwrite the persisted team across two CTO messages in the same session', async () => {
-        const store = new TeamStateStore('.claude-manager');
+        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-session-1' });
+        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-session-1' });
+        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-session-1' });
+        expect(getSessionTeam('cto-session-1')).toBe('cto-session-1');
+    });
+    it("engineers spawned during a CTO session resolve to that CTO session's team", async () => {
+        const plugin = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const chatMessage = plugin['chat.message'];
+        // CTO session fires first, establishing the active team.
+        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-A' });
+        // Simulate session.created event: OpenCode fires this before chat.message for the engineer.
+        registerParentSession('wrapper-tom-1', 'cto-A');
+        // Engineer wrapper session fires (spawned by the CTO).
+        await chatMessage({ agent: ENGINEER_AGENT_IDS.Tom, sessionID: 'wrapper-tom-1' });
+        // The wrapper session must be mapped to the CTO's team, not a new orphan team.
+        const mapping = getWrapperSessionMapping(tempRoot, 'wrapper-tom-1');
+        expect(mapping).toBeDefined();
+        expect(mapping.teamId).toBe('cto-A');
+        expect(mapping.workerName).toBe('Tom');
+    });
+    it('two concurrent CTO sessions each bind their own engineers independently', async () => {
+        const plugin = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const chatMessage = plugin['chat.message'];
+        // Two CTO sessions start concurrently in the same worktree.
+        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-alpha' });
+        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-beta' });
+        // Simulate session.created events: each CTO spawns one engineer sub-session.
+        // The event hook normally calls registerParentSession; call it directly here.
+        registerParentSession('wrapper-tom-alpha', 'cto-alpha');
+        registerParentSession('wrapper-sara-beta', 'cto-beta');
+        // Engineer wrapper sessions check in.
+        await chatMessage({ agent: ENGINEER_AGENT_IDS.Tom, sessionID: 'wrapper-tom-alpha' });
+        await chatMessage({ agent: ENGINEER_AGENT_IDS.Sara, sessionID: 'wrapper-sara-beta' });
+        // Tom must bind to cto-alpha's team, not cto-beta's.
+        const tomMapping = getWrapperSessionMapping(tempRoot, 'wrapper-tom-alpha');
+        expect(tomMapping).toBeDefined();
+        expect(tomMapping.teamId).toBe('cto-alpha');
+        // Sara must bind to cto-beta's team, not cto-alpha's.
+        const saraMapping = getWrapperSessionMapping(tempRoot, 'wrapper-sara-beta');
+        expect(saraMapping).toBeDefined();
+        expect(saraMapping.teamId).toBe('cto-beta');
+    });
+});
+describe('CTO task permissions — self-delegation', () => {
+    let tempRoot;
+    beforeEach(async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'cto-perms-'));
+        clearPluginServices();
+    });
+    afterEach(async () => {
+        clearPluginServices();
+        if (tempRoot)
+            await rm(tempRoot, { recursive: true, force: true });
+    });
+    it('CTO task permissions deny delegation to cto', async () => {
         const plugin = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const config = {};
+        await plugin.config?.(config);
+        const agents = (config.agent ?? {});
+        const cto = agents[AGENT_CTO];
+        const taskPerms = cto.permission.task;
+        // Default deny must apply, and cto must not be explicitly allowed.
+        expect(taskPerms['*']).toBe('deny');
+        expect(taskPerms['cto']).toBeUndefined();
+        expect(taskPerms['CTO']).toBeUndefined();
+    });
+});
+describe('CTO tool isolation — concurrent sessions', () => {
+    let tempRoot;
+    beforeEach(async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'cto-isolation-'));
+        clearPluginServices();
+    });
+    afterEach(async () => {
+        clearPluginServices();
+        if (tempRoot)
+            await rm(tempRoot, { recursive: true, force: true });
+    });
+    it('team_status called from CTO-A uses CTO-A team even after CTO-B has chatted', async () => {
+        const plugin = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const chatMessage = plugin['chat.message'];
+        // CTO-A registers first, then CTO-B registers (simulating two concurrent sessions).
+        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-A' });
+        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-B' });
+        // Execute team_status as CTO-A (sessionID = 'cto-A').
+        const teamStatusTool = plugin.tool['team_status'];
+        const ctx = {
+            metadata: vi.fn(),
+            worktree: tempRoot,
+            sessionID: 'cto-A',
+            agent: AGENT_CTO,
+            abort: new AbortController().signal,
+        };
+        const result = JSON.parse(await teamStatusTool.execute({}, ctx));
+        // Must load cto-A's team, NOT cto-B's (last-write-wins global would give 'cto-B').
+        expect(result.id).toBe('cto-A');
+    });
+    it('resolves engineer team via live SDK lookup when session.created was not received', async () => {
+        // Simulate a client whose session.get returns parentID for the engineer session.
+        const mockClient = {
+            session: {
+                get: vi.fn().mockImplementation(async ({ path }) => {
+                    if (path.id === 'wrapper-tom-live') {
+                        return { data: { id: 'wrapper-tom-live', parentID: 'cto-live' } };
+                    }
+                    return { data: undefined };
+                }),
+            },
+        };
+        const plugin = await ClaudeManagerPlugin({ worktree: tempRoot, client: mockClient });
         const chatMessage = plugin['chat.message'];
-        await chatMessage({ agent: AGENT_CTO, sessionID: 'session-cto-1' });
-        await chatMessage({ agent: AGENT_CTO, sessionID: 'session-cto-1' });
-        // Still the original session — persisted.
-        await expect(store.getActiveTeam(tempRoot)).resolves.toBe('session-cto-1');
-        expect(getActiveTeamSession(tempRoot)).toBe('session-cto-1');
+        // CTO registers its team via chat.message.
+        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-live' });
+        // No registerParentSession call — simulates session.created arriving late or being missed.
+        // Engineer wrapper fires; resolveTeamId must fall through to live SDK lookup.
+        await chatMessage({ agent: ENGINEER_AGENT_IDS.Tom, sessionID: 'wrapper-tom-live' });
+        const mapping = getWrapperSessionMapping(tempRoot, 'wrapper-tom-live');
+        expect(mapping?.teamId).toBe('cto-live');
+        expect(mockClient.session.get).toHaveBeenCalledWith({ path: { id: 'wrapper-tom-live' } });
     });
 });

package/dist/test/prompt-registry.test.js

@@ -51,4 +51,19 @@ describe('managerPromptRegistry', () => {
         expect(managerPromptRegistry.ctoSystemPrompt).toContain('team-planner');
         expect(managerPromptRegistry.ctoSystemPrompt).toContain('automatically selects');
     });
+    it('ctoSystemPrompt mentions browser-qa for delegation', () => {
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('browser-qa');
+    });
+    it('browserQaAgentPrompt mentions Playwright and PLAYWRIGHT_UNAVAILABLE sentinel', () => {
+        expect(managerPromptRegistry.browserQaAgentPrompt).toContain('Playwright');
+        expect(managerPromptRegistry.browserQaAgentPrompt).toContain('PLAYWRIGHT_UNAVAILABLE');
+        expect(managerPromptRegistry.browserQaAgentPrompt).toContain('browser QA');
+    });
+    it('browserQaSessionPrompt mentions Playwright and restricts write tools', () => {
+        expect(managerPromptRegistry.browserQaSessionPrompt).toContain('Playwright');
+        expect(managerPromptRegistry.browserQaSessionPrompt).toContain('Allowed tools');
+        expect(managerPromptRegistry.browserQaSessionPrompt).toContain('browser QA');
+        expect(managerPromptRegistry.browserQaSessionPrompt).not.toContain('implement');
+        expect(managerPromptRegistry.browserQaSessionPrompt).not.toContain('write code');
+    });
 });

package/dist/test/report-claude-event.test.js

@@ -8,10 +8,18 @@ import { mkdtemp, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { ClaudeManagerPlugin } from '../src/plugin/claude-manager.plugin.js';
-import { clearPluginServices, getActiveTeamSession, getOrCreatePluginServices, } from '../src/plugin/service-factory.js';
+import { clearPluginServices, getOrCreatePluginServices, getSessionTeam, registerParentSession, } from '../src/plugin/service-factory.js';
 import { AGENT_CTO, ENGINEER_AGENT_IDS } from '../src/plugin/agent-hierarchy.js';
 import { TeamStateStore } from '../src/state/team-state-store.js';
 import { TeamOrchestrator } from '../src/manager/team-orchestrator.js';
+const BROWSER_QA_TEST_CAPS = {
+    sessionPrompt: 'Browser QA prompt',
+    restrictWriteTools: true,
+    skipModeInstructions: true,
+    plannerEligible: false,
+    isRuntimeUnavailableResponse: (text) => text.trimStart().startsWith('PLAYWRIGHT_UNAVAILABLE:'),
+    runtimeUnavailableTitle: '❌ Playwright unavailable',
+};
 function makeContext(worktree, agentId, sessionID) {
     const metadata = vi.fn();
     const ctx = {
@@ -100,7 +108,7 @@ describe('reportClaudeEvent — via plugin onEvent chain', () => {
         expect(call.metadata.toolId).toBe('call-abc');
         expect(call.metadata.toolArgs).toEqual({ file_path: '/foo.ts' });
         expect(call.metadata.sessionId).toBe('ses-1');
-        expect(call.metadata.engineer).toBe('Tom');
+        expect(call.metadata.workerName).toBe('Tom');
     });
     it('double-decodes a JSON-string input (tool input serialised twice)', async () => {
         // The SDK adapter may serialize `input` as a JSON string inside the outer JSON on
@@ -189,23 +197,25 @@ describe('second invocation continuity', () => {
         if (tempRoot)
             await rm(tempRoot, { recursive: true, force: true });
     });
-    it('wrapper memory is injected after clearPluginServices and a new plugin instance', async () => {
+    it('wrapper memory is injected after clearPluginServices and same CTO session resumes', async () => {
         // ── Phase 1: first task via orchestrator (no real SDK needed) ──────────
+        // Team ID = 'cto-1' (the CTO session ID that originally ran this work).
         const store = new TeamStateStore();
-        await store.setActiveTeam(tempRoot, 'cto-1');
-        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, store, { appendEvents: vi.fn(async () => undefined) }, 'Base prompt', 'Synthesis prompt');
+        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, store, { appendEvents: vi.fn(async () => undefined) }, 'Base prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
         await orchestrator.recordWrapperSession(tempRoot, 'cto-1', 'Tom', 'wrapper-tom-1');
         await orchestrator.recordWrapperExchange(tempRoot, 'cto-1', 'Tom', 'wrapper-tom-1', 'explore', 'Investigate the auth flow', 'Found two race conditions in the token refresh path.');
         // ── Phase 2: process restart ───────────────────────────────────────────
         clearPluginServices();
-        // ── Phase 3: new plugin instance, new CTO session ──────────────────────
+        // ── Phase 3: same CTO session resumes, engineers run a new wrapper ──────
         const plugin2 = await ClaudeManagerPlugin({ worktree: tempRoot });
         const chatMessage2 = plugin2['chat.message'];
         const systemTransform2 = plugin2['experimental.chat.system.transform'];
-        // New CTO session must adopt the persisted team, not create a new one.
-        await chatMessage2({ agent: AGENT_CTO, sessionID: 'cto-2' });
-        expect(getActiveTeamSession(tempRoot)).toBe('cto-1');
-        // Tom's new wrapper session must be registered under the persisted team.
+        // Same CTO session ID resumes — re-registers itself as the team.
+        await chatMessage2({ agent: AGENT_CTO, sessionID: 'cto-1' });
+        expect(getSessionTeam('cto-1')).toBe('cto-1');
+        // Simulate session.created: OpenCode fires this when cto-1 spawns the new wrapper.
+        registerParentSession('wrapper-tom-2', 'cto-1');
+        // Tom's new wrapper session is registered under the same team.
         await chatMessage2({ agent: ENGINEER_AGENT_IDS.Tom, sessionID: 'wrapper-tom-2' });
         // Transform fires (after chat.message has registered the session mapping).
         const output = { system: [] };
@@ -216,10 +226,9 @@ describe('second invocation continuity', () => {
         expect(output.system[0]).toContain('Found two race conditions');
     });
     it('existing engineer Claude session is resumed on second invocation', async () => {
-        // ── Phase 1: pre-seed Tom with a claudeSessionId ───────────────────────
+        // ── Phase 1: pre-seed Tom with a claudeSessionId under team 'cto-1' ────
         const store = new TeamStateStore();
-        await store.setActiveTeam(tempRoot, 'cto-1');
-        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, store, { appendEvents: vi.fn(async () => undefined) }, 'Base prompt', 'Synthesis prompt');
+        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, store, { appendEvents: vi.fn(async () => undefined) }, 'Base prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
         await orchestrator.getOrCreateTeam(tempRoot, 'cto-1');
         await store.updateTeam(tempRoot, 'cto-1', (team) => ({
             ...team,
@@ -227,10 +236,13 @@ describe('second invocation continuity', () => {
         }));
         // ── Phase 2: process restart ───────────────────────────────────────────
         clearPluginServices();
-        // ── Phase 3: new plugin, new CTO, engineer runs second task ───────────
+        // ── Phase 3: same CTO session resumes, engineer runs second task ───────
         const plugin2 = await ClaudeManagerPlugin({ worktree: tempRoot });
         const chatMessage2 = plugin2['chat.message'];
-        await chatMessage2({ agent: AGENT_CTO, sessionID: 'cto-2' });
+        // Same CTO session ID — re-registers as the team so Tom can find his session.
+        await chatMessage2({ agent: AGENT_CTO, sessionID: 'cto-1' });
+        // Simulate session.created: OpenCode fires this when cto-1 spawns the new wrapper.
+        registerParentSession('wrapper-tom-2', 'cto-1');
         await chatMessage2({ agent: ENGINEER_AGENT_IDS.Tom, sessionID: 'wrapper-tom-2' });
         const services2 = getOrCreatePluginServices(tempRoot);
         // Mock at the session level so dispatchEngineer runs its real logic
@@ -256,4 +268,37 @@ describe('second invocation continuity', () => {
         });
         expect(runTask.mock.calls[0]?.[0].systemPrompt).toBeUndefined(); // no system prompt when resuming
     });
+    it('BrowserQA PLAYWRIGHT_UNAVAILABLE returns plainly and emits warning metadata', async () => {
+        const plugin = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const chatMessage = plugin['chat.message'];
+        // Register BrowserQA session
+        await chatMessage({ agent: ENGINEER_AGENT_IDS.BrowserQA, sessionID: 'wrapper-browserqa-1' });
+        const services = getOrCreatePluginServices(tempRoot);
+        // Mock dispatchEngineer to return PLAYWRIGHT_UNAVAILABLE sentinel
+        const unavailableMessage = 'PLAYWRIGHT_UNAVAILABLE: Playwright is not available in this environment. Consider installing it via npm.';
+        vi.spyOn(services.orchestrator, 'dispatchEngineer').mockResolvedValueOnce(makeDispatchResult({
+            engineer: 'BrowserQA',
+            finalText: unavailableMessage,
+        }));
+        vi.spyOn(services.orchestrator, 'recordWrapperExchange').mockResolvedValue(undefined);
+        const { metadata, ctx } = makeContext(tempRoot, ENGINEER_AGENT_IDS.BrowserQA, 'wrapper-browserqa-1');
+        const result = await executeClaude(plugin, ctx, {
+            mode: 'verify',
+            message: 'Check if browser is available',
+        });
+        // Result should contain the PLAYWRIGHT_UNAVAILABLE text plainly (not wrapped in error)
+        expect(result).toContain('PLAYWRIGHT_UNAVAILABLE');
+        expect(result).toContain('Playwright is not available');
+        // Verify warning metadata was emitted
+        expect(metadata).toHaveBeenCalled();
+        const calls = metadata.mock.calls;
+        const warningCall = calls.find((call) => {
+            const arg = call[0];
+            const title = arg?.title ?? '';
+            return (title.includes('Playwright') ||
+                title.includes('unavailable') ||
+                title.toLowerCase().includes('playwright unavailable'));
+        });
+        expect(warningCall).toBeDefined();
+    });
 });

package/dist/test/team-orchestrator.test.js

@@ -4,6 +4,15 @@ import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { TeamOrchestrator } from '../src/manager/team-orchestrator.js';
 import { TeamStateStore } from '../src/state/team-state-store.js';
+// Full BrowserQA capabilities used in all test orchestrator instances
+const BROWSER_QA_TEST_CAPS = {
+    sessionPrompt: 'Browser QA prompt',
+    restrictWriteTools: true,
+    skipModeInstructions: true,
+    plannerEligible: false,
+    isRuntimeUnavailableResponse: (text) => text.trimStart().startsWith('PLAYWRIGHT_UNAVAILABLE:'),
+    runtimeUnavailableTitle: '❌ Playwright unavailable',
+};
 describe('TeamOrchestrator', () => {
     let tempRoot;
     afterEach(async () => {
@@ -35,7 +44,7 @@ describe('TeamOrchestrator', () => {
             outputTokens: 300,
             contextWindowSize: 200_000,
         });
-        const orchestrator = new TeamOrchestrator({ runTask }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt');
+        const orchestrator = new TeamOrchestrator({ runTask }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
         const first = await orchestrator.dispatchEngineer({
             teamId: 'team-1',
             cwd: tempRoot,
@@ -79,7 +88,7 @@ describe('TeamOrchestrator', () => {
     it('rejects work when the same engineer is already busy', async () => {
         tempRoot = await mkdtemp(join(tmpdir(), 'team-orchestrator-'));
         const store = new TeamStateStore('.state');
-        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, store, { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt');
+        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, store, { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
         const team = await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
         await store.saveTeam({
             ...team,
@@ -117,7 +126,7 @@ describe('TeamOrchestrator', () => {
             events: [],
             finalText: '## Synthesis\nCombined plan\n## Recommended Question\nShould we migrate now?\n## Recommended Answer\nNo, defer it.',
         });
-        const orchestrator = new TeamOrchestrator({ runTask }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt');
+        const orchestrator = new TeamOrchestrator({ runTask }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
         const result = await orchestrator.planWithTeam({
             teamId: 'team-1',
             cwd: tempRoot,
@@ -166,7 +175,7 @@ describe('TeamOrchestrator', () => {
                 };
             }
         });
-        const orchestrator = new TeamOrchestrator({ runTask }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt');
+        const orchestrator = new TeamOrchestrator({ runTask }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
         const onLeadEvent = vi.fn();
         const onChallengerEvent = vi.fn();
         const onSynthesisEvent = vi.fn();
@@ -186,7 +195,7 @@ describe('TeamOrchestrator', () => {
     });
     it('persists wrapper session memory for an engineer', async () => {
         tempRoot = await mkdtemp(join(tmpdir(), 'team-orchestrator-'));
-        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt');
+        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
         await orchestrator.recordWrapperSession(tempRoot, 'team-1', 'Tom', 'wrapper-tom');
         await orchestrator.recordWrapperExchange(tempRoot, 'team-1', 'Tom', 'wrapper-tom', 'explore', 'Investigate the auth flow and compare approaches', 'The auth flow uses one shared validator and the cookie refresh path is the main risk.');
         const team = await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
@@ -240,7 +249,7 @@ describe('TeamOrchestrator', () => {
                 };
             }
         });
-        const orchestrator = new TeamOrchestrator({ runTask }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt');
+        const orchestrator = new TeamOrchestrator({ runTask }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
         const result = await orchestrator.planWithTeam({
             teamId: 'team-1',
             cwd: tempRoot,
@@ -253,7 +262,7 @@ describe('TeamOrchestrator', () => {
     });
     it('throws error when fewer than 2 viable engineers exist for planning', async () => {
         tempRoot = await mkdtemp(join(tmpdir(), 'team-orchestrator-'));
-        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt');
+        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
         // Mark all engineers as busy
         const team = await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
         for (const engineer of team.engineers) {
@@ -292,7 +301,7 @@ describe('TeamOrchestrator', () => {
                 contextWindowSize: 200_000,
             };
         });
-        const orchestrator = new TeamOrchestrator({ runTask }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt');
+        const orchestrator = new TeamOrchestrator({ runTask }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
         const allEvents = [];
         const result = await orchestrator.dispatchEngineer({
             teamId: 'team-1',
@@ -314,4 +323,34 @@ describe('TeamOrchestrator', () => {
         // Verify success result
         expect(result.finalText).toBe('Success after retry');
     });
+    it('rejects BrowserQA with implement mode', async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'browserqa-implement-'));
+        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
+        const error = await orchestrator
+            .dispatchEngineer({
+            teamId: 'team-1',
+            cwd: tempRoot,
+            engineer: 'BrowserQA',
+            mode: 'implement',
+            message: 'Write a feature',
+        })
+            .catch((e) => e);
+        expect(error).toBeInstanceOf(Error);
+        expect(error.message).toContain('BrowserQA is a browser QA specialist');
+        expect(error.message).toContain('does not support implement mode');
+    });
+    it('selectPlanEngineers excludes BrowserQA from planner selection', async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'planner-exclude-browserqa-'));
+        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
+        // Create a team with all engineers
+        await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
+        // Select plan engineers
+        const selection = await orchestrator.selectPlanEngineers(tempRoot, 'team-1');
+        // Both lead and challenger should be from general engineers only
+        const generalEngineers = ['Tom', 'John', 'Maya', 'Sara', 'Alex'];
+        expect(generalEngineers).toContain(selection.lead);
+        expect(generalEngineers).toContain(selection.challenger);
+        expect(selection.lead).not.toBe('BrowserQA');
+        expect(selection.challenger).not.toBe('BrowserQA');
+    });
 });

package/dist/test/team-state-store.test.js

@@ -51,22 +51,4 @@ describe('TeamStateStore', () => {
             { id: 'older' },
         ]);
     });
-    it('returns null for active team when no active-team.json exists', async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'team-store-'));
-        const store = new TeamStateStore('.state');
-        await expect(store.getActiveTeam(tempRoot)).resolves.toBeNull();
-    });
-    it('persists and reads back the active team ID', async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'team-store-'));
-        const store = new TeamStateStore('.state');
-        await store.setActiveTeam(tempRoot, 'team-abc');
-        await expect(store.getActiveTeam(tempRoot)).resolves.toBe('team-abc');
-    });
-    it('overwrites the active team ID on subsequent writes', async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'team-store-'));
-        const store = new TeamStateStore('.state');
-        await store.setActiveTeam(tempRoot, 'team-first');
-        await store.setActiveTeam(tempRoot, 'team-second');
-        await expect(store.getActiveTeam(tempRoot)).resolves.toBe('team-second');
-    });
 });