opencode-pilot 0.21.3 → 0.22.0

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.21.2.tar.gz"
-  sha256 "7295684359ee266599b634d903944a10d3597659266303f03c8376944e8e2a36"
+  url "https://github.com/athal7/opencode-pilot/archive/refs/tags/v0.21.4.tar.gz"
+  sha256 "7d21ed495bfb2b737f6a519dc9bfcdb2ef341636b138c6450e1848fd6819c924"
   license "MIT"
 
   depends_on "node"
@@ -18,6 +18,7 @@ class OpencodePilot < Formula
     log_path var/"log/opencode-pilot.log"
     error_log_path var/"log/opencode-pilot.error.log"
     working_dir Dir.home
+    environment_variables PATH: "#{HOMEBREW_PREFIX}/bin:#{HOMEBREW_PREFIX}/sbin:/usr/bin:/bin:/usr/sbin:/sbin"
   end
 
   def caveats

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-pilot",
-  "version": "0.21.3",
+  "version": "0.22.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, enrichItemsWithMergeable, computeAttentionLabels } from "./poller.js";
+import { createPoller, pollGenericSource, enrichItemsWithComments, enrichItemsWithMergeable, computeAttentionLabels, computeDedupKeys } from "./poller.js";
 import { evaluateReadiness, sortByPriority } from "./readiness.js";
 import { executeAction, buildCommand } from "./actions.js";
 import { debug } from "./logger.js";
