jettypod 4.4.74 → 4.4.76

package/apps/dashboard/components/RealTimeKanbanWrapper.tsx

@@ -2,8 +2,9 @@
 
 import { useState, useCallback } from 'react';
 import { KanbanBoard } from './KanbanBoard';
+import { RecentDecisionsWidget } from './RecentDecisionsWidget';
 import { useWebSocket, type WebSocketMessage } from '../hooks/useWebSocket';
-import type { InFlightItem, KanbanGroup } from '@/lib/db';
+import type { InFlightItem, KanbanGroup, Decision } from '@/lib/db';
 
 interface KanbanData {
   inFlight: InFlightItem[];
@@ -17,24 +18,34 @@ interface RealTimeKanbanWrapperProps {
     backlog: [string, KanbanGroup][];
     done: [string, KanbanGroup][];
   };
+  initialDecisions: Decision[];
 }
 
-export function RealTimeKanbanWrapper({ initialData }: RealTimeKanbanWrapperProps) {
+export function RealTimeKanbanWrapper({ initialData, initialDecisions }: RealTimeKanbanWrapperProps) {
   const [data, setData] = useState<KanbanData>(() => ({
     inFlight: initialData.inFlight,
     backlog: new Map(initialData.backlog),
     done: new Map(initialData.done),
   }));
+  const [decisions, setDecisions] = useState<Decision[]>(initialDecisions);
   const [statusError, setStatusError] = useState<string | null>(null);
 
   const refreshData = useCallback(async () => {
-    const response = await fetch('/api/kanban');
-    const newData = await response.json();
+    const [kanbanResponse, decisionsResponse] = await Promise.all([
+      fetch('/api/kanban'),
+      fetch('/api/decisions').catch(() => null),
+    ]);
+    const newData = await kanbanResponse.json();
     setData({
       inFlight: newData.inFlight,
       backlog: new Map(newData.backlog),
       done: new Map(newData.done),
     });
+    // Silently retain previous decisions if API fails
+    if (decisionsResponse?.ok) {
+      const newDecisions = await decisionsResponse.json();
+      setDecisions(newDecisions);
+    }
   }, []);
 
   const handleMessage = useCallback((message: WebSocketMessage) => {
@@ -75,6 +86,32 @@ export function RealTimeKanbanWrapper({ initialData }: RealTimeKanbanWrapperProp
     }
   }, [refreshData]);
 
+  const handleOrderChange = useCallback(async (id: number, newOrder: number) => {
+    try {
+      await fetch(`/api/work/${id}/order`, {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ display_order: newOrder }),
+      });
+      await refreshData();
+    } catch {
+      // Silently fail order changes
+    }
+  }, [refreshData]);
+
+  const handleEpicAssign = useCallback(async (id: number, epicId: number | null) => {
+    try {
+      await fetch(`/api/work/${id}/epic`, {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ epic_id: epicId }),
+      });
+      await refreshData();
+    } catch {
+      // Silently fail epic assignment
+    }
+  }, [refreshData]);
+
   const wsUrl = typeof window !== 'undefined'
     ? `ws://${window.location.hostname}:8080`
     : 'ws://localhost:8080';
