opencode-pilot 0.24.3 → 0.24.5

package/Formula/opencode-pilot.rb

@@ -1,8 +1,8 @@
 class OpencodePilot < Formula
   desc "Automation daemon for OpenCode - polls GitHub/Linear issues and spawns sessions"
   homepage "https://github.com/athal7/opencode-pilot"
-  url "https://github.com/athal7/opencode-pilot/archive/refs/tags/v0.24.2.tar.gz"
-  sha256 "ffdb6ca6cf6b4d0656df859c91fd287c8a466137e86accfcb2b6d1a056782562"
+  url "https://github.com/athal7/opencode-pilot/archive/refs/tags/v0.24.4.tar.gz"
+  sha256 "7a697b9543877054b0ae42a4bbfff69f1bb9b91c3c724cbee9cc256bd75d2e83"
   license "MIT"
 
   depends_on "node"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-pilot",
-  "version": "0.24.3",
+  "version": "0.24.5",
   "type": "module",
   "main": "plugin/index.js",
   "description": "Automation daemon for OpenCode - polls for work and spawns sessions",

package/service/actions.js

@@ -14,6 +14,12 @@ import { resolveWorktreeDirectory, getProjectInfo, getProjectInfoForDirectory }
 import path from "path";
 import os from "os";
 
+// Safety timeout for the server to return HTTP response headers.
+// The /command endpoint can take 30-45s to return headers because it does
+// work before responding. The /message endpoint returns headers in ~1ms.
+// These are generous upper bounds — if exceeded, the server is genuinely stuck.
+export const HEADER_TIMEOUT_MS = 60_000;
+
 /**
  * Parse a slash command from the beginning of a prompt
  * Returns null if the prompt doesn't start with a slash command
@@ -519,6 +525,7 @@ export function selectBestSession(sessions, statuses) {
  */
 export async function sendMessageToSession(serverUrl, sessionId, directory, prompt, options = {}) {
   const fetchFn = options.fetch || fetch;
+  const headerTimeout = options.headerTimeout || HEADER_TIMEOUT_MS;
   
   try {
     // Step 1: Update session title if provided
@@ -536,9 +543,16 @@ export async function sendMessageToSession(serverUrl, sessionId, directory, prom
     // Step 2: Check if the prompt starts with a slash command
     const parsedCommand = parseSlashCommand(prompt);
     
-    // Use AbortController with timeout (same pattern as createSessionViaApi)
+    // Wait for response headers (confirming server accepted the request),
+    // then abort the body stream. Safety timeout catches stuck requests.
     const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), 10000);
+    let headersReceived = false;
+    const timeoutId = setTimeout(() => {
+      if (!headersReceived) {
+        debug(`sendMessageToSession: safety timeout - server did not return headers within ${headerTimeout}ms for session ${sessionId}`);
+        controller.abort();
+      }
+    }, headerTimeout);
     
     try {
       let response;
@@ -580,6 +594,8 @@ export async function sendMessageToSession(serverUrl, sessionId, directory, prom
         });
       }
       
