@doingdev/opencode-claude-manager-plugin 0.1.56 → 0.1.58

package/dist/src/team/roster.d.ts

@@ -1,5 +1,6 @@
-import { type EngineerName, type TeamEngineerRecord, type TeamRecord } from '../types/contracts.js';
-export declare const TEAM_ENGINEERS: readonly ["Tom", "John", "Maya", "Sara", "Alex"];
+import { PLANNER_ELIGIBLE_ENGINEERS, type EngineerName, type TeamEngineerRecord, type TeamRecord } from '../types/contracts.js';
+export declare const TEAM_ENGINEERS: readonly ["Tom", "John", "Maya", "Sara", "Alex", "BrowserQA"];
+export { PLANNER_ELIGIBLE_ENGINEERS };
 export declare function isEngineerName(value: string): value is EngineerName;
 export declare function createEmptyTeamRecord(teamId: string, cwd: string): TeamRecord;
 export declare function createEmptyEngineerRecord(name: EngineerName): TeamEngineerRecord;

package/dist/src/team/roster.js

@@ -1,5 +1,6 @@
-import { DEFAULT_ENGINEER_NAMES, } from '../types/contracts.js';
+import { DEFAULT_ENGINEER_NAMES, PLANNER_ELIGIBLE_ENGINEERS, } from '../types/contracts.js';
 export const TEAM_ENGINEERS = DEFAULT_ENGINEER_NAMES;
+export { PLANNER_ELIGIBLE_ENGINEERS };
 export function isEngineerName(value) {
     return TEAM_ENGINEERS.includes(value);
 }

package/dist/src/types/contracts.d.ts

