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

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

@@ -2,7 +2,7 @@ import { tool } from '@opencode-ai/plugin';
 import { managerPromptRegistry } from '../prompts/registry.js';
 import { isEngineerName } from '../team/roster.js';
 import { TeamOrchestrator, createActionableError, getFailureGuidanceText, } from '../manager/team-orchestrator.js';
-import { AGENT_CTO, AGENT_TEAM_PLANNER, ENGINEER_AGENT_IDS, ENGINEER_AGENT_NAMES, buildCtoAgentConfig, buildEngineerAgentConfig, buildTeamPlannerAgentConfig, denyRestrictedToolsGlobally, } from './agent-hierarchy.js';
+import { AGENT_BROWSER_QA, AGENT_CTO, AGENT_TEAM_PLANNER, buildBrowserQaAgentConfig, buildCtoAgentConfig, buildEngineerAgentConfig, buildTeamPlannerAgentConfig, denyRestrictedToolsGlobally, ENGINEER_AGENT_IDS, ENGINEER_AGENT_NAMES, } from './agents/index.js';
 import { getActiveTeamSession, getOrCreatePluginServices, getPersistedActiveTeam, getWrapperSessionMapping, setActiveTeamSession, setPersistedActiveTeam, setWrapperSessionMapping, } from './service-factory.js';
 const MODEL_ENUM = ['claude-opus-4-6', 'claude-sonnet-4-6'];
 const MODE_ENUM = ['explore', 'implement', 'verify'];
@@ -16,6 +16,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
             denyRestrictedToolsGlobally(config.permission);
             config.agent[AGENT_CTO] ??= buildCtoAgentConfig(managerPromptRegistry);
             config.agent[AGENT_TEAM_PLANNER] ??= buildTeamPlannerAgentConfig(managerPromptRegistry);
+            config.agent[AGENT_BROWSER_QA] ??= buildBrowserQaAgentConfig(managerPromptRegistry);
             for (const engineer of ENGINEER_AGENT_NAMES) {
                 config.agent[ENGINEER_AGENT_IDS[engineer]] ??= buildEngineerAgentConfig(managerPromptRegistry, engineer);
             }
@@ -41,7 +42,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                 const teamId = persisted?.teamId ?? (await resolveTeamId(worktree, input.sessionID));
                 setWrapperSessionMapping(worktree, input.sessionID, {
                     teamId,
-                    engineer,
+                    workerName: engineer,
                 });
                 await services.orchestrator.recordWrapperSession(worktree, teamId, engineer, input.sessionID);
             }
@@ -50,26 +51,37 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
             if (!input.sessionID) {
                 return;
             }