+      // Headers received — cancel the safety timeout
+      headersReceived = true;
       clearTimeout(timeoutId);
       
       if (!response.ok) {
@@ -587,14 +603,17 @@ export async function sendMessageToSession(serverUrl, sessionId, directory, prom
         throw new Error(`Failed to send ${parsedCommand ? 'command' : 'message'}: ${response.status} ${errorText}`);
       }
       
-      debug(`sendMessageToSession: sent ${parsedCommand ? 'command' : 'message'} to session ${sessionId}`);
+      debug(`sendMessageToSession: ${parsedCommand ? 'command' : 'message'} accepted by server for session ${sessionId}`);
     } catch (abortErr) {
       clearTimeout(timeoutId);
-      if (abortErr.name === 'AbortError') {
-        debug(`sendMessageToSession: request started for session ${sessionId} (response aborted as expected)`);
-      } else {
-        throw abortErr;
+      if (abortErr.name === 'AbortError' && !headersReceived) {
+        throw new Error(`Server did not confirm acceptance within ${headerTimeout / 1000}s for session ${sessionId}`);
       }
+      throw abortErr;
+    } finally {
+      // Abort the body stream — we don't need the streaming response content.
+      // Done in finally to ensure cleanup regardless of success/error path.
+      controller.abort();
     }
     
     return {
@@ -670,6 +689,7 @@ export async function findReusableSession(serverUrl, directory, options = {}) {
  */
 export async function createSessionViaApi(serverUrl, directory, prompt, options = {}) {
   const fetchFn = options.fetch || fetch;
+  const headerTimeout = options.headerTimeout || HEADER_TIMEOUT_MS;
   
   let session = null;
   
@@ -706,11 +726,18 @@ export async function createSessionViaApi(serverUrl, directory, prompt, options
     // Step 3: Check if the prompt starts with a slash command
     const parsedCommand = parseSlashCommand(prompt);
     
-    // Use AbortController with timeout for the request
-    // The endpoints return a chunked/streaming response that stays open until
-    // the agent completes. We only need to verify the request was accepted.
+    // Wait for the server to return response headers (confirming it accepted the
+    // request), then abort the body stream. The /command endpoint can take 30-45s
+    // to return headers — we must NOT abort before that or we can't tell if the
+    // server actually accepted. A generous safety timeout catches truly stuck requests.
     const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), 10000); // 10 second timeout
+    let headersReceived = false;
+    const timeoutId = setTimeout(() => {
+      if (!headersReceived) {
+        debug(`createSessionViaApi: safety timeout - server did not return headers within ${headerTimeout}ms for session ${session.id}`);
+        controller.abort();
+      }
+    }, headerTimeout);
     
     try {
       let response;
@@ -755,6 +782,8 @@ export async function createSessionViaApi(serverUrl, directory, prompt, options
         });
       }
       
+      // Headers received — cancel the safety timeout
+      headersReceived = true;
       clearTimeout(timeoutId);
       
       if (!response.ok) {
@@ -762,16 +791,19 @@ export async function createSessionViaApi(serverUrl, directory, prompt, options
         throw new Error(`Failed to send ${parsedCommand ? 'command' : 'message'}: ${response.status} ${errorText}`);
       }
       
-      debug(`createSessionViaApi: sent ${parsedCommand ? 'command' : 'message'} to session ${session.id}`);
+      debug(`createSessionViaApi: ${parsedCommand ? 'command' : 'message'} accepted by server for session ${session.id}`);
     } catch (abortErr) {
       clearTimeout(timeoutId);
-      // AbortError is expected - we intentionally abort after verifying the request started
-      // The server accepted our request, we just don't need to wait for the response
-      if (abortErr.name === 'AbortError') {
-        debug(`createSessionViaApi: request started for session ${session.id} (response aborted as expected)`);
-      } else {
-        throw abortErr;
+      if (abortErr.name === 'AbortError' && !headersReceived) {
+        // Safety timeout fired before headers arrived.
+        // The server may or may not have accepted the request — we don't know.
+        throw new Error(`Server did not confirm acceptance within ${headerTimeout / 1000}s for session ${session.id}`);
       }
+      throw abortErr;
+    } finally {
+      // Abort the body stream — we don't need the streaming response content.
+      // Done in finally to ensure cleanup regardless of success/error path.
+      controller.abort();
     }
     
     return {
@@ -903,6 +935,7 @@ async function executeInDirectory(serverUrl, cwd, item, config, options = {}) {
     sessionId: result.sessionId,
     directory: cwd,
     error: result.error,
+    warning: result.warning,
   };
 }
 

package/service/poll-service.js

@@ -310,6 +310,9 @@ export async function pollOnce(options = {}) {
                 // Store attention state for detecting new feedback on PRs
                 // _has_attention is boolean for enriched items, undefined for non-PR sources
                 hasAttention: item._has_attention ?? null,
+                // Store latest feedback timestamp for detecting new reviews on PRs
+                // that were already processed with existing feedback (true -> true)
+                latestFeedbackAt: item._latest_feedback_at ?? null,
                 dedupKeys: dedupKeys.length > 0 ? dedupKeys : undefined,
               });
             }

package/service/poller.js

@@ -12,7 +12,7 @@ import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import fs from "fs";
 import path from "path";
 import os from "os";
-import { getNestedValue, hasNonBotFeedback, extractIssueRefs } from "./utils.js";
+import { getNestedValue, hasNonBotFeedback, getLatestFeedbackTimestamp, extractIssueRefs } from "./utils.js";
 
 /**
  * Expand template string with item fields
@@ -809,6 +809,7 @@ export function detectStacks(items) {
 export function computeAttentionLabels(items, source) {
   return items.map(item => {
     const reasons = [];
+    let latestFeedbackAt = null;
     
     // Check for merge conflicts
     if (item._mergeable === 'CONFLICTING') {
@@ -821,6 +822,8 @@ export function computeAttentionLabels(items, source) {
       const authorUsername = item.user?.login || item.author?.login;
       if (hasNonBotFeedback(item._comments, authorUsername)) {
         reasons.push('Feedback');
+        // Track the latest feedback timestamp for detecting new reviews
+        latestFeedbackAt = getLatestFeedbackTimestamp(item._comments, authorUsername);
       }
     }
     
@@ -831,6 +834,7 @@ export function computeAttentionLabels(items, source) {
       ...item,
       _attention_label: label,
       _has_attention: reasons.length > 0,
+      _latest_feedback_at: latestFeedbackAt,
     };
   });
 }
@@ -1253,15 +1257,28 @@ export function createPoller(options = {}) {
         }
         
         // Handle attention field (detect new feedback on PRs)
-        // Only reprocess when attention changes from false to true
+        // Triggers when:
+        // 1. Attention changes from false to true (new feedback on a clean PR)
+        // 2. Attention stays true but latest feedback is newer (re-review or additional feedback)
         if (field === 'attention') {
           const storedHasAttention = meta.hasAttention;
           const currentHasAttention = item._has_attention;
           
-          // Only trigger if we have stored state (not legacy items) and attention changed false -> true
+          // Trigger if attention changed false -> true
           if (storedHasAttention === false && currentHasAttention === true) {
             return true;
           }
+          
+          // Trigger if attention stayed true but there's newer feedback
+          // This catches re-reviews and additional feedback on PRs already processed with feedback
+          if (storedHasAttention === true && currentHasAttention === true) {
+            const storedFeedbackAt = meta.latestFeedbackAt;
+            const currentFeedbackAt = item._latest_feedback_at;
+            
+            if (storedFeedbackAt && currentFeedbackAt && currentFeedbackAt > storedFeedbackAt) {
+              return true;
+            }
+          }
         }
       }
       

package/service/utils.js

@@ -192,34 +192,7 @@ export function hasNonBotFeedback(comments, authorUsername) {
   const authorLower = authorUsername?.toLowerCase();
   
   for (const comment of comments) {
-    const user = comment.user;
-    if (!user) continue;
-    
-    const username = user.login;
-    const userType = user.type;
-    
-    // Skip if it's a bot (but Copilot is NOT in bot list, so Copilot reviews are kept)
-    if (isBot(username, userType)) continue;
-    
-    // For author's own feedback, apply special rules
-    if (authorLower && username?.toLowerCase() === authorLower) {
-      // Author's PR reviews → trigger
-      if (isPrReview(comment)) {
-        // Continue to check if it's actionable (not approval-only)
-      }
-      // Author's inline comments (standalone only) → trigger
-      else if (isInlineComment(comment)) {
-        if (isReply(comment)) continue; // Skip replies
-        // Standalone inline comment - continue to actionable check
-      }
-      // Author's top-level comments → ignore
-      else {
-        continue;
-      }
-    }
-    
-    // Skip approval-only reviews (no actionable feedback)
-    if (isApprovalOnly(comment)) continue;
+    if (!isActionableFeedback(comment, authorLower)) continue;
     
     // Found actionable feedback
     return true;
@@ -227,3 +200,84 @@ export function hasNonBotFeedback(comments, authorUsername) {
   
   return false;
 }
+
+/**
+ * Check if a single comment/review is actionable feedback
+ * 
+ * Extracted from hasNonBotFeedback to allow reuse in getLatestFeedbackTimestamp.
+ * 
+ * @param {object} comment - Comment or review object
+ * @param {string} [authorLower] - Lowercase author username
+ * @returns {boolean} True if the comment is actionable feedback
+ */
+function isActionableFeedback(comment, authorLower) {
+  const user = comment.user;
+  if (!user) return false;
+  
+  const username = user.login;
+  const userType = user.type;
+  
+  // Skip if it's a bot (but Copilot is NOT in bot list, so Copilot reviews are kept)
+  if (isBot(username, userType)) return false;
+  
+  // For author's own feedback, apply special rules
+  if (authorLower && username?.toLowerCase() === authorLower) {
+    // Author's PR reviews → trigger
+    if (isPrReview(comment)) {
+      // Continue to check if it's actionable (not approval-only)
+    }
+    // Author's inline comments (standalone only) → trigger
+    else if (isInlineComment(comment)) {
+      if (isReply(comment)) return false; // Skip replies
+      // Standalone inline comment - continue to actionable check
+    }
+    // Author's top-level comments → ignore
+    else {
+      return false;
+    }
+  }
+  
+  // Skip approval-only reviews (no actionable feedback)
+  if (isApprovalOnly(comment)) return false;
+  
+  return true;
+}
+
+/**
+ * Get the timestamp of the latest actionable feedback on a PR/issue
+ * 
+ * Uses the same filtering logic as hasNonBotFeedback to identify actionable
+ * comments, then returns the most recent timestamp. This allows detecting
+ * new feedback even when the PR was already processed with existing feedback.
+ * 
+ * GitHub API timestamp fields:
+ * - PR reviews: submitted_at
+ * - PR review comments (inline): updated_at, created_at
+ * - Issue comments: updated_at, created_at
+ * 
+ * @param {Array} comments - Array of comment/review objects
+ * @param {string} authorUsername - Username of the PR/issue author
+ * @returns {string|null} ISO timestamp of latest feedback, or null if none
+ */
+export function getLatestFeedbackTimestamp(comments, authorUsername) {
+  if (!comments || !Array.isArray(comments) || comments.length === 0) {
+    return null;
+  }
+  
+  const authorLower = authorUsername?.toLowerCase();
+  let latest = null;
+  
+  for (const comment of comments) {
+    if (!isActionableFeedback(comment, authorLower)) continue;
+    
+    // PR reviews use submitted_at, comments use updated_at or created_at
+    const timestamp = comment.submitted_at || comment.updated_at || comment.created_at;
+    if (!timestamp) continue;
+    
+    if (!latest || timestamp > latest) {
+      latest = timestamp;
+    }
+  }
+  
+  return latest;
+}

package/test/unit/actions.test.js

@@ -1263,6 +1263,103 @@ Check for bugs and security issues.`;
     });
   });
 
+  describe('createSessionViaApi timeout handling', () => {
+    test('treats safety timeout as error with warning (not silent success)', async () => {
+      const { createSessionViaApi } = await import('../../service/actions.js');
+      
+      const mockSessionId = 'ses_timeout123';
+      
+      const mockFetch = async (url, opts) => {
+        const urlObj = new URL(url);
+        
+        // Session creation succeeds
+        if (urlObj.pathname === '/session' && opts?.method === 'POST') {
+          return {
+            ok: true,
+            json: async () => ({ id: mockSessionId }),
+          };
+        }
+        
+        // Title update succeeds
+        if (opts?.method === 'PATCH') {
+          return { ok: true, json: async () => ({}) };
+        }
+        
+        // Message endpoint: simulate server never returning headers
+        // by waiting until the AbortSignal fires
+        if (urlObj.pathname.includes('/message') && opts?.method === 'POST') {
+          return new Promise((resolve, reject) => {
+            if (opts.signal) {
+              opts.signal.addEventListener('abort', () => {
+                reject(new DOMException('The operation was aborted.', 'AbortError'));
+              });
+            }
+          });
+        }
+        
+        return { ok: false, text: async () => 'Not found' };
+      };
+      
+      const result = await createSessionViaApi(
+        'http://localhost:4096',
+        '/path/to/project',
+        'Fix the bug',
+        { fetch: mockFetch, title: 'Test Session', headerTimeout: 100 }
+      );
+      
+      // Should return success (session was created) but WITH a warning
+      assert.ok(result.success, 'Should return success because session was created');
+      assert.strictEqual(result.sessionId, mockSessionId, 'Should return session ID');
+      assert.ok(result.warning, 'Should include warning about timeout');
+      assert.ok(result.warning.includes('did not confirm acceptance'), 'Warning should mention acceptance timeout');
+    });
+
+    test('aborts body stream after receiving 200 headers', async () => {
+      const { createSessionViaApi } = await import('../../service/actions.js');
+      
+      const mockSessionId = 'ses_headers123';
+      let bodyAborted = false;
+      
+      const mockFetch = async (url, opts) => {
+        const urlObj = new URL(url);
+        
+        if (urlObj.pathname === '/session' && opts?.method === 'POST') {
+          return {
+            ok: true,
+            json: async () => ({ id: mockSessionId }),
+          };
+        }
+        
+        if (urlObj.pathname.includes('/message') && opts?.method === 'POST') {
+          // Track when the signal aborts (should happen after we return 200)
+          if (opts.signal) {
+            opts.signal.addEventListener('abort', () => {
+              bodyAborted = true;
+            });
+          }
+          // Return 200 immediately (simulating headers received)
+          return {
+            ok: true,
+            json: async () => ({ success: true }),
+          };
+        }
+        
+        return { ok: false, text: async () => 'Not found' };
+      };
+      
+      const result = await createSessionViaApi(
+        'http://localhost:4096',
+        '/path/to/project',
+        'Fix the bug',
+        { fetch: mockFetch }
+      );
+      
+      assert.ok(result.success, 'Should succeed');
+      assert.ok(!result.warning, 'Should NOT have a warning');
+      assert.ok(bodyAborted, 'Should have aborted the body stream after receiving headers');
+    });
+  });
+
   describe('sendMessageToSession slash command routing', () => {
     test('uses /command endpoint for slash commands', async () => {
       const { sendMessageToSession } = await import('../../service/actions.js');

package/test/unit/poller.test.js

@@ -813,23 +813,65 @@ describe('poller.js', () => {
       );
     });
 
-    test('shouldReprocess returns false when attention stays true', async () => {
+    test('shouldReprocess returns false when attention stays true with same feedback timestamp', async () => {
       const { createPoller } = await import('../../service/poller.js');
       
       const poller = createPoller({ stateFile });
-      // Item was processed with attention
+      // Item was processed with attention and a feedback timestamp
+      poller.markProcessed('pr-1', { 
+        source: 'my-prs-attention', 
+        itemState: 'open',
+        hasAttention: true,
+        latestFeedbackAt: '2026-01-15T10:00:00Z'
+      });
+      
+      // Item still has attention with the same feedback timestamp
+      const item = { id: 'pr-1', state: 'open', _has_attention: true, _latest_feedback_at: '2026-01-15T10:00:00Z' };
+      assert.strictEqual(
+        poller.shouldReprocess(item, { reprocessOn: ['attention'] }), 
+        false,
+        'Should NOT reprocess when attention stays true with same feedback'
+      );
+    });
+
+    test('shouldReprocess returns true when attention stays true but feedback is newer (re-review)', async () => {
+      const { createPoller } = await import('../../service/poller.js');
+      
+      const poller = createPoller({ stateFile });
+      // Item was processed with attention and a feedback timestamp
+      poller.markProcessed('pr-1', { 
+        source: 'my-prs-attention', 
+        itemState: 'open',
+        hasAttention: true,
+        latestFeedbackAt: '2026-01-15T10:00:00Z'
+      });
+      
+      // Item has newer feedback (re-review or additional comments)
+      const item = { id: 'pr-1', state: 'open', _has_attention: true, _latest_feedback_at: '2026-01-16T14:30:00Z' };
+      assert.strictEqual(
+        poller.shouldReprocess(item, { reprocessOn: ['attention'] }), 
+        true,
+        'Should reprocess when there is newer feedback (re-review)'
+      );
+    });
+
+    test('shouldReprocess returns false when attention stays true with no timestamps', async () => {
+      const { createPoller } = await import('../../service/poller.js');
+      
+      const poller = createPoller({ stateFile });
+      // Legacy item processed with attention but no timestamp
       poller.markProcessed('pr-1', { 
         source: 'my-prs-attention', 
         itemState: 'open',
         hasAttention: true
       });
       
-      // Item still has attention
+      // Item still has attention (no timestamp available either)
       const item = { id: 'pr-1', state: 'open', _has_attention: true };
       assert.strictEqual(
         poller.shouldReprocess(item, { reprocessOn: ['attention'] }), 
         false,
-        'Should NOT reprocess when attention stays true'
+        'Should NOT reprocess when no timestamps available (legacy)'
       );
     });
 
@@ -1388,6 +1430,43 @@ describe('poller.js', () => {
       assert.strictEqual(result[0]._attention_label, 'PR');
       assert.strictEqual(result[0]._has_attention, false);
     });
+
+    test('tracks latest feedback timestamp for detecting re-reviews', async () => {
+      const { computeAttentionLabels } = await import('../../service/poller.js');
+      
+      const items = [{
+        number: 123,
+        title: 'Test PR',
+        user: { login: 'author' },
+        _mergeable: 'MERGEABLE',
+        _comments: [
+          { user: { login: 'reviewer1', type: 'User' }, body: 'Fix this', created_at: '2026-01-10T10:00:00Z', updated_at: '2026-01-10T10:00:00Z' },
+          { user: { login: 'reviewer2', type: 'User' }, state: 'CHANGES_REQUESTED', body: 'Also this', submitted_at: '2026-01-15T14:30:00Z' },
+        ]
+      }];
+      
+      const result = computeAttentionLabels(items, {});
+      
+      assert.strictEqual(result[0]._has_attention, true);
+      assert.strictEqual(result[0]._latest_feedback_at, '2026-01-15T14:30:00Z');
+    });
+
+    test('sets latest feedback timestamp to null when no feedback', async () => {
+      const { computeAttentionLabels } = await import('../../service/poller.js');
+      
+      const items = [{
+        number: 123,
+        title: 'Test PR',
+        user: { login: 'author' },
+        _mergeable: 'MERGEABLE',
+        _comments: []
+      }];
+      
+      const result = computeAttentionLabels(items, {});
+      
+      assert.strictEqual(result[0]._has_attention, false);
+      assert.strictEqual(result[0]._latest_feedback_at, null);
+    });
   });
 
   describe('enrichItemsWithComments', () => {

package/test/unit/utils.test.js

@@ -192,6 +192,71 @@ describe('utils.js', () => {
     });
   });
 
+  describe('getLatestFeedbackTimestamp', () => {
+    test('returns null for empty/null/undefined comments', async () => {
+      const { getLatestFeedbackTimestamp } = await import('../../service/utils.js');
+      
+      assert.strictEqual(getLatestFeedbackTimestamp([], 'author'), null);
+      assert.strictEqual(getLatestFeedbackTimestamp(null, 'author'), null);
+      assert.strictEqual(getLatestFeedbackTimestamp(undefined, 'author'), null);
+    });
+
+    test('returns latest timestamp from actionable feedback', async () => {
+      const { getLatestFeedbackTimestamp } = await import('../../service/utils.js');
+      
+      const comments = [
+        { user: { login: 'reviewer1', type: 'User' }, body: 'Fix this', created_at: '2026-01-10T10:00:00Z', updated_at: '2026-01-10T10:00:00Z' },
+        { user: { login: 'reviewer2', type: 'User' }, body: 'Also this', created_at: '2026-01-15T14:30:00Z', updated_at: '2026-01-15T14:30:00Z' },
+      ];
+      
+      assert.strictEqual(getLatestFeedbackTimestamp(comments, 'author'), '2026-01-15T14:30:00Z');
+    });
+
+    test('uses submitted_at for PR reviews', async () => {
+      const { getLatestFeedbackTimestamp } = await import('../../service/utils.js');
+      
+      const comments = [
+        { user: { login: 'reviewer', type: 'User' }, state: 'CHANGES_REQUESTED', body: 'Fix this', submitted_at: '2026-01-20T09:00:00Z', created_at: '2026-01-15T10:00:00Z' },
+      ];
+      
+      assert.strictEqual(getLatestFeedbackTimestamp(comments, 'author'), '2026-01-20T09:00:00Z');
+    });
+
+    test('ignores bot comments when computing latest timestamp', async () => {
+      const { getLatestFeedbackTimestamp } = await import('../../service/utils.js');
+      
+      const comments = [
+        { user: { login: 'reviewer', type: 'User' }, body: 'Fix this', created_at: '2026-01-10T10:00:00Z', updated_at: '2026-01-10T10:00:00Z' },
+        { user: { login: 'github-actions[bot]', type: 'Bot' }, body: 'CI passed', created_at: '2026-01-20T10:00:00Z', updated_at: '2026-01-20T10:00:00Z' },
+      ];
+      
+      assert.strictEqual(getLatestFeedbackTimestamp(comments, 'author'), '2026-01-10T10:00:00Z');
+    });
+
+    test('ignores approval-only reviews', async () => {
+      const { getLatestFeedbackTimestamp } = await import('../../service/utils.js');
+      
+      const comments = [
+        { user: { login: 'reviewer', type: 'User' }, body: 'Fix this', created_at: '2026-01-10T10:00:00Z', updated_at: '2026-01-10T10:00:00Z' },
+        { user: { login: 'approver', type: 'User' }, state: 'APPROVED', body: '', submitted_at: '2026-01-20T10:00:00Z' },
+      ];
+      
+      // Approval-only should be filtered out, latest is the first comment
+      assert.strictEqual(getLatestFeedbackTimestamp(comments, 'author'), '2026-01-10T10:00:00Z');
+    });
+
+    test('returns null when only bot comments exist', async () => {
+      const { getLatestFeedbackTimestamp } = await import('../../service/utils.js');
+      
+      const comments = [
+        { user: { login: 'linear', type: 'User' }, body: 'ENG-123', created_at: '2026-01-10T10:00:00Z' },
+        { user: { login: 'github-actions[bot]', type: 'Bot' }, body: 'CI passed', created_at: '2026-01-15T10:00:00Z' },
+      ];
+      
+      assert.strictEqual(getLatestFeedbackTimestamp(comments, 'author'), null);
+    });
+  });
+
   describe('isApprovalOnly', () => {
     test('returns true for APPROVED state with no body', async () => {
       const { isApprovalOnly } = await import('../../service/utils.js');