jettypod 4.4.118 → 4.4.121

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();
+          });
+        });
+      });
+    });
+  }
+};

package/lib/migrations/029-rename-corrupted-to-cleaned.js

@@ -0,0 +1,149 @@
+/**
+ * Migration: Rename worktree status 'corrupted' to 'cleaned'
+ *
+ * The 'corrupted' status was misleading — it's the terminal state for worktrees
+ * that have been successfully cleaned up, not actually corrupted data.
+ * Renaming to 'cleaned' for clarity.
+ *
+ * SQLite doesn't support ALTER CONSTRAINT, so we recreate the table.
+ */
+
+module.exports = {
+  id: '029-rename-corrupted-to-cleaned',
+  description: 'Rename worktree status corrupted to cleaned for clarity',
+
+  async up(db) {
+    return new Promise((resolve, reject) => {
+      db.serialize(() => {
+        // 1. Update existing records
+        db.run(`UPDATE worktrees SET status = 'cleaned' WHERE status = 'corrupted'`, (err) => {
+          if (err) return reject(err);
+        });
+
+        // 2. Create new table with updated constraint
+        db.run(`
+          CREATE TABLE IF NOT EXISTS worktrees_new (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            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', 'cleaned')),
+            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)
+          )
+        `, (err) => {
+          if (err) return reject(err);
+        });
+
+        // 3. Copy data
+        db.run(`
+          INSERT INTO worktrees_new (id, work_item_id, branch_name, worktree_path, status, created_at, updated_at)
+          SELECT id, work_item_id, branch_name, worktree_path, status, created_at, updated_at
+          FROM worktrees
+        `, (err) => {
+          if (err) return reject(err);
+        });
+
+        // 4. Drop old indexes
+        db.run('DROP INDEX IF EXISTS idx_worktrees_work_item_id', (err) => {
+          if (err) return reject(err);
+        });
+
+        db.run('DROP INDEX IF EXISTS idx_worktrees_status', (err) => {
+          if (err) return reject(err);
+        });
+
+        // 5. Drop old table
+        db.run('DROP TABLE worktrees', (err) => {
+          if (err) return reject(err);
+        });
+
+        // 6. Rename new table
+        db.run('ALTER TABLE worktrees_new RENAME TO worktrees', (err) => {
+          if (err) return reject(err);
+        });
+
+        // 7. Recreate indexes
+        db.run(`
+          CREATE INDEX idx_worktrees_work_item_id
+          ON worktrees(work_item_id)
+        `, (err) => {
+          if (err) return reject(err);
+        });
+
+        db.run(`
+          CREATE INDEX idx_worktrees_status
+          ON worktrees(status)
+        `, (err) => {
+          if (err) return reject(err);
+          resolve();
+        });
+      });
+    });
+  },
+
+  async down(db) {
+    return new Promise((resolve, reject) => {
+      db.serialize(() => {
+        db.run(`UPDATE worktrees SET status = 'corrupted' WHERE status = 'cleaned'`, (err) => {
+          if (err) return reject(err);
+        });
+
+        db.run(`
+          CREATE TABLE IF NOT EXISTS worktrees_new (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            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)
+          )
+        `, (err) => {
+          if (err) return reject(err);
+        });
+
+        db.run(`
+          INSERT INTO worktrees_new (id, work_item_id, branch_name, worktree_path, status, created_at, updated_at)
+          SELECT id, work_item_id, branch_name, worktree_path, status, created_at, updated_at
+          FROM worktrees
+        `, (err) => {
+          if (err) return reject(err);
+        });
+
+        db.run('DROP INDEX IF EXISTS idx_worktrees_work_item_id', (err) => {
+          if (err) return reject(err);
+        });
+
+        db.run('DROP INDEX IF EXISTS idx_worktrees_status', (err) => {
+          if (err) return reject(err);
+        });
+
+        db.run('DROP TABLE worktrees', (err) => {
+          if (err) return reject(err);
+        });
+
+        db.run('ALTER TABLE worktrees_new RENAME TO worktrees', (err) => {
+          if (err) return reject(err);
+        });
+
+        db.run(`
+          CREATE INDEX idx_worktrees_work_item_id
+          ON worktrees(work_item_id)
+        `, (err) => {
+          if (err) return reject(err);
+        });
+
+        db.run(`
+          CREATE INDEX idx_worktrees_status
+          ON worktrees(status)
+        `, (err) => {
+          if (err) return reject(err);
+          resolve();
+        });
+      });
+    });
+  }
+};

