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

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

@@ -18,8 +18,8 @@ export declare class TeamOrchestrator {
     private readonly teamStore;
     private readonly transcriptStore;
     private readonly engineerSessionPrompt;
-    private readonly architectSystemPrompt;
-    constructor(sessions: ClaudeSessionService, teamStore: TeamStateStore, transcriptStore: TranscriptStore, engineerSessionPrompt: string, architectSystemPrompt: string);
+    private readonly planSynthesisPrompt;
+    constructor(sessions: ClaudeSessionService, teamStore: TeamStateStore, transcriptStore: TranscriptStore, engineerSessionPrompt: string, planSynthesisPrompt: string);
     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 +33,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 +41,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 +53,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/src/manager/team-orchestrator.js

@@ -6,13 +6,13 @@ export class TeamOrchestrator {
     teamStore;
     transcriptStore;
     engineerSessionPrompt;
-    architectSystemPrompt;
-    constructor(sessions, teamStore, transcriptStore, engineerSessionPrompt, architectSystemPrompt) {
+    planSynthesisPrompt;
+    constructor(sessions, teamStore, transcriptStore, engineerSessionPrompt, planSynthesisPrompt) {
         this.sessions = sessions;
         this.teamStore = teamStore;
         this.transcriptStore = transcriptStore;
         this.engineerSessionPrompt = engineerSessionPrompt;
-        this.architectSystemPrompt = architectSystemPrompt;
+        this.planSynthesisPrompt = planSynthesisPrompt;
     }
     async getOrCreateTeam(cwd, teamId) {
         const existing = await this.teamStore.getTeam(cwd, teamId);
@@ -88,7 +88,7 @@ export class TeamOrchestrator {
             context: options?.clearSession ? createEmptyEngineerRecord(engineer).context : entry.context,
         }));
     }
-    async dispatchEngineer(input) {
+    async dispatchEngineer(input, retryCount = 0) {
         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);
@@ -106,10 +106,9 @@ export class TeamOrchestrator {
             }
             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),
+                prompt: engineerState.claudeSessionId
+                    ? this.buildEngineerPrompt(input.mode, input.message)
+                    : `${this.buildSessionSystemPrompt(input.engineer, input.mode)}\n\n${this.buildEngineerPrompt(input.mode, input.message)}`,
                 resumeSessionId: engineerState.claudeSessionId ?? undefined,
                 persistSession: true,
                 includePartialMessages: true,
@@ -162,6 +161,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;
         }
     }
