jettypod 4.4.81 → 4.4.83

package/apps/dashboard/components/DragContext.tsx

@@ -22,6 +22,11 @@ interface EpicDropZoneInfo {
   onReorder?: ReorderHandler;
 }
 
+interface CardPosition {
+  id: number;
+  rect: DOMRect;
+}
+
 interface DragContextType {
   isDragging: boolean;
   draggedItem: WorkItem | null;
@@ -38,6 +43,9 @@ interface DragContextType {
   updatePointerPosition: (x: number, y: number) => void;
   startDrag: (item: WorkItem, cardRect: DOMRect, pointerX: number, pointerY: number) => void;
   handleDrop: () => Promise<void>;
+  registerCardPosition: (id: number, rect: DOMRect) => void;
+  unregisterCard: (id: number) => void;
+  getCardPositions: () => CardPosition[];
 }
 
 const DragContext = createContext<DragContextType>({
@@ -56,6 +64,9 @@ const DragContext = createContext<DragContextType>({
   updatePointerPosition: () => {},
   startDrag: () => {},
   handleDrop: async () => {},
+  registerCardPosition: () => {},
+  unregisterCard: () => {},
+  getCardPositions: () => [],
 });
 
 interface DragProviderProps {
@@ -72,6 +83,7 @@ export function DragProvider({ children, renderDragOverlay }: DragProviderProps)
   const [draggedCardWidth, setDraggedCardWidth] = useState(0);
   const dropZonesRef = useRef<Map<string, DropZoneInfo>>(new Map());
   const epicDropZonesRef = useRef<Map<string, EpicDropZoneInfo>>(new Map());
+  const cardPositionsRef = useRef<Map<number, DOMRect>>(new Map());
   const pointerPositionRef = useRef<{ x: number; y: number }>({ x: 0, y: 0 });
 
   const registerDropZone = useCallback((id: string, info: DropZoneInfo) => {
@@ -90,6 +102,22 @@ export function DragProvider({ children, renderDragOverlay }: DragProviderProps)
     epicDropZonesRef.current.delete(id);
   }, []);
 
+  const registerCardPosition = useCallback((id: number, rect: DOMRect) => {
+    cardPositionsRef.current.set(id, rect);
+  }, []);
+
+  const unregisterCard = useCallback((id: number) => {
+    cardPositionsRef.current.delete(id);
+  }, []);
+
+  const getCardPositions = useCallback((): CardPosition[] => {
+    const positions: CardPosition[] = [];
+    cardPositionsRef.current.forEach((rect, id) => {
+      positions.push({ id, rect });
+    });
+    return positions;
+  }, []);
+
   const updatePointerPosition = useCallback((x: number, y: number) => {
     pointerPositionRef.current = { x, y };
     setDragPosition({ x, y });
@@ -187,6 +215,9 @@ export function DragProvider({ children, renderDragOverlay }: DragProviderProps)
         updatePointerPosition,
         startDrag,
         handleDrop,
+        registerCardPosition,
+        unregisterCard,
+        getCardPositions,
       }}
     >
       {children}
@@ -203,6 +234,8 @@ export function DragProvider({ children, renderDragOverlay }: DragProviderProps)
               pointerEvents: 'none',
               transform: 'scale(1.02)',
               boxShadow: '0 10px 30px rgba(0, 0, 0, 0.2)',
+              borderRadius: 8,
+              overflow: 'hidden',
             }}
           >
             {renderDragOverlay(draggedItem)}

package/apps/dashboard/components/DraggableCard.tsx

@@ -1,6 +1,6 @@
 'use client';
 
-import { useRef } from 'react';
+import { useRef, useEffect } from 'react';
 import { motion, PanInfo } from 'framer-motion';
 import type { WorkItem } from '@/lib/db';
 import { useDragContext } from './DragContext';
@@ -12,10 +12,38 @@ interface DraggableCardProps {
 }
 
 export function DraggableCard({ item, children, disabled = false }: DraggableCardProps) {
-  const { startDrag, setDraggedItem, updatePointerPosition, handleDrop } = useDragContext();
+  const { startDrag, setDraggedItem, updatePointerPosition, handleDrop, registerCardPosition, unregisterCard } = useDragContext();
   const wasDraggingRef = useRef(false);
   const cardRef = useRef<HTMLDivElement>(null);
 
+  // Register card position for optimized reorder calculations
+  useEffect(() => {
+    if (disabled || !cardRef.current) return;
+
+    const updatePosition = () => {
+      if (cardRef.current) {
+        registerCardPosition(item.id, cardRef.current.getBoundingClientRect());
+      }
+    };
+
+    // Initial registration
+    updatePosition();
+
+    // Update on resize/layout changes
+    const resizeObserver = new ResizeObserver(updatePosition);
+    resizeObserver.observe(cardRef.current);
+
+    // Update on scroll (positions are viewport-relative)
+    const scrollHandler = () => updatePosition();
+    window.addEventListener('scroll', scrollHandler, true);
+
+    return () => {
+      unregisterCard(item.id);
+      resizeObserver.disconnect();
+      window.removeEventListener('scroll', scrollHandler, true);
+    };
+  }, [item.id, disabled, registerCardPosition, unregisterCard]);
+
   if (disabled) {
     return <>{children}</>;
   }

package/apps/dashboard/components/KanbanBoard.tsx

@@ -1,6 +1,6 @@
 '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 type { WorkItem, InFlightItem, KanbanGroup } from '@/lib/db';
@@ -257,26 +257,23 @@ 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, registerEpicDropZone, unregisterEpicDropZone, getCardPositions } = useDragContext();
+
+  // Get item IDs in this epic for filtering
+  const itemIds = useMemo(() => new Set(items.map(item => item.id)), [items]);
 
   // Handle reorder within this epic - calculate new display_order based on pointer Y
   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,
-        });
-      }
-    });
+    if (!onOrderChange) return;
+
+    // Use cached card positions from registry, filtered to this epic's items
+    const allPositions = getCardPositions();
+    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,
+      }));
 
     // Skip reorder if this is the only item in the epic (no other cards to reorder against)
     if (cardPositions.length === 0) {
@@ -306,7 +303,7 @@ function EpicGroup({ epicId, epicTitle, items, isInFlight = false, isDraggable =
       // Show user-friendly error notification
       alert('Failed to reorder item. Please try again.');
     }
-  }, [onOrderChange]);
+  }, [onOrderChange, getCardPositions, itemIds]);
 
   // Register as epic drop zone
   useEffect(() => {
@@ -414,6 +411,78 @@ 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();
+
+  // Get all backlog item IDs for filtering positions
+  const backlogItemIds = useMemo(() => {
+    const ids = new Set<number>();
+    for (const group of backlog.values()) {
+      for (const item of group.items) {
+        ids.add(item.id);
+      }
+    }
+    return ids;
+  }, [backlog]);
+
+  // Handle reorder within backlog - calculate new display_order based on pointer Y
+  const handleBacklogReorder = useCallback(async (itemId: number, pointerY: number) => {
+    if (!onOrderChange) return;
+
+    // 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 onOrderChange(itemId, newOrder);
+  }, [onOrderChange, getCardPositions, backlogItemIds]);
+
+  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 +501,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 +543,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
@@ -595,19 +610,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 +635,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/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

@@ -2801,7 +2801,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
@@ -390,27 +420,151 @@ async function waitForMigrations() {
   }
 }
 
+/**
+ * Attempt to recover work.db from JSON snapshots
+ * Used when database is missing or corrupted
+ * @returns {Promise<{recovered: boolean, itemCount: number}>} Recovery result
+ */
+async function recoverFromSnapshots() {
+  const snapshotsDir = path.join(getJettypodDir(), 'snapshots');
+  const jsonPath = path.join(snapshotsDir, 'work.json');
+
+  // Check if snapshots exist
+  if (!fs.existsSync(jsonPath)) {
+    return { recovered: false, itemCount: 0, reason: 'No snapshot file found' };
+  }
+
+  // Read and parse snapshot
+  let data;
+  try {
+    const jsonContent = fs.readFileSync(jsonPath, 'utf8');
+    data = JSON.parse(jsonContent);
+  } catch (err) {
+    return { recovered: false, itemCount: 0, reason: `Failed to read snapshot: ${err.message}` };
+  }
+
+  // Close existing connection and delete corrupted file
+  await closeDb();
+  const dbFilePath = getDbPath();
+
+  // Remove corrupted database files (including WAL files)
+  const filesToRemove = [dbFilePath, `${dbFilePath}-wal`, `${dbFilePath}-shm`];
+  for (const file of filesToRemove) {
+    if (fs.existsSync(file)) {
+      fs.unlinkSync(file);
+    }
+  }
+
+  // Reset singleton to force fresh connection
+  resetDb();
+
+  // Create fresh database (this will create schema)
+  const database = getDb();
+  await waitForMigrations();
+
+  // Import data from snapshot
+  const tableNames = Object.keys(data);
+  let totalItems = 0;
+
+  for (const tableName of tableNames) {
+    const rows = data[tableName];
+    if (!rows || rows.length === 0) continue;
+
+    // Get column names from first row
+    const columns = Object.keys(rows[0]);
+    const placeholders = columns.map(() => '?').join(', ');
+    const columnNames = columns.join(', ');
+    const insertSql = `INSERT INTO ${tableName} (${columnNames}) VALUES (${placeholders})`;
+
+    for (const row of rows) {
+      const values = columns.map(col => row[col]);
+      await new Promise((resolve, reject) => {
+        database.run(insertSql, values, (err) => {
+          if (err) reject(err);
+          else resolve();
+        });
+      });
+      totalItems++;
+    }
+  }
+
+  return { recovered: true, itemCount: totalItems };
+}
+
 /**
  * Run startup validation checks on the database
  * Call this early in application startup to detect corruption before operations fail
- * @returns {Promise<void>} Resolves if database is healthy, rejects with details if corrupted
- * @throws {Error} If database is corrupted or schema is invalid
+ * Automatically attempts recovery from snapshots if corruption is detected
+ * @returns {Promise<void>} Resolves if database is healthy (or recovered), rejects if unrecoverable
+ * @throws {Error} If database is corrupted and recovery fails
  */
 async function validateOnStartup() {
-  const database = getDb();
-  await waitForMigrations();
+  // Check if database file is missing
+  const dbFilePath = getDbPath();
+  const dbMissing = !fs.existsSync(dbFilePath);
+
+  if (dbMissing) {
+    // Try to recover from snapshots
+    console.log('⚠️  Database file missing, attempting recovery from snapshots...');
+    const result = await recoverFromSnapshots();
+    if (result.recovered) {
+      console.log(`✅ Recovered ${result.itemCount} items from snapshots`);
+      return;
+    } else {
+      // No snapshots - just create fresh DB (getDb will do this)
+      console.log('ℹ️  No snapshots found, creating fresh database');
+      getDb();
+      await waitForMigrations();
+      return;
+    }
+  }
 
-  // Check file integrity first
+  // Database exists - check integrity
+  let database;
+  try {
+    database = getDb();
+    await waitForMigrations();
+  } catch (err) {
+    // Failed to even open the database - try recovery
+    console.log('⚠️  Database failed to open, attempting recovery from snapshots...');
+    const result = await recoverFromSnapshots();
+    if (result.recovered) {
+      console.log(`✅ Recovered ${result.itemCount} items from snapshots`);
+      return;
+    }
+    throw new Error(
+      `Database failed to open and recovery failed.\n` +
+      `Original error: ${err.message}\n` +
+      `Recovery error: ${result.reason}\n\n` +
+      `Manual recovery options:\n` +
+      `  1. Restore from backup: jettypod work restore-backup latest\n` +
+      `  2. Check ~/.jettypod-backups/ for global backups`
+    );
+  }
+
+  // Check file integrity
   const integrity = await checkIntegrity(database);
   if (!integrity.ok) {
+    console.log('⚠️  Database corruption detected, attempting recovery from snapshots...');
+    const result = await recoverFromSnapshots();
+    if (result.recovered) {
+      console.log(`✅ Recovered ${result.itemCount} items from snapshots`);
+      // Verify the recovered database
+      const newDb = getDb();
+      const newIntegrity = await checkIntegrity(newDb);
+      if (newIntegrity.ok) {
+        return;
+      }
+    }
+
+    // Recovery failed or still corrupted
     const errorList = integrity.errors.join('\n  - ');
     throw new Error(
-      `Database integrity check failed. The database file may be corrupted.\n` +
+      `Database integrity check failed and automatic recovery was unsuccessful.\n` +
       `Errors found:\n  - ${errorList}\n\n` +
-      `Recovery options:\n` +
+      `Manual recovery options:\n` +
       `  1. Restore from backup: jettypod work restore-backup latest\n` +
-      `  2. Rebuild from snapshots: The JSON snapshots in .jettypod/snapshots/ can restore your data\n` +
-      `  3. Check ~/.jettypod-backups/ for global backups`
+      `  2. Check ~/.jettypod-backups/ for global backups`
     );
   }
 
@@ -427,7 +581,9 @@ module.exports = {
   waitForMigrations,
   validateSchema,
   checkIntegrity,
+  walCheckpoint,
   validateOnStartup,
+  recoverFromSnapshots,
   dbPath,  // Deprecated: use getDbPath() for dynamic path
   jettypodDir  // Deprecated: use getJettypodDir() for dynamic path
 };

package/lib/db-export.js

@@ -83,17 +83,16 @@ async function exportWorkDb() {
   try {
     fs.writeFileSync(outputPath, JSON.stringify(data, null, 2), 'utf8');
   } catch (err) {
-    // Log warning but don't throw - we don't want to block git operations
-    console.error('Pre-commit hook warning: Failed to export work.json');
+    // Throw error to block commit - snapshot backup is critical
+    let message = 'Failed to export work.json';
     if (err.code === 'EACCES') {
-      console.error('  Permission denied - check directory permissions');
+      message += ': Permission denied - check directory permissions';
     } else if (err.code === 'ENOSPC') {
-      console.error('  No space left on device');
+      message += ': No space left on device';
     } else {
-      console.error(`  ${err.message}`);
+      message += `: ${err.message}`;
     }
-    console.error('  Commit will proceed but snapshots were not updated');
-    // Return path anyway so commit can continue
+    throw new Error(message);
   }
 
   return outputPath;
@@ -115,15 +114,16 @@ async function exportDatabaseDb() {
     try {
       fs.writeFileSync(outputPath, JSON.stringify({}, null, 2), 'utf8');
     } catch (err) {
-      console.error('Pre-commit hook warning: Failed to export database.json');
+      // Throw error to block commit - snapshot backup is critical
+      let message = 'Failed to export database.json';
       if (err.code === 'EACCES') {
-        console.error('  Permission denied - check directory permissions');
+        message += ': Permission denied - check directory permissions';
       } else if (err.code === 'ENOSPC') {
-        console.error('  No space left on device');
+        message += ': No space left on device';
       } else {
-        console.error(`  ${err.message}`);
+        message += `: ${err.message}`;
       }
-      console.error('  Commit will proceed but snapshots were not updated');
+      throw new Error(message);
     }
     return outputPath;
   }
@@ -142,15 +142,18 @@ async function exportDatabaseDb() {
         try {
           fs.writeFileSync(outputPath, JSON.stringify(data, null, 2), 'utf8');
         } catch (writeErr) {
-          console.error('Pre-commit hook warning: Failed to export database.json');
+          // Throw error to block commit - snapshot backup is critical
+          let message = 'Failed to export database.json';
           if (writeErr.code === 'EACCES') {
-            console.error('  Permission denied - check directory permissions');
+            message += ': Permission denied - check directory permissions';
           } else if (writeErr.code === 'ENOSPC') {
-            console.error('  No space left on device');
+            message += ': No space left on device';
           } else {
-            console.error(`  ${writeErr.message}`);
+            message += `: ${writeErr.message}`;
           }
-          console.error('  Commit will proceed but snapshots were not updated');
+          db.close();
+          reject(new Error(message));
+          return;
         }
 
         db.close((closeErr) => {

package/lib/git-hooks/pre-commit

@@ -55,23 +55,63 @@ if (!checkBranchRestriction()) {
   process.exit(1);
 }
 
-// Check if we're in a real project (not a test directory)
-const packageJsonPath = path.join(process.cwd(), 'package.json');
-if (!fs.existsSync(packageJsonPath)) {
-  // Skip tests in test directories
-  process.exit(0);
-}
+// Export database snapshots (runs for all commits where .jettypod exists)
+async function exportSnapshots() {
+  const jettypodDir = path.join(process.cwd(), '.jettypod');
+  if (!fs.existsSync(jettypodDir)) {
+    return; // No JettyPod directory, skip export
+  }
+
+  console.log('\n📸 Exporting database snapshots...\n');
 
-console.log('\n🧪 Running tests before commit...\n');
+  try {
+    const { exportAll } = require('../db-export');
+    const paths = await exportAll();
 
-try {
-  // Run tests
-  execSync('npm test', { stdio: 'inherit' });
+    // Stage the snapshot files
+    execSync(`git add "${paths.work}" "${paths.database}"`, {
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
 
-  console.log('\n✅ Tests passed! Proceeding with commit.\n');
-  process.exit(0);
-} catch (err) {
-  console.log('\n❌ Tests failed! Commit blocked.\n');
-  console.log('Fix the failing tests or use --no-verify to skip this check.\n');
-  process.exit(1);
+    console.log('✅ Snapshots exported and staged\n');
+  } catch (err) {
+    console.error('');
+    console.error('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.error('❌ Snapshot export failed! Commit blocked.');
+    console.error('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.error('');
+    console.error(`Error: ${err.message}`);
+    console.error('');
+    console.error('This prevents data loss - your work items must be backed up.');
+    console.error('Check disk space and directory permissions.');
+    console.error('');
+    process.exit(1);
+  }
 }
+
+// Main async flow
+(async () => {
+  // Export snapshots first (before tests, so they're included in commit)
+  await exportSnapshots();
+
+  // Check if we're in a real project (not a test directory)
+  const packageJsonPath = path.join(process.cwd(), 'package.json');
+  if (!fs.existsSync(packageJsonPath)) {
+    // Skip tests in test directories
+    process.exit(0);
+  }
+
+  console.log('🧪 Running tests before commit...\n');
+
+  try {
+    // Run tests
+    execSync('npm test', { stdio: 'inherit' });
+
+    console.log('\n✅ Tests passed! Proceeding with commit.\n');
+    process.exit(0);
+  } catch (err) {
+    console.log('\n❌ Tests failed! Commit blocked.\n');
+    console.log('Fix the failing tests or use --no-verify to skip this check.\n');
+    process.exit(1);
+  }
+})();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jettypod",
-  "version": "4.4.81",
+  "version": "4.4.83",
   "description": "AI-powered development workflow manager with TDD, BDD, and automatic test generation",
   "main": "jettypod.js",
   "bin": {