@doingdev/opencode-claude-manager-plugin 0.1.65 → 0.1.66

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

@@ -1,612 +0,0 @@
-import { createEmptyEngineerRecord, createEmptyTeamRecord } from '../team/roster.js';
-import { ContextTracker } from './context-tracker.js';
-const BUSY_LEASE_MS = 15 * 60 * 1000;
-export class TeamOrchestrator {
-    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);
-        if (existing) {
-            return this.normalizeTeamRecord(existing);
-        }
-        const created = createEmptyTeamRecord(teamId, cwd);
-        await this.teamStore.saveTeam(created);
-        return created;
-    }
-    async listTeams(cwd) {
-        const teams = await this.teamStore.listTeams(cwd);
-        return teams.map((team) => this.normalizeTeamRecord(team));
-    }
-    async recordWrapperSession(cwd, teamId, engineer, wrapperSessionId) {
-        await this.updateEngineer(cwd, teamId, engineer, (entry) => ({
-            ...entry,
-            wrapperSessionId,
-        }));
-    }
-    async recordWrapperExchange(cwd, teamId, engineer, wrapperSessionId, mode, assignment, result) {
-        const timestamp = new Date().toISOString();
-        await this.updateEngineer(cwd, teamId, engineer, (entry) => ({
-            ...entry,
-            wrapperSessionId,
-            wrapperHistory: appendWrapperHistoryEntries(entry.wrapperHistory, [
-                { timestamp, type: 'assignment', mode, text: summarizeText(assignment, 320) },
-                { timestamp, type: 'result', mode, text: summarizeText(result, 320) },
-            ]),
-            lastMode: mode,
-            lastTaskSummary: summarizeMessage(assignment),
-            lastUsedAt: timestamp,
-        }));
-    }
-    async getWrapperSystemContext(cwd, teamId, engineer) {
-        const team = await this.getOrCreateTeam(cwd, teamId);
-        const state = this.getEngineerState(team, engineer);
-        if (state.wrapperHistory.length === 0) {
-            return null;
-        }
-        const historyLines = state.wrapperHistory.map((entry) => {
-            const modeLabel = entry.mode ? ` [${entry.mode}]` : '';
-            return `- ${entry.type}${modeLabel}: ${entry.text}`;
-        });
-        return [
-            `Persistent wrapper memory for ${engineer} in CTO team ${teamId}:`,
-            'Use this only to improve delegation quality and continuity.',
-            'Prefer the current assignment when it conflicts with older context.',
-            ...historyLines,
-        ].join('\n');
-    }
-    async findTeamByWrapperSession(cwd, wrapperSessionId) {
-        const teams = await this.listTeams(cwd);
-        for (const team of teams) {
-            for (const engineer of team.engineers) {
-                if (engineer.wrapperSessionId === wrapperSessionId) {
-                    return {
-                        teamId: team.id,
-                        engineer: engineer.name,
-                    };
-                }
-            }
-        }
-        return null;
-    }
-    /**
-     * Remove wrapper history entries whose timestamp is strictly after cutoffIso.
-     * Used during CTO undo propagation to prune stale wrapper memory.
-     */
-    async pruneWrapperHistoryAfter(cwd, teamId, engineer, cutoffIso) {
-        await this.updateEngineer(cwd, teamId, engineer, (entry) => ({
-            ...entry,
-            wrapperHistory: entry.wrapperHistory.filter((h) => h.timestamp <= cutoffIso),
-        }));
-    }
-    async resetEngineer(cwd, teamId, engineer, options) {
-        await this.updateEngineer(cwd, teamId, engineer, (entry) => ({
-            ...entry,
-            busy: false,
-            busySince: null,
-            claudeSessionId: options?.clearSession ? null : entry.claudeSessionId,
-            wrapperHistory: options?.clearHistory ? [] : entry.wrapperHistory,
-            context: options?.clearSession ? createEmptyEngineerRecord(engineer).context : entry.context,
-        }));
-    }
-    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);
-        try {
-            const tracker = new ContextTracker();
-            if (engineerState.context.sessionId) {
-                tracker.restore({
-                    sessionId: engineerState.context.sessionId,
-                    totalTurns: engineerState.context.totalTurns,
-                    totalCostUsd: engineerState.context.totalCostUsd,
-                    estimatedContextPercent: engineerState.context.estimatedContextPercent,
-                    contextWindowSize: engineerState.context.contextWindowSize,
-                    latestInputTokens: engineerState.context.latestInputTokens,
-                });
-            }
-            const result = await this.sessions.runTask({
-                cwd: input.cwd,
-                prompt: engineerState.claudeSessionId
-                    ? 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',
-                allowedTools: workerCaps?.sessionAllowedTools,
-                restrictWriteTools: input.mode === 'explore' || (workerCaps?.restrictWriteTools ?? false),
-                model: input.model,
-                effort: (workerCaps?.restrictWriteTools ?? false)
-                    ? 'medium'
-                    : input.mode === 'implement'
-                        ? 'high'
-                        : 'medium',
-                settingSources: ['user', 'project', 'local'],
-                abortSignal: input.abortSignal,
-            }, input.onEvent);
-            tracker.recordResult({
-                sessionId: result.sessionId,
-                turns: result.turns,
-                totalCostUsd: result.totalCostUsd,
-                inputTokens: result.inputTokens,
-                outputTokens: result.outputTokens,
-                contextWindowSize: result.contextWindowSize,
-            });
-            if (result.sessionId && result.events.length > 0) {
-                await this.transcriptStore.appendEvents(input.cwd, result.sessionId, result.events);
-            }
-            const context = tracker.snapshot();
-            await this.updateEngineer(input.cwd, input.teamId, input.engineer, (entry) => ({
-                ...entry,
-                claudeSessionId: result.sessionId ?? engineerState.claudeSessionId,
-                busy: false,
-                busySince: null,
-                lastMode: input.mode,
-                lastTaskSummary: summarizeMessage(input.message),
-                lastUsedAt: new Date().toISOString(),
-                context,
-            }));
-            return {
-                teamId: input.teamId,
-                engineer: input.engineer,
-                mode: input.mode,
-                sessionId: result.sessionId,
-                finalText: result.finalText,
-                turns: result.turns,
-                totalCostUsd: result.totalCostUsd,
-                inputTokens: result.inputTokens,
-                outputTokens: result.outputTokens,
-                contextWindowSize: result.contextWindowSize,
-                context,
-            };
-        }
-        catch (error) {
-            await this.updateEngineer(input.cwd, input.teamId, input.engineer, (engineer) => ({
-                ...engineer,
-                busy: false,
-                busySince: null,
-            }));
-            // Handle context exhaustion with automatic retry (max 1 retry)
-            const classified = TeamOrchestrator.classifyError(error);
-            if (classified.failureKind === 'contextExhausted' && retryCount === 0) {
-                // Reset the engineer's session and retry once with fresh session
-                await this.resetEngineer(input.cwd, input.teamId, input.engineer, {
-                    clearSession: true,
-                    clearHistory: false,
-                });
-                // Emit status event before retry
-                await input.onEvent?.({
-                    type: 'status',
-                    text: 'Context exhausted; resetting session and retrying once with a fresh session.',
-                });
-                try {
-                    // Retry dispatch with fresh session (retryCount=1 prevents infinite loop)
-                    // Use the exact same assignment message without modification
-                    return await this.dispatchEngineer(input, 1);
-                }
-                catch (retryError) {
-                    // If retry also fails with a different error, preserve retry failure info
-                    const retryClassified = TeamOrchestrator.classifyError(retryError);
-                    if (retryClassified.failureKind !== classified.failureKind) {
-                        // Create an error that shows both failures
-                        const combinedMessage = `Initial: ${classified.failureKind} (${classified.message})\n` +
-                            `After retry: ${retryClassified.failureKind} (${retryClassified.message})`;
-                        const combinedError = new Error(combinedMessage);
-                        Object.assign(combinedError, { cause: retryError });
-                        throw combinedError;
-                    }
-                    // Same error type on retry, throw the retry error (more recent state)
-                    throw retryError;
-                }
-            }
-            throw error;
-        }
-    }
-    static classifyError(error) {
-        const message = error instanceof Error ? error.message : String(error);
-        let failureKind = 'unknown';
-        if (message.includes('already working on another assignment')) {
-            failureKind = 'engineerBusy';
-        }
-        else if (message.includes('context') || message.includes('token limit')) {
-            failureKind = 'contextExhausted';
-        }
-        else if (message.includes('does not support implement mode')) {
-            failureKind = 'modeNotSupported';
-        }
-        else if (message.includes('denied') || message.includes('not allowed')) {
-            failureKind = 'toolDenied';
-        }
-        else if (message.includes('abort') || message.includes('cancel')) {
-            failureKind = 'aborted';
-        }
-        else {
-            failureKind = 'sdkError';
-        }
-        return {
-            teamId: '',
-            engineer: 'Tom',
-            mode: 'explore',
-            failureKind,
-            message,
-            cause: error,
-        };
-    }
-    async planWithTeam(input) {
-        // Auto-select engineers if not provided
-        const { lead: leadEngineer, challenger: challengerEngineer } = await this.selectPlanEngineers(input.cwd, input.teamId, input.leadEngineer, input.challengerEngineer);
-        const [leadDraft, challengerDraft] = await Promise.all([
-            this.dispatchEngineer({
-                teamId: input.teamId,
-                cwd: input.cwd,
-                engineer: leadEngineer,
-                mode: 'explore',
-                message: buildPlanDraftRequest('lead', input.request),
-                model: input.model,
-                abortSignal: input.abortSignal,
-                onEvent: input.onLeadEvent,
-            }),
-            this.dispatchEngineer({
-                teamId: input.teamId,
-                cwd: input.cwd,
-                engineer: challengerEngineer,
-                mode: 'explore',
-                message: buildPlanDraftRequest('challenger', input.request),
-                model: input.model,
-                abortSignal: input.abortSignal,
-                onEvent: input.onChallengerEvent,
-            }),
-        ]);
-        const drafts = [
-            { ...leadDraft, request: input.request },
-            { ...challengerDraft, request: input.request },
-        ];
-        const synthesisResult = await this.sessions.runTask({
-            cwd: input.cwd,
-            prompt: `${this.planSynthesisPrompt}\n\n${buildSynthesisPrompt(input.request, drafts)}`,
-            persistSession: false,
-            includePartialMessages: false,
-            permissionMode: 'acceptEdits',
-            restrictWriteTools: true,
-            model: input.model,
-            effort: 'high',
-            settingSources: ['user', 'project', 'local'],
-            abortSignal: input.abortSignal,
-        }, input.onSynthesisEvent);
-        const parsedSynthesis = parseSynthesisResult(synthesisResult.finalText);
-        return {
-            teamId: input.teamId,
-            request: input.request,
-            leadEngineer,
-            challengerEngineer,
-            drafts,
-            synthesis: parsedSynthesis.synthesis,
-            recommendedQuestion: parsedSynthesis.recommendedQuestion,
-            recommendedAnswer: parsedSynthesis.recommendedAnswer,
-        };
-    }
-    async updateEngineer(cwd, teamId, engineerName, update) {
-        await this.getOrCreateTeam(cwd, teamId);
-        await this.teamStore.updateTeam(cwd, teamId, (team) => {
-            const normalized = this.normalizeTeamRecord(team);
-            const existing = this.getEngineerState(normalized, engineerName);
-            return {
-                ...normalized,
-                updatedAt: new Date().toISOString(),
-                engineers: normalized.engineers.map((engineer) => engineer.name === engineerName ? update(existing) : engineer),
-            };
-        });
-    }
-    async reserveEngineer(cwd, teamId, engineerName) {
-        await this.getOrCreateTeam(cwd, teamId);
-        await this.teamStore.updateTeam(cwd, teamId, (team) => {
-            const normalized = this.normalizeTeamRecord(team);
-            const engineer = this.getEngineerState(normalized, engineerName);
-            if (engineer.busy) {
-                const leaseExpired = engineer.busySince !== null &&
-                    Date.now() - new Date(engineer.busySince).getTime() > BUSY_LEASE_MS;
-                if (!leaseExpired) {
-                    throw new Error(`${engineerName} is already working on another assignment.`);
-                }
-            }
-            const now = new Date().toISOString();
-            return {
-                ...normalized,
-                updatedAt: now,
-                engineers: normalized.engineers.map((entry) => entry.name === engineerName
-                    ? {
-                        ...entry,
-                        busy: true,
-                        busySince: now,
-                    }
-                    : entry),
-            };
-        });
-    }
-    getEngineerState(team, engineerName) {
-        return (team.engineers.find((engineer) => engineer.name === engineerName) ??
-            createEmptyEngineerRecord(engineerName));
-    }
-    normalizeTeamRecord(team) {
-        const engineerMap = new Map(team.engineers.map((engineer) => [engineer.name, engineer]));
-        const emptyTeam = createEmptyTeamRecord(team.id, team.cwd);
-        return {
-            ...team,
-            engineers: emptyTeam.engineers.map((engineer) => engineerMap.get(engineer.name) ?? engineer),
-        };
-    }
-    getAvailableEngineers(team) {
-        const now = Date.now();
-        return team.engineers
-            .filter((engineer) => {
-            if (!engineer.busy)
-                return true;
-            // If an engineer has been marked busy but the lease expired, they're available
-            if (engineer.busySince) {
-                const leaseExpired = now - new Date(engineer.busySince).getTime() > BUSY_LEASE_MS;
-                return leaseExpired;
-            }
-            return false;
-        })
-            .sort((a, b) => {
-            // Prefer engineers with lower context pressure and less-recently-used
-            const aContext = a.context.estimatedContextPercent ?? 0;
-            const bContext = b.context.estimatedContextPercent ?? 0;
-            if (aContext !== bContext) {
-                return aContext - bContext; // Lower context first
-            }
-            // If context is equal, prefer less-recently-used
-            const aTime = a.lastUsedAt ? new Date(a.lastUsedAt).getTime() : 0;
-            const bTime = b.lastUsedAt ? new Date(b.lastUsedAt).getTime() : 0;
-            return aTime - bTime; // Earlier usage time first
-        })
-            .map((engineer) => engineer.name);
-    }
-    async selectPlanEngineers(cwd, teamId, preferredLead, preferredChallenger) {
-        const team = await this.getOrCreateTeam(cwd, teamId);
-        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 general engineers (specialists excluded), found ${available.length}.`);
-        }
-        const lead = preferredLead ?? available[0];
-        const foundChallenger = preferredChallenger ?? available.find((e) => e !== lead);
-        const challenger = foundChallenger ?? available[1];
-        if (lead === challenger) {
-            throw new Error('Cannot use the same engineer for both lead and challenger.');
-        }
-        return { lead, challenger };
-    }
-    async getActivePlan(cwd, teamId) {
-        const team = await this.getOrCreateTeam(cwd, teamId);
-        return team.activePlan ?? null;
-    }
-    async setActivePlan(cwd, teamId, plan) {
-        await this.getOrCreateTeam(cwd, teamId);
-        const now = new Date().toISOString();
-        const slices = plan.slices.map((description, index) => ({
-            index,
-            description,
-            status: 'pending',
-        }));
-        const activePlan = {
-            id: `plan-${Date.now()}`,
-            summary: plan.summary,
-            taskSize: plan.taskSize,
-            createdAt: now,
-            confirmedAt: now,
-            preAuthorized: plan.preAuthorized,
-            slices,
-            currentSliceIndex: slices.length > 0 ? 0 : null,
-        };
-        await this.teamStore.updateTeam(cwd, teamId, (team) => ({
-            ...team,
-            updatedAt: now,
-            activePlan,
-        }));
-        return activePlan;
-    }
-    async clearActivePlan(cwd, teamId) {
-        await this.getOrCreateTeam(cwd, teamId);
-        const now = new Date().toISOString();
-        await this.teamStore.updateTeam(cwd, teamId, (team) => ({
-            ...team,
-            updatedAt: now,
-            activePlan: undefined,
-        }));
-    }
-    async updateActivePlanSlice(cwd, teamId, sliceIndex, status) {
-        await this.getOrCreateTeam(cwd, teamId);
-        const now = new Date().toISOString();
-        await this.teamStore.updateTeam(cwd, teamId, (team) => {
-            if (!team.activePlan) {
-                throw new Error(`Cannot update slice: team "${teamId}" has no active plan. Persist an active plan before updating slices.`);
-            }
-            const sliceExists = team.activePlan.slices.some((s) => s.index === sliceIndex);
-            if (!sliceExists) {
-                const sliceCount = team.activePlan.slices.length;
-                const rangeMsg = sliceCount === 0 ? 'plan has no slices' : `valid range: 0–${sliceCount - 1}`;
-                throw new Error(`Cannot update slice: slice index ${sliceIndex} does not exist in active plan "${team.activePlan.id}" (${rangeMsg}).`);
-            }
-            const slices = team.activePlan.slices.map((s) => s.index === sliceIndex
-                ? {
-                    ...s,
-                    status,
-                    ...(status === 'done' || status === 'skipped' ? { completedAt: now } : {}),
-                }
-                : s);
-            const isLastSlice = sliceIndex === team.activePlan.slices.length - 1;
-            const nextIndex = status === 'done' || status === 'skipped'
-                ? isLastSlice
-                    ? null
-                    : sliceIndex + 1
-                : team.activePlan.currentSliceIndex;
-            return {
-                ...team,
-                updatedAt: now,
-                activePlan: {
-                    ...team.activePlan,
-                    slices,
-                    currentSliceIndex: nextIndex,
-                },
-            };
-        });
-    }
-    buildSessionSystemPrompt(engineer, mode) {
-        const specialistPrompt = this.workerCapabilities[engineer]?.sessionPrompt;
-        if (specialistPrompt) {
-            return specialistPrompt;
-        }
-        return [
-            this.engineerSessionPrompt,
-            '',
-            `Assigned engineer: ${engineer}.`,
-            `Current work mode: ${mode}.`,
-        ]
-            .join('\n')
-            .trim();
-    }
-    buildEngineerPrompt(mode, message, engineer) {
-        if (this.workerCapabilities[engineer]?.skipModeInstructions) {
-            return message;
-        }
-        return `${buildModeInstruction(mode)}\n\n${message}`;
-    }
-}
-function buildModeInstruction(mode) {
-    switch (mode) {
-        case 'explore':
-            return [
-                'Exploration mode.',
-                'Read, search, and reason about the codebase without editing files.',
-                'The caller should specify the desired output for this exploration task, such as root cause, findings, affected files, options, risk review, or a concrete plan.',
-                'If the caller does not specify the output shape, return concise findings, relevant file paths, open questions, and the recommended next step.',
-                'Do not create or edit files.',
-            ].join(' ');
-        case 'implement':
-            return [
-                'Implementation mode.',
-                'Before making any edits, state a brief implementation plan: which files you will change, what each change does, and why.',
-                'Then make the changes, run the most relevant verification (tests, lint, typecheck), and report what changed and what you verified.',
-                'Before reporting done, review your own diff for issues that pass tests but break in production.',
-            ].join(' ');
-        case 'verify':
-            return [
-                'Verification mode.',
-                'Run targeted checks in order of relevance: tests, lint, typecheck, build.',
-                'Check that changed code paths have test coverage.',
-                'Report pass/fail with evidence.',
-                'Escalate failures with exact output.',
-            ].join(' ');
-    }
-}
-function summarizeMessage(message) {
-    const compact = message.replace(/\s+/g, ' ').trim();
-    return compact.length > 120 ? `${compact.slice(0, 117)}...` : compact;
-}
-function summarizeText(text, limit) {
-    const compact = text.replace(/\s+/g, ' ').trim();
-    return compact.length > limit ? `${compact.slice(0, limit - 3)}...` : compact;
-}
-function appendWrapperHistoryEntries(existing, nextEntries) {
-    return [...existing, ...nextEntries].slice(-12);
-}
-function buildPlanDraftRequest(perspective, request) {
-    const posture = perspective === 'lead'
-        ? 'You are the lead planner. Propose the most direct workable plan with concrete file paths and clear next steps. Think about failure modes and edge cases — what can break at each boundary?'
-        : 'You are the challenger. Stress-test assumptions, surface missing decisions, and propose a stronger alternative when the lead plan is weak. Think about failure modes and edge cases — what can break at each boundary?';
-    return [
-        posture,
-        '',
-        'Return exactly these sections:',
-        '1. Objective',
-        '2. Proposed approach (include system boundaries and data flow)',
-        '3. Files or systems likely involved',
-        '4. Failure modes and edge cases (what happens when things go wrong?)',
-        '5. Risks and open questions',
-        '6. Verification (how to prove it works, including what tests to add)',
-        '7. Step-by-step plan',
-        '',
-        `User request: ${request}`,
-    ].join('\n');
-}
-function buildSynthesisPrompt(request, drafts) {
-    return [
-        `User request: ${request}`,
-        '',
-        `Lead engineer (${drafts[0].engineer}) draft:`,
-        drafts[0].finalText,
-        '',
-        `Challenger engineer (${drafts[1].engineer}) draft:`,
-        drafts[1].finalText,
-    ].join('\n');
-}
-function parseSynthesisResult(text) {
-    const synthesis = extractSection(text, 'Synthesis') ?? text.trim();
-    const recommendedQuestion = normalizeOptionalSection(extractSection(text, 'Recommended Question'));
-    const recommendedAnswer = normalizeOptionalSection(extractSection(text, 'Recommended Answer'));
-    return {
-        synthesis,
-        recommendedQuestion,
-        recommendedAnswer,
-    };
-}
-function extractSection(text, heading) {
-    const regex = new RegExp(`## ${escapeRegExp(heading)}\\n([\\s\\S]*?)(?=\\n## |$)`);
-    const match = text.match(regex);
-    return match?.[1]?.trim() ?? null;
-}
-function normalizeOptionalSection(value) {
-    if (!value) {
-        return null;
-    }
-    return value.toUpperCase() === 'NONE' ? null : value;
-}
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-export function getFailureGuidanceText(failureKind) {
-    switch (failureKind) {
-        case 'contextExhausted':
-            return 'Context exhausted after using all available tokens. The engineer was reset and the assignment retried once. If it still fails, the task may be too large; consider breaking it into smaller steps.';
-        case 'engineerBusy':
-            return 'This engineer is currently working on another assignment. Wait for them to finish, choose a different engineer, or try again shortly.';
-        case 'toolDenied':
-            return 'A tool permission was denied during the assignment. Check the approval policy and tool permissions, then retry.';
-        case 'modeNotSupported':
-            return 'This engineer does not support the requested work mode. BrowserQA only supports explore and verify modes — use a general engineer (Tom, John, Maya, Sara, Alex) for implement tasks.';
-        case 'aborted':
-            return 'The assignment was cancelled by the user or an abort signal was triggered. Review the request and try again.';
-        case 'sdkError':
-            return 'An SDK error occurred during the assignment. Check logs for details, ensure the Claude session is healthy, and retry.';
-        default:
-            return 'An unknown error occurred during the assignment. Check logs and retry.';
-    }
-}
-export function createActionableError(failure, originalError) {
-    const guidance = getFailureGuidanceText(failure.failureKind);
-    const errorMessage = `[${failure.failureKind}] ${failure.message}\n\n` + `Next steps: ${guidance}`;
-    const error = new Error(errorMessage);
-    Object.assign(error, { cause: originalError });
-    return error;
-}

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

@@ -1 +0,0 @@
-export * from './agents/index.js';

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

@@ -1,2 +0,0 @@
-// 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

@@ -1,14 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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',
-            // Pre-approve the Playwriter toolchain at the SDK level so headless sessions
-            // never stall waiting for interactive confirmation. Write tools remain blocked
-            // by restrictWriteTools and the canUseTool write-filter.
-            sessionAllowedTools: ['Skill', 'Bash', 'Read', 'Grep', 'Glob', 'LS', 'ListDirectory'],
-        },
-    };
-}
-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,
-    };
-}