codingbuddy 5.1.3 → 5.3.0

package/README.md

@@ -21,6 +21,11 @@ npx codingbuddy init
 |---------|-------------|
 | `codingbuddy init` | Analyze project and generate configuration |
 | `codingbuddy mcp` | Start MCP server (stdio mode by default) |
+| `codingbuddy install <source>` | Install plugin from git URL or registry |
+| `codingbuddy search <query>` | Search plugins in registry |
+| `codingbuddy plugins` | List installed plugins |
+| `codingbuddy update [name]` | Update outdated plugins |
+| `codingbuddy uninstall <name>` | Uninstall plugin |
 | `codingbuddy --help` | Show help |
 | `codingbuddy --version` | Show version |
 
@@ -45,6 +50,10 @@ npx codingbuddy init
 | `get_code_conventions` | **🆕** Get project code conventions from config files (tsconfig, eslint, prettier, editorconfig, markdownlint) |
 | `generate_checklist` | Generate contextual checklists including conventions domain |
 | `analyze_task` | Comprehensive task analysis with risk assessment |
+| `pr_quality_report` | Run specialist agents on changed files for PR quality |
+| `create_briefing` | Capture session state for cross-session recovery |
+| `resume_session` | Load previous session briefing |
+| `get_rule_impact_report` | Rule effectiveness analytics |
 
 ### MCP Prompts
 

package/dist/src/agent/agent-prompt.builder.js

@@ -31,6 +31,40 @@ const MODE_TASK_PREFIXES = {
     EVAL: 'review',
     AUTO: 'autonomous execution',
 };
+const MAX_LIST_ITEMS = 10;
+function trimList(items, maxItems = MAX_LIST_ITEMS) {
+    if (items.length <= maxItems)
+        return items;
+    const remaining = items.length - maxItems;
+    return [...items.slice(0, maxItems), `... and ${remaining} more`];
+}
+function renderValueAsText(value, sections, indent = '') {
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            if (item && typeof item === 'object') {
+                renderValueAsText(item, sections, indent);
+            }
+            else {
+                sections.push(`${indent}- ${item}`);
+            }
+        }
+    }
+    else if (value && typeof value === 'object') {
+        for (const [key, val] of Object.entries(value)) {
+            if (Array.isArray(val)) {
+                sections.push(`${indent}- **${key}**:`);
+                renderValueAsText(val, sections, indent + '  ');
+            }
+            else if (val && typeof val === 'object') {
+                sections.push(`${indent}- **${key}**:`);
+                renderValueAsText(val, sections, indent + '  ');
+            }
+            else {
+                sections.push(`${indent}- **${key}**: ${val}`);
+            }
+        }
+    }
+}
 function buildAgentSystemPrompt(agentProfile, context) {
     const sections = [];
     sections.push(`# ${agentProfile.name}`);
@@ -52,11 +86,110 @@ function buildAgentSystemPrompt(agentProfile, context) {
         }
         sections.push('');
     }
+    const rawProfile = agentProfile;
+    const activation = rawProfile.activation;
+    const activationChecklist = activation?.mandatory_checklist;
+    if (activationChecklist &&
+        typeof activationChecklist === 'object' &&
+        !Array.isArray(activationChecklist)) {
+        sections.push('## Mandatory Checklist');
+        const items = [];
+        for (const [name, item] of Object.entries(activationChecklist)) {
+            if (item && typeof item === 'object' && 'rule' in item) {
+                items.push(`- [${name}] ${item.rule}`);
+            }
+        }
+        for (const line of trimList(items)) {
+            sections.push(line);
+        }
+        sections.push('');
+    }
+    else if (Array.isArray(rawProfile.mandatory_checklist) &&
+        rawProfile.mandatory_checklist.length) {
+        sections.push('## Mandatory Checklist');
+        const items = rawProfile.mandatory_checklist.map((item) => `- ${item}`);
+        for (const line of trimList(items)) {
+            sections.push(line);
+        }
+        sections.push('');
+    }
+    const comm = rawProfile.communication;
+    if (comm?.language) {
+        sections.push('## Communication');
+        sections.push(`IMPORTANT: Always respond in ${comm.language}.`);
+        sections.push('');
+    }
+    const skills = rawProfile.skills;
+    if (skills?.required?.length) {
+        sections.push('## Required Skills');
+        for (const s of skills.required) {
+            sections.push(`- **${s.name}**: ${s.purpose} (when: ${s.when})`);
+        }
+        sections.push('');
+    }
+    if (skills?.recommended?.length) {
+        sections.push('## Recommended Skills');
+        for (const s of skills.recommended) {
+            sections.push(`- **${s.name}**: ${s.purpose} (when: ${s.when})`);
+        }
+        sections.push('');
+    }
     sections.push('## Current Mode');
     sections.push(`Mode: ${context.mode}`);
     sections.push('');