@@ -199,7 +199,12 @@ export async function pollOnce(options = {}) {
     
     debug(`Processing ${sortedItems.length} sorted items`);
     for (const item of sortedItems) {
-      // Check if already processed
+      // Compute dedup keys for cross-source deduplication
+      // Context includes repo for resolving relative GitHub refs (#123)
+      const dedupContext = { repo: item.repository_full_name || item.repository?.nameWithOwner };
+      const dedupKeys = computeDedupKeys(item, dedupContext);
+      
+      // Check if already processed (by item ID)
       let existingDirectory = null;
       if (pollerInstance && pollerInstance.isProcessed(item.id)) {
         // Check if item should be reprocessed (reopened, status changed, etc.)
@@ -215,6 +220,16 @@ export async function pollOnce(options = {}) {
           continue;
         }
       }
+      
+      // Check for cross-source deduplication (e.g., Linear issue + GitHub PR)
+      // Skip if any of this item's dedup keys were already processed by another item
+      if (pollerInstance && dedupKeys.length > 0) {
+        const existingItemId = pollerInstance.findProcessedByDedupKey(dedupKeys);
+        if (existingItemId && existingItemId !== item.id) {
+          debug(`Skipping ${item.id} - dedup key matches already-processed item ${existingItemId}`);
+          continue;
+        }
+      }
 
       debug(`Executing action for ${item.id}`);
       // Build action config from source and item (resolves repo from item fields)
@@ -255,6 +270,7 @@ export async function pollOnce(options = {}) {
             // Mark as processed to avoid re-triggering
             // Store item state for detecting reopened/updated items
             // Store directory for worktree reuse when reprocessing
+            // Store dedup keys for cross-source deduplication
             if (pollerInstance) {
               pollerInstance.markProcessed(item.id, { 
                 repoKey: item.repo_key, 
@@ -263,6 +279,7 @@ export async function pollOnce(options = {}) {
                 directory: result.directory || null,
                 itemState: item.state || item.status || null,
                 itemUpdatedAt: item.updated_at || null,
+                dedupKeys: dedupKeys.length > 0 ? dedupKeys : undefined,
               });
             }
             if (result.warning) {

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 } from "./utils.js";
+import { getNestedValue, hasNonBotFeedback, extractIssueRefs } from "./utils.js";
 
 /**
  * Expand template string with item fields
@@ -674,6 +674,49 @@ export function computeAttentionLabels(items, source) {
   });
 }
 
+/**
+ * Compute deduplication keys for an item
+ * 
+ * Dedup keys allow cross-source deduplication: when an issue and its linked PR
+ * both trigger, we can detect they represent the same work.
+ * 
+ * Generates keys from:
+ * 1. The item's own canonical identifier (Linear ID, GitHub repo#number)
+ * 2. Issue references found in title/body (e.g., PR mentioning "Fixes ENG-123")
+ * 
+ * @param {object} item - Item from a source
+ * @param {object} [context] - Context for resolving references
+ * @param {string} [context.repo] - Repository (e.g., "org/repo") for GitHub relative refs
+ * @returns {string[]} Array of dedup keys (e.g., ["linear:ENG-123", "github:org/repo#456"])
+ */
+export function computeDedupKeys(item, context = {}) {
+  const keys = new Set();
+  
+  // 1. Generate canonical key for the item itself
+  
+  // Linear items: use the "number" field which is the issue identifier (e.g., "ENG-123")
+  // Linear preset maps this from url using regex: "url:/([A-Z0-9]+-[0-9]+)/"
+  if (item.number && typeof item.number === 'string' && /^[A-Z][A-Z0-9]*-\d+$/.test(item.number)) {
+    keys.add(`linear:${item.number}`);
+  }
+  
+  // GitHub items: use repo + number
+  // GitHub items have repository.nameWithOwner or repository_full_name (after mapping)
+  const repo = item.repository_full_name || item.repository?.nameWithOwner || context.repo;
+  if (repo && item.number && typeof item.number === 'number') {
+    keys.add(`github:${repo}#${item.number}`);
+  }
+  
+  // 2. Extract issue references from title and body
+  const textToSearch = [item.title, item.body].filter(Boolean).join('\n');
+  const issueRefs = extractIssueRefs(textToSearch, { repo });
+  for (const ref of issueRefs) {
+    keys.add(ref);
+  }
+  
+  return Array.from(keys);
+}
+
 /**
  * Create a poller instance with state tracking
  * 
@@ -688,17 +731,35 @@ export function createPoller(options = {}) {
   
   // Load existing state
   let processedItems = new Map();
+  // Dedup key index: maps dedup keys to item IDs for cross-source deduplication
+  let dedupKeyIndex = new Map();
+  
   if (fs.existsSync(stateFile)) {
     try {
       const state = JSON.parse(fs.readFileSync(stateFile, 'utf-8'));
       if (state.processed) {
         processedItems = new Map(Object.entries(state.processed));
       }
+      if (state.dedupKeys) {
+        dedupKeyIndex = new Map(Object.entries(state.dedupKeys));
+      }
     } catch {
       // Start fresh if state is corrupted
     }
   }
   
+  // Rebuild dedup key index from processed items if not in state file
+  // (handles migration from older state files)
+  if (dedupKeyIndex.size === 0 && processedItems.size > 0) {
+    for (const [itemId, meta] of processedItems) {
+      if (meta.dedupKeys && Array.isArray(meta.dedupKeys)) {
+        for (const key of meta.dedupKeys) {
+          dedupKeyIndex.set(key, itemId);
+        }
+      }
+    }
+  }
+  
   function saveState() {
     const dir = path.dirname(stateFile);
     if (!fs.existsSync(dir)) {
@@ -706,6 +767,7 @@ export function createPoller(options = {}) {
     }
     const state = {
       processed: Object.fromEntries(processedItems),
+      dedupKeys: Object.fromEntries(dedupKeyIndex),
       savedAt: new Date().toISOString(),
     };
     fs.writeFileSync(stateFile, JSON.stringify(state, null, 2));
@@ -719,6 +781,22 @@ export function createPoller(options = {}) {
       return processedItems.has(itemId);
     },
     
+    /**
+     * Check if any of the given dedup keys have been processed
+     * Used for cross-source deduplication (e.g., Linear issue + GitHub PR)
+     * @param {string[]} dedupKeys - Array of dedup keys to check
+     * @returns {string|null} The item ID that owns a matching dedup key, or null
+     */
+    findProcessedByDedupKey(dedupKeys) {
+      for (const key of dedupKeys) {
+        const itemId = dedupKeyIndex.get(key);
+        if (itemId && processedItems.has(itemId)) {
+          return itemId;
+        }
+      }
+      return null;
+    },
+    
     /**
      * Get metadata for a processed item
      * @param {string} itemId - Item ID
@@ -730,13 +808,26 @@ export function createPoller(options = {}) {
     
     /**
      * Mark an item as processed
+     * @param {string} itemId - Item ID
+     * @param {object} [metadata] - Additional metadata to store
+     * @param {string[]} [metadata.dedupKeys] - Dedup keys for cross-source deduplication
      */
     markProcessed(itemId, metadata = {}) {
-      processedItems.set(itemId, {
+      // Store dedup keys in item metadata
+      const itemMeta = {
         processedAt: new Date().toISOString(),
         lastSeenAt: new Date().toISOString(),
         ...metadata,
-      });
+      };
+      processedItems.set(itemId, itemMeta);
+      
+      // Index dedup keys for fast lookup
+      if (metadata.dedupKeys && Array.isArray(metadata.dedupKeys)) {
+        for (const key of metadata.dedupKeys) {
+          dedupKeyIndex.set(key, itemId);
+        }
+      }
+      
       saveState();
     },
     
@@ -814,8 +905,16 @@ export function createPoller(options = {}) {
     
     /**
      * Clear a specific item from processed state
+     * Also removes its dedup keys from the index
      */
     clearProcessed(itemId) {
+      // Remove dedup keys from index first
+      const meta = processedItems.get(itemId);
+      if (meta && meta.dedupKeys && Array.isArray(meta.dedupKeys)) {
+        for (const key of meta.dedupKeys) {
+          dedupKeyIndex.delete(key);
+        }
+      }
       processedItems.delete(itemId);
       saveState();
     },
@@ -825,6 +924,7 @@ export function createPoller(options = {}) {
      */
     clearState() {
       processedItems.clear();
+      dedupKeyIndex.clear();
       saveState();
     },
     
@@ -851,6 +951,7 @@ export function createPoller(options = {}) {
     
     /**
      * Clear all entries for a specific source
+     * Also removes associated dedup keys from the index
      * @param {string} sourceName - Source name
      * @returns {number} Number of entries removed
      */
@@ -858,6 +959,12 @@ export function createPoller(options = {}) {
       let removed = 0;
       for (const [id, meta] of processedItems) {
         if (meta.source === sourceName) {
+          // Remove dedup keys from index
+          if (meta.dedupKeys && Array.isArray(meta.dedupKeys)) {
+            for (const key of meta.dedupKeys) {
+              dedupKeyIndex.delete(key);
+            }
+          }
           processedItems.delete(id);
           removed++;
         }
@@ -868,6 +975,7 @@ export function createPoller(options = {}) {
     
     /**
      * Remove entries older than ttlDays
+     * Also removes associated dedup keys from the index
      * @param {number} [ttlDays=30] - Days before expiration
      * @returns {number} Number of entries removed
      */
@@ -877,6 +985,12 @@ export function createPoller(options = {}) {
       for (const [id, meta] of processedItems) {
         const processedAt = new Date(meta.processedAt).getTime();
         if (processedAt < cutoffMs) {
+          // Remove dedup keys from index
+          if (meta.dedupKeys && Array.isArray(meta.dedupKeys)) {
+            for (const key of meta.dedupKeys) {
+              dedupKeyIndex.delete(key);
+            }
+          }
           processedItems.delete(id);
           removed++;
         }
@@ -888,6 +1002,7 @@ export function createPoller(options = {}) {
     /**
      * Remove entries for a source that are no longer in current items
      * Only removes entries older than minAgeDays to avoid race conditions
+     * Also removes associated dedup keys from the index
      * @param {string} sourceName - Source name to clean
      * @param {string[]} currentItemIds - Current item IDs from source
      * @param {number} [minAgeDays=1] - Minimum age before cleanup (0 = immediate)
@@ -903,6 +1018,12 @@ export function createPoller(options = {}) {
           const processedAt = new Date(meta.processedAt).getTime();
           // Use <= to allow immediate cleanup when minAgeDays=0
           if (processedAt <= cutoffTimestamp) {
+            // Remove dedup keys from index
+            if (meta.dedupKeys && Array.isArray(meta.dedupKeys)) {
+              for (const key of meta.dedupKeys) {
+                dedupKeyIndex.delete(key);
+              }
+            }
             processedItems.delete(id);
             removed++;
           }

package/service/utils.js

@@ -109,6 +109,60 @@ export function isReply(feedback) {
   return feedback.in_reply_to_id !== undefined && feedback.in_reply_to_id !== null;
 }
 
+/**
+ * Extract issue references from text (PR title, body, etc.)
+ * 
+ * Used for cross-source deduplication: when a PR references an issue,
+ * both should be treated as the same work item.
+ * 
+ * Supported patterns:
+ * - Linear issues: ENG-123, PROJ-456 (uppercase prefix, hyphen, numbers)
+ * - GitHub issues: #123, org/repo#123, Fixes #123, Closes org/repo#456
+ * 
+ * @param {string} text - Text to extract references from
+ * @param {object} [context] - Optional context for resolving relative refs
+ * @param {string} [context.repo] - Repository (e.g., "org/repo") for resolving #123
+ * @returns {string[]} Array of normalized issue references (e.g., ["linear:ENG-123", "github:org/repo#123"])
+ */
+export function extractIssueRefs(text, context = {}) {
+  if (!text || typeof text !== 'string') {
+    return [];
+  }
+  
+  const refs = new Set();
+  
+  // Linear issue pattern: ENG-123, PROJ-456 (1-10 char uppercase prefix)
+  // Must be word-bounded to avoid matching random strings
+  const linearPattern = /\b([A-Z][A-Z0-9]{0,9}-\d+)\b/g;
+  let match;
+  while ((match = linearPattern.exec(text)) !== null) {
+    refs.add(`linear:${match[1]}`);
+  }
+  
+  // GitHub issue patterns:
+  // - Full: org/repo#123
+  // - Relative: #123 (needs context.repo)
+  // - Keywords: Fixes #123, Closes org/repo#456, Resolves #789
+  
+  // Full repo reference: org/repo#123
+  const fullGithubPattern = /\b([a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+)#(\d+)\b/g;
+  while ((match = fullGithubPattern.exec(text)) !== null) {
+    refs.add(`github:${match[1]}#${match[2]}`);
+  }
+  
+  // Relative reference: #123 (only if context.repo is provided)
+  if (context.repo) {
+    // Match #123 but not org/repo#123 (already handled above)
+    // Use negative lookbehind to avoid matching the # in full refs
+    const relativePattern = /(?<![a-zA-Z0-9_.-]\/[a-zA-Z0-9_.-]+)#(\d+)\b/g;
+    while ((match = relativePattern.exec(text)) !== null) {
+      refs.add(`github:${context.repo}#${match[1]}`);
+    }
+  }
+  
+  return Array.from(refs);
+}
+
 /**
  * Check if a PR/issue has actionable feedback
  * 

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

@@ -620,3 +620,116 @@ describe("integration: worktree creation with worktree_name", () => {
     assert.strictEqual(sessionDirectory, existingWorktreeDir, "Session should use existing directory");
   });
 });
+
+describe("integration: cross-source deduplication", () => {
+  /**
+   * These tests verify cross-source deduplication:
+   * When a Linear issue and a GitHub PR are linked (PR mentions Linear ID),
+   * only one session should be created.
+   */
+
+  it("computeDedupKeys extracts Linear refs from GitHub PR", async () => {
+    const { computeDedupKeys } = await import("../../service/poller.js");
+
+    // Simulated GitHub PR that mentions a Linear issue
+    const pr = {
+      id: "https://github.com/myorg/backend/pull/456",
+      number: 456,
+      repository_full_name: "myorg/backend",
+      title: "ENG-123: Implement new feature",
+      body: "This PR implements the feature requested in ENG-123.\n\nCloses #789",
+    };
+
+    const keys = computeDedupKeys(pr);
+
+    // Should include:
+    // 1. PR's own canonical key
+    // 2. Linear issue ref from title
+    // 3. GitHub issue ref from body (relative, needs context)
+    assert.ok(keys.includes("github:myorg/backend#456"), "Should have PR's canonical key");
+    assert.ok(keys.includes("linear:ENG-123"), "Should extract Linear ref from title");
+  });
+
+  it("computeDedupKeys generates canonical key for Linear issues", async () => {
+    const { computeDedupKeys } = await import("../../service/poller.js");
+
+    // Simulated Linear issue (number is the identifier like "ENG-123")
+    const issue = {
+      id: "linear:abc-123-uuid",
+      number: "ENG-123", // Linear preset extracts this from URL
+      title: "Implement new feature",
+      body: "Description of the feature",
+    };
+
+    const keys = computeDedupKeys(issue);
+
+    assert.ok(keys.includes("linear:ENG-123"), "Should have Linear issue's canonical key");
+  });
+
+  it("poller detects duplicate via shared dedup key", async () => {
+    const { createPoller } = await import("../../service/poller.js");
+    const { mkdtempSync, rmSync } = await import("fs");
+    const { join } = await import("path");
+    const { tmpdir } = await import("os");
+
+    const tempDir = mkdtempSync(join(tmpdir(), "dedup-test-"));
+    const stateFile = join(tempDir, "poll-state.json");
+
+    try {
+      const poller = createPoller({ stateFile });
+
+      // Linear issue ENG-123 is processed first
+      poller.markProcessed("linear:abc-uuid", {
+        source: "linear/my-issues",
+        dedupKeys: ["linear:ENG-123"],
+      });
+
+      // GitHub PR comes in with ENG-123 in title
+      const prDedupKeys = ["github:myorg/backend#456", "linear:ENG-123"];
+      
+      // Should find the Linear issue via shared dedup key
+      const existingItemId = poller.findProcessedByDedupKey(prDedupKeys);
+      
+      assert.strictEqual(existingItemId, "linear:abc-uuid", 
+        "PR should be detected as duplicate of Linear issue via shared ENG-123 key");
+    } finally {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  it("dedup key index is rebuilt on load if missing from old state file", async () => {
+    const { createPoller } = await import("../../service/poller.js");
+    const { mkdtempSync, rmSync, writeFileSync } = await import("fs");
+    const { join } = await import("path");
+    const { tmpdir } = await import("os");
+
+    const tempDir = mkdtempSync(join(tmpdir(), "dedup-migration-test-"));
+    const stateFile = join(tempDir, "poll-state.json");
+
+    try {
+      // Simulate old state file without dedupKeys index (migration scenario)
+      const oldState = {
+        processed: {
+          "linear:abc-uuid": {
+            processedAt: new Date().toISOString(),
+            source: "linear",
+            dedupKeys: ["linear:ENG-123"], // Keys are in item metadata
+          },
+        },
+        // No dedupKeys index at top level
+        savedAt: new Date().toISOString(),
+      };
+      writeFileSync(stateFile, JSON.stringify(oldState));
+
+      // Load poller - should rebuild index from item metadata
+      const poller = createPoller({ stateFile });
+
+      // Should still be able to find by dedup key
+      const foundId = poller.findProcessedByDedupKey(["linear:ENG-123"]);
+      assert.strictEqual(foundId, "linear:abc-uuid", 
+        "Should rebuild dedup index from processed items on load");
+    } finally {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+});

package/test/unit/poller.test.js

@@ -374,6 +374,193 @@ describe('poller.js', () => {
     });
   });
 
+  describe('cross-source deduplication', () => {
+    test('findProcessedByDedupKey finds item by dedup key', async () => {
+      const { createPoller } = await import('../../service/poller.js');
+      
+      const poller = createPoller({ stateFile });
+      poller.markProcessed('linear:abc123', { 
+        source: 'linear',
+        dedupKeys: ['linear:ENG-123'],
+      });
+      
+      // Should find the item by its dedup key
+      const foundId = poller.findProcessedByDedupKey(['linear:ENG-123']);
+      assert.strictEqual(foundId, 'linear:abc123');
+    });
+
+    test('findProcessedByDedupKey returns null when no match', async () => {
+      const { createPoller } = await import('../../service/poller.js');
+      
+      const poller = createPoller({ stateFile });
+      poller.markProcessed('linear:abc123', { 
+        source: 'linear',
+        dedupKeys: ['linear:ENG-123'],
+      });
+      
+      // Different dedup key should not match
+      const foundId = poller.findProcessedByDedupKey(['linear:ENG-456']);
+      assert.strictEqual(foundId, null);
+    });
+
+    test('findProcessedByDedupKey enables cross-source dedup (Linear + GitHub PR)', async () => {
+      const { createPoller } = await import('../../service/poller.js');
+      
+      const poller = createPoller({ stateFile });
+      
+      // Linear issue ENG-123 is processed first
+      poller.markProcessed('linear:abc123', { 
+        source: 'linear/my-issues',
+        dedupKeys: ['linear:ENG-123'],
+      });
+      
+      // GitHub PR mentioning ENG-123 comes later - should find the Linear item
+      const prDedupKeys = ['github:myorg/backend#456', 'linear:ENG-123']; // PR has ENG-123 in title
+      const foundId = poller.findProcessedByDedupKey(prDedupKeys);
+      
+      assert.strictEqual(foundId, 'linear:abc123', 'PR should match Linear issue by shared dedup key');
+    });
+
+    test('dedup key index persists across poller instances', async () => {
+      const { createPoller } = await import('../../service/poller.js');
+      
+      const poller1 = createPoller({ stateFile });
+      poller1.markProcessed('linear:abc123', { 
+        source: 'linear',
+        dedupKeys: ['linear:ENG-123'],
+      });
+      
+      // New poller instance should have the dedup index
+      const poller2 = createPoller({ stateFile });
+      const foundId = poller2.findProcessedByDedupKey(['linear:ENG-123']);
+      assert.strictEqual(foundId, 'linear:abc123');
+    });
+
+    test('clearProcessed removes dedup keys from index', async () => {
+      const { createPoller } = await import('../../service/poller.js');
+      
+      const poller = createPoller({ stateFile });
+      poller.markProcessed('linear:abc123', { 
+        source: 'linear',
+        dedupKeys: ['linear:ENG-123'],
+      });
+      
+      // Verify it's there
+      assert.strictEqual(poller.findProcessedByDedupKey(['linear:ENG-123']), 'linear:abc123');
+      
+      // Clear the item
+      poller.clearProcessed('linear:abc123');
+      
+      // Dedup key should be gone
+      assert.strictEqual(poller.findProcessedByDedupKey(['linear:ENG-123']), null);
+    });
+
+    test('clearState removes all dedup keys', async () => {
+      const { createPoller } = await import('../../service/poller.js');
+      
+      const poller = createPoller({ stateFile });
+      poller.markProcessed('item-1', { dedupKeys: ['key-1', 'key-2'] });
+      poller.markProcessed('item-2', { dedupKeys: ['key-3'] });
+      
+      poller.clearState();
+      
+      assert.strictEqual(poller.findProcessedByDedupKey(['key-1']), null);
+      assert.strictEqual(poller.findProcessedByDedupKey(['key-2']), null);
+      assert.strictEqual(poller.findProcessedByDedupKey(['key-3']), null);
+    });
+
+    test('clearBySource removes dedup keys for that source only', async () => {
+      const { createPoller } = await import('../../service/poller.js');
+      
+      const poller = createPoller({ stateFile });
+      poller.markProcessed('item-1', { source: 'linear', dedupKeys: ['linear:ENG-123'] });
+      poller.markProcessed('item-2', { source: 'github', dedupKeys: ['github:org/repo#456'] });
+      
+      poller.clearBySource('linear');
+      
+      // Linear dedup key should be gone
+      assert.strictEqual(poller.findProcessedByDedupKey(['linear:ENG-123']), null);
+      // GitHub dedup key should still exist
+      assert.strictEqual(poller.findProcessedByDedupKey(['github:org/repo#456']), 'item-2');
+    });
+  });
+
+  describe('computeDedupKeys', () => {
+    test('generates Linear dedup key from number field', async () => {
+      const { computeDedupKeys } = await import('../../service/poller.js');
+      
+      // Linear item with number field (extracted from URL by preset mapping)
+      const item = {
+        id: 'abc-123-uuid',
+        number: 'ENG-123',
+        title: 'Fix the bug',
+      };
+      
+      const keys = computeDedupKeys(item);
+      assert.ok(keys.includes('linear:ENG-123'));
+    });
+
+    test('generates GitHub dedup key from repo + number', async () => {
+      const { computeDedupKeys } = await import('../../service/poller.js');
+      
+      const item = {
+        id: 'https://github.com/myorg/backend/issues/123',
+        number: 123,
+        repository_full_name: 'myorg/backend',
+        title: 'Fix the bug',
+      };
+      
+      const keys = computeDedupKeys(item);
+      assert.ok(keys.includes('github:myorg/backend#123'));
+    });
+
+    test('extracts Linear refs from PR title/body', async () => {
+      const { computeDedupKeys } = await import('../../service/poller.js');
+      
+      const item = {
+        id: 'https://github.com/myorg/backend/pull/456',
+        number: 456,
+        repository_full_name: 'myorg/backend',
+        title: 'ENG-123: Fix the bug',
+        body: 'This PR fixes the issue described in ENG-123.',
+      };
+      
+      const keys = computeDedupKeys(item);
+      // Should have both the PR's own key and the Linear ref
+      assert.ok(keys.includes('github:myorg/backend#456'), 'Should have PR key');
+      assert.ok(keys.includes('linear:ENG-123'), 'Should extract Linear ref from title/body');
+    });
+
+    test('extracts GitHub issue refs from PR body', async () => {
+      const { computeDedupKeys } = await import('../../service/poller.js');
+      
+      const item = {
+        id: 'https://github.com/myorg/backend/pull/456',
+        number: 456,
+        repository_full_name: 'myorg/backend',
+        title: 'Fix the bug',
+        body: 'Fixes #123',
+      };
+      
+      const keys = computeDedupKeys(item, { repo: 'myorg/backend' });
+      assert.ok(keys.includes('github:myorg/backend#456'), 'Should have PR key');
+      assert.ok(keys.includes('github:myorg/backend#123'), 'Should extract issue ref from body');
+    });
+
+    test('handles items without extractable refs', async () => {
+      const { computeDedupKeys } = await import('../../service/poller.js');
+      
+      const item = {
+        id: 'reminder:abc123',
+        title: 'Buy groceries',
+      };
+      
+      const keys = computeDedupKeys(item);
+      // Should return empty array - no recognizable refs
+      assert.deepStrictEqual(keys, []);
+    });
+  });
+
   describe('status tracking', () => {
     test('shouldReprocess returns false for item with same state', async () => {
       const { createPoller } = await import('../../service/poller.js');

package/test/unit/utils.test.js

@@ -290,6 +290,114 @@ describe('utils.js', () => {
     });
   });
 
+  describe('extractIssueRefs', () => {
+    test('extracts Linear issue IDs from text', async () => {
+      const { extractIssueRefs } = await import('../../service/utils.js');
+      
+      assert.deepStrictEqual(
+        extractIssueRefs('Fix bug in ENG-123'),
+        ['linear:ENG-123']
+      );
+      assert.deepStrictEqual(
+        extractIssueRefs('Implement PROJ-456 feature'),
+        ['linear:PROJ-456']
+      );
+    });
+
+    test('extracts multiple Linear IDs', async () => {
+      const { extractIssueRefs } = await import('../../service/utils.js');
+      
+      const refs = extractIssueRefs('Fixes ENG-123 and also addresses ENG-456');
+      assert.ok(refs.includes('linear:ENG-123'));
+      assert.ok(refs.includes('linear:ENG-456'));
+      assert.strictEqual(refs.length, 2);
+    });
+
+    test('extracts full GitHub issue references', async () => {
+      const { extractIssueRefs } = await import('../../service/utils.js');
+      
+      assert.deepStrictEqual(
+        extractIssueRefs('Fixes myorg/backend#123'),
+        ['github:myorg/backend#123']
+      );
+    });
+
+    test('extracts relative GitHub issue references with context', async () => {
+      const { extractIssueRefs } = await import('../../service/utils.js');
+      
+      const refs = extractIssueRefs('Fixes #123', { repo: 'myorg/backend' });
+      assert.deepStrictEqual(refs, ['github:myorg/backend#123']);
+    });
+
+    test('ignores relative GitHub refs without context', async () => {
+      const { extractIssueRefs } = await import('../../service/utils.js');
+      
+      // Without context.repo, relative refs like #123 cannot be resolved
+      const refs = extractIssueRefs('Fixes #123');
+      assert.deepStrictEqual(refs, []);
+    });
+
+    test('extracts mixed Linear and GitHub refs', async () => {
+      const { extractIssueRefs } = await import('../../service/utils.js');
+      
+      const refs = extractIssueRefs('Fixes ENG-123 and closes myorg/backend#456');
+      assert.ok(refs.includes('linear:ENG-123'));
+      assert.ok(refs.includes('github:myorg/backend#456'));
+      assert.strictEqual(refs.length, 2);
+    });
+
+    test('deduplicates repeated references', async () => {
+      const { extractIssueRefs } = await import('../../service/utils.js');
+      
+      const refs = extractIssueRefs('ENG-123 mentioned again ENG-123');
+      assert.deepStrictEqual(refs, ['linear:ENG-123']);
+    });
+
+    test('handles typical PR body with closing keywords', async () => {
+      const { extractIssueRefs } = await import('../../service/utils.js');
+      
+      const prBody = `## Summary
+      This PR implements the feature requested in ENG-123.
+      
+      Closes #456
+      `;
+      
+      const refs = extractIssueRefs(prBody, { repo: 'myorg/backend' });
+      assert.ok(refs.includes('linear:ENG-123'));
+      assert.ok(refs.includes('github:myorg/backend#456'));
+    });
+
+    test('handles empty/null/undefined input', async () => {
+      const { extractIssueRefs } = await import('../../service/utils.js');
+      
+      assert.deepStrictEqual(extractIssueRefs(''), []);
+      assert.deepStrictEqual(extractIssueRefs(null), []);
+      assert.deepStrictEqual(extractIssueRefs(undefined), []);
+    });
+
+    test('does not match partial patterns', async () => {
+      const { extractIssueRefs } = await import('../../service/utils.js');
+      
+      // Should not match: lowercase, no hyphen
+      assert.deepStrictEqual(extractIssueRefs('eng-123'), []); // lowercase
+      assert.deepStrictEqual(extractIssueRefs('ENG123'), []); // no hyphen
+      // Underscores are word characters, so \b won't match - ENG-123 inside underscores won't be extracted
+      assert.deepStrictEqual(extractIssueRefs('PREFIX_ENG-123_SUFFIX'), []); // underscores prevent word boundary
+      // But spaces, parentheses, etc. are fine
+      assert.deepStrictEqual(extractIssueRefs('(ENG-123)'), ['linear:ENG-123']);
+      assert.deepStrictEqual(extractIssueRefs('See ENG-123 for details'), ['linear:ENG-123']);
+    });
+
+    test('handles various Linear team prefixes', async () => {
+      const { extractIssueRefs } = await import('../../service/utils.js');
+      
+      // Various real-world team prefix patterns
+      assert.deepStrictEqual(extractIssueRefs('A-1'), ['linear:A-1']); // shortest
+      assert.deepStrictEqual(extractIssueRefs('PLATFORM-99999'), ['linear:PLATFORM-99999']); // longer
+      assert.deepStrictEqual(extractIssueRefs('DEV2-123'), ['linear:DEV2-123']); // with numbers
+    });
+  });
+
   describe('getNestedValue', () => {
     test('gets top-level value', async () => {
       const { getNestedValue } = await import('../../service/utils.js');

package/install.sh

@@ -1,246 +0,0 @@
-#!/usr/bin/env bash
-#
-# Install opencode-ntfy plugin and callback service
-#
-# Usage:
-#   curl -fsSL https://raw.githubusercontent.com/athal7/opencode-ntfy/main/install.sh | bash
-#
-# Or from a local clone:
-#   ./install.sh
-#
-
-set -euo pipefail
-
-REPO="athal7/opencode-ntfy"
-PLUGIN_NAME="opencode-ntfy"
-PLUGIN_DIR="$HOME/.config/opencode/plugins/$PLUGIN_NAME"
-SERVICE_DIR="$HOME/.local/share/opencode-ntfy"
-CONFIG_FILE="$HOME/.config/opencode/opencode.json"
-PLIST_DIR="$HOME/Library/LaunchAgents"
-PLIST_NAME="io.opencode.ntfy.plist"
-PLUGIN_FILES="index.js notifier.js callback.js hostname.js nonces.js config.js service-client.js"
-SERVICE_FILES="server.js"
-
-echo "Installing $PLUGIN_NAME..."
-echo ""
-
-# Create directories
-mkdir -p "$PLUGIN_DIR"
-mkdir -p "$SERVICE_DIR"
-
-# Check if we're running from a local clone or need to download
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}" 2>/dev/null)" && pwd 2>/dev/null)" || SCRIPT_DIR=""
-
-if [[ -n "$SCRIPT_DIR" ]] && [[ -f "$SCRIPT_DIR/plugin/index.js" ]]; then
-  # Local install from clone
-  echo "Installing from local directory..."
-  
-  echo ""
-  echo "Plugin files:"
-  for file in $PLUGIN_FILES; do
-    if [[ -f "$SCRIPT_DIR/plugin/$file" ]]; then
-      cp "$SCRIPT_DIR/plugin/$file" "$PLUGIN_DIR/$file"
-      echo "  Installed: plugin/$file -> $PLUGIN_DIR/$file"
-    fi
-  done
-  
-  echo ""
-  echo "Service files:"
-  for file in $SERVICE_FILES; do
-    if [[ -f "$SCRIPT_DIR/service/$file" ]]; then
-      cp "$SCRIPT_DIR/service/$file" "$SERVICE_DIR/$file"
-      echo "  Installed: service/$file -> $SERVICE_DIR/$file"
-    fi
-  done
-else
-  # Remote install - download from GitHub
-  echo "Downloading plugin files from GitHub..."
-  
-  for file in $PLUGIN_FILES; do
-    echo "  Downloading: plugin/$file"
-    if curl -fsSL "https://raw.githubusercontent.com/$REPO/main/plugin/$file" -o "$PLUGIN_DIR/$file"; then
-      echo "  Installed: $file"
-    else
-      echo "  ERROR: Failed to download $file"
-      exit 1
-    fi
-  done
-  
-  echo ""
-  echo "Downloading service files from GitHub..."
-  
-  for file in $SERVICE_FILES; do
-    echo "  Downloading: service/$file"
-    if curl -fsSL "https://raw.githubusercontent.com/$REPO/main/service/$file" -o "$SERVICE_DIR/$file"; then
-      echo "  Installed: $file"
-    else
-      echo "  ERROR: Failed to download $file"
-      exit 1
-    fi
-  done
-fi
-
-echo ""
-echo "Plugin files installed to: $PLUGIN_DIR"
-echo "Service files installed to: $SERVICE_DIR"
-
-# Install LaunchAgent plist (macOS only)
-if [[ "$(uname)" == "Darwin" ]]; then
-  echo ""
-  echo "Installing LaunchAgent for callback service..."
-  
-  mkdir -p "$PLIST_DIR"
-  
-  # Find node path (handle both Intel and Apple Silicon Macs)
-  NODE_PATH=$(command -v node 2>/dev/null)
-  if [[ -z "$NODE_PATH" ]]; then
-    # Try Homebrew paths
-    if [[ -x "/opt/homebrew/bin/node" ]]; then
-      NODE_PATH="/opt/homebrew/bin/node"
-    elif [[ -x "/usr/local/bin/node" ]]; then
-      NODE_PATH="/usr/local/bin/node"
-    else
-      echo "  WARNING: node not found, please install Node.js"
-      NODE_PATH="/usr/local/bin/node"
-    fi
-  fi
-  
-  # Generate plist with correct paths
-  cat > "$PLIST_DIR/$PLIST_NAME" << EOF
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-    <key>Label</key>
-    <string>io.opencode.ntfy</string>
-    
-    <key>ProgramArguments</key>
-    <array>
-        <string>$NODE_PATH</string>
-        <string>$SERVICE_DIR/server.js</string>
-    </array>
-    
-    <key>RunAtLoad</key>
-    <true/>
-    
-    <key>KeepAlive</key>
-    <true/>
-    
-    <key>StandardOutPath</key>
-    <string>$HOME/.local/share/opencode-ntfy/opencode-ntfy.log</string>
-    
-    <key>StandardErrorPath</key>
-    <string>$HOME/.local/share/opencode-ntfy/opencode-ntfy.log</string>
-    
-    <key>WorkingDirectory</key>
-    <string>$SERVICE_DIR</string>
-</dict>
-</plist>
-EOF
-  
-  echo "  LaunchAgent installed to: $PLIST_DIR/$PLIST_NAME"
-  echo ""
-  echo "  To start the callback service:"
-  echo "    launchctl load $PLIST_DIR/$PLIST_NAME"
-  echo ""
-  echo "  To stop the callback service:"
-  echo "    launchctl unload $PLIST_DIR/$PLIST_NAME"
-fi
-
-# Configure opencode.json
-echo ""
-echo "Configuring OpenCode..."
-
-if [[ -f "$CONFIG_FILE" ]]; then
-  # Check if plugin already configured
-  if grep -q "$PLUGIN_DIR" "$CONFIG_FILE" 2>/dev/null; then
-    echo "  Plugin already configured in opencode.json"
-  else
-    echo ""
-    echo "  Would you like to add the plugin to opencode.json? [Y/n]"
-    read -r response </dev/tty || response="y"
-    if [[ "$response" != "n" && "$response" != "N" ]]; then
-      # Use node to update JSON safely
-      if command -v node >/dev/null 2>&1; then
-        node -e "
-          const fs = require('fs');
-          const configPath = '$CONFIG_FILE';
-          const pluginDir = '$PLUGIN_DIR';
-          
-          let config;
-          try {
-            config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-          } catch {
-            config = {};
-          }
-          
-          config.plugin = config.plugin || [];
-          if (!config.plugin.includes(pluginDir)) {
-            config.plugin.push(pluginDir);
-          }
-          
-          fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
-        "
-        echo "  Plugin added to opencode.json"
-      else
-        echo "  WARNING: node not found, please manually add to opencode.json:"
-        echo ""
-        echo "    \"plugin\": [\"$PLUGIN_DIR\"]"
-      fi
-    else
-      echo "  Skipped. You can manually add the plugin path to opencode.json later."
-    fi
-  fi
-else
-  echo ""
-  echo "  No opencode.json found. Create one with the plugin configured? [Y/n]"
-  read -r response </dev/tty || response="y"
-  if [[ "$response" != "n" && "$response" != "N" ]]; then
-    mkdir -p "$(dirname "$CONFIG_FILE")"
-    cat > "$CONFIG_FILE" << EOF
-{
-  "plugin": ["$PLUGIN_DIR"]
-}
-EOF
-    echo "  Created $CONFIG_FILE"
-  else
-    echo "  Skipped. You can create opencode.json later with:"
-    echo ""
-    echo "    {\"plugin\": [\"$PLUGIN_DIR\"]}"
-  fi
-fi
-
-# Environment variable check and guidance
-echo ""
-echo "========================================"
-echo "  Installation complete!"
-echo "========================================"
-echo ""
-
-# Check if NTFY_TOPIC is set
-if [[ -n "${NTFY_TOPIC:-}" ]]; then
-  echo "NTFY_TOPIC is set: $NTFY_TOPIC"
-  echo ""
-  echo "The plugin is ready to use!"
-else
-  echo "REQUIRED: Set NTFY_TOPIC in your environment."
-  echo ""
-  echo "Add to ~/.env (if using direnv) or your shell profile:"
-  echo ""
-  echo "  export NTFY_TOPIC=your-secret-topic"
-fi
-
-echo ""
-echo "Optional configuration:"
-echo "  NTFY_SERVER=https://ntfy.sh        # ntfy server (default: ntfy.sh)"
-echo "  NTFY_TOKEN=tk_xxx                  # ntfy access token for protected topics"
-echo "  NTFY_CALLBACK_HOST=host.ts.net     # Callback host for interactive notifications"
-echo "  NTFY_CALLBACK_PORT=4097            # Callback server port"
-echo "  NTFY_IDLE_DELAY_MS=300000          # Idle notification delay (5 min)"
-
-echo ""
-echo "For interactive permissions:"
-echo "  1. Set NTFY_CALLBACK_HOST to your machine's hostname (e.g., via Tailscale)"
-echo "  2. Start the callback service: launchctl load ~/Library/LaunchAgents/$PLIST_NAME"
-echo "  3. Ensure your phone can reach the callback URL"
-echo ""