fix: v0.4.0 bug fixes — daemon crash, GUI reactivity, CLI wildfire chaining

- Daemon: hasAppBundle() pre-check + @try/@catch for macOS notifications outside .app bundle
- Daemon: strip CLAUDECODE env var from agent subprocess to prevent nesting issues
- Daemon: serialize tray updates through single goroutine to prevent concurrent Cocoa crashes
- Daemon: fix agent manager deadlock by running onChangeFn in goroutine during state persist
- GUI: optimistic local store update for project color changes
- GUI: remove flawed shallowEqualArray check that suppressed task store updates
- CLI: handle stream errors gracefully in wildfire/start-all chaining mode

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: nunocoracao

CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [0.4.0] Ember
+
+### Fixed
+
+- Daemon crash (exit code 2) when macOS notification fires outside `.app` bundle — `hasAppBundle()` pre-check and `@try/@catch` prevent `NSInternalInconsistencyException`
+- Agent subprocess inheriting `CLAUDECODE` env var — stripped from child process environment to prevent Claude Code nesting issues
+- Project color not updating in sidebar/dashboard after changing in settings — optimistic local store update now re-renders immediately
+- Tasks not updating in GUI when chat agent creates them on disk — removed flawed shallow comparison that suppressed store updates from protobuf-es objects
+- CLI wildfire/start-all crashing with "stream error: no agent running" during task transitions — stream errors are now handled gracefully in chaining mode
+- System tray concurrent update crashes — serialized Cocoa API calls through a single goroutine with debouncing
+- Agent manager deadlock when `onChangeFn` calls `ListAgents()` during state persist — moved callback to a goroutine
+
 ## [0.3.0] Ember
 
 ### Added

