opencode-pilot 0.20.3 → 0.20.5

package/package.json

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

package/service/actions.js

@@ -799,6 +799,82 @@ export async function createSessionViaApi(serverUrl, directory, prompt, options
   }
 }
 
+/**
+ * Execute session creation/reuse in a specific directory
+ * Internal helper for executeAction - handles prompt building, session reuse, and API calls
+ * 
+ * @param {string} serverUrl - OpenCode server URL
+ * @param {string} cwd - Working directory for the session
+ * @param {object} item - Item to create session for
+ * @param {object} config - Repo config with action settings
+ * @param {object} [options] - Execution options
+ * @returns {Promise<object>} Result with command, success, sessionId, etc.
+ */
+async function executeInDirectory(serverUrl, cwd, item, config, options = {}) {
+  // Build prompt from template
+  const prompt = buildPromptFromTemplate(config.prompt || "default", item);
+  
+  // Build session title
+  const sessionTitle = config.session?.name
+    ? buildSessionName(config.session.name, item)
+    : (item.title || `session-${Date.now()}`);
+  
+  // Check if we should try to reuse an existing session
+  const reuseActiveSession = config.reuse_active_session !== false; // default true
+  
+  if (reuseActiveSession && !options.dryRun) {
+    const existingSession = await findReusableSession(serverUrl, cwd, { fetch: options.fetch });
+    
+    if (existingSession) {
+      debug(`executeInDirectory: found reusable session ${existingSession.id} for ${cwd}`);
+      
+      const reuseCommand = `[API] POST ${serverUrl}/session/${existingSession.id}/message (reusing session)`;
+      
+      const result = await sendMessageToSession(serverUrl, existingSession.id, cwd, prompt, {
+        title: sessionTitle,
+        agent: config.agent,
+        model: config.model,
+        fetch: options.fetch,
+      });
+      
+      return {
+        command: reuseCommand,
+        success: result.success,
+        sessionId: result.sessionId,
+        directory: cwd,
+        sessionReused: true,
+        error: result.error,
+      };
+    }
+  }
+  
+  const apiCommand = `[API] POST ${serverUrl}/session?directory=${cwd}`;
+  debug(`executeInDirectory: using HTTP API - ${apiCommand}`);
+  
+  if (options.dryRun) {
+    return {
+      command: apiCommand,
+      directory: cwd,
+      dryRun: true,
+    };
+  }
+  
+  const result = await createSessionViaApi(serverUrl, cwd, prompt, {
+    title: sessionTitle,
+    agent: config.agent,
+    model: config.model,
+    fetch: options.fetch,
+  });
+  
+  return {
+    command: apiCommand,
+    success: result.success,
+    sessionId: result.sessionId,
+    directory: cwd,
+    error: result.error,
+  };
+}
+
 /**
  * Execute an action
  * @param {object} item - Item to create session for
@@ -841,11 +917,27 @@ export async function executeAction(item, config, options = {}) {
     };
   }
   
+  // If existing_directory is provided (reprocessing same item), use it directly
+  // This preserves the worktree from the previous run even if its name doesn't match the template
+  if (config.existing_directory) {
+    debug(`executeAction: using existing_directory=${config.existing_directory}`);
+    const cwd = expandPath(config.existing_directory);
+    return await executeInDirectory(serverUrl, cwd, item, config, options);
+  }
+  
   // Resolve worktree directory if configured
   // This allows creating sessions in isolated worktrees instead of the main project
   let worktreeMode = config.worktree;
   
+  // If worktree_name is configured, enable worktree mode (explicit configuration)
+  // This allows presets to specify worktree isolation without requiring existing sandboxes
+  if (!worktreeMode && config.worktree_name) {
+    debug(`executeAction: worktree_name configured, enabling worktree mode`);
+    worktreeMode = 'new';
+  }
+  
   // Auto-detect worktree support: check if the project has sandboxes
+  // This is a fallback for when worktree isn't explicitly configured
   if (!worktreeMode) {
     // Look up project info for this specific directory (not just /project/current)
     const projectInfo = await getProjectInfoForDirectory(serverUrl, baseCwd, { fetch: options.fetch });
@@ -882,63 +974,5 @@ export async function executeAction(item, config, options = {}) {
   
   debug(`executeAction: using cwd=${cwd}`);
   
-  // Build prompt from template
-  const prompt = buildPromptFromTemplate(config.prompt || "default", item);
-  
-  // Build session title
-  const sessionTitle = config.session?.name
-    ? buildSessionName(config.session.name, item)
-    : (item.title || `session-${Date.now()}`);
-  
-  // Check if we should try to reuse an existing session
-  const reuseActiveSession = config.reuse_active_session !== false; // default true
-  
-  if (reuseActiveSession && !options.dryRun) {
-    const existingSession = await findReusableSession(serverUrl, cwd, { fetch: options.fetch });
-    
-    if (existingSession) {
-      debug(`executeAction: found reusable session ${existingSession.id} for ${cwd}`);
-      
-      const reuseCommand = `[API] POST ${serverUrl}/session/${existingSession.id}/message (reusing session)`;
-      
-      const result = await sendMessageToSession(serverUrl, existingSession.id, cwd, prompt, {
-        title: sessionTitle,
-        agent: config.agent,
-        model: config.model,
-        fetch: options.fetch,
-      });
-      
-      return {
-        command: reuseCommand,
-        success: result.success,
-        sessionId: result.sessionId,
-        sessionReused: true,
-        error: result.error,
-      };
-    }
-  }
-  
-  const apiCommand = `[API] POST ${serverUrl}/session?directory=${cwd}`;
-  debug(`executeAction: using HTTP API - ${apiCommand}`);
-  
-  if (options.dryRun) {
-    return {
-      command: apiCommand,
-      dryRun: true,
-    };
-  }
-  
-  const result = await createSessionViaApi(serverUrl, cwd, prompt, {
-    title: sessionTitle,
-    agent: config.agent,
-    model: config.model,
-    fetch: options.fetch,
-  });
-  
-  return {
-    command: apiCommand,
-    success: result.success,
-    sessionId: result.sessionId,
-    error: result.error,
-  };
+  return await executeInDirectory(serverUrl, cwd, item, config, options);
 }

package/service/poll-service.js

@@ -200,10 +200,14 @@ export async function pollOnce(options = {}) {
     debug(`Processing ${sortedItems.length} sorted items`);
     for (const item of sortedItems) {
       // Check if already processed
+      let existingDirectory = null;
       if (pollerInstance && pollerInstance.isProcessed(item.id)) {
         // Check if item should be reprocessed (reopened, status changed, etc.)
         if (pollerInstance.shouldReprocess(item, { reprocessOn })) {
           debug(`Reprocessing ${item.id} - state changed`);
+          // Get the stored directory before clearing state (for worktree reuse)
+          const prevMeta = pollerInstance.getProcessedMeta(item.id);
+          existingDirectory = prevMeta?.directory || null;
           pollerInstance.clearProcessed(item.id);
           console.log(`[poll] Reprocessing ${item.id} (reopened or updated)`);
         } else {
@@ -215,6 +219,12 @@ export async function pollOnce(options = {}) {
       debug(`Executing action for ${item.id}`);
       // Build action config from source and item (resolves repo from item fields)
       const actionConfig = buildActionConfigForItem(source, item);
+      
+      // Pass existing directory for worktree reuse when reprocessing
+      if (existingDirectory) {
+        actionConfig.existing_directory = existingDirectory;
+        debug(`Reusing existing directory: ${existingDirectory}`);
+      }
 
       // Skip items with no valid local path (prevents sessions in home directory)
       const hasLocalPath = actionConfig.working_dir || actionConfig.path || actionConfig.repo_path;
@@ -244,11 +254,13 @@ export async function pollOnce(options = {}) {
           if (result.success) {
             // Mark as processed to avoid re-triggering
             // Store item state for detecting reopened/updated items
+            // Store directory for worktree reuse when reprocessing
             if (pollerInstance) {
               pollerInstance.markProcessed(item.id, { 
                 repoKey: item.repo_key, 
                 command: result.command,
                 source: sourceName,
+                directory: result.directory || null,
                 itemState: item.state || item.status || null,
                 itemUpdatedAt: item.updated_at || null,
               });

package/service/poller.js

@@ -722,6 +722,15 @@ export function createPoller(options = {}) {
       return processedItems.has(itemId);
     },
     
+    /**
+     * Get metadata for a processed item
+     * @param {string} itemId - Item ID
+     * @returns {object|null} Metadata or null if not processed
+     */
+    getProcessedMeta(itemId) {
+      return processedItems.get(itemId) || null;
+    },
+    
     /**
      * Mark an item as processed
      */

