opencode-pilot 0.16.5 → 0.17.0

package/README.md

@@ -46,10 +46,12 @@ See [examples/config.yaml](examples/config.yaml) for a complete example with all
 ### Key Sections
 
 - **`server_port`** - Preferred OpenCode server port (e.g., `4096`). When multiple OpenCode instances are running, pilot attaches sessions to this port.
+- **`startup_delay`** - Milliseconds to wait before first poll (default: `10000`). Allows OpenCode server time to fully initialize after restart.
+- **`repos_dir`** - Directory containing git repos (e.g., `~/code`). Pilot auto-discovers repos by scanning git remotes (both `origin` and `upstream` for fork support).
 - **`defaults`** - Default values applied to all sources
 - **`sources`** - What to poll (presets, shorthand, or full config)
 - **`tools`** - Field mappings to normalize different MCP APIs
-- **`repos`** - Repository paths and settings (use YAML anchors to share config)
+- **`repos`** - Explicit repository paths (overrides auto-discovery from `repos_dir`)
 
 ### Source Syntax
 

package/examples/config.yaml

@@ -6,6 +6,16 @@
 # to this port. If not set, pilot discovers servers automatically.
 # server_port: 4096
 
+# Startup delay in milliseconds before first poll (default: 10000)
+# Allows OpenCode server time to fully initialize after restart.
+# Set to 0 for immediate polling.
+# startup_delay: 10000
+
+# Directory containing your git repos - enables auto-discovery
+# Pilot scans for repos by checking git remotes (origin and upstream)
+# This means PRs from upstream forks will match your local clones
+repos_dir: ~/code
+
 defaults:
   agent: plan
   prompt: default
@@ -68,7 +78,8 @@ sources:
 #       title: name
 #       body: notes
 
-# Map repos to local paths
+# Explicit repo mappings (overrides repos_dir auto-discovery)
+# Only needed if a repo isn't in repos_dir or needs custom settings
 # repos:
 #   myorg/backend:
 #     path: ~/code/backend

package/package.json

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

package/service/actions.js

@@ -5,7 +5,7 @@
  * Supports prompt_template for custom prompts (e.g., to invoke /devcontainer).
  */
 
-import { spawn, execSync } from "child_process";
+import { execSync } from "child_process";
 import { readFileSync, existsSync } from "fs";
 import { debug } from "./logger.js";
 import { getNestedValue } from "./utils.js";
@@ -290,164 +290,20 @@ export function getActionConfig(source, repoConfig, defaults) {
 }
 
 /**
- * Get command info using new config format
+ * Build a display string for dry-run logging
+ * Shows what API call would be made
  * @param {object} item - Item to create session for
- * @param {object} config - Merged action config
- * @param {string} [templatesDir] - Templates directory path (for testing)
- * @param {string} [serverUrl] - URL of running opencode server to attach to
- * @returns {object} { args: string[], cwd: string }
+ * @param {object} config - Repo config with action settings
+ * @returns {string} Display string for logging
  */
