Add in_progress tracking for crash recovery

When the agent script ends abruptly, there was no record of which feature
was being worked on. This change adds:

- New `in_progress` boolean column to Feature model
- Schema migration for existing databases (ALTER TABLE)
- feature_get_next() now checks for in-progress features first and returns
  them with "resumed": true flag
- feature_mark_passing() and feature_skip() clear the in_progress flag
- Coding prompt updated to check git status for uncommitted changes and
  handle resumed features appropriately

This allows the agent to resume work on partially-implemented features
after a crash, leveraging any uncommitted changes from the previous session.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: gmccrackin

.claude/templates/coding_prompt.template.md

@@ -14,26 +14,36 @@ pwd
 # 2. List files to understand project structure
 ls -la
 
-# 3. Read the project specification to understand what you're building
+# 3. Check for uncommitted changes from previous session
+git status
+git diff --stat
+
+# 4. Read the project specification to understand what you're building
 cat app_spec.txt
 
-# 4. Read progress notes from previous sessions
+# 5. Read progress notes from previous sessions
 cat claude-progress.txt
 
-# 5. Check recent git history
+# 6. Check recent git history
 git log --oneline -20
 ```
 
 Then use MCP tools to check feature status:
 
 ```
-# 6. Get progress statistics (passing/total counts)
+# 7. Get progress statistics (passing/total counts)
 Use the feature_get_stats tool
 
-# 7. Get the next feature to work on
+# 8. Get the next feature to work on (may resume an in-progress feature)
 Use the feature_get_next tool
 ```
 
+**If feature_get_next returns a feature with `"resumed": true`:**
+- This feature was started in a previous session that crashed or was interrupted
+- Check uncommitted changes (`git status`) - they likely relate to this feature
+- Continue working on this feature, building on any existing progress
+- Do NOT start fresh - leverage the uncommitted changes
+
 Understanding the `app_spec.txt` is critical - it contains the full requirements
 for the application you're building.
 

api/database.py

@@ -28,6 +28,7 @@ class Feature(Base):
     description = Column(Text, nullable=False)
     steps = Column(JSON, nullable=False)  # Stored as JSON array
     passes = Column(Boolean, default=False, index=True)
+    in_progress = Column(Boolean, default=False, index=True)
 
     def to_dict(self) -> dict:
         """Convert feature to dictionary for JSON serialization."""
@@ -39,6 +40,7 @@ def to_dict(self) -> dict:
             "description": self.description,
             "steps": self.steps,
             "passes": self.passes,
+            "in_progress": self.in_progress,
         }
 
 

api/migration.py

@@ -1,8 +1,10 @@
 """
-JSON to SQLite Migration
-========================
+Database Migrations
+===================
 
-Automatically migrates existing feature_list.json files to SQLite database.
+Handles database migrations:
+- JSON to SQLite migration for legacy feature_list.json files
+- Schema migrations for adding new columns
 """
 
 import json
@@ -11,6 +13,7 @@
 from pathlib import Path
 from typing import Optional
 
+from sqlalchemy import text
 from sqlalchemy.orm import sessionmaker, Session
 
 from api.database import Feature
@@ -152,3 +155,46 @@ def export_to_json(
 
     finally:
         session.close()
+
+
+def migrate_add_in_progress_column(
+    project_dir: Path,
+    session_maker: sessionmaker,
+) -> bool:
+    """
+    Add in_progress column to existing databases.
+
+    This migration adds the in_progress boolean column to track which feature
+    is currently being worked on. This allows crash recovery by resuming
+    work on in-progress features.
+
+    Args:
+        project_dir: Directory containing the project
+        session_maker: SQLAlchemy session maker
+
+    Returns:
+        True if migration was performed, False if column already exists
+    """
+    session: Session = session_maker()
+    try:
+        # Check if column already exists using PRAGMA
+        result = session.execute(text("PRAGMA table_info(features)"))
+        columns = [row[1] for row in result.fetchall()]
+
+        if "in_progress" in columns:
+            return False  # Column already exists
+
+        # Add the column with default value of 0 (False)
+        session.execute(
+            text("ALTER TABLE features ADD COLUMN in_progress BOOLEAN DEFAULT 0")
+        )
+        session.commit()
+        print("Added in_progress column to features table")
+        return True
+
+    except Exception as e:
+        session.rollback()
+        print(f"Error adding in_progress column: {e}")
+        return False
+    finally:
+        session.close()

mcp_server/feature_mcp.py

@@ -30,7 +30,7 @@
 sys.path.insert(0, str(Path(__file__).parent.parent))
 
 from api.database import Feature, create_database
-from api.migration import migrate_json_to_sqlite
+from api.migration import migrate_json_to_sqlite, migrate_add_in_progress_column
 
 # Configuration from environment
 PROJECT_DIR = Path(os.environ.get("PROJECT_DIR", ".")).resolve()
@@ -81,8 +81,9 @@ async def server_lifespan(server: FastMCP):
     # Initialize database
     _engine, _session_maker = create_database(PROJECT_DIR)
 
-    # Run migration if needed (converts legacy JSON to SQLite)
-    migrate_json_to_sqlite(PROJECT_DIR, _session_maker)
+    # Run migrations
+    migrate_json_to_sqlite(PROJECT_DIR, _session_maker)  # Legacy JSON to SQLite
+    migrate_add_in_progress_column(PROJECT_DIR, _session_maker)  # Add in_progress column
 
     yield
 
@@ -131,15 +132,34 @@ def feature_get_stats() -> str:
 def feature_get_next() -> str:
     """Get the highest-priority pending feature to work on.
 
-    Returns the feature with the lowest priority number that has passes=false.
-    Use this at the start of each coding session to determine what to implement next.
+    If a feature is already marked as in_progress (from a previous crashed session),
+    returns that feature to allow resuming interrupted work.
+
+    Otherwise, returns the feature with the lowest priority number that has passes=false
+    and marks it as in_progress.
 
     Returns:
-        JSON with feature details (id, priority, category, name, description, steps, passes)
+        JSON with feature details (id, priority, category, name, description, steps, passes, in_progress)
         or error message if all features are passing.
+        If resuming, includes "resumed": true and a message.
     """
     session = get_session()
     try:
+        # First, check for any in-progress feature (resume interrupted work)
+        in_progress_feature = (
+            session.query(Feature)
+            .filter(Feature.in_progress == True)
+            .first()
+        )
+
+        if in_progress_feature:
+            return json.dumps({
+                **in_progress_feature.to_dict(),
+                "resumed": True,
+                "message": "Resuming previously started feature"
+            }, indent=2)
+
+        # Get next pending feature by priority
         feature = (
             session.query(Feature)
             .filter(Feature.passes == False)
@@ -150,6 +170,11 @@ def feature_get_next() -> str:
         if feature is None:
             return json.dumps({"error": "All features are passing! No more work to do."})
 
+        # Mark as in_progress
+        feature.in_progress = True
+        session.commit()
+        session.refresh(feature)
+
         return json.dumps(feature.to_dict(), indent=2)
     finally:
         session.close()
@@ -212,6 +237,7 @@ def feature_mark_passing(
             return json.dumps({"error": f"Feature with ID {feature_id} not found"})
 
         feature.passes = True
+        feature.in_progress = False  # Clear in_progress flag
         session.commit()
         session.refresh(feature)
 
@@ -257,6 +283,7 @@ def feature_skip(
         new_priority = (max_priority_result[0] + 1) if max_priority_result else 1
 
         feature.priority = new_priority
+        feature.in_progress = False  # Clear in_progress flag
         session.commit()
         session.refresh(feature)