-    sections.push(MODE_INSTRUCTIONS[context.mode]);
-    sections.push('');
+    const modesObj = rawProfile.modes;
+    const modeKey = context.mode.toLowerCase();
+    const agentModeConfig = modesObj?.[modeKey];
+    if (agentModeConfig && typeof agentModeConfig === 'object') {
+        sections.push('## Mode-Specific Instructions');
+        renderValueAsText(agentModeConfig, sections);
+        sections.push('');
+    }
+    else {
+        sections.push(MODE_INSTRUCTIONS[context.mode]);
+        sections.push('');
+    }
+    const verificationGuide = activation?.verification_guide ?? rawProfile.verification_guide;
+    if (Array.isArray(verificationGuide) && verificationGuide.length) {
+        sections.push('## Verification Guide');
+        const items = verificationGuide.map((step) => `- ${step}`);
+        for (const line of trimList(items)) {
+            sections.push(line);
+        }
+        sections.push('');
+    }
+    else if (verificationGuide && typeof verificationGuide === 'object') {
+        sections.push('## Verification Guide');
+        const items = [];
+        for (const [key, desc] of Object.entries(verificationGuide)) {
+            items.push(`- **${key}**: ${desc}`);
+        }
+        for (const line of trimList(items)) {
+            sections.push(line);
+        }
+        sections.push('');
+    }
+    const executionOrder = activation?.execution_order;
+    if (executionOrder && typeof executionOrder === 'object' && !Array.isArray(executionOrder)) {
+        sections.push('## Execution Order');
+        for (const [phase, steps] of Object.entries(executionOrder)) {
+            if (Array.isArray(steps) && steps.length) {
+                sections.push(`### ${phase}`);
+                for (const line of trimList(steps)) {
+                    sections.push(line);
+                }
+            }
+        }
+        sections.push('');
+    }
+    else if (Array.isArray(executionOrder) && executionOrder.length) {
+        sections.push('## Execution Order');
+        const items = executionOrder.map((step, i) => `${i + 1}. ${step}`);
+        for (const line of trimList(items)) {
+            sections.push(line);
+        }
+        sections.push('');
+    }
     sections.push('## Task Context');
     if (context.taskDescription) {
         sections.push(`Task: ${context.taskDescription}`);

package/dist/src/agent/agent-stack.loader.d.ts

@@ -0,0 +1,3 @@
+import type { AgentStack } from './agent.types';
+export declare function loadAgentStack(filePath: string): Promise<AgentStack>;
+export declare function loadAgentStacks(dirPath: string): Promise<AgentStack[]>;

package/dist/src/agent/agent-stack.loader.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadAgentStack = loadAgentStack;
+exports.loadAgentStacks = loadAgentStacks;
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const agent_stack_schema_1 = require("./agent-stack.schema");
+async function loadAgentStack(filePath) {
+    const raw = await (0, promises_1.readFile)(filePath, 'utf-8');
+    const data = JSON.parse(raw);
+    const result = agent_stack_schema_1.AgentStackSchema.safeParse(data);
+    if (!result.success) {
+        const errors = result.error.issues.map(i => `${i.path.join('.')}: ${i.message}`).join(', ');
+        throw new Error(`Invalid agent stack in ${filePath}: ${errors}`);
+    }
+    return result.data;
+}
+async function loadAgentStacks(dirPath) {
+    let entries;
+    try {
+        entries = await (0, promises_1.readdir)(dirPath, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const jsonFiles = entries.filter(e => e.isFile() && e.name.endsWith('.json'));
+    const stacks = [];
+    for (const entry of jsonFiles) {
+        try {
+            const stack = await loadAgentStack((0, path_1.join)(dirPath, entry.name));
+            stacks.push(stack);
+        }
+        catch {
+        }
+    }
+    return stacks;
+}
+//# sourceMappingURL=agent-stack.loader.js.map

package/dist/src/agent/agent-stack.schema.d.ts

@@ -0,0 +1,14 @@
+import * as z from 'zod';
+export declare const AgentStackSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    category: z.ZodString;
+    tags: z.ZodArray<z.ZodString>;
+    primary_agent: z.ZodString;
+    specialist_agents: z.ZodArray<z.ZodString>;
+    recommended_for: z.ZodOptional<z.ZodObject<{
+        file_patterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        modes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.z.core.$strip>>;
+}, z.z.core.$strip>;
+export type ValidatedAgentStack = z.infer<typeof AgentStackSchema>;

package/dist/src/agent/agent-stack.schema.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentStackSchema = void 0;
+const z = require("zod");
+exports.AgentStackSchema = z.object({
+    name: z.string(),
+    description: z.string(),
+    category: z.string(),
+    tags: z.array(z.string()),
+    primary_agent: z.string(),
+    specialist_agents: z.array(z.string()),
+    recommended_for: z
+        .object({
+        file_patterns: z.array(z.string()).optional(),
+        modes: z.array(z.string()).optional(),
+    })
+        .optional(),
+});
+//# sourceMappingURL=agent-stack.schema.js.map

package/dist/src/agent/agent-stack.service.d.ts

@@ -0,0 +1,15 @@
+import { RulesService } from '../rules/rules.service';
+import { ConfigService } from '../config/config.service';
+import type { AgentStack, AgentStackSummary } from './agent.types';
+export declare class AgentStackService {
+    private readonly rulesService;
+    private readonly configService;
+    private readonly logger;
+    constructor(rulesService: RulesService, configService: ConfigService);
+    listStacks(category?: string): Promise<AgentStackSummary[]>;
+    resolveStack(stackName: string): Promise<AgentStack>;
+    private loadStacksFromDir;
+    private loadStackFile;
+    private isValidStack;
+    private toSummary;
+}

package/dist/src/agent/agent-stack.service.js

@@ -0,0 +1,112 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var AgentStackService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentStackService = void 0;
+const common_1 = require("@nestjs/common");
+const fs = require("fs/promises");
+const path = require("path");
+const rules_service_1 = require("../rules/rules.service");
+const config_service_1 = require("../config/config.service");
+const AGENT_STACKS_DIR = 'agent-stacks';
+const CUSTOM_STACKS_DIR = '.codingbuddy/agent-stacks';
+let AgentStackService = AgentStackService_1 = class AgentStackService {
+    constructor(rulesService, configService) {
+        this.rulesService = rulesService;
+        this.configService = configService;
+        this.logger = new common_1.Logger(AgentStackService_1.name);
+    }
+    async listStacks(category) {
+        const stackMap = new Map();
+        const defaultDir = path.join(this.rulesService.getRulesDir(), AGENT_STACKS_DIR);
+        const defaultStacks = await this.loadStacksFromDir(defaultDir);
+        for (const stack of defaultStacks) {
+            stackMap.set(stack.name, stack);
+        }
+        const customDir = path.join(this.configService.getProjectRoot(), CUSTOM_STACKS_DIR);
+        const customStacks = await this.loadStacksFromDir(customDir);
+        for (const stack of customStacks) {
+            stackMap.set(stack.name, stack);
+        }
+        let stacks = Array.from(stackMap.values());
+        if (category) {
+            stacks = stacks.filter(s => s.category === category);
+        }
+        return stacks.map(this.toSummary);
+    }
+    async resolveStack(stackName) {
+        const customDir = path.join(this.configService.getProjectRoot(), CUSTOM_STACKS_DIR);
+        const customStack = await this.loadStackFile(path.join(customDir, `${stackName}.json`));
+        if (customStack)
+            return customStack;
+        const defaultDir = path.join(this.rulesService.getRulesDir(), AGENT_STACKS_DIR);
+        const defaultStack = await this.loadStackFile(path.join(defaultDir, `${stackName}.json`));
+        if (defaultStack)
+            return defaultStack;
+        throw new Error(`Agent stack '${stackName}' not found`);
+    }
+    async loadStacksFromDir(dirPath) {
+        let entries;
+        try {
+            entries = (await fs.readdir(dirPath));
+        }
+        catch {
+            return [];
+        }
+        const stacks = [];
+        for (const entry of entries) {
+            if (!entry.endsWith('.json'))
+                continue;
+            const stack = await this.loadStackFile(path.join(dirPath, entry));
+            if (stack)
+                stacks.push(stack);
+        }
+        return stacks;
+    }
+    async loadStackFile(filePath) {
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            const parsed = JSON.parse(content);
+            if (!this.isValidStack(parsed)) {
+                this.logger.warn(`Invalid agent stack file (missing required fields): ${filePath}`);
+                return null;
+            }
+            return parsed;
+        }
+        catch {
+            return null;
+        }
+    }
+    isValidStack(obj) {
+        return (typeof obj.name === 'string' &&
+            typeof obj.description === 'string' &&
+            typeof obj.category === 'string' &&
+            typeof obj.primary_agent === 'string' &&
+            Array.isArray(obj.specialist_agents));
+    }
+    toSummary(stack) {
+        return {
+            name: stack.name,
+            description: stack.description,
+            category: stack.category,
+            primary_agent: stack.primary_agent,
+            specialist_count: stack.specialist_agents.length,
+            tags: stack.tags,
+        };
+    }
+};
+exports.AgentStackService = AgentStackService;
+exports.AgentStackService = AgentStackService = AgentStackService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [rules_service_1.RulesService,
+        config_service_1.ConfigService])
+], AgentStackService);
+//# sourceMappingURL=agent-stack.service.js.map

