@link-assistant/hive-mind 1.34.8 → 1.35.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @link-assistant/hive-mind
 
+## 1.35.0
+
+### Minor Changes
+
+- f3de781: Add handlers for agent task lifecycle events (task_started, task_progress, task_notification) and rate_limit_event in interactive mode, reducing PR comment noise by ~30%
+
 ## 1.34.8
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.34.8",
+  "version": "1.35.0",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",

package/src/interactive-mode.lib.mjs

@@ -7,10 +7,14 @@
  *
  * Supported JSON event types:
  * - system.init: Session initialization
+ * - system.task_started: Agent subtask started (Issue #1450)
+ * - system.task_progress: Agent subtask progress update (Issue #1450)
+ * - system.task_notification: Agent subtask completed/failed (Issue #1450)
  * - assistant (text): AI text responses
  * - assistant (tool_use): Tool invocations
  * - user (tool_result): Tool execution results
  * - result: Session completion
+ * - rate_limit_event: Rate limit info (silently logged, Issue #1450)
  * - unrecognized: Any unknown event types
  *
  * Features:
@@ -213,6 +217,7 @@ const getToolIcon = toolName => {
     WebSearch: '🔍',
     TodoWrite: '📋',
     Task: '🎯',
+    Agent: '🤖',
     NotebookEdit: '📓',
     default: '🔧',
   };
@@ -253,6 +258,9 @@ export const createInteractiveHandler = options => {
     // Simple map of tool_use_id -> { toolName, toolIcon } for standalone tool results
     // This is preserved even after pendingToolCalls entry is deleted
     toolUseRegistry: new Map(),
+    // Track active agent tasks for progress update deduplication
+    // Map of task_id -> { commentId, toolUseId, description, commentIdPromise, resolveCommentId }
+    pendingTasks: new Map(),
   };
 
   /**
@@ -809,6 +817,232 @@ ${createRawJsonSection(data)}`;
     }
   };
 
+  /**
+   * Handle system.task_started event (Agent subtask started)
+   * Creates a progress comment that will be updated by task_progress events
+   * @param {Object} data - Event data
+   */
+  const handleTaskStarted = async data => {
+    const taskId = data.task_id;
+    const toolUseId = data.tool_use_id || '';
+    const description = data.description || 'Agent task';
+    const taskType = data.task_type || 'unknown';
+
+    // Create a promise for the comment ID (handles queued comments)
+    let resolveCommentId;
+    const commentIdPromise = new Promise(resolve => {
+      resolveCommentId = resolve;
+    });
+
+    // Build prompt preview if available
+    let promptSection = '';
+    if (data.prompt) {
+      const truncatedPrompt = truncateMiddle(data.prompt, { maxLines: 15, keepStart: 6, keepEnd: 6 });
+      promptSection = '\n\n' + createCollapsible('📝 Task prompt', truncatedPrompt);
+    }
+
+    const comment = `## 🤖 Agent task: ${escapeMarkdown(description)}
+
+| Property | Value |
+|----------|-------|
+| **Task ID** | \`${taskId || 'unknown'}\` |
+| **Type** | \`${taskType}\` |
+| **Status** | ⏳ Running... |
+${promptSection}
+
+---
+
+${createRawJsonSection(data)}`;
+
+    // Track this task BEFORE posting
+    state.pendingTasks.set(taskId, {
+      commentId: null,
+      commentIdPromise,
+      resolveCommentId,
+      toolUseId,
+      description,
+      lastProgressDescription: description,
+      progressCount: 0,
+      allEvents: [data],
+    });
+
+    const commentId = await postComment(comment, null);
+
+    if (commentId) {
+      const pendingTask = state.pendingTasks.get(taskId);
+      if (pendingTask) {
+        pendingTask.commentId = commentId;
+        resolveCommentId(commentId);
+      }
+    }
+
+    if (verbose) {
+      await log(`🤖 Interactive mode: Agent task started - ${description} (task: ${taskId})`, { verbose: true });
+    }
+  };
+
+  /**
+   * Handle system.task_progress event (Agent subtask progress update)
+   * Updates the existing task comment instead of creating a new one
+   * @param {Object} data - Event data
+   */
+  const handleTaskProgress = async data => {
+    const taskId = data.task_id;
+    const description = data.description || 'Working...';
+    const lastToolName = data.last_tool_name || '';
+    const usage = data.usage || {};
+
+    const pendingTask = state.pendingTasks.get(taskId);
+
+    if (pendingTask) {
+      pendingTask.progressCount++;
+      pendingTask.lastProgressDescription = description;
+      pendingTask.allEvents.push(data);
+
+      let commentId = pendingTask.commentId;
+
+      // Wait for comment ID if not yet available
+      if (!commentId && pendingTask.commentIdPromise) {
+        const timeoutPromise = new Promise(resolve => setTimeout(() => resolve(null), 15000));
+        commentId = await Promise.race([pendingTask.commentIdPromise, timeoutPromise]);
+      }
+
+      if (commentId) {
+        // Build progress steps list from accumulated events
+        const progressSteps = pendingTask.allEvents
+          .filter(e => e.subtype === 'task_progress')
+          .map(e => {
+            const toolIcon = e.last_tool_name ? getToolIcon(e.last_tool_name) : '🔄';
+            return `- ${toolIcon} ${e.description || 'Working...'}`;
+          })
+          .join('\n');
+
+        const durationText = usage.duration_ms ? formatDuration(usage.duration_ms) : '';
+        const toolUsesText = usage.tool_uses ? `${usage.tool_uses} tool calls` : '';
+        const statsText = [durationText, toolUsesText].filter(Boolean).join(' | ');
+
+        const updatedComment = `## 🤖 Agent task: ${escapeMarkdown(pendingTask.description)}
+
+| Property | Value |
+|----------|-------|
+| **Task ID** | \`${taskId}\` |
+| **Status** | ⏳ Running... |
+| **Progress** | ${pendingTask.progressCount} updates |
+${statsText ? `| **Stats** | ${statsText} |\n` : ''}
+${createCollapsible(`📋 Progress steps (${pendingTask.progressCount})`, progressSteps, true)}
+
+---
+
+${createRawJsonSection(pendingTask.allEvents.slice(-3))}`;
+
+        await editComment(commentId, updatedComment);
+      }
+    } else {
+      // No pending task found - this can happen if task_started was missed
+      // Just log it silently rather than creating an unrecognized comment
+      if (verbose) {
+        await log(`🤖 Interactive mode: Task progress for unknown task ${taskId}: ${description}`, { verbose: true });
+      }
+    }
+
+    if (verbose) {
+      await log(`🤖 Interactive mode: Task progress - ${description} (task: ${taskId}, tool: ${lastToolName})`, { verbose: true });
+    }
+  };
+
+  /**
+   * Handle system.task_notification event (Agent subtask completed/failed)
+   * Updates the existing task comment with final status
+   * @param {Object} data - Event data
+   */
+  const handleTaskNotification = async data => {
+    const taskId = data.task_id;
+    const status = data.status || 'unknown';
+    const summary = data.summary || data.description || 'Task finished';
+    const usage = data.usage || {};
+    const isCompleted = status === 'completed';
+    const statusIcon = isCompleted ? '✅' : '❌';
+    const statusText = isCompleted ? 'Completed' : status.charAt(0).toUpperCase() + status.slice(1);
+
+    const pendingTask = state.pendingTasks.get(taskId);
+
+    if (pendingTask) {
+      pendingTask.allEvents.push(data);
+
+      let commentId = pendingTask.commentId;
+
+      // Wait for comment ID if not yet available
+      if (!commentId && pendingTask.commentIdPromise) {
+        const timeoutPromise = new Promise(resolve => setTimeout(() => resolve(null), 15000));
+        commentId = await Promise.race([pendingTask.commentIdPromise, timeoutPromise]);
+      }
+
+      if (commentId) {
+        // Build final progress steps list
+        const progressSteps = pendingTask.allEvents
+          .filter(e => e.subtype === 'task_progress')
+          .map(e => {
+            const toolIcon = e.last_tool_name ? getToolIcon(e.last_tool_name) : '🔄';
+            return `- ${toolIcon} ${e.description || 'Working...'}`;
+          })
+          .join('\n');
+
+        const durationText = usage.duration_ms ? formatDuration(usage.duration_ms) : '';
+        const toolUsesText = usage.tool_uses ? `${usage.tool_uses} tool calls` : '';
+        const tokensText = usage.total_tokens ? `${usage.total_tokens.toLocaleString()} tokens` : '';
+        const statsText = [durationText, toolUsesText, tokensText].filter(Boolean).join(' | ');
+
+        const updatedComment = `## 🤖 Agent task: ${escapeMarkdown(pendingTask.description)}
+
+| Property | Value |
+|----------|-------|
+| **Task ID** | \`${taskId}\` |
+| **Status** | ${statusIcon} ${statusText} |
+| **Summary** | ${escapeMarkdown(summary)} |
+${statsText ? `| **Stats** | ${statsText} |\n` : ''}
+${progressSteps ? createCollapsible(`📋 Progress steps (${pendingTask.progressCount})`, progressSteps) : ''}
+
+---
+
+${createRawJsonSection([pendingTask.allEvents[0], data])}`;
+
+        await editComment(commentId, updatedComment);
+      }
+
+      // Clean up
+      state.pendingTasks.delete(taskId);
+    } else {
+      // Post as standalone if no pending task
+      const comment = `## 🤖 Agent task ${statusIcon} ${statusText}
+
+**Summary:** ${escapeMarkdown(summary)}
+
+---
+
+${createRawJsonSection(data)}`;
+
+      await postComment(comment);
+    }
+
+    if (verbose) {
+      await log(`🤖 Interactive mode: Task ${statusText.toLowerCase()} - ${summary} (task: ${taskId})`, {
+        verbose: true,
+      });
+    }
+  };
+
+  /**
+   * Handle rate_limit_event (silently logged, no comment created)
+   * @param {Object} data - Event data
+   */
+  const handleRateLimitEvent = async data => {
+    // Rate limit events are internal/informational - log but don't create a PR comment
+    if (verbose) {
+      const info = data.rate_limit_info || {};
+      await log(`⏱️ Interactive mode: Rate limit event - status: ${info.status || 'unknown'}, type: ${info.rateLimitType || 'unknown'}`, { verbose: true });
+    }
+  };
+
   /**
    * Handle unrecognized event types
    * @param {Object} data - Event data
@@ -851,12 +1085,22 @@ ${createRawJsonSection(data)}`;
       case 'system':
         if (data.subtype === 'init') {
           await handleSystemInit(data);
+        } else if (data.subtype === 'task_started') {
+          await handleTaskStarted(data);
+        } else if (data.subtype === 'task_progress') {
+          await handleTaskProgress(data);
+        } else if (data.subtype === 'task_notification') {
+          await handleTaskNotification(data);
         } else {
           // Unknown system subtype
           await handleUnrecognized(data);
         }
         break;
 
+      case 'rate_limit_event':
+        await handleRateLimitEvent(data);
+        break;
+
       case 'assistant':
         if (data.message && data.message.content) {
           const content = Array.isArray(data.message.content) ? data.message.content : [data.message.content];
@@ -923,6 +1167,10 @@ ${createRawJsonSection(data)}`;
       handleToolUse,
       handleToolResult,
       handleResult,
+      handleTaskStarted,
+      handleTaskProgress,
+      handleTaskNotification,
+      handleRateLimitEvent,
       handleUnrecognized,
     },
   };