package/service/readiness.js

@@ -348,13 +348,18 @@ export function evaluateReadiness(issue, config) {
   }
 
   // Check bot comments (for PRs enriched with _comments)
-  const botResult = checkBotComments(issue, config);
-  if (!botResult.ready) {
-    return {
-      ready: false,
-      reason: botResult.reason,
-      priority: 0,
-    };
+  // Skip this check when require_attention is set, because checkAttention
+  // handles the combined logic (conflicts OR feedback) via _has_attention
+  const readinessConfig = config.readiness || {};
+  if (!readinessConfig.require_attention) {
+    const botResult = checkBotComments(issue, config);
+    if (!botResult.ready) {
+      return {
+        ready: false,
+        reason: botResult.reason,
+        priority: 0,
+      };
+    }
   }
 
   // Check mergeable status (for PRs enriched with _mergeable)

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

@@ -21,6 +21,14 @@ import {
   resolveWorktreeDirectory,
 } from "../../service/worktree.js";
 
+import {
+  computeAttentionLabels,
+} from "../../service/poller.js";
+
+import {
+  evaluateReadiness,
+} from "../../service/readiness.js";
+
 /**
  * Create a mock OpenCode server for testing
  */
@@ -345,3 +353,270 @@ describe("integration: sandbox reuse", () => {
     assert.strictEqual(listDirectory, "/path/to/project", "Should pass directory when looking up named worktree");
   });
 });