package/dist/src/agent/agent.module.js

@@ -9,6 +9,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentModule = void 0;
 const common_1 = require("@nestjs/common");
 const agent_service_1 = require("./agent.service");
+const agent_stack_service_1 = require("./agent-stack.service");
+const council_preset_service_1 = require("./council-preset.service");
+const teams_capability_service_1 = require("./teams-capability.service");
 const rules_module_1 = require("../rules/rules.module");
 const custom_1 = require("../custom");
 const config_module_1 = require("../config/config.module");
@@ -18,8 +21,8 @@ exports.AgentModule = AgentModule;
 exports.AgentModule = AgentModule = __decorate([
     (0, common_1.Module)({
         imports: [rules_module_1.RulesModule, custom_1.CustomModule, config_module_1.CodingBuddyConfigModule],
-        providers: [agent_service_1.AgentService],
-        exports: [agent_service_1.AgentService],
+        providers: [agent_service_1.AgentService, agent_stack_service_1.AgentStackService, council_preset_service_1.CouncilPresetService, teams_capability_service_1.TeamsCapabilityService],
+        exports: [agent_service_1.AgentService, agent_stack_service_1.AgentStackService, council_preset_service_1.CouncilPresetService, teams_capability_service_1.TeamsCapabilityService],
     })
 ], AgentModule);
 //# sourceMappingURL=agent.module.js.map

