@doingdev/opencode-claude-manager-plugin 0.1.44 → 0.1.47

package/dist/manager/team-orchestrator.js

@@ -0,0 +1,360 @@
+import { createEmptyEngineerRecord, createEmptyTeamRecord } from '../team/roster.js';
+import { ContextTracker } from './context-tracker.js';
+export class TeamOrchestrator {
+    sessions;
+    teamStore;
+    transcriptStore;
+    engineerSessionPrompt;
+    projectClaudeFiles;
+    constructor(sessions, teamStore, transcriptStore, engineerSessionPrompt, projectClaudeFiles) {
+        this.sessions = sessions;
+        this.teamStore = teamStore;
+        this.transcriptStore = transcriptStore;
+        this.engineerSessionPrompt = engineerSessionPrompt;
+        this.projectClaudeFiles = projectClaudeFiles;
+    }
+    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;
+    }
+    async dispatchEngineer(input) {
+        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: this.buildEngineerPrompt(input.mode, input.message),
+                systemPrompt: engineerState.claudeSessionId
+                    ? undefined
+                    : this.buildSessionSystemPrompt(input.engineer, input.mode),
+                resumeSessionId: engineerState.claudeSessionId ?? undefined,
+                persistSession: true,
+                includePartialMessages: true,
+                permissionMode: this.mapWorkModeToSessionMode(input.mode) === 'plan' ? 'plan' : 'acceptEdits',
+                model: input.model,
+                effort: input.mode === 'implement' ? 'high' : 'medium',
+                settingSources: ['user'],
+                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,
+                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,
+            }));
+            throw error;
+        }
+    }
+    async planWithTeam(input) {
+        if (input.leadEngineer === input.challengerEngineer) {
+            throw new Error('Choose two different engineers for plan synthesis.');
+        }
+        const [leadDraft, challengerDraft] = await Promise.all([
+            this.dispatchEngineer({
+                teamId: input.teamId,
+                cwd: input.cwd,
+                engineer: input.leadEngineer,
+                mode: 'explore',
+                message: buildPlanDraftRequest('lead', input.request),
+                model: input.model,
+                abortSignal: input.abortSignal,
+            }),
+            this.dispatchEngineer({
+                teamId: input.teamId,
+                cwd: input.cwd,
+                engineer: input.challengerEngineer,
+                mode: 'explore',
+                message: buildPlanDraftRequest('challenger', input.request),
+                model: input.model,
+                abortSignal: input.abortSignal,
+            }),
+        ]);
+        const drafts = [
+            { ...leadDraft, request: input.request },
+            { ...challengerDraft, request: input.request },
+        ];
+        const synthesisResult = await this.sessions.runTask({
+            cwd: input.cwd,
+            prompt: buildSynthesisPrompt(input.request, drafts),
+            systemPrompt: buildSynthesisSystemPrompt(),
+            persistSession: false,
+            includePartialMessages: false,
+            permissionMode: 'plan',
+            model: input.model,
+            effort: 'high',
+            settingSources: ['user'],
+            abortSignal: input.abortSignal,
+        });
+        const parsedSynthesis = parseSynthesisResult(synthesisResult.finalText);
+        return {
+            teamId: input.teamId,
+            request: input.request,
+            leadEngineer: input.leadEngineer,
+            challengerEngineer: input.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) {
+                throw new Error(`${engineerName} is already working on another assignment.`);
+            }
+            return {
+                ...normalized,
+                updatedAt: new Date().toISOString(),
+                engineers: normalized.engineers.map((entry) => entry.name === engineerName
+                    ? {
+                        ...entry,
+                        busy: true,
+                    }
+                    : 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]));
+        return {
+            ...team,
+            engineers: createEmptyTeamRecord(team.id, team.cwd).engineers.map((engineer) => engineerMap.get(engineer.name) ?? engineer),
+        };
+    }
+    buildSessionSystemPrompt(engineer, mode) {
+        const claudeFileSection = this.projectClaudeFiles.length
+            ? `\n\nProject Claude Files:\n${this.projectClaudeFiles
+                .map((file) => `## ${file.relativePath}\n${file.content}`)
+                .join('\n\n')}`
+            : '';
+        return [
+            this.engineerSessionPrompt,
+            '',
+            `Assigned engineer: ${engineer}.`,
+            `Current work mode: ${mode}.`,
+            claudeFileSection,
+        ]
+            .join('\n')
+            .trim();
+    }
+    buildEngineerPrompt(mode, message) {
+        return `${buildModeInstruction(mode)}\n\n${message}`;
+    }
+    mapWorkModeToSessionMode(mode) {
+        return mode === 'explore' ? 'plan' : 'free';
+    }
+}
+function buildModeInstruction(mode) {
+    switch (mode) {
+        case 'explore':
+            return 'Work in planning mode. Investigate, reason, and write the plan inline. Do not make file edits.';
+        case 'implement':
+            return 'Work in implementation mode. Make the changes, verify them, and report clearly.';
+        case 'verify':
+            return 'Work in verification mode. Run the narrowest useful checks first, then broaden only if needed.';
+    }
+}
+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'
+        ? 'Propose the most direct workable plan.'
+        : 'Challenge weak assumptions, find missing decisions, and propose a stronger alternative if needed.';
+    return [
+        posture,
+        '',
+        'Return exactly these sections:',
+        '1. Objective',
+        '2. Proposed approach',
+        '3. Files or systems likely involved',
+        '4. Risks and open questions',
+        '5. Verification',
+        '6. Step-by-step plan',
+        '',
+        `User request: ${request}`,
+    ].join('\n');
+}
+function buildSynthesisSystemPrompt() {
+    return [
+        'You are the CTO synthesis engine.',
+        'Combine two independent engineering plans into one better plan.',
+        'Prefer the clearest, simplest, highest-leverage path.',
+        'If one user decision is still required, surface exactly one recommended question and one recommended answer.',
+        'Use this output format exactly:',
+        '## Synthesis',
+        '<combined plan>',
+        '## Recommended Question',
+        '<question or NONE>',
+        '## Recommended Answer',
+        '<answer or NONE>',
+    ].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, '\\$&');
+}

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

@@ -1,18 +1,14 @@
-/**
- * Agent hierarchy configuration for the CTO + Engineer Wrapper architecture.
- *
- * CTO (cto)                            — pure orchestrator, spawns engineers, reviews diffs, commits
- * Engineer Explore (engineer_explore)   — manages a Claude Code session for read-only investigation
- * Engineer Implement (engineer_implement) — manages a Claude Code session for implementation
- * Claude Code session                   — the underlying AI session (prompt only, no OpenCode agent)
- */
-import type { ManagerPromptRegistry } from '../types/contracts.js';
+import type { EngineerName, ManagerPromptRegistry } from '../types/contracts.js';
 export declare const AGENT_CTO = "cto";
-export declare const AGENT_ENGINEER_EXPLORE = "engineer_explore";
-export declare const AGENT_ENGINEER_IMPLEMENT = "engineer_implement";
-export declare const AGENT_ENGINEER_VERIFY = "engineer_verify";
-/** All restricted tool IDs (union of all domain groups) */
-export declare const ALL_RESTRICTED_TOOL_IDS: readonly ["explore", "implement", "verify", "compact_context", "clear_session", "session_health", "list_transcripts", "list_history", "git_diff", "git_commit", "git_reset", "git_status", "git_log", "approval_policy", "approval_decisions", "approval_update"];
+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"];
+export declare const ALL_RESTRICTED_TOOL_IDS: readonly ["team_status", "list_transcripts", "list_history", "git_diff", "git_commit", "git_reset", "git_status", "git_log", "approval_policy", "approval_decisions", "approval_update", "claude"];
 type ToolPermission = 'allow' | 'ask' | 'deny';
 type AgentPermission = {
     '*'?: ToolPermission;
@@ -24,13 +20,9 @@ type AgentPermission = {
     webfetch?: ToolPermission;
     websearch?: ToolPermission;
     lsp?: ToolPermission;
-    /** OpenCode built-in: manage session todo list */
     todowrite?: ToolPermission;
-    /** OpenCode built-in: read session todo list */
     todoread?: ToolPermission;
-    /** OpenCode built-in: ask the user structured questions with options */
     question?: ToolPermission;
-    /** OpenCode built-in: launch subagents (matches subagent type, last-match-wins) */
     task?: ToolPermission | Record<string, ToolPermission>;
     bash?: ToolPermission | Record<string, ToolPermission>;
     [tool: string]: ToolPermission | Record<string, ToolPermission> | undefined;
@@ -42,27 +34,13 @@ export declare function buildCtoAgentConfig(prompts: ManagerPromptRegistry): {
     permission: AgentPermission;
     prompt: string;
 };
-export declare function buildEngineerExploreAgentConfig(prompts: ManagerPromptRegistry): {
-    description: string;
-    mode: "subagent";
-    color: string;
-    permission: AgentPermission;
-    prompt: string;
-};
-export declare function buildEngineerImplementAgentConfig(prompts: ManagerPromptRegistry): {
-    description: string;
-    mode: "subagent";
-    color: string;
-    permission: AgentPermission;
-    prompt: string;
-};
-export declare function buildEngineerVerifyAgentConfig(prompts: ManagerPromptRegistry): {
+export declare function buildEngineerAgentConfig(prompts: ManagerPromptRegistry, engineer: EngineerName): {
     description: string;
     mode: "subagent";
+    hidden: boolean;
     color: string;
     permission: AgentPermission;
     prompt: string;
 };
-/** Deny all restricted tools at the global level so only designated agents can use them. */
 export declare function denyRestrictedToolsGlobally(permissions: Record<string, ToolPermission>): void;
 export {};

package/dist/plugin/agent-hierarchy.js

@@ -1,53 +1,29 @@
-/**
- * Agent hierarchy configuration for the CTO + Engineer Wrapper architecture.
- *
- * CTO (cto)                            — pure orchestrator, spawns engineers, reviews diffs, commits
- * Engineer Explore (engineer_explore)   — manages a Claude Code session for read-only investigation
- * Engineer Implement (engineer_implement) — manages a Claude Code session for implementation
- * Claude Code session                   — the underlying AI session (prompt only, no OpenCode agent)
- */
-// ---------------------------------------------------------------------------
-// Agent names
-// ---------------------------------------------------------------------------
+import { TEAM_ENGINEERS } from '../team/roster.js';
 export const AGENT_CTO = 'cto';
-export const AGENT_ENGINEER_EXPLORE = 'engineer_explore';
-export const AGENT_ENGINEER_IMPLEMENT = 'engineer_implement';
-export const AGENT_ENGINEER_VERIFY = 'engineer_verify';
-// ---------------------------------------------------------------------------
-// Tool IDs — grouped by domain
-// ---------------------------------------------------------------------------
-/** Shared engineer session tools (compact, clear, status, diagnostics) */
-const ENGINEER_SHARED_TOOL_IDS = [
-    'compact_context',
-    'clear_session',
-    'session_health',
+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',
     'list_transcripts',
     'list_history',
+    'git_diff',
+    'git_commit',
+    'git_reset',
+    'git_status',
+    'git_log',
+    'approval_policy',
+    'approval_decisions',
+    'approval_update',
 ];
-/** All engineer tools — mode-locked sends + shared session tools */
-const ENGINEER_TOOL_IDS = ['explore', 'implement', 'verify', ...ENGINEER_SHARED_TOOL_IDS];
-/** Tools for the engineer_explore wrapper (explore-mode send + shared) */
-const ENGINEER_EXPLORE_TOOL_IDS = ['explore', ...ENGINEER_SHARED_TOOL_IDS];
-/** Tools for the engineer_implement wrapper (implement-mode send + shared) */
-const ENGINEER_IMPLEMENT_TOOL_IDS = ['implement', ...ENGINEER_SHARED_TOOL_IDS];
-/** Tools for the engineer_verify wrapper (verify-mode send + shared) */
-const ENGINEER_VERIFY_TOOL_IDS = ['verify', ...ENGINEER_SHARED_TOOL_IDS];
-/** Git tools — owned by CTO */
-const GIT_TOOL_IDS = ['git_diff', 'git_commit', 'git_reset', 'git_status', 'git_log'];
-/** Approval tools — owned by CTO */
-const APPROVAL_TOOL_IDS = ['approval_policy', 'approval_decisions', 'approval_update'];
-/** All restricted tool IDs (union of all domain groups) */
-export const ALL_RESTRICTED_TOOL_IDS = [
-    ...ENGINEER_TOOL_IDS,
-    ...GIT_TOOL_IDS,
-    ...APPROVAL_TOOL_IDS,
-];
-/** Tools the CTO can use directly (git + approval only, NO engineer tools) */
-const CTO_TOOL_IDS = [...GIT_TOOL_IDS, ...APPROVAL_TOOL_IDS];
-// ---------------------------------------------------------------------------
-// Shared read-only tool permissions
-// ---------------------------------------------------------------------------
-const READONLY_TOOLS = {
+const ENGINEER_TOOL_IDS = ['claude'];
+export const ALL_RESTRICTED_TOOL_IDS = [...CTO_ONLY_TOOL_IDS, ...ENGINEER_TOOL_IDS];
+const CTO_READONLY_TOOLS = {
     read: 'allow',
     grep: 'allow',
     glob: 'allow',
@@ -60,126 +36,57 @@ const READONLY_TOOLS = {
     todoread: 'allow',
     question: 'allow',
 };
-// ---------------------------------------------------------------------------
-// Permission builders
-// ---------------------------------------------------------------------------
-/** CTO: pure orchestrator — read-only + git + approval + task (spawn engineers). No session tools. */
 function buildCtoPermissions() {
     const denied = {};
     for (const toolId of ALL_RESTRICTED_TOOL_IDS) {
         denied[toolId] = 'deny';
     }
     const allowed = {};
-    for (const toolId of CTO_TOOL_IDS) {
+    for (const toolId of CTO_ONLY_TOOL_IDS) {
         allowed[toolId] = 'allow';
     }
-    return {
-        '*': 'deny',
-        ...READONLY_TOOLS,
-        ...denied,
-        ...allowed,
-        task: {
-            '*': 'deny',
-            [AGENT_ENGINEER_EXPLORE]: 'allow',
-            [AGENT_ENGINEER_IMPLEMENT]: 'allow',
-            [AGENT_ENGINEER_VERIFY]: 'allow',
-        },
-    };
-}
-/** Engineer explore wrapper: read-only investigation + explore + shared session tools. */
-function buildEngineerExplorePermissions() {
-    const denied = {};
-    for (const toolId of ALL_RESTRICTED_TOOL_IDS) {
-        denied[toolId] = 'deny';
-    }
-    const allowed = {};
-    for (const toolId of ENGINEER_EXPLORE_TOOL_IDS) {
-        allowed[toolId] = 'allow';
+    const taskPermissions = { '*': 'deny' };
+    for (const engineer of ENGINEER_AGENT_NAMES) {
+        taskPermissions[ENGINEER_AGENT_IDS[engineer]] = 'allow';
     }
     return {
         '*': 'deny',
-        ...READONLY_TOOLS,
+        ...CTO_READONLY_TOOLS,
         ...denied,
         ...allowed,
+        task: taskPermissions,
     };
 }
-/** Engineer implement wrapper: read-only investigation + implement + shared session tools. */
-function buildEngineerImplementPermissions() {
+function buildEngineerPermissions() {
     const denied = {};
     for (const toolId of ALL_RESTRICTED_TOOL_IDS) {
         denied[toolId] = 'deny';
     }
-    const allowed = {};
-    for (const toolId of ENGINEER_IMPLEMENT_TOOL_IDS) {
-        allowed[toolId] = 'allow';
-    }
     return {
         '*': 'deny',
-        ...READONLY_TOOLS,
         ...denied,
-        ...allowed,
+        claude: 'allow',
     };
 }
-/** Engineer verify wrapper: read-only + verify + restricted bash for test/lint/typecheck/build. */
-function buildEngineerVerifyPermissions() {
-    const denied = {};
-    for (const toolId of ALL_RESTRICTED_TOOL_IDS) {
-        denied[toolId] = 'deny';
-    }
-    const allowed = {};
-    for (const toolId of ENGINEER_VERIFY_TOOL_IDS) {
-        allowed[toolId] = 'allow';
-    }
-    return {
-        '*': 'deny',
-        ...READONLY_TOOLS,
-        ...denied,
-        ...allowed,
-    };
-}
-// ---------------------------------------------------------------------------
-// Agent config builders
-// ---------------------------------------------------------------------------
 export function buildCtoAgentConfig(prompts) {
     return {
-        description: 'Delegates by default with minimal spot-checks, spawns engineers for exploration and implementation, reviews diffs, and commits.',
+        description: 'Technical orchestrator. Finds missing requirements, explicitly assigns engineers, compares plans, reviews diffs, and owns the final outcome.',
         mode: 'primary',
         color: '#D97757',
         permission: buildCtoPermissions(),
         prompt: prompts.ctoSystemPrompt,
     };
 }
-export function buildEngineerExploreAgentConfig(prompts) {
-    return {
-        description: 'Thin high-judgment wrapper that frames work quickly and dispatches to Claude Code in plan mode for read-only investigation.',
-        mode: 'subagent',
-        color: '#D97757',
-        permission: buildEngineerExplorePermissions(),
-        prompt: prompts.engineerExplorePrompt,
-    };
-}
-export function buildEngineerImplementAgentConfig(prompts) {
-    return {
-        description: 'Thin high-judgment wrapper that frames work quickly and dispatches to Claude Code in free mode for implementation.',
-        mode: 'subagent',
-        color: '#D97757',
-        permission: buildEngineerImplementPermissions(),
-        prompt: prompts.engineerImplementPrompt,
-    };
-}
-export function buildEngineerVerifyAgentConfig(prompts) {
+export function buildEngineerAgentConfig(prompts, engineer) {
     return {
-        description: 'Thin high-judgment wrapper that runs verification commands (tests, lint, typecheck, build) and reports pass/fail.',
+        description: `${engineer} is a persistent engineer who works through one Claude Code session and remembers prior turns.`,
         mode: 'subagent',
+        hidden: false,
         color: '#D97757',
-        permission: buildEngineerVerifyPermissions(),
-        prompt: prompts.engineerVerifyPrompt,
+        permission: buildEngineerPermissions(),
+        prompt: `You are ${engineer}.\n\n${prompts.engineerAgentPrompt}`,
     };
 }
-// ---------------------------------------------------------------------------
-// Global permission helper
-// ---------------------------------------------------------------------------
-/** Deny all restricted tools at the global level so only designated agents can use them. */
 export function denyRestrictedToolsGlobally(permissions) {
     for (const toolId of ALL_RESTRICTED_TOOL_IDS) {
         permissions[toolId] ??= 'deny';