package/lib/migrations/030-rejection-round-columns.js

@@ -0,0 +1,54 @@
+/**
+ * Migration: Add rejection round tracking columns to work_items
+ *
+ * Purpose: Support rejection round nesting by tracking how many times
+ * a parent item has been rejected and which round spawned each child.
+ *
+ * Columns:
+ * - rejection_count INTEGER DEFAULT 0: Number of times this item has been rejected
+ * - rejection_round INTEGER: Which rejection round spawned this child item (null = original)
+ * - rejection_history TEXT: JSON array of [{round, reason, at}] for all rejections
+ */
+
+module.exports = {
+  id: '030-rejection-round-columns',
+  description: 'Add rejection_count, rejection_round, and rejection_history columns to work_items',
+
+  async up(db) {
+    return new Promise((resolve, reject) => {
+      db.run(`ALTER TABLE work_items ADD COLUMN rejection_count INTEGER DEFAULT 0`, (err) => {
+        if (err) return reject(err);
+        db.run(`ALTER TABLE work_items ADD COLUMN rejection_round INTEGER`, (err) => {
+          if (err) return reject(err);
+          db.run(`ALTER TABLE work_items ADD COLUMN rejection_history TEXT`, (err) => {
+            if (err) return reject(err);
+            resolve();
+          });
+        });
+      });
+    });
+  },
+
+  async down(db) {
+    // SQLite 3.35+ supports DROP COLUMN, but for safety we use the backup approach
+    return new Promise((resolve, reject) => {
+      db.all(`PRAGMA table_info(work_items)`, (err, columns) => {
+        if (err) return reject(err);
+        const keepColumns = columns
+          .map(c => c.name)
+          .filter(n => n !== 'rejection_count' && n !== 'rejection_round' && n !== 'rejection_history');
+        const columnList = keepColumns.join(', ');
+        db.run(`CREATE TABLE work_items_backup AS SELECT ${columnList} FROM work_items`, (err) => {
+          if (err) return reject(err);
+          db.run(`DROP TABLE work_items`, (err) => {
+            if (err) return reject(err);
+            db.run(`ALTER TABLE work_items_backup RENAME TO work_items`, (err) => {
+              if (err) return reject(err);
+              resolve();
+            });
+          });
+        });
+      });
+    });
+  }
+};

package/lib/migrations/031-session-isolation-index.js

