feat: add comprehensive integration tests for auto-mode-service

- Created git-test-repo helper for managing test git repositories
- Added 13 integration tests covering:
  - Worktree operations (create, error handling, non-worktree mode)
  - Feature execution (status updates, model selection, duplicate prevention)
  - Auto loop (start/stop, pending features, max concurrency, events)
  - Error handling (provider errors, continue after failures)
- Integration tests use real git operations with temporary repos
- All 416 tests passing with 72.65% overall coverage
- Service coverage improved: agent-service 58%, auto-mode-service 44%, feature-loader 66%

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

apps/server/tests/unit/lib/events.test.ts

@@ -0,0 +1,130 @@
+import { describe, it, expect, vi } from "vitest";
+import { createEventEmitter, type EventType } from "@/lib/events.js";
+
+describe("events.ts", () => {
+  describe("createEventEmitter", () => {
+    it("should emit events to single subscriber", () => {
+      const emitter = createEventEmitter();
+      const callback = vi.fn();
+
+      emitter.subscribe(callback);
+      emitter.emit("agent:stream", { message: "test" });
+
+      expect(callback).toHaveBeenCalledOnce();
+      expect(callback).toHaveBeenCalledWith("agent:stream", { message: "test" });
+    });
+
+    it("should emit events to multiple subscribers", () => {
+      const emitter = createEventEmitter();
+      const callback1 = vi.fn();
+      const callback2 = vi.fn();
+      const callback3 = vi.fn();
+
+      emitter.subscribe(callback1);
+      emitter.subscribe(callback2);
+      emitter.subscribe(callback3);
+      emitter.emit("feature:started", { id: "123" });
+
+      expect(callback1).toHaveBeenCalledOnce();
+      expect(callback2).toHaveBeenCalledOnce();
+      expect(callback3).toHaveBeenCalledOnce();
+      expect(callback1).toHaveBeenCalledWith("feature:started", { id: "123" });
+    });
+
+    it("should support unsubscribe functionality", () => {
+      const emitter = createEventEmitter();
+      const callback = vi.fn();
+
+      const unsubscribe = emitter.subscribe(callback);
+      emitter.emit("agent:stream", { test: 1 });
+
+      expect(callback).toHaveBeenCalledOnce();
+
+      unsubscribe();
+      emitter.emit("agent:stream", { test: 2 });
+
+      expect(callback).toHaveBeenCalledOnce(); // Still called only once
+    });
+
+    it("should handle errors in subscribers without crashing", () => {
+      const emitter = createEventEmitter();
+      const errorCallback = vi.fn(() => {
+        throw new Error("Subscriber error");
+      });
+      const normalCallback = vi.fn();
+      const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+      emitter.subscribe(errorCallback);
+      emitter.subscribe(normalCallback);
+
+      expect(() => {
+        emitter.emit("feature:error", { error: "test" });
+      }).not.toThrow();
+
+      expect(errorCallback).toHaveBeenCalledOnce();
+      expect(normalCallback).toHaveBeenCalledOnce();
+      expect(consoleSpy).toHaveBeenCalled();
+
+      consoleSpy.mockRestore();
+    });
+
+    it("should emit different event types", () => {
+      const emitter = createEventEmitter();
+      const callback = vi.fn();
+
+      emitter.subscribe(callback);
+
+      const eventTypes: EventType[] = [
+        "agent:stream",
+        "auto-mode:started",
+        "feature:completed",
+        "project:analysis-progress",
+      ];
+
+      eventTypes.forEach((type) => {
+        emitter.emit(type, { type });
+      });
+
+      expect(callback).toHaveBeenCalledTimes(4);
+    });
+
+    it("should handle emitting without subscribers", () => {
+      const emitter = createEventEmitter();
+
+      expect(() => {
+        emitter.emit("agent:stream", { test: true });
+      }).not.toThrow();
+    });
+
+    it("should allow multiple subscriptions and unsubscriptions", () => {
+      const emitter = createEventEmitter();
+      const callback1 = vi.fn();
+      const callback2 = vi.fn();
+      const callback3 = vi.fn();
+
+      const unsub1 = emitter.subscribe(callback1);
+      const unsub2 = emitter.subscribe(callback2);
+      const unsub3 = emitter.subscribe(callback3);
+
+      emitter.emit("feature:started", { test: 1 });
+      expect(callback1).toHaveBeenCalledOnce();
+      expect(callback2).toHaveBeenCalledOnce();
+      expect(callback3).toHaveBeenCalledOnce();
+
+      unsub2();
+
+      emitter.emit("feature:started", { test: 2 });
+      expect(callback1).toHaveBeenCalledTimes(2);
+      expect(callback2).toHaveBeenCalledOnce(); // Still just once
+      expect(callback3).toHaveBeenCalledTimes(2);
+
+      unsub1();
+      unsub3();
+
+      emitter.emit("feature:started", { test: 3 });
+      expect(callback1).toHaveBeenCalledTimes(2);
+      expect(callback2).toHaveBeenCalledOnce();
+      expect(callback3).toHaveBeenCalledTimes(2);
+    });
+  });
+});