jfl 0.4.4 → 0.6.0

package/template/.github/workflows/jfl-review.yml

@@ -327,6 +327,10 @@ jobs:
             echo "Red findings detected — requesting changes"
             gh pr review ${{ github.event.pull_request.number }} --request-changes \
               --body "JFL AI Review: ${{ steps.findings.outputs.red_count }} blocker(s) found. Address red findings before merge."
+          else
+            echo "No blockers — approving (dismisses any previous CHANGES_REQUESTED)"
+            gh pr review ${{ github.event.pull_request.number }} --approve \
+              --body "JFL AI Review: Clean. No blockers found."
           fi
 
       - name: Post review:findings event to hub

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

@@ -48,17 +48,8 @@ if [ -f ".auto-merge.pid" ]; then
   rm -f ".auto-merge.pid"
 fi
 
-# Stop context-hub if running (already handled by Stop hook, but be defensive)
-if [ -f ".jfl/context-hub.pid" ]; then
-  PID=$(cat ".jfl/context-hub.pid")
-  if kill -0 "$PID" 2>/dev/null; then
-    echo "  Stopping context-hub (PID: $PID)..."
-    kill -TERM "$PID" 2>/dev/null || true
-    sleep 1
-    kill -0 "$PID" 2>/dev/null && kill -9 "$PID" 2>/dev/null || true
-  fi
-  rm -f ".jfl/context-hub.pid"
-fi
+# Context Hub is a persistent daemon — do NOT kill it on session end.
+# It serves multiple sessions and runtimes (Claude Code, Pi, etc).
 
 # Get current session info
 BRANCH=$(git branch --show-current 2>/dev/null || echo "")

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

@@ -0,0 +1,72 @@
+#!/usr/bin/env bash
+#
+# session-end-hub.sh — Session end via Context Hub API
+#
+# Calls POST /api/session/end for journal check + cleanup.
+# Falls back to session-cleanup.sh if hub is unavailable.
+#
+# @purpose Hub-first session cleanup with script fallback
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_DIR="${JFL_REPO_DIR:-$(pwd)}"
+RUNTIME="${1:-claude-code}"
+
+cd "$REPO_DIR" || exit 0
+
+# Read port and token
+PORT=$(jq -r '.contextHub.port // empty' .jfl/config.json 2>/dev/null)
+if [ -z "$PORT" ]; then
+  PORT=$(cat .jfl/context-hub.port 2>/dev/null)
+fi
+if [ -z "$PORT" ]; then
+  PORT="4242"
+fi
+
+TOKEN=$(cat .jfl/context-hub.token 2>/dev/null || echo "")
+AUTH_HEADER=""
+if [ -n "$TOKEN" ]; then
+  AUTH_HEADER="Authorization: Bearer $TOKEN"
+fi
+
+HUB_URL="http://localhost:${PORT}"
+RESULT=""
+
+if curl -sf "$HUB_URL/health" >/dev/null 2>&1; then
+  RESULT=$(curl -sf -X POST "$HUB_URL/api/session/end" \
+    -H "Content-Type: application/json" \
+    ${AUTH_HEADER:+-H "$AUTH_HEADER"} \
+    -d "{\"runtime\":\"$RUNTIME\"}" \
+    --max-time 90 2>/dev/null) || RESULT=""
+fi
+
+if [ -n "$RESULT" ]; then
+  HAS_JOURNAL=$(echo "$RESULT" | jq -r '.hasJournal // false' 2>/dev/null)
+  CLEANUP=$(echo "$RESULT" | jq -r '.cleanupResult // "unknown"' 2>/dev/null)
+
+  if [ "$HAS_JOURNAL" = "true" ]; then
+    echo '✓ Journal exists'
+  else
+    echo '⚠️  No journal entry for session'
+  fi
+
+  if [ "$CLEANUP" = "ok" ]; then
+    echo '✓ Session cleanup complete'
+  else
+    echo "Cleanup: $CLEANUP"
+  fi
+else
+  # Fallback: run cleanup script directly
+  BRANCH=$(cat .jfl/current-session-branch.txt 2>/dev/null || git branch --show-current 2>/dev/null)
+  JOURNAL=".jfl/journal/${BRANCH}.jsonl"
+  if [ ! -s "$JOURNAL" ] 2>/dev/null; then
+    echo '⚠️  No journal entry for session'
+  else
+    echo '✓ Journal exists'
+  fi
+
+  if [ -x "$SCRIPT_DIR/session-cleanup.sh" ]; then
+    "$SCRIPT_DIR/session-cleanup.sh" >> .jfl/logs/session-cleanup.log 2>&1 || echo 'Cleanup skipped'
+  fi
+fi
+
+exit 0

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

