opencode-pilot 0.24.8 → 0.24.9

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.24.7.tar.gz"
-  sha256 "3d97d488ca8695f9785171e767b8a7a3eb65d2a8c5aca9eab3862b70cf6fc144"
+  url "https://github.com/athal7/opencode-pilot/archive/refs/tags/v0.24.8.tar.gz"
+  sha256 "23b550fd74fee8f2fd8c60c8358f67065ee77af921fdc3bc2ff26a6cfef68ae6"
   license "MIT"
 
   depends_on "node"

package/package.json

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

package/service/actions.js

@@ -639,26 +639,17 @@ export async function sendMessageToSession(serverUrl, sessionId, directory, prom
  * @param {string} directory - Working directory to match
  * @param {object} [options] - Options
  * @param {function} [options.fetch] - Custom fetch function (for testing)
- * @param {string} [options.projectDirectory] - Project directory for session lookup
- *   (used instead of directory when provided, so sessions created with the project
- *   directory are found instead of old worktree-scoped sessions)
  * @returns {Promise<object|null>} Session to reuse, or null
  */
 export async function findReusableSession(serverUrl, directory, options = {}) {
-  // Use project directory for session lookup when available.
-  // Sessions created with v0.24.7+ are scoped to the project directory,
-  // while messages use the worktree directory. Query the project directory
-  // to find correctly-scoped sessions.
-  const lookupDirectory = options.projectDirectory || directory;
-  
   // Get sessions for this directory
   const sessions = await listSessions(serverUrl, { 
-    directory: lookupDirectory, 
+    directory, 
     fetch: options.fetch 
   });
   
   if (sessions.length === 0) {
-    debug(`findReusableSession: no sessions found for ${lookupDirectory}`);
+    debug(`findReusableSession: no sessions found for ${directory}`);
     return null;
   }
   
@@ -666,11 +657,11 @@ export async function findReusableSession(serverUrl, directory, options = {}) {
   const activeSessions = sessions.filter(s => !isSessionArchived(s));
   
   if (activeSessions.length === 0) {
-    debug(`findReusableSession: all ${sessions.length} sessions are archived for ${lookupDirectory}`);
+    debug(`findReusableSession: all ${sessions.length} sessions are archived for ${directory}`);
     return null;
   }
   
-  debug(`findReusableSession: found ${activeSessions.length} active sessions for ${lookupDirectory}`);
+  debug(`findReusableSession: found ${activeSessions.length} active sessions for ${directory}`);
   
   // Get statuses to prefer idle sessions
   const statuses = await getSessionStatuses(serverUrl, { fetch: options.fetch });
@@ -891,14 +882,16 @@ async function executeInDirectory(serverUrl, cwd, item, config, options = {}, pr
     }
   }
   
-  // Check if we should try to reuse an existing session
+  // Check if we should try to reuse an existing session.
+  // Skip reuse when working in a worktree (projectDirectory differs from cwd),
+  // because querying by worktree dir finds old sessions with projectID "global",
+  // and querying by project dir finds unrelated sessions for other PRs.
+  // Each worktree should get its own correctly-scoped session.
   const reuseActiveSession = config.reuse_active_session !== false; // default true
+  const inWorktree = projectDirectory && projectDirectory !== cwd;
   
-  if (reuseActiveSession && !options.dryRun) {
-    const existingSession = await findReusableSession(serverUrl, cwd, { 
-      fetch: options.fetch,
-      projectDirectory: projectDirectory,
-    });
+  if (reuseActiveSession && !inWorktree && !options.dryRun) {
+    const existingSession = await findReusableSession(serverUrl, cwd, { fetch: options.fetch });
     
     if (existingSession) {
       debug(`executeInDirectory: found reusable session ${existingSession.id} for ${cwd}`);

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

@@ -622,14 +622,15 @@ describe("integration: worktree creation with worktree_name", () => {
     assert.strictEqual(sessionDirectory, "/proj", "Session should be scoped to project directory");
   });
 
-  it("session reuse queries by project directory, not worktree directory", async () => {
-    // This tests the key fix: when reprocessing an item with a worktree,
-    // findReusableSession should query by the project directory (e.g., /proj)
-    // so it finds sessions created with correct scoping (v0.24.7+), rather
-    // than finding old sessions created with the worktree directory (projectID "global").
+  it("skips session reuse when working in a worktree", async () => {
+    // When working in a worktree (projectDirectory differs from cwd), session
+    // reuse is skipped entirely. Querying by worktree dir finds old sessions
+    // with projectID "global", querying by project dir finds unrelated sessions
+    // for other PRs. Each worktree should get its own correctly-scoped session.
     
-    let sessionQueryDirectory = null;
+    let sessionListQueried = false;
     let sessionCreated = false;
+    let sessionCreateDirectory = null;
     
     const existingWorktreeDir = "/worktree/calm-wizard";
     
@@ -643,25 +644,16 @@ describe("integration: worktree creation with worktree_name", () => {
       "GET /experimental/worktree": () => ({
         body: [existingWorktreeDir],
       }),
-      "GET /session": (req) => {
-        sessionQueryDirectory = req.directory;
-        // Return a session ONLY if queried by project directory
-        if (req.directory === "/proj") {
-          return {
-            body: [{ id: "ses_proj_scoped", directory: "/proj", time: { created: 1000, updated: 2000 } }],
-          };
-        }
-        // Old worktree-scoped sessions should NOT be found when querying by project dir
+      "GET /session": () => {
+        sessionListQueried = true;
         return { body: [] };
       },
       "GET /session/status": () => ({ body: {} }),
       "POST /session": (req) => {
         sessionCreated = true;
+        sessionCreateDirectory = req.query?.directory;
         return { body: { id: "ses_new" } };
       },
-      "PATCH /session/ses_proj_scoped": () => ({ body: {} }),
-      "POST /session/ses_proj_scoped/message": () => ({ body: { success: true } }),
-      "POST /session/ses_proj_scoped/command": () => ({ body: { success: true } }),
       "PATCH /session/ses_new": () => ({ body: {} }),
       "POST /session/ses_new/message": () => ({ body: { success: true } }),
       "POST /session/ses_new/command": () => ({ body: { success: true } }),
@@ -679,12 +671,13 @@ describe("integration: worktree creation with worktree_name", () => {
     );
 
     assert.ok(result.success, "Action should succeed");
-    // The session lookup should use the PROJECT directory, not the worktree directory
-    assert.strictEqual(sessionQueryDirectory, "/proj",
-      "findReusableSession should query by project directory, not worktree");
-    // Should reuse the project-scoped session, NOT create a new one
-    assert.strictEqual(result.sessionReused, true, "Should reuse the project-scoped session");
-    assert.strictEqual(sessionCreated, false, "Should NOT create a new session when project-scoped session exists");
+    // Should NOT query for existing sessions when in a worktree
+    assert.strictEqual(sessionListQueried, false,
+      "Should skip session reuse entirely when in a worktree");
+    // Should create a new session scoped to the project directory
+    assert.ok(sessionCreated, "Should create a new session");
+    assert.strictEqual(sessionCreateDirectory, "/proj",
+      "New session should be scoped to project directory");
   });
 });
 

package/test/unit/actions.test.js

@@ -2147,60 +2147,6 @@ Check for bugs and security issues.`;
       assert.strictEqual(result.id, 'ses_new');
     });
 
-    test('uses projectDirectory for session lookup when provided', async () => {
-      const { findReusableSession } = await import('../../service/actions.js');
-      
-      let queriedDirectory = null;
-      const mockFetch = async (url) => {
-        if (url.includes('/session/status')) {
-          return { ok: true, json: async () => ({}) };
-        }
-        // Capture the directory used in the session query
-        const urlObj = new URL(url);
-        queriedDirectory = urlObj.searchParams.get('directory');
-        return {
-          ok: true,
-          json: async () => [
-            { id: 'ses_proj', time: { created: 1000, updated: 2000 } },
-          ],
-        };
-      };
-      
-      const result = await findReusableSession('http://localhost:4096', '/worktree/pr-415', { 
-        fetch: mockFetch,
-        projectDirectory: '/home/user/code/odin',
-      });
-      
-      assert.strictEqual(result.id, 'ses_proj');
-      assert.strictEqual(queriedDirectory, '/home/user/code/odin',
-        'Should query sessions using projectDirectory, not the worktree directory');
-    });
-
-    test('falls back to directory when projectDirectory not provided', async () => {
-      const { findReusableSession } = await import('../../service/actions.js');
-      
-      let queriedDirectory = null;
-      const mockFetch = async (url) => {
-        if (url.includes('/session/status')) {
-          return { ok: true, json: async () => ({}) };
-        }
-        const urlObj = new URL(url);
-        queriedDirectory = urlObj.searchParams.get('directory');
-        return {
-          ok: true,
-          json: async () => [
-            { id: 'ses_1', time: { created: 1000, updated: 2000 } },
-          ],
-        };
-      };
-      
-      const result = await findReusableSession('http://localhost:4096', '/test/dir', { fetch: mockFetch });
-      
-      assert.strictEqual(result.id, 'ses_1');
-      assert.strictEqual(queriedDirectory, '/test/dir',
-        'Should query sessions using directory when projectDirectory not provided');
-    });
-
     test('falls back to busy session when no idle available', async () => {
       const { findReusableSession } = await import('../../service/actions.js');