fix: stop repeated GitHub PR fetch warnings for non-GitHub repos

apps/server/src/routes/worktree/routes/list.ts

@@ -16,10 +16,27 @@ import { isGitRepo } from '@automaker/git-utils';
 import { getErrorMessage, logError, normalizePath, execEnv, isGhCliAvailable } from '../common.js';
 import { readAllWorktreeMetadata, type WorktreePRInfo } from '../../../lib/worktree-metadata.js';
 import { createLogger } from '@automaker/utils';
+import {
+  checkGitHubRemote,
+  type GitHubRemoteStatus,
+} from '../../github/routes/check-github-remote.js';
 
 const execAsync = promisify(exec);
 const logger = createLogger('Worktree');
 
+/**
+ * Cache for GitHub remote status per project path.
+ * This prevents repeated "no git remotes found" warnings when polling
+ * projects that don't have a GitHub remote configured.
+ */
+interface GitHubRemoteCacheEntry {
+  status: GitHubRemoteStatus;
+  checkedAt: number;
+}
+
+const githubRemoteCache = new Map<string, GitHubRemoteCacheEntry>();
+const GITHUB_REMOTE_CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
+
 interface WorktreeInfo {
   path: string;
   branch: string;
@@ -121,23 +138,63 @@ async function scanWorktreesDirectory(
   return discovered;
 }
 
+/**
+ * Get cached GitHub remote status for a project, or check and cache it.
+ * Returns null if gh CLI is not available.
+ */
+async function getGitHubRemoteStatus(projectPath: string): Promise<GitHubRemoteStatus | null> {
+  // Check if gh CLI is available first
+  const ghAvailable = await isGhCliAvailable();
+  if (!ghAvailable) {
+    return null;
+  }
+
+  const now = Date.now();
+  const cached = githubRemoteCache.get(projectPath);
+
+  // Return cached result if still valid
+  if (cached && now - cached.checkedAt < GITHUB_REMOTE_CACHE_TTL_MS) {
+    return cached.status;
+  }
+
+  // Check GitHub remote and cache the result
+  const status = await checkGitHubRemote(projectPath);
+  githubRemoteCache.set(projectPath, {
+    status,
+    checkedAt: Date.now(),
+  });
+
+  return status;
+}
+
 /**
  * Fetch open PRs from GitHub and create a map of branch name to PR info.
  * This allows detecting PRs that were created outside the app.
+ *
+ * Uses cached GitHub remote status to avoid repeated warnings when the
+ * project doesn't have a GitHub remote configured.
  */
 async function fetchGitHubPRs(projectPath: string): Promise<Map<string, WorktreePRInfo>> {
   const prMap = new Map<string, WorktreePRInfo>();
 
   try {
-    // Check if gh CLI is available
-    const ghAvailable = await isGhCliAvailable();
-    if (!ghAvailable) {
+    // Check GitHub remote status (uses cache to avoid repeated warnings)
+    const remoteStatus = await getGitHubRemoteStatus(projectPath);
+
+    // If gh CLI not available or no GitHub remote, return empty silently
+    if (!remoteStatus || !remoteStatus.hasGitHubRemote) {
       return prMap;
     }
 
+    // Use -R flag with owner/repo for more reliable PR fetching
+    const repoFlag =
+      remoteStatus.owner && remoteStatus.repo
+        ? `-R ${remoteStatus.owner}/${remoteStatus.repo}`
+        : '';
+
     // Fetch open PRs from GitHub
     const { stdout } = await execAsync(
-      'gh pr list --state open --json number,title,url,state,headRefName,createdAt --limit 1000',
+      `gh pr list ${repoFlag} --state open --json number,title,url,state,headRefName,createdAt --limit 1000`,
       { cwd: projectPath, env: execEnv, timeout: 15000 }
     );
 
@@ -170,16 +227,23 @@ async function fetchGitHubPRs(projectPath: string): Promise<Map<string, Worktree
 export function createListHandler() {
   return async (req: Request, res: Response): Promise<void> => {
     try {
-      const { projectPath, includeDetails } = req.body as {
+      const { projectPath, includeDetails, forceRefreshGitHub } = req.body as {
         projectPath: string;
         includeDetails?: boolean;
+        forceRefreshGitHub?: boolean;
       };
 
       if (!projectPath) {
         res.status(400).json({ success: false, error: 'projectPath required' });
         return;
       }
 
+      // Clear GitHub remote cache if force refresh requested
+      // This allows users to re-check for GitHub remote after adding one
+      if (forceRefreshGitHub) {
+        githubRemoteCache.delete(projectPath);
+      }
+
       if (!(await isGitRepo(projectPath))) {
         res.json({ success: true, worktrees: [] });
         return;

apps/ui/src/components/views/board-view/worktree-panel/hooks/use-worktrees.ts

@@ -39,7 +39,10 @@ export function useWorktrees({
           logger.warn('Worktree API not available');
           return;
         }
-        const result = await api.worktree.listAll(projectPath, true);
+        // Pass forceRefreshGitHub when this is a manual refresh (not silent polling)
+        // This clears the GitHub remote cache so users can re-detect after adding a remote
+        const forceRefreshGitHub = !silent;
+        const result = await api.worktree.listAll(projectPath, true, forceRefreshGitHub);
         if (result.success && result.worktrees) {
           setWorktrees(result.worktrees);
           setWorktreesInStore(projectPath, result.worktrees);

apps/ui/src/lib/electron.ts

@@ -1596,10 +1596,15 @@ function createMockWorktreeAPI(): WorktreeAPI {
       return { success: true, worktrees: [] };
     },
 
-    listAll: async (projectPath: string, includeDetails?: boolean) => {
+    listAll: async (
+      projectPath: string,
+      includeDetails?: boolean,
+      forceRefreshGitHub?: boolean
+    ) => {
       console.log('[Mock] Listing all worktrees:', {
         projectPath,
         includeDetails,
+        forceRefreshGitHub,
       });
       return {
         success: true,

apps/ui/src/lib/http-api-client.ts

@@ -1724,8 +1724,8 @@ export class HttpApiClient implements ElectronAPI {
     getStatus: (projectPath: string, featureId: string) =>
       this.post('/api/worktree/status', { projectPath, featureId }),
     list: (projectPath: string) => this.post('/api/worktree/list', { projectPath }),
-    listAll: (projectPath: string, includeDetails?: boolean) =>
-      this.post('/api/worktree/list', { projectPath, includeDetails }),
+    listAll: (projectPath: string, includeDetails?: boolean, forceRefreshGitHub?: boolean) =>
+      this.post('/api/worktree/list', { projectPath, includeDetails, forceRefreshGitHub }),
     create: (projectPath: string, branchName: string, baseBranch?: string) =>
       this.post('/api/worktree/create', {
         projectPath,

apps/ui/src/types/electron.d.ts

@@ -705,7 +705,8 @@ export interface WorktreeAPI {
   // List all worktrees with details (for worktree selector)
   listAll: (
     projectPath: string,
-    includeDetails?: boolean
+    includeDetails?: boolean,
+    forceRefreshGitHub?: boolean
   ) => Promise<{
     success: boolean;
     worktrees?: Array<{