-export function getCommandInfoNew(item, config, templatesDir, serverUrl) {
-  // Determine working directory: working_dir > path > repo_path > home
-  const workingDir = config.working_dir || config.path || config.repo_path || "~";
-  const cwd = expandPath(workingDir);
-
-  // Build session name
+export function buildCommand(item, config) {
+  const workingDir = config.working_dir || config.path || config.repo_path;
+  const cwd = workingDir ? expandPath(workingDir) : '(no path)';
   const sessionName = config.session?.name
     ? buildSessionName(config.session.name, item)
     : (item.title || `session-${Date.now()}`);
-
-  // Build command args
-  const args = ["opencode", "run"];
-  
-  // Add --attach if server URL is provided
-  if (serverUrl) {
-    args.push("--attach", serverUrl);
-  }
-  
-  // Add session title
-  args.push("--title", sessionName);
-  
-  // Add agent if specified
-  if (config.agent) {
-    args.push("--agent", config.agent);
-  }
-  
-  // Add model if specified
-  if (config.model) {
-    args.push("--model", config.model);
-  }
-
-  // Build prompt from template
-  const prompt = buildPromptFromTemplate(config.prompt || "default", item, templatesDir);
-  if (prompt) {
-    args.push(prompt);
-  }
-
-  return { args, cwd };
-}
-
-/**
- * Build the prompt from item and config
- * Uses prompt_template if provided, otherwise combines title and body
- * @param {object} item - Item with title, body, etc.
- * @param {object} config - Config with optional session.prompt_template
- * @returns {string} The prompt to send to opencode
- */
-function buildPrompt(item, config) {
-  // If prompt_template is provided, expand it
-  if (config.session?.prompt_template) {
-    return expandTemplate(config.session.prompt_template, item);
-  }
-  
-  // Default: combine title and body
-  const parts = [];
-  if (item.title) parts.push(item.title);
-  if (item.body) parts.push(item.body);
-  return parts.join("\n\n");
-}
-
-/**
- * Build command args for action
- * Uses "opencode run" for non-interactive execution
- * @deprecated Legacy function - not currently used. See getCommandInfoNew instead.
- * @returns {object} { args: string[], cwd: string }
- */
-function buildCommandArgs(item, config) {
-  const repoPath = expandPath(config.repo_path || ".");
-  const sessionTitle = config.session?.name_template
-    ? buildSessionName(config.session.name_template, item)
-    : (item.title || `session-${Date.now()}`);
-
-  // Build opencode run command args array (non-interactive)
-  // Note: --title sets session title (--session is for continuing existing sessions)
-  const args = ["opencode", "run"];
-
-  // Add title for the session (helps identify it later)
-  args.push("--title", sessionTitle);
-
-  // Add agent if specified
-  if (config.session?.agent) {
-    args.push("--agent", config.session.agent);
-  }
-
-  // Add prompt (must be last for "run" command)
-  const prompt = buildPrompt(item, config);
-  if (prompt) {
-    args.push(prompt);
-  }
-
-  return { args, cwd: repoPath };
-}
-
-/**
- * Get command info for an action
- * @param {object} item - Item to create session for
- * @param {object} config - Repo config with action settings
- * @returns {object} { args: string[], cwd: string }
- */
-export function getCommandInfo(item, config) {
-  return getCommandInfoNew(item, config);
-}
-
-/**
- * Build command string for display/logging
- * @param {object} item - Item to create session for
- * @param {object} config - Repo config with action settings
- * @returns {string} Command string (for display only)
- */
-export function buildCommand(item, config) {
-  const cmdInfo = getCommandInfo(item, config);
-  
-  const quoteArgs = (args) => args.map(a => 
-    a.includes(" ") || a.includes("\n") ? `"${a.replace(/"/g, '\\"')}"` : a
-  ).join(" ");
   
-  const cmdStr = quoteArgs(cmdInfo.args);
-  return cmdInfo.cwd ? `(cd ${cmdInfo.cwd} && ${cmdStr})` : cmdStr;
-}
-
-/**
- * Execute a spawn command and return a promise
- */
-function runSpawn(args, options = {}) {
-  return new Promise((resolve, reject) => {
-    const [cmd, ...cmdArgs] = args;
-    const spawnOpts = {
-      stdio: ["ignore", "pipe", "pipe"],
-      ...options,
-    };
-    const child = spawn(cmd, cmdArgs, spawnOpts);
-
-    let stdout = "";
-    let stderr = "";
-
-    child.stdout.on("data", (data) => {
-      stdout += data.toString();
-    });
-
-    child.stderr.on("data", (data) => {
-      stderr += data.toString();
-    });
-
-    child.on("close", (code) => {
-      resolve({ stdout, stderr, exitCode: code, success: code === 0 });
-    });
-
-    child.on("error", (err) => {
-      reject(err);
-    });
-  });
+  return `[API] POST /session?directory=${cwd} (title: "${sessionName}")`;
 }
 
 /**
@@ -595,8 +451,19 @@ 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 base working directory first to determine which server to attach to
-  const workingDir = config.working_dir || config.path || config.repo_path || "~";
+  // Get base working directory - require explicit config, don't default to home
+  const workingDir = config.working_dir || config.path || config.repo_path;
+  
+  // Fail-safe: require a valid local path to be configured
+  if (!workingDir) {
+    debug(`executeAction: skipping item - no local path configured`);
+    return {
+      success: false,
+      skipped: true,
+      error: 'No local path configured for this repository. Configure repos_dir or add explicit repo config.',
+    };
+  }
+  
   const baseCwd = expandPath(workingDir);
   
   // Discover running opencode server for this directory
@@ -605,13 +472,22 @@ export async function executeAction(item, config, options = {}) {
   
   debug(`executeAction: discovered server=${serverUrl} for baseCwd=${baseCwd}`);
   
+  // Require OpenCode server - pilot runs as a plugin, so server should always be available
+  // Mark as skipped (retriable) rather than hard error - server may still be initializing
+  if (!serverUrl) {
+    return {
+      success: false,
+      skipped: true,
+      error: 'No OpenCode server found. Will retry on next poll.',
+    };
+  }
+  
   // Resolve worktree directory if configured
   // This allows creating sessions in isolated worktrees instead of the main project
   let worktreeMode = config.worktree;
   
-  // Auto-detect worktree support: if not explicitly configured and server is running,
-  // check if the project has sandboxes (indicating worktree workflow is set up)
-  if (!worktreeMode && serverUrl) {
+  // Auto-detect worktree support: check if the project has sandboxes
+  if (!worktreeMode) {
     // Look up project info for this specific directory (not just /project/current)
     const projectInfo = await getProjectInfoForDirectory(serverUrl, baseCwd, { fetch: options.fetch });
     if (projectInfo?.sandboxes?.length > 0) {
@@ -643,117 +519,35 @@ export async function executeAction(item, config, options = {}) {
   
   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
-  // See: https://github.com/anomalyco/opencode/issues/7376
-  if (serverUrl) {
-    // 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()}`);
-    
-    const apiCommand = `[API] POST ${serverUrl}/session?directory=${cwd}`;
-    debug(`executeAction: using HTTP API - ${apiCommand}`);
-    
-    if (options.dryRun) {
-      return {
-        command: apiCommand,
-        dryRun: true,
-        method: 'api',
-      };
-    }
-    
-    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,
-      method: 'api',
-    };
-  }
+  // Build prompt from template
+  const prompt = buildPromptFromTemplate(config.prompt || "default", item);
   
-  // No server running - fall back to spawning opencode run
-  // This works correctly because we set cwd on the spawn
-  const cmdInfo = getCommandInfoNew(item, config, undefined, null);
+  // Build session title
+  const sessionTitle = config.session?.name
+    ? buildSessionName(config.session.name, item)
+    : (item.title || `session-${Date.now()}`);
+  
+  const apiCommand = `[API] POST ${serverUrl}/session?directory=${cwd}`;
+  debug(`executeAction: using HTTP API - ${apiCommand}`);
   
-  // Build command string for display
-  const quoteArgs = (args) => args.map(a => 
-    a.includes(" ") || a.includes("\n") ? `"${a.replace(/"/g, '\\"')}"` : a
-  ).join(" ");
-  const cmdStr = quoteArgs(cmdInfo.args);
-  const command = cmdInfo.cwd ? `(cd ${cmdInfo.cwd} && ${cmdStr})` : cmdStr;
-
-  debug(`executeAction: command=${command}`);
-  debug(`executeAction: args=${JSON.stringify(cmdInfo.args)}, cwd=${cmdInfo.cwd}`);
-
   if (options.dryRun) {
     return {
-      command,
+      command: apiCommand,
       dryRun: true,
-      method: 'spawn',
     };
   }
-
-  // Execute opencode run in background (detached)
-  // We don't wait for completion since sessions can run for a long time
-  debug(`executeAction: spawning opencode run (detached)`);
-  const [cmd, ...cmdArgs] = cmdInfo.args;
-  const child = spawn(cmd, cmdArgs, {
-    cwd: cmdInfo.cwd,
-    detached: true,
-    stdio: 'ignore',
-  });
-  child.unref();
   
-  debug(`executeAction: spawned pid=${child.pid}`);
-  return {
-    command,
-    success: true,
-    pid: child.pid,
-    method: 'spawn',
-  };
-}
-
-/**
- * Check if opencode is available
- * @returns {Promise<boolean>}
- */
-export async function checkOpencode() {
-  return new Promise((resolve) => {
-    const child = spawn("which", ["opencode"]);
-    child.on("close", (code) => {
-      resolve(code === 0);
-    });
-    child.on("error", () => {
-      resolve(false);
-    });
+  const result = await createSessionViaApi(serverUrl, cwd, prompt, {
+    title: sessionTitle,
+    agent: config.agent,
+    model: config.model,
+    fetch: options.fetch,
   });
-}
-
-/**
- * Validate that required tools are available
- * @returns {Promise<object>} { valid: boolean, missing?: string[] }
- */
-export async function validateTools() {
-  const missing = [];
-
-  const hasOpencode = await checkOpencode();
-  if (!hasOpencode) {
-    missing.push("opencode");
-  }
-
+  
   return {
-    valid: missing.length === 0,
-    missing,
+    command: apiCommand,
+    success: result.success,
+    sessionId: result.sessionId,
+    error: result.error,
   };
 }

package/service/poll-service.js

@@ -9,7 +9,7 @@
  * 5. Track processed items to avoid duplicates
  */
 
-import { loadRepoConfig, getRepoConfig, getAllSources, getToolProviderConfig, resolveRepoForItem, getCleanupTtlDays } from "./repo-config.js";
+import { loadRepoConfig, getRepoConfig, getAllSources, getToolProviderConfig, resolveRepoForItem, getCleanupTtlDays, getStartupDelay } from "./repo-config.js";
 import { createPoller, pollGenericSource, enrichItemsWithComments } from "./poller.js";
 import { evaluateReadiness, sortByPriority } from "./readiness.js";
 import { executeAction, buildCommand } from "./actions.js";
@@ -198,6 +198,14 @@ export async function pollOnce(options = {}) {
       // Build action config from source and item (resolves repo from item fields)
       const actionConfig = buildActionConfigForItem(source, item);
 
+      // Skip items with no valid local path (prevents sessions in home directory)
+      const hasLocalPath = actionConfig.working_dir || actionConfig.path || actionConfig.repo_path;
+      if (!hasLocalPath) {
+        debug(`Skipping ${item.id} - no local path configured for repository`);
+        console.warn(`[poll] Skipping ${item.id} - no local path configured (repo not in repos_dir or explicit config)`);
+        continue;
+      }
+
       // Execute or dry-run
       if (dryRun) {
         const command = buildCommand(item, actionConfig);
@@ -232,8 +240,13 @@ export async function pollOnce(options = {}) {
             } else {
               console.log(`[poll] Started session for ${item.id}`);
             }
+          } else if (result.skipped) {
+            // Item was skipped (e.g., no local path configured) - use debug level
+            // This will retry on next poll, but doesn't spam logs
+            debug(`Skipped ${item.id}: ${result.error}`);
           } else {
-            console.error(`[poll] Failed to start session: ${result.error || result.stderr || 'unknown error'}`);
+            // Real failure - log as error
+            console.error(`[poll] Failed to start session for ${item.id}: ${result.error || result.stderr || 'unknown error'}`);
           }
         } catch (err) {
           console.error(`[poll] Error executing action: ${err.message}`);
@@ -287,12 +300,21 @@ export function startPolling(options = {}) {
     console.log(`[poll] Cleaned up ${expiredRemoved} expired state entries (older than ${ttlDays} days)`);
   }
 
-  // Run first poll immediately
-  pollOnce({ configPath }).catch((err) => {
-    console.error("[poll] Error in poll cycle:", err.message);
-  });
+  // Delay first poll to allow OpenCode server to fully initialize
+  // This prevents race conditions on startup where projects/sandboxes aren't loaded yet
+  const startupDelay = getStartupDelay();
+  if (startupDelay > 0) {
+    console.log(`[poll] Waiting ${startupDelay / 1000}s for server to initialize...`);
+  }
+  
+  // Schedule first poll after startup delay (or immediately if delay is 0)
+  setTimeout(() => {
+    pollOnce({ configPath }).catch((err) => {
+      console.error("[poll] Error in poll cycle:", err.message);
+    });
+  }, startupDelay);
 
-  // Start interval
+  // Start interval (runs after startup delay + interval for first scheduled poll)
   pollingInterval = setInterval(() => {
     pollOnce({ configPath }).catch((err) => {
       console.error("[poll] Error in poll cycle:", err.message);

package/service/repo-config.js

@@ -62,6 +62,7 @@ function parseGitHubRepo(url) {
 
 /**
  * Discover repos from a repos_dir by scanning git remotes
+ * Checks both 'origin' and 'upstream' remotes to support fork workflows
  * @param {string} reposDir - Directory containing git repositories
  * @returns {Map<string, object>} Map of "owner/repo" -> { path }
  */
@@ -90,20 +91,24 @@ function discoverRepos(reposDir) {
       // Skip if not a git repo
       if (!fs.existsSync(gitDir)) continue;
       
-      // Get remote origin URL via git API
-      try {
-        const remoteUrl = execSync('git remote get-url origin', {
-          cwd: repoPath,
-          encoding: 'utf-8',
-          stdio: ['pipe', 'pipe', 'pipe']
-        }).trim();
-        
-        const repoKey = parseGitHubRepo(remoteUrl);
-        if (repoKey) {
-          discovered.set(repoKey, { path: repoPath });
+      // Check both origin and upstream remotes to support fork workflows
+      // e.g., origin = athal7/opencode (fork), upstream = anomalyco/opencode (original)
+      // Both should resolve to the same local path
+      for (const remote of ['origin', 'upstream']) {
+        try {
+          const remoteUrl = execSync(`git remote get-url ${remote}`, {
+            cwd: repoPath,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe']
+          }).trim();
+          
+          const repoKey = parseGitHubRepo(remoteUrl);
+          if (repoKey) {
+            discovered.set(repoKey, { path: repoPath });
+          }
+        } catch {
+          // Skip if remote doesn't exist or git errors
         }
-      } catch {
-        // Skip repos without origin or git errors
       }
     }
   } catch {
@@ -426,6 +431,16 @@ export function getServerPort() {
   return config?.server_port ?? null;
 }
 
+/**
+ * Get startup delay from config (ms to wait before first poll)
+ * This allows OpenCode server time to fully initialize after restart
+ * @returns {number} Startup delay in ms (default: 10000 = 10 seconds)
+ */
+export function getStartupDelay() {
+  const config = getRawConfig();
+  return config?.startup_delay ?? 10000;
+}
+
 /**
  * Clear config cache (for testing)
  */

package/service/server.js

@@ -166,6 +166,20 @@ if (isMainModule()) {
   
   console.log('[opencode-pilot] Starting service...')
   
+  // Handle uncaught exceptions - log and exit to prevent silent crashes
+  process.on('uncaughtException', (err) => {
+    console.error('[opencode-pilot] Uncaught exception:', err.message)
+    console.error(err.stack)
+    process.exit(1)
+  })
+  
+  // Handle unhandled promise rejections - log and exit to prevent silent crashes
+  process.on('unhandledRejection', (reason, promise) => {
+    console.error('[opencode-pilot] Unhandled rejection at:', promise)
+    console.error('[opencode-pilot] Reason:', reason)
+    process.exit(1)
+  })
+  
   startService(config).then((service) => {
     // Handle graceful shutdown
     process.on('SIGTERM', async () => {

package/test/unit/actions.test.js

@@ -160,137 +160,32 @@ describe('actions.js', () => {
 
   });
 
-  describe('getCommandInfoNew', () => {
-    test('builds command with all options', async () => {
-      writeFileSync(join(templatesDir, 'default.md'), '{title}\n\n{body}');
-      
-      const { getCommandInfoNew } = await import('../../service/actions.js');
+  describe('buildCommand', () => {
+    test('builds display string for API call', async () => {
+      const { buildCommand } = await import('../../service/actions.js');
       
-      const item = { number: 123, title: 'Fix bug', body: 'Details' };
+      const item = { number: 123, title: 'Fix bug' };
       const config = {
         path: '~/code/backend',
-        prompt: 'default',
-        agent: 'coder',
         session: { name: 'issue-{number}' }
       };
       
-      const cmdInfo = getCommandInfoNew(item, config, templatesDir);
-      
-      assert.strictEqual(cmdInfo.cwd, join(homedir(), 'code/backend'));
-      assert.ok(cmdInfo.args.includes('opencode'));
-      assert.ok(cmdInfo.args.includes('run'));
-      assert.ok(cmdInfo.args.includes('--title'));
-      assert.ok(cmdInfo.args.includes('issue-123'));
-      assert.ok(cmdInfo.args.includes('--agent'));
-      assert.ok(cmdInfo.args.includes('coder'));
-    });
-
-    test('uses working_dir when no path', async () => {
-      const { getCommandInfoNew } = await import('../../service/actions.js');
-      
-      const item = { id: 'reminder-1', title: 'Do something' };
-      const config = {
-        working_dir: '~/scratch',
-        prompt: 'default'
-      };
-      
-      const cmdInfo = getCommandInfoNew(item, config, templatesDir);
+      const result = buildCommand(item, config);
       
-      assert.strictEqual(cmdInfo.cwd, join(homedir(), 'scratch'));
+      assert.ok(result.includes('[API]'), 'Should indicate API call');
+      assert.ok(result.includes('/session'), 'Should include session endpoint');
+      assert.ok(result.includes('issue-123'), 'Should include expanded session name');
     });
 
-    test('defaults to home dir when no path or working_dir', async () => {
-      const { getCommandInfoNew } = await import('../../service/actions.js');
+    test('shows (no path) when path not configured', async () => {
+      const { buildCommand } = await import('../../service/actions.js');
       
       const item = { title: 'Do something' };
       const config = { prompt: 'default' };
       
-      const cmdInfo = getCommandInfoNew(item, config, templatesDir);
-      
-      assert.strictEqual(cmdInfo.cwd, homedir());
-    });
-
-    test('includes prompt from template as message', async () => {
-      writeFileSync(join(templatesDir, 'devcontainer.md'), '/devcontainer issue-{number}\n\n{title}\n\n{body}');
-      
-      const { getCommandInfoNew } = await import('../../service/actions.js');
-      
-      const item = { number: 66, title: 'Fix bug', body: 'Details' };
-      const config = {
-        path: '~/code/backend',
-        prompt: 'devcontainer'
-      };
-      
-      const cmdInfo = getCommandInfoNew(item, config, templatesDir);
-      
-      // Should NOT have --command flag (slash command is in template)
-      assert.ok(!cmdInfo.args.includes('--command'), 'Should not include --command flag');
-      
-      // Prompt should include the /devcontainer command
-      const lastArg = cmdInfo.args[cmdInfo.args.length - 1];
-      assert.ok(lastArg.includes('/devcontainer issue-66'), 'Prompt should include /devcontainer command');
-      assert.ok(lastArg.includes('Fix bug'), 'Prompt should include title');
-    });
-
-    test('includes --attach when serverUrl is provided', async () => {
-      const { getCommandInfoNew } = await import('../../service/actions.js');
-      
-      const item = { number: 123, title: 'Fix bug' };
-      const config = {
-        path: '~/code/backend',
-        prompt: 'default'
-      };
-      
-      const cmdInfo = getCommandInfoNew(item, config, templatesDir, 'http://localhost:4096');
-      
-      assert.ok(cmdInfo.args.includes('--attach'), 'Should include --attach flag');
-      assert.ok(cmdInfo.args.includes('http://localhost:4096'), 'Should include server URL');
-    });
-
-    test('does not include --attach when serverUrl is null', async () => {
-      const { getCommandInfoNew } = await import('../../service/actions.js');
-      
-      const item = { number: 123, title: 'Fix bug' };
-      const config = {
-        path: '~/code/backend',
-        prompt: 'default'
-      };
-      
-      const cmdInfo = getCommandInfoNew(item, config, templatesDir, null);
-      
-      assert.ok(!cmdInfo.args.includes('--attach'), 'Should not include --attach flag');
-    });
-
-    test('uses item title as session name when no session.name configured', async () => {
-      const { getCommandInfoNew } = await import('../../service/actions.js');
-      
-      const item = { id: 'reminder-123', title: 'Review quarterly reports' };
-      const config = {
-        path: '~/code/backend',
-        prompt: 'default'
-      };
-      
-      const cmdInfo = getCommandInfoNew(item, config, templatesDir);
-      
-      const titleIndex = cmdInfo.args.indexOf('--title');
-      assert.ok(titleIndex !== -1, 'Should have --title flag');
-      assert.strictEqual(cmdInfo.args[titleIndex + 1], 'Review quarterly reports', 'Should use item title as session name');
-    });
-
-    test('falls back to timestamp when no session.name and no title', async () => {
-      const { getCommandInfoNew } = await import('../../service/actions.js');
+      const result = buildCommand(item, config);
       
-      const item = { id: 'item-123' };
-      const config = {
-        path: '~/code/backend',
-        prompt: 'default'
-      };
-      
-      const cmdInfo = getCommandInfoNew(item, config, templatesDir);
-      
-      const titleIndex = cmdInfo.args.indexOf('--title');
-      assert.ok(titleIndex !== -1, 'Should have --title flag');
-      assert.ok(cmdInfo.args[titleIndex + 1].startsWith('session-'), 'Should fall back to session-{timestamp}');
+      assert.ok(result.includes('(no path)'), 'Should indicate missing path');
     });
   });
 
@@ -543,13 +438,12 @@ describe('actions.js', () => {
       });
       
       assert.ok(result.dryRun);
-      assert.strictEqual(result.method, 'api', 'Should use API method when server found');
       assert.ok(result.command.includes('POST'), 'Command should show POST request');
       assert.ok(result.command.includes('http://localhost:4096'), 'Command should include server URL');
       assert.ok(result.command.includes('directory='), 'Command should include directory param');
     });
 
-    test('falls back to spawn when no server discovered (dry run)', async () => {
+    test('returns error when no server discovered', async () => {
       const { executeAction } = await import('../../service/actions.js');
       
       const item = { number: 123, title: 'Fix bug' };
@@ -566,10 +460,50 @@ describe('actions.js', () => {
         discoverServer: mockDiscoverServer
       });
       
-      assert.ok(result.dryRun);
-      assert.strictEqual(result.method, 'spawn', 'Should use spawn method when no server');
-      assert.ok(!result.command.includes('--attach'), 'Command should not include --attach flag');
-      assert.ok(result.command.includes('opencode run'), 'Command should include opencode run');
+      assert.strictEqual(result.success, false, 'Should fail when no server');
+      assert.ok(result.error.includes('No OpenCode server'), 'Should have descriptive error');
+    });
+
+    test('skips item when no local path is configured', async () => {
+      const { executeAction } = await import('../../service/actions.js');
+      
+      const item = { number: 123, title: 'PR from unknown fork' };
+      // Config with no path/working_dir - simulates unknown repo
+      const config = {
+        prompt: 'default'
+        // Note: no path, working_dir, or repo_path - simulates unknown repo
+      };
+      
+      const result = await executeAction(item, config, { dryRun: true });
+      
+      assert.strictEqual(result.success, false, 'Should fail when no path configured');
+      assert.strictEqual(result.skipped, true, 'Should mark as skipped');
+      assert.ok(result.error.includes('No local path configured'), 'Should have descriptive error');
+    });
+
+    test('allows any path when working_dir is explicitly set', async () => {
+      const { executeAction } = await import('../../service/actions.js');
+      const os = await import('os');
+      
+      const item = { number: 123, title: 'Global task' };
+      // Explicit working_dir to home - user intentionally wants this
+      const config = {
+        working_dir: os.homedir(),
+        prompt: 'default'
+      };
+      
+      // Mock server discovery
+      const mockDiscoverServer = async () => 'http://localhost:4096';
+      
+      // Should not skip because working_dir is explicitly set
+      const result = await executeAction(item, config, { 
+        dryRun: true,
+        discoverServer: mockDiscoverServer,
+        fetch: async () => ({ ok: false, text: async () => 'Not found' })
+      });
+      
+      // It won't succeed (no valid session endpoint mock) but it shouldn't be skipped
+      assert.notStrictEqual(result.skipped, true, 'Should NOT skip when working_dir is explicit');
     });
 
     test('creates new worktree when worktree: "new" is configured (dry run)', async () => {
@@ -615,7 +549,6 @@ describe('actions.js', () => {
       });
       
       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');
@@ -655,7 +588,6 @@ describe('actions.js', () => {
       });
       
       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');
     });
@@ -692,7 +624,6 @@ describe('actions.js', () => {
       });
       
       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');

package/test/unit/repo-config.test.js

@@ -216,6 +216,29 @@ repos_dir: ${reposDir}
       assert.deepStrictEqual(config, {});
     });
 
+    test('discovers repos from upstream remote for fork workflows', async () => {
+      // Create a repo with both origin (fork) and upstream (original) remotes
+      const repoPath = join(reposDir, 'opencode');
+      mkdirSync(repoPath);
+      execSync('git init', { cwd: repoPath, stdio: 'ignore' });
+      execSync('git remote add origin https://github.com/athal7/opencode.git', { cwd: repoPath, stdio: 'ignore' });
+      execSync('git remote add upstream https://github.com/anomalyco/opencode.git', { cwd: repoPath, stdio: 'ignore' });
+
+      writeFileSync(configPath, `
+repos_dir: ${reposDir}
+`);
+
+      const { loadRepoConfig, getRepoConfig } = await import('../../service/repo-config.js');
+      loadRepoConfig(configPath);
+      
+      // Both the fork (origin) and original (upstream) should resolve to the same local path
+      const forkConfig = getRepoConfig('athal7/opencode');
+      const upstreamConfig = getRepoConfig('anomalyco/opencode');
+      
+      assert.strictEqual(forkConfig.path, repoPath, 'fork (origin) should resolve');
+      assert.strictEqual(upstreamConfig.path, repoPath, 'upstream should also resolve');
+    });
+
   });
 
   describe('sources', () => {