@@ -12,6 +12,7 @@ SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 PROJECT_ROOT="$(pwd)"
 LOG_DIR="$PROJECT_ROOT/.jfl/logs"
 SESSION_FILE="$PROJECT_ROOT/.jfl/current-session.json"
+LOCK_SCRIPT="$SCRIPT_DIR/session-lock.sh"
 
 # Colors
 RED='\033[0;31m'
@@ -56,10 +57,32 @@ if [ -f "$SESSION_FILE" ]; then
     fi
 fi
 
+SESSION_ID=""
+if [ -f "$PROJECT_ROOT/.jfl/current-session-branch.txt" ]; then
+    SESSION_ID=$(cat "$PROJECT_ROOT/.jfl/current-session-branch.txt" 2>/dev/null || echo "")
+fi
+
+# Stop heartbeat daemon
+stop_heartbeat() {
+    local pid_file="$1"
+    if [ -f "$pid_file" ]; then
+        local hb_pid
+        hb_pid=$(cat "$pid_file" 2>/dev/null || echo "")
+        if [ -n "$hb_pid" ]; then
+            kill "$hb_pid" 2>/dev/null || true
+        fi
+        rm -f "$pid_file"
+    fi
+}
+
 if $IS_WORKTREE && [ -n "$SESSION_NAME" ] && [ "$SESSION_NAME" != "main" ] && [ "$SESSION_NAME" != "null" ]; then
     echo -e "${BLUE}→${NC} Ending worktree session: $SESSION_NAME"
     echo ""
 
+    # Stop heartbeat
+    stop_heartbeat "$WORKTREE_PATH/.jfl/heartbeat.pid"
+    stop_heartbeat "$PROJECT_ROOT/.jfl/heartbeat.pid"
+
     # 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"
