opencode-pilot 0.20.2 → 0.20.4

package/package.json

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

package/service/actions.js

@@ -845,7 +845,15 @@ export async function executeAction(item, config, options = {}) {
   // 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 });

package/service/poll-service.js

@@ -50,6 +50,7 @@ export function buildActionConfigFromSource(source, repoConfig) {
     ...(source.agent && { agent: source.agent }),
     ...(source.model && { model: source.model }),
     ...(source.working_dir && { working_dir: source.working_dir }),
+    ...(source.worktree_name && { worktree_name: source.worktree_name }),
   };
 }
 

package/service/presets/github.yaml

@@ -24,6 +24,7 @@ my-issues:
   item:
     id: "{url}"
   repo: "{repository.nameWithOwner}"
+  worktree_name: "issue-{number}"
   session:
     name: "{title}"
 
@@ -35,6 +36,7 @@ review-requests:
     id: "{url}"
   repo: "{repository.nameWithOwner}"
   prompt: review
+  worktree_name: "pr-{number}"
   session:
     name: "Review: {title}"
 
@@ -47,6 +49,7 @@ my-prs-attention:
     id: "{url}"
   repo: "{repository.nameWithOwner}"
   prompt: review-feedback
+  worktree_name: "pr-{number}"
   session:
     # Dynamic name showing which conditions triggered (set by enrichment)
     name: "{_attention_label}: {title}"
@@ -56,7 +59,7 @@ my-prs-attention:
   readiness:
     # Require at least one attention condition (conflicts or human feedback)
     require_attention: true
-  # Reprocess when PR is updated
+  # Only reprocess when state changes (e.g., reopened)
+  # Note: updatedAt is NOT included - CI status changes would trigger reprocessing
   reprocess_on:
     - state
-    - updatedAt

package/service/presets/linear.yaml

@@ -21,5 +21,6 @@ my-issues:
     # teamId and assigneeId are required - user must provide
   item:
     id: "linear:{id}"
+  worktree_name: "{number}"
   session:
     name: "{title}"

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,217 @@ 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");
+  });
+});

package/test/unit/actions.test.js

@@ -830,6 +830,64 @@ 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');
+    });
   });
 
   describe('createSessionViaApi', () => {
@@ -1534,4 +1592,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/poll-service.test.js

@@ -154,6 +154,56 @@ sources:
       assert.strictEqual(config.agent, 'code');
     });
 
+    test('includes worktree_name from source config', async () => {
+      const { buildActionConfigFromSource } = await import('../../service/poll-service.js');
+      
+      const source = {
+        name: 'test-source',
+        worktree_name: 'pr-{number}'
+      };
+      const repoConfig = {
+        path: '~/code/default'
+      };
+      
+      const config = buildActionConfigFromSource(source, repoConfig);
+      
+      assert.strictEqual(config.worktree_name, 'pr-{number}');
+    });
+
+    test('worktree_name from source overrides repoConfig', async () => {
+      const { buildActionConfigFromSource } = await import('../../service/poll-service.js');
+      
+      const source = {
+        name: 'test-source',
+        worktree_name: 'pr-{number}'
+      };
+      const repoConfig = {
+        path: '~/code/default',
+        worktree_name: 'issue-{number}'  // Should be overridden
+      };
+      
+      const config = buildActionConfigFromSource(source, repoConfig);
+      
+      assert.strictEqual(config.worktree_name, 'pr-{number}');
+    });
+
+    test('falls back to repoConfig worktree_name when source has none', async () => {
+      const { buildActionConfigFromSource } = await import('../../service/poll-service.js');
+      
+      const source = {
+        name: 'test-source'
+        // No worktree_name
+      };
+      const repoConfig = {
+        path: '~/code/default',
+        worktree_name: 'issue-{number}'
+      };
+      
+      const config = buildActionConfigFromSource(source, repoConfig);
+      
+      assert.strictEqual(config.worktree_name, 'issue-{number}');
+    });
+
   });
 
   describe('per-item repo resolution', () => {

package/test/unit/poller.test.js

@@ -1059,4 +1059,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/repo-config.test.js

@@ -874,6 +874,45 @@ sources:
       assert.strictEqual(sources[0].session.name, '{title}', 'linear preset should use title');
     });
 
+    test('github presets include worktree_name for sandbox reuse', async () => {
+      writeFileSync(configPath, `
+sources:
+  - preset: github/my-issues
+  - preset: github/review-requests
+  - preset: github/my-prs-attention
+`);
+
+      const { loadRepoConfig, getSources } = await import('../../service/repo-config.js');
+      loadRepoConfig(configPath);
+      const sources = getSources();
+
+      // my-issues: worktree_name: "issue-{number}"
+      assert.strictEqual(sources[0].worktree_name, 'issue-{number}', 'my-issues should use issue-{number}');
+      
+      // review-requests: worktree_name: "pr-{number}"
+      assert.strictEqual(sources[1].worktree_name, 'pr-{number}', 'review-requests should use pr-{number}');
+      
+      // my-prs-attention: worktree_name: "pr-{number}"
+      assert.strictEqual(sources[2].worktree_name, 'pr-{number}', 'my-prs-attention should use pr-{number}');
+    });
+
+    test('linear preset includes worktree_name for sandbox reuse', async () => {
+      writeFileSync(configPath, `
+sources:
+  - preset: linear/my-issues
+    args:
+      teamId: "team-uuid"
+      assigneeId: "user-uuid"
+`);
+
+      const { loadRepoConfig, getSources } = await import('../../service/repo-config.js');
+      loadRepoConfig(configPath);
+      const sources = getSources();
+
+      // linear uses the issue identifier (e.g., "ABC-123")
+      assert.strictEqual(sources[0].worktree_name, '{number}', 'linear preset should use {number} (identifier)');
+    });
+
   });
 
   describe('shorthand syntax', () => {

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');
+    });
   });
 });