@@ -193,14 +225,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,
@@ -210,7 +241,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,
@@ -224,8 +255,7 @@ export class TeamOrchestrator {
         ];
         const synthesisResult = await this.sessions.runTask({
             cwd: input.cwd,
-            prompt: buildSynthesisPrompt(input.request, drafts),
-            systemPrompt: buildSynthesisSystemPrompt(this.architectSystemPrompt),
+            prompt: `${this.planSynthesisPrompt}\n\n${buildSynthesisPrompt(input.request, drafts)}`,
             persistSession: false,
             includePartialMessages: false,
             permissionMode: 'acceptEdits',
@@ -239,8 +269,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,
@@ -296,6 +326,47 @@ export class TeamOrchestrator {
             engineers: createEmptyTeamRecord(team.id, team.cwd).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 available = this.getAvailableEngineers(team);
+        if (available.length < 2) {
+            throw new Error(`Not enough available engineers for dual planning. Need 2, 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) {
         return [
             this.engineerSessionPrompt,
@@ -365,9 +436,6 @@ function buildPlanDraftRequest(perspective, request) {
         `User request: ${request}`,
     ].join('\n');
 }
-function buildSynthesisSystemPrompt(architectSystemPrompt) {
-    return architectSystemPrompt;
-}
 function buildSynthesisPrompt(request, drafts) {
     return [
         `User request: ${request}`,
@@ -403,3 +471,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/src/plugin/agent-hierarchy.d.ts

@@ -1,6 +1,6 @@
 import type { EngineerName, ManagerPromptRegistry } from '../types/contracts.js';
 export declare const AGENT_CTO = "cto";
-export declare const AGENT_ARCHITECT = "architect";
+export declare const AGENT_TEAM_PLANNER = "team-planner";
 export declare const ENGINEER_AGENT_IDS: {
     readonly Tom: "tom";
     readonly John: "john";
@@ -42,7 +42,7 @@ export declare function buildEngineerAgentConfig(prompts: ManagerPromptRegistry,
     permission: AgentPermission;
     prompt: string;
 };
-export declare function buildArchitectAgentConfig(prompts: ManagerPromptRegistry): {
+export declare function buildTeamPlannerAgentConfig(prompts: ManagerPromptRegistry): {
     description: string;
     mode: "subagent";
     hidden: boolean;

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

@@ -1,6 +1,6 @@
 import { TEAM_ENGINEERS } from '../team/roster.js';
 export const AGENT_CTO = 'cto';
-export const AGENT_ARCHITECT = 'architect';
+export const AGENT_TEAM_PLANNER = 'team-planner';
 export const ENGINEER_AGENT_IDS = {
     Tom: 'tom',
     John: 'john',
@@ -38,24 +38,15 @@ const CTO_READONLY_TOOLS = {
     todoread: 'allow',
     question: 'allow',
 };
-function buildArchitectPermissions() {
+function buildTeamPlannerPermissions() {
     const denied = {};
     for (const toolId of ALL_RESTRICTED_TOOL_IDS) {
         denied[toolId] = 'deny';
     }
     return {
         '*': 'deny',
-        read: 'allow',
-        grep: 'allow',
-        glob: 'allow',
-        list: 'allow',
-        codesearch: 'allow',
-        webfetch: 'deny',
-        websearch: 'deny',
-        lsp: 'deny',
-        todowrite: 'deny',
-        todoread: 'deny',
-        question: 'deny',
+        plan_with_team: 'allow',
+        question: 'allow',
         ...denied,
     };
 }
@@ -70,9 +61,13 @@ function buildCtoPermissions() {
     }
     const taskPermissions = { '*': 'deny' };
     for (const engineer of ENGINEER_AGENT_NAMES) {
-        taskPermissions[ENGINEER_AGENT_IDS[engineer]] = 'allow';
+        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_ARCHITECT] = 'allow';
+    taskPermissions[AGENT_TEAM_PLANNER] = 'allow';
     return {
         '*': 'deny',
         ...CTO_READONLY_TOOLS,
@@ -103,7 +98,7 @@ export function buildCtoAgentConfig(prompts) {
 }
 export function buildEngineerAgentConfig(prompts, engineer) {
     return {
-        description: `${engineer} is a persistent engineer who works through one Claude Code session and remembers prior turns.`,
+        description: `${engineer} is a persistent engineer who works through one Claude Code session and remembers prior turns. Receives structured assignments (goal, mode, context, acceptance criteria, relevant paths, constraints, verification).`,
         mode: 'subagent',
         hidden: false,
         color: '#D97757',
@@ -111,14 +106,14 @@ export function buildEngineerAgentConfig(prompts, engineer) {
         prompt: `You are ${engineer}.\n\n${prompts.engineerAgentPrompt}`,
     };
 }
-export function buildArchitectAgentConfig(prompts) {
+export function buildTeamPlannerAgentConfig(prompts) {
     return {
-        description: 'Synthesizes two engineer plan drafts into one stronger, actionable plan.',
+        description: 'Runs dual-engineer planning by calling plan_with_team. Automatically selects two non-overlapping available engineers if engineer names are not provided.',
         mode: 'subagent',
         hidden: false,
         color: '#D97757',
-        permission: buildArchitectPermissions(),
-        prompt: prompts.architectSystemPrompt,
+        permission: buildTeamPlannerPermissions(),
+        prompt: prompts.teamPlannerPrompt,
     };
 }
 export function denyRestrictedToolsGlobally(permissions) {

package/dist/src/plugin/claude-manager.plugin.d.ts

@@ -1,2 +1,10 @@
 import { type Plugin } from '@opencode-ai/plugin';
+import type { EngineerName } from '../types/contracts.js';
 export declare const ClaudeManagerPlugin: Plugin;
+/**
+ * Normalize an agent ID to its lowercase canonical form.
+ * Handles both uppercase (e.g., 'Tom') and lowercase (e.g., 'tom') inputs.
+ */
+export declare function normalizeAgentId(agentId: string): string;
+export declare function engineerFromAgent(agentId: string): EngineerName;
+export declare function isEngineerAgent(agentId: string): boolean;

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

@@ -1,8 +1,8 @@
 import { tool } from '@opencode-ai/plugin';
 import { managerPromptRegistry } from '../prompts/registry.js';
 import { isEngineerName } from '../team/roster.js';
-import { TeamOrchestrator } from '../manager/team-orchestrator.js';
-import { AGENT_CTO, AGENT_ARCHITECT, ENGINEER_AGENT_IDS, ENGINEER_AGENT_NAMES, buildCtoAgentConfig, buildEngineerAgentConfig, buildArchitectAgentConfig, denyRestrictedToolsGlobally, } from './agent-hierarchy.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';
 const MODEL_ENUM = ['claude-opus-4-6', 'claude-sonnet-4-6'];
 const MODE_ENUM = ['explore', 'implement', 'verify'];
@@ -15,7 +15,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
             config.permission ??= {};
             denyRestrictedToolsGlobally(config.permission);
             config.agent[AGENT_CTO] ??= buildCtoAgentConfig(managerPromptRegistry);
-            config.agent[AGENT_ARCHITECT] ??= buildArchitectAgentConfig(managerPromptRegistry);
+            config.agent[AGENT_TEAM_PLANNER] ??= buildTeamPlannerAgentConfig(managerPromptRegistry);
             for (const engineer of ENGINEER_AGENT_NAMES) {
                 config.agent[ENGINEER_AGENT_IDS[engineer]] ??= buildEngineerAgentConfig(managerPromptRegistry, engineer);
             }
@@ -105,34 +105,36 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                 },
             }),
             plan_with_team: tool({
-                description: 'Run dual-engineer plan synthesis. Two engineers explore in parallel (lead + challenger), then their plans are synthesized into one stronger plan.',
+                description: 'Run dual-engineer plan synthesis. Two engineers explore in parallel (lead + challenger), then their plans are synthesized into one stronger plan. Automatically selects distinct available engineers if names are not provided.',
                 args: {
                     request: tool.schema.string().min(1),
-                    leadEngineer: tool.schema.enum(['Tom', 'John', 'Maya', 'Sara', 'Alex']),
-                    challengerEngineer: tool.schema.enum(['Tom', 'John', 'Maya', 'Sara', 'Alex']),
+                    leadEngineer: tool.schema.enum(['Tom', 'John', 'Maya', 'Sara', 'Alex']).optional(),
+                    challengerEngineer: tool.schema.enum(['Tom', 'John', 'Maya', 'Sara', 'Alex']).optional(),
                     model: tool.schema.enum(MODEL_ENUM).optional(),
                 },
                 async execute(args, context) {
                     const teamId = getActiveTeamSession(context.worktree) ?? 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', {
                         teamId,
-                        lead: args.leadEngineer,
-                        challenger: args.challengerEngineer,
+                        lead,
+                        challenger,
                     });
                     const result = await services.orchestrator.planWithTeam({
                         teamId,
                         cwd: context.worktree,
                         request: args.request,
-                        leadEngineer: args.leadEngineer,
-                        challengerEngineer: args.challengerEngineer,
+                        leadEngineer: lead,
+                        challengerEngineer: challenger,
                         model: args.model,
                         abortSignal: context.abort,
-                        onLeadEvent: (event) => reportClaudeEvent(context, args.leadEngineer, event),
-                        onChallengerEvent: (event) => reportClaudeEvent(context, args.challengerEngineer, event),
-                        onSynthesisEvent: (event) => reportArchitectEvent(context, event),
+                        onLeadEvent: (event) => reportClaudeEvent(context, lead, event),
+                        onChallengerEvent: (event) => reportClaudeEvent(context, challenger, event),
+                        onSynthesisEvent: (event) => reportPlanSynthesisEvent(context, event),
                     });
                     context.metadata({
-                        title: '✅ Architect finished',
+                        title: '✅ Plan synthesis finished',
                         metadata: {
                             teamId: result.teamId,
                             lead: result.leadEngineer,
@@ -386,6 +388,7 @@ async function runEngineerAssignment(input, context) {
         failure.teamId = input.teamId;
         failure.engineer = input.engineer;
         failure.mode = input.mode;
+        const guidance = getFailureGuidanceText(failure.failureKind);
         context.metadata({
             title: `❌ ${input.engineer} failed (${failure.failureKind})`,
             metadata: {
@@ -393,9 +396,10 @@ async function runEngineerAssignment(input, context) {
                 engineer: failure.engineer,
                 failureKind: failure.failureKind,
                 message: failure.message.slice(0, 200),
+                guidance,
             },
         });
-        throw error;
+        throw createActionableError(failure, error);
     }
     await services.orchestrator.recordWrapperExchange(context.worktree, input.teamId, input.engineer, context.sessionID, input.mode, input.message, result.finalText);
     context.metadata({
@@ -411,16 +415,25 @@ async function runEngineerAssignment(input, context) {
     });
     return result;
 }
-function engineerFromAgent(agentId) {
-    const engineerEntry = Object.entries(ENGINEER_AGENT_IDS).find(([, value]) => value === agentId);
+/**
+ * Normalize an agent ID to its lowercase canonical form.
+ * Handles both uppercase (e.g., 'Tom') and lowercase (e.g., 'tom') inputs.
+ */
+export function normalizeAgentId(agentId) {
+    return agentId.toLowerCase();
+}
+export function engineerFromAgent(agentId) {
+    const normalized = normalizeAgentId(agentId);
+    const engineerEntry = Object.entries(ENGINEER_AGENT_IDS).find(([, value]) => value === normalized);
     const engineer = engineerEntry?.[0];
     if (!engineer || !isEngineerName(engineer)) {
         throw new Error(`The claude tool can only be used from a named engineer agent. Received agent ${agentId}.`);
     }
     return engineer;
 }
-function isEngineerAgent(agentId) {
-    return Object.values(ENGINEER_AGENT_IDS).includes(agentId);
+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.
@@ -496,6 +509,16 @@ function reportClaudeEvent(context, engineer, event) {
         });
         return;
     }
+    if (event.type === 'status') {
+        context.metadata({
+            title: `ℹ️ ${engineer}: ${event.text}`,
+            metadata: {
+                engineer,
+                status: event.text,
+            },
+        });
+        return;
+    }
     if (event.type === 'init') {
         context.metadata({
             title: `⚡ ${engineer} session ready`,
@@ -562,10 +585,10 @@ function reportClaudeEvent(context, engineer, event) {
         });
     }
 }
-function reportArchitectEvent(context, event) {
+function reportPlanSynthesisEvent(context, event) {
     if (event.type === 'error') {
         context.metadata({
-            title: `❌ Architect hit an error`,
+            title: `❌ Plan synthesis hit an error`,
             metadata: {
                 sessionId: event.sessionId,
                 error: event.text.slice(0, 200),
@@ -575,7 +598,7 @@ function reportArchitectEvent(context, event) {
     }
     if (event.type === 'init') {
         context.metadata({
-            title: `⚡ Architect session ready`,
+            title: `⚡ Plan synthesis ready`,
             metadata: {
                 sessionId: event.sessionId,
             },
@@ -608,10 +631,10 @@ function reportArchitectEvent(context, event) {
         const toolDescription = formatToolDescription(toolName ?? '', toolArgs);
         context.metadata({
             title: toolDescription
-                ? `⚡ Architect → ${toolDescription}`
+                ? `⚡ Plan synthesis → ${toolDescription}`
                 : toolName
-                    ? `⚡ Architect → ${toolName}`
-                    : `⚡ Architect is using Claude Code tools`,
+                    ? `⚡ Plan synthesis → ${toolName}`
+                    : `⚡ Plan synthesis is running`,
             metadata: {
                 sessionId: event.sessionId,
                 ...(toolName !== undefined && { toolName }),
@@ -625,7 +648,7 @@ function reportArchitectEvent(context, event) {
         const isThinking = event.text.startsWith('<thinking>');
         const stateLabel = event.type === 'partial' && isThinking ? 'is thinking' : 'is working';
         context.metadata({
-            title: `⚡ Architect ${stateLabel}`,
+            title: `⚡ Plan synthesis ${stateLabel}`,
             metadata: {
                 sessionId: event.sessionId,
                 preview: event.text.slice(0, 160),
@@ -635,8 +658,9 @@ function reportArchitectEvent(context, event) {
     }
 }
 function annotateToolRun(context, title, metadata) {
+    const agentLabel = context.agent === AGENT_CTO ? 'CTO' : undefined;
     context.metadata({
-        title,
+        title: agentLabel ? `${agentLabel} → ${title}` : title,
         metadata,
     });
 }

package/dist/src/plugin/service-factory.js

@@ -24,7 +24,7 @@ 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.architectSystemPrompt);
+    const orchestrator = new TeamOrchestrator(sessionService, teamStore, transcriptStore, managerPromptRegistry.engineerSessionPrompt, managerPromptRegistry.planSynthesisPrompt);
     const services = {
         manager,
         sessions: sessionService,