jettypod 4.4.116 → 4.4.120

package/lib/chore-taxonomy.js

@@ -1,6 +1,10 @@
 /**
  * Chore Type Taxonomy
- * Defines the 4 chore types and their workflow guidance for the chore-planning and chore-mode skills.
+ * Defines the 5 chore types and their workflow guidance for the chore-planning and chore-mode skills.
+ *
+ * Types fall into two categories:
+ * - Behavior-preserving (refactor, dependency, cleanup, tooling): Run existing affected tests, never write new tests
+ * - Behavior-adding (enhancement): TDD with red-green-refactor cycle, writes new tests first
  */
 
 /**
@@ -11,7 +15,8 @@ const CHORE_TYPES = Object.freeze({
   REFACTOR: 'refactor',
   DEPENDENCY: 'dependency',
   CLEANUP: 'cleanup',
-  TOOLING: 'tooling'
+  TOOLING: 'tooling',
+  ENHANCEMENT: 'enhancement'
 });
 
 /**
@@ -33,14 +38,14 @@ const CHORE_TYPE_GUIDANCE = Object.freeze({
       'Consider breaking into smaller refactors if scope is large'
     ],
     verification: [
-      'All existing tests pass without modification',
+      'Affected tests pass without modification',
       'No new functionality added (that requires new tests)',
       'Code review confirms behavior preservation',
       'Performance is not degraded'
     ],
     testHandling: {
       required: true,
-      approach: 'Run all tests for affected modules before and after. Update test file paths/imports if moved. Do NOT change test assertions - if tests fail, the refactor broke behavior.'
+      approach: 'Run tests for affected and potentially impacted modules. Update test file paths/imports if moved. Do NOT change test assertions - if tests fail, the refactor broke behavior.'
     }
   },
   [CHORE_TYPES.DEPENDENCY]: {
@@ -51,14 +56,14 @@ const CHORE_TYPE_GUIDANCE = Object.freeze({
       'Consider update strategy: one at a time vs batch'
     ],
     verification: [
-      'All tests pass after update',
+      'Affected and potentially impacted tests pass after update',
       'Application builds successfully',
       'No new deprecation warnings (or documented)',
       'Security vulnerabilities addressed (if security update)'
     ],
     testHandling: {
       required: false,
-      approach: 'Run full test suite to catch regressions. No new tests needed unless migrating to new API patterns. Document any test changes needed due to library API changes.'
+      approach: 'Run tests for affected and potentially impacted modules to catch regressions. No new tests needed unless migrating to new API patterns. Document any test changes needed due to library API changes.'
     }
   },
   [CHORE_TYPES.CLEANUP]: {
@@ -69,14 +74,14 @@ const CHORE_TYPE_GUIDANCE = Object.freeze({
       'Consider impact on git history/blame'
     ],
     verification: [
-      'All tests still pass',
+      'Affected tests still pass',
       'No broken imports or references',
       'Application runs correctly',
       'Removed code was actually unused'
     ],
     testHandling: {
       required: false,
-      approach: 'Run existing tests to ensure nothing breaks. Remove tests only if they test deleted code. No new tests needed for cleanup work.'
+      approach: 'Run tests for affected modules to ensure nothing breaks. Remove tests only if they test deleted code. No new tests needed for cleanup work.'
     }
   },
   [CHORE_TYPES.TOOLING]: {
@@ -96,6 +101,24 @@ const CHORE_TYPE_GUIDANCE = Object.freeze({
       required: false,
       approach: 'Verify tooling changes work via manual testing or CI runs. Add integration tests only if tooling is complex. Focus on verification over unit testing for infrastructure.'
     }
+  },
+  [CHORE_TYPES.ENHANCEMENT]: {
+    scope: [
+      'Define what new behavior is being added',
+      'Identify where the behavior integrates with existing code',
+      'Plan test cases BEFORE writing implementation (TDD)',
+      'Keep scope focused - one behavior per chore'
+    ],
+    verification: [
+      'New tests written BEFORE implementation (TDD red phase)',
+      'All new tests pass (TDD green phase)',
+      'Code is clean and well-structured (TDD refactor phase)',
+      'Existing affected tests still pass'
+    ],
+    testHandling: {
+      required: true,
+      approach: 'TDD red-green-refactor: Write failing tests first that define the new behavior, then implement minimum code to pass, then refactor. Run affected tests to ensure no regressions.'
+    }
   }
 });
 
@@ -136,7 +159,7 @@ function isValidChoreType(type) {
 function getGuidance(type) {
   if (type === null || type === undefined) {
     throw new Error(
-      'Chore type is required. Valid types: refactor, dependency, cleanup, tooling'
+      'Chore type is required. Valid types: refactor, dependency, cleanup, tooling, enhancement'
     );
   }
 
@@ -144,7 +167,7 @@ function getGuidance(type) {
 
   if (!normalized || !VALID_CHORE_TYPES.includes(normalized)) {
     throw new Error(
-      `Invalid chore type: "${type}". Valid types: refactor, dependency, cleanup, tooling`
+      `Invalid chore type: "${type}". Valid types: refactor, dependency, cleanup, tooling, enhancement`
     );
   }
 

package/lib/database.js

@@ -1,7 +1,7 @@
 const sqlite3 = require('sqlite3').verbose();
 const path = require('path');
 const fs = require('fs');
-const { getGitRoot } = require('./git-root');
+const { getGitRoot, resetCache: resetGitRootCache } = require('./git-root');
 const { runMigrations } = require('./migrations');
 const { getSchemaSQL } = require('./schema');
 
@@ -12,6 +12,7 @@ let cachedDbPath = null;
 let cachedGitRoot = null;
 let isClosing = false;
 let migrationPromise = null;
+let schemaGeneration = 0;
 
 /**
  * Get the root directory for jettypod operations
@@ -29,14 +30,19 @@ function getRepoRoot() {
   return cachedGitRoot;
 }
 
+// Track which NODE_ENV was used to compute the cached path
+let cachedNodeEnv = undefined;
+
 // Dynamic getters for paths (always use main repo, not worktree)
 function getJettypodDir() {
   const root = getRepoRoot();
-  if (!cachedJettypodDir || cachedJettypodDir !== path.join(root, '.jettypod')) {
+  const currentNodeEnv = process.env.NODE_ENV;
+  if (!cachedJettypodDir || cachedJettypodDir !== path.join(root, '.jettypod') || cachedNodeEnv !== currentNodeEnv) {
     cachedJettypodDir = path.join(root, '.jettypod');
     // Use separate database for tests
-    const dbFileName = process.env.NODE_ENV === 'test' ? 'test-work.db' : 'work.db';
+    const dbFileName = currentNodeEnv === 'test' ? 'test-work.db' : 'work.db';
     cachedDbPath = path.join(cachedJettypodDir, dbFileName);
+    cachedNodeEnv = currentNodeEnv;
   }
   return cachedJettypodDir;
 }
@@ -131,11 +137,18 @@ function getDb() {
  * @throws {Error} If schema creation fails
  */
 function initSchema() {
+  // Capture db reference and generation to prevent race conditions.
+  // Module-level getDb() calls (e.g. in work-tracking/index.js) start initSchema() async.
+  // If tests call resetDb() + getDb() before the old callback fires, the old callback
+  // would read the reassigned module-level `db` and run migrations on the wrong connection.
+  const localDb = db;
+  const myGeneration = ++schemaGeneration;
+
   // Create a promise that resolves when migrations complete
   migrationPromise = new Promise((resolve, reject) => {
-    db.serialize(() => {
+    localDb.serialize(() => {
       // Create core tables using the shared schema module (single source of truth)
-      db.exec(getSchemaSQL(), (err) => {
+      localDb.exec(getSchemaSQL(), (err) => {
         if (err) {
           throw new Error(`Failed to create core tables: ${err.message}`);
         }
@@ -147,20 +160,25 @@ function initSchema() {
           console.warn(`ALTER TABLE ADD COLUMN ${columnName} failed:`, err.message);
         }
       };
-      db.run(`ALTER TABLE work_items ADD COLUMN branch_name TEXT`, handleAlterError('branch_name'));
-      db.run(`ALTER TABLE work_items ADD COLUMN file_paths TEXT`, handleAlterError('file_paths'));
-      db.run(`ALTER TABLE work_items ADD COLUMN commit_sha TEXT`, handleAlterError('commit_sha'));
-      db.run(`ALTER TABLE work_items ADD COLUMN mode TEXT`, handleAlterError('mode'));
-      db.run(`ALTER TABLE work_items ADD COLUMN current INTEGER DEFAULT 0`, handleAlterError('current'));
-      db.run(`ALTER TABLE work_items ADD COLUMN needs_discovery INTEGER DEFAULT 0`, handleAlterError('needs_discovery'));
-      db.run(`ALTER TABLE work_items ADD COLUMN worktree_path TEXT`, handleAlterError('worktree_path'));
-      db.run(`ALTER TABLE work_items ADD COLUMN discovery_rationale TEXT`, handleAlterError('discovery_rationale'));
-      db.run(`ALTER TABLE work_items ADD COLUMN display_order INTEGER`, handleAlterError('display_order'));
-      db.run(`ALTER TABLE work_items ADD COLUMN architectural_decision TEXT`, async (err) => {
+      localDb.run(`ALTER TABLE work_items ADD COLUMN branch_name TEXT`, handleAlterError('branch_name'));
+      localDb.run(`ALTER TABLE work_items ADD COLUMN file_paths TEXT`, handleAlterError('file_paths'));
+      localDb.run(`ALTER TABLE work_items ADD COLUMN commit_sha TEXT`, handleAlterError('commit_sha'));
+      localDb.run(`ALTER TABLE work_items ADD COLUMN mode TEXT`, handleAlterError('mode'));
+      localDb.run(`ALTER TABLE work_items ADD COLUMN current INTEGER DEFAULT 0`, handleAlterError('current'));
+      localDb.run(`ALTER TABLE work_items ADD COLUMN needs_discovery INTEGER DEFAULT 0`, handleAlterError('needs_discovery'));
+      localDb.run(`ALTER TABLE work_items ADD COLUMN worktree_path TEXT`, handleAlterError('worktree_path'));
+      localDb.run(`ALTER TABLE work_items ADD COLUMN discovery_rationale TEXT`, handleAlterError('discovery_rationale'));
+      localDb.run(`ALTER TABLE work_items ADD COLUMN display_order INTEGER`, handleAlterError('display_order'));
+      localDb.run(`ALTER TABLE work_items ADD COLUMN architectural_decision TEXT`, async (err) => {
         handleAlterError('architectural_decision')(err);
+        // If the singleton was reset since we started, abort — a new initSchema() owns migrations now
+        if (myGeneration !== schemaGeneration) {
+          resolve();
+          return;
+        }
         // Run data migrations after all schema operations complete
         try {
-          await runMigrations(db);
+          await runMigrations(localDb);
           resolve();
         } catch (err) {
           console.error('Migration failed:', err.message);
@@ -303,12 +321,14 @@ async function closeDb() {
  * Forces the singleton to be recreated on next getDb() call
  */
 function resetDb() {
+  schemaGeneration++; // Invalidate any in-flight initSchema callbacks
   db = null;
   cachedJettypodDir = null;
   cachedDbPath = null;
   cachedGitRoot = null;
   isClosing = false;
   migrationPromise = null;
+  resetGitRootCache();
 }
 
 /**

package/lib/db-watcher.js

@@ -21,7 +21,7 @@ let onChange = null;
 let watchedPath = null;
 
 // Polling interval in milliseconds
-const POLL_MS = 50;
+const POLL_MS = 500;
 
 /**
  * Start watching the database file for changes

package/lib/git-hooks/pre-commit

@@ -88,7 +88,7 @@ async function exportSnapshots() {
     const paths = await exportAll();
 
     // Stage the snapshot files
-    execSync(`git add "${paths.work}" "${paths.database}"`, {
+    execSync(`git add -f "${paths.work}" "${paths.database}"`, {
       stdio: ['pipe', 'pipe', 'pipe']
     });
 

package/lib/jettypod-backup.js

@@ -75,10 +75,33 @@ async function createBackup(gitRoot, reason = 'unknown', options = {}) {
   const backupPath = path.join(backupBaseDir, backupName);
 
   try {
-    // Copy entire .jettypod directory
-    execSync(`cp -R "${jettypodPath}" "${backupPath}"`, {
-      stdio: 'pipe'
-    });
+    // Copy .jettypod directory structure
+    fs.mkdirSync(backupPath, { recursive: true });
+
+    // Copy all files, using sqlite3 .backup for .db files (WAL-safe)
+    // CRITICAL: fs.copyFileSync/cp does NOT work with SQLite WAL mode -
+    // it only copies the base .db file, missing data in the -wal file.
+    const entries = fs.readdirSync(jettypodPath);
+    for (const entry of entries) {
+      const srcFile = path.join(jettypodPath, entry);
+      const destFile = path.join(backupPath, entry);
+      const stat = fs.statSync(srcFile);
+
+      if (stat.isDirectory()) {
+        execSync(`cp -R "${srcFile}" "${destFile}"`, { stdio: 'pipe' });
+      } else if (entry.endsWith('.db') && !entry.endsWith('-shm') && !entry.endsWith('-wal')) {
+        // Use sqlite3 .backup for database files (handles WAL mode correctly)
+        try {
+          execSync(`sqlite3 "${srcFile}" ".backup '${destFile}'"`, { stdio: 'pipe' });
+        } catch (dbErr) {
+          // Fall back to file copy if sqlite3 fails (e.g., empty db)
+          fs.copyFileSync(srcFile, destFile);
+        }
+      } else if (!entry.endsWith('-shm') && !entry.endsWith('-wal')) {
+        // Copy non-WAL files normally (skip -shm/-wal as .backup handles them)
+        fs.copyFileSync(srcFile, destFile);
+      }
+    }
 
     // Verify backup was created
     if (!fs.existsSync(backupPath)) {

package/lib/migrations/027-plan-at-creation-column.js

@@ -0,0 +1,33 @@
+/**
+ * Migration: Add plan_at_creation column to work_items
+ *
+ * Purpose: Track which plan the user was on when creating each work item.
+ * Used for local usage tracking — only work items created on the 'free'
+ * plan count toward the weekly limit.
+ */
+
+module.exports = {
+  id: '027-plan-at-creation-column',
+  description: 'Add plan_at_creation column to work_items',
+
+  async up(db) {
+    return new Promise((resolve, reject) => {
+      db.run(`ALTER TABLE work_items ADD COLUMN plan_at_creation TEXT DEFAULT NULL`, (err) => {
+        // Ignore "duplicate column" — column may already exist if a previous
+        // run succeeded at ALTER TABLE but crashed before recording the migration.
+        if (err && !err.message.includes('duplicate column')) return reject(err);
+        // Backfill existing work items — assume free plan for all existing items
+        db.run(`UPDATE work_items SET plan_at_creation = 'free' WHERE plan_at_creation IS NULL`, (err2) => {
+          if (err2) return reject(err2);
+          resolve();
+        });
+      });
+    });
+  },
+
+  async down(db) {
+    // SQLite doesn't support DROP COLUMN before 3.35.0
+    // Column will just be ignored if not used
+    return Promise.resolve();
+  }
+};

package/lib/migrations/028-ready-for-review-column.js

@@ -0,0 +1,27 @@
+/**
+ * Migration: Add ready_for_review column to work_items
+ *
+ * Purpose: Gate accept/reject button visibility on kanban cards.
+ * When ready_for_review = 1, the card shows accept/reject buttons.
+ * Auto-set when all child chores complete; cleared on rejection.
+ */
+
+module.exports = {
+  id: '028-ready-for-review-column',
+  description: 'Add ready_for_review column to work_items',
+
+  async up(db) {
+    return new Promise((resolve, reject) => {
+      db.run(`ALTER TABLE work_items ADD COLUMN ready_for_review INTEGER DEFAULT 0`, (err) => {
+        if (err) return reject(err);
+        resolve();
+      });
+    });
+  },
+
+  async down(db) {
+    // SQLite doesn't support DROP COLUMN before 3.35.0
+    // Column will just be ignored if not used
+    return Promise.resolve();
+  }
+};

package/lib/migrations/029-remove-autoincrement.js

@@ -0,0 +1,307 @@
+/**
+ * Migration: Remove AUTOINCREMENT from all tables
+ *
+ * AUTOINCREMENT maintains a persistent counter in sqlite_sequence that never
+ * decreases. If any row is ever inserted with a high explicit ID (test data,
+ * corrupted import, etc.), all future IDs inflate permanently.
+ *
+ * Plain INTEGER PRIMARY KEY still auto-assigns IDs (max(id)+1) but without
+ * the ratcheting counter. This is the SQLite-recommended approach.
+ */
+
+module.exports = {
+  id: '029-remove-autoincrement',
+  description: 'Remove AUTOINCREMENT from all tables to prevent ID counter inflation',
+
+  async up(db) {
+    // Each table that uses AUTOINCREMENT needs to be recreated.
+    // SQLite doesn't support ALTER TABLE to change column definitions.
+    //
+    // Strategy: create _new table without AUTOINCREMENT, copy data, drop old, rename.
+    // All done inside serialize() for safety.
+
+    const tables = [
+      {
+        name: 'work_items',
+        create: `CREATE TABLE work_items_new (
+          id INTEGER PRIMARY KEY,
+          type TEXT NOT NULL,
+          title TEXT NOT NULL,
+          description TEXT,
+          status TEXT DEFAULT 'backlog',
+          parent_id INTEGER,
+          epic_id INTEGER,
+          branch_name TEXT,
+          file_paths TEXT,
+          commit_sha TEXT,
+          mode TEXT,
+          current INTEGER DEFAULT 0,
+          phase TEXT,
+          prototype_files TEXT,
+          discovery_winner TEXT,
+          discovery_rationale TEXT,
+          scenario_file TEXT,
+          completed_at TEXT,
+          created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+          needs_discovery INTEGER DEFAULT 0,
+          worktree_path TEXT,
+          display_order INTEGER,
+          architectural_decision TEXT,
+          discovery_completed_at TEXT,
+          rejection_reason TEXT,
+          rejected_at TEXT,
+          plan_at_creation TEXT DEFAULT NULL,
+          ready_for_review INTEGER DEFAULT 0,
+          conversational INTEGER DEFAULT 0
+        )`,
+        indexes: []
+      },
+      {
+        name: 'claude_sessions',
+        create: `CREATE TABLE claude_sessions_new (
+          id INTEGER PRIMARY KEY,
+          work_item_id INTEGER UNIQUE,
+          title TEXT NOT NULL,
+          session_title TEXT,
+          status TEXT NOT NULL CHECK(status IN ('active', 'completed', 'error', 'orphaned')),
+          started_at TEXT NOT NULL DEFAULT (datetime('now')),
+          completed_at TEXT,
+          content TEXT,
+          FOREIGN KEY (work_item_id) REFERENCES work_items(id) ON DELETE SET NULL
+        )`,
+        indexes: [
+          'CREATE INDEX idx_claude_sessions_status ON claude_sessions(status)',
+          'CREATE INDEX idx_claude_sessions_work_item ON claude_sessions(work_item_id)'
+        ]
+      },
+      {
+        name: 'discovery_decisions',
+        create: `CREATE TABLE discovery_decisions_new (
+          id INTEGER PRIMARY KEY,
+          work_item_id INTEGER NOT NULL,
+          aspect TEXT NOT NULL,
+          decision TEXT NOT NULL,
+          rationale TEXT NOT NULL,
+          created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+          FOREIGN KEY (work_item_id) REFERENCES work_items(id)
+        )`,
+        indexes: []
+      },
+      {
+        name: 'env_vars',
+        create: `CREATE TABLE env_vars_new (
+          id INTEGER PRIMARY KEY,
+          name TEXT NOT NULL UNIQUE,
+          value TEXT NOT NULL,
+          created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+          updated_at TEXT DEFAULT CURRENT_TIMESTAMP
+        )`,
+        indexes: []
+      },
+      {
+        name: 'external_readiness_checklist',
+        create: `CREATE TABLE external_readiness_checklist_new (
+          id INTEGER PRIMARY KEY,
+          category TEXT NOT NULL,
+          item_key TEXT NOT NULL,
+          title TEXT NOT NULL,
+          description TEXT,
+          completed INTEGER DEFAULT 0,
+          completed_at DATETIME,
+          UNIQUE(category, item_key)
+        )`,
+        indexes: []
+      },
+      {
+        name: 'merge_locks',
+        create: `CREATE TABLE merge_locks_new (
+          id INTEGER PRIMARY KEY,
+          locked_by TEXT NOT NULL,
+          locked_at TEXT NOT NULL DEFAULT (datetime('now')),
+          operation TEXT NOT NULL DEFAULT 'merging',
+          work_item_id INTEGER NOT NULL,
+          heartbeat_at TEXT NOT NULL DEFAULT (datetime('now'))
+        )`,
+        indexes: [
+          'CREATE INDEX idx_merge_locks_locked_at ON merge_locks(locked_at)'
+        ]
+      },
+      {
+        name: 'skill_executions',
+        create: `CREATE TABLE skill_executions_new (
+          id INTEGER PRIMARY KEY,
+          work_item_id INTEGER NOT NULL,
+          skill_name TEXT NOT NULL,
+          status TEXT DEFAULT 'in_progress',
+          step_reached INTEGER DEFAULT 1,
+          context_json TEXT,
+          started_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+          completed_at DATETIME,
+          FOREIGN KEY (work_item_id) REFERENCES work_items(id)
+        )`,
+        indexes: []
+      },
+      {
+        name: 'test_runs',
+        create: `CREATE TABLE test_runs_new (
+          id INTEGER PRIMARY KEY,
+          run_at TEXT NOT NULL DEFAULT (datetime('now')),
+          total_scenarios INTEGER NOT NULL,
+          passed INTEGER NOT NULL,
+          failed INTEGER NOT NULL,
+          pending INTEGER NOT NULL,
+          duration_ms INTEGER NOT NULL
+        )`,
+        indexes: []
+      },
+      {
+        name: 'test_scenarios',
+        create: `CREATE TABLE test_scenarios_new (
+          id INTEGER PRIMARY KEY,
+          feature_file TEXT NOT NULL,
+          scenario_name TEXT NOT NULL,
+          UNIQUE(feature_file, scenario_name)
+        )`,
+        indexes: []
+      },
+      {
+        name: 'test_results',
+        create: `CREATE TABLE test_results_new (
+          id INTEGER PRIMARY KEY,
+          test_run_id INTEGER NOT NULL,
+          scenario_id INTEGER NOT NULL,
+          status TEXT NOT NULL CHECK(status IN ('passed', 'failed', 'pending')),
+          duration_ms INTEGER NOT NULL DEFAULT 0,
+          error_message TEXT,
+          failed_step TEXT,
+          run_at TEXT NOT NULL DEFAULT (datetime('now')),
+          FOREIGN KEY (test_run_id) REFERENCES test_runs(id),
+          FOREIGN KEY (scenario_id) REFERENCES test_scenarios(id)
+        )`,
+        indexes: [
+          'CREATE INDEX idx_test_results_run ON test_results(test_run_id)',
+          'CREATE INDEX idx_test_results_scenario ON test_results(scenario_id)'
+        ]
+      },
+      {
+        name: 'workflow_checkpoints',
+        create: `CREATE TABLE workflow_checkpoints_new (
+          id INTEGER PRIMARY KEY,
+          skill_name TEXT NOT NULL,
+          current_step INTEGER NOT NULL,
+          total_steps INTEGER,
+          context_json TEXT,
+          branch_name TEXT NOT NULL,
+          work_item_id INTEGER,
+          created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+          updated_at TEXT DEFAULT CURRENT_TIMESTAMP
+        )`,
+        indexes: [
+          'CREATE INDEX idx_workflow_checkpoints_branch ON workflow_checkpoints(branch_name)'
+        ]
+      },
+      {
+        name: 'workflow_gates',
+        create: `CREATE TABLE workflow_gates_new (
+          id INTEGER PRIMARY KEY,
+          work_item_id INTEGER NOT NULL,
+          gate_name TEXT NOT NULL,
+          passed_at DATETIME,
+          UNIQUE(work_item_id, gate_name),
+          FOREIGN KEY (work_item_id) REFERENCES work_items(id)
+        )`,
+        indexes: []
+      },
+      {
+        name: 'worktree_sessions',
+        create: `CREATE TABLE worktree_sessions_new (
+          id INTEGER PRIMARY KEY,
+          worktree_path TEXT UNIQUE NOT NULL,
+          work_item_id INTEGER NOT NULL,
+          branch_name TEXT NOT NULL,
+          last_activity DATETIME DEFAULT CURRENT_TIMESTAMP,
+          FOREIGN KEY (work_item_id) REFERENCES work_items(id)
+        )`,
+        indexes: [
+          'CREATE INDEX idx_worktree_sessions_path ON worktree_sessions(worktree_path)',
+          'CREATE INDEX idx_worktree_sessions_work_item ON worktree_sessions(work_item_id)'
+        ]
+      },
+      {
+        name: 'worktrees',
+        create: `CREATE TABLE worktrees_new (
+          id INTEGER PRIMARY KEY,
+          work_item_id INTEGER NOT NULL,
+          branch_name TEXT NOT NULL,
+          worktree_path TEXT NOT NULL,
+          status TEXT NOT NULL CHECK(status IN ('active', 'merging', 'merged', 'cleanup_pending', 'corrupted')),
+          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+          updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+          FOREIGN KEY (work_item_id) REFERENCES work_items(id)
+        )`,
+        indexes: [
+          'CREATE INDEX idx_worktrees_work_item_id ON worktrees(work_item_id)',
+          'CREATE INDEX idx_worktrees_status ON worktrees(status)'
+        ]
+      }
+    ];
+
+    return new Promise((resolve, reject) => {
+      db.run('PRAGMA foreign_keys = OFF', (err) => {
+        if (err) return reject(err);
+
+        db.serialize(() => {
+          for (const table of tables) {
+            // 1. Create new table without AUTOINCREMENT
+            db.run(table.create, (err) => {
+              if (err) return reject(new Error(`Failed to create ${table.name}_new: ${err.message}`));
+            });
+
+            // 2. Copy all data
+            db.run(`INSERT INTO ${table.name}_new SELECT * FROM ${table.name}`, (err) => {
+              if (err) return reject(new Error(`Failed to copy data for ${table.name}: ${err.message}`));
+            });
+
+            // 3. Drop old indexes
+            for (const idx of table.indexes) {
+              const idxName = idx.match(/CREATE INDEX (\S+)/)?.[1];
+              if (idxName) {
+                db.run(`DROP INDEX IF EXISTS ${idxName}`, (err) => {
+                  if (err) return reject(new Error(`Failed to drop index ${idxName}: ${err.message}`));
+                });
+              }
+            }
+
+            // 4. Drop old table
+            db.run(`DROP TABLE "${table.name}"`, (err) => {
+              if (err) return reject(new Error(`Failed to drop ${table.name}: ${err.message}`));
+            });
+
+            // 5. Rename new table
+            db.run(`ALTER TABLE ${table.name}_new RENAME TO ${table.name}`, (err) => {
+              if (err) return reject(new Error(`Failed to rename ${table.name}_new: ${err.message}`));
+            });
+
+            // 6. Recreate indexes
+            for (const idx of table.indexes) {
+              db.run(idx, (err) => {
+                if (err) return reject(new Error(`Failed to create index: ${err.message}`));
+              });
+            }
+          }
+
+          // 7. Drop sqlite_sequence (no longer needed without AUTOINCREMENT)
+          db.run('DROP TABLE IF EXISTS sqlite_sequence', (err) => {
+            if (err) return reject(new Error(`Failed to drop sqlite_sequence: ${err.message}`));
+          });
+
+          // 8. Re-enable foreign keys
+          db.run('PRAGMA foreign_keys = ON', (err) => {
+            if (err) return reject(err);
+            resolve();
+          });
+        });
+      });
+    });
+  }
+};