+
+describe("integration: PR attention detection", () => {
+  /**
+   * These tests verify the full flow of PR attention detection:
+   * 1. PRs with merge conflicts should be detected as needing attention
+   * 2. PRs with human feedback should be detected as needing attention
+   * 3. PRs with only bot comments but conflicts should still be ready (require_attention mode)
+   * 4. computeAttentionLabels + evaluateReadiness work together correctly
+   */
+
+  it("PR with conflicts and only bot comments is ready when require_attention is set", () => {
+    // This is the key scenario that was broken: PR has merge conflicts but no human feedback
+    // With require_attention, it should be ready because conflicts count as "attention needed"
+    const items = [{
+      number: 123,
+      title: "Test PR",
+      user: { login: "author" },
+      _mergeable: "CONFLICTING",
+      _comments: [
+        { user: { login: "github-actions[bot]", type: "Bot" }, body: "CI passed" },
+        { user: { login: "codecov[bot]", type: "Bot" }, body: "Coverage report" },
+      ],
+    }];
+
+    // Step 1: Compute attention labels (happens in poll-service)
+    const labeled = computeAttentionLabels(items, {});
+    
+    assert.strictEqual(labeled[0]._attention_label, "Conflicts");
+    assert.strictEqual(labeled[0]._has_attention, true);
+
+    // Step 2: Evaluate readiness with require_attention config
+    const config = {
+      readiness: {
+        require_attention: true,
+      },
+    };
+    const result = evaluateReadiness(labeled[0], config);
+
+    assert.strictEqual(result.ready, true, "PR with conflicts should be ready even with only bot comments");
+  });
+
+  it("PR with human feedback is ready when require_attention is set", () => {
+    const items = [{
+      number: 456,
+      title: "Another PR",
+      user: { login: "author" },
+      _mergeable: "MERGEABLE",
+      _comments: [
+        { user: { login: "reviewer", type: "User" }, body: "Please fix the tests" },
+      ],
+    }];
+
+    const labeled = computeAttentionLabels(items, {});
+    
+    assert.strictEqual(labeled[0]._attention_label, "Feedback");
+    assert.strictEqual(labeled[0]._has_attention, true);
+
+    const config = {
+      readiness: {
+        require_attention: true,
+      },
+    };
+    const result = evaluateReadiness(labeled[0], config);
+
+    assert.strictEqual(result.ready, true, "PR with human feedback should be ready");
+  });
+
+  it("PR with both conflicts and feedback shows combined label", () => {
+    const items = [{
+      number: 789,
+      title: "Complex PR",
+      user: { login: "author" },
+      _mergeable: "CONFLICTING",
+      _comments: [
+        { user: { login: "reviewer", type: "User" }, body: "Needs changes" },
+      ],
+    }];
+
+    const labeled = computeAttentionLabels(items, {});
+    
+    assert.strictEqual(labeled[0]._attention_label, "Conflicts+Feedback");
+    assert.strictEqual(labeled[0]._has_attention, true);
+
+    const config = {
+      readiness: {
+        require_attention: true,
+      },
+    };
+    const result = evaluateReadiness(labeled[0], config);
+
+    assert.strictEqual(result.ready, true);
+  });
+
+  it("PR without conflicts or feedback is NOT ready when require_attention is set", () => {
+    const items = [{
+      number: 999,
+      title: "Clean PR",
+      user: { login: "author" },
+      _mergeable: "MERGEABLE",
+      _comments: [
+        { user: { login: "github-actions[bot]", type: "Bot" }, body: "CI passed" },
+      ],
+    }];
+
+    const labeled = computeAttentionLabels(items, {});
+    
+    assert.strictEqual(labeled[0]._attention_label, "PR");
+    assert.strictEqual(labeled[0]._has_attention, false);
+
+    const config = {
+      readiness: {
+        require_attention: true,
+      },
+    };
+    const result = evaluateReadiness(labeled[0], config);
+
+    assert.strictEqual(result.ready, false, "PR without attention conditions should NOT be ready");
+    assert.ok(result.reason.includes("no attention needed"), "Should have appropriate reason");
+  });
+
+  it("PR with only bot comments is NOT ready when require_attention is NOT set", () => {
+    // Without require_attention, the strict bot check applies
+    const pr = {
+      number: 111,
+      title: "Test",
+      user: { login: "author" },
+      _comments: [
+        { user: { login: "github-actions[bot]", type: "Bot" }, body: "CI passed" },
+      ],
+    };
+
+    const config = {}; // No require_attention
+
+    const result = evaluateReadiness(pr, config);
+
+    assert.strictEqual(result.ready, false, "Without require_attention, bot-only comments should fail");
+    assert.ok(result.reason.includes("bot"), "Should mention bot in reason");
+  });
+});
+
+describe("integration: worktree creation with worktree_name", () => {
+  let mockServer;
+
+  afterEach(async () => {
+    if (mockServer) {
+      await mockServer.close();
+      mockServer = null;
+    }
+  });
+
+  it("executeAction creates worktree when worktree_name is set but project has no sandboxes", async () => {
+    let worktreeListCalled = false;
+    let worktreeCreateCalled = false;
+    let createdWorktreeName = null;
+    let sessionCreated = false;
+    let sessionDirectory = null;
+
+    mockServer = await createMockServer({
+      // Project has no sandboxes
+      "GET /project": () => ({
+        body: [{ id: "proj_1", worktree: "/proj", sandboxes: [], time: { created: 1 } }],
+      }),
+      "GET /project/current": () => ({
+        body: { id: "proj_1", worktree: "/proj", sandboxes: [], time: { created: 1 } },
+      }),
+      // No existing worktrees
+      "GET /experimental/worktree": () => {
+        worktreeListCalled = true;
+        return { body: [] };
+      },
+      // Worktree creation
+      "POST /experimental/worktree": (req) => {
+        worktreeCreateCalled = true;
+        createdWorktreeName = req.body?.name;
+        return {
+          body: {
+            name: req.body?.name || "new-wt",
+            directory: `/worktree/${req.body?.name || "new-wt"}`,
+          },
+        };
+      },
+      // No existing sessions
+      "GET /session": () => ({ body: [] }),
+      "GET /session/status": () => ({ body: {} }),
+      // Session creation
+      "POST /session": (req) => {
+        sessionCreated = true;
+        // Extract directory from URL
+        const url = new URL(req.path, "http://localhost");
+        sessionDirectory = req.query?.directory;
+        return { body: { id: "ses_new" } };
+      },
+      "PATCH /session/ses_new": () => ({ body: {} }),
+      "POST /session/ses_new/message": () => ({ body: { success: true } }),
+    });
+
+    const result = await executeAction(
+      { number: 42, title: "Review PR" },
+      { 
+        path: "/proj", 
+        prompt: "review",
+        worktree_name: "pr-{number}", // This should trigger worktree creation
+      },
+      { discoverServer: async () => mockServer.url }
+    );
+
+    assert.ok(result.success, "Action should succeed");
+    assert.ok(worktreeListCalled, "Should check for existing worktrees");
+    assert.ok(worktreeCreateCalled, "Should create worktree when worktree_name is configured");
+    assert.strictEqual(createdWorktreeName, "pr-42", "Should expand worktree_name template");
+    assert.ok(sessionCreated, "Should create session");
+    assert.strictEqual(sessionDirectory, "/worktree/pr-42", "Session should be in worktree directory");
+  });
+
+  it("reuses stored directory when reprocessing same item", async () => {
+    // This tests the scenario where:
+    // 1. Item was processed before, worktree created with random name (e.g., "calm-wizard")
+    // 2. Item triggers again (e.g., new feedback)
+    // 3. We should reuse the stored directory, not create a new worktree
+    
+    let worktreeListCalled = false;
+    let worktreeCreateCalled = false;
+    let sessionDirectory = null;
+    
+    // Existing worktree has a random name, not "pr-42"
+    const existingWorktreeDir = "/worktree/calm-wizard";
+    
+    const mockServer = await createMockServer({
+      "GET /experimental/worktree": () => {
+        worktreeListCalled = true;
+        // Return existing worktree with random name
+        return { body: [existingWorktreeDir] };
+      },
+      "POST /experimental/worktree": () => {
+        worktreeCreateCalled = true;
+        return { body: { name: "pr-42", directory: "/worktree/pr-42" } };
+      },
+      "GET /session": () => ({ body: [] }),
+      "GET /session/status": () => ({ body: {} }),
+      "POST /session": (req) => {
+        sessionDirectory = req.query?.directory;
+        return { body: { id: "ses_reprocess" } };
+      },
+      "PATCH /session/ses_reprocess": () => ({ body: {} }),
+      "POST /session/ses_reprocess/message": () => ({ body: { success: true } }),
+    });
+
+    // Simulate reprocessing with a stored directory from previous run
+    const result = await executeAction(
+      { number: 42, title: "Review PR" },
+      { 
+        path: "/proj", 
+        prompt: "review",
+        worktree_name: "pr-{number}",
+        // This is the key: pass the directory we used last time
+        existing_directory: existingWorktreeDir,
+      },
+      { discoverServer: async () => mockServer.url }
+    );
+
+    assert.ok(result.success, "Action should succeed");
+    // Should NOT create a new worktree since we have existing_directory
+    assert.strictEqual(worktreeCreateCalled, false, "Should NOT create new worktree when existing_directory provided");
+    // Session should be created in the existing directory
+    assert.strictEqual(sessionDirectory, existingWorktreeDir, "Session should use existing directory");
+  });
+});