@@ -72,13 +95,22 @@ if $IS_WORKTREE && [ -n "$SESSION_NAME" ] && [ "$SESSION_NAME" != "main" ] && [
         exit 1
     fi
 
+    # Unregister from lock registry
+    if [ -x "$LOCK_SCRIPT" ] && [ -n "$SESSION_ID" ]; then
+        "$LOCK_SCRIPT" unregister "$SESSION_ID" >/dev/null 2>&1 || true
+        echo -e "${GREEN}✓${NC} Session unregistered from lock registry"
+    fi
+
     # Clean up session file
     rm -f "$SESSION_FILE"
 
 else
-    # Main branch session - just commit and push
+    # Main branch session - commit, merge, push
     echo -e "${BLUE}→${NC} Ending main branch session..."
 
+    # Step 0: Stop heartbeat
+    stop_heartbeat "$PROJECT_ROOT/.jfl/heartbeat.pid"
+
     # Step 1: Stop auto-commit
     echo -e "${BLUE}→${NC} Stopping auto-commit..."
     "$SCRIPT_DIR/auto-commit.sh" stop 2>/dev/null || true
@@ -124,13 +156,38 @@ else
         echo -e "${GREEN}✓${NC} No uncommitted changes"
     fi
 
-    # Step 4: Push to remote
-    echo -e "${BLUE}→${NC} Pushing to remote..."
+    # Step 4: Merge session branch to working branch (sequenced)
     CURRENT_BRANCH=$(git rev-parse --abbrev-ref HEAD)
-    if git push origin "$CURRENT_BRANCH" 2>/dev/null; then
-        echo -e "${GREEN}✓${NC} Pushed to origin/$CURRENT_BRANCH"
+    WORKING_BRANCH=$(jq -r '.working_branch // empty' .jfl/config.json 2>/dev/null)
+    if [ -z "$WORKING_BRANCH" ]; then WORKING_BRANCH="main"; fi
+
+    if [ "$CURRENT_BRANCH" != "$WORKING_BRANCH" ] && [[ "$CURRENT_BRANCH" == session-* ]]; then
+        echo -e "${BLUE}→${NC} Merging $CURRENT_BRANCH → $WORKING_BRANCH (sequenced)..."
+
+        if [ -x "$LOCK_SCRIPT" ] && [ -n "$SESSION_ID" ]; then
+            if "$LOCK_SCRIPT" merge "$CURRENT_BRANCH" "$WORKING_BRANCH" "$SESSION_ID" "$PROJECT_ROOT" 2>&1; then
+                echo -e "${GREEN}✓${NC} Merged and pushed via sequencer"
+            else
+                echo -e "${YELLOW}⚠${NC} Sequenced merge failed — pushing branch for manual merge"
+                git push origin "$CURRENT_BRANCH" 2>/dev/null || true
+            fi
+        else
+            # Fallback: direct push
+            echo -e "${BLUE}→${NC} Pushing to remote..."
+            if git push origin "$CURRENT_BRANCH" 2>/dev/null; then
+                echo -e "${GREEN}✓${NC} Pushed to origin/$CURRENT_BRANCH"
+            else
+                echo -e "${YELLOW}⚠${NC} Push failed (will retry on next session)"
+            fi
+        fi
     else
-        echo -e "${YELLOW}⚠${NC} Push failed (will retry on next session)"
+        # Already on working branch — just push
+        echo -e "${BLUE}→${NC} Pushing to remote..."
+        if git push origin "$CURRENT_BRANCH" 2>/dev/null; then
+            echo -e "${GREEN}✓${NC} Pushed to origin/$CURRENT_BRANCH"
+        else
+            echo -e "${YELLOW}⚠${NC} Push failed (will retry on next session)"
+        fi
     fi
 
     # Step 5: Sync product repo if symlink/submodule
@@ -188,6 +245,12 @@ else
     # Clean up session file
     rm -f "$SESSION_FILE"
 
+    # Unregister from lock registry
+    if [ -x "$LOCK_SCRIPT" ] && [ -n "$SESSION_ID" ]; then
+        "$LOCK_SCRIPT" unregister "$SESSION_ID" >/dev/null 2>&1 || true
+        echo -e "${GREEN}✓${NC} Session unregistered from lock registry"
+    fi
+
     echo ""
     echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
     echo -e "  ${GREEN}Session ended successfully!${NC}"

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

@@ -200,9 +200,11 @@ if [[ -d "$WORKTREES_DIR" ]]; then
 fi
 
 # ==============================================================================
-# Step 2.9: Check for concurrent sessions via jfl-services
+# Step 2.9: Check for concurrent sessions via lock registry
 # ==============================================================================
 
+LOCK_SCRIPT="$SCRIPT_DIR/session-lock.sh"
+
 # Generate session details first
 user=$(git config user.name 2>/dev/null | tr ' ' '-' | tr '[:upper:]' '[:lower:]' | tr -cd 'a-z0-9-' || echo "user")
 user="${user:0:30}"
@@ -217,41 +219,41 @@ if [[ -z "$working_branch" ]]; then
     working_branch=$(git branch --show-current)
 fi
 
-# Check for concurrent sessions via jfl-services API
-use_worktree=false
-api_response=""
-if command -v curl >/dev/null 2>&1; then
-    api_response=$(curl -s -X GET "http://localhost:3401/sessions/active?projectPath=$(pwd)" 2>/dev/null || echo "")
-
-    if [[ -n "$api_response" ]] && echo "$api_response" | jq -e '.count' >/dev/null 2>&1; then
-        session_count=$(echo "$api_response" | jq -r '.count // 0')
+# Clean stale sessions first
+if [[ -x "$LOCK_SCRIPT" ]]; then
+    cleaned=$("$LOCK_SCRIPT" clean 2>/dev/null | grep -o '[0-9]*' || echo "0")
+    if [[ "$cleaned" -gt 0 ]]; then
+        echo -e "${YELLOW}→${NC}  Cleaned $cleaned stale session lock(s)"
+    fi
+fi
 
-        if [[ $session_count -gt 0 ]]; then
-            use_worktree=true
-            echo -e "${YELLOW}→${NC}  Multiple sessions detected ($session_count active) - using worktree for isolation"
-        else
-            echo -e "${GREEN}→${NC}  Single session - working directly on branch $working_branch"
-        fi
+# Check for concurrent sessions via lock registry (no external service needed)
+use_worktree=false
+if [[ -x "$LOCK_SCRIPT" ]]; then
+    session_count=$("$LOCK_SCRIPT" count 2>/dev/null || echo "0")
+
+    if [[ $session_count -gt 0 ]]; then
+        use_worktree=true
+        echo -e "${YELLOW}→${NC}  $session_count active session(s) detected — using worktree for isolation"
+        # Show who's active
+        "$LOCK_SCRIPT" active 2>/dev/null | python3 -c "
+import sys, json
+try:
+    sessions = json.load(sys.stdin)
+    for s in sessions:
+        print(f'     • {s[\"id\"]} (branch: {s[\"branch\"]}, pid: {s[\"pid\"]})')
+except: pass
+" 2>/dev/null || true
     else
-        # API unavailable - fall back to local detection
-        echo -e "${YELLOW}→${NC}  jfl-services unavailable - checking locally..."
-        local_sessions=$(ps aux | grep -c "claude.*$(pwd)" 2>/dev/null || echo "1")
-        if [[ $local_sessions -gt 2 ]]; then
-            use_worktree=true
-            echo -e "${YELLOW}→${NC}  Multiple processes detected - using worktree for isolation"
-        fi
+        echo -e "${GREEN}→${NC}  Single session — working directly on branch $working_branch"
     fi
 else
-    # No curl - assume single session
-    echo -e "${GREEN}→${NC}  Working directly on branch $working_branch"
+    echo -e "${YELLOW}→${NC}  session-lock.sh not found — assuming single session"
 fi
 
-# Register this session with jfl-services
-if command -v curl >/dev/null 2>&1; then
-    curl -s -X POST "http://localhost:3401/sessions/start" \
-        -H "Content-Type: application/json" \
-        -d "{\"id\":\"$session_name\",\"projectPath\":\"$(pwd)\",\"branch\":\"$working_branch\",\"user\":\"$user\",\"pid\":$$,\"worktree\":\"$use_worktree\"}" \
-        >/dev/null 2>&1 || true
+# Register this session in the lock registry
+if [[ -x "$LOCK_SCRIPT" ]]; then
+    "$LOCK_SCRIPT" register "$session_name" "$working_branch" >/dev/null 2>&1 || true
 fi
 
 # ==============================================================================
@@ -305,6 +307,20 @@ if [[ "$use_worktree" == "true" ]]; then
         echo "$session_name" > "$REPO_DIR/.jfl/current-session-branch.txt"
         echo "$session_name" > "$worktree_path/.jfl/current-session-branch.txt"
 
+        # Update lock registry with worktree path
+        if [[ -x "$LOCK_SCRIPT" ]]; then
+            "$LOCK_SCRIPT" register "$session_name" "$session_name" "$worktree_path" >/dev/null 2>&1 || true
+        fi
+
+        # Start heartbeat in background (touch lock file every 30s)
+        if [[ -x "$LOCK_SCRIPT" ]]; then
+            (while true; do "$LOCK_SCRIPT" heartbeat "$session_name" >/dev/null 2>&1 || break; sleep 30; done) &
+            HEARTBEAT_PID=$!
+            echo "$HEARTBEAT_PID" > "$worktree_path/.jfl/heartbeat.pid"
+            disown "$HEARTBEAT_PID" 2>/dev/null || true
+            echo -e "${GREEN}✓${NC}  Heartbeat started (PID $HEARTBEAT_PID)"
+        fi
+
         echo ""
         echo -e "${GREEN}✓${NC}  Session ready in worktree: $worktree_path"
         echo ""
@@ -344,6 +360,15 @@ if [[ "$use_worktree" != "true" ]]; then
     echo "direct" > "$REPO_DIR/.jfl/current-worktree.txt"
     echo "$session_name" > "$REPO_DIR/.jfl/current-session-branch.txt"
 
+    # Start heartbeat in background (touch lock file every 30s)
+    if [[ -x "$LOCK_SCRIPT" ]]; then
+        (while true; do "$LOCK_SCRIPT" heartbeat "$session_name" >/dev/null 2>&1 || break; sleep 30; done) &
+        HEARTBEAT_PID=$!
+        echo "$HEARTBEAT_PID" > "$REPO_DIR/.jfl/heartbeat.pid"
+        disown "$HEARTBEAT_PID" 2>/dev/null || true
+        echo -e "${GREEN}✓${NC}  Heartbeat started (PID $HEARTBEAT_PID)"
+    fi
+
     echo ""
     echo -e "${GREEN}✓${NC}  Session ready on branch: $session_name"
     echo ""