gui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "watchfire",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "description": "Remote control for AI coding agents",
   "main": "./out/main/index.js",
   "scripts": {

gui/src/renderer/src/stores/projects-store.ts

@@ -12,6 +12,7 @@ interface ProjectsState {
   fetchProjects: () => Promise<void>
   fetchAgentStatus: (projectId: string) => Promise<void>
   fetchAllAgentStatuses: () => Promise<void>
+  updateProjectLocal: (projectId: string, updates: Partial<Project>) => void
   reorderProjects: (projectIds: string[]) => Promise<void>
   removeProject: (projectId: string) => Promise<void>
 }
@@ -56,6 +57,14 @@ export const useProjectsStore = create<ProjectsState>((set, get) => ({
     }
   },
 
+  updateProjectLocal: (projectId, updates) => {
+    set((s) => ({
+      projects: s.projects.map((p) =>
+        p.projectId === projectId ? { ...p, ...updates } : p
+      )
+    }))
+  },
+
   reorderProjects: async (projectIds) => {
     // Optimistic local reorder
     const { projects } = get()

gui/src/renderer/src/stores/tasks-store.ts

@@ -1,7 +1,6 @@
 import { create } from 'zustand'
 import type { Task } from '../generated/watchfire_pb'
 import { getTaskClient } from '../lib/grpc-client'
-import { shallowEqualArray } from '../lib/utils'
 
 interface TasksState {
   tasks: Record<string, Task[]>
@@ -37,11 +36,6 @@ export const useTasksStore = create<TasksState>((set, get) => ({
     try {
       const client = getTaskClient()
       const resp = await client.listTasks({ projectId, includeDeleted })
-      const existing = get().tasks[projectId]
-      if (existing && shallowEqualArray(existing as Record<string, unknown>[], resp.tasks as Record<string, unknown>[])) {
-        set({ loading: false })
-        return
-      }
       set((s) => ({
         tasks: { ...s.tasks, [projectId]: resp.tasks },
         loading: false

gui/src/renderer/src/views/ProjectView/SettingsTab.tsx

@@ -39,16 +39,18 @@ export function SettingsTab({ projectId, project }: Props) {
   }, [project])
 
   const fetchProjects = useProjectsStore((s) => s.fetchProjects)
+  const updateProjectLocal = useProjectsStore((s) => s.updateProjectLocal)
 
   const save = useCallback(async (updates: Record<string, unknown>) => {
+    updateProjectLocal(projectId, updates as Partial<Project>)
     try {
       const client = getProjectClient()
       await client.updateProject({ projectId, ...updates })
       await fetchProjects()
     } catch (err) {
       toast('Failed to save settings', 'error')
     }
-  }, [projectId, fetchProjects])
+  }, [projectId, fetchProjects, updateProjectLocal])
 
   const debouncedSave = (updates: Record<string, unknown>) => {
     if (timerRef.current) clearTimeout(timerRef.current)

internal/cli/agent.go

@@ -202,11 +202,14 @@ func streamOutput(ctx context.Context, stream pb.AgentService_SubscribeRawOutput
 		chunk, err := stream.Recv()
 		if err != nil {
 			if err == io.EOF || ctx.Err() != nil {
-				// Stream ended
-			} else {
+				// Stream ended normally
+			} else if !isChaining {
+				// Non-chaining: unexpected stream error is fatal
 				_ = term.Restore(int(os.Stdin.Fd()), oldState)
 				return fmt.Errorf("stream error: %w", err)
 			}
+			// In chaining mode, stream errors (e.g. "no agent running") are
+			// expected during task transitions — fall through to re-subscribe.
 
 			// Non-chaining modes: done
 			if !isChaining {

internal/daemon/agent/manager.go

@@ -603,7 +603,9 @@ func (m *Manager) persistStateLocked() {
 		log.Printf("Failed to persist agent state: %v", err)
 	}
 
-	// Notify tray/listeners of state change
+	// Notify tray/listeners of state change in a goroutine.
+	// Must use goroutine because onChangeFn calls ListAgents() which needs m.mu.RLock(),
+	// and persistStateLocked is called while m.mu is write-locked.
 	if m.onChangeFn != nil {
 		go m.onChangeFn()
 	}

internal/daemon/agent/sandbox.go

@@ -128,6 +128,7 @@ func SpawnSandboxed(homeDir, projectDir, command string, args ...string) (*exec.
 
 	// Set environment
 	env := os.Environ()
+	env = removeEnv(env, "CLAUDECODE") // prevent nested-session detection
 	env = setEnv(env, "TERM", "xterm-256color")
 	env = setEnv(env, "COLORTERM", "truecolor")
 
@@ -144,6 +145,17 @@ func SpawnSandboxed(homeDir, projectDir, command string, args ...string) (*exec.
 	return cmd, tmpFile.Name(), nil
 }
 
+// removeEnv removes an environment variable from a slice.
+func removeEnv(env []string, key string) []string {
+	prefix := key + "="
+	for i, e := range env {
+		if strings.HasPrefix(e, prefix) {
+			return append(env[:i], env[i+1:]...)
+		}
+	}
+	return env
+}
+
 // setEnv sets or replaces an environment variable in a slice.
 func setEnv(env []string, key, value string) []string {
 	prefix := key + "="

internal/daemon/notify/notify_darwin.m

@@ -4,37 +4,56 @@
 
 void SetDarwinAppIcon(const void *data, int len) {
     @autoreleasepool {
-        NSData *imgData = [NSData dataWithBytes:data length:len];
-        NSImage *icon = [[NSImage alloc] initWithData:imgData];
-        if (icon) {
-            [NSApp setApplicationIconImage:icon];
+        @try {
+            NSData *imgData = [NSData dataWithBytes:data length:len];
+            NSImage *icon = [[NSImage alloc] initWithData:imgData];
+            if (icon) {
+                [NSApp setApplicationIconImage:icon];
+            }
+        } @catch (NSException *exception) {
+            NSLog(@"Watchfire: set app icon failed: %@", exception.reason);
         }
     }
 }
 
+// Returns YES if the process has a valid app bundle (required for UNUserNotificationCenter).
+static BOOL hasAppBundle(void) {
+    NSBundle *bundle = [NSBundle mainBundle];
+    return bundle != nil && [bundle bundleIdentifier] != nil;
+}
+
 void SendDarwinNotification(const char *title, const char *message) {
     @autoreleasepool {
-        UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter];
-
-        // Request authorization (no-op after first grant).
-        [center requestAuthorizationWithOptions:(UNAuthorizationOptionAlert | UNAuthorizationOptionSound)
-                             completionHandler:^(BOOL granted, NSError *error) {}];
-
-        UNMutableNotificationContent *content = [[UNMutableNotificationContent alloc] init];
-        content.title = [NSString stringWithUTF8String:title];
-        content.body  = [NSString stringWithUTF8String:message];
-        content.sound = [UNNotificationSound defaultSound];
-
-        NSString *identifier = [[NSUUID UUID] UUIDString];
-        UNNotificationRequest *request =
-            [UNNotificationRequest requestWithIdentifier:identifier
-                                                 content:content
-                                                 trigger:nil];
-
-        [center addNotificationRequest:request withCompletionHandler:^(NSError *error) {
-            if (error) {
-                NSLog(@"Watchfire notification error: %@", error);
+        @try {
+            if (!hasAppBundle()) {
+                NSLog(@"Watchfire: skipping notification (no app bundle)");
+                return;
             }
-        }];
+
+            UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter];
+
+            // Request authorization (no-op after first grant).
+            [center requestAuthorizationWithOptions:(UNAuthorizationOptionAlert | UNAuthorizationOptionSound)
+                                 completionHandler:^(BOOL granted, NSError *error) {}];
+
+            UNMutableNotificationContent *content = [[UNMutableNotificationContent alloc] init];
+            content.title = [NSString stringWithUTF8String:title];
+            content.body  = [NSString stringWithUTF8String:message];
+            content.sound = [UNNotificationSound defaultSound];
+
+            NSString *identifier = [[NSUUID UUID] UUIDString];
+            UNNotificationRequest *request =
+                [UNNotificationRequest requestWithIdentifier:identifier
+                                                     content:content
+                                                     trigger:nil];
+
+            [center addNotificationRequest:request withCompletionHandler:^(NSError *error) {
+                if (error) {
+                    NSLog(@"Watchfire notification error: %@", error);
+                }
+            }];
+        } @catch (NSException *exception) {
+            NSLog(@"Watchfire: notification failed: %@", exception.reason);
+        }
     }
 }

internal/daemon/tray/tray.go

@@ -28,6 +28,11 @@ var (
 	onExit   func()
 	portItem *systray.MenuItem
 
+	// Serialized tray update channel (prevents concurrent Cocoa API calls)
+	updateCh chan struct{}  // signal channel
+	updateMu sync.Mutex    // protects latestAgents
+	latestAgents []AgentInfo
+
 	// Dynamic tray icons
 	iconIdle   []byte
 	iconActive []byte
@@ -131,6 +136,10 @@ func onReady() {
 	// Initialize previous agents map
 	previousAgents = make(map[string]AgentInfo)
 
+	// Start serialized tray update processor
+	updateCh = make(chan struct{}, 1)
+	go processUpdates()
+
 	// Start the daemon services
 	if onStart != nil {
 		onStart()
@@ -275,8 +284,49 @@ func startProjectAtSlot(slot int, mode string) {
 	go state.StartAgent(projectID, mode)
 }
 
-// UpdateAgents refreshes the agent menu items, project slots, tray icon, and tooltip.
+// UpdateAgents sends an agent update to the serialized update processor.
+// This is non-blocking and safe to call from any goroutine concurrently.
 func UpdateAgents(agents []AgentInfo) {
+	updateMu.Lock()
+	latestAgents = agents
+	updateMu.Unlock()
+
+	// Signal that there's an update (non-blocking)
+	select {
+	case updateCh <- struct{}{}:
+	default:
+		// Signal already pending — processUpdates will pick up latestAgents
+	}
+}
+
+// processUpdates drains updateCh and applies updates serially with debouncing.
+// This ensures all systray/Cocoa API calls happen on a single goroutine.
+func processUpdates() {
+	for range updateCh {
+		// Debounce: wait briefly for more updates before applying
+		time.Sleep(50 * time.Millisecond)
+
+		// Drain any pending signals
+	drain:
+		for {
+			select {
+			case <-updateCh:
+			default:
+				break drain
+			}
+		}
+
+		// Read the latest agents snapshot
+		updateMu.Lock()
+		agents := latestAgents
+		updateMu.Unlock()
+
+		applyAgentUpdate(agents)
+	}
+}
+
+// applyAgentUpdate performs the actual systray updates. Only called from processUpdates.
+func applyAgentUpdate(agents []AgentInfo) {
 	// Detect agent completions for notifications
 	detectCompletions(previousAgents, agents)