opencode-pilot 0.17.1 → 0.18.0

package/README.md

@@ -65,9 +65,12 @@ Three ways to configure sources, from simplest to most flexible:
 
 - `github/my-issues` - Issues assigned to me
 - `github/review-requests` - PRs needing my review
-- `github/my-prs-feedback` - My PRs with change requests
+- `github/my-prs-feedback` - My PRs with comments/feedback (simple trigger)
+- `github/my-prs-attention` - My PRs needing attention (conflicts OR feedback, with dynamic labeling)
 - `linear/my-issues` - Linear tickets (requires `teamId`, `assigneeId`)
 
+**Tip:** Use `my-prs-attention` instead of `my-prs-feedback` if you also want to detect merge conflicts. The session name will indicate which condition(s) triggered it: "Conflicts: {title}", "Feedback: {title}", or "Conflicts+Feedback: {title}".
+
 ### Prompt Templates
 
 Create prompt templates as markdown files in `~/.config/opencode/pilot/templates/`. Templates support placeholders like `{title}`, `{body}`, `{number}`, `{html_url}`, etc.

package/examples/config.yaml

@@ -27,11 +27,16 @@ sources:
 
   - preset: github/review-requests
 
-  - preset: github/my-prs-feedback
+  # PRs needing attention (conflicts OR feedback) - recommended over my-prs-feedback
+  # Session names dynamically indicate the condition: "Conflicts: ...", "Feedback: ...", or "Conflicts+Feedback: ..."
+  - preset: github/my-prs-attention
     repos:
       - myorg/backend
       - myorg/frontend
 
+  # Alternative: Simple feedback-only trigger (use my-prs-attention for conflicts too)
+  # - preset: github/my-prs-feedback
+
   # Linear (requires teamId and assigneeId)
   - preset: linear/my-issues
     args:
@@ -87,4 +92,4 @@ sources:
 #   ttl_days: 30
 
 # Available presets: github/my-issues, github/review-requests,
-# github/my-prs-feedback, linear/my-issues
+# github/my-prs-feedback, github/my-prs-attention, linear/my-issues

package/package.json

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

package/service/poll-service.js

@@ -10,7 +10,7 @@
  */
 
 import { loadRepoConfig, getRepoConfig, getAllSources, getToolProviderConfig, resolveRepoForItem, getCleanupTtlDays, getStartupDelay } from "./repo-config.js";
-import { createPoller, pollGenericSource, enrichItemsWithComments } from "./poller.js";
+import { createPoller, pollGenericSource, enrichItemsWithComments, enrichItemsWithMergeable, computeAttentionLabels } from "./poller.js";
 import { evaluateReadiness, sortByPriority } from "./readiness.js";
 import { executeAction, buildCommand } from "./actions.js";
 import { debug } from "./logger.js";
@@ -133,6 +133,18 @@ export async function pollOnce(options = {}) {
           items = await enrichItemsWithComments(items, source);
           debug(`Enriched ${items.length} items with comments for bot filtering`);
         }