@@ -0,0 +1,17 @@
+module.exports = {
+  id: '031-session-isolation-index',
+  description: 'Add index on claude_sessions for efficient session isolation filtering',
+
+  async up(db) {
+    await new Promise((resolve, reject) => {
+      db.run(`
+        CREATE INDEX IF NOT EXISTS idx_claude_sessions_active_work
+        ON claude_sessions(status, work_item_id)
+        WHERE work_item_id IS NOT NULL AND status = 'active'
+      `, (err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+  }
+};

package/lib/migrations/index.js

@@ -20,11 +20,16 @@ async function runMigrations(db) {
     });
   });
 
-  // Get list of applied migrations
-  const applied = await new Promise((resolve, reject) => {
-    db.all('SELECT id FROM migrations', [], (err, rows) => {
+  // Create _meta table for schema versioning
+  await new Promise((resolve, reject) => {
+    db.run(`
+      CREATE TABLE IF NOT EXISTS _meta (
+        key TEXT PRIMARY KEY,
+        value TEXT
+      )
+    `, (err) => {
       if (err) reject(err);
-      else resolve(rows.map(r => r.id));
+      else resolve();
     });
   });
 
@@ -34,6 +39,32 @@ async function runMigrations(db) {
     .filter(f => f.endsWith('.js') && f !== 'index.js' && !f.endsWith('.test.js'))
     .sort();
 
+  const knownMigrationCount = files.length;
+
+  // Check schema version for forward-compatibility
+  const currentVersion = await new Promise((resolve, reject) => {
+    db.get('SELECT value FROM _meta WHERE key = ?', ['schema_version'], (err, row) => {
+      if (err) reject(err);
+      else resolve(row ? parseInt(row.value, 10) : 0);
+    });
+  });
+
+  if (currentVersion > knownMigrationCount) {
+    console.warn(
+      `⚠️  Database schema version (${currentVersion}) is newer than this version of JettyPod supports (${knownMigrationCount}).` +
+      '\n   Please update JettyPod to avoid compatibility issues.'
+    );
+    return; // Don't run migrations — the DB is from a newer version
+  }
+
+  // Get list of applied migrations
+  const applied = await new Promise((resolve, reject) => {
+    db.all('SELECT id FROM migrations', [], (err, rows) => {
+      if (err) reject(err);
+      else resolve(rows.map(r => r.id));
+    });
+  });
+
   // Run pending migrations
   for (const file of files) {
     const migration = require(path.join(migrationsDir, file));
@@ -69,6 +100,18 @@ async function runMigrations(db) {
       throw err;
     }
   }
+
+  // Update schema version to reflect current state
+  await new Promise((resolve, reject) => {
+    db.run(
+      'INSERT OR REPLACE INTO _meta (key, value) VALUES (?, ?)',
+      ['schema_version', String(knownMigrationCount)],
+      (err) => {
+        if (err) reject(err);
+        else resolve();
+      }
+    );
+  });
 }
 
 module.exports = { runMigrations };

package/lib/schema.js

@@ -11,7 +11,7 @@
 
 const SCHEMA_SQL = `
   CREATE TABLE IF NOT EXISTS work_items (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    id INTEGER PRIMARY KEY,
     type TEXT NOT NULL,
     title TEXT NOT NULL,
     description TEXT,
@@ -42,7 +42,7 @@ const SCHEMA_SQL = `
   );
 
   CREATE TABLE IF NOT EXISTS external_readiness_checklist (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    id INTEGER PRIMARY KEY,
     category TEXT NOT NULL,
     item_key TEXT NOT NULL,
     title TEXT NOT NULL,
@@ -53,7 +53,7 @@ const SCHEMA_SQL = `
   );
 
   CREATE TABLE IF NOT EXISTS discovery_decisions (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    id INTEGER PRIMARY KEY,
     work_item_id INTEGER NOT NULL,
     aspect TEXT NOT NULL,
     decision TEXT NOT NULL,
@@ -63,7 +63,7 @@ const SCHEMA_SQL = `
   );
 
   CREATE TABLE IF NOT EXISTS skill_executions (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    id INTEGER PRIMARY KEY,
     work_item_id INTEGER NOT NULL,
     skill_name TEXT NOT NULL,
     status TEXT DEFAULT 'in_progress',
@@ -75,13 +75,18 @@ const SCHEMA_SQL = `
   );
 
   CREATE TABLE IF NOT EXISTS workflow_gates (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    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)
   );
+
+  CREATE TABLE IF NOT EXISTS _meta (
+    key TEXT PRIMARY KEY,
+    value TEXT
+  );
 `;
 
 /**

package/lib/seed-onboarding.js

@@ -7,7 +7,7 @@
  */
 
 const ONBOARDING_EPIC = {
-  title: 'Project Onboarding',
+  title: 'Project Planning',
   description: 'Get your project set up and planned. Work through these chores one at a time — each one is a short conversation.'
 };