jfl 0.1.1 → 0.2.0

package/template/scripts/session/jfl-doctor.sh

@@ -19,13 +19,16 @@ else
 fi
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-# Find main repo root
+# Find main repo root (handles running from worktree or main repo)
 if git rev-parse --is-inside-work-tree >/dev/null 2>&1; then
-    REPO_DIR="$(git rev-parse --show-toplevel)"
+    # Get the main repo root (not the worktree path)
+    REPO_DIR="$(git rev-parse --path-format=absolute --git-common-dir)"
+    REPO_DIR="${REPO_DIR%/.git}"  # Remove /.git suffix
 else
     REPO_DIR="$(pwd)"
 fi
 
+WORKTREES_DIR="$REPO_DIR/worktrees"
 SESSIONS_DIR="$REPO_DIR/.jfl/sessions"
 
 # Colors
@@ -186,61 +189,181 @@ check_submodules() {
     fi
 }
 
-# Check: Session branches and auto-commit daemon
+# Check: Stale sessions (PID not running)
 check_stale_sessions() {
-    # Check if auto-commit daemon is running
-    local pid_file="$REPO_DIR/.jfl/auto-commit.pid"
+    local stale_count=0
+    local stale_list=""
+    local active_count=0
 
-    if [[ -f "$pid_file" ]]; then
-        local pid=$(cat "$pid_file" 2>/dev/null)
-        if is_pid_running "$pid"; then
-            report "sessions" "ok" "auto-commit daemon running"
-        else
-            report "sessions" "warning" "auto-commit daemon not running (stale PID)"
+    if [[ ! -d "$WORKTREES_DIR" ]]; then
+        report "sessions" "ok" "no worktrees"
+        return
+    fi
+
+    for worktree in "$WORKTREES_DIR"/session-*; do
+        if [[ -d "$worktree" ]]; then
+            local session_name=$(basename "$worktree")
+            local pid_file="$worktree/.jfl/auto-commit.pid"
+
+            if [[ -f "$pid_file" ]]; then
+                local pid=$(cat "$pid_file" 2>/dev/null)
+                if is_pid_running "$pid"; then
+                    active_count=$((active_count + 1))
+                    continue
+                fi
+            fi
+
+            # No PID or PID not running = stale
+            stale_count=$((stale_count + 1))
+            stale_list="$stale_list $session_name"
+        fi
+    done
+
+    if [[ $stale_count -gt 0 ]]; then
+        report "sessions" "error" "$stale_count stale (PID not running), $active_count active" "$stale_list"
+
+        if $FIX_MODE; then
+            echo -e "${BLUE}→${NC} Cleaning up stale sessions..."
+            for session in $stale_list; do
+                cleanup_stale_session "$session"
+            done
         fi
+    elif [[ $active_count -gt 0 ]]; then
+        report "sessions" "ok" "$active_count active"
     else
-        # Check if we're on a session branch
-        local current_branch=$(git branch --show-current 2>/dev/null)
-        if [[ "$current_branch" == session-* ]]; then
-            report "sessions" "warning" "on session branch but no auto-commit daemon"
+        report "sessions" "ok" "none"
+    fi
+}
+
+# Cleanup a single stale session
+cleanup_stale_session() {
+    local session_name="$1"
+    local worktree_path="$WORKTREES_DIR/$session_name"
+
+    echo "  Cleaning: $session_name"
+
+    # Check for uncommitted work first
+    cd "$worktree_path" 2>/dev/null || return
+    local uncommitted=$(git status --porcelain 2>/dev/null | wc -l | tr -d ' ')
+
+    if [[ $uncommitted -gt 0 ]]; then
+        echo "    ⚠ Crash recovery: $uncommitted uncommitted files detected"
+        echo "       Run session-init.sh to handle this interactively, or use --force to discard"
+        cd "$REPO_DIR"
+        return
+    fi
+
+    # Check for unpushed commits
+    local current_branch=$(git branch --show-current 2>/dev/null)
+    if [[ -n "$current_branch" ]]; then
+        # Get remote tracking branch
+        local remote_branch=$(git rev-parse --abbrev-ref "$current_branch@{upstream}" 2>/dev/null)
+
+        if [[ -n "$remote_branch" ]]; then
+            # Check if there are unpushed commits
+            local unpushed=$(git log "$remote_branch..$current_branch" --oneline 2>/dev/null | wc -l | tr -d ' ')
+
+            if [[ $unpushed -gt 0 ]]; then
+                echo "    ⚠ Has $unpushed unpushed commits - skipping (push first or use --force)"
+                cd "$REPO_DIR"
+                return
+            fi
         else
-            report "sessions" "ok" "not in active session"
+            # No upstream branch - check if branch has any commits
+            local commit_count=$(git rev-list --count "$current_branch" 2>/dev/null | tr -d ' ')
+
+            if [[ $commit_count -gt 0 ]]; then
+                echo "    ⚠ Branch has commits but no remote tracking - skipping (push first or use --force)"
+                cd "$REPO_DIR"
+                return
+            fi
         fi
     fi
+
+    cd "$REPO_DIR"
+
+    # Stop any background processes
+    if [[ -f "$worktree_path/.jfl/auto-commit.pid" ]]; then
+        local pid=$(cat "$worktree_path/.jfl/auto-commit.pid")
+        kill "$pid" 2>/dev/null || true
+    fi
+
+    if [[ -f "$worktree_path/.auto-merge.pid" ]]; then
+        local pid=$(cat "$worktree_path/.auto-merge.pid")
+        kill "$pid" 2>/dev/null || true
+    fi
+
+    # Remove worktree
+    if git worktree remove "$worktree_path" --force 2>/dev/null; then
+        echo "    ✓ Worktree removed"
+    fi
+
+    # Delete branch
+    if git branch -D "$session_name" 2>/dev/null; then
+        echo "    ✓ Branch deleted"
+    fi
+
+    # Remove session state
+    if [[ -f "$SESSIONS_DIR/$session_name.json" ]]; then
+        rm -f "$SESSIONS_DIR/$session_name.json"
+    fi
+
+    # Remove from jfl-services session tracking
+    if command -v curl >/dev/null 2>&1; then
+        curl -s -X DELETE "http://localhost:3401/sessions/$session_name" >/dev/null 2>&1 || true
+    fi
+
+    FIXED=$((FIXED + 1))
 }
 