package/test/unit/actions.test.js

@@ -830,6 +830,133 @@ Check for bugs and security issues.`;
       assert.ok(result.command.includes(tempDir), 
         'Should use base directory when no worktree workflow detected');
     });
+
+    test('creates worktree when worktree_name configured but no existing sandboxes (dry run)', async () => {
+      const { executeAction } = await import('../../service/actions.js');
+      
+      const item = { number: 123, title: 'Review PR' };
+      const config = {
+        path: tempDir,
+        prompt: 'review',
+        // worktree_name without worktree: 'new' - preset pattern
+        worktree_name: 'pr-{number}'
+      };
+      
+      // Mock server discovery
+      const mockDiscoverServer = async () => 'http://localhost:4096';
+      
+      let worktreeListCalled = false;
+      let worktreeCreateCalled = false;
+      let createdWorktreeName = null;
+      
+      const mockFetch = async (url, opts) => {
+        // Worktree list endpoint - no existing worktrees
+        if (url.startsWith('http://localhost:4096/experimental/worktree') && !opts?.method) {
+          worktreeListCalled = true;
+          return {
+            ok: true,
+            json: async () => []
+          };
+        }
+        // Worktree creation endpoint
+        if (url.startsWith('http://localhost:4096/experimental/worktree') && opts?.method === 'POST') {
+          worktreeCreateCalled = true;
+          const body = JSON.parse(opts.body);
+          createdWorktreeName = body.name;
+          return {
+            ok: true,
+            json: async () => ({
+              name: body.name,
+              branch: `opencode/${body.name}`,
+              directory: `/data/worktree/proj/${body.name}`
+            })
+          };
+        }
+        return { ok: false, text: async () => 'Not found' };
+      };
+      
+      const result = await executeAction(item, config, { 
+        dryRun: true,
+        discoverServer: mockDiscoverServer,
+        fetch: mockFetch
+      });
+      
+      assert.ok(result.dryRun);
+      assert.ok(worktreeListCalled, 'Should check for existing worktrees');
+      assert.ok(worktreeCreateCalled, 'Should create worktree when worktree_name is configured');
+      assert.strictEqual(createdWorktreeName, 'pr-123', 'Should expand worktree_name template');
+      assert.ok(result.command.includes('/data/worktree/proj/pr-123'), 
+        'Should use new worktree directory');
+    });
+
+    test('uses existing_directory without creating new worktree', async () => {
+      const { executeAction } = await import('../../service/actions.js');
+      
+      const item = { number: 123, title: 'Review PR #123' };
+      const config = {
+        path: '/data/proj',
+        prompt: 'review',
+        worktree_name: 'pr-{number}',
+        // This is the key - pass an existing directory from a previous run
+        existing_directory: '/data/worktree/calm-wizard',
+      };
+      
+      const mockDiscoverServer = async () => 'http://localhost:4096';
+      
+      let worktreeListCalled = false;
+      let worktreeCreateCalled = false;
+      let sessionDirectory = null;
+      
+      const mockFetch = async (url, opts) => {
+        const urlObj = new URL(url);
+        
+        // Track if worktree endpoints are called (they shouldn't be)
+        if (urlObj.pathname === '/experimental/worktree') {
+          if (opts?.method === 'POST') {
+            worktreeCreateCalled = true;
+          } else {
+            worktreeListCalled = true;
+          }
+          return { ok: true, json: async () => [] };
+        }
+        
+        // No existing sessions
+        if (urlObj.pathname === '/session' && !opts?.method) {
+          return { ok: true, json: async () => [] };
+        }
+        if (urlObj.pathname === '/session/status') {
+          return { ok: true, json: async () => ({}) };
+        }
+        
+        // Session creation - capture the directory
+        if (urlObj.pathname === '/session' && opts?.method === 'POST') {
+          sessionDirectory = urlObj.searchParams.get('directory');
+          return { ok: true, json: async () => ({ id: 'ses_test' }) };
+        }
+        
+        // Other session endpoints
+        if (urlObj.pathname.includes('/session/')) {
+          return { ok: true, json: async () => ({}) };
+        }
+        
+        return { ok: false, text: async () => 'Not found' };
+      };
+      
+      const result = await executeAction(item, config, { 
+        discoverServer: mockDiscoverServer,
+        fetch: mockFetch
+      });
+      
+      assert.ok(result.success);
+      // Should NOT call worktree endpoints when existing_directory is provided
+      assert.strictEqual(worktreeListCalled, false, 'Should NOT list worktrees');
+      assert.strictEqual(worktreeCreateCalled, false, 'Should NOT create worktree');
+      // Should use the existing directory
+      assert.strictEqual(sessionDirectory, '/data/worktree/calm-wizard', 
+        'Should use existing_directory for session');
+      assert.strictEqual(result.directory, '/data/worktree/calm-wizard',
+        'Result should include directory');
+    });
   });
 
   describe('createSessionViaApi', () => {
@@ -1534,4 +1661,276 @@ Check for bugs and security issues.`;
       assert.strictEqual(sessionCreated, true, 'Should create new session directly');
     });
   });