@@ -2,10 +2,14 @@ export interface ManagerPromptRegistry {
     ctoSystemPrompt: string;
     engineerAgentPrompt: string;
     engineerSessionPrompt: string;
-    /** Prompt injected as the system prompt of the non-persistent synthesis runTask call inside plan_with_team. */
+    /** Prompt prepended to the user prompt of the synthesis runTask call inside plan_with_team. */
     planSynthesisPrompt: string;
     /** Visible subagent prompt for teamPlanner — thin bridge that calls plan_with_team. */
     teamPlannerPrompt: string;
+    /** Visible subagent prompt for browserQa — thin bridge that calls claude tool for browser verification. */
+    browserQaAgentPrompt: string;
+    /** Prompt prepended to browser verification task prompts in Claude Code sessions. */
+    browserQaSessionPrompt: string;
     contextWarnings: {
         moderate: string;
         high: string;
@@ -13,7 +17,8 @@ export interface ManagerPromptRegistry {
     };
 }
 export type SessionMode = 'plan' | 'free';
-export declare const DEFAULT_ENGINEER_NAMES: readonly ["Tom", "John", "Maya", "Sara", "Alex"];
+export declare const DEFAULT_ENGINEER_NAMES: readonly ["Tom", "John", "Maya", "Sara", "Alex", "BrowserQA"];
+export declare const PLANNER_ELIGIBLE_ENGINEERS: readonly ["Tom", "John", "Maya", "Sara", "Alex"];
 export type EngineerName = (typeof DEFAULT_ENGINEER_NAMES)[number];
 export type EngineerWorkMode = 'explore' | 'implement' | 'verify';
 export interface WrapperHistoryEntry {
@@ -164,6 +169,25 @@ export interface SynthesizedPlanResult {
     recommendedQuestion: string | null;
     recommendedAnswer: string | null;
 }
+/**
+ * Per-worker capability config for behavior that differs from the standard engineer path.
+ * Keyed by EngineerName in a Partial<Record<EngineerName, WorkerCapabilities>> map;
+ * absent entries use default behavior.
+ */
+export interface WorkerCapabilities {
+    /** Override the session system prompt for this worker. Absent = use standard engineer prompt. */
+    sessionPrompt?: string;
+    /** Always restrict write tools regardless of mode. Default: false. */
+    restrictWriteTools?: boolean;
+    /** Skip mode instructions in the task prompt. Default: false. */
+    skipModeInstructions?: boolean;
+    /** Allow this worker in plan_with_team. Absent or true = eligible. False = excluded. */
+    plannerEligible?: boolean;
+    /** Returns true if the final output indicates the required runtime is unavailable. */
+    isRuntimeUnavailableResponse?: (finalText: string) => boolean;
+    /** Metadata title for the runtime-unavailable event. */
+    runtimeUnavailableTitle?: string;
+}
 export interface GitDiffResult {
     hasDiff: boolean;
     diffText: string;

package/dist/src/types/contracts.js

@@ -1 +1,2 @@
-export const DEFAULT_ENGINEER_NAMES = ['Tom', 'John', 'Maya', 'Sara', 'Alex'];
+export const DEFAULT_ENGINEER_NAMES = ['Tom', 'John', 'Maya', 'Sara', 'Alex', 'BrowserQA'];
+export const PLANNER_ELIGIBLE_ENGINEERS = ['Tom', 'John', 'Maya', 'Sara', 'Alex'];

package/dist/team/roster.d.ts

@@ -1,5 +1,6 @@
-import { type EngineerName, type TeamEngineerRecord, type TeamRecord } from '../types/contracts.js';
-export declare const TEAM_ENGINEERS: readonly ["Tom", "John", "Maya", "Sara", "Alex"];
+import { PLANNER_ELIGIBLE_ENGINEERS, type EngineerName, type TeamEngineerRecord, type TeamRecord } from '../types/contracts.js';
+export declare const TEAM_ENGINEERS: readonly ["Tom", "John", "Maya", "Sara", "Alex", "BrowserQA"];
+export { PLANNER_ELIGIBLE_ENGINEERS };
 export declare function isEngineerName(value: string): value is EngineerName;
 export declare function createEmptyTeamRecord(teamId: string, cwd: string): TeamRecord;
 export declare function createEmptyEngineerRecord(name: EngineerName): TeamEngineerRecord;

package/dist/team/roster.js

@@ -1,5 +1,6 @@
-import { DEFAULT_ENGINEER_NAMES, } from '../types/contracts.js';
+import { DEFAULT_ENGINEER_NAMES, PLANNER_ELIGIBLE_ENGINEERS, } from '../types/contracts.js';
 export const TEAM_ENGINEERS = DEFAULT_ENGINEER_NAMES;
+export { PLANNER_ELIGIBLE_ENGINEERS };
 export function isEngineerName(value) {
     return TEAM_ENGINEERS.includes(value);
 }

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',
         });
     });
@@ -199,4 +201,72 @@ describe('Agent ID normalization and lookup helpers', () => {
         expect(isEngineerAgent('cto')).toBe(false);
         expect(isEngineerAgent('team-planner')).toBe(false);
     });
