Improve auto-loop event emission and add ntfy notifications

.gitignore

@@ -71,7 +71,7 @@ test/agent-session-test-*/
 test/feature-backlog-test-*/
 test/running-task-display-test-*/
 test/agent-output-modal-responsive-*/
-test/fixtures/.worker-*/
+test/fixtures/
 test/board-bg-test-*/
 test/edit-feature-test-*/
 test/open-project-test-*/

apps/server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@automaker/server",
-  "version": "0.15.0",
+  "version": "1.0.0",
   "description": "Backend server for Automaker - provides API for both web and Electron modes",
   "author": "AutoMaker Team",
   "license": "SEE LICENSE IN LICENSE",

apps/server/src/services/auto-loop-coordinator.ts

@@ -15,6 +15,12 @@ const logger = createLogger('AutoLoopCoordinator');
 const CONSECUTIVE_FAILURE_THRESHOLD = 3;
 const FAILURE_WINDOW_MS = 60000;
 
+// Sleep intervals for the auto-loop (in milliseconds)
+const SLEEP_INTERVAL_CAPACITY_MS = 5000;
+const SLEEP_INTERVAL_IDLE_MS = 10000;
+const SLEEP_INTERVAL_NORMAL_MS = 2000;
+const SLEEP_INTERVAL_ERROR_MS = 5000;
+
 export interface AutoModeConfig {
   maxConcurrency: number;
   useWorktrees: boolean;
@@ -169,20 +175,32 @@ export class AutoLoopCoordinator {
         // presence is accounted for when deciding whether to dispatch new auto-mode tasks.
         const runningCount = await this.getRunningCountForWorktree(projectPath, branchName);
         if (runningCount >= projectState.config.maxConcurrency) {
-          await this.sleep(5000, projectState.abortController.signal);
+          await this.sleep(SLEEP_INTERVAL_CAPACITY_MS, projectState.abortController.signal);
           continue;
         }
         const pendingFeatures = await this.loadPendingFeaturesFn(projectPath, branchName);
         if (pendingFeatures.length === 0) {
           if (runningCount === 0 && !projectState.hasEmittedIdleEvent) {
-            this.eventBus.emitAutoModeEvent('auto_mode_idle', {
-              message: 'No pending features - auto mode idle',
+            // Double-check that we have no features in 'in_progress' state that might
+            // have been released from the concurrency manager but not yet updated to
+            // their final status. This prevents auto_mode_idle from firing prematurely
+            // when features are transitioning states (e.g., during status update).
+            const hasInProgressFeatures = await this.hasInProgressFeaturesForWorktree(
               projectPath,
-              branchName,
-            });
-            projectState.hasEmittedIdleEvent = true;
+              branchName
+            );
+
+            // Only emit auto_mode_idle if we're truly done with all features
+            if (!hasInProgressFeatures) {
+              this.eventBus.emitAutoModeEvent('auto_mode_idle', {
+                message: 'No pending features - auto mode idle',
+                projectPath,
+                branchName,
+              });
+              projectState.hasEmittedIdleEvent = true;
+            }
           }
-          await this.sleep(10000, projectState.abortController.signal);
+          await this.sleep(SLEEP_INTERVAL_IDLE_MS, projectState.abortController.signal);
           continue;
         }
 
@@ -228,10 +246,10 @@ export class AutoLoopCoordinator {
             }
           });
         }
-        await this.sleep(2000, projectState.abortController.signal);
+        await this.sleep(SLEEP_INTERVAL_NORMAL_MS, projectState.abortController.signal);
       } catch {
         if (projectState.abortController.signal.aborted) break;
-        await this.sleep(5000, projectState.abortController.signal);
+        await this.sleep(SLEEP_INTERVAL_ERROR_MS, projectState.abortController.signal);
       }
     }
     projectState.isRunning = false;
@@ -462,4 +480,48 @@ export class AutoLoopCoordinator {
       signal?.addEventListener('abort', onAbort);
     });
   }
+
+  /**
+   * Check if a feature belongs to the current worktree based on branch name.
+   * For main worktree (branchName === null or 'main'): includes features with no branchName or branchName === 'main'.
+   * For feature worktrees (branchName !== null and !== 'main'): only includes features with matching branchName.
+   */
+  private featureBelongsToWorktree(feature: Feature, branchName: string | null): boolean {
+    const isMainWorktree = branchName === null || branchName === 'main';
+    if (isMainWorktree) {
+      // Main worktree: include features with no branchName or branchName === 'main'
+      return !feature.branchName || feature.branchName === 'main';
+    } else {
+      // Feature worktree: only include exact branch match
+      return feature.branchName === branchName;
+    }
+  }
+
+  /**
+   * Check if there are features in 'in_progress' status for the current worktree.
+   * This prevents auto_mode_idle from firing prematurely when features are
+   * transitioning states (e.g., during status update from in_progress to completed).
+   */
+  private async hasInProgressFeaturesForWorktree(
+    projectPath: string,
+    branchName: string | null
+  ): Promise<boolean> {
+    if (!this.loadAllFeaturesFn) {
+      return false;
+    }
+
+    try {
+      const allFeatures = await this.loadAllFeaturesFn(projectPath);
+      return allFeatures.some(
+        (f) => f.status === 'in_progress' && this.featureBelongsToWorktree(f, branchName)
+      );
+    } catch (error) {
+      const errorInfo = classifyError(error);
+      logger.warn(
+        `Failed to load all features for idle check (projectPath=${projectPath}, branchName=${branchName}): ${errorInfo.message}`,
+        error
+      );
+      return false;
+    }
+  }
 }

