opencode-pilot 0.14.1 → 0.15.1

package/README.md

@@ -70,6 +70,27 @@ Three ways to configure sources, from simplest to most flexible:
 
 Create prompt templates as markdown files in `~/.config/opencode/pilot/templates/`. Templates support placeholders like `{title}`, `{body}`, `{number}`, `{html_url}`, etc.
 
+### Worktree Support
+
+Run sessions in isolated git worktrees instead of the main project directory. This uses OpenCode's built-in worktree management API to create and manage worktrees.
+
+```yaml
+sources:
+  - preset: github/my-issues
+    # Create a fresh worktree for each session
+    worktree: "new"
+    worktree_name: "issue-{number}"  # Optional: name template
+    
+  - preset: linear/my-issues
+    # Use an existing worktree by name
+    worktree: "my-feature-branch"
+```
+
+**Options:**
+- `worktree: "new"` - Create a new worktree via OpenCode's API
+- `worktree: "name"` - Look up existing worktree by name from project sandboxes
+- `worktree_name` - Template for naming new worktrees (only with `worktree: "new"`)
+
 ## CLI Commands
 
 ```bash
@@ -92,12 +113,6 @@ opencode-pilot test-mapping MCP   # Test field mappings
 3. **Spawn sessions** - Start `opencode run` with the appropriate prompt template
 4. **Track state** - Remember which items have been processed
 
-## Known Issues
-
-None currently! Previous issues have been resolved:
-
-- ~~Sessions attached to global server run in wrong directory~~ - Fixed in v0.14.0 by using the HTTP API with `?directory=` parameter instead of `opencode run --attach`
-
 ## Related
 
 - [opencode-devcontainers](https://github.com/athal7/opencode-devcontainers) - Run multiple devcontainer instances for OpenCode

package/examples/config.yaml

@@ -33,6 +33,16 @@ sources:
     working_dir: ~/code/myproject
     prompt: worktree
 
+  # Example with worktree support - run each issue in a fresh git worktree
+  # - preset: github/my-issues
+  #   worktree: "new"                    # Create a new worktree per session
+  #   worktree_name: "issue-{number}"    # Name template for new worktrees
+  #   prompt: worktree
+  
+  # Use an existing worktree by name
+  # - preset: github/review-requests
+  #   worktree: "review-worktree"        # Must exist in project sandboxes
+
   # GitHub shorthand syntax
   # - name: urgent-issues
   #   github: "is:issue assignee:@me label:urgent state:open"

package/package.json

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

package/service/actions.js

@@ -10,6 +10,7 @@ import { readFileSync, existsSync } from "fs";
 import { debug } from "./logger.js";
 import { getNestedValue } from "./utils.js";
 import { getServerPort } from "./repo-config.js";
+import { resolveWorktreeDirectory } from "./worktree.js";
 import path from "path";
 import os from "os";
 
@@ -560,15 +561,40 @@ export async function createSessionViaApi(serverUrl, directory, prompt, options
  * @returns {Promise<object>} Result with command, stdout, stderr, exitCode
  */
 export async function executeAction(item, config, options = {}) {
-  // Get working directory first to determine which server to attach to
+  // Get base working directory first to determine which server to attach to
   const workingDir = config.working_dir || config.path || config.repo_path || "~";
-  const cwd = expandPath(workingDir);
+  const baseCwd = expandPath(workingDir);
   
   // Discover running opencode server for this directory
   const discoverFn = options.discoverServer || discoverOpencodeServer;
-  const serverUrl = await discoverFn(cwd);
+  const serverUrl = await discoverFn(baseCwd);
+  
+  debug(`executeAction: discovered server=${serverUrl} for baseCwd=${baseCwd}`);
+  
+  // Resolve worktree directory if configured
+  // This allows creating sessions in isolated worktrees instead of the main project
+  const worktreeConfig = {
+    worktree: config.worktree,
+    // Expand worktree_name template with item fields (e.g., "issue-{number}")
+    worktreeName: config.worktree_name ? expandTemplate(config.worktree_name, item) : undefined,
+  };
+  
+  const worktreeResult = await resolveWorktreeDirectory(
+    serverUrl,
+    baseCwd,
+    worktreeConfig,
+    { fetch: options.fetch }
+  );
+  
+  const cwd = expandPath(worktreeResult.directory);
+  
+  if (worktreeResult.worktreeCreated) {
+    debug(`executeAction: created new worktree at ${cwd}`);
+  } else if (worktreeResult.error) {
+    debug(`executeAction: worktree resolution warning - ${worktreeResult.error}`);
+  }
   
-  debug(`executeAction: discovered server=${serverUrl} for cwd=${cwd}`);
+  debug(`executeAction: using cwd=${cwd}`);
   
   // If a server is running, use the HTTP API to create the session
   // This is a workaround for the known issue where --attach doesn't support --dir

package/service/poll-service.js

@@ -22,11 +22,12 @@ const DEFAULT_POLL_INTERVAL = 5 * 60 * 1000; // 5 minutes
 
 /**
  * Check if a source has tool configuration
+ * @see getToolConfig in poller.js for actual tool config resolution
  * @param {object} source - Source configuration
- * @returns {boolean} True if source has tool.mcp and tool.name
+ * @returns {boolean} True if source has tool.command or (tool.mcp and tool.name)
  */
 export function hasToolConfig(source) {
-  return !!(source.tool && source.tool.mcp && source.tool.name);
+  return !!(source.tool && (source.tool.command || (source.tool.mcp && source.tool.name)));
 }
 
 /**
@@ -113,7 +114,7 @@ export async function pollOnce(options = {}) {
     const sourceName = source.name || 'unknown';
 
     if (!hasToolConfig(source)) {
-      console.error(`[poll] Source '${sourceName}' missing tool configuration (requires tool.mcp and tool.name)`);
+      console.error(`[poll] Source '${sourceName}' missing tool configuration (requires tool.command or tool.mcp and tool.name)`);
       continue;
     }
 

package/service/worktree.js

@@ -0,0 +1,182 @@
+/**
+ * worktree.js - Worktree management for OpenCode sessions
+ *
+ * Interacts with OpenCode server to list and create worktrees (sandboxes).
+ * Worktrees allow running sessions in isolated git branches/directories.
+ */
+
+import { debug } from "./logger.js";
+
+/**
+ * List available worktrees/sandboxes for a project
+ * 
+ * @param {string} serverUrl - OpenCode server URL (e.g., "http://localhost:4096")
+ * @param {object} [options] - Options
+ * @param {function} [options.fetch] - Custom fetch function (for testing)
+ * @returns {Promise<string[]>} Array of worktree directory paths
+ */
+export async function listWorktrees(serverUrl, options = {}) {
+  const fetchFn = options.fetch || fetch;
+  
+  try {
+    const response = await fetchFn(`${serverUrl}/experimental/worktree`);
+    
+    if (!response.ok) {
+      debug(`listWorktrees: ${serverUrl} returned ${response.status}`);
+      return [];
+    }
+    
+    const worktrees = await response.json();
+    debug(`listWorktrees: found ${worktrees.length} worktrees`);
+    return Array.isArray(worktrees) ? worktrees : [];
+  } catch (err) {
+    debug(`listWorktrees: error - ${err.message}`);
+    return [];
+  }
+}
+
+/**
+ * Create a new worktree for a project
+ * 
+ * @param {string} serverUrl - OpenCode server URL (e.g., "http://localhost:4096")
+ * @param {object} [options] - Options
+ * @param {string} [options.name] - Optional name for the worktree
+ * @param {string} [options.startCommand] - Optional startup script to run after creation
+ * @param {function} [options.fetch] - Custom fetch function (for testing)
+ * @returns {Promise<object>} Result with { success, worktree?, error? }
+ */
+export async function createWorktree(serverUrl, options = {}) {
+  const fetchFn = options.fetch || fetch;
+  
+  try {
+    const body = {};
+    if (options.name) body.name = options.name;
+    if (options.startCommand) body.startCommand = options.startCommand;
+    
+    const response = await fetchFn(`${serverUrl}/experimental/worktree`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    });
+    
+    if (!response.ok) {
+      const errorText = await response.text();
+      debug(`createWorktree: ${serverUrl} returned ${response.status} - ${errorText}`);
+      return {
+        success: false,
+        error: `Failed to create worktree: ${response.status} ${errorText}`,
+      };
+    }
+    
+    const worktree = await response.json();
+    debug(`createWorktree: created worktree ${worktree.name} at ${worktree.directory}`);
+    
+    return {
+      success: true,
+      worktree,
+    };
+  } catch (err) {
+    debug(`createWorktree: error - ${err.message}`);
+    return {
+      success: false,
+      error: err.message,
+    };
+  }
+}
+
+/**
+ * Get project info including sandboxes from the server
+ * 
+ * @param {string} serverUrl - OpenCode server URL
+ * @param {object} [options] - Options
+ * @param {function} [options.fetch] - Custom fetch function (for testing)
+ * @returns {Promise<object|null>} Project info or null if unavailable
+ */
+export async function getProjectInfo(serverUrl, options = {}) {
+  const fetchFn = options.fetch || fetch;
+  
+  try {
+    const response = await fetchFn(`${serverUrl}/project/current`);
+    
+    if (!response.ok) {
+      debug(`getProjectInfo: ${serverUrl} returned ${response.status}`);
+      return null;
+    }
+    
+    const project = await response.json();
+    debug(`getProjectInfo: project ${project.id} with ${project.sandboxes?.length || 0} sandboxes`);
+    return project;
+  } catch (err) {
+    debug(`getProjectInfo: error - ${err.message}`);
+    return null;
+  }
+}
+
+/**
+ * Resolve the working directory based on worktree configuration
+ * 
+ * Uses OpenCode's experimental worktree API:
+ * - GET /experimental/worktree - List existing worktrees
+ * - POST /experimental/worktree - Create new worktree
+ * 
+ * @param {string} serverUrl - OpenCode server URL
+ * @param {string} baseDir - Base working directory from config
+ * @param {object} worktreeConfig - Worktree configuration
+ * @param {string} [worktreeConfig.worktree] - Worktree mode: "new" or worktree name
+ * @param {string} [worktreeConfig.worktreeName] - Name for new worktree (only with "new")
+ * @param {object} [options] - Options
+ * @param {function} [options.fetch] - Custom fetch function (for testing)
+ * @returns {Promise<object>} Result with { directory, worktreeCreated?, error? }
+ */
+export async function resolveWorktreeDirectory(serverUrl, baseDir, worktreeConfig, options = {}) {
+  // No worktree config - use base directory
+  if (!worktreeConfig?.worktree) {
+    return { directory: baseDir };
+  }
+  
+  // Require server for any worktree operation
+  if (!serverUrl) {
+    return {
+      directory: baseDir,
+      error: "Cannot use worktree: no server running",
+    };
+  }
+  
+  const worktreeValue = worktreeConfig.worktree;
+  
+  // "new" - create a fresh worktree via OpenCode API
+  if (worktreeValue === "new") {
+    const result = await createWorktree(serverUrl, {
+      name: worktreeConfig.worktreeName,
+      fetch: options.fetch,
+    });
+    
+    if (!result.success) {
+      return {
+        directory: baseDir,
+        error: result.error,
+      };
+    }
+    
+    return {
+      directory: result.worktree.directory,
+      worktreeCreated: true,
+      worktree: result.worktree,
+    };
+  }
+  
+  // Named worktree - look it up from available sandboxes via OpenCode API
+  const worktrees = await listWorktrees(serverUrl, options);
+  const match = worktrees.find(w => w.includes(worktreeValue));
+  if (match) {
+    return { directory: match };
+  }
+  
+  debug(`resolveWorktreeDirectory: worktree "${worktreeValue}" not found in available sandboxes`);
+  
+  // Fallback to base directory
+  return {
+    directory: baseDir,
+    error: `Worktree "${worktreeValue}" not found in project sandboxes`,
+  };
+}

package/test/unit/actions.test.js

@@ -571,6 +571,128 @@ describe('actions.js', () => {
       assert.ok(!result.command.includes('--attach'), 'Command should not include --attach flag');
       assert.ok(result.command.includes('opencode run'), 'Command should include opencode run');
     });
+
+    test('creates new worktree when worktree: "new" is configured (dry run)', async () => {
+      const { executeAction } = await import('../../service/actions.js');
+      
+      const item = { number: 123, title: 'Fix bug' };
+      const config = {
+        path: tempDir,
+        prompt: 'default',
+        worktree: 'new',
+        worktree_name: 'feature-branch'
+      };
+      
+      // Mock server discovery
+      const mockDiscoverServer = async () => 'http://localhost:4096';
+      
+      // Mock worktree creation via fetch
+      const mockFetch = async (url, opts) => {
+        // Worktree creation endpoint
+        if (url === 'http://localhost:4096/experimental/worktree' && opts?.method === 'POST') {
+          const body = JSON.parse(opts.body);
+          assert.strictEqual(body.name, 'feature-branch', 'Should pass worktree name');
+          return {
+            ok: true,
+            json: async () => ({
+              name: 'feature-branch',
+              branch: 'opencode/feature-branch',
+              directory: '/data/worktree/proj123/feature-branch'
+            })
+          };
+        }
+        return { ok: false, text: async () => 'Not found' };
+      };
+      
+      const result = await executeAction(item, config, { 
+        dryRun: true,
+        discoverServer: mockDiscoverServer,
+        fetch: mockFetch
+      });
+      
+      assert.ok(result.dryRun);
+      assert.strictEqual(result.method, 'api', 'Should use API method');
+      // The directory in the command should be the worktree directory
+      assert.ok(result.command.includes('/data/worktree/proj123/feature-branch'), 
+        'Should use worktree directory in command');
+    });
+
+    test('uses existing worktree by name (dry run)', async () => {
+      const { executeAction } = await import('../../service/actions.js');
+      
+      const item = { number: 123, title: 'Fix bug' };
+      const config = {
+        path: tempDir,
+        prompt: 'default',
+        worktree: 'my-feature'
+      };
+      
+      // Mock server discovery
+      const mockDiscoverServer = async () => 'http://localhost:4096';
+      
+      // Mock worktree list lookup
+      const mockFetch = async (url) => {
+        if (url === 'http://localhost:4096/experimental/worktree') {
+          return {
+            ok: true,
+            json: async () => [
+              '/data/worktree/proj123/other-branch',
+              '/data/worktree/proj123/my-feature'
+            ]
+          };
+        }
+        return { ok: false, text: async () => 'Not found' };
+      };
+      
+      const result = await executeAction(item, config, { 
+        dryRun: true,
+        discoverServer: mockDiscoverServer,
+        fetch: mockFetch
+      });
+      
+      assert.ok(result.dryRun);
+      assert.strictEqual(result.method, 'api', 'Should use API method');
+      assert.ok(result.command.includes('/data/worktree/proj123/my-feature'), 
+        'Should use looked up worktree path in command');
+    });
+
+    test('falls back to base directory when worktree creation fails (dry run)', async () => {
+      const { executeAction } = await import('../../service/actions.js');
+      
+      const item = { number: 123, title: 'Fix bug' };
+      const config = {
+        path: tempDir,
+        prompt: 'default',
+        worktree: 'new'
+      };
+      
+      // Mock server discovery
+      const mockDiscoverServer = async () => 'http://localhost:4096';
+      
+      // Mock worktree creation failure
+      const mockFetch = async (url, opts) => {
+        if (url === 'http://localhost:4096/experimental/worktree' && opts?.method === 'POST') {
+          return {
+            ok: false,
+            status: 500,
+            text: async () => 'Internal server error'
+          };
+        }
+        return { ok: false, text: async () => 'Not found' };
+      };
+      
+      const result = await executeAction(item, config, { 
+        dryRun: true,
+        discoverServer: mockDiscoverServer,
+        fetch: mockFetch
+      });
+      
+      assert.ok(result.dryRun);
+      assert.strictEqual(result.method, 'api', 'Should still use API method');
+      // Should fall back to base directory
+      assert.ok(result.command.includes(tempDir), 
+        'Should fall back to base directory when worktree creation fails');
+    });
   });
 
   describe('createSessionViaApi', () => {

package/test/unit/poll-service.test.js

@@ -50,23 +50,39 @@ sources:
     test('hasToolConfig validates source configuration', async () => {
       const { hasToolConfig } = await import('../../service/poll-service.js');
       
-      // Valid config
-      const valid = {
+      // Valid MCP config
+      const validMcp = {
         name: 'test',
         tool: { mcp: 'github', name: 'search_issues' },
         args: {}
       };
-      assert.strictEqual(hasToolConfig(valid), true);
+      assert.strictEqual(hasToolConfig(validMcp), true);
+      
+      // Valid CLI command config
+      const validCli = {
+        name: 'test',
+        tool: { command: ['gh', 'search', 'issues'] },
+        args: {}
+      };
+      assert.strictEqual(hasToolConfig(validCli), true);
+      
+      // Valid CLI command config (string form)
+      const validCliString = {
+        name: 'test',
+        tool: { command: 'gh search issues' },
+        args: {}
+      };
+      assert.strictEqual(hasToolConfig(validCliString), true);
       
       // Missing tool
       const missingTool = { name: 'test' };
       assert.strictEqual(hasToolConfig(missingTool), false);
       
-      // Missing mcp
+      // Missing mcp (and no command)
       const missingMcp = { name: 'test', tool: { name: 'search_issues' } };
       assert.strictEqual(hasToolConfig(missingMcp), false);
       
-      // Missing tool.name
+      // Missing tool.name (and no command)
       const missingName = { name: 'test', tool: { mcp: 'github' } };
       assert.strictEqual(hasToolConfig(missingName), false);
     });

package/test/unit/worktree.test.js

@@ -0,0 +1,250 @@
+import { describe, it, mock } from "node:test";
+import assert from "node:assert";
+import {
+  listWorktrees,
+  createWorktree,
+  getProjectInfo,
+  resolveWorktreeDirectory,
+} from "../../service/worktree.js";
+
+describe("worktree", () => {
+  describe("listWorktrees", () => {
+    it("returns worktrees from server", async () => {
+      const mockFetch = mock.fn(async () => ({
+        ok: true,
+        json: async () => ["/path/to/worktree1", "/path/to/worktree2"],
+      }));
+
+      const result = await listWorktrees("http://localhost:4096", { fetch: mockFetch });
+
+      assert.deepStrictEqual(result, ["/path/to/worktree1", "/path/to/worktree2"]);
+      assert.strictEqual(mockFetch.mock.calls.length, 1);
+      assert.strictEqual(mockFetch.mock.calls[0].arguments[0], "http://localhost:4096/experimental/worktree");
+    });
+
+    it("returns empty array on error", async () => {
+      const mockFetch = mock.fn(async () => ({
+        ok: false,
+        status: 500,
+      }));
+
+      const result = await listWorktrees("http://localhost:4096", { fetch: mockFetch });
+
+      assert.deepStrictEqual(result, []);
+    });
+
+    it("returns empty array on network error", async () => {
+      const mockFetch = mock.fn(async () => {
+        throw new Error("Network error");
+      });
+
+      const result = await listWorktrees("http://localhost:4096", { fetch: mockFetch });
+
+      assert.deepStrictEqual(result, []);
+    });
+  });
+
+  describe("createWorktree", () => {
+    it("creates a worktree successfully", async () => {
+      const worktreeResponse = {
+        name: "brave-falcon",
+        branch: "opencode/brave-falcon",
+        directory: "/data/worktree/abc123/brave-falcon",
+      };
+
+      const mockFetch = mock.fn(async () => ({
+        ok: true,
+        json: async () => worktreeResponse,
+      }));
+
+      const result = await createWorktree("http://localhost:4096", { fetch: mockFetch });
+
+      assert.strictEqual(result.success, true);
+      assert.deepStrictEqual(result.worktree, worktreeResponse);
+    });
+
+    it("passes name option to server", async () => {
+      const mockFetch = mock.fn(async (url, options) => ({
+        ok: true,
+        json: async () => ({
+          name: "my-feature",
+          branch: "opencode/my-feature",
+          directory: "/data/worktree/abc123/my-feature",
+        }),
+      }));
+
+      await createWorktree("http://localhost:4096", {
+        name: "my-feature",
+        fetch: mockFetch,
+      });
+
+      const body = JSON.parse(mockFetch.mock.calls[0].arguments[1].body);
+      assert.strictEqual(body.name, "my-feature");
+    });
+
+    it("returns error on failure", async () => {
+      const mockFetch = mock.fn(async () => ({
+        ok: false,
+        status: 400,
+        text: async () => "Invalid request",
+      }));
+
+      const result = await createWorktree("http://localhost:4096", { fetch: mockFetch });
+
+      assert.strictEqual(result.success, false);
+      assert.ok(result.error.includes("400"));
+    });
+  });
+
+  describe("getProjectInfo", () => {
+    it("returns project info", async () => {
+      const projectInfo = {
+        id: "abc123",
+        worktree: "/path/to/project",
+        sandboxes: ["/path/to/sandbox1", "/path/to/sandbox2"],
+      };
+
+      const mockFetch = mock.fn(async () => ({
+        ok: true,
+        json: async () => projectInfo,
+      }));
+
+      const result = await getProjectInfo("http://localhost:4096", { fetch: mockFetch });
+
+      assert.deepStrictEqual(result, projectInfo);
+    });
+
+    it("returns null on error", async () => {
+      const mockFetch = mock.fn(async () => ({
+        ok: false,
+        status: 404,
+      }));
+
+      const result = await getProjectInfo("http://localhost:4096", { fetch: mockFetch });
+
+      assert.strictEqual(result, null);
+    });
+  });
+
+  describe("resolveWorktreeDirectory", () => {
+    it("returns base directory when no worktree config", async () => {
+      const result = await resolveWorktreeDirectory(
+        "http://localhost:4096",
+        "/path/to/project",
+        {}
+      );
+
+      assert.strictEqual(result.directory, "/path/to/project");
+    });
+
+    it("returns base directory when worktree is undefined", async () => {
+      const result = await resolveWorktreeDirectory(
+        "http://localhost:4096",
+        "/path/to/project",
+        { worktree: undefined }
+      );
+
+      assert.strictEqual(result.directory, "/path/to/project");
+    });
+
+    it("creates new worktree when worktree is 'new'", async () => {
+      const mockFetch = mock.fn(async () => ({
+        ok: true,
+        json: async () => ({
+          name: "test-worktree",
+          branch: "opencode/test-worktree",
+          directory: "/data/worktree/abc123/test-worktree",
+        }),
+      }));
+
+      const result = await resolveWorktreeDirectory(
+        "http://localhost:4096",
+        "/path/to/project",
+        { worktree: "new" },
+        { fetch: mockFetch }
+      );
+
+      assert.strictEqual(result.directory, "/data/worktree/abc123/test-worktree");
+      assert.strictEqual(result.worktreeCreated, true);
+    });
+
+    it("passes worktreeName when creating new worktree", async () => {
+      const mockFetch = mock.fn(async () => ({
+        ok: true,
+        json: async () => ({
+          name: "my-feature",
+          branch: "opencode/my-feature",
+          directory: "/data/worktree/abc123/my-feature",
+        }),
+      }));
+
+      await resolveWorktreeDirectory(
+        "http://localhost:4096",
+        "/path/to/project",
+        { worktree: "new", worktreeName: "my-feature" },
+        { fetch: mockFetch }
+      );
+
+      const body = JSON.parse(mockFetch.mock.calls[0].arguments[1].body);
+      assert.strictEqual(body.name, "my-feature");
+    });
+
+    it("returns error when no server running", async () => {
+      const result = await resolveWorktreeDirectory(
+        null,
+        "/path/to/project",
+        { worktree: "new" }
+      );
+
+      assert.strictEqual(result.directory, "/path/to/project");
+      assert.ok(result.error.includes("no server"));
+    });
+
+    it("returns error when no server running for named worktree", async () => {
+      const result = await resolveWorktreeDirectory(
+        null,
+        "/path/to/project",
+        { worktree: "my-feature" }
+      );
+
+      assert.strictEqual(result.directory, "/path/to/project");
+      assert.ok(result.error.includes("no server"));
+    });
+
+    it("looks up named worktree from sandboxes", async () => {
+      const mockFetch = mock.fn(async () => ({
+        ok: true,
+        json: async () => [
+          "/data/worktree/abc123/brave-falcon",
+          "/data/worktree/abc123/my-feature",
+        ],
+      }));
+
+      const result = await resolveWorktreeDirectory(
+        "http://localhost:4096",
+        "/path/to/project",
+        { worktree: "my-feature" },
+        { fetch: mockFetch }
+      );
+
+      assert.strictEqual(result.directory, "/data/worktree/abc123/my-feature");
+    });
+
+    it("returns error when named worktree not found", async () => {
+      const mockFetch = mock.fn(async () => ({
+        ok: true,
+        json: async () => ["/data/worktree/abc123/other-worktree"],
+      }));
+
+      const result = await resolveWorktreeDirectory(
+        "http://localhost:4096",
+        "/path/to/project",
+        { worktree: "nonexistent" },
+        { fetch: mockFetch }
+      );
+
+      assert.strictEqual(result.directory, "/path/to/project");
+      assert.ok(result.error.includes("not found"));
+    });
+  });
+});