+        
+        // Enrich items with mergeable status for conflict detection if configured
+        if (source.enrich_mergeable) {
+          items = await enrichItemsWithMergeable(items, source);
+          debug(`Enriched ${items.length} items with mergeable status`);
+        }
+        
+        // Compute attention labels if both enrichments are present (for my-prs-attention)
+        if (source.enrich_mergeable && source.filter_bot_comments) {
+          items = computeAttentionLabels(items, source);
+          debug(`Computed attention labels for ${items.length} items`);
+        }
       } catch (err) {
         console.error(`[poll] Error fetching from ${sourceName}: ${err.message}`);
         continue;

package/service/poller.js

@@ -533,6 +533,116 @@ export async function enrichItemsWithComments(items, source, options = {}) {
   return enrichedItems;
 }
 
+/**
+ * Fetch mergeable status for a PR via gh CLI
+ * 
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @param {number} number - PR number
+ * @param {number} timeout - Timeout in ms
+ * @returns {Promise<string|null>} Mergeable status ("MERGEABLE", "CONFLICTING", "UNKNOWN") or null on error
+ */
+async function fetchMergeableStatus(owner, repo, number, timeout) {
+  const { exec } = await import('child_process');
+  const { promisify } = await import('util');
+  const execAsync = promisify(exec);
+  
+  try {
+    const { stdout } = await Promise.race([
+      execAsync(`gh pr view ${number} -R ${owner}/${repo} --json mergeable --jq .mergeable`),
+      createTimeout(timeout, "gh pr view"),
+    ]);
+    
+    const status = stdout.trim();
+    return status || null;
+  } catch (err) {
+    console.error(`[poller] Error fetching mergeable status for ${owner}/${repo}#${number}: ${err.message}`);
+    return null;
+  }
+}
+
+/**
+ * Enrich items with mergeable status for conflict detection
+ * 
+ * For items from sources with enrich_mergeable: true, fetches mergeable status
+ * via gh CLI and attaches it as _mergeable field for readiness evaluation.
+ * 
+ * @param {Array} items - Items to enrich
+ * @param {object} source - Source configuration with optional enrich_mergeable
+ * @param {object} [options] - Options
+ * @param {number} [options.timeout] - Timeout in ms (default: 30000)
+ * @returns {Promise<Array>} Items with _mergeable field added
+ */
+export async function enrichItemsWithMergeable(items, source, options = {}) {
+  // Skip if not configured
+  if (!source.enrich_mergeable) {
+    return items;
+  }
+  
+  const timeout = options.timeout || DEFAULT_MCP_TIMEOUT;
+  
+  // Fetch mergeable status for each item
+  const enrichedItems = [];
+  for (const item of items) {
+    // Extract owner/repo from item
+    const fullName = item.repository_full_name || item.repository?.nameWithOwner;
+    if (!fullName || !item.number) {
+      enrichedItems.push(item);
+      continue;
+    }
+    
+    const [owner, repo] = fullName.split("/");
+    const mergeable = await fetchMergeableStatus(owner, repo, item.number, timeout);
+    enrichedItems.push({ ...item, _mergeable: mergeable });
+  }
+  
+  return enrichedItems;
+}
+
+/**
+ * Compute attention label from enriched item conditions
+ * 
+ * Examines _mergeable and _comments fields to determine what needs attention.
+ * Sets _attention_label (for session name) and _has_attention (for readiness).
+ * 
+ * @param {Array} items - Items enriched with _mergeable and/or _comments
+ * @param {object} source - Source configuration
+ * @returns {Array} Items with _attention_label and _has_attention added
+ */
+export function computeAttentionLabels(items, source) {
+  return items.map(item => {
+    const reasons = [];
+    
+    // Check for merge conflicts
+    if (item._mergeable === 'CONFLICTING') {
+      reasons.push('Conflicts');
+    }
+    
+    // Check for human feedback (non-bot, non-author comments)
+    if (item._comments && item._comments.length > 0) {
+      const authorUsername = item.user?.login || item.author?.login;
+      const hasHumanFeedback = item._comments.some(comment => {
+        const commenter = comment.user?.login || comment.author?.login;
+        const isBot = commenter?.includes('[bot]') || comment.user?.type === 'Bot';
+        const isAuthor = commenter === authorUsername;
+        return !isBot && !isAuthor;
+      });
+      if (hasHumanFeedback) {
+        reasons.push('Feedback');
+      }
+    }
+    
+    // Build label: "Conflicts", "Feedback", or "Conflicts+Feedback"
+    const label = reasons.length > 0 ? reasons.join('+') : 'PR';
+    
+    return {
+      ...item,
+      _attention_label: label,
+      _has_attention: reasons.length > 0,
+    };
+  });
+}
+
 /**
  * Create a poller instance with state tracking
  * 

package/service/presets/github.yaml

@@ -41,7 +41,7 @@ my-prs-feedback:
   name: my-prs-feedback
   tool:
     # comments:>0 filter ensures only PRs with feedback are returned
-    command: ["gh", "search", "prs", "--author=@me", "--state=open", "comments:>0", "--json", "number,title,url,repository,state,body,updatedAt"]
+    command: ["gh", "search", "prs", "--author=@me", "--state=open", "comments:>0", "--json", "number,title,url,repository,state,body,updatedAt,commentsCount"]
   item:
     id: "{url}"
   repo: "{repository.nameWithOwner}"
@@ -53,3 +53,26 @@ my-prs-feedback:
   reprocess_on:
     - state
     - updatedAt
+
+my-prs-attention:
+  name: my-prs-attention
+  tool:
+    # Get all open PRs authored by me - we filter by conditions after enrichment
+    command: ["gh", "search", "prs", "--author=@me", "--state=open", "--json", "number,title,url,repository,state,body,updatedAt,commentsCount"]
+  item:
+    id: "{url}"
+  repo: "{repository.nameWithOwner}"
+  prompt: review-feedback
+  session:
+    # Dynamic name showing which conditions triggered (set by enrichment)
+    name: "{_attention_label}: {title}"
+  # Enrich with both mergeable status and comments to detect all attention conditions
+  enrich_mergeable: true
+  filter_bot_comments: true
+  readiness:
+    # Require at least one attention condition (conflicts or human feedback)
+    require_attention: true
+  # Reprocess when PR is updated
+  reprocess_on:
+    - state
+    - updatedAt

package/service/readiness.js

@@ -213,6 +213,77 @@ export function checkBotComments(item, config) {
   };
 }
 
+/**
+ * Check if a PR has merge conflicts
+ * 
+ * This check is only applied when the item has been enriched with `_mergeable`
+ * (the mergeable status from GitHub: "MERGEABLE", "CONFLICTING", or "UNKNOWN").
+ * Items without `_mergeable` are considered ready (check is skipped).
+ * 
+ * Used by the my-prs-conflicts source to filter to only PRs with conflicts.
+ * 
+ * @param {object} item - Item with optional _mergeable field
+ * @param {object} config - Repo config with optional readiness.require_conflicts
+ * @returns {object} { ready: boolean, reason?: string }
+ */
+export function checkMergeable(item, config) {
+  const readinessConfig = config.readiness || {};
+  
+  // Skip check if no _mergeable field (item not enriched)
+  if (!item._mergeable) {
+    return { ready: true };
+  }
+  
+  // Check if we require conflicts (for conflict-detection sources)
+  if (readinessConfig.require_conflicts) {
+    if (item._mergeable === "CONFLICTING") {
+      return { ready: true };
+    }
+    return {
+      ready: false,
+      reason: `PR is ${item._mergeable}, not CONFLICTING`,
+    };
+  }
+  
+  // Default: allow any mergeable status
+  return { ready: true };
+}
+
+/**
+ * Check if a PR needs attention (has conflicts OR human feedback)
+ * 
+ * This check uses the _has_attention field computed by computeAttentionLabels().
+ * Items without _has_attention are considered ready (check is skipped).
+ * 
+ * Used by the my-prs-attention source to filter to PRs needing action.
+ * 
+ * @param {object} item - Item with optional _has_attention field
+ * @param {object} config - Repo config with optional readiness.require_attention
+ * @returns {object} { ready: boolean, reason?: string }
+ */
+export function checkAttention(item, config) {
+  const readinessConfig = config.readiness || {};
+  
+  // Skip check if require_attention not configured
+  if (!readinessConfig.require_attention) {
+    return { ready: true };
+  }
+  
+  // Skip check if _has_attention not computed (item not enriched)
+  if (item._has_attention === undefined) {
+    return { ready: true };
+  }
+  
+  if (item._has_attention) {
+    return { ready: true };
+  }
+  
+  return {
+    ready: false,
+    reason: "PR has no conflicts and no human feedback - no attention needed",
+  };
+}
+
 /**
  * Calculate priority score for an issue
  * @param {object} issue - Issue with labels and created_at
@@ -286,6 +357,26 @@ export function evaluateReadiness(issue, config) {
     };
   }
 
+  // Check mergeable status (for PRs enriched with _mergeable)
+  const mergeableResult = checkMergeable(issue, config);
+  if (!mergeableResult.ready) {
+    return {
+      ready: false,
+      reason: mergeableResult.reason,
+      priority: 0,
+    };
+  }
+
+  // Check attention status (for PRs needing conflicts OR feedback)
+  const attentionResult = checkAttention(issue, config);
+  if (!attentionResult.ready) {
+    return {
+      ready: false,
+      reason: attentionResult.reason,
+      priority: 0,
+    };
+  }
+
   // Check required field values
   const fieldsResult = checkFields(issue, config);
   if (!fieldsResult.ready) {

package/test/unit/poller.test.js

@@ -902,4 +902,116 @@ describe('poller.js', () => {
       assert.strictEqual(transformed[0].title, 'First');
     });
   });
+
+  describe('computeAttentionLabels', () => {
+    test('labels PR with conflicts only', async () => {
+      const { computeAttentionLabels } = await import('../../service/poller.js');
+      
+      const items = [{
+        number: 123,
+        title: 'Test PR',
+        _mergeable: 'CONFLICTING',
+        _comments: []
+      }];
+      
+      const result = computeAttentionLabels(items, {});
+      
+      assert.strictEqual(result[0]._attention_label, 'Conflicts');
+      assert.strictEqual(result[0]._has_attention, true);
+    });
+
+    test('labels PR with human feedback only', async () => {
+      const { computeAttentionLabels } = await import('../../service/poller.js');
+      
+      const items = [{
+        number: 123,
+        title: 'Test PR',
+        user: { login: 'author' },
+        _mergeable: 'MERGEABLE',
+        _comments: [
+          { user: { login: 'reviewer', type: 'User' }, body: 'Please fix' }
+        ]
+      }];
+      
+      const result = computeAttentionLabels(items, {});
+      
+      assert.strictEqual(result[0]._attention_label, 'Feedback');
+      assert.strictEqual(result[0]._has_attention, true);
+    });
+
+    test('labels PR with both conflicts and feedback', async () => {
+      const { computeAttentionLabels } = await import('../../service/poller.js');
+      
+      const items = [{
+        number: 123,
+        title: 'Test PR',
+        user: { login: 'author' },
+        _mergeable: 'CONFLICTING',
+        _comments: [
+          { user: { login: 'reviewer', type: 'User' }, body: 'Please fix' }
+        ]
+      }];
+      
+      const result = computeAttentionLabels(items, {});
+      
+      assert.strictEqual(result[0]._attention_label, 'Conflicts+Feedback');
+      assert.strictEqual(result[0]._has_attention, true);
+    });
+
+    test('labels PR with no attention conditions', 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]._attention_label, 'PR');
+      assert.strictEqual(result[0]._has_attention, false);
+    });
+
+    test('ignores bot comments when computing feedback', async () => {
+      const { computeAttentionLabels } = await import('../../service/poller.js');
+      
+      const items = [{
+        number: 123,
+        title: 'Test PR',
+        user: { login: 'author' },
+        _mergeable: 'MERGEABLE',
+        _comments: [
+          { user: { login: 'github-actions[bot]', type: 'Bot' }, body: 'CI passed' },
+          { user: { login: 'codecov[bot]', type: 'Bot' }, body: 'Coverage report' }
+        ]
+      }];
+      
+      const result = computeAttentionLabels(items, {});
+      
+      assert.strictEqual(result[0]._attention_label, 'PR');
+      assert.strictEqual(result[0]._has_attention, false);
+    });
+
+    test('ignores author comments when computing feedback', async () => {
+      const { computeAttentionLabels } = await import('../../service/poller.js');
+      
+      const items = [{
+        number: 123,
+        title: 'Test PR',
+        user: { login: 'author' },
+        _mergeable: 'MERGEABLE',
+        _comments: [
+          { user: { login: 'author', type: 'User' }, body: 'Added screenshots' }
+        ]
+      }];
+      
+      const result = computeAttentionLabels(items, {});
+      
+      assert.strictEqual(result[0]._attention_label, 'PR');
+      assert.strictEqual(result[0]._has_attention, false);
+    });
+  });
 });

package/test/unit/readiness.test.js

@@ -387,4 +387,293 @@ describe('readiness.js', () => {
       assert.strictEqual(result.ready, true);
     });
   });
+
+  describe('checkMergeable', () => {
+    test('returns ready when no _mergeable field (skip check)', async () => {
+      const { checkMergeable } = await import('../../service/readiness.js');
+      
+      const pr = {
+        number: 123,
+        title: 'Test PR'
+      };
+      const config = {};
+      
+      const result = checkMergeable(pr, config);
+      
+      assert.strictEqual(result.ready, true);
+    });
+
+    test('returns ready when PR has conflicts and require_conflicts is true', async () => {
+      const { checkMergeable } = await import('../../service/readiness.js');
+      
+      const pr = {
+        number: 123,
+        title: 'Test PR',
+        _mergeable: 'CONFLICTING'
+      };
+      const config = {
+        readiness: {
+          require_conflicts: true
+        }
+      };
+      
+      const result = checkMergeable(pr, config);
+      
+      assert.strictEqual(result.ready, true);
+    });
+
+    test('returns not ready when PR is mergeable and require_conflicts is true', async () => {
+      const { checkMergeable } = await import('../../service/readiness.js');
+      
+      const pr = {
+        number: 123,
+        title: 'Test PR',
+        _mergeable: 'MERGEABLE'
+      };
+      const config = {
+        readiness: {
+          require_conflicts: true
+        }
+      };
+      
+      const result = checkMergeable(pr, config);
+      
+      assert.strictEqual(result.ready, false);
+      assert.ok(result.reason.includes('MERGEABLE'));
+    });
+
+    test('returns not ready when PR status is UNKNOWN and require_conflicts is true', async () => {
+      const { checkMergeable } = await import('../../service/readiness.js');
+      
+      const pr = {
+        number: 123,
+        title: 'Test PR',
+        _mergeable: 'UNKNOWN'
+      };
+      const config = {
+        readiness: {
+          require_conflicts: true
+        }
+      };
+      
+      const result = checkMergeable(pr, config);
+      
+      assert.strictEqual(result.ready, false);
+      assert.ok(result.reason.includes('UNKNOWN'));
+    });
+
+    test('returns ready for any mergeable status when require_conflicts is not set', async () => {
+      const { checkMergeable } = await import('../../service/readiness.js');
+      
+      const pr = {
+        number: 123,
+        title: 'Test PR',
+        _mergeable: 'CONFLICTING'
+      };
+      const config = {};
+      
+      const result = checkMergeable(pr, config);
+      
+      assert.strictEqual(result.ready, true);
+    });
+  });
+
+  describe('evaluateReadiness with mergeable', () => {
+    test('checks mergeable when _mergeable is present with require_conflicts', async () => {
+      const { evaluateReadiness } = await import('../../service/readiness.js');
+      
+      const pr = {
+        number: 123,
+        title: 'Test PR',
+        _mergeable: 'MERGEABLE'
+      };
+      const config = {
+        readiness: {
+          require_conflicts: true
+        }
+      };
+      
+      const result = evaluateReadiness(pr, config);
+      
+      assert.strictEqual(result.ready, false);
+      assert.ok(result.reason.includes('MERGEABLE'));
+    });
+
+    test('passes when PR has conflicts and require_conflicts is configured', async () => {
+      const { evaluateReadiness } = await import('../../service/readiness.js');
+      
+      const pr = {
+        number: 123,
+        title: 'Test PR',
+        _mergeable: 'CONFLICTING'
+      };
+      const config = {
+        readiness: {
+          require_conflicts: true
+        }
+      };
+      
+      const result = evaluateReadiness(pr, config);
+      
+      assert.strictEqual(result.ready, true);
+    });
+  });
+
+  describe('checkAttention', () => {
+    test('returns ready when require_attention is not configured', async () => {
+      const { checkAttention } = await import('../../service/readiness.js');
+      
+      const pr = {
+        number: 123,
+        title: 'Test PR',
+        _has_attention: false
+      };
+      const config = {};
+      
+      const result = checkAttention(pr, config);
+      
+      assert.strictEqual(result.ready, true);
+    });
+
+    test('returns ready when _has_attention is not computed', async () => {
+      const { checkAttention } = await import('../../service/readiness.js');
+      
+      const pr = {
+        number: 123,
+        title: 'Test PR'
+      };
+      const config = {
+        readiness: {
+          require_attention: true
+        }
+      };
+      
+      const result = checkAttention(pr, config);
+      
+      assert.strictEqual(result.ready, true);
+    });
+
+    test('returns ready when PR has attention (conflicts)', async () => {
+      const { checkAttention } = await import('../../service/readiness.js');
+      
+      const pr = {
+        number: 123,
+        title: 'Test PR',
+        _has_attention: true,
+        _attention_label: 'Conflicts'
+      };
+      const config = {
+        readiness: {
+          require_attention: true
+        }
+      };
+      
+      const result = checkAttention(pr, config);
+      
+      assert.strictEqual(result.ready, true);
+    });
+
+    test('returns ready when PR has attention (feedback)', async () => {
+      const { checkAttention } = await import('../../service/readiness.js');
+      
+      const pr = {
+        number: 123,
+        title: 'Test PR',
+        _has_attention: true,
+        _attention_label: 'Feedback'
+      };
+      const config = {
+        readiness: {
+          require_attention: true
+        }
+      };
+      
+      const result = checkAttention(pr, config);
+      
+      assert.strictEqual(result.ready, true);
+    });
+
+    test('returns ready when PR has both conditions', async () => {
+      const { checkAttention } = await import('../../service/readiness.js');
+      
+      const pr = {
+        number: 123,
+        title: 'Test PR',
+        _has_attention: true,
+        _attention_label: 'Conflicts+Feedback'
+      };
+      const config = {
+        readiness: {
+          require_attention: true
+        }
+      };
+      
+      const result = checkAttention(pr, config);
+      
+      assert.strictEqual(result.ready, true);
+    });
+
+    test('returns not ready when PR has no attention conditions', async () => {
+      const { checkAttention } = await import('../../service/readiness.js');
+      
+      const pr = {
+        number: 123,
+        title: 'Test PR',
+        _has_attention: false,
+        _attention_label: 'PR'
+      };
+      const config = {
+        readiness: {
+          require_attention: true
+        }
+      };
+      
+      const result = checkAttention(pr, config);
+      
+      assert.strictEqual(result.ready, false);
+      assert.ok(result.reason.includes('no conflicts'));
+    });
+  });
+
+  describe('evaluateReadiness with attention', () => {
+    test('checks attention when require_attention is configured', async () => {
+      const { evaluateReadiness } = await import('../../service/readiness.js');
+      
+      const pr = {
+        number: 123,
+        title: 'Test PR',
+        _has_attention: false
+      };
+      const config = {
+        readiness: {
+          require_attention: true
+        }
+      };
+      
+      const result = evaluateReadiness(pr, config);
+      
+      assert.strictEqual(result.ready, false);
+      assert.ok(result.reason.includes('no attention needed'));
+    });
+
+    test('passes when PR has attention', async () => {
+      const { evaluateReadiness } = await import('../../service/readiness.js');
+      
+      const pr = {
+        number: 123,
+        title: 'Test PR',
+        _has_attention: true,
+        _attention_label: 'Conflicts'
+      };
+      const config = {
+        readiness: {
+          require_attention: true
+        }
+      };
+      
+      const result = evaluateReadiness(pr, config);
+      
+      assert.strictEqual(result.ready, true);
+    });
+  });
 });

package/test/unit/repo-config.test.js

@@ -697,6 +697,28 @@ sources:
       assert.deepStrictEqual(sources[0].reprocess_on, ['state', 'updatedAt']);
     });
 
+    test('expands github/my-prs-attention preset', async () => {
+      writeFileSync(configPath, `
+sources:
+  - preset: github/my-prs-attention
+`);
+
+      const { loadRepoConfig, getSources } = await import('../../service/repo-config.js');
+      loadRepoConfig(configPath);
+      const sources = getSources();
+
+      assert.strictEqual(sources[0].name, 'my-prs-attention');
+      // GitHub presets now use gh CLI instead of MCP
+      assert.ok(sources[0].tool.command.includes('--author=@me'), 'command should include author filter');
+      // This preset enables both mergeable and comments enrichment
+      assert.strictEqual(sources[0].enrich_mergeable, true);
+      assert.strictEqual(sources[0].filter_bot_comments, true);
+      // This preset requires attention (conflicts OR human feedback)
+      assert.strictEqual(sources[0].readiness.require_attention, true);
+      // Session name uses dynamic attention label
+      assert.ok(sources[0].session.name.includes('_attention_label'), 'session name should use dynamic label');
+    });
+
     test('expands linear/my-issues preset with required args', async () => {
       writeFileSync(configPath, `
 sources:
@@ -753,6 +775,7 @@ sources:
   - preset: github/my-issues
   - preset: github/review-requests
   - preset: github/my-prs-feedback
+  - preset: github/my-prs-attention
 `);
 
       const { loadRepoConfig, getSources, resolveRepoForItem } = await import('../../service/repo-config.js');
@@ -838,6 +861,7 @@ sources:
   - preset: github/my-issues
   - preset: github/review-requests
   - preset: github/my-prs-feedback
+  - preset: github/my-prs-attention
 `);
 
       const { loadRepoConfig, getSources } = await import('../../service/repo-config.js');
@@ -852,6 +876,9 @@ sources:
       
       // my-prs-feedback: "Feedback: {title}"
       assert.strictEqual(sources[2].session.name, 'Feedback: {title}', 'my-prs-feedback should prefix with Feedback:');
+      
+      // my-prs-attention: "{_attention_label}: {title}" (dynamic based on detected conditions)
+      assert.ok(sources[3].session.name.includes('_attention_label'), 'my-prs-attention should use dynamic label');
     });
 
     test('linear preset includes session name', async () => {