feat(machines): Refine machine status logic and update tests

Refines the machine status logic to better reflect maintenance needs:
- Machines with only minor/cosmetic issues are now considered "Operational".
- "Needs Service" status is reserved for machines with "major" issues.
- "Unplayable" remains for machines with unplayable issues.
- Updated dashboard stats and machine list UI to reflect these changes.
- Updated unit and integration tests to align with new status criteria.
- Verified that PR feedback on types and E2E stability is already addressed.

(Note: Restoration of accidentally deleted tests for status labels and styles is included.)

Co-authored-by: timothyfroehlich <5819722+timothyfroehlich@users.noreply.github.com>

Author: google-labs-jules[bot]

src/app/(app)/m/page.tsx

@@ -257,11 +257,11 @@ export default async function MachinesPage({
                         <span
                           className={cn(
                             "font-bold",
-                            machine.openIssuesCount > 0
-                              ? machine.status === "unplayable"
-                                ? "text-error"
-                                : "text-warning"
-                              : "text-on-surface-variant"
+                            machine.status === "unplayable"
+                              ? "text-error"
+                              : machine.status === "needs_service"
+                                ? "text-warning"
+                                : "text-on-surface-variant"
                           )}
                           data-testid={`machine-open-issues-count-${machine.id}`}
                         >

src/test/integration/dashboard.test.ts

@@ -446,30 +446,33 @@ describe("Dashboard Queries (PGlite)", () => {
     it("should correctly calculate machines needing service", async () => {
       const db = await getTestDb();
 
-      // Create 4 machines
-      const [machine1, machine2, machine3] = await db
+      // Create 5 machines
+      const [machine1, machine2, machine3, machine4, machine5] = await db
         .insert(machines)
         .values([
           createTestMachine({ name: "Machine 1", initials: "M1" }),
           createTestMachine({ name: "Machine 2", initials: "M2" }),
           createTestMachine({ name: "Machine 3", initials: "M3" }),
           createTestMachine({ name: "Machine 4", initials: "M4" }),
+          createTestMachine({ name: "Machine 5", initials: "M5" }),
         ])
         .returning();
 
-      // Machine 1: open issue (needs service)
+      // Machine 1: open major issue (needs service)
       await db.insert(issues).values(
         createTestIssue(machine1.initials, {
           issueNumber: 1,
           status: "new",
+          severity: "major",
         })
       );
 
-      // Machine 2: open issue (needs service)
+      // Machine 2: open unplayable issue (needs service)
       await db.insert(issues).values(
         createTestIssue(machine2.initials, {
           issueNumber: 1,
           status: "in_progress",
+          severity: "unplayable",
         })
       );
 
@@ -483,6 +486,20 @@ describe("Dashboard Queries (PGlite)", () => {
 
       // Machine 4: no issues (operational)
 
+      // Machine 5: only minor/cosmetic open issues (operational)
+      await db.insert(issues).values([
+        createTestIssue(machine5.initials, {
+          issueNumber: 1,
+          status: "new",
+          severity: "minor",
+        }),
+        createTestIssue(machine5.initials, {
+          issueNumber: 2,
+          status: "new",
+          severity: "cosmetic",
+        }),
+      ]);
+
       // Query all machines with issues (dashboard query pattern)
       const allMachines = await db.query.machines.findMany({
         with: {

src/test/integration/machines.test.ts

@@ -178,7 +178,7 @@ describe("Machine CRUD Operations (PGlite)", () => {
       expect(status).toBe("operational");
     });
 
-    it("should derive 'needs_service' status when machine has playable/minor issues", async () => {
+    it("should derive 'needs_service' status when machine has major issues", async () => {
       const db = await getTestDb();
 
       // Create machine
@@ -225,6 +225,53 @@ describe("Machine CRUD Operations (PGlite)", () => {
       expect(status).toBe("needs_service");
     });
 
+    it("should derive 'operational' status when machine has only minor/cosmetic issues", async () => {
+      const db = await getTestDb();
+
+      // Create machine
+      const testMachine = createTestMachine({
+        name: "Operational with issues",
+        initials: "OWI",
+      });
+      const [machine] = await db
+        .insert(machines)
+        .values(testMachine)
+        .returning();
+
+      // Create minor and cosmetic issues
+      await db.insert(issues).values([
+        createTestIssue(machine.initials, {
+          title: "Minor issue",
+          issueNumber: 1,
+          severity: "minor",
+          status: "new",
+        }),
+        createTestIssue(machine.initials, {
+          title: "Cosmetic issue",
+          issueNumber: 2,
+          severity: "cosmetic",
+          status: "new",
+        }),
+      ]);
+
+      // Query machine with issues
+      const result = await db.query.machines.findFirst({
+        where: eq(machines.id, machine.id),
+        with: {
+          issues: {
+            columns: {
+              status: true,
+              severity: true,
+            },
+          },
+        },
+      });
+
+      // Derive status
+      const status = deriveMachineStatus(result?.issues ?? []);
+      expect(status).toBe("operational");
+    });
+
     it("should derive 'unplayable' status when machine has at least one unplayable issue", async () => {
       const db = await getTestDb();
 
@@ -285,7 +332,7 @@ describe("Machine CRUD Operations (PGlite)", () => {
         .values(testMachine)
         .returning();
 
-      // Create fixed unplayable issue and open minor issue
+      // Create fixed unplayable issue and open major issue
       await db.insert(issues).values([
         createTestIssue(machine.initials, {
           title: "Fixed unplayable issue",
@@ -295,9 +342,9 @@ describe("Machine CRUD Operations (PGlite)", () => {
           closedAt: new Date(),
         }),
         createTestIssue(machine.initials, {
-          title: "Current minor issue",
+          title: "Current major issue",
           issueNumber: 2,
-          severity: "minor",
+          severity: "major",
           status: "new",
         }),
       ]);