jettypod 4.4.82 → 4.4.84

package/apps/dashboard/components/KanbanBoard.tsx

@@ -1,8 +1,9 @@
 'use client';
 
-import { useState, useCallback, useRef, useEffect } from 'react';
+import { useState, useCallback, useRef, useEffect, useMemo } from 'react';
 import Link from 'next/link';
 import { useRouter } from 'next/navigation';
+import { AnimatePresence } from 'framer-motion';
 import type { WorkItem, InFlightItem, KanbanGroup } from '@/lib/db';
 import type { UndoAction } from '@/lib/undoStack';
 import { EditableTitle } from './EditableTitle';
@@ -10,6 +11,7 @@ import { CardMenu } from './CardMenu';
 import { DragProvider, useDragContext } from './DragContext';
 import { DraggableCard } from './DraggableCard';
 import { DropZone } from './DropZone';
+import { PlaceholderCard } from './PlaceholderCard';
 
 const typeIcons: Record<string, string> = {
   epic: '🎯',
@@ -257,29 +259,42 @@ interface EpicGroupProps {
 
 function EpicGroup({ epicId, epicTitle, items, isInFlight = false, isDraggable = true, onTitleSave, onStatusChange, onEpicAssign, onOrderChange }: EpicGroupProps) {
   const containerRef = useRef<HTMLDivElement>(null);
-  const { isDragging, draggedItem, activeEpicZone, registerEpicDropZone, unregisterEpicDropZone } = useDragContext();
+  const { isDragging, draggedItem, activeEpicZone, activeDropZone, dragPosition, draggedCardHeight, registerEpicDropZone, unregisterEpicDropZone, getCardPositions } = useDragContext();
 
-  // Handle reorder within this epic - calculate new display_order based on pointer Y
+  // Use ref for items to avoid re-registering drop zone when items change
+  const itemsRef = useRef(items);
+  itemsRef.current = items;
+
+  // Use ref for callbacks to keep drop zone registration stable
+  const onOrderChangeRef = useRef(onOrderChange);
+  onOrderChangeRef.current = onOrderChange;
+
+  // Stable reorder handler that reads from refs
   const handleEpicReorder = useCallback(async (itemId: number, pointerY: number) => {
-    if (!onOrderChange || !containerRef.current) return;
-
-    // Find all card elements in this epic container
-    const cardElements = containerRef.current.querySelectorAll('[data-item-id]');
-    const cardPositions: { id: number; midY: number }[] = [];
-
-    cardElements.forEach((el) => {
-      const id = parseInt(el.getAttribute('data-item-id') || '0', 10);
-      if (id !== itemId) {
-        const rect = el.getBoundingClientRect();
-        cardPositions.push({
-          id,
-          midY: (rect.top + rect.bottom) / 2,
-        });
-      }
-    });
+    console.log('[EpicGroup] handleEpicReorder called:', { itemId, pointerY, epicId });
+    if (!onOrderChangeRef.current) {
+      console.log('[EpicGroup] No onOrderChange, returning');
+      return;
+    }
+
+    // Get current item IDs from ref
+    const itemIds = new Set(itemsRef.current.map(item => item.id));
+    console.log('[EpicGroup] itemIds in this epic:', Array.from(itemIds));
+
+    // Use cached card positions from registry, filtered to this epic's items
+    const allPositions = getCardPositions();
+    console.log('[EpicGroup] allPositions:', allPositions.length);
+    const cardPositions = allPositions
+      .filter(pos => itemIds.has(pos.id) && pos.id !== itemId)
+      .map(pos => ({
+        id: pos.id,
+        midY: (pos.rect.top + pos.rect.bottom) / 2,
+      }));
+    console.log('[EpicGroup] filtered cardPositions:', cardPositions);
 
     // Skip reorder if this is the only item in the epic (no other cards to reorder against)
     if (cardPositions.length === 0) {
+      console.log('[EpicGroup] No other cards to reorder against, returning');
       return;
     }
 
@@ -297,18 +312,21 @@ function EpicGroup({ epicId, epicTitle, items, isInFlight = false, isDraggable =
 
     // Calculate new display_order using index * 10
     const newOrder = insertIndex * 10;
+    console.log('[EpicGroup] Calculated insertIndex:', insertIndex, 'newOrder:', newOrder, 'for itemId:', itemId);
 
     try {
-      await onOrderChange(itemId, newOrder);
+      console.log('[EpicGroup] Calling onOrderChange...');
+      await onOrderChangeRef.current(itemId, newOrder);
+      console.log('[EpicGroup] onOrderChange completed successfully');
     } catch (error) {
       // Log error and notify user - items remain in original order since state wasn't updated
-      console.error('Failed to reorder item:', error);
+      console.error('[EpicGroup] Failed to reorder item:', error);
       // Show user-friendly error notification
       alert('Failed to reorder item. Please try again.');
     }
-  }, [onOrderChange]);
+  }, [getCardPositions]);
 
-  // Register as epic drop zone
+  // Register as epic drop zone - stable registration that doesn't change with items
   useEffect(() => {
     if (!containerRef.current || !onEpicAssign || epicId === null) return;
 
@@ -317,13 +335,13 @@ function EpicGroup({ epicId, epicTitle, items, isInFlight = false, isDraggable =
       epicId,
       element: containerRef.current,
       onEpicAssign,
-      onReorder: onOrderChange ? handleEpicReorder : undefined,
+      onReorder: handleEpicReorder,
     });
 
     return () => {
       unregisterEpicDropZone(zoneId);
     };
-  }, [epicId, onEpicAssign, onOrderChange, handleEpicReorder, registerEpicDropZone, unregisterEpicDropZone]);
+  }, [epicId, onEpicAssign, handleEpicReorder, registerEpicDropZone, unregisterEpicDropZone]);
 
   // Check if this epic zone is the active drop target
   const isActiveTarget = activeEpicZone === `epic-${epicId}`;
@@ -338,7 +356,45 @@ function EpicGroup({ epicId, epicTitle, items, isInFlight = false, isDraggable =
   // Show reorder highlight when dragging within same epic (purple)
   const showReorderHighlight = isActiveTarget && isSameEpic;
 
-  if (items.length === 0 && !showHighlight && !showReorderHighlight) return null;
+  // For ungrouped section (epicId === null)
+  const isUngroupedSection = epicId === null;
+  // Check if cursor is over this ungrouped section (not over any epic zone, but over backlog drop zone)
+  const isOverUngroupedSection = isUngroupedSection && !activeEpicZone && activeDropZone;
+
+  // Render the ungrouped zone when dragging from an epic (provides drop target), but only highlight when cursor is over it
+  const shouldRenderUngroupedZone = isUngroupedSection && isDragging && draggedItemEpicId !== null;
+  const showRemoveFromEpicZone = isOverUngroupedSection && isDragging && draggedItemEpicId !== null;
+
+  // Show reorder for ungrouped section when dragging an ungrouped card and cursor is over it
+  const showUngroupedReorder = isOverUngroupedSection && isDragging && draggedItemEpicId === null;
+
+  // Calculate insertion preview for this group - only for the active zone
+  const showPreview = (showReorderHighlight || showRemoveFromEpicZone || showHighlight || showUngroupedReorder) && draggedItem;
+  let insertAfterItemId: number | null | undefined = undefined; // undefined = no preview, null = at beginning
+
+  if (showPreview && draggedItem) {
+    const allPositions = getCardPositions();
+    const itemIds = new Set(items.map(item => item.id));
+    const groupPositions = allPositions
+      .filter(pos => itemIds.has(pos.id) && pos.id !== draggedItem.id)
+      .map(pos => ({
+        id: pos.id,
+        midY: (pos.rect.top + pos.rect.bottom) / 2,
+      }))
+      .sort((a, b) => a.midY - b.midY);
+
+    // Find which card the pointer is after
+    insertAfterItemId = null; // Default to beginning
+    for (const pos of groupPositions) {
+      if (dragPosition.y > pos.midY) {
+        insertAfterItemId = pos.id;
+      } else {
+        break;
+      }
+    }
+  }
+
+  if (items.length === 0 && !showHighlight && !showReorderHighlight && !shouldRenderUngroupedZone) return null;
 
   return (
     <div
@@ -348,6 +404,8 @@ function EpicGroup({ epicId, epicTitle, items, isInFlight = false, isDraggable =
           ? 'ring-2 ring-indigo-400 bg-indigo-100/50 dark:bg-indigo-900/30'
           : showReorderHighlight
           ? 'ring-2 ring-purple-400 bg-purple-100/50 dark:bg-purple-900/30'
+          : showRemoveFromEpicZone
+          ? 'ring-2 ring-orange-400 bg-orange-100/50 dark:bg-orange-900/30'
           : ''
       }`}
       data-epic-id={epicId}
@@ -378,11 +436,43 @@ function EpicGroup({ epicId, epicTitle, items, isInFlight = false, isDraggable =
           )}
         </div>
       )}
+      {/* Ungrouped section header - shown when dragging from epic */}
+      {isUngroupedSection && showRemoveFromEpicZone && items.length === 0 && (
+        <div className="flex items-center gap-2 py-3">
+          <span className="text-xs font-medium text-orange-600 dark:text-orange-400">
+            Drop here to remove from epic
+          </span>
+        </div>
+      )}
+      {isUngroupedSection && items.length > 0 && (
+        <div className="flex items-center gap-2 mb-2">
+          <span className="text-xs font-medium text-zinc-400 dark:text-zinc-500">Ungrouped</span>
+          {showRemoveFromEpicZone && (
+            <span className="text-xs px-1.5 py-0.5 rounded bg-orange-100 text-orange-700 dark:bg-orange-900/50 dark:text-orange-300">
+              drop to remove from epic
+            </span>
+          )}
+        </div>
+      )}
       <div className="space-y-2">
+        {/* Placeholder at the beginning (insertAfterItemId === null) */}
+        <AnimatePresence>
+          {insertAfterItemId === null && (
+            <PlaceholderCard key="placeholder-start" height={draggedCardHeight} />
+          )}
+        </AnimatePresence>
         {items.map((item) => (
-          <DraggableCard key={item.id} item={item} disabled={!isDraggable}>
-            <KanbanCard item={item} onTitleSave={onTitleSave} onStatusChange={onStatusChange} />
-          </DraggableCard>
+          <div key={item.id}>
+            <DraggableCard item={item} disabled={!isDraggable}>
+              <KanbanCard item={item} onTitleSave={onTitleSave} onStatusChange={onStatusChange} />
+            </DraggableCard>
+            {/* Placeholder after this card */}
+            <AnimatePresence>
+              {insertAfterItemId === item.id && (
+                <PlaceholderCard key={`placeholder-${item.id}`} height={draggedCardHeight} />
+              )}
+            </AnimatePresence>
+          </div>
         ))}
       </div>
     </div>
@@ -414,6 +504,81 @@ function KanbanColumn({ title, children, count }: KanbanColumnProps) {
   );
 }
 
+// Wrapper component that handles backlog reorder with access to drag context
+interface BacklogDropZoneWrapperProps {
+  backlog: Map<string, KanbanGroup>;
+  onStatusChange?: (id: number, newStatus: string) => Promise<void | { success: boolean; notFound?: boolean }>;
+  onOrderChange?: (id: number, newOrder: number) => Promise<void>;
+  children: React.ReactNode;
+}
+
+function BacklogDropZoneWrapper({ backlog, onStatusChange, onOrderChange, children }: BacklogDropZoneWrapperProps) {
+  const { getCardPositions } = useDragContext();
+
+  // Use refs to keep handler stable
+  const backlogRef = useRef(backlog);
+  backlogRef.current = backlog;
+  const onOrderChangeRef = useRef(onOrderChange);
+  onOrderChangeRef.current = onOrderChange;
+
+  // Handle reorder within backlog - calculate new display_order based on pointer Y
+  const handleBacklogReorder = useCallback(async (itemId: number, pointerY: number) => {
+    if (!onOrderChangeRef.current) return;
+
+    // Get current backlog item IDs from ref
+    const backlogItemIds = new Set<number>();
+    for (const group of backlogRef.current.values()) {
+      for (const item of group.items) {
+        backlogItemIds.add(item.id);
+      }
+    }
+
+    // Use cached card positions from registry, filtered to backlog items
+    const allPositions = getCardPositions();
+    const cardPositions = allPositions
+      .filter(pos => backlogItemIds.has(pos.id) && pos.id !== itemId)
+      .map(pos => ({
+        id: pos.id,
+        midY: (pos.rect.top + pos.rect.bottom) / 2,
+      }));
+
+    // Sort by Y position
+    cardPositions.sort((a, b) => a.midY - b.midY);
+
+    // Find insertion index based on pointer Y
+    let insertIndex = cardPositions.length;
+    for (let i = 0; i < cardPositions.length; i++) {
+      if (pointerY < cardPositions[i].midY) {
+        insertIndex = i;
+        break;
+      }
+    }
+
+    // Calculate new display_order
+    // Use index * 10 to leave room for future insertions
+    const newOrder = insertIndex * 10;
+
+    await onOrderChangeRef.current(itemId, newOrder);
+  }, [getCardPositions]);
+
+  return (
+    <DropZone
+      targetStatus="backlog"
+      onDrop={async (itemId, newStatus) => {
+        if (onStatusChange) await onStatusChange(itemId, newStatus);
+      }}
+      onReorder={handleBacklogReorder}
+      allowReorder={true}
+      className="rounded-lg p-2 -m-2 min-h-[100px]"
+      highlightClassName="ring-2 ring-amber-400 bg-amber-100/50 dark:bg-amber-900/30"
+      reorderHighlightClassName="ring-2 ring-purple-400 bg-purple-100/50 dark:bg-purple-900/30"
+      data-testid="backlog-drop-zone"
+    >
+      {children}
+    </DropZone>
+  );
+}
+
 interface KanbanBoardProps {
   inFlight: InFlightItem[];
   backlog: Map<string, KanbanGroup>;
@@ -432,7 +597,6 @@ interface KanbanBoardProps {
 export function KanbanBoard({ inFlight, backlog, done, onTitleSave, onStatusChange, onOrderChange, onEpicAssign, onUndo, onRedo, canUndo, canRedo }: KanbanBoardProps) {
   const backlogCount = inFlight.length + Array.from(backlog.values()).reduce((sum, g) => sum + g.items.length, 0);
   const doneCount = Array.from(done.values()).reduce((sum, g) => sum + g.items.length, 0);
-  const backlogContainerRef = useRef<HTMLDivElement>(null);
 
   // Keyboard shortcuts for undo/redo (Cmd+Z / Cmd+Shift+Z)
   useEffect(() => {
@@ -475,59 +639,6 @@ export function KanbanBoard({ inFlight, backlog, done, onTitleSave, onStatusChan
     }
   }
 
-  // Get flat list of all backlog items for reordering
-  const getAllBacklogItems = useCallback((): WorkItem[] => {
-    const items: WorkItem[] = [];
-    for (const group of backlog.values()) {
-      items.push(...group.items);
-    }
-    return items;
-  }, [backlog]);
-
-  // Handle reorder within backlog - calculate new display_order based on pointer Y
-  const handleBacklogReorder = useCallback(async (itemId: number, pointerY: number) => {
-    if (!onOrderChange || !backlogContainerRef.current) return;
-
-    const items = getAllBacklogItems();
-    const draggedItem = items.find(item => item.id === itemId);
-    if (!draggedItem) return;
-
-    // Find all card elements in the backlog container
-    const cardElements = backlogContainerRef.current.querySelectorAll('[data-item-id]');
-    const cardPositions: { id: number; top: number; bottom: number; midY: number }[] = [];
-
-    cardElements.forEach((el) => {
-      const id = parseInt(el.getAttribute('data-item-id') || '0', 10);
-      if (id !== itemId) {
-        const rect = el.getBoundingClientRect();
-        cardPositions.push({
-          id,
-          top: rect.top,
-          bottom: rect.bottom,
-          midY: (rect.top + rect.bottom) / 2,
-        });
-      }
-    });
-
-    // Sort by Y position
-    cardPositions.sort((a, b) => a.midY - b.midY);
-
-    // Find insertion index based on pointer Y
-    let insertIndex = cardPositions.length;
-    for (let i = 0; i < cardPositions.length; i++) {
-      if (pointerY < cardPositions[i].midY) {
-        insertIndex = i;
-        break;
-      }
-    }
-
-    // Calculate new display_order
-    // Use index * 10 to leave room for future insertions
-    const newOrder = insertIndex * 10;
-
-    await onOrderChange(itemId, newOrder);
-  }, [getAllBacklogItems, onOrderChange]);
-
   // Render function for the drag overlay
   const renderDragOverlay = useCallback((item: WorkItem) => {
     // Find epic title if this is an in-flight item
@@ -546,7 +657,7 @@ export function KanbanBoard({ inFlight, backlog, done, onTitleSave, onStatusChan
   }, [inFlight]);
 
   return (
-    <DragProvider renderDragOverlay={renderDragOverlay}>
+    <DragProvider renderDragOverlay={renderDragOverlay} onRemoveFromEpic={onEpicAssign}>
     <div className="flex gap-4 overflow-x-auto h-full" data-testid="kanban-board">
       {/* Backlog Column */}
       <KanbanColumn title="Backlog" count={backlogCount}>
@@ -595,19 +706,12 @@ export function KanbanBoard({ inFlight, backlog, done, onTitleSave, onStatusChan
         )}
 
         {/* Backlog Section - Drop Zone with Reordering */}
-        <DropZone
-          targetStatus="backlog"
-          onDrop={async (itemId, newStatus) => {
-            if (onStatusChange) await onStatusChange(itemId, newStatus);
-          }}
-          onReorder={handleBacklogReorder}
-          allowReorder={true}
-          className="rounded-lg p-2 -m-2 min-h-[100px]"
-          highlightClassName="ring-2 ring-amber-400 bg-amber-100/50 dark:bg-amber-900/30"
-          reorderHighlightClassName="ring-2 ring-purple-400 bg-purple-100/50 dark:bg-purple-900/30"
-          data-testid="backlog-drop-zone"
+        <BacklogDropZoneWrapper
+          backlog={backlog}
+          onStatusChange={onStatusChange}
+          onOrderChange={onOrderChange}
         >
-          <div ref={backlogContainerRef}>
+          <div>
             {/* Grouped Backlog Items */}
             {Array.from(backlog.entries()).map(([key, group]) => (
               <EpicGroup
@@ -627,7 +731,7 @@ export function KanbanBoard({ inFlight, backlog, done, onTitleSave, onStatusChan
               <p className="text-sm text-zinc-500 text-center py-4">Drop items here for backlog</p>
             )}
           </div>
-        </DropZone>
+        </BacklogDropZoneWrapper>
 
         {backlogCount === 0 && inFlight.length === 0 && (
           <p className="text-sm text-zinc-500 text-center py-4">No items in backlog</p>

package/apps/dashboard/components/PlaceholderCard.tsx

@@ -0,0 +1,30 @@
+'use client';
+
+import { motion } from 'framer-motion';
+
+interface PlaceholderCardProps {
+  height: number;
+  minHeight?: number;
+}
+
+const DEFAULT_MIN_HEIGHT = 40;
+
+export function PlaceholderCard({ height, minHeight = DEFAULT_MIN_HEIGHT }: PlaceholderCardProps) {
+  const effectiveHeight = Math.max(height, minHeight);
+
+  return (
+    <motion.div
+      data-testid="drag-placeholder"
+      initial={{ opacity: 0, height: 0 }}
+      animate={{ opacity: 0.6, height: effectiveHeight }}
+      exit={{ opacity: 0, height: 0 }}
+      transition={{ duration: 0.2, ease: 'easeOut' }}
+      style={{
+        borderRadius: 8,
+        border: '2px dashed rgba(100, 116, 139, 0.4)',
+        backgroundColor: 'rgba(100, 116, 139, 0.1)',
+        marginBottom: 8,
+      }}
+    />
+  );
+}

package/apps/dashboard/components/RealTimeKanbanWrapper.tsx

@@ -146,15 +146,18 @@ function RealTimeKanbanContent({ initialData, initialDecisions }: RealTimeKanban
   }, [refreshData, data, undoStack]);
 
   const handleOrderChange = useCallback(async (id: number, newOrder: number) => {
+    console.log('[RealTimeKanban] handleOrderChange called:', { id, newOrder });
     try {
-      await fetch(`/api/work/${id}/order`, {
+      const response = await fetch(`/api/work/${id}/order`, {
         method: 'PATCH',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({ display_order: newOrder }),
       });
+      console.log('[RealTimeKanban] Order API response:', response.status, await response.clone().json());
       await refreshData();
-    } catch {
-      // Silently fail order changes
+      console.log('[RealTimeKanban] Data refreshed after order change');
+    } catch (error) {
+      console.error('[RealTimeKanban] Order change failed:', error);
     }
   }, [refreshData]);
 

package/apps/dashboard/lib/db.ts

@@ -337,6 +337,15 @@ export function getKanbanData(doneLimit: number = 50): KanbanData {
       }
     }
 
+    // Always ensure an ungrouped entry exists in backlog for drag-drop target
+    if (!backlogGroups.has('ungrouped')) {
+      backlogGroups.set('ungrouped', {
+        epicId: null,
+        epicTitle: null,
+        items: []
+      });
+    }
+
     // Sort done items by completed_at DESC (newest first) within each group
     for (const [, group] of doneGroups) {
       group.items.sort((a, b) => {

package/hooks/post-checkout

@@ -8,6 +8,7 @@
  */
 
 const { importAll } = require('jettypod/lib/db-import');
+const { walCheckpoint } = require('jettypod/lib/database');
 const { execSync } = require('child_process');
 
 (async () => {
@@ -80,7 +81,16 @@ const { execSync } = require('child_process');
     }
   }
 
-  // SECOND: Import database snapshots
+  // SECOND: Checkpoint WAL before importing to prevent corruption
+  // This flushes any pending writes to the main database file
+  try {
+    await walCheckpoint();
+  } catch (err) {
+    // Checkpoint failure shouldn't block - just log and continue
+    console.error('Post-checkout hook warning: WAL checkpoint failed:', err.message);
+  }
+
+  // THIRD: Import database snapshots
   try {
     await importAll();
     process.exit(0);

package/jettypod.js

@@ -2158,38 +2158,42 @@ switch (command) {
         return null;
       };
 
+      // Kill any stale dashboard processes on ports 3456-3465 BEFORE finding port
+      // This ensures we start fresh on 3456 instead of hopping to higher ports
+      try {
+        const { execSync } = require('child_process');
+        for (let port = BASE_PORT; port < BASE_PORT + 10; port++) {
+          try {
+            const result = execSync(`lsof -ti :${port}`, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] });
+            const pids = result.trim().split('\n').filter(p => p);
+            for (const pid of pids) {
+              execSync(`kill -9 ${pid}`, { stdio: 'ignore' });
+            }
+          } catch (e) { /* no process on this port */ }
+        }
+      } catch (e) { /* ignore cleanup errors */ }
+
       const availablePort = await findAvailablePort(BASE_PORT);
 
       if (availablePort) {
         // Check if dashboard dependencies are installed (lazy install on first use)
         const dashboardNodeModules = path.join(dashboardPath, 'node_modules');
-        const dashboardNextBuild = path.join(dashboardPath, '.next');
 
-        if (!fs.existsSync(dashboardNodeModules) || !fs.existsSync(dashboardNextBuild)) {
-          console.log('Setting up dashboard for first use...');
+        if (!fs.existsSync(dashboardNodeModules)) {
+          console.log('Installing dashboard dependencies...');
 
           try {
-            // Install dependencies
-            console.log('  Installing dependencies...');
             const { execSync } = require('child_process');
             execSync('npm install', {
               cwd: dashboardPath,
               stdio: 'inherit'
             });
-
-            // Build the dashboard
-            console.log('  Building dashboard...');
-            execSync('npm run build', {
-              cwd: dashboardPath,
-              stdio: 'inherit'
-            });
-
-            console.log('✅ Dashboard setup complete!');
+            console.log('✅ Dependencies installed');
             console.log('');
           } catch (err) {
-            console.error('❌ Failed to set up dashboard:', err.message);
+            console.error('❌ Failed to install dependencies:', err.message);
             console.error('   Try running manually:');
-            console.error(`   cd ${dashboardPath} && npm install && npm run build`);
+            console.error(`   cd ${dashboardPath} && npm install`);
             break;
           }
         }
@@ -2211,9 +2215,9 @@ switch (command) {
         });
         wsProcess.unref();
 
-        // Start dashboard in background with project path
-        console.log('🚀 Starting dashboard...');
-        const dashboardProcess = spawn('npm', ['run', 'start', '--', '-p', String(availablePort)], {
+        // Start dashboard in dev mode for live reload
+        console.log('🚀 Starting dashboard (dev mode)...');
+        const dashboardProcess = spawn('npm', ['run', 'dev', '--', '-p', String(availablePort)], {
           cwd: dashboardPath,
           detached: true,
           stdio: 'ignore',
@@ -2801,7 +2805,8 @@ Quick commands:
           'stable-mode': ['speed_mode_complete'],
           'production-mode': ['stable_mode_complete'],
           'feature-planning': [],
-          'epic-planning': []
+          'epic-planning': [],
+          'chore-planning': []
         };
 
         // Validate skill name

package/lib/database.js

@@ -270,6 +270,36 @@ function initSchema() {
   });
 }
 
+/**
+ * Force a WAL checkpoint to flush all pending writes to the main database file
+ * Should be called before git checkout/merge operations to prevent WAL corruption
+ * @param {sqlite3.Database} [database] - Database connection (uses singleton if not provided)
+ * @returns {Promise<{success: boolean, pagesWritten: number}>} Checkpoint result
+ */
+function walCheckpoint(database) {
+  const db = database || (typeof getDb === 'function' ? getDb() : null);
+  if (!db) {
+    return Promise.resolve({ success: false, pagesWritten: 0, reason: 'No database connection' });
+  }
+
+  return new Promise((resolve) => {
+    // TRUNCATE mode: checkpoint and truncate the WAL file to zero bytes
+    db.get('PRAGMA wal_checkpoint(TRUNCATE)', [], (err, row) => {
+      if (err) {
+        // Don't reject - checkpoint failure shouldn't block operations
+        resolve({ success: false, pagesWritten: 0, reason: err.message });
+        return;
+      }
+
+      // row contains: busy (0=success), log (pages in WAL), checkpointed (pages written)
+      const success = row && row.busy === 0;
+      const pagesWritten = row ? row.checkpointed : 0;
+
+      resolve({ success, pagesWritten });
+    });
+  });
+}
+
 /**
  * Check database file integrity using SQLite's built-in integrity check
  * @param {sqlite3.Database} database - Database connection to check
@@ -551,6 +581,7 @@ module.exports = {
   waitForMigrations,
   validateSchema,
   checkIntegrity,
+  walCheckpoint,
   validateOnStartup,
   recoverFromSnapshots,
   dbPath,  // Deprecated: use getDbPath() for dynamic path