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

package/dist/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>;
@@ -33,7 +34,7 @@ export declare class TeamOrchestrator {
         clearSession?: boolean;
         clearHistory?: boolean;
     }): Promise<void>;
-    dispatchEngineer(input: DispatchEngineerInput): Promise<EngineerTaskResult>;
+    dispatchEngineer(input: DispatchEngineerInput, retryCount?: number): Promise<EngineerTaskResult>;
     static classifyError(error: unknown): EngineerFailureResult & {
         cause: unknown;
     };
@@ -41,8 +42,8 @@ export declare class TeamOrchestrator {
         teamId: string;
         cwd: string;
         request: string;
-        leadEngineer: EngineerName;
-        challengerEngineer: EngineerName;
+        leadEngineer?: EngineerName;
+        challengerEngineer?: EngineerName;
         model?: string;
         abortSignal?: AbortSignal;
         onLeadEvent?: ClaudeSessionEventHandler;
@@ -53,7 +54,14 @@ export declare class TeamOrchestrator {
     private reserveEngineer;
     private getEngineerState;
     private normalizeTeamRecord;
+    getAvailableEngineers(team: TeamRecord): EngineerName[];
+    selectPlanEngineers(cwd: string, teamId: string, preferredLead?: EngineerName, preferredChallenger?: EngineerName): Promise<{
+        lead: EngineerName;
+        challenger: EngineerName;
+    }>;
     private buildSessionSystemPrompt;
     private buildEngineerPrompt;
 }
+export declare function getFailureGuidanceText(failureKind: string): string;
+export declare function createActionableError(failure: EngineerFailureResult, originalError: unknown): Error;
 export {};

package/dist/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);
@@ -88,7 +90,14 @@ export class TeamOrchestrator {
             context: options?.clearSession ? createEmptyEngineerRecord(engineer).context : entry.context,
         }));
     }
-    async dispatchEngineer(input) {
+    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);
@@ -161,6 +174,39 @@ export class TeamOrchestrator {
                 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;
         }
     }
