opencode-pilot 0.24.9 → 0.24.10

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

package/package.json

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

package/service/actions.js

@@ -687,16 +687,17 @@ export async function findReusableSession(serverUrl, directory, options = {}) {
 export async function createSessionViaApi(serverUrl, directory, prompt, options = {}) {
   const fetchFn = options.fetch || fetch;
   const headerTimeout = options.headerTimeout || HEADER_TIMEOUT_MS;
-  // Use project directory for session creation (determines projectID in OpenCode).
-  // The working directory (which may be a worktree) is used for messages/commands.
   const projectDir = options.projectDirectory || directory;
   
   let session = null;
   
   try {
-    // Step 1: Create session scoped to the project directory
+    // Step 1: Create session with the working directory (may be a worktree).
+    // This sets the session's working directory so the agent operates in the
+    // correct location. For worktree sessions, the server may assign
+    // projectID 'global' since sandbox paths don't match project worktrees.
     const sessionUrl = new URL('/session', serverUrl);
-    sessionUrl.searchParams.set('directory', projectDir);
+    sessionUrl.searchParams.set('directory', directory);
     
     const createResponse = await fetchFn(sessionUrl.toString(), {
       method: 'POST',
@@ -712,14 +713,20 @@ export async function createSessionViaApi(serverUrl, directory, prompt, options
     session = await createResponse.json();
     debug(`createSessionViaApi: created session ${session.id} in ${directory}`);
     
-    // Step 2: Update session title if provided
-    if (options.title) {
+    // Step 2: Update session - always PATCH with project directory when it
+    // differs from the working directory (worktree case). This re-associates
+    // the session with the correct project so it appears in the UI.
+    // Also set the title if provided.
+    const needsProjectScoping = projectDir !== directory;
+    if (options.title || needsProjectScoping) {
       const updateUrl = new URL(`/session/${session.id}`, serverUrl);
       updateUrl.searchParams.set('directory', projectDir);
+      const patchBody = {};
+      if (options.title) patchBody.title = options.title;
       await fetchFn(updateUrl.toString(), {
         method: 'PATCH',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ title: options.title }),
+        body: JSON.stringify(patchBody),
       });
     }
     

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

@@ -564,9 +564,9 @@ describe("integration: worktree creation with worktree_name", () => {
     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");
-    // Session creation uses the project directory (for correct projectID scoping)
-    // The worktree path is used for messages/commands (file operations)
-    assert.strictEqual(sessionDirectory, "/proj", "Session should be scoped to project directory");
+    // Session creation uses the worktree directory (sets working directory)
+    // The PATCH with project directory re-associates it with the correct project
+    assert.strictEqual(sessionDirectory, "/worktree/pr-42", "Session should be created in worktree directory");
   });
 
   it("reuses stored directory when reprocessing same item", async () => {
@@ -618,8 +618,8 @@ describe("integration: worktree creation with worktree_name", () => {
     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 creation uses the project directory (for correct projectID scoping)
-    assert.strictEqual(sessionDirectory, "/proj", "Session should be scoped to project directory");
+    // Session creation uses the existing worktree directory (sets working directory)
+    assert.strictEqual(sessionDirectory, existingWorktreeDir, "Session should be created in existing worktree directory");
   });
 
   it("skips session reuse when working in a worktree", async () => {
@@ -631,6 +631,7 @@ describe("integration: worktree creation with worktree_name", () => {
     let sessionListQueried = false;
     let sessionCreated = false;
     let sessionCreateDirectory = null;
+    let patchDirectory = null;
     
     const existingWorktreeDir = "/worktree/calm-wizard";
     
@@ -654,7 +655,10 @@ describe("integration: worktree creation with worktree_name", () => {
         sessionCreateDirectory = req.query?.directory;
         return { body: { id: "ses_new" } };
       },
-      "PATCH /session/ses_new": () => ({ body: {} }),
+      "PATCH /session/ses_new": (req) => {
+        patchDirectory = req.query?.directory;
+        return { body: {} };
+      },
       "POST /session/ses_new/message": () => ({ body: { success: true } }),
       "POST /session/ses_new/command": () => ({ body: { success: true } }),
     });
@@ -674,10 +678,13 @@ describe("integration: worktree creation with worktree_name", () => {
     // 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
+    // Should create a new session with the worktree directory (correct working dir)
     assert.ok(sessionCreated, "Should create a new session");
-    assert.strictEqual(sessionCreateDirectory, "/proj",
-      "New session should be scoped to project directory");
+    assert.strictEqual(sessionCreateDirectory, existingWorktreeDir,
+      "Session should be created in worktree directory");
+    // PATCH re-associates the session with the correct project
+    assert.strictEqual(patchDirectory, "/proj",
+      "PATCH should use project directory for correct project scoping");
   });
 });
 

package/test/unit/actions.test.js

@@ -981,9 +981,9 @@ Check for bugs and security issues.`;
       // 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');
-      // Session creation uses project directory (for correct projectID scoping)
-      assert.strictEqual(sessionDirectory, '/data/proj', 
-        'Session creation should use project directory, not worktree');
+      // Session creation uses the worktree directory (sets correct working directory)
+      assert.strictEqual(sessionDirectory, '/data/worktree/calm-wizard', 
+        'Session creation should use worktree directory for correct working dir');
       // Result directory is the worktree (where file operations happen)
       assert.strictEqual(result.directory, '/data/worktree/calm-wizard',
         'Result should include worktree directory');
@@ -1042,11 +1042,12 @@ Check for bugs and security issues.`;
       assert.ok(messageUrl.includes('%2Fpath%2Fto%2Fproject'), 'Message URL should include encoded directory path');
     });
 
-    test('uses projectDirectory for session creation, working directory for messages', async () => {
+    test('creates session with worktree directory, patches with project directory for scoping', async () => {
       const { createSessionViaApi } = await import('../../service/actions.js');
       
       const mockSessionId = 'ses_test_proj';
       let createUrl = null;
+      let patchUrl = null;
       let messageUrl = null;
       
       const mockFetch = async (url, opts) => {
@@ -1057,6 +1058,11 @@ Check for bugs and security issues.`;
           return { ok: true, json: async () => ({ id: mockSessionId }) };
         }
         
+        if (urlObj.pathname.includes(`/session/${mockSessionId}`) && opts?.method === 'PATCH') {
+          patchUrl = url;
+          return { ok: true, json: async () => ({}) };
+        }
+        
         if (urlObj.pathname.includes('/message') && opts?.method === 'POST') {
           messageUrl = url;
           return { ok: true, json: async () => ({ success: true }) };
@@ -1075,13 +1081,18 @@ Check for bugs and security issues.`;
         }
       );
       
-      // Session creation should use the project directory (for correct projectID scoping)
-      assert.ok(createUrl.includes('%2Fhome%2Fuser%2Fcode%2Fodin'), 
-        'Session creation should use projectDirectory');
-      assert.ok(!createUrl.includes('worktree'), 
-        'Session creation should NOT use the worktree path');
+      // Session creation should use the worktree directory (sets working directory)
+      assert.ok(createUrl.includes('worktree'), 
+        'Session creation should use the worktree path');
+      assert.ok(createUrl.includes('pr-415'), 
+        'Session creation should use the worktree path');
+      
+      // PATCH should use the project directory (re-associates with correct project)
+      assert.ok(patchUrl, 'PATCH should be called for project scoping');
+      assert.ok(patchUrl.includes('%2Fhome%2Fuser%2Fcode%2Fodin'), 
+        'PATCH should use projectDirectory for project scoping');
       
-      // Message should use the working directory (for file operations in the worktree)
+      // Message should use the working directory (worktree)
       assert.ok(messageUrl.includes('worktree'), 
         'Message should use the worktree working directory');
       assert.ok(messageUrl.includes('pr-415'),