+
+  describe('buildSessionName', () => {
+    test('expands template with item fields', async () => {
+      const { buildSessionName } = await import('../../service/actions.js');
+      
+      const template = 'Review: {title}';
+      const item = { title: 'Fix mobile overflow', number: 123 };
+      
+      const result = buildSessionName(template, item);
+      
+      assert.strictEqual(result, 'Review: Fix mobile overflow');
+    });
+
+    test('handles nested field references', async () => {
+      const { buildSessionName } = await import('../../service/actions.js');
+      
+      const template = '{repository.name} #{number}';
+      const item = { repository: { name: 'my-repo' }, number: 456 };
+      
+      const result = buildSessionName(template, item);
+      
+      assert.strictEqual(result, 'my-repo #456');
+    });
+
+    test('preserves placeholders for missing fields', async () => {
+      const { buildSessionName } = await import('../../service/actions.js');
+      
+      const template = '{label}: {title}';
+      const item = { title: 'Fix bug' }; // no label field
+      
+      const result = buildSessionName(template, item);
+      
+      assert.strictEqual(result, '{label}: Fix bug');
+    });
+
+    test('handles attention label pattern', async () => {
+      const { buildSessionName } = await import('../../service/actions.js');
+      
+      const template = '{_attention_label}: {title}';
+      const item = { _attention_label: 'Conflicts + Feedback', title: 'Update API' };
+      
+      const result = buildSessionName(template, item);
+      
+      assert.strictEqual(result, 'Conflicts + Feedback: Update API');
+    });
+  });
+
+  describe('listSessions', () => {
+    test('fetches sessions from server with directory filter', async () => {
+      const { listSessions } = await import('../../service/actions.js');
+      
+      let capturedUrl = '';
+      const mockFetch = async (url) => {
+        capturedUrl = url;
+        return {
+          ok: true,
+          json: async () => [
+            { id: 'ses_1', title: 'Session 1' },
+            { id: 'ses_2', title: 'Session 2' },
+          ],
+        };
+      };
+      
+      const result = await listSessions('http://localhost:4096', {
+        directory: '/Users/test/code/project',
+        fetch: mockFetch,
+      });
+      
+      assert.ok(capturedUrl.includes('directory='));
+      assert.ok(capturedUrl.includes(encodeURIComponent('/Users/test/code/project')));
+      assert.ok(capturedUrl.includes('roots=true'));
+      assert.strictEqual(result.length, 2);
+    });
+
+    test('returns empty array on server error', async () => {
+      const { listSessions } = await import('../../service/actions.js');
+      
+      const mockFetch = async () => ({
+        ok: false,
+        status: 500,
+      });
+      
+      const result = await listSessions('http://localhost:4096', { fetch: mockFetch });
+      
+      assert.deepStrictEqual(result, []);
+    });
+
+    test('returns empty array on network error', async () => {
+      const { listSessions } = await import('../../service/actions.js');
+      
+      const mockFetch = async () => {
+        throw new Error('Network error');
+      };
+      
+      const result = await listSessions('http://localhost:4096', { fetch: mockFetch });
+      
+      assert.deepStrictEqual(result, []);
+    });
+
+    test('returns empty array when response is not an array', async () => {
+      const { listSessions } = await import('../../service/actions.js');
+      
+      const mockFetch = async () => ({
+        ok: true,
+        json: async () => ({ error: 'unexpected format' }),
+      });
+      
+      const result = await listSessions('http://localhost:4096', { fetch: mockFetch });
+      
+      assert.deepStrictEqual(result, []);
+    });
+  });
+
+  describe('getSessionStatuses', () => {
+    test('fetches session statuses from server', async () => {
+      const { getSessionStatuses } = await import('../../service/actions.js');
+      
+      const mockFetch = async () => ({
+        ok: true,
+        json: async () => ({
+          'ses_1': { type: 'busy' },
+          'ses_2': { type: 'idle' },
+        }),
+      });
+      
+      const result = await getSessionStatuses('http://localhost:4096', { fetch: mockFetch });
+      
+      assert.strictEqual(result['ses_1'].type, 'busy');
+      assert.strictEqual(result['ses_2'].type, 'idle');
+    });
+
+    test('returns empty object on server error', async () => {
+      const { getSessionStatuses } = await import('../../service/actions.js');
+      
+      const mockFetch = async () => ({
+        ok: false,
+        status: 500,
+      });
+      
+      const result = await getSessionStatuses('http://localhost:4096', { fetch: mockFetch });
+      
+      assert.deepStrictEqual(result, {});
+    });
+
+    test('returns empty object on network error', async () => {
+      const { getSessionStatuses } = await import('../../service/actions.js');
+      
+      const mockFetch = async () => {
+        throw new Error('Connection refused');
+      };
+      
+      const result = await getSessionStatuses('http://localhost:4096', { fetch: mockFetch });
+      
+      assert.deepStrictEqual(result, {});
+    });
+  });
+
+  describe('findReusableSession', () => {
+    test('finds best idle session from list', async () => {
+      const { findReusableSession } = await import('../../service/actions.js');
+      
+      const mockFetch = async (url) => {
+        if (url.includes('/session/status')) {
+          return {
+            ok: true,
+            json: async () => ({
+              'ses_busy': { type: 'busy' },
+              // ses_idle not in status map = idle
+            }),
+          };
+        }
+        // GET /session
+        return {
+          ok: true,
+          json: async () => [
+            { id: 'ses_busy', time: { created: 1000, updated: 3000 } },
+            { id: 'ses_idle', time: { created: 1000, updated: 2000 } },
+          ],
+        };
+      };
+      
+      const result = await findReusableSession('http://localhost:4096', '/test/dir', { fetch: mockFetch });
+      
+      assert.strictEqual(result.id, 'ses_idle');
+    });
+
+    test('returns null when all sessions are archived', async () => {
+      const { findReusableSession } = await import('../../service/actions.js');
+      
+      const mockFetch = async (url) => {
+        if (url.includes('/session/status')) {
+          return { ok: true, json: async () => ({}) };
+        }
+        return {
+          ok: true,
+          json: async () => [
+            { id: 'ses_1', time: { created: 1000, updated: 2000, archived: 3000 } },
+            { id: 'ses_2', time: { created: 1000, updated: 2000, archived: 3000 } },
+          ],
+        };
+      };
+      
+      const result = await findReusableSession('http://localhost:4096', '/test/dir', { fetch: mockFetch });
+      
+      assert.strictEqual(result, null);
+    });
+
+    test('returns null when no sessions exist', async () => {
+      const { findReusableSession } = await import('../../service/actions.js');
+      
+      const mockFetch = async (url) => {
+        if (url.includes('/session/status')) {
+          return { ok: true, json: async () => ({}) };
+        }
+        return { ok: true, json: async () => [] };
+      };
+      
+      const result = await findReusableSession('http://localhost:4096', '/test/dir', { fetch: mockFetch });
+      
+      assert.strictEqual(result, null);
+    });
+
+    test('prefers most recently updated idle session', async () => {
+      const { findReusableSession } = await import('../../service/actions.js');
+      
+      const mockFetch = async (url) => {
+        if (url.includes('/session/status')) {
+          return { ok: true, json: async () => ({}) }; // all idle
+        }
+        return {
+          ok: true,
+          json: async () => [
+            { id: 'ses_old', time: { created: 1000, updated: 2000 } },
+            { id: 'ses_new', time: { created: 1000, updated: 5000 } },
+            { id: 'ses_mid', time: { created: 1000, updated: 3000 } },
+          ],
+        };
+      };
+      
+      const result = await findReusableSession('http://localhost:4096', '/test/dir', { fetch: mockFetch });
+      
+      assert.strictEqual(result.id, 'ses_new');
+    });
+
+    test('falls back to busy session when no idle available', async () => {
+      const { findReusableSession } = await import('../../service/actions.js');
+      
+      const mockFetch = async (url) => {
+        if (url.includes('/session/status')) {
+          return {
+            ok: true,
+            json: async () => ({
+              'ses_busy1': { type: 'busy' },
+              'ses_busy2': { type: 'retry' },
+            }),
+          };
+        }
+        return {
+          ok: true,
+          json: async () => [
+            { id: 'ses_busy1', time: { created: 1000, updated: 2000 } },
+            { id: 'ses_busy2', time: { created: 1000, updated: 4000 } },
+          ],
+        };
+      };
+      
+      const result = await findReusableSession('http://localhost:4096', '/test/dir', { fetch: mockFetch });
+      
+      // Should return most recently updated busy session
+      assert.strictEqual(result.id, 'ses_busy2');
+    });
+  });
 });