@@ -192,14 +238,13 @@ export class TeamOrchestrator {
         };
     }
     async planWithTeam(input) {
-        if (input.leadEngineer === input.challengerEngineer) {
-            throw new Error('Choose two different engineers for plan synthesis.');
-        }
+        // 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: input.leadEngineer,
+                engineer: leadEngineer,
                 mode: 'explore',
                 message: buildPlanDraftRequest('lead', input.request),
                 model: input.model,
@@ -209,7 +254,7 @@ export class TeamOrchestrator {
             this.dispatchEngineer({
                 teamId: input.teamId,
                 cwd: input.cwd,
-                engineer: input.challengerEngineer,
+                engineer: challengerEngineer,
                 mode: 'explore',
                 message: buildPlanDraftRequest('challenger', input.request),
                 model: input.model,
@@ -237,8 +282,8 @@ export class TeamOrchestrator {
         return {
             teamId: input.teamId,
             request: input.request,
-            leadEngineer: input.leadEngineer,
-            challengerEngineer: input.challengerEngineer,
+            leadEngineer,
+            challengerEngineer,
             drafts,
             synthesis: parsedSynthesis.synthesis,
             recommendedQuestion: parsedSynthesis.recommendedQuestion,
@@ -289,12 +334,60 @@ 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) {
+        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 };
+    }
     buildSessionSystemPrompt(engineer, mode) {
+        const specialistPrompt = this.workerCapabilities[engineer]?.sessionPrompt;
+        if (specialistPrompt) {
+            return specialistPrompt;
+        }
         return [
             this.engineerSessionPrompt,
             '',
@@ -304,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}`;
     }
 }
@@ -398,3 +494,26 @@ function normalizeOptionalSection(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 '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/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/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.`,
-        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. Asks for engineer names if 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/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/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,
+    };
+}

package/dist/plugin/agents/common.d.ts

@@ -0,0 +1,37 @@
+export declare const AGENT_CTO = "cto";
+export declare const AGENT_TEAM_PLANNER = "team-planner";
+export declare const AGENT_BROWSER_QA = "browser-qa";
+export declare const ENGINEER_AGENT_IDS: {
+    readonly Tom: "tom";
+    readonly John: "john";
+    readonly Maya: "maya";
+    readonly Sara: "sara";
+    readonly Alex: "alex";
+    readonly BrowserQA: "browser-qa";
+};
+/** General named engineers only (Tom/John/Maya/Sara/Alex). BrowserQA is a specialist registered separately. */
+export declare const ENGINEER_AGENT_NAMES: readonly ["Tom", "John", "Maya", "Sara", "Alex"];
+export declare const CTO_ONLY_TOOL_IDS: readonly ["team_status", "reset_engineer", "list_transcripts", "list_history", "git_diff", "git_commit", "git_reset", "git_status", "git_log", "approval_policy", "approval_decisions", "approval_update"];
+export declare const ENGINEER_TOOL_IDS: readonly ["claude"];
+export declare const ALL_RESTRICTED_TOOL_IDS: readonly ["team_status", "reset_engineer", "list_transcripts", "list_history", "git_diff", "git_commit", "git_reset", "git_status", "git_log", "approval_policy", "approval_decisions", "approval_update", "claude"];
+export type ToolPermission = 'allow' | 'ask' | 'deny';
+export 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 const CTO_READONLY_TOOLS: Record<string, ToolPermission>;
+export declare function buildEngineerPermissions(): AgentPermission;
+export declare function denyRestrictedToolsGlobally(permissions: Record<string, ToolPermission>): void;

package/dist/plugin/agents/common.js

@@ -0,0 +1,59 @@
+import { PLANNER_ELIGIBLE_ENGINEERS } from '../../team/roster.js';
+export const AGENT_CTO = 'cto';
+export const AGENT_TEAM_PLANNER = 'team-planner';
+export const AGENT_BROWSER_QA = 'browser-qa';
+export const ENGINEER_AGENT_IDS = {
+    Tom: 'tom',
+    John: 'john',
+    Maya: 'maya',
+    Sara: 'sara',
+    Alex: 'alex',
+    BrowserQA: 'browser-qa',
+};
+/** General named engineers only (Tom/John/Maya/Sara/Alex). BrowserQA is a specialist registered separately. */
+export const ENGINEER_AGENT_NAMES = PLANNER_ELIGIBLE_ENGINEERS;
+export 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',
+];
+export const ENGINEER_TOOL_IDS = ['claude'];
+export const ALL_RESTRICTED_TOOL_IDS = [...CTO_ONLY_TOOL_IDS, ...ENGINEER_TOOL_IDS];
+export 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',
+};
+export function buildEngineerPermissions() {
+    const denied = {};
+    for (const toolId of ALL_RESTRICTED_TOOL_IDS) {
+        denied[toolId] = 'deny';
+    }
+    return {
+        '*': 'deny',
+        ...denied,
+        claude: 'allow',
+    };
+}
+export function denyRestrictedToolsGlobally(permissions) {
+    for (const toolId of ALL_RESTRICTED_TOOL_IDS) {
+        permissions[toolId] ??= 'deny';
+    }
+}

package/dist/plugin/agents/cto.d.ts

@@ -0,0 +1,9 @@
+import type { ManagerPromptRegistry } from '../../types/contracts.js';
+import type { AgentPermission } from './common.js';
+export declare function buildCtoAgentConfig(prompts: ManagerPromptRegistry): {
+    description: string;
+    mode: "primary";
+    color: string;
+    permission: AgentPermission;
+    prompt: string;
+};

package/dist/plugin/agents/cto.js

@@ -0,0 +1,39 @@
+import { AGENT_BROWSER_QA, AGENT_TEAM_PLANNER, ALL_RESTRICTED_TOOL_IDS, CTO_ONLY_TOOL_IDS, CTO_READONLY_TOOLS, ENGINEER_AGENT_IDS, ENGINEER_AGENT_NAMES, } from './common.js';
+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.
+    }
+    // BrowserQA is a specialist registered separately from ENGINEER_AGENT_NAMES; add both forms.
+    taskPermissions['BrowserQA'] = 'allow'; // uppercase (user-friendly)
+    taskPermissions[AGENT_BROWSER_QA] = 'allow'; // 'browser-qa' canonical
+    taskPermissions[AGENT_TEAM_PLANNER] = 'allow';
+    return {
+        '*': 'deny',
+        ...CTO_READONLY_TOOLS,
+        ...denied,
+        ...allowed,
+        task: taskPermissions,
+    };
+}
+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,
+    };
+}

package/dist/plugin/agents/engineers.d.ts

@@ -0,0 +1,9 @@
+import type { EngineerName, ManagerPromptRegistry } from '../../types/contracts.js';
+export declare function buildEngineerAgentConfig(prompts: ManagerPromptRegistry, engineer: EngineerName): {
+    description: string;
+    mode: "subagent";
+    hidden: boolean;
+    color: string;
+    permission: import("./common.js").AgentPermission;
+    prompt: string;
+};