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

package/dist/manager/team-orchestrator.js

@@ -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,
@@ -224,8 +223,7 @@ export class TeamOrchestrator {
         ];
         const synthesisResult = await this.sessions.runTask({
             cwd: input.cwd,
-            prompt: buildSynthesisPrompt(input.request, drafts),
-            systemPrompt: buildSynthesisSystemPrompt(this.planSynthesisPrompt),
+            prompt: `${this.planSynthesisPrompt}\n\n${buildSynthesisPrompt(input.request, drafts)}`,
             persistSession: false,
             includePartialMessages: false,
             permissionMode: 'acceptEdits',
@@ -365,9 +363,6 @@ function buildPlanDraftRequest(perspective, request) {
         `User request: ${request}`,
     ].join('\n');
 }
-function buildSynthesisSystemPrompt(planSynthesisPrompt) {
-    return planSynthesisPrompt;
-}
 function buildSynthesisPrompt(request, drafts) {
     return [
         `User request: ${request}`,

package/dist/plugin/agent-hierarchy.js

@@ -61,7 +61,11 @@ 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_TEAM_PLANNER] = 'allow';
     return {

package/dist/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/plugin/claude-manager.plugin.js

@@ -411,16 +411,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.

package/dist/prompts/registry.js

@@ -27,7 +27,7 @@ export const managerPromptRegistry = {
         '',
         'Plan and decompose:',
         '- Break work into independent pieces that can run in parallel. Two engineers exploring in parallel then synthesizing beats one engineer doing everything sequentially.',
-        '- For medium or large tasks, delegate dual-engineer exploration and synthesis to the `team-planner` subagent: task it with the request and the two engineer names (lead + challenger).',
+        "- For medium or large tasks, delegate dual-engineer exploration and synthesis to the `team-planner` subagent: use `task(subagent_type: 'team-planner', ...)`. When tasking engineer subagents directly, use lowercase subagent IDs: tom, john, maya, sara, alex.",
         '- Define clear success criteria before delegating. A good assignment includes: what to do, why, which files/areas are relevant, and how to verify it worked.',
         '',
         'Delegate through the Task tool:',

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

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);
@@ -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,
@@ -224,8 +223,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',
@@ -365,9 +363,6 @@ function buildPlanDraftRequest(perspective, request) {
         `User request: ${request}`,
     ].join('\n');
 }
-function buildSynthesisSystemPrompt(architectSystemPrompt) {
-    return architectSystemPrompt;
-}
 function buildSynthesisPrompt(request, drafts) {
     return [
         `User request: ${request}`,

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,
@@ -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. Asks for engineer names if 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

@@ -2,7 +2,7 @@ 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 { 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);
             }
@@ -129,10 +129,10 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                         abortSignal: context.abort,
                         onLeadEvent: (event) => reportClaudeEvent(context, args.leadEngineer, event),
                         onChallengerEvent: (event) => reportClaudeEvent(context, args.challengerEngineer, event),
-                        onSynthesisEvent: (event) => reportArchitectEvent(context, event),
+                        onSynthesisEvent: (event) => reportPlanSynthesisEvent(context, event),
                     });
                     context.metadata({
-                        title: '✅ Architect finished',
+                        title: '✅ Plan synthesis finished',
                         metadata: {
                             teamId: result.teamId,
                             lead: result.leadEngineer,
@@ -411,16 +411,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.
@@ -562,10 +571,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 +584,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 +617,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 +634,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 +644,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,

package/dist/src/prompts/registry.js

@@ -27,7 +27,7 @@ export const managerPromptRegistry = {
         '',
         'Plan and decompose:',
         '- Break work into independent pieces that can run in parallel. Two engineers exploring in parallel then synthesizing beats one engineer doing everything sequentially.',
-        '- For medium or large tasks, delegate dual-engineer exploration to two engineers, then task the `architect` subagent to synthesize their independent plans into one stronger plan.',
+        "- For medium or large tasks, delegate dual-engineer exploration and synthesis to the `team-planner` subagent: use `task(subagent_type: 'team-planner', ...)`. When tasking engineer subagents directly, use lowercase subagent IDs: tom, john, maya, sara, alex.",
         '- Define clear success criteria before delegating. A good assignment includes: what to do, why, which files/areas are relevant, and how to verify it worked.',
         '',
         'Delegate through the Task tool:',
@@ -76,8 +76,8 @@ export const managerPromptRegistry = {
         'Report blockers immediately with exact error output. Do not retry silently more than once.',
         'Do not run git commit, git push, git reset, git checkout, or git stash.',
     ].join('\n'),
-    architectSystemPrompt: [
-        'You are the Architect. Your role is to synthesize two independent engineering plans into one stronger, unified plan.',
+    planSynthesisPrompt: [
+        'You are synthesizing two independent engineering plans into one stronger, unified plan.',
         'Compare the lead and challenger plans on clarity, feasibility, risk, and fit to the user request.',
         'Prefer the simplest path that fully addresses the goal. Surface tradeoffs honestly.',
         'If the plans disagree on something only the user can decide, surface exactly one recommended question and one recommended answer.',
@@ -91,6 +91,14 @@ export const managerPromptRegistry = {
         '## Recommended Answer',
         '<answer or NONE>',
     ].join('\n'),
+    teamPlannerPrompt: [
+        'You are the team planner. Your only job is to invoke `plan_with_team`.',
+        '`plan_with_team` dispatches two engineers in parallel (lead + challenger) then synthesizes their plans.',
+        '',
+        'If the task includes a lead engineer and a challenger engineer, call `plan_with_team` immediately.',
+        'If either engineer name is missing, use `question` to ask: which engineers should lead and challenge (Tom, John, Maya, Sara, or Alex)?',
+        'Do not attempt any planning or analysis yourself. Delegate entirely to `plan_with_team`.',
+    ].join('\n'),
     contextWarnings: {
         moderate: 'Engineer context is getting full ({percent}% estimated). Reuse is still fine, but keep the next prompt focused.',
         high: 'Engineer context is heavy ({percent}% estimated, {turns} turns, ${cost}). Prefer a narrowly scoped follow-up or internal compaction.',

package/dist/src/types/contracts.d.ts

@@ -2,7 +2,10 @@ export interface ManagerPromptRegistry {
     ctoSystemPrompt: string;
     engineerAgentPrompt: string;
     engineerSessionPrompt: string;
-    architectSystemPrompt: string;
+    /** Prompt injected as the system prompt of the non-persistent synthesis runTask call inside plan_with_team. */
+    planSynthesisPrompt: string;
+    /** Visible subagent prompt for teamPlanner — thin bridge that calls plan_with_team. */
+    teamPlannerPrompt: string;
     contextWarnings: {
         moderate: string;
         high: string;

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

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import { ClaudeManagerPlugin } from '../src/plugin/claude-manager.plugin.js';
-import { AGENT_CTO, AGENT_ARCHITECT, ENGINEER_AGENT_IDS, ENGINEER_AGENT_NAMES, } from '../src/plugin/agent-hierarchy.js';
+import { AGENT_CTO, AGENT_TEAM_PLANNER, ENGINEER_AGENT_IDS, ENGINEER_AGENT_NAMES, } from '../src/plugin/agent-hierarchy.js';
 describe('ClaudeManagerPlugin', () => {
     it('configures CTO with orchestration tools and question access', async () => {
         const plugin = await ClaudeManagerPlugin({
@@ -34,16 +34,38 @@ describe('ClaudeManagerPlugin', () => {
             git_log: 'allow',
             claude: 'deny',
         });
+        // Task permissions should include both uppercase (user-friendly) and lowercase (canonical) agent IDs.
         expect(cto.permission.task).toEqual({
             '*': 'deny',
+            Tom: 'allow',
             tom: 'allow',
+            John: 'allow',
             john: 'allow',
+            Maya: 'allow',
             maya: 'allow',
+            Sara: 'allow',
             sara: 'allow',
+            Alex: 'allow',
             alex: 'allow',
-            architect: 'allow',
+            'team-planner': 'allow',
         });
     });
+    it('allows CTO to delegate to engineers using both uppercase and lowercase agent IDs', async () => {
+        const plugin = await ClaudeManagerPlugin({
+            worktree: '/tmp/project',
+        });
+        const config = {};
+        await plugin.config?.(config);
+        const agents = (config.agent ?? {});
+        const cto = agents[AGENT_CTO];
+        const taskPerms = cto.permission.task;
+        // Verify both uppercase and lowercase can be used for delegation.
+        // This prevents delegation failures when users write task(subagent_type: 'Maya') vs task(subagent_type: 'maya').
+        expect(taskPerms.Tom).toBe('allow');
+        expect(taskPerms.tom).toBe('allow');
+        expect(taskPerms.Maya).toBe('allow');
+        expect(taskPerms.maya).toBe('allow');
+    });
     it('configures every named engineer with only the claude bridge tool', async () => {
         const plugin = await ClaudeManagerPlugin({
             worktree: '/tmp/project',
@@ -69,26 +91,25 @@ describe('ClaudeManagerPlugin', () => {
             expect(agent.permission).not.toHaveProperty('grep');
         }
     });
-    it('configures architect as a read-only subagent for plan synthesis', async () => {
+    it('configures team-planner as a planning-bridge subagent', async () => {
         const plugin = await ClaudeManagerPlugin({
             worktree: '/tmp/project',
         });
         const config = {};
         await plugin.config?.(config);
         const agents = (config.agent ?? {});
-        const architect = agents[AGENT_ARCHITECT];
-        expect(architect).toBeDefined();
-        expect(architect.mode).toBe('subagent');
-        expect(architect.description.toLowerCase()).toContain('synthesiz');
-        expect(architect.permission).toMatchObject({
+        const teamPlanner = agents[AGENT_TEAM_PLANNER];
+        expect(teamPlanner).toBeDefined();
+        expect(teamPlanner.mode).toBe('subagent');
+        expect(teamPlanner.description.toLowerCase()).toContain('plan');
+        expect(teamPlanner.permission).toMatchObject({
             '*': 'deny',
-            read: 'allow',
-            grep: 'allow',
-            glob: 'allow',
-            list: 'allow',
-            codesearch: 'allow',
+            plan_with_team: 'allow',
+            question: 'allow',
             claude: 'deny',
         });
+        expect(teamPlanner.permission).not.toHaveProperty('read');
+        expect(teamPlanner.permission).not.toHaveProperty('grep');
     });
     it('registers the named engineer bridge and team status tools', async () => {
         const plugin = await ClaudeManagerPlugin({
@@ -129,3 +150,53 @@ describe('ClaudeManagerPlugin', () => {
         expect(plugin['experimental.chat.system.transform']).toBeTypeOf('function');
     });
 });
+describe('Agent ID normalization and lookup helpers', () => {
+    it('normalizeAgentId converts mixed-case agent IDs to lowercase', async () => {
+        const { normalizeAgentId } = await import('../src/plugin/claude-manager.plugin.js');
+        expect(normalizeAgentId('Tom')).toBe('tom');
+        expect(normalizeAgentId('MAYA')).toBe('maya');
+        expect(normalizeAgentId('john')).toBe('john');
+        expect(normalizeAgentId('JoHn')).toBe('john');
+    });
+    it('engineerFromAgent resolves both uppercase and lowercase agent IDs', async () => {
+        const { engineerFromAgent } = await import('../src/plugin/claude-manager.plugin.js');
+        // Lowercase (canonical)
+        expect(engineerFromAgent('tom')).toBe('Tom');
+        expect(engineerFromAgent('maya')).toBe('Maya');
+        expect(engineerFromAgent('john')).toBe('John');
+        // Uppercase (normalized)
+        expect(engineerFromAgent('Tom')).toBe('Tom');
+        expect(engineerFromAgent('Maya')).toBe('Maya');
+        expect(engineerFromAgent('John')).toBe('John');
+        // Mixed case
+        expect(engineerFromAgent('JoHn')).toBe('John');
+        expect(engineerFromAgent('mAyA')).toBe('Maya');
+    });
+    it('engineerFromAgent throws on invalid agent IDs', async () => {
+        const { engineerFromAgent } = await import('../src/plugin/claude-manager.plugin.js');
+        expect(() => engineerFromAgent('invalid')).toThrow('The claude tool can only be used from a named engineer agent');
+        expect(() => engineerFromAgent('TomInvalid')).toThrow('The claude tool can only be used from a named engineer agent');
+    });
+    it('isEngineerAgent identifies both uppercase and lowercase agent IDs', async () => {
+        const { isEngineerAgent } = await import('../src/plugin/claude-manager.plugin.js');
+        // Lowercase (canonical)
+        expect(isEngineerAgent('tom')).toBe(true);
+        expect(isEngineerAgent('maya')).toBe(true);
+        expect(isEngineerAgent('john')).toBe(true);
+        expect(isEngineerAgent('sara')).toBe(true);
+        expect(isEngineerAgent('alex')).toBe(true);
+        // Uppercase (normalized)
+        expect(isEngineerAgent('Tom')).toBe(true);
+        expect(isEngineerAgent('Maya')).toBe(true);
+        expect(isEngineerAgent('John')).toBe(true);
+        expect(isEngineerAgent('Sara')).toBe(true);
+        expect(isEngineerAgent('Alex')).toBe(true);
+        // Mixed case
+        expect(isEngineerAgent('JoHn')).toBe(true);
+        expect(isEngineerAgent('mAyA')).toBe(true);
+        // Invalid
+        expect(isEngineerAgent('invalid')).toBe(false);
+        expect(isEngineerAgent('cto')).toBe(false);
+        expect(isEngineerAgent('team-planner')).toBe(false);
+    });
+});

package/dist/test/prompt-registry.test.js

@@ -5,7 +5,7 @@ describe('managerPromptRegistry', () => {
         expect(managerPromptRegistry.ctoSystemPrompt).toContain('You are a principal engineer orchestrating a team of AI-powered engineers');
         expect(managerPromptRegistry.ctoSystemPrompt).toContain('Task tool');
         expect(managerPromptRegistry.ctoSystemPrompt).toContain('dual-engineer');
-        expect(managerPromptRegistry.ctoSystemPrompt).toContain('architect');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('team-planner');
         expect(managerPromptRegistry.ctoSystemPrompt).toContain('question');
         expect(managerPromptRegistry.ctoSystemPrompt).toContain('Tom, John, Maya, Sara, and Alex');
         expect(managerPromptRegistry.ctoSystemPrompt).not.toContain('clear_session');
@@ -29,12 +29,16 @@ describe('managerPromptRegistry', () => {
         expect(managerPromptRegistry.contextWarnings.high).toContain('{turns}');
         expect(managerPromptRegistry.contextWarnings.critical).toContain('near capacity');
     });
-    it('gives the architect synthesis guidance with complete output format', () => {
-        expect(managerPromptRegistry.architectSystemPrompt).toContain('Architect');
-        expect(managerPromptRegistry.architectSystemPrompt).toContain('synthesiz');
-        expect(managerPromptRegistry.architectSystemPrompt).toContain('two independent');
-        expect(managerPromptRegistry.architectSystemPrompt).toContain('## Synthesis');
-        expect(managerPromptRegistry.architectSystemPrompt).toContain('## Recommended Question');
-        expect(managerPromptRegistry.architectSystemPrompt).toContain('## Recommended Answer');
+    it('planSynthesisPrompt contains synthesis guidance and complete output format', () => {
+        expect(managerPromptRegistry.planSynthesisPrompt).toContain('synthesiz');
+        expect(managerPromptRegistry.planSynthesisPrompt).toContain('two independent');
+        expect(managerPromptRegistry.planSynthesisPrompt).toContain('## Synthesis');
+        expect(managerPromptRegistry.planSynthesisPrompt).toContain('## Recommended Question');
+        expect(managerPromptRegistry.planSynthesisPrompt).toContain('## Recommended Answer');
+    });
+    it('teamPlannerPrompt directs the agent to call plan_with_team and ask if engineers are missing', () => {
+        expect(managerPromptRegistry.teamPlannerPrompt).toContain('plan_with_team');
+        expect(managerPromptRegistry.teamPlannerPrompt).toContain('question');
+        expect(managerPromptRegistry.teamPlannerPrompt).toContain('engineer');
     });
 });

package/dist/test/report-claude-event.test.js

@@ -180,7 +180,7 @@ describe('second invocation continuity', () => {
         // ── Phase 1: first task via orchestrator (no real SDK needed) ──────────
         const store = new TeamStateStore();
         await store.setActiveTeam(tempRoot, 'cto-1');
-        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, store, { appendEvents: vi.fn(async () => undefined) }, 'Base prompt', 'Architect prompt');
+        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, store, { appendEvents: vi.fn(async () => undefined) }, 'Base prompt', 'Synthesis prompt');
         await orchestrator.recordWrapperSession(tempRoot, 'cto-1', 'Tom', 'wrapper-tom-1');
         await orchestrator.recordWrapperExchange(tempRoot, 'cto-1', 'Tom', 'wrapper-tom-1', 'explore', 'Investigate the auth flow', 'Found two race conditions in the token refresh path.');
         // ── Phase 2: process restart ───────────────────────────────────────────
@@ -206,7 +206,7 @@ describe('second invocation continuity', () => {
         // ── Phase 1: pre-seed Tom with a claudeSessionId ───────────────────────
         const store = new TeamStateStore();
         await store.setActiveTeam(tempRoot, 'cto-1');
-        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, store, { appendEvents: vi.fn(async () => undefined) }, 'Base prompt', 'Architect prompt');
+        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, store, { appendEvents: vi.fn(async () => undefined) }, 'Base prompt', 'Synthesis prompt');
         await orchestrator.getOrCreateTeam(tempRoot, 'cto-1');
         await store.updateTeam(tempRoot, 'cto-1', (team) => ({
             ...team,
@@ -240,7 +240,7 @@ describe('second invocation continuity', () => {
         expect(runTask).toHaveBeenCalledOnce();
         expect(runTask.mock.calls[0]?.[0]).toMatchObject({
             resumeSessionId: 'ses-tom-persisted',
-            systemPrompt: undefined, // no new system prompt when resuming
         });
+        expect(runTask.mock.calls[0]?.[0].systemPrompt).toBeUndefined(); // no system prompt when resuming
     });
 });

package/dist/test/team-orchestrator.test.js

@@ -35,7 +35,7 @@ describe('TeamOrchestrator', () => {
             outputTokens: 300,
             contextWindowSize: 200_000,
         });
-        const orchestrator = new TeamOrchestrator({ runTask }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Architect prompt');
+        const orchestrator = new TeamOrchestrator({ runTask }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt');
         const first = await orchestrator.dispatchEngineer({
             teamId: 'team-1',
             cwd: tempRoot,
@@ -53,17 +53,22 @@ describe('TeamOrchestrator', () => {
         expect(first.sessionId).toBe('ses_tom');
         expect(second.sessionId).toBe('ses_tom');
         expect(runTask.mock.calls[0]?.[0]).toMatchObject({
-            systemPrompt: expect.stringContaining('Assigned engineer: Tom.'),
             resumeSessionId: undefined,
             permissionMode: 'acceptEdits',
             restrictWriteTools: true,
         });
+        expect(runTask.mock.calls[0]?.[0].systemPrompt).toBeUndefined();
+        expect(runTask.mock.calls[0]?.[0].prompt).toContain('Base engineer prompt');
+        expect(runTask.mock.calls[0]?.[0].prompt).toContain('Assigned engineer: Tom.');
+        expect(runTask.mock.calls[0]?.[0].prompt).toContain('Investigate the auth flow');
         expect(runTask.mock.calls[1]?.[0]).toMatchObject({
-            systemPrompt: undefined,
             resumeSessionId: 'ses_tom',
             permissionMode: 'acceptEdits',
             restrictWriteTools: false,
         });
+        expect(runTask.mock.calls[1]?.[0].systemPrompt).toBeUndefined();
+        expect(runTask.mock.calls[1]?.[0].prompt).not.toContain('Assigned engineer: Tom.');
+        expect(runTask.mock.calls[1]?.[0].prompt).toContain('Implement the chosen fix');
         const team = await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
         expect(team.engineers.find((engineer) => engineer.name === 'Tom')).toMatchObject({
             claudeSessionId: 'ses_tom',
@@ -74,7 +79,7 @@ describe('TeamOrchestrator', () => {
     it('rejects work when the same engineer is already busy', async () => {
         tempRoot = await mkdtemp(join(tmpdir(), 'team-orchestrator-'));
         const store = new TeamStateStore('.state');
-        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, store, { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Architect prompt');
+        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, store, { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt');
         const team = await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
         await store.saveTeam({
             ...team,
@@ -112,7 +117,7 @@ describe('TeamOrchestrator', () => {
             events: [],
             finalText: '## Synthesis\nCombined plan\n## Recommended Question\nShould we migrate now?\n## Recommended Answer\nNo, defer it.',
         });
-        const orchestrator = new TeamOrchestrator({ runTask }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Architect prompt');
+        const orchestrator = new TeamOrchestrator({ runTask }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt');
         const result = await orchestrator.planWithTeam({
             teamId: 'team-1',
             cwd: tempRoot,
@@ -125,6 +130,10 @@ describe('TeamOrchestrator', () => {
         expect(result.recommendedQuestion).toBe('Should we migrate now?');
         expect(result.recommendedAnswer).toBe('No, defer it.');
         expect(runTask).toHaveBeenCalledTimes(3);
+        const synthesisCall = runTask.mock.calls[2]?.[0];
+        expect(synthesisCall.systemPrompt).toBeUndefined();
+        expect(synthesisCall.prompt).toContain('Synthesis prompt');
+        expect(synthesisCall.prompt).toContain('Plan the billing refactor');
     });
     it('invokes lead, challenger, and synthesis event callbacks', async () => {
         tempRoot = await mkdtemp(join(tmpdir(), 'team-orchestrator-'));
@@ -157,7 +166,7 @@ describe('TeamOrchestrator', () => {
                 };
             }
         });
-        const orchestrator = new TeamOrchestrator({ runTask }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Architect prompt');
+        const orchestrator = new TeamOrchestrator({ runTask }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt');
         const onLeadEvent = vi.fn();
         const onChallengerEvent = vi.fn();
         const onSynthesisEvent = vi.fn();
@@ -177,7 +186,7 @@ describe('TeamOrchestrator', () => {
     });
     it('persists wrapper session memory for an engineer', async () => {
         tempRoot = await mkdtemp(join(tmpdir(), 'team-orchestrator-'));
-        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Architect prompt');
+        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt');
         await orchestrator.recordWrapperSession(tempRoot, 'team-1', 'Tom', 'wrapper-tom');
         await orchestrator.recordWrapperExchange(tempRoot, 'team-1', 'Tom', 'wrapper-tom', 'explore', 'Investigate the auth flow and compare approaches', 'The auth flow uses one shared validator and the cookie refresh path is the main risk.');
         const team = await orchestrator.getOrCreateTeam(tempRoot, 'team-1');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doingdev/opencode-claude-manager-plugin",
-  "version": "0.1.55",
+  "version": "0.1.56",
   "description": "OpenCode plugin that orchestrates Claude Code sessions.",
   "keywords": [
     "opencode",