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

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

@@ -2,13 +2,47 @@ 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 { getActiveTeamSession, getOrCreatePluginServices, getPersistedActiveTeam, getWrapperSessionMapping, setActiveTeamSession, setPersistedActiveTeam, setWrapperSessionMapping, } from './service-factory.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 { getOrCreatePluginServices, getParentSessionId, getSessionTeam, getWrapperSessionMapping, registerParentSession, registerSessionTeam, setWrapperSessionMapping, } from './service-factory.js';
 const MODEL_ENUM = ['claude-opus-4-6', 'claude-sonnet-4-6'];
 const MODE_ENUM = ['explore', 'implement', 'verify'];
-export const ClaudeManagerPlugin = async ({ worktree }) => {
+export const ClaudeManagerPlugin = async ({ worktree, client }) => {
     const services = getOrCreatePluginServices(worktree);
     await services.approvalManager.loadPersistedPolicy();
+    /**
+     * Resolves the team ID for a brand-new engineer wrapper session.
+     *
+     * 1. Walk the cached parentID chain (populated by session.created events).
+     * 2. On a cache miss, attempt a live client.session.get() lookup and cache
+     *    whatever parentID the SDK returns.
+     * 3. Fall back to the orphan sentinel (sessionID itself) only when both
+     *    cache and live lookup come up empty.
+     */
+    async function resolveTeamId(sessionID) {
+        let current = sessionID;
+        const seen = new Set();
+        while (current && !seen.has(current)) {
+            seen.add(current);
+            const team = getSessionTeam(current);
+            if (team !== undefined)
+                return team;
+            // Cache miss on this node's parent: try the live SDK.
+            if (client && !getParentSessionId(current)) {
+                try {
+                    const result = await client.session.get({ path: { id: current } });
+                    const parentID = result.data?.parentID;
+                    if (parentID) {
+                        registerParentSession(current, parentID);
+                    }
+                }
+                catch {
+                    // Network / auth failure — let the walk continue to orphan.
+                }
+            }
+            current = getParentSessionId(current);
+        }
+        return sessionID;
+    }
     return {
         config: async (config) => {
             config.agent ??= {};
@@ -16,21 +50,16 @@ 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);
             }
         },
         'chat.message': async (input) => {
             if (input.agent === AGENT_CTO) {
-                // Adopt the persisted active team if one exists, so a new CTO session
-                // does not orphan previously created engineers and wrapper memory.
-                const persistedTeamId = await getPersistedActiveTeam(worktree);
-                const activeTeamId = persistedTeamId ?? input.sessionID;
-                setActiveTeamSession(worktree, activeTeamId);
-                if (!persistedTeamId) {
-                    // First CTO session for this worktree — persist this session as active team.
-                    await setPersistedActiveTeam(worktree, activeTeamId);
-                }
+                // Each CTO session ID is its own team. The session ID is the durable
+                // identity: no worktree-global active-team state.
+                registerSessionTeam(input.sessionID, input.sessionID);
                 return;
             }
             if (input.agent && isEngineerAgent(input.agent)) {
@@ -38,46 +67,65 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                 const existing = getWrapperSessionMapping(worktree, input.sessionID);
                 const persisted = existing ??
                     (await services.orchestrator.findTeamByWrapperSession(worktree, input.sessionID));
-                const teamId = persisted?.teamId ?? (await resolveTeamId(worktree, input.sessionID));
+                const teamId = persisted?.teamId ?? (await resolveTeamId(input.sessionID));
                 setWrapperSessionMapping(worktree, input.sessionID, {
                     teamId,
-                    engineer,
+                    workerName: engineer,
                 });
                 await services.orchestrator.recordWrapperSession(worktree, teamId, engineer, input.sessionID);
             }
         },
+        event: async ({ event: sdkEvent }) => {
+            if (sdkEvent.type === 'session.created') {
+                const session = sdkEvent.properties.info;
+                if (session.parentID) {
+                    registerParentSession(session.id, session.parentID);
+                }
+            }
+        },
         'experimental.chat.system.transform': async (input, output) => {
             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 ??
                         (await services.orchestrator.findTeamByWrapperSession(context.worktree, context.sessionID));
-                    const teamId = persisted?.teamId ?? (await resolveTeamId(context.worktree, context.sessionID));
+                    const teamId = persisted?.teamId ?? (await resolveTeamId(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 +135,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;
                 },
             }),
@@ -96,7 +153,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     teamId: tool.schema.string().optional(),
                 },
                 async execute(args, context) {
-                    const teamId = args.teamId ?? getActiveTeamSession(context.worktree) ?? context.sessionID;
+                    const teamId = args.teamId ?? context.sessionID;
                     annotateToolRun(context, 'Reading team status', {
                         teamId,
                     });
@@ -113,7 +170,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     model: tool.schema.enum(MODEL_ENUM).optional(),
                 },
                 async execute(args, context) {
-                    const teamId = getActiveTeamSession(context.worktree) ?? context.sessionID;
+                    const teamId = context.sessionID;
                     // Pre-determine engineers for event labeling (using orchestrator selection logic)
                     const { lead, challenger } = await services.orchestrator.selectPlanEngineers(context.worktree, teamId, args.leadEngineer, args.challengerEngineer);
                     annotateToolRun(context, 'Running dual-engineer plan synthesis', {
@@ -152,12 +209,12 @@ 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(),
                 },
                 async execute(args, context) {
-                    const teamId = getActiveTeamSession(context.worktree) ?? context.sessionID;
+                    const teamId = context.sessionID;
                     annotateToolRun(context, `Resetting ${args.engineer}`, {
                         teamId,
                         clearSession: args.clearSession,
@@ -435,14 +492,6 @@ export function isEngineerAgent(agentId) {
     const normalized = normalizeAgentId(agentId);
     return Object.values(ENGINEER_AGENT_IDS).some((id) => id === normalized);
 }
-/**
- * Resolves the team ID for an engineer session.
- * Reads the persisted active team first (survives process restarts), then
- * falls back to the in-memory registry, then to the raw session ID as a last resort.
- */
-async function resolveTeamId(worktree, sessionID) {
-    return (await getPersistedActiveTeam(worktree)) ?? getActiveTeamSession(worktree) ?? sessionID;
-}
 function formatToolDescription(toolName, toolArgs) {
     if (!toolArgs || typeof toolArgs !== 'object')
         return undefined;
@@ -497,12 +546,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 +561,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 +571,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 +607,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 +625,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/src/plugin/service-factory.d.ts

@@ -3,26 +3,27 @@ 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;
-export declare function setActiveTeamSession(worktree: string, teamId: string): void;
-export declare function getActiveTeamSession(worktree: string): string | null;
-export declare function getPersistedActiveTeam(worktree: string): Promise<string | null>;
-export declare function setPersistedActiveTeam(worktree: string, teamId: string): Promise<void>;
+export declare function registerParentSession(childId: string, parentId: string): void;
+export declare function getParentSessionId(childId: string): string | undefined;
+export declare function registerSessionTeam(sessionId: string, teamId: string): void;
+export declare function getSessionTeam(sessionId: string): string | undefined;
 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/src/plugin/service-factory.js

@@ -8,9 +8,13 @@ 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();
+/** childSessionId → parentSessionId — populated from session.created events */
+const parentSessionRegistry = new Map();
+/** ctoSessionId → teamId — populated when a CTO chat.message fires */
+const sessionTeamRegistry = new Map();
 export function getOrCreatePluginServices(worktree) {
     const existing = serviceRegistry.get(worktree);
     if (existing) {
@@ -24,41 +28,36 @@ 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;
 }
 export function clearPluginServices() {
     serviceRegistry.clear();
-    activeTeamRegistry.clear();
     wrapperSessionRegistry.clear();
+    parentSessionRegistry.clear();
+    sessionTeamRegistry.clear();
 }
-export function setActiveTeamSession(worktree, teamId) {
-    activeTeamRegistry.set(worktree, teamId);
+export function registerParentSession(childId, parentId) {
+    parentSessionRegistry.set(childId, parentId);
 }
-export function getActiveTeamSession(worktree) {
-    return activeTeamRegistry.get(worktree) ?? null;
+export function getParentSessionId(childId) {
+    return parentSessionRegistry.get(childId);
 }
-export async function getPersistedActiveTeam(worktree) {
-    const services = serviceRegistry.get(worktree);
-    if (!services) {
-        return null;
-    }
-    return services.teamStore.getActiveTeam(worktree);
+export function registerSessionTeam(sessionId, teamId) {
+    sessionTeamRegistry.set(sessionId, teamId);
 }
-export async function setPersistedActiveTeam(worktree, teamId) {
-    const services = serviceRegistry.get(worktree);
-    if (!services) {
-        return;
-    }
-    await services.teamStore.setActiveTeam(worktree, teamId);
+export function getSessionTeam(sessionId) {
+    return sessionTeamRegistry.get(sessionId);
 }
 export function setWrapperSessionMapping(worktree, wrapperSessionId, mapping) {
     wrapperSessionRegistry.set(`${worktree}:${wrapperSessionId}`, mapping);

package/dist/src/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/state/team-state-store.d.ts

@@ -7,10 +7,7 @@ export declare class TeamStateStore {
     getTeam(cwd: string, teamId: string): Promise<TeamRecord | null>;
     listTeams(cwd: string): Promise<TeamRecord[]>;
     updateTeam(cwd: string, teamId: string, update: (team: TeamRecord) => TeamRecord): Promise<TeamRecord>;
-    getActiveTeam(cwd: string): Promise<string | null>;
-    setActiveTeam(cwd: string, teamId: string): Promise<void>;
     private getTeamKey;
-    private getActiveTeamPath;
     private getTeamsDirectory;
     private getTeamPath;
     private enqueueWrite;

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

@@ -62,31 +62,9 @@ export class TeamStateStore {
             return updated;
         });
     }
-    async getActiveTeam(cwd) {
-        const filePath = this.getActiveTeamPath(cwd);
-        try {
-            const content = await fs.readFile(filePath, 'utf8');
-            const parsed = JSON.parse(content);
-            return parsed.teamId ?? null;
-        }
-        catch (error) {
-            if (isFileNotFoundError(error)) {
-                return null;
-            }
-            throw error;
-        }
-    }
-    async setActiveTeam(cwd, teamId) {
-        const filePath = this.getActiveTeamPath(cwd);
-        await fs.mkdir(path.dirname(filePath), { recursive: true });
-        await writeJsonAtomically(filePath, { teamId });
-    }
     getTeamKey(cwd, teamId) {
         return `${cwd}:${teamId}`;
     }
-    getActiveTeamPath(cwd) {
-        return path.join(cwd, this.baseDirectoryName, 'active-team.json');
-    }
     getTeamsDirectory(cwd) {
         return path.join(cwd, this.baseDirectoryName, 'teams');
     }

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

@@ -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/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/state/team-state-store.d.ts

@@ -7,10 +7,7 @@ export declare class TeamStateStore {
     getTeam(cwd: string, teamId: string): Promise<TeamRecord | null>;
     listTeams(cwd: string): Promise<TeamRecord[]>;
     updateTeam(cwd: string, teamId: string, update: (team: TeamRecord) => TeamRecord): Promise<TeamRecord>;
-    getActiveTeam(cwd: string): Promise<string | null>;
-    setActiveTeam(cwd: string, teamId: string): Promise<void>;
     private getTeamKey;
-    private getActiveTeamPath;
     private getTeamsDirectory;
     private getTeamPath;
     private enqueueWrite;

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

@@ -62,31 +62,9 @@ export class TeamStateStore {
             return updated;
         });
     }
-    async getActiveTeam(cwd) {
-        const filePath = this.getActiveTeamPath(cwd);
-        try {
-            const content = await fs.readFile(filePath, 'utf8');
-            const parsed = JSON.parse(content);
-            return parsed.teamId ?? null;
-        }
-        catch (error) {
-            if (isFileNotFoundError(error)) {
-                return null;
-            }
-            throw error;
-        }
-    }
-    async setActiveTeam(cwd, teamId) {
-        const filePath = this.getActiveTeamPath(cwd);
-        await fs.mkdir(path.dirname(filePath), { recursive: true });
-        await writeJsonAtomically(filePath, { teamId });
-    }
     getTeamKey(cwd, teamId) {
         return `${cwd}:${teamId}`;
     }
-    getActiveTeamPath(cwd) {
-        return path.join(cwd, this.baseDirectoryName, 'active-team.json');
-    }
     getTeamsDirectory(cwd) {
         return path.join(cwd, this.baseDirectoryName, 'teams');
     }

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);
 }