-            const existing = getWrapperSessionMapping(worktree, input.sessionID);
-            const persisted = existing ??
-                (await services.orchestrator.findTeamByWrapperSession(worktree, input.sessionID));
-            if (!persisted) {
+            // Try in-memory mapping first
+            let mapping = getWrapperSessionMapping(worktree, input.sessionID);
+            // Fall back to persisted lookup if in-memory mapping is absent
+            if (!mapping) {
+                // Check if this is an engineer wrapper session
+                const engineerMatch = await services.orchestrator.findTeamByWrapperSession(worktree, input.sessionID);
+                if (engineerMatch) {
+                    mapping = {
+                        teamId: engineerMatch.teamId,
+                        workerName: engineerMatch.engineer,
+                    };
+                }
+            }
+            if (!mapping) {
                 return;
             }
-            const wrapperContext = await services.orchestrator.getWrapperSystemContext(worktree, persisted.teamId, persisted.engineer);
+            const wrapperContext = await services.orchestrator.getWrapperSystemContext(worktree, mapping.teamId, mapping.workerName);
             if (wrapperContext) {
                 output.system.push(wrapperContext);
             }
         },
         tool: {
             claude: tool({
-                description: "Run work through this named engineer's persistent Claude Code session. The session remembers prior turns for this engineer.",
+                description: "Run work through a named engineer's persistent Claude Code session. Engineers include general developers (Tom, John, Maya, Sara, Alex) and specialists like browser-qa. The session remembers prior turns.",
                 args: {
                     mode: tool.schema.enum(MODE_ENUM),
                     message: tool.schema.string().min(1),
                     model: tool.schema.enum(MODEL_ENUM).optional(),
                 },
                 async execute(args, context) {
+                    // Handle engineer agents (includes BrowserQA)
                     const engineer = engineerFromAgent(context.agent);
                     const existing = getWrapperSessionMapping(context.worktree, context.sessionID);
                     const persisted = existing ??
@@ -77,7 +89,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     const teamId = persisted?.teamId ?? (await resolveTeamId(context.worktree, context.sessionID));
                     setWrapperSessionMapping(context.worktree, context.sessionID, {
                         teamId,
-                        engineer,
+                        workerName: engineer,
                     });
                     await services.orchestrator.recordWrapperSession(context.worktree, teamId, engineer, context.sessionID);
                     const result = await runEngineerAssignment({
@@ -87,6 +99,15 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                         message: args.message,
                         model: args.model,
                     }, context);
+                    const capabilities = services.workerCapabilities[engineer];
+                    if (capabilities?.isRuntimeUnavailableResponse?.(result.finalText)) {
+                        const lines = result.finalText.split('\n');
+                        const unavailableLine = lines[0] ?? 'Playwright unavailable (reason unknown)';
+                        context.metadata({
+                            title: capabilities.runtimeUnavailableTitle ?? '❌ Playwright unavailable',
+                            metadata: { unavailable: unavailableLine },
+                        });
+                    }
                     return result.finalText;
                 },
             }),
@@ -152,7 +173,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
             reset_engineer: tool({
                 description: 'Reset a stuck or corrupted engineer. Clears the busy flag. Optionally clears the Claude session (starts fresh) and/or wrapper history.',
                 args: {
-                    engineer: tool.schema.enum(['Tom', 'John', 'Maya', 'Sara', 'Alex']),
+                    engineer: tool.schema.enum(['Tom', 'John', 'Maya', 'Sara', 'Alex', 'BrowserQA']),
                     clearSession: tool.schema.boolean().optional(),
                     clearHistory: tool.schema.boolean().optional(),
                 },
@@ -497,12 +518,13 @@ function formatToolDescription(toolName, toolArgs) {
             return undefined;
     }
 }
-function reportClaudeEvent(context, engineer, event) {
+function reportClaudeEvent(context, workerName, event) {
+    const baseMetadata = { workerName, engineer: workerName };
     if (event.type === 'error') {
         context.metadata({
-            title: `❌ ${engineer} hit an error`,
+            title: `❌ ${workerName} hit an error`,
             metadata: {
-                engineer,
+                ...baseMetadata,
                 sessionId: event.sessionId,
                 error: event.text.slice(0, 200),
             },
@@ -511,9 +533,9 @@ function reportClaudeEvent(context, engineer, event) {
     }
     if (event.type === 'status') {
         context.metadata({
-            title: `ℹ️ ${engineer}: ${event.text}`,
+            title: `ℹ️ ${workerName}: ${event.text}`,
             metadata: {
-                engineer,
+                ...baseMetadata,
                 status: event.text,
             },
         });
@@ -521,9 +543,9 @@ function reportClaudeEvent(context, engineer, event) {
     }
     if (event.type === 'init') {
         context.metadata({
-            title: `⚡ ${engineer} session ready`,
+            title: `⚡ ${workerName} session ready`,
             metadata: {
-                engineer,
+                ...baseMetadata,
                 sessionId: event.sessionId,
             },
         });
@@ -557,12 +579,12 @@ function reportClaudeEvent(context, engineer, event) {
         const toolDescription = formatToolDescription(toolName ?? '', toolArgs);
         context.metadata({
             title: toolDescription
-                ? `⚡ ${engineer} → ${toolDescription}`
+                ? `⚡ ${workerName} → ${toolDescription}`
                 : toolName
-                    ? `⚡ ${engineer} → ${toolName}`
-                    : `⚡ ${engineer} is using Claude Code tools`,
+                    ? `⚡ ${workerName} → ${toolName}`
+                    : `⚡ ${workerName} is using Claude Code tools`,
             metadata: {
-                engineer,
+                ...baseMetadata,
                 sessionId: event.sessionId,
                 ...(toolName !== undefined && { toolName }),
                 ...(toolId !== undefined && { toolId }),
@@ -575,9 +597,9 @@ function reportClaudeEvent(context, engineer, event) {
         const isThinking = event.text.startsWith('<thinking>');
         const stateLabel = event.type === 'partial' && isThinking ? 'is thinking' : 'is working';
         context.metadata({
-            title: `⚡ ${engineer} ${stateLabel}`,
+            title: `⚡ ${workerName} ${stateLabel}`,
             metadata: {
-                engineer,
+                ...baseMetadata,
                 sessionId: event.sessionId,
                 preview: event.text.slice(0, 160),
                 isThinking,

package/dist/plugin/service-factory.d.ts

@@ -3,13 +3,14 @@ import { ToolApprovalManager } from '../claude/tool-approval-manager.js';
 import { PersistentManager } from '../manager/persistent-manager.js';
 import { TeamOrchestrator } from '../manager/team-orchestrator.js';
 import { TeamStateStore } from '../state/team-state-store.js';
-import type { EngineerName } from '../types/contracts.js';
+import type { EngineerName, WorkerCapabilities } from '../types/contracts.js';
 interface ClaudeManagerPluginServices {
     manager: PersistentManager;
     sessions: ClaudeSessionService;
     approvalManager: ToolApprovalManager;
     teamStore: TeamStateStore;
     orchestrator: TeamOrchestrator;
+    workerCapabilities: Partial<Record<EngineerName, WorkerCapabilities>>;
 }
 export declare function getOrCreatePluginServices(worktree: string): ClaudeManagerPluginServices;
 export declare function clearPluginServices(): void;
@@ -19,10 +20,10 @@ export declare function getPersistedActiveTeam(worktree: string): Promise<string
 export declare function setPersistedActiveTeam(worktree: string, teamId: string): Promise<void>;
 export declare function setWrapperSessionMapping(worktree: string, wrapperSessionId: string, mapping: {
     teamId: string;
-    engineer: EngineerName;
+    workerName: EngineerName;
 }): void;
 export declare function getWrapperSessionMapping(worktree: string, wrapperSessionId: string): {
     teamId: string;
-    engineer: EngineerName;
+    workerName: EngineerName;
 } | null;
 export {};

package/dist/plugin/service-factory.js

@@ -8,6 +8,7 @@ import { TeamOrchestrator } from '../manager/team-orchestrator.js';
 import { managerPromptRegistry } from '../prompts/registry.js';
 import { TeamStateStore } from '../state/team-state-store.js';
 import { TranscriptStore } from '../state/transcript-store.js';
+import { buildWorkerCapabilities } from './agents/browser-qa.js';
 const serviceRegistry = new Map();
 const activeTeamRegistry = new Map();
 const wrapperSessionRegistry = new Map();
@@ -24,13 +25,15 @@ export function getOrCreatePluginServices(worktree) {
     const teamStore = new TeamStateStore();
     const transcriptStore = new TranscriptStore();
     const manager = new PersistentManager(gitOps, transcriptStore);
-    const orchestrator = new TeamOrchestrator(sessionService, teamStore, transcriptStore, managerPromptRegistry.engineerSessionPrompt, managerPromptRegistry.planSynthesisPrompt);
+    const workerCapabilities = buildWorkerCapabilities(managerPromptRegistry);
+    const orchestrator = new TeamOrchestrator(sessionService, teamStore, transcriptStore, managerPromptRegistry.engineerSessionPrompt, managerPromptRegistry.planSynthesisPrompt, workerCapabilities);
     const services = {
         manager,
         sessions: sessionService,
         approvalManager,
         teamStore,
         orchestrator,
+        workerCapabilities,
     };
     serviceRegistry.set(worktree, services);
     return services;

package/dist/prompts/registry.js

@@ -30,9 +30,10 @@ export const managerPromptRegistry = {
         '## Delegate: Send precise assignments',
         "- For single-engineer work: use `task(subagent_type: 'tom'|'john'|'maya'|'sara'|'alex', ...)` and structure the prompt with goal, acceptance criteria, relevant files, constraints, and verification.",
         "- For dual-engineer planning: use `task(subagent_type: 'team-planner', ...)` which will lead + challenger synthesis.",
-        '- Each assignment includes: goal, acceptance criteria, relevant files/areas, constraints, and verification method.',
+        "- For browser/UI verification: use `task(subagent_type: 'browser-qa', ...)` with a clear verification goal. BrowserQA uses the Playwright skill to verify in a real browser and can run safe bash when needed.",
+        '- Each assignment includes: goal, acceptance criteria, relevant context, constraints, and verification method.',
         '- Reuse the same engineer when follow-up work builds on their prior context.',
-        '- Only one implementing engineer modifies the worktree at a time. Parallelize exploration and research freely.',
+        '- Only one implementing engineer modifies the worktree at a time. Parallelize exploration, research, and browser verification freely.',
         '',
         '## Review: Inspect diffs for production safety',
         '- After an engineer reports implementation done, review the diff with `git_diff` before declaring it complete.',
@@ -149,6 +150,40 @@ export const managerPromptRegistry = {
         '- If either name is missing, `plan_with_team` will auto-select two non-overlapping engineers based on availability and context.',
         'Do not attempt any planning or analysis yourself. Delegate entirely to `plan_with_team`.',
     ].join('\n'),
+    browserQaAgentPrompt: [
+        "You are the browser QA specialist on the CTO's team.",
+        'Your job is to run browser verification tasks through the `claude` tool.',
+        'The CTO will send tasks requesting you to test a website or web feature using the Playwright skill/command.',
+        '',
+        'How to handle verification tasks:',
+        '- Extract the verification goal and relevant context from the prompt.',
+        '- Use the `claude` tool with mode: "verify" and request Claude Code to use the Playwright skill/command.',
+        '- Instruct Claude Code: "Use the Playwright skill/command for real browser testing. If unavailable, report PLAYWRIGHT_UNAVAILABLE: <reason> and stop."',
+        '- Return the tool result directly—do not add commentary unless something unexpected occurred.',
+        '',
+        'Important:',
+        '- Never simulate or fabricate test results.',
+        '- If the Playwright tool is not available, the result will start with PLAYWRIGHT_UNAVAILABLE:.',
+        '- Your persistent Claude Code session remembers prior verification runs.',
+    ].join('\n'),
+    browserQaSessionPrompt: [
+        'You are a browser QA specialist. Your job is to verify web features and user flows using the Playwright skill/command.',
+        '',
+        'For each verification task:',
+        '1. Use the Playwright skill/command to control a real browser.',
+        '2. Navigate to the specified URL, interact with the UI, and verify the expected behavior.',
+        '3. Take screenshots and collect specific error messages if verification fails.',
+        '4. Report results concisely: what was tested, pass/fail status, any errors or unexpected behavior.',
+        '',
+        'CRITICAL: If the Playwright skill or command is unavailable (not installed, command not found, skill not loaded):',
+        '- Output EXACTLY as the first line of your response:',
+        '  PLAYWRIGHT_UNAVAILABLE: <specific reason>',
+        '- Do not attempt to verify by other means.',
+        '- Do not simulate or fabricate test results.',
+        '- Stop after reporting unavailability.',
+        '',
+        'Allowed tools: Playwright skill/command, safe bash, read-only tools (Read, Grep, Glob). No file editing or code modifications.',
+    ].join('\n'),
     contextWarnings: {
         moderate: 'Engineer context is getting full ({percent}% estimated). Reuse is still fine, but keep the next prompt focused.',
         high: 'Engineer context is heavy ({percent}% estimated, {turns} turns, ${cost}). Prefer a narrowly scoped follow-up or internal compaction.',

package/dist/src/manager/team-orchestrator.d.ts

@@ -2,7 +2,7 @@ import type { ClaudeSessionEventHandler } from '../claude/claude-agent-sdk-adapt
 import type { ClaudeSessionService } from '../claude/claude-session.service.js';
 import type { TeamStateStore } from '../state/team-state-store.js';
 import type { TranscriptStore } from '../state/transcript-store.js';
-import type { EngineerFailureResult, EngineerName, EngineerTaskResult, EngineerWorkMode, SynthesizedPlanResult, TeamRecord } from '../types/contracts.js';
+import type { EngineerFailureResult, EngineerName, EngineerTaskResult, EngineerWorkMode, SynthesizedPlanResult, TeamRecord, WorkerCapabilities } from '../types/contracts.js';
 interface DispatchEngineerInput {
     teamId: string;
     cwd: string;
@@ -19,7 +19,8 @@ export declare class TeamOrchestrator {
     private readonly transcriptStore;
     private readonly engineerSessionPrompt;
     private readonly planSynthesisPrompt;
-    constructor(sessions: ClaudeSessionService, teamStore: TeamStateStore, transcriptStore: TranscriptStore, engineerSessionPrompt: string, planSynthesisPrompt: string);
+    private readonly workerCapabilities;
+    constructor(sessions: ClaudeSessionService, teamStore: TeamStateStore, transcriptStore: TranscriptStore, engineerSessionPrompt: string, planSynthesisPrompt: string, workerCapabilities: Partial<Record<EngineerName, WorkerCapabilities>>);
     getOrCreateTeam(cwd: string, teamId: string): Promise<TeamRecord>;
     listTeams(cwd: string): Promise<TeamRecord[]>;
     recordWrapperSession(cwd: string, teamId: string, engineer: EngineerName, wrapperSessionId: string): Promise<void>;

package/dist/src/manager/team-orchestrator.js

@@ -7,12 +7,14 @@ export class TeamOrchestrator {
     transcriptStore;
     engineerSessionPrompt;
     planSynthesisPrompt;
-    constructor(sessions, teamStore, transcriptStore, engineerSessionPrompt, planSynthesisPrompt) {
+    workerCapabilities;
+    constructor(sessions, teamStore, transcriptStore, engineerSessionPrompt, planSynthesisPrompt, workerCapabilities) {
         this.sessions = sessions;
         this.teamStore = teamStore;
         this.transcriptStore = transcriptStore;
         this.engineerSessionPrompt = engineerSessionPrompt;
         this.planSynthesisPrompt = planSynthesisPrompt;
+        this.workerCapabilities = workerCapabilities;
     }
     async getOrCreateTeam(cwd, teamId) {
         const existing = await this.teamStore.getTeam(cwd, teamId);
@@ -89,6 +91,13 @@ export class TeamOrchestrator {
         }));
     }
     async dispatchEngineer(input, retryCount = 0) {
+        const workerCaps = this.workerCapabilities[input.engineer];
+        // Reject write-restricted workers in implement mode
+        if (workerCaps?.restrictWriteTools && input.mode === 'implement') {
+            throw new Error(`${input.engineer} is a browser QA specialist and does not support implement mode. ` +
+                'It can only verify and explore (test browser interactions via Playwright). ' +
+                'For code changes, use a general engineer (Tom, John, Maya, Sara, Alex).');
+        }
         const team = await this.getOrCreateTeam(input.cwd, input.teamId);
         const engineerState = this.getEngineerState(team, input.engineer);
         await this.reserveEngineer(input.cwd, input.teamId, input.engineer);
@@ -107,15 +116,19 @@ export class TeamOrchestrator {
             const result = await this.sessions.runTask({
                 cwd: input.cwd,
                 prompt: engineerState.claudeSessionId
-                    ? this.buildEngineerPrompt(input.mode, input.message)
-                    : `${this.buildSessionSystemPrompt(input.engineer, input.mode)}\n\n${this.buildEngineerPrompt(input.mode, input.message)}`,
+                    ? this.buildEngineerPrompt(input.mode, input.message, input.engineer)
+                    : `${this.buildSessionSystemPrompt(input.engineer, input.mode)}\n\n${this.buildEngineerPrompt(input.mode, input.message, input.engineer)}`,
                 resumeSessionId: engineerState.claudeSessionId ?? undefined,
                 persistSession: true,
                 includePartialMessages: true,
                 permissionMode: 'acceptEdits',
-                restrictWriteTools: input.mode === 'explore',
+                restrictWriteTools: input.mode === 'explore' || (workerCaps?.restrictWriteTools ?? false),
                 model: input.model,
-                effort: input.mode === 'implement' ? 'high' : 'medium',
+                effort: (workerCaps?.restrictWriteTools ?? false)
+                    ? 'medium'
+                    : input.mode === 'implement'
+                        ? 'high'
+                        : 'medium',
                 settingSources: ['user', 'project', 'local'],
                 abortSignal: input.abortSignal,
             }, input.onEvent);
@@ -321,9 +334,10 @@ export class TeamOrchestrator {
     }
     normalizeTeamRecord(team) {
         const engineerMap = new Map(team.engineers.map((engineer) => [engineer.name, engineer]));
+        const emptyTeam = createEmptyTeamRecord(team.id, team.cwd);
         return {
             ...team,
-            engineers: createEmptyTeamRecord(team.id, team.cwd).engineers.map((engineer) => engineerMap.get(engineer.name) ?? engineer),
+            engineers: emptyTeam.engineers.map((engineer) => engineerMap.get(engineer.name) ?? engineer),
         };
     }
     getAvailableEngineers(team) {
@@ -355,9 +369,11 @@ export class TeamOrchestrator {
     }
     async selectPlanEngineers(cwd, teamId, preferredLead, preferredChallenger) {
         const team = await this.getOrCreateTeam(cwd, teamId);
-        const available = this.getAvailableEngineers(team);
+        const allAvailable = this.getAvailableEngineers(team);
+        // Filter to only planner-eligible engineers (specialists with plannerEligible: false are excluded)
+        const available = allAvailable.filter((e) => this.workerCapabilities[e]?.plannerEligible !== false);
         if (available.length < 2) {
-            throw new Error(`Not enough available engineers for dual planning. Need 2, found ${available.length}.`);
+            throw new Error(`Not enough available engineers for dual planning. Need 2 general engineers (specialists excluded), found ${available.length}.`);
         }
         const lead = preferredLead ?? available[0];
         const foundChallenger = preferredChallenger ?? available.find((e) => e !== lead);
@@ -368,6 +384,10 @@ export class TeamOrchestrator {
         return { lead, challenger };
     }
     buildSessionSystemPrompt(engineer, mode) {
+        const specialistPrompt = this.workerCapabilities[engineer]?.sessionPrompt;
+        if (specialistPrompt) {
+            return specialistPrompt;
+        }
         return [
             this.engineerSessionPrompt,
             '',
@@ -377,7 +397,10 @@ export class TeamOrchestrator {
             .join('\n')
             .trim();
     }
-    buildEngineerPrompt(mode, message) {
+    buildEngineerPrompt(mode, message, engineer) {
+        if (this.workerCapabilities[engineer]?.skipModeInstructions) {
+            return message;
+        }
         return `${buildModeInstruction(mode)}\n\n${message}`;
     }
 }

package/dist/src/plugin/agent-hierarchy.d.ts

@@ -1,54 +1 @@
-import type { EngineerName, ManagerPromptRegistry } from '../types/contracts.js';
-export declare const AGENT_CTO = "cto";
-export declare const AGENT_TEAM_PLANNER = "team-planner";
-export declare const ENGINEER_AGENT_IDS: {
-    readonly Tom: "tom";
-    readonly John: "john";
-    readonly Maya: "maya";
-    readonly Sara: "sara";
-    readonly Alex: "alex";
-};
-export declare const ENGINEER_AGENT_NAMES: readonly ["Tom", "John", "Maya", "Sara", "Alex"];
-type ToolPermission = 'allow' | 'ask' | 'deny';
-type AgentPermission = {
-    '*'?: ToolPermission;
-    read?: ToolPermission;
-    grep?: ToolPermission;
-    glob?: ToolPermission;
-    list?: ToolPermission;
-    codesearch?: ToolPermission;
-    webfetch?: ToolPermission;
-    websearch?: ToolPermission;
-    lsp?: ToolPermission;
-    todowrite?: ToolPermission;
-    todoread?: ToolPermission;
-    question?: ToolPermission;
-    task?: ToolPermission | Record<string, ToolPermission>;
-    bash?: ToolPermission | Record<string, ToolPermission>;
-    [tool: string]: ToolPermission | Record<string, ToolPermission> | undefined;
-};
-export declare function buildCtoAgentConfig(prompts: ManagerPromptRegistry): {
-    description: string;
-    mode: "primary";
-    color: string;
-    permission: AgentPermission;
-    prompt: string;
-};
-export declare function buildEngineerAgentConfig(prompts: ManagerPromptRegistry, engineer: EngineerName): {
-    description: string;
-    mode: "subagent";
-    hidden: boolean;
-    color: string;
-    permission: AgentPermission;
-    prompt: string;
-};
-export declare function buildTeamPlannerAgentConfig(prompts: ManagerPromptRegistry): {
-    description: string;
-    mode: "subagent";
-    hidden: boolean;
-    color: string;
-    permission: AgentPermission;
-    prompt: string;
-};
-export declare function denyRestrictedToolsGlobally(permissions: Record<string, ToolPermission>): void;
-export {};
+export * from './agents/index.js';

package/dist/src/plugin/agent-hierarchy.js

@@ -1,123 +1,2 @@
-import { TEAM_ENGINEERS } from '../team/roster.js';
-export const AGENT_CTO = 'cto';
-export const AGENT_TEAM_PLANNER = 'team-planner';
-export const ENGINEER_AGENT_IDS = {
-    Tom: 'tom',
-    John: 'john',
-    Maya: 'maya',
-    Sara: 'sara',
-    Alex: 'alex',
-};
-export const ENGINEER_AGENT_NAMES = TEAM_ENGINEERS;
-const CTO_ONLY_TOOL_IDS = [
-    'team_status',
-    'reset_engineer',
-    'list_transcripts',
-    'list_history',
-    'git_diff',
-    'git_commit',
-    'git_reset',
-    'git_status',
-    'git_log',
-    'approval_policy',
-    'approval_decisions',
-    'approval_update',
-];
-const ENGINEER_TOOL_IDS = ['claude'];
-const ALL_RESTRICTED_TOOL_IDS = [...CTO_ONLY_TOOL_IDS, ...ENGINEER_TOOL_IDS];
-const CTO_READONLY_TOOLS = {
-    read: 'allow',
-    grep: 'allow',
-    glob: 'allow',
-    list: 'allow',
-    codesearch: 'allow',
-    webfetch: 'allow',
-    websearch: 'allow',
-    lsp: 'allow',
-    todowrite: 'allow',
-    todoread: 'allow',
-    question: 'allow',
-};
-function buildTeamPlannerPermissions() {
-    const denied = {};
-    for (const toolId of ALL_RESTRICTED_TOOL_IDS) {
-        denied[toolId] = 'deny';
-    }
-    return {
-        '*': 'deny',
-        plan_with_team: 'allow',
-        question: 'allow',
-        ...denied,
-    };
-}
-function buildCtoPermissions() {
-    const denied = {};
-    for (const toolId of ALL_RESTRICTED_TOOL_IDS) {
-        denied[toolId] = 'deny';
-    }
-    const allowed = {};
-    for (const toolId of CTO_ONLY_TOOL_IDS) {
-        allowed[toolId] = 'allow';
-    }
-    const taskPermissions = { '*': 'deny' };
-    for (const engineer of ENGINEER_AGENT_NAMES) {
-        const agentId = ENGINEER_AGENT_IDS[engineer];
-        // Support both uppercase (user-friendly) and lowercase (canonical) agent IDs.
-        // This ensures both task({ subagent_type: 'Tom' }) and task({ subagent_type: 'tom' }) work.
-        taskPermissions[engineer] = 'allow'; // 'Tom', 'John', etc.
-        taskPermissions[agentId] = 'allow'; // 'tom', 'john', etc.
-    }
-    taskPermissions[AGENT_TEAM_PLANNER] = 'allow';
-    return {
-        '*': 'deny',
-        ...CTO_READONLY_TOOLS,
-        ...denied,
-        ...allowed,
-        task: taskPermissions,
-    };
-}
-function buildEngineerPermissions() {
-    const denied = {};
-    for (const toolId of ALL_RESTRICTED_TOOL_IDS) {
-        denied[toolId] = 'deny';
-    }
-    return {
-        '*': 'deny',
-        ...denied,
-        claude: 'allow',
-    };
-}
-export function buildCtoAgentConfig(prompts) {
-    return {
-        description: 'Principal engineer who orchestrates AI-powered engineers. Decomposes work, asks clarifying questions, delegates precisely, reviews diffs, and owns the outcome.',
-        mode: 'primary',
-        color: '#D97757',
-        permission: buildCtoPermissions(),
-        prompt: prompts.ctoSystemPrompt,
-    };
-}
-export function buildEngineerAgentConfig(prompts, engineer) {
-    return {
-        description: `${engineer} is a persistent engineer who works through one Claude Code session and remembers prior turns. Receives structured assignments (goal, mode, context, acceptance criteria, relevant paths, constraints, verification).`,
-        mode: 'subagent',
-        hidden: false,
-        color: '#D97757',
-        permission: buildEngineerPermissions(),
-        prompt: `You are ${engineer}.\n\n${prompts.engineerAgentPrompt}`,
-    };
-}
-export function buildTeamPlannerAgentConfig(prompts) {
-    return {
-        description: 'Runs dual-engineer planning by calling plan_with_team. Automatically selects two non-overlapping available engineers if engineer names are not provided.',
-        mode: 'subagent',
-        hidden: false,
-        color: '#D97757',
-        permission: buildTeamPlannerPermissions(),
-        prompt: prompts.teamPlannerPrompt,
-    };
-}
-export function denyRestrictedToolsGlobally(permissions) {
-    for (const toolId of ALL_RESTRICTED_TOOL_IDS) {
-        permissions[toolId] ??= 'deny';
-    }
-}
+// Re-export barrel — all symbols now live in src/plugin/agents/.
+export * from './agents/index.js';

package/dist/src/plugin/agents/browser-qa.d.ts

@@ -0,0 +1,14 @@
+import type { EngineerName, ManagerPromptRegistry, WorkerCapabilities } from '../../types/contracts.js';
+/**
+ * Build the worker capabilities map for all specialist workers.
+ * Called once at service-factory construction time to avoid re-building on each tool call.
+ */
+export declare function buildWorkerCapabilities(prompts: ManagerPromptRegistry): Partial<Record<EngineerName, WorkerCapabilities>>;
+export declare function buildBrowserQaAgentConfig(prompts: ManagerPromptRegistry): {
+    description: string;
+    mode: "subagent";
+    hidden: boolean;
+    color: string;
+    permission: import("./common.js").AgentPermission;
+    prompt: string;
+};

package/dist/src/plugin/agents/browser-qa.js

@@ -0,0 +1,27 @@
+import { buildEngineerPermissions } from './common.js';
+/**
+ * Build the worker capabilities map for all specialist workers.
+ * Called once at service-factory construction time to avoid re-building on each tool call.
+ */
+export function buildWorkerCapabilities(prompts) {
+    return {
+        BrowserQA: {
+            sessionPrompt: prompts.browserQaSessionPrompt,
+            restrictWriteTools: true,
+            skipModeInstructions: true,
+            plannerEligible: false,
+            isRuntimeUnavailableResponse: (text) => text.trimStart().startsWith('PLAYWRIGHT_UNAVAILABLE:'),
+            runtimeUnavailableTitle: '❌ Playwright unavailable',
+        },
+    };
+}
+export function buildBrowserQaAgentConfig(prompts) {
+    return {
+        description: 'Browser QA specialist who uses the Playwright skill/command to test web features and user flows. Maintains a persistent Claude Code session that remembers prior verification runs.',
+        mode: 'subagent',
+        hidden: false,
+        color: '#D97757',
+        permission: buildEngineerPermissions(), // Same permissions as engineers (claude tool only)
+        prompt: prompts.browserQaAgentPrompt,
+    };
+}