fix(staged): properly revert changes when dragging back to original column

- stageChange now preserves the original "from" column and detects when
  a bug is dragged back to it, clearing the staged change correctly
- Auto-stage qe-verify+ flag when moving bugs to in-testing column,
  ensuring bugs have both RESOLVED-FIXED status and qe-verify+ flag

Author: msujaws

src/App.test.tsx

@@ -375,4 +375,76 @@ describe('App', () => {
       expect(replaceStateMock).not.toHaveBeenCalled()
     })
   })
+
+  describe('handleBugMove side effects', () => {
+    beforeEach(() => {
+      useStore.setState({
+        apiKey: 'test-api-key',
+        isValid: true,
+        isValidating: false,
+        changes: new Map(),
+        bugs: [
+          {
+            id: 123,
+            summary: 'Test bug',
+            status: 'ASSIGNED',
+            assigned_to: 'dev@test.com',
+            priority: 'P2',
+            severity: 'normal',
+            component: 'Core',
+            whiteboard: '',
+            last_change_time: '2024-01-01T00:00:00Z',
+            creation_time: '2024-01-01T00:00:00Z',
+          },
+        ],
+      })
+    })
+
+    it('should stage qe-verify plus when moving bug to in-testing column', () => {
+      const { stageChange, stageQeVerifyChange } = useStore.getState()
+
+      // Simulate handleBugMove for in-testing: should stage both status and qe-verify
+      stageChange(123, 'in-progress', 'in-testing')
+      stageQeVerifyChange(123, 'unknown', 'plus')
+
+      const { changes } = useStore.getState()
+      const change = changes.get(123)
+
+      expect(change?.status).toEqual({ from: 'in-progress', to: 'in-testing' })
+      expect(change?.qeVerify).toEqual({ from: 'unknown', to: 'plus' })
+    })
+
+    it('should NOT stage qe-verify when bug already has qe-verify plus', () => {
+      // Set up a bug that already has qe-verify+
+      useStore.setState({
+        bugs: [
+          {
+            id: 123,
+            summary: 'Test bug',
+            status: 'RESOLVED',
+            resolution: 'FIXED',
+            assigned_to: 'dev@test.com',
+            priority: 'P2',
+            severity: 'normal',
+            component: 'Core',
+            whiteboard: '',
+            last_change_time: '2024-01-01T00:00:00Z',
+            creation_time: '2024-01-01T00:00:00Z',
+            flags: [{ name: 'qe-verify', status: '+' }],
+          },
+        ],
+      })
+
+      const { stageChange } = useStore.getState()
+
+      // When bug already has qe-verify+, moving to in-testing shouldn't add qeVerify change
+      stageChange(123, 'done', 'in-testing')
+
+      const { changes } = useStore.getState()
+      const change = changes.get(123)
+
+      expect(change?.status).toEqual({ from: 'done', to: 'in-testing' })
+      expect(change?.qeVerify).toBeUndefined()
+    })
+  })
 })

src/App.tsx

@@ -160,9 +160,9 @@ function App() {
     (bugId: number, fromColumn: string, toColumn: string) => {
       stageChange(bugId, fromColumn, toColumn)
 
-      // Handle sprint tag for backlog <-> todo moves
       const bug = bugs.find((b) => b.id === bugId)
       if (bug) {
+        // Handle sprint tag for backlog <-> todo moves
         const currentWhiteboard = bug.whiteboard
 
         // Moving from backlog to todo: add sprint tag
@@ -180,9 +180,18 @@ function App() {
             stageWhiteboardChange(bugId, currentWhiteboard, newWhiteboard)
           }
         }
+
+        // Handle qe-verify for moves to in-testing
+        // Bug needs qe-verify+ to stay in in-testing column
+        if (toColumn === 'in-testing') {
+          const currentQeVerify = getQeVerifyStatus(bug.flags)
+          if (currentQeVerify !== 'plus') {
+            stageQeVerifyChange(bugId, currentQeVerify, 'plus')
+          }
+        }
       }
     },
-    [stageChange, bugs, stageWhiteboardChange],
+    [stageChange, bugs, stageWhiteboardChange, stageQeVerifyChange],
   )
 
   // Handle assignee change

src/store/slices/staged-slice.test.ts

@@ -102,6 +102,42 @@ describe('StagedSlice', () => {
       const { changes } = useStore.getState()
       expect(changes.has(123)).toBe(false)
     })
+
+    it('should remove change when dragging from staged position back to original', () => {
+      const { stageChange } = useStore.getState()
+
+      // First drag: backlog -> todo
+      stageChange(123, 'backlog', 'todo')
+      expect(useStore.getState().changes.get(123)?.status).toEqual({
+        from: 'backlog',
+        to: 'todo',
+      })
+
+      // Second drag: from staged position (todo) back to original (backlog)
+      // This simulates the actual drag flow where fromColumn is the staged column
+      stageChange(123, 'todo', 'backlog')
+
+      // Should remove the change since we're back to original
+      const { changes } = useStore.getState()
+      expect(changes.has(123)).toBe(false)
+    })
+
+    it('should update to new column when dragging from staged position to third column', () => {
+      const { stageChange } = useStore.getState()
+
+      // First drag: backlog -> todo
+      stageChange(123, 'backlog', 'todo')
+
+      // Second drag: from staged position (todo) to in-progress
+      stageChange(123, 'todo', 'in-progress')
+
+      // Should preserve original "from" but update "to"
+      const change = useStore.getState().changes.get(123)
+      expect(change?.status).toEqual({
+        from: 'backlog',
+        to: 'in-progress',
+      })
+    })
   })
 
   describe('unstageChange', () => {

src/store/slices/staged-slice.ts

@@ -63,20 +63,25 @@ export const createStagedSlice: StateCreator<StagedSlice> = (set, get) => ({
       const newChanges = new Map(state.changes)
       const existing = newChanges.get(bugId)
 
+      // Preserve the original column from any existing staged change
+      const originalColumn = existing?.status?.from ?? fromColumn
+
       // If moving back to original column, remove the status change
-      if (fromColumn === toColumn) {
-        if (existing?.assignee) {
-          // Keep assignee change, remove status
-          newChanges.set(bugId, { assignee: existing.assignee })
-        } else {
-          // No other changes, remove the bug entry
-          newChanges.delete(bugId)
+      if (originalColumn === toColumn) {
+        if (existing) {
+          const { status: _removed, ...rest } = existing
+          // Check if there are other changes remaining
+          if (Object.keys(rest).length > 0) {
+            newChanges.set(bugId, rest)
+          } else {
+            newChanges.delete(bugId)
+          }
         }
       } else {
-        // Add/update status change, preserve assignee if exists
+        // Add/update status change, preserve other changes if exist
         newChanges.set(bugId, {
           ...existing,
-          status: { from: fromColumn, to: toColumn },
+          status: { from: originalColumn, to: toColumn },
         })
       }