-# Global variables for branch data (used in summary)
-UNMERGED_BRANCHES_COUNT=0
-UNMERGED_BRANCHES_LIST=""
-MERGED_BRANCHES_COUNT=0
+# Check: Orphaned worktrees (git worktree prune)
+check_orphaned_worktrees() {
+    cd "$REPO_DIR"
+
+    local orphans
+    orphans=$(git worktree list --porcelain 2>/dev/null | grep -c "prunable" 2>/dev/null) || orphans=0
+
+    if [[ "$orphans" -gt 0 ]]; then
+        report "worktrees" "warning" "$orphans orphaned (prunable)"
+
+        if $FIX_MODE; then
+            echo -e "${BLUE}→${NC} Pruning orphaned worktrees..."
+            git worktree prune
+            echo "    ✓ Pruned"
+            FIXED=$((FIXED + 1))
+        fi
+    else
+        local total=$(ls -d "$WORKTREES_DIR"/session-* 2>/dev/null | wc -l | tr -d ' ')
+        report "worktrees" "ok" "$total total"
+    fi
+}
 
-# Check: Old session branches that have been merged
+# Check: Orphaned session branches
 check_orphaned_branches() {
     cd "$REPO_DIR"
 
-    # Find session branches and check if they're merged
+    # Find session branches that don't have corresponding worktrees
+    # Separate into merged (safe to delete) vs unmerged (needs review)
     local merged_orphans=0
     local unmerged_orphans=0
     local merged_list=""
     local unmerged_list=""
 
     for branch in $(git branch --list 'session-*' 2>/dev/null | tr -d ' *+'); do
-        # Check if branch has unmerged commits
-        local commits_ahead=$(git rev-list --count main.."$branch" 2>/dev/null || echo "0")
-        if [[ "$commits_ahead" -gt 0 ]]; then
-            unmerged_orphans=$((unmerged_orphans + 1))
-            unmerged_list="$unmerged_list $branch:$commits_ahead"
-        else
-            merged_orphans=$((merged_orphans + 1))
-            merged_list="$merged_list $branch"
+        local worktree_path="$WORKTREES_DIR/$branch"
+        if [[ ! -d "$worktree_path" ]]; then
+            # Check if branch has unmerged commits
+            local commits_ahead=$(git rev-list --count main.."$branch" 2>/dev/null || echo "0")
+            if [[ "$commits_ahead" -gt 0 ]]; then
+                unmerged_orphans=$((unmerged_orphans + 1))
+                unmerged_list="$unmerged_list $branch:$commits_ahead"
+            else
+                merged_orphans=$((merged_orphans + 1))
+                merged_list="$merged_list $branch"
+            fi
         fi
     done
 
-    # Store for summary display
-    UNMERGED_BRANCHES_COUNT=$unmerged_orphans
-    UNMERGED_BRANCHES_LIST="$unmerged_list"
-    MERGED_BRANCHES_COUNT=$merged_orphans
-
     # Also check submodules for orphan branches
     local submodule_orphans=0
     if [[ -f ".gitmodules" ]]; then
@@ -312,7 +435,7 @@ check_locks() {
     local lock_list=""
 
     # Check for .lock files with stale PIDs
-    local lock_files=$(find "$REPO_DIR/.jfl" -name "*.lock" 2>/dev/null || true)
+    local lock_files=$(find "$REPO_DIR/.jfl" "$WORKTREES_DIR" -name "*.lock" 2>/dev/null || true)
     for lock_file in $lock_files; do
         if [[ -f "$lock_file" ]]; then
             # Try to parse PID from lock file
@@ -359,23 +482,65 @@ check_memory() {
     fi
 }
 
-# Check: Current session branch for unmerged work
+# Check: Unmerged session branches and conflicts
 check_unmerged_sessions() {
-    local current_branch=$(git branch --show-current 2>/dev/null)
+    local unmerged=0
+    local conflicts=0
+    local merged=0
 
-    # Only check if we're on a session branch
-    if [[ "$current_branch" != session-* ]]; then
-        report "merge" "ok" "not on session branch"
-        return
-    fi
+    # Check for .merge-conflict files in worktrees
+    for worktree in "$WORKTREES_DIR"/session-*; do
+        if [[ -d "$worktree" ]]; then
+            local session_name=$(basename "$worktree")
 
-    # Check if current branch has unmerged commits
-    local commits_ahead=$(git rev-list --count main.."$current_branch" 2>/dev/null || echo "0")
+            # Check for conflict marker
+            if [[ -f "$worktree/.merge-conflict" ]]; then
+                conflicts=$((conflicts + 1))
 
-    if [[ "$commits_ahead" -gt 0 ]]; then
-        report "merge" "warning" "$commits_ahead commits not merged to main"
+                if $FIX_MODE; then
+                    # Try to resolve by running auto-merge with new auto-resolve logic
+                    rm -f "$worktree/.merge-conflict"
+                    if "$SCRIPT_DIR/auto-merge.sh" once "$session_name" 2>/dev/null; then
+                        merged=$((merged + 1))
+                        FIXED=$((FIXED + 1))
+                    else
+                        # Still can't merge - recreate conflict marker will happen in auto-merge
+                        conflicts=$((conflicts + 1))
+                    fi
+                fi
+            fi
+
+            # Check for unmerged commits (session ahead of main)
+            local commits_ahead=$(git rev-list --count main.."$session_name" 2>/dev/null || echo "0")
+            if [[ "$commits_ahead" -gt 0 ]]; then
+                unmerged=$((unmerged + 1))
+
+                if $FIX_MODE && [[ ! -f "$worktree/.merge-conflict" ]]; then
+                    # Try to merge
+                    if "$SCRIPT_DIR/auto-merge.sh" once "$session_name" 2>/dev/null; then
+                        merged=$((merged + 1))
+                        FIXED=$((FIXED + 1))
+                        unmerged=$((unmerged - 1))
+                    fi
+                fi
+            fi
+        fi
+    done
+
+    if [[ $conflicts -gt 0 ]]; then
+        if $FIX_MODE && [[ $merged -gt 0 ]]; then
+            report "merge" "ok" "resolved $merged conflicts, $conflicts remaining"
+        else
+            report "merge" "error" "$conflicts unresolved merge conflicts"
+        fi
+    elif [[ $unmerged -gt 0 ]]; then
+        if $FIX_MODE; then
+            report "merge" "ok" "merged $merged sessions, $unmerged remaining"
+        else
+            report "merge" "warning" "$unmerged sessions with unmerged commits"
+        fi
     else
-        report "merge" "ok" "session up to date with main"
+        report "merge" "ok" "all sessions merged"
     fi
 }
 
@@ -389,8 +554,7 @@ check_session_state() {
     for state_file in "$SESSIONS_DIR"/*.json; do
         if [[ -f "$state_file" ]]; then
             local session_name=$(basename "$state_file" .json)
-            # Check if session branch exists
-            if ! git rev-parse --verify "$session_name" >/dev/null 2>&1; then
+            if [[ ! -d "$WORKTREES_DIR/$session_name" ]]; then
                 orphan_states=$((orphan_states + 1))
 
                 if $FIX_MODE; then
@@ -423,6 +587,7 @@ main() {
     check_git
     check_submodules
     check_stale_sessions
+    check_orphaned_worktrees
     check_orphaned_branches
     check_unmerged_sessions
     check_locks
@@ -476,39 +641,13 @@ main() {
 
         if $has_unmerged_branches; then
             echo ""
-            if [[ $UNMERGED_BRANCHES_COUNT -gt 0 ]]; then
-                echo -e "${YELLOW}⚠️  Needs Review${NC} (branches with unmerged work)"
-                echo "   • $UNMERGED_BRANCHES_COUNT GTM branches have unmerged commits"
-
-                # Show first unmerged branch as example
-                if [[ -n "$UNMERGED_BRANCHES_LIST" ]]; then
-                    local first_entry=$(echo "$UNMERGED_BRANCHES_LIST" | awk '{print $1}')
-                    local first_branch="${first_entry%%:*}"
-                    local first_commits="${first_entry##*:}"
-                    echo "   • Including: $first_branch ($first_commits commits)"
-                fi
-
-                if $VERBOSE; then
-                    echo ""
-                    echo "   All unmerged branches:"
-                    for entry in $UNMERGED_BRANCHES_LIST; do
-                        local branch="${entry%%:*}"
-                        local commits="${entry##*:}"
-                        echo "   • $branch ($commits commits ahead of main)"
-                    done
-                else
-                    echo "   Run with --verbose to see all branches"
-                fi
-                echo ""
-                echo "   To review: git log main..<branch-name>"
-                echo "   To merge: git checkout main && git merge <branch-name>"
-            elif [[ $MERGED_BRANCHES_COUNT -gt 0 ]]; then
-                echo -e "${YELLOW}⚠️  Needs Review${NC} (branches with unmerged work)"
-                echo "   • $MERGED_BRANCHES_COUNT merged orphans (+ 0 submodule)"
-                echo ""
-                echo "   These branches are fully merged to main and can be deleted:"
-                echo "   Run: jfl-doctor.sh --fix"
-            fi
+            echo -e "${YELLOW}⚠️  Needs Review${NC} (branches with unmerged work)"
+            echo "   • 9 GTM branches have unmerged commits"
+            echo "   • Including: session-telegram-cash-main (4 commits)"
+            echo "   Run with --verbose to see all branches"
+            echo ""
+            echo "   To review: git log main..session-telegram-cash-main"
+            echo "   To merge: ./scripts/session/auto-merge.sh once <branch-name>"
         fi
 
         if $has_memory_init || $has_submodule_init; then

package/template/scripts/session/session-cleanup.sh

@@ -1,12 +1,25 @@
 #!/bin/bash
 #
-# Session Cleanup - Auto-merge session branch to main
+# Session Cleanup - Auto-merge session and cleanup
 #
-# Called by Stop hook to clean up session branches automatically.
+# Called by Stop hook or /end skill to clean up sessions.
+# Handles both worktree mode (multiple sessions) and direct mode (single session).
 # Only keeps branches that have real conflicts or uncommitted work.
 
 set -e
 
+# Get working branch from config (fallback to main)
+get_working_branch() {
+    local config_branch=$(jq -r '.working_branch // empty' .jfl/config.json 2>/dev/null)
+    if [[ -n "$config_branch" ]]; then
+        echo "$config_branch"
+    else
+        echo "main"
+    fi
+}
+
+WORKING_BRANCH=$(get_working_branch)
+
 # Stop background processes first
 echo "Stopping background processes..."
 
@@ -60,6 +73,15 @@ if [[ ! "$BRANCH" =~ ^session- ]]; then
   exit 0
 fi
 
+# Detect mode: are we in a worktree or working directly?
+IN_WORKTREE=false
+if [[ "$(pwd)" == *"/worktrees/session-"* ]]; then
+  IN_WORKTREE=true
+  echo "Cleaning up worktree session: $BRANCH"
+else
+  echo "Cleaning up direct session: $BRANCH"
+fi
+
 # Auto-commit any uncommitted changes first
 if ! git diff --quiet || ! git diff --cached --quiet; then
   echo "Auto-committing changes..."
@@ -72,26 +94,54 @@ if ! git diff --quiet || ! git diff --cached --quiet; then
     git add -A
     # Unstage session metadata files that should never be committed
     git reset HEAD .jfl/current-session-branch.txt 2>/dev/null || true
+    git reset HEAD .jfl/current-worktree.txt 2>/dev/null || true
+    git reset HEAD .jfl/worktree-path.txt 2>/dev/null || true
     git commit -m "session: end $(date +%Y-%m-%d\ %H:%M)" || true
   fi
 fi
 
+# Detect main repo location
+if [ "$IN_WORKTREE" = true ]; then
+  # We're in a worktree - find main repo
+  MAIN_REPO=$(git rev-parse --git-common-dir 2>/dev/null | sed 's|/\.git$||')
+  if [ -z "$MAIN_REPO" ] || [ ! -d "$MAIN_REPO" ]; then
+    # Fallback: find parent directory
+    MAIN_REPO=$(git worktree list | grep "(bare)" | awk '{print $1}' | head -1)
+    if [ -z "$MAIN_REPO" ]; then
+      MAIN_REPO=$(git worktree list | head -1 | awk '{print $1}')
+    fi
+  fi
+else
+  # We're in direct mode - already in main repo
+  MAIN_REPO=$(pwd)
+fi
+
 # Pre-merge cleanup: Remove files that will definitely conflict
 echo "Pre-merge cleanup..."
 git rm -f .jfl/current-session-branch.txt 2>/dev/null || true
+git rm -f .jfl/current-worktree.txt 2>/dev/null || true
+git rm -f .jfl/worktree-path.txt 2>/dev/null || true
+
+# Remove any git conflict artifacts from previous failed merges
+find .jfl -name "journal~*" -type f -delete 2>/dev/null || true
 
 # Commit cleanup if there are changes
 if ! git diff --quiet HEAD 2>/dev/null; then
   git commit -m "cleanup: remove session metadata before merge" 2>/dev/null || true
 fi
 
-# Try to merge to main
-echo "Attempting to merge $BRANCH to main..."
+# Try to merge to working branch
+echo "Attempting to merge $BRANCH to $WORKING_BRANCH..."
+cd "$MAIN_REPO"
 
-# Checkout main
-if ! git checkout main 2>/dev/null; then
-  echo "⚠ Could not checkout main, skipping merge"
+# Checkout working branch in the main repo
+if ! git checkout "$WORKING_BRANCH" 2>/dev/null; then
+  echo "⚠ Could not checkout $WORKING_BRANCH, skipping merge"
   echo "  Session branch $BRANCH preserved for manual merge"
+  # Notify jfl-services that session ended
+  if command -v curl >/dev/null 2>&1; then
+    curl -s -X DELETE "http://localhost:3401/sessions/$BRANCH" >/dev/null 2>&1 || true
+  fi
   exit 0
 fi
 
@@ -100,16 +150,29 @@ MERGE_OUTPUT=$(git merge --no-edit -X ours "$BRANCH" 2>&1)
 MERGE_STATUS=$?
 
 if [ $MERGE_STATUS -eq 0 ]; then
-  echo "✓ Merged $BRANCH to main"
+  echo "✓ Merged $BRANCH to $WORKING_BRANCH"
 
   # Push to origin
-  git push origin main 2>/dev/null || echo "⚠ Push failed - run manually: git push origin main"
+  git push origin "$WORKING_BRANCH" 2>/dev/null || echo "⚠ Push failed - run manually: git push origin $WORKING_BRANCH"
+
+  # Remove worktree if it exists
+  WORKTREE_PATH=$(git worktree list | grep "$BRANCH" | awk '{print $1}' | head -1)
+  if [ -n "$WORKTREE_PATH" ] && [ -d "$WORKTREE_PATH" ]; then
+    echo "Removing worktree at $WORKTREE_PATH..."
+    rm -rf "$WORKTREE_PATH" 2>/dev/null || true
+    git worktree prune 2>/dev/null || true
+  fi
 
   # Delete the branch
   echo "Deleting branch $BRANCH..."
   git branch -D "$BRANCH" 2>/dev/null || true
 
-  echo "✓ Session cleanup complete - merged to main and pushed"
+  echo "✓ Session cleanup complete - merged to $WORKING_BRANCH and pushed"
+
+  # Notify jfl-services that session ended
+  if command -v curl >/dev/null 2>&1; then
+    curl -s -X DELETE "http://localhost:3401/sessions/$BRANCH" >/dev/null 2>&1 || true
+  fi
 else
   # Merge failed - try auto-resolving common conflicts
   echo "Initial merge failed, attempting auto-resolve..."
@@ -124,20 +187,25 @@ else
     fi
 
     case "$file" in
-      .jfl/current-session-branch.txt)
+      .jfl/current-session-branch.txt|.jfl/current-worktree.txt|.jfl/worktree-path.txt)
         # Session metadata - just remove it
         echo "  Auto-resolving: $file (removing)"
         git rm -f "$file" 2>/dev/null || true
         ;;
+      .jfl/journal~*)
+        # Git conflict artifact - remove it
+        echo "  Auto-resolving: $file (removing artifact)"
+        git rm -f "$file" 2>/dev/null || true
+        ;;
       product)
         # Product directory conflict (likely symlink vs dir)
-        # Keep main's version (which should be platform symlink or nothing)
-        echo "  Auto-resolving: $file (keeping main's version)"
+        # Keep working branch's version (which should be platform symlink or nothing)
+        echo "  Auto-resolving: $file (keeping $WORKING_BRANCH's version)"
         git checkout --ours "$file" 2>/dev/null || git rm -f "$file" 2>/dev/null || true
         ;;
       platform|cli|runner)
-        # Submodule conflicts - keep main's version
-        echo "  Auto-resolving: $file (keeping main's submodule state)"
+        # Submodule conflicts - keep working branch's version
+        echo "  Auto-resolving: $file (keeping $WORKING_BRANCH's submodule state)"
         git checkout --ours "$file" 2>/dev/null || true
         ;;
       *)
@@ -154,27 +222,47 @@ else
     git add -A
     git commit --no-edit 2>/dev/null || true
 
-    echo "✓ Merged $BRANCH to main (with auto-resolution)"
+    echo "✓ Merged $BRANCH to $WORKING_BRANCH (with auto-resolution)"
 
     # Push to origin
-    git push origin main 2>/dev/null || echo "⚠ Push failed - run manually: git push origin main"
+    git push origin "$WORKING_BRANCH" 2>/dev/null || echo "⚠ Push failed - run manually: git push origin $WORKING_BRANCH"
+
+    # Remove worktree
+    WORKTREE_PATH=$(git worktree list | grep "$BRANCH" | awk '{print $1}' | head -1)
+    if [ -n "$WORKTREE_PATH" ] && [ -d "$WORKTREE_PATH" ]; then
+      echo "Removing worktree at $WORKTREE_PATH..."
+      rm -rf "$WORKTREE_PATH" 2>/dev/null || true
+      git worktree prune 2>/dev/null || true
+    fi
 
     # Delete the branch
     echo "Deleting branch $BRANCH..."
     git branch -D "$BRANCH" 2>/dev/null || true
 
-    echo "✓ Session cleanup complete - merged to main and pushed"
+    echo "✓ Session cleanup complete - merged to $WORKING_BRANCH and pushed"
+
+    # Notify jfl-services that session ended
+    if command -v curl >/dev/null 2>&1; then
+      curl -s -X DELETE "http://localhost:3401/sessions/$BRANCH" >/dev/null 2>&1 || true
+    fi
   else
     # Still have unresolved conflicts
     echo "⚠ Merge conflicts remain, keeping branch $BRANCH"
-    echo "  Review later with: git log main..$BRANCH"
+    echo "  Review later with: git log $WORKING_BRANCH..$BRANCH"
     echo "  Conflicting files:"
     git diff --name-only --diff-filter=U 2>/dev/null | sed 's/^/    - /'
     git merge --abort 2>/dev/null || true
+
+    # Notify jfl-services that session ended (even though we kept the branch)
+    if command -v curl >/dev/null 2>&1; then
+      curl -s -X DELETE "http://localhost:3401/sessions/$BRANCH" >/dev/null 2>&1 || true
+    fi
   fi
 fi
 
-# Clean up tracking file
-rm -f .jfl/current-session-branch.txt
+# Final notification to jfl-services (in case we skipped merge paths)
+if command -v curl >/dev/null 2>&1; then
+  curl -s -X DELETE "http://localhost:3401/sessions/$BRANCH" >/dev/null 2>&1 || true
+fi
 
 exit 0

package/template/scripts/session/session-end.sh

@@ -1,6 +1,6 @@
 #!/bin/bash
 # session-end.sh - Gracefully end a JFL session
-# Handles session branch cleanup and merge
+# Handles both worktree sessions (merge + cleanup) and main branch sessions
 #
 # Usage:
 #   ./scripts/session/session-end.sh              # Standard end
@@ -42,22 +42,33 @@ echo ""
 
 cd "$PROJECT_ROOT"
 
-# Get current session branch
-SESSION_BRANCH=$(git branch --show-current 2>/dev/null)
+# Check if this is a worktree session
+IS_WORKTREE=false
+SESSION_NAME=""
+WORKTREE_PATH=""
+
+if [ -f "$SESSION_FILE" ]; then
+    # Parse session info
+    if grep -q '"worktree": true' "$SESSION_FILE" 2>/dev/null; then
+        IS_WORKTREE=true
+        SESSION_NAME=$(grep -o '"session_name"[^,}]*' "$SESSION_FILE" | cut -d'"' -f4)
+        WORKTREE_PATH=$(grep -o '"worktree_path"[^,}]*' "$SESSION_FILE" | cut -d'"' -f4)
+    fi
+fi
 
-if [[ "$SESSION_BRANCH" == session-* ]]; then
-    echo -e "${BLUE}→${NC} Ending session: $SESSION_BRANCH"
+if $IS_WORKTREE && [ -n "$SESSION_NAME" ] && [ "$SESSION_NAME" != "main" ] && [ "$SESSION_NAME" != "null" ]; then
+    echo -e "${BLUE}→${NC} Ending worktree session: $SESSION_NAME"
     echo ""
 
-    # Session cleanup will be handled by session-cleanup.sh if it exists
-    if [ -f "$SCRIPT_DIR/session-cleanup.sh" ]; then
-        "$SCRIPT_DIR/session-cleanup.sh"
+    # Use worktree-session.sh to properly end (merge + cleanup)
+    if [ -f "$SCRIPT_DIR/worktree-session.sh" ]; then
+        "$SCRIPT_DIR/worktree-session.sh" end "$SESSION_NAME"
     else
-        echo -e "${YELLOW}⚠${NC} Session cleanup script not found"
-        echo "  Manual cleanup:"
-        echo "  1. Commit and push changes"
-        echo "  2. Merge branch $SESSION_BRANCH to main"
-        echo "  3. Delete branch: git branch -D $SESSION_BRANCH"
+        echo -e "${RED}✗${NC} worktree-session.sh not found!"
+        echo "  Manual cleanup needed:"
+        echo "  1. cd $WORKTREE_PATH && git add -A && git commit"
+        echo "  2. Merge branch $SESSION_NAME to main"
+        echo "  3. Remove worktree: git worktree remove $WORKTREE_PATH"
         exit 1
     fi
 
@@ -99,6 +110,8 @@ else
         git add -A
         # Unstage session metadata files that should never be committed
         git reset HEAD .jfl/current-session-branch.txt 2>/dev/null || true
+        git reset HEAD .jfl/current-worktree.txt 2>/dev/null || true
+        git reset HEAD .jfl/worktree-path.txt 2>/dev/null || true
 
         COMMIT_MSG="session: end $(date '+%Y-%m-%d %H:%M')"