package/test/unit/poller.test.js

@@ -136,6 +136,29 @@ describe('poller.js', () => {
       assert.strictEqual(poller.getProcessedIds().length, 1);
     });
 
+    test('getProcessedMeta returns stored metadata', async () => {
+      const { createPoller } = await import('../../service/poller.js');
+      
+      const poller = createPoller({ stateFile });
+      
+      // Not processed yet
+      assert.strictEqual(poller.getProcessedMeta('item-1'), null);
+      
+      // Mark as processed with metadata including directory
+      poller.markProcessed('item-1', { 
+        source: 'test',
+        directory: '/worktree/pr-123',
+        itemState: 'open',
+      });
+      
+      const meta = poller.getProcessedMeta('item-1');
+      assert.ok(meta);
+      assert.strictEqual(meta.source, 'test');
+      assert.strictEqual(meta.directory, '/worktree/pr-123');
+      assert.strictEqual(meta.itemState, 'open');
+      assert.ok(meta.processedAt); // Should have timestamp
+    });
+
     test('persists state across instances', async () => {
       const { createPoller } = await import('../../service/poller.js');
       
@@ -1059,4 +1082,165 @@ describe('poller.js', () => {
       assert.strictEqual(result[0]._has_attention, false);
     });
   });
+
+  describe('enrichItemsWithComments', () => {
+    test('skips enrichment when filter_bot_comments is not set', async () => {
+      const { enrichItemsWithComments } = await import('../../service/poller.js');
+      
+      const items = [{ number: 1, comments: 5, repository_full_name: 'org/repo' }];
+      const source = { tool: { command: ['gh', 'search', 'prs'] } }; // no filter_bot_comments
+      
+      const result = await enrichItemsWithComments(items, source);
+      
+      // Items returned unchanged, no _comments added
+      assert.strictEqual(result.length, 1);
+      assert.strictEqual(result[0]._comments, undefined);
+    });
+
+    test('skips enrichment for non-GitHub sources', async () => {
+      const { enrichItemsWithComments } = await import('../../service/poller.js');
+      
+      const items = [{ number: 1, comments: 5, repository_full_name: 'org/repo' }];
+      const source = { 
+        filter_bot_comments: true,
+        tool: { mcp: 'linear', name: 'list_issues' } // not GitHub
+      };
+      
+      const result = await enrichItemsWithComments(items, source);
+      
+      // Items returned unchanged
+      assert.strictEqual(result.length, 1);
+      assert.strictEqual(result[0]._comments, undefined);
+    });
+
+    test('skips items with zero comments', async () => {
+      const { enrichItemsWithComments } = await import('../../service/poller.js');
+      
+      const items = [
+        { number: 1, comments: 0, repository_full_name: 'org/repo' },
+        { number: 2, comments: 0, repository_full_name: 'org/repo' }
+      ];
+      const source = { 
+        filter_bot_comments: true,
+        tool: { command: ['gh', 'search', 'prs'] }
+      };
+      
+      const result = await enrichItemsWithComments(items, source);
+      
+      // Items returned unchanged (no API calls made)
+      assert.strictEqual(result.length, 2);
+      assert.strictEqual(result[0]._comments, undefined);
+      assert.strictEqual(result[1]._comments, undefined);
+    });
+
+    test('identifies GitHub MCP source correctly', async () => {
+      const { enrichItemsWithComments } = await import('../../service/poller.js');
+      
+      const items = [{ number: 1, comments: 0, repository_full_name: 'org/repo' }];
+      const source = { 
+        filter_bot_comments: true,
+        tool: { mcp: 'github', name: 'search_issues' }
+      };
+      
+      // Should not throw, just skip due to 0 comments
+      const result = await enrichItemsWithComments(items, source);
+      assert.strictEqual(result.length, 1);
+    });
+
+    test('identifies GitHub CLI source correctly', async () => {
+      const { enrichItemsWithComments } = await import('../../service/poller.js');
+      
+      const items = [{ number: 1, comments: 0, repository_full_name: 'org/repo' }];
+      const source = { 
+        filter_bot_comments: true,
+        tool: { command: ['gh', 'search', 'issues', '--json', 'number'] }
+      };
+      
+      // Should not throw, just skip due to 0 comments
+      const result = await enrichItemsWithComments(items, source);
+      assert.strictEqual(result.length, 1);
+    });
+  });
+
+  describe('enrichItemsWithMergeable', () => {
+    test('skips enrichment when enrich_mergeable is not set', async () => {
+      const { enrichItemsWithMergeable } = await import('../../service/poller.js');
+      
+      const items = [{ number: 1, repository_full_name: 'org/repo' }];
+      const source = {}; // no enrich_mergeable
+      
+      const result = await enrichItemsWithMergeable(items, source);
+      
+      // Items returned unchanged
+      assert.strictEqual(result.length, 1);
+      assert.strictEqual(result[0]._mergeable, undefined);
+    });
+
+    test('skips items without repository info', async () => {
+      const { enrichItemsWithMergeable } = await import('../../service/poller.js');
+      
+      const items = [
+        { number: 1 }, // no repository_full_name
+        { repository_full_name: 'org/repo' } // no number
+      ];
+      const source = { enrich_mergeable: true };
+      
+      const result = await enrichItemsWithMergeable(items, source);
+      
+      // Items returned unchanged (no API calls made for invalid items)
+      assert.strictEqual(result.length, 2);
+      assert.strictEqual(result[0]._mergeable, undefined);
+      assert.strictEqual(result[1]._mergeable, undefined);
+    });
+
+    test('accepts repository.nameWithOwner as alternative field', async () => {
+      const { enrichItemsWithMergeable } = await import('../../service/poller.js');
+      
+      const items = [
+        { number: 1, repository: { nameWithOwner: 'org/repo' } }
+      ];
+      const source = { enrich_mergeable: true };
+      
+      // This will attempt the API call (which may fail in test env)
+      // but it should not skip due to missing repo info
+      const result = await enrichItemsWithMergeable(items, source);
+      
+      // Should have attempted enrichment (result may have _mergeable: null on CLI error)
+      assert.strictEqual(result.length, 1);
+      // The item should have been processed (not skipped)
+      assert.ok('_mergeable' in result[0] || result[0]._mergeable === undefined);
+    });
+  });
+
+  describe('fetchGitHubComments', () => {
+    test('returns empty array when repository_full_name is missing', async () => {
+      const { fetchGitHubComments } = await import('../../service/poller.js');
+      
+      const item = { number: 123 }; // no repository_full_name
+      
+      const result = await fetchGitHubComments(item);
+      
+      assert.deepStrictEqual(result, []);
+    });
+
+    test('returns empty array when number is missing', async () => {
+      const { fetchGitHubComments } = await import('../../service/poller.js');
+      
+      const item = { repository_full_name: 'org/repo' }; // no number
+      
+      const result = await fetchGitHubComments(item);
+      
+      assert.deepStrictEqual(result, []);
+    });
+
+    test('returns empty array when owner/repo cannot be parsed', async () => {
+      const { fetchGitHubComments } = await import('../../service/poller.js');
+      
+      const item = { repository_full_name: 'invalid', number: 123 }; // no slash
+      
+      const result = await fetchGitHubComments(item);
+      
+      assert.deepStrictEqual(result, []);
+    });
+  });
 });