apps/server/src/services/event-hook-service.ts

@@ -27,7 +27,11 @@ import type {
   EventHookTrigger,
   EventHookShellAction,
   EventHookHttpAction,
+  EventHookNtfyAction,
+  NtfyEndpointConfig,
+  EventHookContext,
 } from '@automaker/types';
+import { ntfyService, type NtfyContext } from './ntfy-service.js';
 
 const execAsync = promisify(exec);
 const logger = createLogger('EventHooks');
@@ -38,19 +42,8 @@ const DEFAULT_SHELL_TIMEOUT = 30000;
 /** Default timeout for HTTP requests (10 seconds) */
 const DEFAULT_HTTP_TIMEOUT = 10000;
 
-/**
- * Context available for variable substitution in hooks
- */
-interface HookContext {
-  featureId?: string;
-  featureName?: string;
-  projectPath?: string;
-  projectName?: string;
-  error?: string;
-  errorType?: string;
-  timestamp: string;
-  eventType: EventHookTrigger;
-}
+// Use the shared EventHookContext type (aliased locally as HookContext for clarity)
+type HookContext = EventHookContext;
 
 /**
  * Auto-mode event payload structure
@@ -451,6 +444,8 @@ export class EventHookService {
         await this.executeShellHook(hook.action, context, hookName);
       } else if (hook.action.type === 'http') {
         await this.executeHttpHook(hook.action, context, hookName);
+      } else if (hook.action.type === 'ntfy') {
+        await this.executeNtfyHook(hook.action, context, hookName);
       }
     } catch (error) {
       logger.error(`Hook "${hookName}" failed:`, error);
@@ -558,6 +553,89 @@ export class EventHookService {
     }
   }
 
+  /**
+   * Execute an ntfy.sh notification hook
+   */
+  private async executeNtfyHook(
+    action: EventHookNtfyAction,
+    context: HookContext,
+    hookName: string
+  ): Promise<void> {
+    if (!this.settingsService) {
+      logger.warn('Settings service not available for ntfy hook');
+      return;
+    }
+
+    // Get the endpoint configuration
+    const settings = await this.settingsService.getGlobalSettings();
+    const endpoints = settings.ntfyEndpoints || [];
+    const endpoint = endpoints.find((e) => e.id === action.endpointId);
+
+    if (!endpoint) {
+      logger.error(`Ntfy hook "${hookName}" references unknown endpoint: ${action.endpointId}`);
+      return;
+    }
+
+    // Convert HookContext to NtfyContext
+    const ntfyContext: NtfyContext = {
+      featureId: context.featureId,
+      featureName: context.featureName,
+      projectPath: context.projectPath,
+      projectName: context.projectName,
+      error: context.error,
+      errorType: context.errorType,
+      timestamp: context.timestamp,
+      eventType: context.eventType,
+    };
+
+    // Build click URL with deep-link if project context is available
+    let clickUrl = action.clickUrl;
+    if (!clickUrl && endpoint.defaultClickUrl) {
+      clickUrl = endpoint.defaultClickUrl;
+      // If we have a project path and the click URL looks like the server URL,
+      // append deep-link path
+      if (context.projectPath && clickUrl) {
+        try {
+          const url = new URL(clickUrl);
+          // Add featureId as query param for deep linking to board with feature output modal
+          if (context.featureId) {
+            url.pathname = '/board';
+            url.searchParams.set('featureId', context.featureId);
+          } else if (context.projectPath) {
+            url.pathname = '/board';
+          }
+          clickUrl = url.toString();
+        } catch (error) {
+          // If URL parsing fails, log warning and use as-is
+          logger.warn(
+            `Failed to parse defaultClickUrl "${clickUrl}" for deep linking: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+    }
+
+    logger.info(`Executing ntfy hook "${hookName}" to endpoint "${endpoint.name}"`);
+
+    const result = await ntfyService.sendNotification(
+      endpoint,
+      {
+        title: action.title,
+        body: action.body,
+        tags: action.tags,
+        emoji: action.emoji,
+        clickUrl,
+        priority: action.priority,
+      },
+      ntfyContext
+    );
+
+    if (!result.success) {
+      logger.warn(`Ntfy hook "${hookName}" failed: ${result.error}`);
+    } else {
+      logger.info(`Ntfy hook "${hookName}" completed successfully`);
+    }
+  }
+
   /**
    * Substitute {{variable}} placeholders in a string
    */