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

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/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

@@ -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
@@ -193,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 ───────────────────────────────────────────
@@ -219,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,
@@ -256,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');
@@ -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/types/contracts.d.ts

@@ -6,6 +6,10 @@ export interface ManagerPromptRegistry {
     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.57",
+  "version": "0.1.58",
   "description": "OpenCode plugin that orchestrates Claude Code sessions.",
   "keywords": [
     "opencode",