opencode-pilot 0.20.4 → 0.20.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-pilot",
-  "version": "0.20.4",
+  "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,6 +917,14 @@ 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;
@@ -890,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/test/integration/session-reuse.test.js

@@ -566,4 +566,57 @@ describe("integration: worktree creation with worktree_name", () => {
     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

@@ -888,6 +888,75 @@ Check for bugs and security issues.`;
       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', () => {

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