package/dist/src/agent/agent.service.d.ts

@@ -1,6 +1,7 @@
 import { RulesService } from '../rules/rules.service';
 import { CustomService } from '../custom';
 import { ConfigService } from '../config/config.service';
+import { TeamsCapabilityService } from './teams-capability.service';
 import type { Mode } from '../keyword/keyword.types';
 import type { AgentProfile } from '../rules/rules.types';
 import type { AgentContext, AgentSystemPrompt, InlineAgentDefinition, ParallelAgentSet, DispatchAgentsInput, DispatchResult } from './agent.types';
@@ -9,8 +10,9 @@ export declare class AgentService {
     private readonly rulesService;
     private readonly customService;
     private readonly configService;
+    private readonly teamsCapability;
     private readonly logger;
-    constructor(rulesService: RulesService, customService: CustomService, configService: ConfigService);
+    constructor(rulesService: RulesService, customService: CustomService, configService: ConfigService, teamsCapability: TeamsCapabilityService);
     getAgentSystemPrompt(agentName: string, context: AgentContext, inlineAgents?: Record<string, InlineAgentDefinition>): Promise<AgentSystemPrompt>;
     prepareParallelAgents(mode: Mode, specialists: string[], targetFiles?: string[], sharedContext?: string, verbosity?: VerbosityLevel, inlineAgents?: Record<string, InlineAgentDefinition>): Promise<ParallelAgentSet>;
     private loadAgents;
@@ -19,8 +21,13 @@ export declare class AgentService {
     getRecommendedAgents(modeDefaults: string[], files: string[]): string[];
     private addFilePatternAgents;
     dispatchAgents(input: DispatchAgentsInput): Promise<DispatchResult>;
+    private dispatchTaskmaestro;
+    private dispatchTeams;
+    private dispatchSubagent;
+    private dispatchComposable;
     private buildTaskmaestroPrompt;
     private buildTaskmaestroHint;
     private buildTeamsHint;
+    private buildComposableHint;
     resolveAgent(agentName: string, inlineAgents?: Record<string, InlineAgentDefinition>): Promise<AgentProfile>;
 }

package/dist/src/agent/agent.service.js

@@ -15,15 +15,18 @@ const common_1 = require("@nestjs/common");
 const rules_service_1 = require("../rules/rules.service");
 const custom_1 = require("../custom");
 const config_service_1 = require("../config/config.service");
+const teams_capability_service_1 = require("./teams-capability.service");
 const agent_types_1 = require("./agent.types");
 const agent_prompt_builder_1 = require("./agent-prompt.builder");
 const agent_summary_utils_1 = require("./agent-summary.utils");
+const execution_plan_1 = require("./execution-plan");
 const verbosity_types_1 = require("../shared/verbosity.types");
 let AgentService = AgentService_1 = class AgentService {
-    constructor(rulesService, customService, configService) {
+    constructor(rulesService, customService, configService, teamsCapability) {
         this.rulesService = rulesService;
         this.customService = customService;
         this.configService = configService;
+        this.teamsCapability = teamsCapability;
         this.logger = new common_1.Logger(AgentService_1.name);
     }
     async getAgentSystemPrompt(agentName, context, inlineAgents) {
@@ -146,48 +149,64 @@ let AgentService = AgentService_1 = class AgentService {
                 result.failedAgents = [...(result.failedAgents || []), { id: input.primaryAgent, reason }];
             }
         }
+        if (input.executionStrategy === 'taskmaestro+teams' && input.specialists?.length) {
+            return this.dispatchComposable(input, context, result);
+        }
         if (input.executionStrategy === 'taskmaestro' && input.specialists?.length) {
-            const uniqueSpecialists = Array.from(new Set(input.specialists));
-            const { agents, failedAgents } = await this.loadAgents(uniqueSpecialists, context, true, input.inlineAgents);
-            const assignments = agents.map(agent => ({
-                name: agent.id,
-                displayName: agent.displayName,
-                prompt: this.buildTaskmaestroPrompt(agent, input),
-            }));
-            return {
-                primaryAgent: result.primaryAgent,
-                taskmaestro: {
-                    sessionName: `${(input.mode ?? 'eval').toLowerCase()}-specialists`,
-                    paneCount: assignments.length,
-                    assignments,
-                },
-                executionStrategy: 'taskmaestro',
-                executionHint: this.buildTaskmaestroHint(assignments.length),
-                failedAgents: failedAgents.length > 0 ? failedAgents : result.failedAgents,
-            };
+            return this.dispatchTaskmaestro(input, context, result);
         }
         if (input.executionStrategy === 'teams' && input.specialists?.length) {
-            const uniqueSpecialists = Array.from(new Set(input.specialists));
-            const teamName = `${(input.mode ?? 'eval').toLowerCase()}-specialists`;
-            const { agents, failedAgents } = await this.loadAgents(uniqueSpecialists, context, true, input.inlineAgents);
-            const teammates = agents.map(agent => ({
-                name: agent.id,
-                subagent_type: 'general-purpose',
-                team_name: teamName,
-                prompt: agent.taskPrompt || `Perform ${agent.displayName} analysis in ${input.mode} mode`,
-            }));
-            return {
-                primaryAgent: result.primaryAgent,
-                teams: {
-                    team_name: teamName,
-                    description: `${input.mode} mode specialist team`,
-                    teammates,
-                },
-                executionStrategy: 'teams',
-                executionHint: this.buildTeamsHint(teamName, teammates.length),
-                failedAgents: failedAgents.length > 0 ? failedAgents : result.failedAgents,
-            };
+            return this.dispatchTeams(input, context, result);
         }
+        return this.dispatchSubagent(input, context, result);
+    }
+    async dispatchTaskmaestro(input, context, result) {
+        const uniqueSpecialists = Array.from(new Set(input.specialists));
+        const { agents, failedAgents } = await this.loadAgents(uniqueSpecialists, context, true, input.inlineAgents);
+        const assignments = agents.map(agent => ({
+            name: agent.id,
+            displayName: agent.displayName,
+            prompt: this.buildTaskmaestroPrompt(agent, input),
+        }));
+        const tmDispatch = {
+            sessionName: `${(input.mode ?? 'eval').toLowerCase()}-specialists`,
+            paneCount: assignments.length,
+            assignments,
+        };
+        return {
+            primaryAgent: result.primaryAgent,
+            taskmaestro: tmDispatch,
+            executionStrategy: 'taskmaestro',
+            executionHint: this.buildTaskmaestroHint(assignments.length),
+            executionPlan: (0, execution_plan_1.buildSimplePlan)((0, execution_plan_1.taskmaestroLayer)(tmDispatch)),
+            failedAgents: failedAgents.length > 0 ? failedAgents : result.failedAgents,
+        };
+    }
+    async dispatchTeams(input, context, result) {
+        const uniqueSpecialists = Array.from(new Set(input.specialists));
+        const teamName = `${(input.mode ?? 'eval').toLowerCase()}-specialists`;
+        const { agents, failedAgents } = await this.loadAgents(uniqueSpecialists, context, true, input.inlineAgents);
+        const teammates = agents.map(agent => ({
+            name: agent.id,
+            subagent_type: 'general-purpose',
+            team_name: teamName,
+            prompt: agent.taskPrompt || `Perform ${agent.displayName} analysis in ${input.mode} mode`,
+        }));
+        const teamsConfig = {
+            team_name: teamName,
+            description: `${input.mode} mode specialist team`,
+            teammates,
+        };
+        return {
+            primaryAgent: result.primaryAgent,
+            teams: teamsConfig,
+            executionStrategy: 'teams',
+            executionHint: this.buildTeamsHint(teamName, teammates.length),
+            executionPlan: (0, execution_plan_1.buildSimplePlan)((0, execution_plan_1.teamsLayer)(teamsConfig)),
+            failedAgents: failedAgents.length > 0 ? failedAgents : result.failedAgents,
+        };
+    }
+    async dispatchSubagent(input, context, result) {
         if (input.includeParallel && input.specialists?.length) {
             const uniqueSpecialists = Array.from(new Set(input.specialists));
             const { agents, failedAgents } = await this.loadAgents(uniqueSpecialists, context, true, input.inlineAgents);
@@ -205,10 +224,63 @@ let AgentService = AgentService_1 = class AgentService {
             if (failedAgents.length > 0) {
                 result.failedAgents = failedAgents;
             }
+            result.executionPlan = (0, execution_plan_1.buildSimplePlan)((0, execution_plan_1.subagentLayer)(result.parallelAgents));
         }
         result.executionStrategy = 'subagent';
         return result;
     }
+    async dispatchComposable(input, context, result) {
+        const teamsAvailable = await this.teamsCapability.isAvailable();
+        if (!teamsAvailable) {
+            this.logger.debug('Teams capability disabled — falling back to pure TaskMaestro for composable dispatch');
+            return this.dispatchTaskmaestro(input, context, result);
+        }
+        const uniqueSpecialists = Array.from(new Set(input.specialists));
+        const teamName = `${(input.mode ?? 'eval').toLowerCase()}-specialists`;
+        const { agents, failedAgents } = await this.loadAgents(uniqueSpecialists, context, true, input.inlineAgents);
+        const assignments = agents.map(agent => ({
+            name: agent.id,
+            displayName: agent.displayName,
+            prompt: this.buildTaskmaestroPrompt(agent, input),
+            innerCoordination: {
+                type: 'teams',
+                teamSpec: {
+                    team_name: teamName,
+                    description: `${input.mode} mode specialist team (coordinated within TaskMaestro panes)`,
+                },
+                teammates: agents.map(a => ({
+                    name: a.id,
+                    subagent_type: 'general-purpose',
+                })),
+            },
+        }));
+        const tmDispatch = {
+            sessionName: teamName,
+            paneCount: assignments.length,
+            assignments,
+        };
+        const teammates = agents.map(agent => ({
+            name: agent.id,
+            subagent_type: 'general-purpose',
+            team_name: teamName,
+            prompt: agent.taskPrompt || `Perform ${agent.displayName} analysis in ${input.mode} mode`,
+        }));
+        const teamsConfig = {
+            team_name: teamName,
+            description: `${input.mode} mode specialist team (coordinated within TaskMaestro panes)`,
+            teammates,
+        };
+        const executionPlan = (0, execution_plan_1.buildNestedPlan)((0, execution_plan_1.taskmaestroLayer)(tmDispatch), (0, execution_plan_1.teamsLayer)(teamsConfig));
+        return {
+            primaryAgent: result.primaryAgent,
+            taskmaestro: tmDispatch,
+            teams: teamsConfig,
+            executionStrategy: 'taskmaestro+teams',
+            executionHint: this.buildComposableHint(teamName, assignments.length),
+            executionPlan,
+            failedAgents: failedAgents.length > 0 ? failedAgents : result.failedAgents,
+        };
+    }
     buildTaskmaestroPrompt(agent, input) {
         const taskContext = input.taskDescription ? `\n\n**Task:** ${input.taskDescription}` : '';
         const fileContext = input.targetFiles?.length
@@ -241,6 +313,19 @@ When done, provide a summary of all findings.`;
 4. Monitor via TaskList — teammates coordinate via shared task list
 5. Collect results when all teammates go idle
 6. Shutdown teammates via SendMessage with shutdown_request`;
+    }
+    buildComposableHint(teamName, paneCount) {
+        return `Composable execution (TaskMaestro + Teams):
+Outer — TaskMaestro manages ${paneCount} tmux pane(s):
+  1. /taskmaestro start --panes ${paneCount}
+  2. Assign each pane its specialist prompt
+Inner — Teams coordinates within panes:
+  1. Each pane worker uses TeamCreate: { team_name: "${teamName}" }
+  2. Workers share task list for coordination
+  3. Monitor via TaskList and /taskmaestro status
+Teardown:
+  1. Shutdown teammates via SendMessage with shutdown_request
+  2. /taskmaestro stop all`;
     }
     async resolveAgent(agentName, inlineAgents) {
         if (inlineAgents?.[agentName]) {
@@ -279,6 +364,7 @@ exports.AgentService = AgentService = AgentService_1 = __decorate([
     (0, common_1.Injectable)(),
     __metadata("design:paramtypes", [rules_service_1.RulesService,
         custom_1.CustomService,
-        config_service_1.ConfigService])
+        config_service_1.ConfigService,
+        teams_capability_service_1.TeamsCapabilityService])
 ], AgentService);
 //# sourceMappingURL=agent.service.js.map