+    it('CTO agent config does not have direct assign_engineer access (delegates to named engineers)', async () => {
+        const { buildCtoAgentConfig } = await import('../src/plugin/agent-hierarchy.js');
+        const { managerPromptRegistry } = await import('../src/prompts/registry.js');
+        const ctoConfig = buildCtoAgentConfig(managerPromptRegistry);
+        const ctoPermissions = ctoConfig.permission;
+        // CTO should NOT have direct access to assign_engineer (uses task() to named engineers instead)
+        expect(ctoPermissions['assign_engineer']).not.toBe('allow');
+        // 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/prompt-registry.test.js

@@ -3,11 +3,13 @@ import { managerPromptRegistry } from '../src/prompts/registry.js';
 describe('managerPromptRegistry', () => {
     it('gives the CTO explicit orchestration guidance', () => {
         expect(managerPromptRegistry.ctoSystemPrompt).toContain('You are a principal engineer orchestrating a team of AI-powered engineers');
-        expect(managerPromptRegistry.ctoSystemPrompt).toContain('Task tool');
-        expect(managerPromptRegistry.ctoSystemPrompt).toContain('dual-engineer');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('Operating Loop');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('named engineer');
         expect(managerPromptRegistry.ctoSystemPrompt).toContain('team-planner');
         expect(managerPromptRegistry.ctoSystemPrompt).toContain('question');
-        expect(managerPromptRegistry.ctoSystemPrompt).toContain('Tom, John, Maya, Sara, and Alex');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('Review: Inspect diffs for production safety');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('race condition');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('contextExhausted');
         expect(managerPromptRegistry.ctoSystemPrompt).not.toContain('clear_session');
         expect(managerPromptRegistry.ctoSystemPrompt).not.toContain('freshSession');
     });
@@ -21,8 +23,10 @@ describe('managerPromptRegistry', () => {
     it('keeps the engineer session prompt direct and repo-aware', () => {
         expect(managerPromptRegistry.engineerSessionPrompt).toContain('expert software engineer');
         expect(managerPromptRegistry.engineerSessionPrompt).toContain('Start with the smallest investigation that resolves the key uncertainty');
-        expect(managerPromptRegistry.engineerSessionPrompt).toContain('Verify your own work');
+        expect(managerPromptRegistry.engineerSessionPrompt).toContain('Verify your work before reporting done');
         expect(managerPromptRegistry.engineerSessionPrompt).toContain('Do not run git commit');
+        expect(managerPromptRegistry.engineerSessionPrompt).toContain('rollout');
+        expect(managerPromptRegistry.engineerSessionPrompt).toContain('backwards compatibility');
     });
     it('keeps context warnings available for engineer sessions', () => {
         expect(managerPromptRegistry.contextWarnings.moderate).toContain('{percent}');
@@ -36,9 +40,30 @@ describe('managerPromptRegistry', () => {
         expect(managerPromptRegistry.planSynthesisPrompt).toContain('## Recommended Question');
         expect(managerPromptRegistry.planSynthesisPrompt).toContain('## Recommended Answer');
     });
-    it('teamPlannerPrompt directs the agent to call plan_with_team and ask if engineers are missing', () => {
+    it('teamPlannerPrompt directs the agent to call plan_with_team with autonomous engineer selection', () => {
         expect(managerPromptRegistry.teamPlannerPrompt).toContain('plan_with_team');
-        expect(managerPromptRegistry.teamPlannerPrompt).toContain('question');
+        expect(managerPromptRegistry.teamPlannerPrompt).toContain('auto-select');
         expect(managerPromptRegistry.teamPlannerPrompt).toContain('engineer');
     });
+    it('ctoSystemPrompt delegates single work to named engineers via task() and dual work to team-planner', () => {
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('task(subagent_type:');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('single-engineer');
+        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

@@ -12,6 +12,14 @@ import { clearPluginServices, getActiveTeamSession, getOrCreatePluginServices, }
 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
@@ -163,6 +171,19 @@ describe('reportClaudeEvent — via plugin onEvent chain', () => {
         expect(call.title).toBe('⚡ Maya → git_status');
         expect(call.metadata.toolArgs).toEqual({});
     });
+    it('surfaces status event as visible metadata', async () => {
+        const event = {
+            type: 'status',
+            text: 'Context exhausted; resetting session and retrying once with a fresh session.',
+        };
+        const { plugin } = await setupPlugin([event]);
+        const { metadata, ctx } = makeContext(tempRoot, ENGINEER_AGENT_IDS.Sara, 'wrapper-6');
+        await executeClaude(plugin, ctx);
+        const statusCall = metadata.mock.calls.find(([c]) => c?.title?.includes('ℹ️'))?.[0];
+        expect(statusCall).toBeDefined();
+        expect(statusCall.title).toBe('ℹ️ Sara: Context exhausted; resetting session and retrying once with a fresh session.');
+        expect(statusCall.metadata.status).toBe('Context exhausted; resetting session and retrying once with a fresh session.');
+    });
 });
 // ── Second-invocation continuity ─────────────────────────────────────────────
 describe('second invocation continuity', () => {
@@ -180,7 +201,7 @@ describe('second invocation continuity', () => {
         // ── Phase 1: first task via orchestrator (no real SDK needed) ──────────
         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 ───────────────────────────────────────────
@@ -206,7 +227,7 @@ describe('second invocation continuity', () => {
         // ── Phase 1: pre-seed Tom with a claudeSessionId ───────────────────────
         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,
@@ -243,4 +264,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');
@@ -203,4 +212,145 @@ describe('TeamOrchestrator', () => {
             engineer: 'Tom',
         });
     });
+    it('planWithTeam auto-selects two distinct engineers when names are omitted', async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'team-orchestrator-'));
+        const runTask = vi.fn(async (_input, _onEvent) => {
+            // Return different results for lead vs challenger
+            const calls = runTask.mock.calls.length;
+            if (calls === 1) {
+                return {
+                    sessionId: 'ses_lead',
+                    events: [],
+                    finalText: 'Lead plan',
+                    turns: 1,
+                    totalCostUsd: 0.01,
+                    inputTokens: 100,
+                    outputTokens: 50,
+                    contextWindowSize: 200_000,
+                };
+            }
+            else if (calls === 2) {
+                return {
+                    sessionId: 'ses_challenger',
+                    events: [],
+                    finalText: 'Challenger plan',
+                    turns: 1,
+                    totalCostUsd: 0.01,
+                    inputTokens: 100,
+                    outputTokens: 50,
+                    contextWindowSize: 200_000,
+                };
+            }
+            else {
+                return {
+                    sessionId: undefined,
+                    events: [],
+                    finalText: '## Synthesis\nBest plan\n## Recommended Question\nNONE\n## Recommended Answer\nNONE',
+                };
+            }
+        });
+        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,
+            request: 'Plan the refactor',
+            // NOTE: both leadEngineer and challengerEngineer are omitted
+        });
+        expect(result.leadEngineer).toBeDefined();
+        expect(result.challengerEngineer).toBeDefined();
+        expect(result.leadEngineer).not.toEqual(result.challengerEngineer);
+    });
+    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', { BrowserQA: BROWSER_QA_TEST_CAPS });
+        // Mark all engineers as busy
+        const team = await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
+        for (const engineer of team.engineers) {
+            await orchestrator['updateEngineer'](tempRoot, 'team-1', engineer.name, (e) => ({
+                ...e,
+                busy: true,
+                busySince: new Date().toISOString(),
+            }));
+        }
+        await expect(orchestrator.planWithTeam({
+            teamId: 'team-1',
+            cwd: tempRoot,
+            request: 'Plan something',
+        })).rejects.toThrow('Not enough available engineers for dual planning');
+    });
+    it('context exhaustion retries exactly once with same assignment message and fresh session', async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'team-orchestrator-'));
+        let callCount = 0;
+        let lastInputMessage = '';
+        const runTask = vi.fn(async (input) => {
+            callCount++;
+            lastInputMessage = input.prompt ?? '';
+            // First call throws context exhaustion, second succeeds
+            if (callCount === 1) {
+                const error = new Error('Token limit exceeded: context exhausted');
+                throw error;
+            }
+            return {
+                sessionId: 'ses_retry',
+                events: [],
+                finalText: 'Success after retry',
+                turns: 1,
+                totalCostUsd: 0.02,
+                inputTokens: 100,
+                outputTokens: 50,
+                contextWindowSize: 200_000,
+            };
+        });
+        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',
+            cwd: tempRoot,
+            engineer: 'Tom',
+            mode: 'implement',
+            message: 'Fix the bug',
+            onEvent: (event) => {
+                allEvents.push({ type: event.type, text: event.text });
+            },
+        });
+        // Verify retry happened exactly once (2 runTask calls total)
+        expect(callCount).toBe(2);
+        // Verify status event was emitted for context exhaustion
+        const statusEvent = allEvents.find((e) => e.type === 'status');
+        expect(statusEvent?.text).toContain('Context exhausted');
+        // Verify the retry message is the same (contains the original task)
+        expect(lastInputMessage).toContain('Fix the bug');
+        // 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/types/contracts.d.ts

@@ -2,10 +2,14 @@ export interface ManagerPromptRegistry {
     ctoSystemPrompt: string;
     engineerAgentPrompt: string;
     engineerSessionPrompt: string;
-    /** Prompt injected as the system prompt of the non-persistent synthesis runTask call inside plan_with_team. */
+    /** Prompt prepended to the user prompt of the synthesis runTask call inside plan_with_team. */
     planSynthesisPrompt: string;
     /** Visible subagent prompt for teamPlanner — thin bridge that calls plan_with_team. */
     teamPlannerPrompt: string;
+    /** Visible subagent prompt for browserQa — thin bridge that calls claude tool for browser verification. */
+    browserQaAgentPrompt: string;
+    /** Prompt prepended to browser verification task prompts in Claude Code sessions. */
+    browserQaSessionPrompt: string;
     contextWarnings: {
         moderate: string;
         high: string;
@@ -13,7 +17,8 @@ export interface ManagerPromptRegistry {
     };
 }
 export type SessionMode = 'plan' | 'free';
-export declare const DEFAULT_ENGINEER_NAMES: readonly ["Tom", "John", "Maya", "Sara", "Alex"];
+export declare const DEFAULT_ENGINEER_NAMES: readonly ["Tom", "John", "Maya", "Sara", "Alex", "BrowserQA"];
+export declare const PLANNER_ELIGIBLE_ENGINEERS: readonly ["Tom", "John", "Maya", "Sara", "Alex"];
 export type EngineerName = (typeof DEFAULT_ENGINEER_NAMES)[number];
 export type EngineerWorkMode = 'explore' | 'implement' | 'verify';
 export interface WrapperHistoryEntry {
@@ -164,6 +169,25 @@ export interface SynthesizedPlanResult {
     recommendedQuestion: string | null;
     recommendedAnswer: string | null;
 }
+/**
+ * Per-worker capability config for behavior that differs from the standard engineer path.
+ * Keyed by EngineerName in a Partial<Record<EngineerName, WorkerCapabilities>> map;
+ * absent entries use default behavior.
+ */
+export interface WorkerCapabilities {
+    /** Override the session system prompt for this worker. Absent = use standard engineer prompt. */
+    sessionPrompt?: string;
+    /** Always restrict write tools regardless of mode. Default: false. */
+    restrictWriteTools?: boolean;
+    /** Skip mode instructions in the task prompt. Default: false. */
+    skipModeInstructions?: boolean;
+    /** Allow this worker in plan_with_team. Absent or true = eligible. False = excluded. */
+    plannerEligible?: boolean;
+    /** Returns true if the final output indicates the required runtime is unavailable. */
+    isRuntimeUnavailableResponse?: (finalText: string) => boolean;
+    /** Metadata title for the runtime-unavailable event. */
+    runtimeUnavailableTitle?: string;
+}
 export interface GitDiffResult {
     hasDiff: boolean;
     diffText: string;

package/dist/types/contracts.js

@@ -1 +1,2 @@
-export const DEFAULT_ENGINEER_NAMES = ['Tom', 'John', 'Maya', 'Sara', 'Alex'];
+export const DEFAULT_ENGINEER_NAMES = ['Tom', 'John', 'Maya', 'Sara', 'Alex', 'BrowserQA'];
+export const PLANNER_ELIGIBLE_ENGINEERS = ['Tom', 'John', 'Maya', 'Sara', 'Alex'];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doingdev/opencode-claude-manager-plugin",
-  "version": "0.1.56",
+  "version": "0.1.58",
   "description": "OpenCode plugin that orchestrates Claude Code sessions.",
   "keywords": [
     "opencode",