@lobehub/lobehub 2.0.9 → 2.0.11

package/packages/builtin-tool-group-management/src/executor.test.ts

@@ -284,7 +284,7 @@ describe('GroupManagementExecutor', () => {
       const ctx = createMockContext();
 
       const result = await groupManagementExecutor.executeAgentTask(
-        { agentId: 'agent-1', task: 'Do something', title: 'Test Task' },
+        { agentId: 'agent-1', instruction: 'Do something', title: 'Test Task' },
         ctx,
       );
 
@@ -293,9 +293,8 @@ describe('GroupManagementExecutor', () => {
       expect(result.content).toBe('Triggered async task for agent "agent-1".');
       expect(result.state).toEqual({
         agentId: 'agent-1',
-        task: 'Do something',
+        instruction: 'Do something',
         timeout: undefined,
-        title: 'Test Task',
         type: 'executeAgentTask',
       });
     });
@@ -320,7 +319,7 @@ describe('GroupManagementExecutor', () => {
       );
 
       await groupManagementExecutor.executeAgentTask(
-        { agentId: 'agent-1', task: 'Do something', timeout: 30000, title: 'Test Task' },
+        { agentId: 'agent-1', instruction: 'Do something', timeout: 30000, title: 'Test Task' },
         ctx,
       );
 
@@ -334,8 +333,8 @@ describe('GroupManagementExecutor', () => {
       // Now triggerExecuteTask should have been called
       expect(triggerExecuteTask).toHaveBeenCalledWith({
         agentId: 'agent-1',
+        instruction: 'Do something',
         supervisorAgentId: 'supervisor-agent',
-        task: 'Do something',
         timeout: 30000,
         toolMessageId: 'test-message-id',
       });
@@ -345,7 +344,7 @@ describe('GroupManagementExecutor', () => {
       const ctx = createMockContext();
 
       const result = await groupManagementExecutor.executeAgentTask(
-        { agentId: 'agent-1', task: 'Do something', title: 'Test Task' },
+        { agentId: 'agent-1', instruction: 'Do something', title: 'Test Task' },
         ctx,
       );
 
@@ -357,16 +356,15 @@ describe('GroupManagementExecutor', () => {
       const ctx = createMockContext();
 
       const result = await groupManagementExecutor.executeAgentTask(
-        { agentId: 'agent-1', task: 'Do something', timeout: 60000, title: 'Test Task' },
+        { agentId: 'agent-1', instruction: 'Do something', timeout: 60000, title: 'Test Task' },
         ctx,
       );
 
       expect(result.success).toBe(true);
       expect(result.state).toEqual({
         agentId: 'agent-1',
-        task: 'Do something',
+        instruction: 'Do something',
         timeout: 60000,
-        title: 'Test Task',
         type: 'executeAgentTask',
       });
     });

package/packages/builtin-tool-group-management/src/executor.ts

@@ -124,7 +124,7 @@ class GroupManagementExecutor extends BaseExecutor<typeof GroupManagementApiName
     params: ExecuteTaskParams,
     ctx: BuiltinToolContext,
   ): Promise<BuiltinToolResult> => {
-    const { agentId, task, timeout, skipCallSupervisor, runInClient } = params;
+    const { agentId, instruction, timeout, skipCallSupervisor, runInClient } = params;
 
     // Register afterCompletion callback to trigger async task execution after AgentRuntime completes
     // This follows the same pattern as speak/broadcast - trigger mode, not blocking
@@ -132,10 +132,10 @@ class GroupManagementExecutor extends BaseExecutor<typeof GroupManagementApiName
       ctx.registerAfterCompletion(() =>
         ctx.groupOrchestration!.triggerExecuteTask({
           agentId,
+          instruction,
           runInClient,
           skipCallSupervisor,
           supervisorAgentId: ctx.agentId!,
-          task,
           timeout,
           toolMessageId: ctx.messageId,
         }),
@@ -147,9 +147,9 @@ class GroupManagementExecutor extends BaseExecutor<typeof GroupManagementApiName
       content: `Triggered async task for agent "${agentId}"${runInClient ? ' (client-side)' : ''}.`,
       state: {
         agentId,
+        instruction,
         runInClient,
         skipCallSupervisor,
-        task,
         timeout,
         type: 'executeAgentTask',
       },

package/packages/builtin-tool-group-management/src/manifest.ts

@@ -100,9 +100,9 @@ export const GroupManagementManifest: BuiltinToolManifest = {
             description: 'Brief title describing what this task does (shown in UI).',
             type: 'string',
           },
-          task: {
+          instruction: {
             description:
-              'Clear description of the task to perform. Be specific about expected deliverables.',
+              'Clear instruction describing the task to perform. Be specific about expected deliverables.',
             type: 'string',
           },
           ...(isDesktop && {
@@ -125,57 +125,56 @@ export const GroupManagementManifest: BuiltinToolManifest = {
             type: 'boolean',
           },
         },
-        required: ['agentId', 'title', 'task'],
+        required: ['agentId', 'title', 'instruction'],
+        type: 'object',
+      },
+    },
+    {
+      description:
+        'Assign multiple tasks to different agents to run in parallel. Each agent works independently in their own context. Use this when you need multiple agents to work on different parts of a problem simultaneously.',
+      name: GroupManagementApiName.executeAgentTasks,
+      humanIntervention: 'required',
+      parameters: {
+        properties: {
+          tasks: {
+            description: 'Array of tasks, each assigned to a specific agent.',
+            items: {
+              properties: {
+                agentId: {
+                  description: 'The ID of the agent to execute this task.',
+                  type: 'string',
+                },
+                title: {
+                  description: 'Brief title describing what this task does (shown in UI).',
+                  type: 'string',
+                },
+                instruction: {
+                  description:
+                    'Detailed instruction for the agent to execute. Be specific about expected deliverables.',
+                  type: 'string',
+                },
+                timeout: {
+                  description:
+                    'Optional timeout in milliseconds for this task (default: 1800000, 30 minutes).',
+                  type: 'number',
+                },
+              },
+              required: ['agentId', 'title', 'instruction'],
+              type: 'object',
+            },
+            type: 'array',
+          },
+          skipCallSupervisor: {
+            default: false,
+            description:
+              'If true, the orchestration will end after all tasks complete, without calling the supervisor again.',
+            type: 'boolean',
+          },
+        },
+        required: ['tasks'],
         type: 'object',
       },
     },
-    // TODO: Enable executeAgentTasks when ready
-    // {
-    //   description:
-    //     'Assign multiple tasks to different agents to run in parallel. Each agent works independently in their own context. Use this when you need multiple agents to work on different parts of a problem simultaneously.',
-    //   name: GroupManagementApiName.executeAgentTasks,
-    //   humanIntervention: 'required',
-    //   parameters: {
-    //     properties: {
-    //       tasks: {
-    //         description: 'Array of tasks, each assigned to a specific agent.',
-    //         items: {
-    //           properties: {
-    //             agentId: {
-    //               description: 'The ID of the agent to execute this task.',
-    //               type: 'string',
-    //             },
-    //             title: {
-    //               description: 'Brief title describing what this task does (shown in UI).',
-    //               type: 'string',
-    //             },
-    //             instruction: {
-    //               description:
-    //                 'Detailed instruction/prompt for the task execution. Be specific about expected deliverables.',
-    //               type: 'string',
-    //             },
-    //             timeout: {
-    //               description:
-    //                 'Optional timeout in milliseconds for this task (default: 1800000, 30 minutes).',
-    //               type: 'number',
-    //             },
-    //           },
-    //           required: ['agentId', 'title', 'instruction'],
-    //           type: 'object',
-    //         },
-    //         type: 'array',
-    //       },
-    //       skipCallSupervisor: {
-    //         default: false,
-    //         description:
-    //           'If true, the orchestration will end after all tasks complete, without calling the supervisor again.',
-    //         type: 'boolean',
-    //       },
-    //     },
-    //     required: ['tasks'],
-    //     type: 'object',
-    //   },
-    // },
     // {
     //   description:
     //     'Interrupt a running agent task. Use this to stop a task that is taking too long or is no longer needed.',

package/packages/builtin-tool-group-management/src/systemRole.ts

@@ -40,17 +40,64 @@ Best for:
 - Reviewing/critiquing content presented in conversation
 - Discussion and debate
 
+### ⚡ Single Task Execution (executeAgentTask)
+**Use when a single agent needs to do extended, multi-step work** - agent works asynchronously in isolated context.
+
+Characteristics:
+- Agent runs in background with dedicated context
+- Asynchronous execution - doesn't block conversation
+- Results are returned upon completion
+- Supports long-running operations with configurable timeout (default 30min)
+
+Best for:
+- Complex multi-step tasks requiring extended processing
+- Writing/generating lengthy code, documents, or creative content
+- Deep research requiring multiple searches and synthesis
+- Tasks that may take significant time to complete
+- Work that benefits from focused, uninterrupted execution
+
+### ⚡⚡ Parallel Task Execution (executeAgentTasks)
+**Use when multiple tasks need to run simultaneously** - each task runs asynchronously in its own isolated context.
+
+Characteristics:
+- Multiple tasks run in parallel, each with dedicated context
+- All tasks execute independently and concurrently
+- Results from all tasks are returned upon completion
+- Each task can have its own timeout
+- **Same agent can be assigned multiple tasks** with different instructions
+
+Best for:
+- Breaking down complex problems into parallelizable subtasks
+- Assigning different aspects of work to specialized agents
+- When speed matters and subtasks are independent
+- Multi-agent implementation (e.g., frontend + backend + tests)
+- **Batch processing**: Same agent handling multiple similar tasks with different inputs (e.g., one Researcher investigating 3 different topics in parallel)
+
+Key difference from speak/broadcast:
+- speak/broadcast: Synchronous responses in shared conversation context (quick interactions)
+- executeAgentTask: Single async execution in isolated context (extended work)
+- executeAgentTasks: Multiple async executions in parallel (distributed work)
+
 ## Decision Flowchart
 
 \`\`\`
 User Request
      │
      ▼
-Does the task need multiple perspectives?
+Does the task require extended, multi-step work?
+(complex creation, deep research, lengthy generation)
      │
-     ├─── YES ──→ broadcast (parallel speaking)
+     ├─── YES ──→ Can multiple agents work on different parts in parallel?
+     │                 │
+     │                 ├─── YES ──→ executeAgentTasks (parallel task execution)
+     │                 │
+     │                 └─── NO ───→ executeAgentTask (single task execution)
      │
-     └─── NO ───→ speak (single agent)
+     └─── NO ───→ Does the task need multiple perspectives?
+                       │
+                       ├─── YES ──→ broadcast (parallel speaking)
+                       │
+                       └─── NO ───→ speak (single agent)
 \`\`\`
 </core_decision_framework>
 
@@ -61,16 +108,40 @@ Before responding, analyze the user's intent:
 - "What do you think about...", "Any ideas for...", "How should we..."
 - "Review this...", "Give me feedback on...", "Critique..."
 - "Explain...", "Compare...", "Summarize..."
-- Requests for opinions, perspectives, or expertise-based answers
-- Questions that benefit from diverse viewpoints
+- Requests for **quick opinions or perspectives based on existing knowledge**
+- Questions that benefit from diverse viewpoints **without requiring research or investigation**
+
+⚠️ **NOT broadcast** (use executeAgentTask/executeAgentTasks instead):
+- "Research...", "Investigate...", "Analyze in depth..." - these require actual work, not just opinions
+- "Everyone research/investigate..." - this means each agent should do research work, not just share opinions
 
 **Signals for Single Agent (speak):**
 - Explicit request: "Ask [Agent Name] to...", "Let [Agent Name] answer..."
 - Follow-up to a specific agent's previous response
 - Task clearly matches only one agent's expertise
 
+**Signals for Single Task Execution (executeAgentTask):**
+- Complex multi-step work: "Develop a...", "Design and implement...", "Create a complete..."
+- Extended creation: "Write a full...", "Generate a comprehensive...", "Build an entire..."
+- Deep research: "Do thorough research on...", "Investigate in depth...", "Analyze extensively..."
+- Time-intensive requests: Tasks that clearly need extended processing time
+
+**Signals for Parallel Task Execution (executeAgentTasks):**
+- Distributed work: "Have multiple agents work on...", "Split this into parallel tasks..."
+- Multi-aspect implementation: "Build the frontend and backend...", "Create X, Y, and Z components..."
+- Speed-critical requests: "Get this done as fast as possible by having agents work in parallel"
+- Independent subtasks: When the problem can be decomposed into non-dependent parts
+- Batch processing: "Do X for each of these: A, B, C...", "Research these 3 competitors...", "Write posts about these topics..."
+- **Parallel research/investigation**: "Everyone investigate...", "Each of you research...", "All of you look into..." - when multiple agents need to do actual research work and provide findings
+
 **Default Behavior:**
 - When in doubt about single vs multiple agents → Lean towards broadcast for diverse perspectives
+- When task involves extended, multi-step work → Use executeAgentTask for single agent, executeAgentTasks for parallel work
+
+**Key Distinction - Opinion vs Research:**
+- "Give opinions/thoughts/feedback" → broadcast (quick response from knowledge)
+- "Research/investigate/analyze" → executeAgentTask/executeAgentTasks (requires actual work)
+- Even if user says "give conclusions", if the task involves research or investigation, use task execution
 </user_intent_analysis>
 
 <intent_clarification>
@@ -133,6 +204,10 @@ When a user's request is broad or unclear, ask 1-2 focused questions to understa
 - **speak**: Single agent responds synchronously in group context
 - **broadcast**: Multiple agents respond in parallel in group context
 
+**Task Execution:**
+- **executeAgentTask**: Assign async task to single agent for extended, multi-step work
+- **executeAgentTasks**: Assign multiple async tasks to different agents in parallel
+
 **Flow Control:**
 - **vote**: Initiate voting among agents
 </core_capabilities>
@@ -169,6 +244,75 @@ User: "Ask the frontend expert about React performance"
 Analysis: User explicitly requested specific agent
 Action: speak to frontend expert with the question
 \`\`\`
+
+### Pattern 4: Delegated Task Execution (executeAgentTask)
+When a single agent needs extended, multi-step work that benefits from focused execution.
+
+\`\`\`
+User: "Write a complete REST API for user authentication"
+Analysis: Complex multi-step task requiring extended work
+Action: executeAgentTask to Backend - "Implement REST API for user authentication with JWT tokens, including login, register, and refresh endpoints"
+\`\`\`
+
+\`\`\`
+User: "Do thorough research on the latest trends in AI for our product roadmap"
+Analysis: Deep research requiring extensive investigation and synthesis
+Action: executeAgentTask to Researcher - "Research current AI trends relevant to [product context], compile findings with sources and recommendations"
+\`\`\`
+
+### Pattern 5: Parallel Task Execution (executeAgentTasks)
+When multiple tasks can run simultaneously - either by different agents OR the same agent with different instructions.
+
+**Different agents working on different parts:**
+\`\`\`
+User: "Build a user dashboard with frontend, backend API, and database schema"
+Analysis: Can be split into independent parallel tasks for each agent
+Action: executeAgentTasks with:
+  - Frontend: "Build React dashboard UI with charts and user stats"
+  - Backend: "Implement REST API endpoints for dashboard data"
+  - DBA: "Design database schema for user metrics and analytics"
+\`\`\`
+
+**Same agent with different instructions (batch processing):**
+\`\`\`
+User: "Research these 3 competitors: Company A, Company B, Company C"
+Analysis: Same type of task with different inputs - assign to same agent 3 times
+Action: executeAgentTasks with:
+  - Researcher: "Research Company A - analyze their product, pricing, and market position"
+  - Researcher: "Research Company B - analyze their product, pricing, and market position"
+  - Researcher: "Research Company C - analyze their product, pricing, and market position"
+\`\`\`
+
+\`\`\`
+User: "Write blog posts for each of these 3 topics: AI trends, Cloud computing, DevOps best practices"
+Analysis: Same agent can write multiple posts in parallel
+Action: executeAgentTasks with:
+  - Writer: "Write a blog post about AI trends in 2024"
+  - Writer: "Write a blog post about Cloud computing adoption"
+  - Writer: "Write a blog post about DevOps best practices"
+\`\`\`
+
+**Multiple agents doing research (NOT broadcast!):**
+\`\`\`
+User: "Help me research how X is implemented, everyone investigate and give me your conclusions"
+Analysis: "research/investigate" means actual work, NOT just opinions. Each agent needs to do research and provide findings.
+Action: executeAgentTasks with:
+  - Developer A: "Research how X implements feature Y, analyze the code structure and patterns"
+  - Developer B: "Research how X handles Z, document the approach and trade-offs"
+  - Developer C: "Research X's architecture for W, summarize key design decisions"
+⚠️ DO NOT use broadcast - "research/investigate" requires investigation work, not quick opinions!
+\`\`\`
+
+### Pattern 6: Hybrid Workflow (Discuss then Execute)
+When you need input before execution.
+
+\`\`\`
+User: "Help me build a dashboard for analytics"
+Analysis: Benefits from initial discussion, then requires implementation
+Action:
+1. broadcast to [Designer, Frontend, Data] - "What key metrics and layout should this analytics dashboard include?"
+2. After consensus → executeAgentTask to Frontend - "Implement dashboard based on discussed requirements"
+\`\`\`
 </workflow_patterns>
 
 <tool_usage_guidelines>
@@ -176,6 +320,10 @@ Action: speak to frontend expert with the question
 - speak: \`agentId\`, \`instruction\` (optional guidance)
 - broadcast: \`agentIds\` (array), \`instruction\` (optional shared guidance)
 
+**Task Execution:**
+- executeAgentTask: \`agentId\`, \`title\` (brief UI label), \`task\` (detailed instructions with expected deliverables), \`timeout\` (optional, default 30min)
+- executeAgentTasks: \`tasks\` (array of {agentId, title, task, timeout?}), \`skipCallSupervisor\` (optional)
+
 **Flow Control:**
 - vote: \`question\`, \`options\` (array of {id, label, description}), \`voterAgentIds\` (optional), \`requireReasoning\` (default true)
 </tool_usage_guidelines>

package/packages/builtin-tool-group-management/src/types.ts

@@ -72,6 +72,8 @@ export interface DelegateParams {
 
 export interface ExecuteTaskParams {
   agentId: string;
+  /** Clear instruction describing the task to perform */
+  instruction: string;
   /**
    * Whether to run on the desktop client (for local file/shell access).
    * MUST be true when task requires local-system tools. Default is false (server execution).
@@ -83,7 +85,6 @@ export interface ExecuteTaskParams {
    * Use this when the task is the final action needed.
    */
   skipCallSupervisor?: boolean;
-  task: string;
   timeout?: number;
   /** Brief title describing what this task does (shown in UI) */
   title: string;
@@ -92,7 +93,7 @@ export interface ExecuteTaskParams {
 export interface TaskItem {
   /** The ID of the agent to execute this task */
   agentId: string;
-  /** Detailed instruction/prompt for the task execution */
+  /** Detailed instruction for the agent to execute */
   instruction: string;
   /** Optional timeout in milliseconds for this specific task */
   timeout?: number;

package/packages/builtin-tool-gtd/src/systemRole.ts

@@ -38,8 +38,8 @@ export const systemPrompt = `You have GTD (Getting Things Done) tools to help ma
 
 <tool_overview>
 **Planning Tools** - For high-level goal documentation:
-- \`createPlan\`: Create a strategic plan document with goal and context
-- \`updatePlan\`: Update plan details
+- \`createPlan\`: Create a strategic plan document. **Required params: goal, description (brief summary), context** - all three must be provided
+- \`updatePlan\`: Update plan details (only planId is required)
 
 **Todo Tools** - For actionable execution items:
 - \`createTodos\`: Create new todo items from text array
@@ -49,8 +49,8 @@ export const systemPrompt = `You have GTD (Getting Things Done) tools to help ma
 **Todo Status Workflow:** todo → processing → completed (use "processing" when actively working on an item)
 
 **Async Task Tools** - For long-running background tasks:
-- \`execTask\`: Execute a single async task in isolated context
-- \`execTasks\`: Execute multiple async tasks in parallel
+- \`execTask\`: Execute a single async task. **Required params: description (brief UI label), instruction (detailed prompt)** - both must be provided
+- \`execTasks\`: Execute multiple async tasks in parallel. Each task requires **description** and **instruction**
 </tool_overview>
 
 <default_workflow>

package/packages/context-engine/src/processors/TasksFlatten.ts

@@ -7,9 +7,11 @@ const log = debug('context-engine:processor:TasksFlattenProcessor');
 
 /**
  * Tasks Flatten Processor
- * Responsible for flattening role=tasks messages into individual task messages
+ * Responsible for flattening role=tasks and role=groupTasks messages into individual task messages
+ *
+ * - tasks: Multiple task messages with same agentId aggregated
+ * - groupTasks: Multiple task messages with different agentIds aggregated
  *
- * Tasks messages are created when multiple task messages with the same parentId are aggregated.
  * This processor converts them back to individual task messages that can be processed by TaskMessageProcessor.
  */
 export class TasksFlattenProcessor extends BaseProcessor {
@@ -30,8 +32,8 @@ export class TasksFlattenProcessor extends BaseProcessor {
 
     // Process each message
     for (const message of clonedContext.messages) {
-      // Check if this is a tasks message with tasks field
-      if (message.role === 'tasks' && message.tasks) {
+      // Check if this is a tasks or groupTasks message with tasks field
+      if (['tasks', 'groupTasks'].includes(message.role) && message.tasks) {
         // If tasks array is empty, skip this message entirely (no content to flatten)
         if (message.tasks.length === 0) {
           continue;
@@ -40,7 +42,7 @@ export class TasksFlattenProcessor extends BaseProcessor {
         processedCount++;
         tasksMessagesFlattened++;
 
-        log(`Flattening tasks message ${message.id} with ${message.tasks.length} tasks`);
+        log(`Flattening ${message.role} message ${message.id} with ${message.tasks.length} tasks`);
 
         // Flatten each task
         for (const task of message.tasks) {

package/packages/context-engine/src/processors/__tests__/TasksFlatten.test.ts

@@ -188,4 +188,168 @@ describe('TasksFlattenProcessor', () => {
     expect(result.metadata.tasksMessagesFlattened).toBe(1);
     expect(result.metadata.taskMessagesCreated).toBe(2);
   });
+
+  describe('groupTasks handling', () => {
+    it('should flatten groupTasks message into individual task messages', async () => {
+      const processor = new TasksFlattenProcessor();
+
+      const context = {
+        messages: [
+          {
+            content: 'Hello',
+            id: 'msg-1',
+            role: 'user',
+          },
+          {
+            id: 'groupTasks-1',
+            role: 'groupTasks',
+            tasks: [
+              {
+                agentId: 'agent-1',
+                content: 'Task 1 result',
+                id: 'task-1',
+                metadata: { instruction: 'Do task 1' },
+                role: 'task',
+              },
+              {
+                agentId: 'agent-2',
+                content: 'Task 2 result',
+                id: 'task-2',
+                metadata: { instruction: 'Do task 2' },
+                role: 'task',
+              },
+              {
+                agentId: 'agent-3',
+                content: 'Task 3 result',
+                id: 'task-3',
+                metadata: { instruction: 'Do task 3' },
+                role: 'task',
+              },
+            ],
+          },
+        ],
+        metadata: {},
+        stats: { startTime: Date.now() },
+      };
+
+      const result = await processor.process(context as any);
+
+      // Should have 4 messages: 1 user + 3 flattened tasks
+      expect(result.messages).toHaveLength(4);
+      expect(result.messages[0].role).toBe('user');
+      expect(result.messages[1].role).toBe('task');
+      expect(result.messages[1].id).toBe('task-1');
+      expect(result.messages[1].agentId).toBe('agent-1');
+      expect(result.messages[2].role).toBe('task');
+      expect(result.messages[2].id).toBe('task-2');
+      expect(result.messages[2].agentId).toBe('agent-2');
+      expect(result.messages[3].role).toBe('task');
+      expect(result.messages[3].id).toBe('task-3');
+      expect(result.messages[3].agentId).toBe('agent-3');
+    });
+
+    it('should skip empty groupTasks array', async () => {
+      const processor = new TasksFlattenProcessor();
+
+      const context = {
+        messages: [
+          {
+            content: 'Hello',
+            id: 'msg-1',
+            role: 'user',
+          },
+          {
+            id: 'groupTasks-1',
+            role: 'groupTasks',
+            tasks: [],
+          },
+        ],
+        metadata: {},
+        stats: { startTime: Date.now() },
+      };
+
+      const result = await processor.process(context as any);
+
+      // Should only have user message, empty groupTasks should be skipped
+      expect(result.messages).toHaveLength(1);
+      expect(result.messages[0].role).toBe('user');
+    });
+
+    it('should preserve parent message references for groupTasks', async () => {
+      const processor = new TasksFlattenProcessor();
+
+      const context = {
+        messages: [
+          {
+            groupId: 'group-1',
+            id: 'groupTasks-1',
+            parentId: 'parent-1',
+            role: 'groupTasks',
+            tasks: [
+              {
+                agentId: 'agent-1',
+                content: 'Task result',
+                id: 'task-1',
+                role: 'task',
+              },
+            ],
+            threadId: 'thread-1',
+            topicId: 'topic-1',
+          },
+        ],
+        metadata: {},
+        stats: { startTime: Date.now() },
+      };
+
+      const result = await processor.process(context as any);
+
+      expect(result.messages).toHaveLength(1);
+      expect(result.messages[0].parentId).toBe('parent-1');
+      expect(result.messages[0].threadId).toBe('thread-1');
+      expect(result.messages[0].groupId).toBe('group-1');
+      expect(result.messages[0].topicId).toBe('topic-1');
+    });
+
+    it('should handle mixed tasks and groupTasks messages', async () => {
+      const processor = new TasksFlattenProcessor();
+
+      const context = {
+        messages: [
+          {
+            id: 'tasks-1',
+            role: 'tasks',
+            tasks: [{ content: 'Task A', id: 'task-a', role: 'task' }],
+          },
+          {
+            content: 'User message',
+            id: 'msg-1',
+            role: 'user',
+          },
+          {
+            id: 'groupTasks-1',
+            role: 'groupTasks',
+            tasks: [
+              { agentId: 'agent-1', content: 'Task B', id: 'task-b', role: 'task' },
+              { agentId: 'agent-2', content: 'Task C', id: 'task-c', role: 'task' },
+            ],
+          },
+        ],
+        metadata: {},
+        stats: { startTime: Date.now() },
+      };
+
+      const result = await processor.process(context as any);
+
+      // Should have 4 messages: 1 from tasks + 1 user + 2 from groupTasks
+      expect(result.messages).toHaveLength(4);
+      expect(result.messages[0].id).toBe('task-a');
+      expect(result.messages[1].id).toBe('msg-1');
+      expect(result.messages[2].id).toBe('task-b');
+      expect(result.messages[3].id).toBe('task-c');
+
+      // Metadata should count both
+      expect(result.metadata.tasksMessagesFlattened).toBe(2);
+      expect(result.metadata.taskMessagesCreated).toBe(3);
+    });
+  });
 });