package/test/unit/readiness.test.js

@@ -675,5 +675,56 @@ describe('readiness.js', () => {
       
       assert.strictEqual(result.ready, true);
     });
+
+    test('passes when PR has conflicts but only bot comments (require_attention skips bot check)', async () => {
+      const { evaluateReadiness } = await import('../../service/readiness.js');
+      
+      // This is the key scenario: PR has merge conflicts but no human feedback
+      // With require_attention, the checkBotComments check should be skipped
+      // because checkAttention handles the combined logic via _has_attention
+      const pr = {
+        number: 123,
+        title: 'Test PR',
+        user: { login: 'author' },
+        _mergeable: 'CONFLICTING',
+        _comments: [
+          { user: { login: 'github-actions[bot]', type: 'Bot' }, body: 'CI passed' },
+        ],
+        _has_attention: true,
+        _attention_label: 'Conflicts'
+      };
+      const config = {
+        readiness: {
+          require_attention: true
+        }
+      };
+      
+      const result = evaluateReadiness(pr, config);
+      
+      // Should be ready because it has conflicts (via _has_attention)
+      // even though it only has bot comments
+      assert.strictEqual(result.ready, true);
+    });
+
+    test('still fails bot check when require_attention is NOT configured', async () => {
+      const { evaluateReadiness } = await import('../../service/readiness.js');
+      
+      // Without require_attention, the strict bot check applies
+      const pr = {
+        number: 123,
+        title: 'Test PR',
+        user: { login: 'author' },
+        _comments: [
+          { user: { login: 'github-actions[bot]', type: 'Bot' }, body: 'CI passed' },
+        ]
+      };
+      const config = {};
+      
+      const result = evaluateReadiness(pr, config);
+      
+      // Should fail because no human feedback and no require_attention bypass
+      assert.strictEqual(result.ready, false);
+      assert.ok(result.reason.includes('bot'));
+    });
   });
 });