@@ -88,11 +125,11 @@ export function RealTimeKanbanWrapper({ initialData }: RealTimeKanbanWrapperProp
   const connectionStatus = isConnected ? 'connected' : isReconnecting ? 'reconnecting' : 'disconnected';
 
   return (
-    <div>
+    <div className="h-full flex flex-col">
       {/* Status Error Display */}
       {statusError && (
         <div
-          className="mb-4 p-3 bg-red-100 dark:bg-red-900/30 text-red-700 dark:text-red-300 rounded-lg flex items-center justify-between"
+          className="mb-4 p-3 bg-red-100 dark:bg-red-900/30 text-red-700 dark:text-red-300 rounded-lg flex items-center justify-between flex-shrink-0"
           data-testid="status-error"
         >
           <span>{statusError}</span>
@@ -106,7 +143,7 @@ export function RealTimeKanbanWrapper({ initialData }: RealTimeKanbanWrapperProp
         </div>
       )}
       {/* Connection Status Indicator */}
-      <div className="mb-4 flex items-center gap-2" data-testid="connection-status">
+      <div className="mb-4 flex items-center gap-2 flex-shrink-0" data-testid="connection-status">
         <span
           className={`w-2 h-2 rounded-full ${
             connectionStatus === 'connected'
@@ -124,13 +161,22 @@ export function RealTimeKanbanWrapper({ initialData }: RealTimeKanbanWrapperProp
             : 'Disconnected'}
         </span>
       </div>
-      <KanbanBoard
-        inFlight={data.inFlight}
-        backlog={data.backlog}
-        done={data.done}
-        onTitleSave={handleTitleSave}
-        onStatusChange={handleStatusChange}
-      />
+      <div className="flex-1 min-h-0 flex gap-4">
+        <div className="flex-1 min-w-0">
+          <KanbanBoard
+            inFlight={data.inFlight}
+            backlog={data.backlog}
+            done={data.done}
+            onTitleSave={handleTitleSave}
+            onStatusChange={handleStatusChange}
+            onOrderChange={handleOrderChange}
+            onEpicAssign={handleEpicAssign}
+          />
+        </div>
+        <div className="w-60 flex-shrink-0">
+          <RecentDecisionsWidget decisions={decisions} />
+        </div>
+      </div>
     </div>
   );
 }

package/apps/dashboard/components/RecentDecisionsWidget.tsx

@@ -0,0 +1,58 @@
+'use client';
+
+import type { Decision } from '@/lib/db';
+
+interface RecentDecisionsWidgetProps {
+  decisions: Decision[];
+}
+
+function formatRelativeDate(dateString: string): string {
+  const date = new Date(dateString);
+  const now = new Date();
+  const diffMs = now.getTime() - date.getTime();
+  const diffMins = Math.floor(diffMs / 60000);
+  const diffHours = Math.floor(diffMs / 3600000);
+  const diffDays = Math.floor(diffMs / 86400000);
+
+  if (diffMins < 1) return 'just now';
+  if (diffMins < 60) return `${diffMins}m ago`;
+  if (diffHours < 24) return `${diffHours}h ago`;
+  if (diffDays < 7) return `${diffDays}d ago`;
+  return date.toLocaleDateString();
+}
+
+export function RecentDecisionsWidget({ decisions }: RecentDecisionsWidgetProps) {
+  if (decisions.length === 0) {
+    return (
+      <div className="bg-white dark:bg-zinc-800 rounded-lg border border-zinc-200 dark:border-zinc-700 p-4">
+        <h3 className="text-sm font-semibold text-zinc-900 dark:text-zinc-100 mb-3">
+          Recent Decisions
+        </h3>
+        <p className="text-sm text-zinc-500 dark:text-zinc-400">No decisions yet</p>
+      </div>
+    );
+  }
+
+  return (
+    <div className="bg-white dark:bg-zinc-800 rounded-lg border border-zinc-200 dark:border-zinc-700 p-4">
+      <h3 className="text-sm font-semibold text-zinc-900 dark:text-zinc-100 mb-3">
+        Recent Decisions
+      </h3>
+      <div className="space-y-3">
+        {decisions.map((decision) => (
+          <div key={decision.id} className="flex gap-3">
+            <div className="w-1 bg-zinc-300 dark:bg-zinc-600 rounded-full flex-shrink-0" />
+            <div className="flex-1 min-w-0">
+              <p className="text-sm text-zinc-900 dark:text-zinc-100 line-clamp-2">
+                {decision.decision}
+              </p>
+              <p className="text-xs text-zinc-500 dark:text-zinc-400 mt-1">
+                {decision.aspect || 'General'} &middot; #{decision.work_item_id} &middot; {formatRelativeDate(decision.created_at)}
+              </p>
+            </div>
+          </div>
+        ))}
+      </div>
+    </div>
+  );
+}

package/apps/dashboard/lib/db.ts

@@ -3,6 +3,7 @@
 
 import Database from 'better-sqlite3';
 import path from 'path';
+import fs from 'fs';
 import { execSync } from 'child_process';
 
 // Types matching JettyPod schema
@@ -19,6 +20,7 @@ export interface WorkItem {
   phase: string | null;
   completed_at: string | null;
   created_at: string;
+  display_order: number | null;
   children?: WorkItem[];
   chores?: WorkItem[];
   current_step?: number | null;
@@ -52,6 +54,16 @@ function getDbPath(): string {
   return path.join(projectRoot, '.jettypod', 'work.db');
 }
 
+export function getProjectName(): string {
+  const projectRoot = getProjectRoot();
+  const configPath = path.join(projectRoot, '.jettypod', 'config.json');
+  if (fs.existsSync(configPath)) {
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    return config.name || 'Untitled Project';
+  }
+  return 'Untitled Project';
+}
+
 function getDb(): Database.Database {
   const dbPath = getDbPath();
   return new Database(dbPath, { readonly: true });
@@ -123,6 +135,40 @@ export function getDecisionsForWorkItem(workItemId: number): Decision[] {
   }
 }
 
+export function getRecentDecisions(limit: number = 5): Decision[] {
+  const db = getDb();
+  try {
+    // Combine epic architectural decisions and feature UX decisions
+    const decisions = db.prepare(`
+      SELECT id, work_item_id, aspect, decision, rationale, created_at
+      FROM (
+        -- Epic architectural decisions from discovery_decisions table
+        SELECT id, work_item_id, aspect, decision, rationale, created_at
+        FROM discovery_decisions
+
+        UNION ALL
+
+        -- Feature UX decisions from work_items table
+        -- Use discovery_completed_at when available, fallback to created_at for older records
+        SELECT
+          id * -1 as id,
+          id as work_item_id,
+          'UX Approach' as aspect,
+          discovery_winner as decision,
+          discovery_rationale as rationale,
+          COALESCE(discovery_completed_at, created_at) as created_at
+        FROM work_items
+        WHERE discovery_winner IS NOT NULL
+      )
+      ORDER BY created_at DESC
+      LIMIT ?
+    `).all(limit) as Decision[];
+    return decisions;
+  } finally {
+    db.close();
+  }
+}
+
 // Build a tree structure from flat work items
 export function buildWorkItemTree(items: WorkItem[]): WorkItem[] {
   const itemMap = new Map<number, WorkItem>();
@@ -239,7 +285,7 @@ export function getKanbanData(doneLimit: number = 50): KanbanData {
     // - Bugs if they exist
     const allItems = db.prepare(`
       SELECT w.id, w.type, w.title, w.description, w.status, w.parent_id, w.epic_id,
-             w.branch_name, w.mode, w.phase, w.completed_at, w.created_at,
+             w.branch_name, w.mode, w.phase, w.completed_at, w.created_at, w.display_order,
              p.type as parent_type,
              wc.current_step, wc.total_steps
       FROM work_items w
@@ -247,7 +293,7 @@ export function getKanbanData(doneLimit: number = 50): KanbanData {
       LEFT JOIN workflow_checkpoints wc ON wc.work_item_id = w.id
       WHERE w.type IN ('feature', 'chore', 'bug')
         AND (w.parent_id IS NULL OR p.type = 'epic')
-      ORDER BY w.id
+      ORDER BY COALESCE(w.display_order, w.id)
     `).all() as (WorkItem & { parent_type: string | null })[];
 
     const inFlight: InFlightItem[] = [];
@@ -291,21 +337,46 @@ export function getKanbanData(doneLimit: number = 50): KanbanData {
       }
     }
 
-    // Limit done items
+    // Sort done items by completed_at DESC (newest first) within each group
+    for (const [, group] of doneGroups) {
+      group.items.sort((a, b) => {
+        const dateA = a.completed_at ? new Date(a.completed_at).getTime() : 0;
+        const dateB = b.completed_at ? new Date(b.completed_at).getTime() : 0;
+        return dateB - dateA; // DESC order
+      });
+    }
+
+    // Sort epic groups by most recent completion date (newest first)
+    const sortedDoneGroups = new Map(
+      Array.from(doneGroups.entries()).sort(([, groupA], [, groupB]) => {
+        const mostRecentA = groupA.items[0]?.completed_at
+          ? new Date(groupA.items[0].completed_at).getTime()
+          : 0;
+        const mostRecentB = groupB.items[0]?.completed_at
+          ? new Date(groupB.items[0].completed_at).getTime()
+          : 0;
+        return mostRecentB - mostRecentA; // DESC order
+      })
+    );
+
+    // Limit done items - build new Map to avoid modifying during iteration
+    const limitedDoneGroups = new Map<string, KanbanGroup>();
     let doneCount = 0;
-    for (const [key, group] of doneGroups) {
+    for (const [key, group] of sortedDoneGroups) {
       if (doneCount >= doneLimit) {
-        doneGroups.delete(key);
-        continue;
+        break;
       }
       const remaining = doneLimit - doneCount;
       if (group.items.length > remaining) {
-        group.items = group.items.slice(0, remaining);
+        limitedDoneGroups.set(key, { ...group, items: group.items.slice(0, remaining) });
+        doneCount += remaining;
+      } else {
+        limitedDoneGroups.set(key, group);
+        doneCount += group.items.length;
       }
-      doneCount += group.items.length;
     }
 
-    return { inFlight, backlog: backlogGroups, done: doneGroups };
+    return { inFlight, backlog: backlogGroups, done: limitedDoneGroups };
   } finally {
     db.close();
   }
@@ -335,3 +406,28 @@ export function updateWorkItemStatus(id: number, status: string): boolean {
     db.close();
   }
 }
+
+export function updateWorkItemOrder(id: number, displayOrder: number): boolean {
+  const db = getWriteDb();
+  try {
+    const result = db.prepare(`
+      UPDATE work_items SET display_order = ? WHERE id = ?
+    `).run(displayOrder, id);
+    return result.changes > 0;
+  } finally {
+    db.close();
+  }
+}
+
+export function updateWorkItemEpic(id: number, epicId: number | null): boolean {
+  const db = getWriteDb();
+  try {
+    // Update parent_id for features/chores to assign them to an epic
+    const result = db.prepare(`
+      UPDATE work_items SET parent_id = ? WHERE id = ? AND type IN ('feature', 'chore', 'bug')
+    `).run(epicId, id);
+    return result.changes > 0;
+  } finally {
+    db.close();
+  }
+}

package/apps/dashboard/package.json

@@ -12,6 +12,7 @@
     "better-sqlite3": "^12.5.0",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
+    "framer-motion": "^11.15.0",
     "lucide-react": "^0.555.0",
     "next": "16.0.6",
     "react": "19.2.0",
@@ -28,6 +29,6 @@
     "eslint-config-next": "16.0.6",
     "tailwindcss": "^4",
     "tw-animate-css": "^1.4.0",
-    "typescript": "^5"
+    "typescript": "5.9.3"
   }
 }

package/lib/database.js

@@ -250,6 +250,7 @@ function initSchema() {
       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) => {
         handleAlterError('architectural_decision')(err);
         // Run data migrations after all schema operations complete (skip in test environments)
@@ -279,7 +280,8 @@ function validateSchema(database) {
     'id', 'type', 'title', 'description', 'status', 'parent_id', 'epic_id',
     'branch_name', 'file_paths', 'commit_sha', 'mode', 'current', 'phase',
     'prototype_files', 'discovery_winner', 'discovery_rationale', 'scenario_file',
-    'completed_at', 'created_at', 'needs_discovery', 'worktree_path', 'architectural_decision'
+    'completed_at', 'created_at', 'needs_discovery', 'worktree_path', 'architectural_decision',
+    'display_order'
   ];
 
   return new Promise((resolve, reject) => {

package/lib/migrations/017-display-order-column.js

@@ -0,0 +1,48 @@
+/**
+ * Migration: Add display_order column to work_items table
+ *
+ * Purpose: Enable custom ordering of work items in the Kanban board.
+ * When items are dragged and dropped, their display_order is updated
+ * to maintain the user's preferred ordering.
+ */
+
+module.exports = {
+  id: '017-display-order-column',
+  description: 'Add display_order column to work_items for Kanban board ordering',
+
+  async up(db) {
+    return new Promise((resolve, reject) => {
+      db.run(`
+        ALTER TABLE work_items
+        ADD COLUMN display_order INTEGER DEFAULT NULL
+      `, (err) => {
+        if (err) {
+          // Column might already exist from a partial migration
+          if (err.message && err.message.includes('duplicate column')) {
+            return resolve();
+          }
+          return reject(err);
+        }
+        resolve();
+      });
+    });
+  },
+
+  async down(db) {
+    // SQLite doesn't support DROP COLUMN in older versions
+    // For newer SQLite (3.35+), we can use DROP COLUMN directly
+    return new Promise((resolve, reject) => {
+      db.run(`
+        ALTER TABLE work_items DROP COLUMN display_order
+      `, (err) => {
+        if (err) {
+          // If DROP COLUMN isn't supported, we'd need table recreation
+          // but for this simple nullable column, it's safe to leave
+          console.warn('Could not drop display_order column:', err.message);
+          return resolve();
+        }
+        resolve();
+      });
+    });
+  }
+};

package/lib/migrations/019-discovery-completed-at.js

@@ -0,0 +1,36 @@
+/**
+ * Migration: Add discovery_completed_at column to work_items table
+ *
+ * Purpose: Track when feature UX decisions are actually made (via work implement),
+ * rather than using created_at which is when the work item was created.
+ * This enables proper chronological sorting in the decisions widget.
+ */
+
+module.exports = {
+  id: '019-discovery-completed-at',
+  description: 'Add discovery_completed_at column to work_items for accurate decision timestamps',
+
+  async up(db) {
+    return new Promise((resolve, reject) => {
+      db.run(`
+        ALTER TABLE work_items
+        ADD COLUMN discovery_completed_at TEXT
+      `, (err) => {
+        if (err) {
+          // Column might already exist from a partial migration
+          if (err.message && err.message.includes('duplicate column')) {
+            return resolve();
+          }
+          return reject(err);
+        }
+        resolve();
+      });
+    });
+  },
+
+  async down(db) {
+    // SQLite doesn't support DROP COLUMN in older versions
+    // For simplicity, we'll leave the column (it's nullable and harmless)
+    return Promise.resolve();
+  }
+};

package/lib/migrations/020-normalize-timestamps.js

@@ -0,0 +1,59 @@
+/**
+ * Migration: Normalize completed_at timestamps to ISO format
+ *
+ * Purpose: Convert space-separated timestamps (e.g., "2025-12-12 21:22:40")
+ * to ISO format (e.g., "2025-12-12T21:22:40.000Z") for consistent sorting.
+ * Old timestamps were written by SQLite datetime('now') as local time.
+ */
+
+module.exports = {
+  id: '020-normalize-timestamps',
+  description: 'Normalize completed_at timestamps to ISO format',
+
+  async up(db) {
+    return new Promise((resolve, reject) => {
+      // Find all rows with space-separated timestamps (not ISO format)
+      db.all(
+        `SELECT id, completed_at FROM work_items
+         WHERE completed_at IS NOT NULL
+         AND completed_at NOT LIKE '%T%'`,
+        (err, rows) => {
+          if (err) return reject(err);
+          if (!rows || rows.length === 0) return resolve();
+
+          let pending = rows.length;
+          let hasError = false;
+
+          for (const row of rows) {
+            if (hasError) continue;
+
+            // Parse as local time (JS default for space-separated format)
+            // Then convert to ISO string (UTC)
+            const localDate = new Date(row.completed_at);
+            const isoTimestamp = localDate.toISOString();
+
+            db.run(
+              `UPDATE work_items SET completed_at = ? WHERE id = ?`,
+              [isoTimestamp, row.id],
+              (updateErr) => {
+                if (updateErr && !hasError) {
+                  hasError = true;
+                  return reject(updateErr);
+                }
+                pending--;
+                if (pending === 0 && !hasError) {
+                  resolve();
+                }
+              }
+            );
+          }
+        }
+      );
+    });
+  },
+
+  async down(db) {
+    // No practical way to reverse this - timestamps are still valid
+    return Promise.resolve();
+  }
+};

package/lib/update-command/index.js

@@ -1,5 +1,7 @@
 const { execSync } = require('child_process');
 const https = require('https');
+const fs = require('fs');
+const path = require('path');
 const packageJson = require('../../package.json');
 
 /**
@@ -83,6 +85,18 @@ function updateJettyPod(version = 'latest') {
       stdio: 'inherit'
     });
 
+    // Clear dashboard .next folder to force rebuild with new assets
+    try {
+      const globalRoot = execSync('npm root -g', { encoding: 'utf-8' }).trim();
+      const dashboardNextPath = path.join(globalRoot, 'jettypod', 'apps', 'dashboard', '.next');
+      if (fs.existsSync(dashboardNextPath)) {
+        fs.rmSync(dashboardNextPath, { recursive: true, force: true });
+        console.log('🧹 Cleared dashboard cache');
+      }
+    } catch {
+      // Non-fatal - dashboard will still work, just might use old cache
+    }
+
     return true;
   } catch (err) {
     console.log('');

package/lib/work-commands/index.js

@@ -1726,10 +1726,11 @@ async function mergeWork(options = {}) {
     } else {
       // Chore worktree: mark as done (existing behavior)
       console.log('Marking chore as done...');
+      const completedAt = new Date().toISOString();
       await new Promise((resolve, reject) => {
         db.run(
-          `UPDATE work_items SET status = 'done', completed_at = datetime('now') WHERE id = ?`,
-          [currentWork.id],
+          `UPDATE work_items SET status = 'done', completed_at = ? WHERE id = ?`,
+          [completedAt, currentWork.id],
           (err) => {
             if (err) return reject(err);
             resolve();

package/lib/work-tracking/index.js

@@ -2173,10 +2173,10 @@ async function main() {
             if (isTransition) {
               // When transitioning to implementation, ensure status is 'todo' (ready for work)
               // This prevents status from being left as NULL or in a discovery-related state
-              updateSql = `UPDATE work_items SET phase = 'implementation', mode = 'speed', status = 'todo', scenario_file = ?, prototype_files = ?, discovery_winner = ?, discovery_rationale = ? WHERE id = ?`;
+              updateSql = `UPDATE work_items SET phase = 'implementation', mode = 'speed', status = 'todo', scenario_file = ?, prototype_files = ?, discovery_winner = ?, discovery_rationale = ?, discovery_completed_at = datetime('now') WHERE id = ?`;
               updateParams = [scenarioFileValue, prototypeFilesValue, winnerValue, rationaleValue, featureId];
             } else {
-              updateSql = `UPDATE work_items SET prototype_files = ?, discovery_winner = ?, discovery_rationale = ? WHERE id = ?`;
+              updateSql = `UPDATE work_items SET prototype_files = ?, discovery_winner = ?, discovery_rationale = ?, discovery_completed_at = datetime('now') WHERE id = ?`;
               updateParams = [prototypeFilesValue, winnerValue, rationaleValue, featureId];
             }
 

package/package.json

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

package/skills-templates/feature-planning/SKILL.md

@@ -63,8 +63,49 @@ jettypod workflow start feature-planning <feature-id>
 
 This creates an execution record for session resume.
 
+### Step 1B: Route Simple Improvements
+
+**CRITICAL:** Before proceeding with full feature planning, determine if this is a simple improvement.
+
+**Ask the user:**
+
+```
+Is this:
+1. **Simple improvement** - A basic enhancement to existing functionality (e.g., copy change, styling tweak, minor behavior adjustment)
+2. **New functionality** - Adding new capabilities, even if small
+
+Simple improvements skip the full feature planning workflow and use a lightweight process.
+```
+
+**⚡ WAIT for user response.**
+
+**If user says "simple improvement" (or 1):**
+
+Display:
+```
+This is a simple improvement. Routing to the lightweight simple-improvement workflow...
+```
+
+**Then IMMEDIATELY invoke simple-improvement using the Skill tool:**
+```
+Use the Skill tool with skill: "simple-improvement"
+```
+
+**Feature-planning skill ends here for simple improvements.** The simple-improvement skill takes over.
+
+---
+
+**If user says "new functionality" (or 2):**
+
+Display:
+```
+Got it - this is new functionality. Let's explore the best approach...
+```
+
 **Proceed to Step 2** (or Step 3 if this is a standalone feature with no parent epic).
 
+---
+
 ### Step 2: Check Epic Architectural Decisions
 
 **Skip this step and proceed to Step 3 if `PARENT_EPIC_ID` from Step 1 is null (standalone feature).**