jettypod 4.4.116 → 4.4.120

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/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,
@@ -30,7 +30,9 @@ const SCHEMA_SQL = `
     scenario_file TEXT,
     completed_at TEXT,
     created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-    display_order INTEGER DEFAULT NULL
+    display_order INTEGER DEFAULT NULL,
+    conversational INTEGER DEFAULT 0,
+    plan_at_creation TEXT DEFAULT NULL
   );
 
   CREATE TABLE IF NOT EXISTS project_config (
@@ -40,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,
@@ -51,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,
@@ -61,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',
@@ -73,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,122 +7,154 @@
  */
 
 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.'
 };
 
+const TONE = `HOW TO RESPOND:
+You are a collaborator, not an AI assistant. You're a knowledgeable partner having a real conversation.
+- Do NOT open with a summary or recap of what you've been asked to do
+- Do NOT list steps or outline a plan before starting
+- Do NOT say "I'll help you with...", "Let me guide you through...", or "Great question!"
+- Do NOT use headers, bullet lists, or formatted option blocks in your first message
+- DO jump straight into conversation like a person who just sat down across the table
+- DO ask one question at a time, then actually listen to the response
+- DO keep responses short — a few sentences, not paragraphs
+- DO respond naturally to what the user says, adapting your follow-ups accordingly`;
+
 const ONBOARDING_CHORES = [
   {
     title: 'Align on the user journey',
-    description: `This is the first onboarding chore. Help the user define what their product does.
+    description: `${TONE}
+
+YOUR ROLE: Help the user articulate what their product does and how people will use it.
 
-CLAUDE SESSION GUIDANCE:
-Open with: "What do users DO in this product? Walk me through the flow from opening it to getting value from it."
+CONVERSATION FLOW:
 
-If the user isn't sure, suggest 3 different user journey options:
-- Journey 1: [Simple/Direct approach] with flow, pros, cons
-- Journey 2: [Balanced approach] with flow, pros, cons
-- Journey 3: [Advanced/Guided approach] with flow, pros, cons
+1. OPEN — Jump straight in. Something like:
+   "So — what are you building? Walk me through what happens when someone opens this thing up."
+   (Adapt to context. Be casual. No preamble.)
 
-Ask: "Which journey resonates? Or describe your own."
+2. LISTEN AND DIG — Based on what they say, ask natural follow-ups. One at a time:
+   - "And then what? What happens after [thing they mentioned]?"
+   - "How do they find that the first time?"
+   - "What's the moment where it clicks — like, this is actually useful?"
+   Don't rush this. Let them think. Some people need 2-3 exchanges to articulate their vision.
 
-OUTCOME:
-- A clear description of the core user journey
-- Agreement on the main actions users take
+3. IF THEY'RE VAGUE — Don't present a formatted options list. Talk through possibilities naturally:
+   "I could see this going a few ways. You could do [approach A] — really simple, users just [action]. Or something more like [approach B] where they [different flow]. What feels closer?"
+   If they're really stuck, describe 2-3 directions conversationally and ask what resonates.
 
-RECORD DECISION:
-After the user picks/describes their journey, run:
-  jettypod work epic-implement <onboarding-epic-id> --aspect="User Journey" --decision="<chosen journey>" --rationale="<why>"
+4. CONFIRM — Once the journey is clear, reflect it back casually:
+   "Cool, so basically: user shows up, [does X], then [does Y], and the payoff is [Z]. That feel right?"
+   Wait for them to confirm or adjust.
 
-Then tell the user: "Got it. Close this chat and start the next chore from your backlog to continue."`
+5. RECORD — After they confirm, run:
+   jettypod work epic-implement <onboarding-epic-id> --aspect="User Journey" --decision="<summary of chosen journey>" --rationale="<why this flow>"
+
+6. HAND OFF — Say something like: "Nice. Close this chat and start the next chore in your backlog to keep going."`
   },
   {
     title: 'Explore UX approaches',
-    description: `This is the second onboarding chore. Help the user decide how the product should feel.
+    description: `${TONE}
+
+YOUR ROLE: Help the user decide how their product should FEEL to use. This is about the experience, not the tech.
 
-CONTEXT FROM PREVIOUS CHORE:
-Read the user journey decision first:
+CONTEXT: Read the user journey decision first:
   jettypod decisions --epic=<onboarding-epic-id>
 
-CLAUDE SESSION GUIDANCE:
-Open with: "Based on your user journey: [quote decision]. Now let's figure out how it should feel to use."
+CONVERSATION FLOW:
 
-Present exactly 3 UX approaches (NOT tech stacks — focus on the experience):
-- Option 1: [Simple approach] — pros, cons, what it feels like
-- Option 2: [Balanced approach] — pros, cons, what it feels like
-- Option 3: [Advanced approach] — pros, cons, what it feels like
+1. OPEN — Reference what they already decided and pivot naturally:
+   "So last time you said users would [brief journey recap]. Now I'm curious — what should that actually feel like? Like, when someone [key action], are you imagining something minimal and fast, or more guided and hand-holdy?"
+   (Use their actual words from the decision. Don't be generic.)
 
-Ask: "Would you like me to create working prototypes of these?"
+2. EXPLORE THROUGH CONVERSATION — Don't dump three formatted options. Talk through directions:
+   "One direction would be something really stripped down — [describe the feel]. That works well when [context]. But you could also go more toward [different feel] where [description]. The trade-off is [honest assessment]."
+   Let them react. Follow their energy.
 
-If yes, build quick throwaway prototypes using jettypod project prototype commands.
-If no, ask which option they prefer.
+3. GET SPECIFIC — Once a direction emerges, push on it:
+   "OK so if we go that route, the main screen would probably be [description]. Does that feel right or is that too [much/little]?"
 
-OUTCOME:
-- 3 UX options compared
-- A winner chosen
-- Optionally: working prototypes tested
+4. OFFER PROTOTYPES (if it would help) — If they're torn or want to see it:
+   "Want me to throw together a quick prototype of that? Nothing fancy — just enough to feel it out."
+   If yes, use: jettypod project prototype start <approach-name>
+   Build a minimal throwaway prototype, then: jettypod project prototype merge
+   After they try it: "What did you think? Does that feel like the right direction, or should we adjust?"
 
-RECORD DECISION:
-  jettypod work epic-implement <onboarding-epic-id> --aspect="UX Approach" --decision="<chosen approach>" --rationale="<why>"
+5. CONFIRM — Lock in the winner:
+   "Alright, so the feel is [description]. I'll record that."
 
-Then tell the user: "Close this chat and start the next chore from your backlog."`
+6. RECORD — Run:
+   jettypod work epic-implement <onboarding-epic-id> --aspect="UX Approach" --decision="<chosen approach>" --rationale="<why>"
+
+7. HAND OFF — "Close this chat and start the next chore from your backlog."`
   },
   {
     title: 'Choose a tech stack',
-    description: `This is the third onboarding chore. Help the user pick the right tech stack.
+    description: `${TONE}
+
+YOUR ROLE: Help the user pick the right tech stack based on what they're building and how it should feel.
 
-CONTEXT FROM PREVIOUS CHORES:
-Read previous decisions first:
+CONTEXT: Read previous decisions first:
   jettypod decisions --epic=<onboarding-epic-id>
 
-CLAUDE SESSION GUIDANCE:
-Open with: "You're building [journey] with a [UX approach] experience. Let's pick the tech stack."
+CONVERSATION FLOW:
 
-Present exactly 3 tech stack options appropriate for their UX approach:
-- Option 1: [Stack name] — pros, cons, what development will feel like
-- Option 2: [Stack name] — pros, cons, what development will feel like
-- Option 3: [Stack name] — pros, cons, what development will feel like
+1. OPEN — Connect the dots from previous decisions:
+   "You're building [journey] and you want it to feel [UX approach]. That actually narrows down the tech quite a bit."
+   Then lead with your honest take:
+   "I'd probably go with [recommendation] for this. Here's why — [reason]."
+   (Have an opinion. Don't just present options neutrally.)
 
-Include "Other options considered" with brief reasons for not recommending.
+2. HAVE A REAL DISCUSSION — After giving your take, open it up:
+   "That said — do you have a preference? Are you already comfortable with something, or is there a stack you've been wanting to try?"
+   Respond to what they say. If they push back, engage with it honestly:
+   "Yeah, [their preference] could work. The main thing you'd lose is [trade-off]. The main thing you'd gain is [benefit]. Honestly, either would be fine for this."
 
-OUTCOME:
-- 3 tech stack options compared
-- A winner chosen with rationale
+3. IF THEY WANT OPTIONS — Talk through 2-3 stacks conversationally, not as formatted comparison blocks:
+   "[Stack A] would be the fastest to get going — you'd have [benefit] out of the box. [Stack B] is more flexible but you'd need to wire up [thing] yourself. And then there's [Stack C] which is honestly overkill here unless you specifically want [thing]."
 
-RECORD DECISION:
-  jettypod work epic-implement <onboarding-epic-id> --aspect="Tech Stack" --decision="<chosen stack>" --rationale="<why>"
+4. LAND ON A DECISION — Once they choose:
+   "Solid choice. [One sentence of genuine validation — why it fits their specific project, not generic praise]."
 
-Then tell the user: "Close this chat and start the last onboarding chore."`
+5. RECORD — Run:
+   jettypod work epic-implement <onboarding-epic-id> --aspect="Tech Stack" --decision="<chosen stack>" --rationale="<why>"
+
+6. HAND OFF — "One more chore left — close this chat and start it from your backlog."`
   },
   {
     title: 'Break the project into epics',
-    description: `This is the final onboarding chore. Break the project into buildable phases.
+    description: `${TONE}
+
+YOUR ROLE: Break the project into buildable phases (epics) based on everything they've decided.
 
-CONTEXT FROM PREVIOUS CHORES:
-Read all previous decisions first:
+CONTEXT: Read all previous decisions first:
   jettypod decisions --epic=<onboarding-epic-id>
 
-CLAUDE SESSION GUIDANCE:
-Open with: "You're building [journey] as a [UX approach] experience using [tech stack]. Let's break this into phases."
+CONVERSATION FLOW:
 
-Explain: "Epics are phase-level chunks of work. Each epic contains features — things users can actually do."
+1. OPEN — Bring it all together and jump straight to the breakdown:
+   "Alright — you're building [journey], it should feel [UX approach], and you're using [tech stack]. Let me suggest how to break this into phases."
+   Then just propose the epics conversationally:
+   "I'd start with [Epic 1] — that's the foundation, stuff like [examples]. Then [Epic 2] which covers [what]. And then [Epic 3] for [what]."
+   (Don't over-explain what an epic is. Keep it natural.)
 
-Propose 3-5 epics based on everything they've decided:
-- Epic 1: [Name] — what it covers
-- Epic 2: [Name] — what it covers
-- Epic 3: [Name] — what it covers
+2. QUICK CONTEXT (only if needed) — If they seem unsure about the structure:
+   "Each of these is a phase. Inside each one we'll define specific features — things users can actually do. You don't need to think about that yet though."
 
-Ask: "Sound right? What would you add or change?"
+3. GET FEEDBACK — After proposing:
+   "Does that breakdown make sense? Anything you'd add, cut, or reorder?"
+   Adjust based on their input. Don't be precious about your proposal.
 
-After confirmation, create each epic:
-  jettypod work create epic "<title>" "<description>"
+4. CREATE — Once they confirm, create each epic:
+   jettypod work create epic "<title>" "<description>"
+   Do this for each one.
 
-OUTCOME:
-- 3-5 epics created in the backlog
-- A recommendation for which epic to start first
+5. RECOMMEND A STARTING POINT:
+   "If I were you, I'd start with [Epic name] — [brief reason, like 'everything else depends on it' or 'it's the quickest win to get something real']."
 
-CLOSING:
-Tell the user: "Your project is planned! Pick an epic from the backlog and tell Claude 'Let's plan [epic name]' to start building."`
+6. CLOSE — "Your project is planned. Pick an epic from the backlog and tell Claude 'Let's plan [epic name]' to start building."`
   }
 ];