opencode-pilot 0.23.0 → 0.24.1

package/.devcontainer/devcontainer.json

@@ -5,7 +5,7 @@
     "ghcr.io/devcontainers/features/git:1": {},
     "ghcr.io/devcontainers/features/github-cli:1": {}
   },
-  "postCreateCommand": "sudo apt-get update && sudo apt-get install -y bats ripgrep && npm install -g opencode-ai@latest",
+  "postCreateCommand": "sudo apt-get update && sudo apt-get install -y ripgrep && npm install -g opencode-ai@latest",
   "customizations": {
     "vscode": {
       "extensions": [

package/.github/workflows/ci.yml

@@ -29,7 +29,7 @@ jobs:
 
       - name: Verify JavaScript syntax
         run: |
-          for file in plugin/*.js; do
+          for file in plugin/*.js service/*.js; do
             echo "Checking $file..."
             node --check "$file"
           done

package/CONTRIBUTING.md

@@ -1,4 +1,4 @@
-# Contributing to opencode-ntfy
+# Contributing to opencode-pilot
 
 Thanks for your interest in contributing!
 
@@ -6,84 +6,75 @@ Thanks for your interest in contributing!
 
 1. Clone the repository:
    ```bash
-   git clone https://github.com/athal7/opencode-ntfy.git
-   cd opencode-ntfy
+   git clone https://github.com/athal7/opencode-pilot.git
+   cd opencode-pilot
    ```
 
-2. Install the plugin locally for testing:
+2. Install dependencies:
    ```bash
-   ./install.sh
-   ```
-
-3. Set required environment variables:
-   ```bash
-   export NTFY_TOPIC=your-test-topic
+   npm install
    ```
 
 ## Running Tests
 
-Run the full test suite:
 ```bash
-./test/run_tests.bash
+npm test                # Unit tests
+npm run test:integration # Integration tests
+npm run test:all        # All tests
 ```
 
-The test suite includes:
-- **File structure tests** - Verify all plugin files exist
-- **Syntax validation** - Run `node --check` on all JS files
-- **Export structure tests** - Verify expected functions are exported
-- **Integration tests** - Test plugin loads in OpenCode without hanging (requires opencode CLI)
+Tests use the Node.js built-in test runner (`node:test`) with `node:assert`.
 
 ## Writing Tests
 
-Tests live in `test/` using bash test helpers from `test_helper.bash`.
+Tests live in `test/unit/` and `test/integration/`. Each test file follows this pattern:
 
-Example test:
-```bash
-test_my_feature() {
-  # Use assertions from test_helper.bash
-  assert_file_exists "$PLUGIN_DIR/myfile.js"
-  assert_contains "$output" "expected string"
-}
-
-# Register and run
-run_test "my_feature" "test_my_feature"
-```
+```js
+import { test, describe } from 'node:test';
+import assert from 'node:assert';
 
-For JavaScript unit tests, use Node.js inline:
-```bash
-test_function_works() {
-  node --input-type=module -e "
-    import { myFunction } from '../plugin/module.js';
-    if (myFunction() !== 'expected') throw new Error('Failed');
-    console.log('PASS');
-  " || return 1
-}
+describe('myModule', () => {
+  test('does the thing', () => {
+    assert.strictEqual(actual, expected);
+  });
+});
 ```
 
 ## Code Style
 
 - Use ES modules (`import`/`export`)
 - Use `async`/`await` for async operations
-- Log with `[opencode-ntfy]` prefix
+- Log with `[opencode-pilot]` prefix
 - Handle errors gracefully (log, don't crash OpenCode)
-- No external dependencies (use Node.js built-ins only)
+- No external dependencies beyond what's in `package.json`
 
-## Plugin Architecture
+## Project Architecture
 
 ```
 plugin/
-├── index.js      # Main entry point, event handlers
-├── notifier.js   # ntfy HTTP client
-├── callback.js   # HTTP callback server for interactive responses
-├── hostname.js   # Callback host discovery (Tailscale, env, localhost)
-└── nonces.js     # Single-use nonces for callback authentication
+└── index.js              # OpenCode plugin entry point (auto-starts daemon)
+service/
+├── server.js             # HTTP server and polling orchestration
+├── poll-service.js       # Polling lifecycle management
+├── poller.js             # MCP tool polling
+├── actions.js            # Session creation and template expansion
+├── readiness.js          # Evaluate item readiness (labels, deps, priority)
+├── worktree.js           # Git worktree management
+├── repo-config.js        # Repository discovery and config
+├── logger.js             # Debug logging
+├── utils.js              # Shared utilities
+├── version.js            # Package version detection
+└── presets/
+    ├── index.js           # Preset loader
+    ├── github.yaml        # GitHub source presets
+    └── linear.yaml        # Linear source presets
 ```
 
 ## Submitting Changes
 
 1. Create a feature branch: `git checkout -b my-feature`
 2. Make your changes
-3. Run tests: `./test/run_tests.bash`
+3. Run tests: `npm test`
 4. Commit with a clear message following conventional commits:
    - `feat(#1): add idle notifications`
    - `fix(#3): handle network timeout`
@@ -91,12 +82,10 @@ plugin/
 
 ## Releasing
 
-Releases are automated via GitHub Actions. To create a release:
-
-1. Tag the commit: `git tag v1.0.0`
-2. Push the tag: `git push origin v1.0.0`
+Releases are automated via [semantic-release](https://github.com/semantic-release/semantic-release) on merge to `main`. The CI pipeline will:
 
-The release workflow will:
 1. Run tests
-2. Create a tarball
-3. Create a GitHub release with release notes
+2. Determine the next version from commit messages
+3. Publish to npm
+4. Create a GitHub release
+5. Update the Homebrew formula

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.22.0.tar.gz"
-  sha256 "b4437190cab6bff8c03ab93b6d70c8de7ccb3e396decc36b460d53f3ee482dde"
+  url "https://github.com/athal7/opencode-pilot/archive/refs/tags/v0.23.1.tar.gz"
+  sha256 "106172281e27a0847f1c457837c503aa64058908ab4ac5df6fb7326db4c07079"
   license "MIT"
 
   depends_on "node"

package/README.md

@@ -140,6 +140,18 @@ sources:
 - `worktree_name` - Template for naming new worktrees (only with `worktree: "new"`)
 - `prefer_existing_sandbox: false` - Disable sandbox reuse for this source
 
+### Stacked PR Support
+
+When `detect_stacks: true` is set on a source, pilot detects stacked PRs (where one PR's head branch is another PR's base branch) and reuses the existing session from a stack sibling. This gives the agent full context about the entire stack without redundant context-gathering.
+
+```yaml
+sources:
+  - preset: github/review-requests
+    detect_stacks: true  # Enabled by default in this preset
+```
+
+The `github/review-requests` and `github/my-prs-attention` presets enable stack detection by default.
+
 ## CLI Commands
 
 ```bash

package/examples/config.yaml

@@ -35,6 +35,8 @@ sources:
   - preset: github/my-issues
     prompt: worktree
 
+  # PR presets have detect_stacks: true by default, enabling session reuse
+  # across stacked PRs (where one PR's head branch = another's base branch)
   - preset: github/review-requests
     # Per-source model override (takes precedence over defaults.model)
     # model: anthropic/claude-haiku-3.5

package/package.json

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

package/service/actions.js

@@ -819,6 +819,37 @@ async function executeInDirectory(serverUrl, cwd, item, config, options = {}) {
     ? buildSessionName(config.session.name, item)
     : (item.title || `session-${Date.now()}`);
   
+  // Check if we should reuse a stack sibling's session
+  // This is set when another PR in the same stack was already processed
+  if (config.reuse_stack_session && !options.dryRun) {
+    try {
+      debug(`executeInDirectory: trying stack session reuse ${config.reuse_stack_session} for ${cwd}`);
+      
+      const stackResult = await sendMessageToSession(serverUrl, config.reuse_stack_session, cwd, prompt, {
+        title: sessionTitle,
+        agent: config.agent,
+        model: config.model,
+        fetch: options.fetch,
+      });
+      
+      if (stackResult.success) {
+        const stackCommand = `[API] POST ${serverUrl}/session/${config.reuse_stack_session}/message (stack reuse)`;
+        return {
+          command: stackCommand,
+          success: true,
+          sessionId: stackResult.sessionId,
+          directory: cwd,
+          sessionReused: true,
+          error: stackResult.error,
+        };
+      }
+      
+      debug(`executeInDirectory: stack session reuse failed, falling through`);
+    } catch (err) {
+      debug(`executeInDirectory: stack session reuse error, falling through: ${err.message}`);
+    }
+  }
+  
   // Check if we should try to reuse an existing session
   const reuseActiveSession = config.reuse_active_session !== false; // default true
   

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, enrichItemsWithMergeable, computeAttentionLabels, computeDedupKeys } from "./poller.js";
+import { createPoller, pollGenericSource, enrichItemsWithComments, enrichItemsWithMergeable, enrichItemsWithBranchRefs, computeAttentionLabels, computeDedupKeys, detectStacks } from "./poller.js";
 import { evaluateReadiness, sortByPriority } from "./readiness.js";
 import { executeAction, buildCommand } from "./actions.js";
 import { debug } from "./logger.js";
@@ -146,6 +146,12 @@ export async function pollOnce(options = {}) {
           debug(`Enriched ${items.length} items with mergeable status`);
         }
         
+        // Enrich items with branch refs for stack detection if configured
+        if (source.detect_stacks) {
+          items = await enrichItemsWithBranchRefs(items, source);
+          debug(`Enriched ${items.length} items with branch refs for stack detection`);
+        }
+        
         // Compute attention labels if both enrichments are present (for my-prs-attention)
         if (source.enrich_mergeable && source.filter_bot_comments) {
           items = computeAttentionLabels(items, source);
@@ -193,6 +199,12 @@ export async function pollOnce(options = {}) {
     const sortConfig = readyItems.length > 0 ? readyItems[0]._repoConfig : {};
     const sortedItems = sortByPriority(readyItems, sortConfig);
 
+    // Detect PR stacks for session reuse (only when detect_stacks is enabled)
+    const stackMap = source.detect_stacks ? detectStacks(sortedItems) : new Map();
+    if (stackMap.size > 0) {
+      debug(`Detected ${stackMap.size} items in PR stacks`);
+    }
+
     // Process ready items
     // Get reprocess_on config: source-level overrides provider-level
     const reprocessOn = source.reprocess_on || toolProviderConfig?.reprocess_on;
@@ -241,6 +253,21 @@ export async function pollOnce(options = {}) {
         debug(`Reusing existing directory: ${existingDirectory}`);
       }
 
+      // Check if a stack sibling was already processed (for session reuse across stacked PRs)
+      if (stackMap.has(item.id) && pollerInstance) {
+        const siblings = stackMap.get(item.id);
+        for (const siblingId of siblings) {
+          const siblingMeta = pollerInstance.getProcessedMeta(siblingId);
+          if (siblingMeta?.sessionId && siblingMeta?.directory) {
+            actionConfig.existing_directory = siblingMeta.directory;
+            actionConfig.reuse_stack_session = siblingMeta.sessionId;
+            debug(`Stack reuse: ${item.id} reusing session ${siblingMeta.sessionId} from sibling ${siblingId}`);
+            console.log(`[poll] Stack reuse: ${item.id} reusing session from stack sibling ${siblingId}`);
+            break;
+          }
+        }
+      }
+
       // Skip items with no valid local path (prevents sessions in home directory)
       const hasLocalPath = actionConfig.working_dir || actionConfig.path || actionConfig.repo_path;
       if (!hasLocalPath) {
@@ -277,8 +304,12 @@ export async function pollOnce(options = {}) {
                 command: result.command,
                 source: sourceName,
                 directory: result.directory || null,
+                sessionId: result.sessionId || null,
                 itemState: item.state || item.status || null,
                 itemUpdatedAt: item.updated_at || null,
+                // 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,
                 dedupKeys: dedupKeys.length > 0 ? dedupKeys : undefined,
               });
             }

package/service/poller.js

@@ -635,6 +635,167 @@ export async function enrichItemsWithMergeable(items, source, options = {}) {
   return enrichedItems;
 }
 
+/**
+ * Fetch branch ref names 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<object|null>} { headRefName, baseRefName } or null on error
+ */
+async function fetchBranchRefs(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 headRefName,baseRefName`),
+      createTimeout(timeout, "gh pr view branch refs"),
+    ]);
+    
+    const data = JSON.parse(stdout.trim());
+    return data && data.headRefName && data.baseRefName ? data : null;
+  } catch (err) {
+    console.error(`[poller] Error fetching branch refs for ${owner}/${repo}#${number}: ${err.message}`);
+    return null;
+  }
+}
+
+/**
+ * Enrich items with branch ref names for stack detection
+ * 
+ * For items from sources with detect_stacks: true, fetches headRefName and
+ * baseRefName via gh CLI and attaches them as _headRefName and _baseRefName
+ * fields for stack detection.
+ * 
+ * @param {Array} items - Items to enrich
+ * @param {object} source - Source configuration with optional detect_stacks
+ * @param {object} [options] - Options
+ * @param {number} [options.timeout] - Timeout in ms (default: 30000)
+ * @returns {Promise<Array>} Items with _headRefName and _baseRefName fields added
+ */
+export async function enrichItemsWithBranchRefs(items, source, options = {}) {
+  // Skip if not configured or not a GitHub source
+  if (!source.detect_stacks || !isGitHubSource(source)) {
+    return items;
+  }
+  
+  const timeout = options.timeout || DEFAULT_MCP_TIMEOUT;
+  
+  // Fetch branch refs 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 refs = await fetchBranchRefs(owner, repo, item.number, timeout);
+    if (refs) {
+      enrichedItems.push({ ...item, _headRefName: refs.headRefName, _baseRefName: refs.baseRefName });
+    } else {
+      enrichedItems.push(item);
+    }
+  }
+  
+  return enrichedItems;
+}
+
+/**
+ * Detect PR stacks from enriched items
+ * 
+ * Groups items by repo and finds stacks by matching headRefName/baseRefName:
+ * if PR A's headRefName equals PR B's baseRefName, they're in the same stack.
+ * Walks chains to handle 3+ PR stacks.
+ * 
+ * @param {Array} items - Items enriched with _headRefName and _baseRefName
+ * @returns {Map<string, string[]>} Map of itemId -> sibling itemIds (only stacked items included)
+ */
+export function detectStacks(items) {
+  const stacks = new Map();
+  
+  if (!items || items.length === 0) return stacks;
+  
+  // Group items by repo (stacks only make sense within same repo)
+  const byRepo = new Map();
+  for (const item of items) {
+    if (!item._headRefName || !item._baseRefName) continue;
+    
+    const repo = item.repository_full_name || item.repository?.nameWithOwner;
+    if (!repo) continue;
+    
+    if (!byRepo.has(repo)) {
+      byRepo.set(repo, []);
+    }
+    byRepo.get(repo).push(item);
+  }
+  
+  // For each repo group, find stacks
+  for (const [, repoItems] of byRepo) {
+    if (repoItems.length < 2) continue;
+    
+    // Build lookup: headRefName -> item
+    const headToItem = new Map();
+    for (const item of repoItems) {
+      headToItem.set(item._headRefName, item);
+    }
+    
+    // Find connected components (stacks) using union-find approach
+    // Two items are connected if one's headRefName equals the other's baseRefName
+    const parent = new Map(); // itemId -> root itemId
+    
+    function find(id) {
+      if (!parent.has(id)) parent.set(id, id);
+      if (parent.get(id) !== id) {
+        parent.set(id, find(parent.get(id)));
+      }
+      return parent.get(id);
+    }
+    
+    function union(a, b) {
+      const rootA = find(a);
+      const rootB = find(b);
+      if (rootA !== rootB) {
+        parent.set(rootA, rootB);
+      }
+    }
+    
+    // Connect items that form a stack
+    for (const item of repoItems) {
+      const baseMatch = headToItem.get(item._baseRefName);
+      if (baseMatch && baseMatch.id !== item.id) {
+        union(item.id, baseMatch.id);
+      }
+    }
+    
+    // Group items by their root to find stack members
+    const groups = new Map(); // root -> [itemIds]
+    for (const item of repoItems) {
+      if (!parent.has(item.id)) continue;
+      const root = find(item.id);
+      if (!groups.has(root)) {
+        groups.set(root, []);
+      }
+      groups.get(root).push(item.id);
+    }
+    
+    // Build sibling map for groups with 2+ members
+    for (const [, members] of groups) {
+      if (members.length < 2) continue;
+      for (const id of members) {
+        stacks.set(id, members.filter(m => m !== id));
+      }
+    }
+  }
+  
+  return stacks;
+}
+
 /**
  * Compute attention label from enriched item conditions
  * 
@@ -1090,6 +1251,18 @@ export function createPoller(options = {}) {
             }
           }
         }
+        
+        // Handle attention field (detect new feedback on PRs)
+        // Only reprocess when attention changes from false to true
+        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
+          if (storedHasAttention === false && currentHasAttention === true) {
+            return true;
+          }
+        }
       }
       
       return false;

package/service/presets/github.yaml

@@ -39,6 +39,8 @@ review-requests:
   worktree_name: "pr-{number}"
   session:
     name: "Review: {title}"
+  # Detect stacked PRs and reuse sessions across the stack
+  detect_stacks: true
 
 my-prs-attention:
   name: my-prs-attention
@@ -56,10 +58,13 @@ my-prs-attention:
   # Enrich with both mergeable status and comments to detect all attention conditions
   enrich_mergeable: true
   filter_bot_comments: true
+  # Detect stacked PRs and reuse sessions across the stack
+  detect_stacks: true
   readiness:
     # Require at least one attention condition (conflicts or human feedback)
     require_attention: true
-  # Only reprocess when state changes (e.g., reopened)
+  # Reprocess when state changes (reopened) or new feedback received
   # Note: updatedAt is NOT included - CI status changes would trigger reprocessing
   reprocess_on:
     - state
+    - attention

package/test/integration/session-reuse.test.js

@@ -733,3 +733,177 @@ describe("integration: cross-source deduplication", () => {
     }
   });
 });
+
+describe("integration: stacked PR session reuse", () => {
+  let mockServer;
+
+  afterEach(async () => {
+    if (mockServer) {
+      await mockServer.close();
+      mockServer = null;
+    }
+  });
+
+  it("reuses stack sibling's session when reuse_stack_session is set", async () => {
+    let sessionCreated = false;
+    let messageSessionId = null;
+    let messageTitleUpdated = null;
+
+    mockServer = await createMockServer({
+      "GET /session": () => ({
+        // Return the stack sibling's session
+        body: [{ id: "ses_stack_sibling", directory: "/wt/pr-101", time: { created: 1000, updated: 2000 } }],
+      }),
+      "GET /session/status": () => ({ body: {} }),
+      "POST /session": () => {
+        sessionCreated = true;
+        return { body: { id: "ses_new" } };
+      },
+      "PATCH /session/ses_stack_sibling": (req) => {
+        messageTitleUpdated = req.body?.title;
+        return { body: {} };
+      },
+      "POST /session/ses_stack_sibling/message": (req) => {
+        messageSessionId = "ses_stack_sibling";
+        return { body: { success: true } };
+      },
+      "GET /project/current": () => ({
+        body: { id: "proj_1", worktree: "/proj", time: { created: 1000, updated: 2000 }, sandboxes: [] },
+      }),
+    });
+
+    const result = await executeAction(
+      { number: 102, title: "Part 2 of feature" },
+      {
+        path: "/proj",
+        prompt: "default",
+        // These are set by poll-service when a stack sibling is found
+        existing_directory: "/wt/pr-101",
+        reuse_stack_session: "ses_stack_sibling",
+      },
+      { discoverServer: async () => mockServer.url }
+    );
+
+    assert.ok(result.success, "Action should succeed");
+    assert.strictEqual(result.sessionReused, true, "Should indicate session was reused");
+    assert.strictEqual(sessionCreated, false, "Should NOT create new session");
+    assert.strictEqual(messageSessionId, "ses_stack_sibling", "Should post to stack sibling's session");
+  });
+
+  it("falls back to normal flow when stack session is gone", async () => {
+    let sessionCreated = false;
+    let newSessionMessageId = null;
+
+    mockServer = await createMockServer({
+      "GET /session": () => ({
+        // No sessions exist (sibling's session was archived/gone)
+        body: [],
+      }),
+      "GET /session/status": () => ({ body: {} }),
+      // Stack session reuse will try this and fail
+      "PATCH /session/ses_gone": () => ({
+        status: 404,
+        body: { error: "Session not found" },
+      }),
+      "POST /session/ses_gone/message": () => ({
+        status: 404,
+        body: { error: "Session not found" },
+      }),
+      // Falls through to creating a new session
+      "POST /session": () => {
+        sessionCreated = true;
+        return { body: { id: "ses_new_fallback" } };
+      },
+      "PATCH /session/ses_new_fallback": () => ({ body: {} }),
+      "POST /session/ses_new_fallback/message": (req) => {
+        newSessionMessageId = "ses_new_fallback";
+        return { body: { success: true } };
+      },
+      "GET /project/current": () => ({
+        body: { id: "proj_1", worktree: "/proj", time: { created: 1000, updated: 2000 }, sandboxes: [] },
+      }),
+    });
+
+    const result = await executeAction(
+      { number: 102, title: "Part 2 of feature" },
+      {
+        path: "/proj",
+        prompt: "default",
+        existing_directory: "/wt/pr-101",
+        reuse_stack_session: "ses_gone",
+      },
+      { discoverServer: async () => mockServer.url }
+    );
+
+    assert.ok(result.success, "Action should succeed via fallback");
+    assert.ok(sessionCreated, "Should create new session when stack session is gone");
+  });
+
+  it("detectStacks + poller metadata enables stack reuse across poll cycles", async () => {
+    // This test verifies the full flow:
+    // 1. PR #101 was processed in a previous poll cycle (has sessionId + directory in metadata)
+    // 2. PR #102 is in the same stack (detected via detectStacks)
+    // 3. poll-service should set reuse_stack_session from sibling metadata
+
+    const { createPoller, detectStacks } = await import("../../service/poller.js");
+    const { mkdtempSync, rmSync: rmSyncFs } = await import("fs");
+    const { join } = await import("path");
+    const { tmpdir } = await import("os");
+
+    const tempDir = mkdtempSync(join(tmpdir(), "stack-reuse-test-"));
+    const stateFile = join(tempDir, "poll-state.json");
+
+    try {
+      const poller = createPoller({ stateFile });
+
+      // Simulate: PR #101 was processed in a previous poll cycle
+      poller.markProcessed("https://github.com/myorg/app/pull/101", {
+        source: "review-requests",
+        directory: "/wt/pr-101",
+        sessionId: "ses_pr101",
+      });
+
+      // Current poll returns both PRs with branch refs
+      const items = [
+        {
+          id: "https://github.com/myorg/app/pull/101",
+          number: 101,
+          repository_full_name: "myorg/app",
+          _baseRefName: "main",
+          _headRefName: "feature-part-1",
+        },
+        {
+          id: "https://github.com/myorg/app/pull/102",
+          number: 102,
+          repository_full_name: "myorg/app",
+          _baseRefName: "feature-part-1",
+          _headRefName: "feature-part-2",
+        },
+      ];
+
+      // Detect stacks
+      const stackMap = detectStacks(items);
+
+      assert.ok(stackMap.has(items[1].id), "PR #102 should be in a stack");
+
+      // Simulate what poll-service does: look up sibling metadata
+      const siblings = stackMap.get(items[1].id);
+      let foundSessionId = null;
+      let foundDirectory = null;
+
+      for (const siblingId of siblings) {
+        const meta = poller.getProcessedMeta(siblingId);
+        if (meta?.sessionId && meta?.directory) {
+          foundSessionId = meta.sessionId;
+          foundDirectory = meta.directory;
+          break;
+        }
+      }
+
+      assert.strictEqual(foundSessionId, "ses_pr101", "Should find PR #101's session ID");
+      assert.strictEqual(foundDirectory, "/wt/pr-101", "Should find PR #101's directory");
+    } finally {
+      rmSyncFs(tempDir, { recursive: true, force: true });
+    }
+  });
+});

package/test/unit/poller.test.js

@@ -792,6 +792,126 @@ describe('poller.js', () => {
       // Poll 3: item-2 reappears - wasUnseen flag should still be true until cleared
       // (The flag gets cleared when shouldReprocess triggers reprocessing)
     });
+
+    test('shouldReprocess returns true when attention changes from false to true', async () => {
+      const { createPoller } = await import('../../service/poller.js');
+      
+      const poller = createPoller({ stateFile });
+      // Item was processed without attention (no feedback)
+      poller.markProcessed('pr-1', { 
+        source: 'my-prs-attention', 
+        itemState: 'open',
+        hasAttention: false
+      });
+      
+      // Item now has attention (received feedback)
+      const item = { id: 'pr-1', state: 'open', _has_attention: true };
+      assert.strictEqual(
+        poller.shouldReprocess(item, { reprocessOn: ['attention'] }), 
+        true,
+        'Should reprocess when attention changes false -> true'
+      );
+    });
+
+    test('shouldReprocess returns false when attention stays true', async () => {
+      const { createPoller } = await import('../../service/poller.js');
+      
+      const poller = createPoller({ stateFile });
+      // Item was processed with attention
+      poller.markProcessed('pr-1', { 
+        source: 'my-prs-attention', 
+        itemState: 'open',
+        hasAttention: true
+      });
+      
+      // Item still has attention
+      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'
+      );
+    });
+
+    test('shouldReprocess returns false when attention stays false', async () => {
+      const { createPoller } = await import('../../service/poller.js');
+      
+      const poller = createPoller({ stateFile });
+      // Item was processed without attention
+      poller.markProcessed('pr-1', { 
+        source: 'my-prs-attention', 
+        itemState: 'open',
+        hasAttention: false
+      });
+      
+      // Item still has no attention
+      const item = { id: 'pr-1', state: 'open', _has_attention: false };
+      assert.strictEqual(
+        poller.shouldReprocess(item, { reprocessOn: ['attention'] }), 
+        false,
+        'Should NOT reprocess when attention stays false'
+      );
+    });
+
+    test('shouldReprocess returns false when attention changes from true to false', async () => {
+      const { createPoller } = await import('../../service/poller.js');
+      
+      const poller = createPoller({ stateFile });
+      // Item was processed with attention
+      poller.markProcessed('pr-1', { 
+        source: 'my-prs-attention', 
+        itemState: 'open',
+        hasAttention: true
+      });
+      
+      // Attention was addressed (no longer needs attention)
+      const item = { id: 'pr-1', state: 'open', _has_attention: false };
+      assert.strictEqual(
+        poller.shouldReprocess(item, { reprocessOn: ['attention'] }), 
+        false,
+        'Should NOT reprocess when attention changes true -> false'
+      );
+    });
+
+    test('shouldReprocess handles attention with no stored hasAttention (legacy)', async () => {
+      const { createPoller } = await import('../../service/poller.js');
+      
+      const poller = createPoller({ stateFile });
+      // Legacy item without hasAttention stored
+      poller.markProcessed('pr-1', { 
+        source: 'my-prs-attention', 
+        itemState: 'open'
+        // Note: no hasAttention
+      });
+      
+      // Item now has attention
+      const item = { id: 'pr-1', state: 'open', _has_attention: true };
+      // Should NOT reprocess - we don't know previous state, assume it was handled
+      assert.strictEqual(
+        poller.shouldReprocess(item, { reprocessOn: ['attention'] }), 
+        false,
+        'Should NOT reprocess legacy items without stored hasAttention'
+      );
+    });
+
+    test('shouldReprocess handles attention combined with state changes', async () => {
+      const { createPoller } = await import('../../service/poller.js');
+      
+      const poller = createPoller({ stateFile });
+      poller.markProcessed('pr-1', { 
+        source: 'my-prs-attention', 
+        itemState: 'closed',  // Was closed
+        hasAttention: false
+      });
+      
+      // Reopened but no attention - state change should trigger
+      const item = { id: 'pr-1', state: 'open', _has_attention: false };
+      assert.strictEqual(
+        poller.shouldReprocess(item, { reprocessOn: ['state', 'attention'] }), 
+        true,
+        'Should reprocess when state changes even if attention unchanged'
+      );
+    });
   });
 
   describe('pollGenericSource', () => {
@@ -1438,4 +1558,261 @@ describe('poller.js', () => {
       assert.deepStrictEqual(result, []);
     });
   });
+
+  describe('detectStacks', () => {
+    test('detects a simple 2-PR stack', async () => {
+      const { detectStacks } = await import('../../service/poller.js');
+
+      const items = [
+        {
+          id: 'https://github.com/myorg/app/pull/101',
+          number: 101,
+          repository_full_name: 'myorg/app',
+          _baseRefName: 'main',
+          _headRefName: 'feature-part-1',
+        },
+        {
+          id: 'https://github.com/myorg/app/pull/102',
+          number: 102,
+          repository_full_name: 'myorg/app',
+          _baseRefName: 'feature-part-1',
+          _headRefName: 'feature-part-2',
+        },
+      ];
+
+      const stacks = detectStacks(items);
+
+      // Both PRs should be in the map as siblings of each other
+      assert.ok(stacks.has(items[0].id), 'PR #101 should be in stacks map');
+      assert.ok(stacks.has(items[1].id), 'PR #102 should be in stacks map');
+      assert.deepStrictEqual(stacks.get(items[0].id), [items[1].id]);
+      assert.deepStrictEqual(stacks.get(items[1].id), [items[0].id]);
+    });
+
+    test('detects a 3-PR chain', async () => {
+      const { detectStacks } = await import('../../service/poller.js');
+
+      const items = [
+        {
+          id: 'https://github.com/myorg/app/pull/101',
+          number: 101,
+          repository_full_name: 'myorg/app',
+          _baseRefName: 'main',
+          _headRefName: 'feature-part-1',
+        },
+        {
+          id: 'https://github.com/myorg/app/pull/102',
+          number: 102,
+          repository_full_name: 'myorg/app',
+          _baseRefName: 'feature-part-1',
+          _headRefName: 'feature-part-2',
+        },
+        {
+          id: 'https://github.com/myorg/app/pull/103',
+          number: 103,
+          repository_full_name: 'myorg/app',
+          _baseRefName: 'feature-part-2',
+          _headRefName: 'feature-part-3',
+        },
+      ];
+
+      const stacks = detectStacks(items);
+
+      // All three should be siblings of each other
+      assert.ok(stacks.has(items[0].id));
+      assert.ok(stacks.has(items[1].id));
+      assert.ok(stacks.has(items[2].id));
+
+      // PR #101 should have #102 and #103 as siblings
+      const siblings101 = stacks.get(items[0].id);
+      assert.ok(siblings101.includes(items[1].id));
+      assert.ok(siblings101.includes(items[2].id));
+      assert.strictEqual(siblings101.length, 2);
+
+      // PR #102 should have #101 and #103 as siblings
+      const siblings102 = stacks.get(items[1].id);
+      assert.ok(siblings102.includes(items[0].id));
+      assert.ok(siblings102.includes(items[2].id));
+      assert.strictEqual(siblings102.length, 2);
+    });
+
+    test('returns empty map when no stacks exist', async () => {
+      const { detectStacks } = await import('../../service/poller.js');
+
+      const items = [
+        {
+          id: 'https://github.com/myorg/app/pull/101',
+          number: 101,
+          repository_full_name: 'myorg/app',
+          _baseRefName: 'main',
+          _headRefName: 'feature-a',
+        },
+        {
+          id: 'https://github.com/myorg/app/pull/102',
+          number: 102,
+          repository_full_name: 'myorg/app',
+          _baseRefName: 'main',
+          _headRefName: 'feature-b',
+        },
+      ];
+
+      const stacks = detectStacks(items);
+
+      assert.strictEqual(stacks.size, 0, 'No stacks should be detected when all PRs are based on main');
+    });
+
+    test('handles PRs from different repos independently', async () => {
+      const { detectStacks } = await import('../../service/poller.js');
+
+      const items = [
+        {
+          id: 'https://github.com/myorg/app-a/pull/1',
+          number: 1,
+          repository_full_name: 'myorg/app-a',
+          _baseRefName: 'main',
+          _headRefName: 'feature-x',
+        },
+        {
+          id: 'https://github.com/myorg/app-b/pull/2',
+          number: 2,
+          repository_full_name: 'myorg/app-b',
+          _baseRefName: 'feature-x',
+          _headRefName: 'feature-y',
+        },
+      ];
+
+      const stacks = detectStacks(items);
+
+      // Even though app-b PR #2's base matches app-a PR #1's head,
+      // they're in different repos so should NOT be stacked
+      assert.strictEqual(stacks.size, 0, 'Should not match branches across different repos');
+    });
+
+    test('handles items missing branch refs gracefully', async () => {
+      const { detectStacks } = await import('../../service/poller.js');
+
+      const items = [
+        {
+          id: 'https://github.com/myorg/app/pull/101',
+          number: 101,
+          repository_full_name: 'myorg/app',
+          _baseRefName: 'main',
+          _headRefName: 'feature-part-1',
+        },
+        {
+          id: 'https://github.com/myorg/app/pull/102',
+          number: 102,
+          repository_full_name: 'myorg/app',
+          // Missing _baseRefName and _headRefName (enrichment failed)
+        },
+      ];
+
+      const stacks = detectStacks(items);
+
+      assert.strictEqual(stacks.size, 0, 'Should not crash on items without branch refs');
+    });
+
+    test('handles single item gracefully', async () => {
+      const { detectStacks } = await import('../../service/poller.js');
+
+      const items = [
+        {
+          id: 'https://github.com/myorg/app/pull/101',
+          number: 101,
+          repository_full_name: 'myorg/app',
+          _baseRefName: 'main',
+          _headRefName: 'feature-1',
+        },
+      ];
+
+      const stacks = detectStacks(items);
+
+      assert.strictEqual(stacks.size, 0, 'Single item cannot form a stack');
+    });
+
+    test('handles empty items array', async () => {
+      const { detectStacks } = await import('../../service/poller.js');
+
+      const stacks = detectStacks([]);
+
+      assert.strictEqual(stacks.size, 0);
+    });
+
+    test('uses repository.nameWithOwner as fallback for repo grouping', async () => {
+      const { detectStacks } = await import('../../service/poller.js');
+
+      const items = [
+        {
+          id: 'https://github.com/myorg/app/pull/101',
+          number: 101,
+          repository: { nameWithOwner: 'myorg/app' },
+          _baseRefName: 'main',
+          _headRefName: 'feature-part-1',
+        },
+        {
+          id: 'https://github.com/myorg/app/pull/102',
+          number: 102,
+          repository: { nameWithOwner: 'myorg/app' },
+          _baseRefName: 'feature-part-1',
+          _headRefName: 'feature-part-2',
+        },
+      ];
+
+      const stacks = detectStacks(items);
+
+      assert.ok(stacks.has(items[0].id));
+      assert.ok(stacks.has(items[1].id));
+    });
+  });
+
+  describe('enrichItemsWithBranchRefs', () => {
+    test('skips enrichment when detect_stacks is not set', async () => {
+      const { enrichItemsWithBranchRefs } = await import('../../service/poller.js');
+
+      const items = [{ number: 1, repository_full_name: 'org/repo' }];
+      const source = { tool: { command: ['gh', 'search', 'prs'] } }; // no detect_stacks
+
+      const result = await enrichItemsWithBranchRefs(items, source);
+
+      assert.strictEqual(result.length, 1);
+      assert.strictEqual(result[0]._headRefName, undefined);
+      assert.strictEqual(result[0]._baseRefName, undefined);
+    });
+
+    test('skips enrichment for non-GitHub sources', async () => {
+      const { enrichItemsWithBranchRefs } = await import('../../service/poller.js');
+
+      const items = [{ number: 1, repository_full_name: 'org/repo' }];
+      const source = {
+        detect_stacks: true,
+        tool: { mcp: 'linear', name: 'list_issues' }
+      };
+
+      const result = await enrichItemsWithBranchRefs(items, source);
+
+      assert.strictEqual(result.length, 1);
+      assert.strictEqual(result[0]._headRefName, undefined);
+      assert.strictEqual(result[0]._baseRefName, undefined);
+    });
+
+    test('skips items without repository info', async () => {
+      const { enrichItemsWithBranchRefs } = await import('../../service/poller.js');
+
+      const items = [
+        { number: 1 }, // no repository_full_name
+        { repository_full_name: 'org/repo' } // no number
+      ];
+      const source = {
+        detect_stacks: true,
+        tool: { command: ['gh', 'search', 'prs'] }
+      };
+
+      const result = await enrichItemsWithBranchRefs(items, source);
+
+      // Items returned unchanged (no API calls for invalid items)
+      assert.strictEqual(result.length, 2);
+      assert.strictEqual(result[0]._headRefName, undefined);
+      assert.strictEqual(result[1]._headRefName, undefined);
+    });
+  });
 });