package/test/unit/server.test.js

@@ -86,5 +86,101 @@ describe('service/server.js', () => {
       
       assert.strictEqual(res.status, 404);
     });
+
+    test('returns 404 for POST to health', async () => {
+      const { startService } = await import('../../service/server.js');
+      
+      service = await startService({ 
+        httpPort: 0,
+        enablePolling: false 
+      });
+      
+      const port = service.httpServer.address().port;
+      const res = await fetch(`http://localhost:${port}/health`, {
+        method: 'POST',
+        body: '{}'
+      });
+      
+      assert.strictEqual(res.status, 404);
+    });
+  });
+
+  describe('startService and stopService', () => {
+    test('starts and stops cleanly', async () => {
+      const { startService, stopService } = await import('../../service/server.js');
+      
+      const localService = await startService({ 
+        httpPort: 0,
+        enablePolling: false 
+      });
+      
+      assert.ok(localService.httpServer, 'Should have httpServer');
+      assert.strictEqual(localService.pollingState, null, 'Should not have pollingState when disabled');
+      
+      const port = localService.httpServer.address().port;
+      assert.ok(port > 0, 'Should have valid port');
+      
+      await stopService(localService);
+      
+      // Server should be closed - attempting to fetch should fail
+      try {
+        await fetch(`http://localhost:${port}/health`, { signal: AbortSignal.timeout(500) });
+        assert.fail('Fetch should have failed after stop');
+      } catch (err) {
+        // Expected - connection refused or timeout
+        assert.ok(err.message.includes('fetch failed') || err.name === 'TimeoutError' || err.name === 'AbortError');
+      }
+    });
+
+    test('handles stopService on already stopped service', async () => {
+      const { startService, stopService } = await import('../../service/server.js');
+      
+      const localService = await startService({ 
+        httpPort: 0,
+        enablePolling: false 
+      });
+      
+      // Stop twice - should not throw
+      await stopService(localService);
+      await stopService(localService);
+    });
+
+    test('starts with enablePolling=false when no config exists', async () => {
+      const { startService, stopService } = await import('../../service/server.js');
+      
+      const localService = await startService({ 
+        httpPort: 0,
+        enablePolling: true, // enabled but config doesn't exist
+        reposConfig: '/nonexistent/config.yaml'
+      });
+      
+      // Should start without polling since config doesn't exist
+      assert.ok(localService.httpServer);
+      assert.strictEqual(localService.pollingState, null);
+      
+      await stopService(localService);
+    });
+  });
+
+  describe('CORS headers', () => {
+    test('OPTIONS includes all required headers', async () => {
+      const { startService } = await import('../../service/server.js');
+      
+      service = await startService({ 
+        httpPort: 0,
+        enablePolling: false 
+      });
+      
+      const port = service.httpServer.address().port;
+      const res = await fetch(`http://localhost:${port}/anything`, {
+        method: 'OPTIONS'
+      });
+      
+      assert.strictEqual(res.status, 204);
+      assert.strictEqual(res.headers.get('access-control-allow-origin'), '*');
+      assert.strictEqual(res.headers.get('access-control-allow-methods'), 'GET, OPTIONS');
+      assert.ok(res.headers.get('access-control-allow-headers').includes('Content-Type'));
+      assert.strictEqual(res.headers.get('access-control-max-age'), '86400');
+    });
   });
 });