autoworkflow 3.9.0 → 3.10.0

package/.claude/.autoworkflow/memories/blockers.md

@@ -1,23 +1,15 @@
-# Blockers Memory
+# Blockers
 
-> Document known issues, workarounds, and gotchas.
-> Saves time by not rediscovering the same problems.
+> Known issues and workarounds. Claude edits directly.
 
 ---
 
-## Template Entry
-
-*Recorded: YYYY-MM-DD HH:MM:SS*
+## Template
+*YYYY-MM-DD*
 
 **Issue:** What is the problem?
-
-**Symptoms:** How does it manifest?
-
-**Root Cause:** Why does this happen? (if known)
-
 **Workaround:** How to work around it?
-
-**Status:** Open / Resolved / Won't Fix
+**Status:** Open / Resolved
 
 ---
 

package/.claude/.autoworkflow/memories/decisions.md

@@ -1,22 +1,14 @@
-# Decisions Memory
+# Decisions
 
-> Document important architectural and implementation decisions here.
-> This helps maintain context across sessions and explains "why" for future reference.
+> Architectural and implementation choices. Claude edits directly.
 
 ---
 
-## Template Entry
-
-*Recorded: YYYY-MM-DD HH:MM:SS*
-
-**Context:** What was the situation or requirement?
-
-**Options Considered:**
-1. Option A - pros/cons
-2. Option B - pros/cons
+## Template
+*YYYY-MM-DD*
 
+**Context:** What was the situation?
 **Decision:** What was chosen and why?
-
 **Implications:** What does this mean going forward?
 
 ---

package/.claude/.autoworkflow/memories/patterns.md

@@ -1,24 +1,15 @@
-# Patterns Memory
+# Patterns
 
-> Document discovered patterns in this codebase.
-> Helps maintain consistency and avoid reinventing solutions.
+> Discovered codebase patterns. Claude edits directly.
 
 ---
 
-## Template Entry
+## Template
+*YYYY-MM-DD*
 
-*Recorded: YYYY-MM-DD HH:MM:SS*
-
-**Pattern Name:** What is this pattern called?
-
-**Where Used:** Which files/components use this?
-
-**How It Works:**
-```
-// Code example or description
-```
-
-**When to Use:** What situations call for this pattern?
+**Pattern:** What is this pattern?
+**Where:** Which files/components use it?
+**Usage:** When and how to use it?
 
 ---
 

package/.claude/hooks/logger.sh

@@ -0,0 +1,318 @@
+#!/bin/bash
+# AutoWorkflow Logger
+# Centralized logging for all hooks, gates, and workflow events
+#
+# Usage:
+#   source logger.sh
+#   aw_log "HOOK" "session-check.sh" "START"
+#   aw_log "GATE" "plan_approval" "PASSED"
+#   aw_log "PHASE" "PLAN" "IMPLEMENT"
+#   aw_log "VERIFY" "1/10" "checking..."
+#   aw_log "ERROR" "pre-commit" "TypeScript errors found"
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# CONFIGURATION
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+# Project directory
+LOGGER_PROJECT_DIR="${CLAUDE_PROJECT_DIR:-.}"
+
+# Log directory and file
+LOG_DIR="$LOGGER_PROJECT_DIR/.claude/.autoworkflow/logs"
+LOG_FILE="$LOG_DIR/aw.log"
+MAX_LOG_SIZE=1048576  # 1MB
+MAX_LOG_FILES=5
+
+# Debug mode (set AUTOWORKFLOW_DEBUG=1 to enable verbose output)
+DEBUG_MODE="${AUTOWORKFLOW_DEBUG:-0}"
+
+# Colors for terminal output (when viewing with tail -f)
+LOG_RED='\033[0;31m'
+LOG_GREEN='\033[0;32m'
+LOG_YELLOW='\033[1;33m'
+LOG_CYAN='\033[0;36m'
+LOG_BLUE='\033[0;34m'
+LOG_MAGENTA='\033[0;35m'
+LOG_BOLD='\033[1m'
+LOG_DIM='\033[2m'
+LOG_NC='\033[0m'
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# INITIALIZATION
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+# Ensure log directory exists
+mkdir -p "$LOG_DIR"
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# LOG ROTATION
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+rotate_logs() {
+    if [ -f "$LOG_FILE" ]; then
+        local size=$(stat -f%z "$LOG_FILE" 2>/dev/null || stat -c%s "$LOG_FILE" 2>/dev/null || echo "0")
+
+        if [ "$size" -gt "$MAX_LOG_SIZE" ]; then
+            # Rotate existing logs
+            for i in $(seq $((MAX_LOG_FILES - 1)) -1 1); do
+                if [ -f "$LOG_FILE.$i" ]; then
+                    mv "$LOG_FILE.$i" "$LOG_FILE.$((i + 1))"
+                fi
+            done
+
+            # Move current log to .1
+            mv "$LOG_FILE" "$LOG_FILE.1"
+
+            # Create new log file with header
+            echo "# AutoWorkflow Log - Rotated $(date '+%Y-%m-%d %H:%M:%S')" > "$LOG_FILE"
+            echo "# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━" >> "$LOG_FILE"
+            echo "" >> "$LOG_FILE"
+
+            # Remove oldest if exceeds max
+            if [ -f "$LOG_FILE.$MAX_LOG_FILES" ]; then
+                rm -f "$LOG_FILE.$MAX_LOG_FILES"
+            fi
+        fi
+    fi
+}
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# LOGGING FUNCTIONS
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+# Get color for category
+get_category_color() {
+    local category="$1"
+    case "$category" in
+        HOOK)    echo "$LOG_CYAN" ;;
+        PHASE)   echo "$LOG_BLUE" ;;
+        GATE)    echo "$LOG_MAGENTA" ;;
+        VERIFY)  echo "$LOG_GREEN" ;;
+        MEMORY)  echo "$LOG_CYAN" ;;
+        COMMIT)  echo "$LOG_GREEN" ;;
+        ERROR)   echo "$LOG_RED" ;;
+        WARN)    echo "$LOG_YELLOW" ;;
+        DEBUG)   echo "$LOG_DIM" ;;
+        *)       echo "$LOG_NC" ;;
+    esac
+}
+
+# Get symbol for status
+get_status_symbol() {
+    local status="$1"
+    case "$status" in
+        START|STARTED)     echo "▶" ;;
+        COMPLETE|DONE)     echo "✓" ;;
+        PASSED|SUCCESS)    echo "✓" ;;
+        FAILED|ERROR)      echo "✗" ;;
+        BLOCKED|DENIED)    echo "⛔" ;;
+        WAITING|PENDING)   echo "◉" ;;
+        SKIPPED)           echo "○" ;;
+        *)                 echo "●" ;;
+    esac
+}
+
+# Main logging function
+# Usage: aw_log <CATEGORY> <SOURCE> <MESSAGE> [DETAILS]
+aw_log() {
+    local category="${1:-INFO}"
+    local source="${2:-unknown}"
+    local message="${3:-}"
+    local details="${4:-}"
+
+    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
+    local time_only=$(date '+%H:%M:%S')
+
+    # Check for log rotation
+    rotate_logs
+
+    # Get color and symbol
+    local color=$(get_category_color "$category")
+    local symbol=$(get_status_symbol "$message")
+
+    # Format the log entry
+    local log_entry="[$time_only] [$category] $source $symbol $message"
+    [ -n "$details" ] && log_entry="$log_entry - $details"
+
+    # Write to log file (plain text, no colors)
+    echo "[$timestamp] [$category] $source $symbol $message${details:+ - $details}" >> "$LOG_FILE"
+
+    # If debug mode, also output to stderr (visible in terminal)
+    if [ "$DEBUG_MODE" = "1" ]; then
+        echo -e "${color}${log_entry}${LOG_NC}" >&2
+    fi
+}
+
+# Convenience functions for common log types
+aw_log_hook() {
+    local hook_name="$1"
+    local status="$2"
+    local details="${3:-}"
+    aw_log "HOOK" "$hook_name" "$status" "$details"
+}
+
+aw_log_phase() {
+    local from="$1"
+    local to="$2"
+    aw_log "PHASE" "$from → $to" "TRANSITION"
+}
+
+aw_log_gate() {
+    local gate_name="$1"
+    local status="$2"
+    local details="${3:-}"
+    aw_log "GATE" "$gate_name" "$status" "$details"
+}
+
+aw_log_verify() {
+    local iteration="$1"
+    local status="$2"
+    local details="${3:-}"
+    aw_log "VERIFY" "iteration $iteration" "$status" "$details"
+}
+
+aw_log_memory() {
+    local action="$1"
+    local file="$2"
+    aw_log "MEMORY" "$action" "$file"
+}
+
+aw_log_commit() {
+    local status="$1"
+    local message="${2:-}"
+    aw_log "COMMIT" "$status" "$message"
+}
+
+aw_log_error() {
+    local source="$1"
+    local message="$2"
+    aw_log "ERROR" "$source" "FAILED" "$message"
+}
+
+aw_log_warn() {
+    local source="$1"
+    local message="$2"
+    aw_log "WARN" "$source" "WARNING" "$message"
+}
+
+aw_log_debug() {
+    if [ "$DEBUG_MODE" = "1" ]; then
+        local source="$1"
+        local message="$2"
+        aw_log "DEBUG" "$source" "DEBUG" "$message"
+    fi
+}
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# LOG VIEWING FUNCTIONS
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+# View logs in real-time (for CLI command)
+view_logs_live() {
+    if [ -f "$LOG_FILE" ]; then
+        echo -e "${LOG_CYAN}━━━ AutoWorkflow Logs (live) ━━━${LOG_NC}"
+        echo -e "${LOG_DIM}Press Ctrl+C to stop${LOG_NC}"
+        echo ""
+        tail -f "$LOG_FILE"
+    else
+        echo "No log file found. Logs will appear after first hook execution."
+    fi
+}
+
+# View recent logs
+view_logs_recent() {
+    local lines="${1:-50}"
+    if [ -f "$LOG_FILE" ]; then
+        echo -e "${LOG_CYAN}━━━ AutoWorkflow Logs (last $lines) ━━━${LOG_NC}"
+        echo ""
+        tail -n "$lines" "$LOG_FILE"
+    else
+        echo "No log file found."
+    fi
+}
+
+# View all logs
+view_logs_all() {
+    if [ -f "$LOG_FILE" ]; then
+        echo -e "${LOG_CYAN}━━━ AutoWorkflow Logs (all) ━━━${LOG_NC}"
+        echo ""
+        cat "$LOG_FILE"
+    else
+        echo "No log file found."
+    fi
+}
+
+# Clear logs
+clear_logs() {
+    rm -f "$LOG_FILE" "$LOG_FILE".*
+    echo -e "${LOG_GREEN}✓${LOG_NC} Logs cleared"
+}
+
+# Show log stats
+show_log_stats() {
+    echo -e "${LOG_CYAN}━━━ Log Statistics ━━━${LOG_NC}"
+    echo ""
+
+    if [ -f "$LOG_FILE" ]; then
+        local size=$(stat -f%z "$LOG_FILE" 2>/dev/null || stat -c%s "$LOG_FILE" 2>/dev/null || echo "0")
+        local lines=$(wc -l < "$LOG_FILE" | tr -d ' ')
+        local hooks=$(grep -c "\[HOOK\]" "$LOG_FILE" 2>/dev/null || echo "0")
+        local phases=$(grep -c "\[PHASE\]" "$LOG_FILE" 2>/dev/null || echo "0")
+        local gates=$(grep -c "\[GATE\]" "$LOG_FILE" 2>/dev/null || echo "0")
+        local errors=$(grep -c "\[ERROR\]" "$LOG_FILE" 2>/dev/null || echo "0")
+
+        echo "  Log file: $LOG_FILE"
+        echo "  Size: $((size / 1024)) KB"
+        echo "  Lines: $lines"
+        echo ""
+        echo "  Events:"
+        echo "    Hooks:  $hooks"
+        echo "    Phases: $phases"
+        echo "    Gates:  $gates"
+        echo "    Errors: $errors"
+    else
+        echo "  No log file found."
+    fi
+    echo ""
+}
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# CLI INTERFACE (when run directly)
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+if [ "${BASH_SOURCE[0]}" = "$0" ]; then
+    case "${1:-}" in
+        live|watch|tail|-f)
+            view_logs_live
+            ;;
+        recent)
+            view_logs_recent "${2:-50}"
+            ;;
+        all|--all|-a)
+            view_logs_all
+            ;;
+        clear|--clear|-c)
+            clear_logs
+            ;;
+        stats|--stats|-s)
+            show_log_stats
+            ;;
+        *)
+            echo "AutoWorkflow Logger"
+            echo ""
+            echo "Usage: logger.sh <command>"
+            echo ""
+            echo "Commands:"
+            echo "  live, watch, tail, -f   View logs in real-time"
+            echo "  recent [n]              Show last n log entries (default: 50)"
+            echo "  all, --all, -a          Show all logs"
+            echo "  clear, --clear, -c      Clear all logs"
+            echo "  stats, --stats, -s      Show log statistics"
+            echo ""
+            echo "Environment:"
+            echo "  AUTOWORKFLOW_DEBUG=1    Enable debug output to terminal"
+            echo ""
+            echo "Log file: $LOG_FILE"
+            ;;
+    esac
+fi

package/.claude/hooks/phase-transition.sh

@@ -17,6 +17,10 @@ NC='\033[0m'
 # Project directory (use env var if set, otherwise current directory)
 PROJECT_DIR="${CLAUDE_PROJECT_DIR:-.}"
 
+# Source the logger
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/logger.sh" 2>/dev/null || true
+
 # State directory
 STATE_DIR="$PROJECT_DIR/.claude/.autoworkflow"
 mkdir -p "$STATE_DIR"
@@ -112,11 +116,13 @@ check_analyze_gate() {
 check_plan_approval_gate() {
     echo ""
     echo "Checking plan_approval_gate..."
+    aw_log_gate "plan_approval" "CHECKING"
 
     if [ -f "$APPROVAL_FILE" ]; then
         local approval=$(cat "$APPROVAL_FILE")
         if [ "$approval" = "approved" ]; then
             echo -e "  ${GREEN}✅${NC} Plan has been approved"
+            aw_log_gate "plan_approval" "PASSED"
             return 0
         fi
     fi
@@ -127,6 +133,7 @@ check_plan_approval_gate() {
     echo ""
     echo "Wait for user to say 'yes', 'proceed', 'approved', etc."
     echo ""
+    aw_log_gate "plan_approval" "BLOCKED" "awaiting user approval"
     return 1
 }
 
@@ -134,11 +141,13 @@ check_plan_approval_gate() {
 check_verify_gate() {
     echo ""
     echo "Checking verify_gate..."
+    aw_log_gate "verify" "CHECKING"
 
     if [ -f "$STATE_DIR/verify-status" ]; then
         local status=$(cat "$STATE_DIR/verify-status")
         if [ "$status" = "PASSED" ]; then
             echo -e "  ${GREEN}✅${NC} Verification passed"
+            aw_log_gate "verify" "PASSED"
             return 0
         fi
     fi
@@ -147,6 +156,7 @@ check_verify_gate() {
     echo ""
     echo -e "${YELLOW}BLOCKED:${NC} Run npm run verify and fix all errors first."
     echo ""
+    aw_log_gate "verify" "BLOCKED" "verification not passed"
     return 1
 }
 
@@ -190,6 +200,8 @@ transition() {
     local from="$1"
     local to="$2"
 
+    aw_log_phase "$from" "$to"
+
     echo ""
     echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
     echo -e "${BOLD}AUTOWORKFLOW: PHASE TRANSITION${NC}"
@@ -244,6 +256,9 @@ transition() {
     # Output reflection prompt for the new phase
     output_reflection_prompt "$to"
 
+    # Prompt to update memories based on completed phase
+    prompt_memory_update "$from"
+
     echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
     echo ""
 
@@ -287,127 +302,119 @@ reset_workflow() {
 }
 
 # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-# MEMORY SYSTEM (Serena-inspired)
-# Persistent context that survives across sessions
+# MEMORY SYSTEM v2 (Serena-inspired)
+# Claude edits files directly + hooks prompt at key moments
 # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
 MEMORY_DIR="$STATE_DIR/memories"
 mkdir -p "$MEMORY_DIR"
 
-# Save a memory (key-value with optional category)
-save_memory() {
-    local category="$1"
-    local key="$2"
-    local value="$3"
-    local timestamp=$(date +"%Y-%m-%d %H:%M:%S")
-
-    local memory_file="$MEMORY_DIR/${category}.md"
-
-    # Create file with header if it doesn't exist
-    if [ ! -f "$memory_file" ]; then
-        cat > "$memory_file" << EOF
-# ${category^} Memory
-
-> Auto-generated memory store. Add entries as you work.
-
----
-
-EOF
-    fi
-
-    # Append new memory entry
-    cat >> "$memory_file" << EOF
-## $key
-*Recorded: $timestamp*
-
-$value
-
----
-
-EOF
-
-    echo -e "${GREEN}✅${NC} Memory saved: $category/$key"
-}
+# Prompt Claude to update memories (called at phase transitions)
+prompt_memory_update() {
+    local phase="$1"
+    local memory_type=""
+    local prompt_text=""
 
-# Read memories for a category
-read_memories() {
-    local category="$1"
-    local memory_file="$MEMORY_DIR/${category}.md"
+    case "$phase" in
+        PLAN|CONFIRM)
+            memory_type="decisions"
+            prompt_text="If you made any architectural or implementation decisions, update .claude/.autoworkflow/memories/decisions.md"
+            ;;
+        IMPLEMENT|VERIFY)
+            memory_type="patterns"
+            prompt_text="If you discovered any codebase patterns, update .claude/.autoworkflow/memories/patterns.md"
+            ;;
+        COMMIT)
+            memory_type="context"
+            prompt_text="Update .claude/.autoworkflow/memories/context.md with session summary for continuity"
+            ;;
+    esac
 
-    if [ -f "$memory_file" ]; then
-        cat "$memory_file"
-    else
-        echo "No memories found for category: $category"
+    if [ -n "$memory_type" ]; then
+        echo ""
+        echo -e "${CYAN}━━━ MEMORY UPDATE ━━━${NC}"
+        echo -e "${DIM}$prompt_text${NC}"
+        echo ""
+        echo -e "${DIM}Format: Add a new ## Section with date and details${NC}"
+        echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━${NC}"
+        echo ""
     fi
 }
 
-# List all memory categories
-list_memories() {
+# Prompt to record a blocker (called when errors occur)
+prompt_blocker_update() {
+    local error_context="$1"
     echo ""
-    echo -e "${CYAN}Available Memory Categories:${NC}"
+    echo -e "${YELLOW}━━━ BLOCKER DETECTED ━━━${NC}"
+    echo -e "${DIM}Consider recording this in .claude/.autoworkflow/memories/blockers.md${NC}"
     echo ""
-
-    if [ -d "$MEMORY_DIR" ]; then
-        for file in "$MEMORY_DIR"/*.md; do
-            if [ -f "$file" ]; then
-                local category=$(basename "$file" .md)
-                local count=$(grep -c "^## " "$file" 2>/dev/null || echo "0")
-                echo "  - $category ($count entries)"
-            fi
-        done
-    else
-        echo "  No memories stored yet."
-    fi
+    echo -e "${DIM}Include: Issue, Symptoms, Workaround, Status${NC}"
+    echo -e "${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
     echo ""
 }
 
-# Save context for session continuity
-save_context() {
-    local task_description="$1"
-    local current_phase=$(get_phase)
-    local task_type=$(get_task_type)
-    local timestamp=$(date +"%Y-%m-%d %H:%M:%S")
-
-    local context_file="$MEMORY_DIR/context.md"
-
-    cat > "$context_file" << EOF
-# Session Context
-
-> Last updated: $timestamp
-
-## Current State
-- **Phase:** $current_phase
-- **Task Type:** $task_type
-- **Description:** $task_description
-
-## What Was Done
-<!-- Claude should update this section as work progresses -->
+# Load and display memories at session start
+load_memories_summary() {
+    echo ""
+    echo -e "${CYAN}━━━ PROJECT MEMORIES ━━━${NC}"
 
-## What Remains
-<!-- Claude should update this section -->
+    local has_memories=false
 
-## Key Decisions Made
-<!-- Document important choices and their rationale -->
+    # Check decisions
+    if [ -f "$MEMORY_DIR/decisions.md" ]; then
+        local decision_count=$(grep -c "^## " "$MEMORY_DIR/decisions.md" 2>/dev/null || echo "0")
+        if [ "$decision_count" -gt 1 ]; then  # More than template
+            echo -e "  ${GREEN}●${NC} Decisions: $((decision_count - 1)) recorded"
+            has_memories=true
+        fi
+    fi
 
-## Files Modified
-$(cat "$STATE_DIR/changed-files" 2>/dev/null || echo "None yet")
+    # Check patterns
+    if [ -f "$MEMORY_DIR/patterns.md" ]; then
+        local pattern_count=$(grep -c "^## " "$MEMORY_DIR/patterns.md" 2>/dev/null || echo "0")
+        if [ "$pattern_count" -gt 1 ]; then
+            echo -e "  ${GREEN}●${NC} Patterns: $((pattern_count - 1)) recorded"
+            has_memories=true
+        fi
+    fi
 
----
+    # Check blockers
+    if [ -f "$MEMORY_DIR/blockers.md" ]; then
+        local blocker_count=$(grep -c "^## " "$MEMORY_DIR/blockers.md" 2>/dev/null || echo "0")
+        if [ "$blocker_count" -gt 1 ]; then
+            echo -e "  ${YELLOW}●${NC} Blockers: $((blocker_count - 1)) recorded"
+            has_memories=true
+        fi
+    fi
 
-*Use this context to resume work in a new session.*
-EOF
+    if [ "$has_memories" = false ]; then
+        echo -e "  ${DIM}No memories recorded yet${NC}"
+    fi
 
-    echo -e "${GREEN}✅${NC} Context saved for session continuity"
+    echo ""
+    echo -e "${DIM}Read with: Read tool on .claude/.autoworkflow/memories/*.md${NC}"
+    echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+    echo ""
 }
 
-# Load context summary
+# Load context summary (for session resume)
 load_context() {
     local context_file="$MEMORY_DIR/context.md"
 
     if [ -f "$context_file" ]; then
         echo ""
         echo -e "${CYAN}━━━ PREVIOUS SESSION CONTEXT ━━━${NC}"
-        cat "$context_file"
+        # Show just the key sections
+        if grep -q "## What Was Done" "$context_file"; then
+            echo -e "${BOLD}What Was Done:${NC}"
+            sed -n '/## What Was Done/,/## /p' "$context_file" | head -8 | tail -n +2
+        fi
+        if grep -q "## What Remains" "$context_file"; then
+            echo -e "${BOLD}What Remains:${NC}"
+            sed -n '/## What Remains/,/## /p' "$context_file" | head -8 | tail -n +2
+        fi
+        echo ""
+        echo -e "${DIM}Full context: .claude/.autoworkflow/memories/context.md${NC}"
         echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
         echo ""
     fi
@@ -442,22 +449,16 @@ case "$1" in
         fi
         echo ""
         ;;
-    # Memory commands (Serena-inspired)
-    memory-save)
-        save_memory "$2" "$3" "$4"
-        ;;
-    memory-read)
-        read_memories "$2"
-        ;;
-    memory-list)
-        list_memories
+    # Memory commands v2 (Claude edits files directly)
+    memories)
+        load_memories_summary
         ;;
-    context-save)
-        save_context "$2"
-        ;;
-    context-load)
+    context)
         load_context
         ;;
+    blocker)
+        prompt_blocker_update "$2"
+        ;;
     reflect)
         output_reflection_prompt "$2"
         ;;
@@ -471,12 +472,16 @@ case "$1" in
         echo "  reset                   - Reset workflow state"
         echo "  status                  - Show current state"
         echo ""
-        echo "Memory Commands (Serena-inspired):"
-        echo "  memory-save <category> <key> <value>  - Save a memory"
-        echo "  memory-read <category>                - Read memories"
-        echo "  memory-list                           - List all categories"
-        echo "  context-save <description>            - Save session context"
-        echo "  context-load                          - Load previous context"
-        echo "  reflect <phase>                       - Show reflection prompts"
+        echo "Memory Commands (Claude edits files directly):"
+        echo "  memories                - Show memory summary"
+        echo "  context                 - Load previous session context"
+        echo "  blocker                 - Prompt to record a blocker"
+        echo "  reflect <phase>         - Show reflection prompts"
+        echo ""
+        echo "Memory Files (edit directly with Claude):"
+        echo "  .claude/.autoworkflow/memories/decisions.md"
+        echo "  .claude/.autoworkflow/memories/patterns.md"
+        echo "  .claude/.autoworkflow/memories/blockers.md"
+        echo "  .claude/.autoworkflow/memories/context.md"
         ;;
 esac

package/.claude/hooks/post-edit.sh

@@ -20,6 +20,10 @@ NC='\033[0m'
 # Project directory (use env var if set, otherwise current directory)
 PROJECT_DIR="${CLAUDE_PROJECT_DIR:-.}"
 
+# Source the logger
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/logger.sh" 2>/dev/null || true
+
 # State directory
 STATE_DIR="$PROJECT_DIR/.claude/.autoworkflow"
 mkdir -p "$STATE_DIR"
@@ -311,6 +315,8 @@ run_verify() {
 
 # Main execution
 main() {
+    aw_log_hook "post-edit.sh" "START"
+
     local current_phase=$(get_phase)
 
     # Track that we're in VERIFY phase
@@ -318,6 +324,7 @@ main() {
 
     # Get current iteration and increment
     local iteration=$(increment_iteration)
+    aw_log_verify "$iteration/$MAX_ITERATIONS" "STARTED"
 
     # Check if we've exceeded max iterations
     if [ "$iteration" -gt "$MAX_ITERATIONS" ]; then
@@ -334,6 +341,7 @@ main() {
         echo "  2. Reset counter: rm $VERIFY_ITERATION_FILE"
         echo ""
         echo "BLOCKED" > "$VERIFY_STATUS_FILE"
+        aw_log_verify "$iteration/$MAX_ITERATIONS" "BLOCKED" "max iterations reached"
         # Don't exit with error - let Claude continue but report the issue
         exit 0
     fi
@@ -356,6 +364,7 @@ main() {
 
         # Update status
         echo "PASSED" > "$VERIFY_STATUS_FILE"
+        aw_log_verify "$iteration/$MAX_ITERATIONS" "PASSED" "0 errors"
 
         # Check if this was a feature/refactor that needs audit
         local task_type=""
@@ -386,6 +395,7 @@ main() {
         # Update status
         echo "FAILED" > "$VERIFY_STATUS_FILE"
         echo "$iteration" > "$VERIFY_ITERATION_FILE"
+        aw_log_verify "$iteration/$MAX_ITERATIONS" "FAILED" "errors found"
 
         echo "Fix the errors above and save the file."
         echo "Verification will re-run automatically."
@@ -396,6 +406,8 @@ main() {
         # Enter FIX phase
         set_phase "FIX"
     fi
+
+    aw_log_hook "post-edit.sh" "COMPLETE"
 }
 
 main

package/.claude/hooks/pre-commit-check.sh

@@ -19,6 +19,10 @@ NC='\033[0m'
 # Project directory (use env var if set, otherwise current directory)
 PROJECT_DIR="${CLAUDE_PROJECT_DIR:-.}"
 
+# Source the logger
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/logger.sh" 2>/dev/null || true
+
 # State directory
 STATE_DIR="$PROJECT_DIR/.claude/.autoworkflow"
 mkdir -p "$STATE_DIR"
@@ -191,6 +195,8 @@ check_commit_message() {
 
 # Main execution
 main() {
+    aw_log_gate "pre_commit" "CHECKING" "7 checks"
+
     print_header
 
     echo "Checking requirements..."
@@ -219,6 +225,8 @@ main() {
         echo "BLOCKED" > "$STATE_DIR/gate-status"
         echo "$ERRORS" > "$STATE_DIR/gate-errors"
 
+        aw_log_gate "pre_commit" "BLOCKED" "$ERRORS errors"
+
         # EXIT WITH ERROR TO BLOCK THE COMMIT
         exit 1
     else
@@ -231,6 +239,8 @@ main() {
         echo "PASSED" > "$STATE_DIR/gate-status"
         echo "0" > "$STATE_DIR/gate-errors"
 
+        aw_log_gate "pre_commit" "PASSED" "7/7 checks"
+
         exit 0
     fi
 }

package/.claude/hooks/session-check.sh

@@ -21,6 +21,10 @@ NC='\033[0m'
 # Project directory (use env var if set, otherwise current directory)
 PROJECT_DIR="${CLAUDE_PROJECT_DIR:-.}"
 
+# Source the logger
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/logger.sh" 2>/dev/null || true
+
 # State directory
 STATE_DIR="$PROJECT_DIR/.claude/.autoworkflow"
 mkdir -p "$STATE_DIR"
@@ -462,13 +466,57 @@ reset_turn_state() {
     echo "0" > "$CURRENT_TURN_EDITS_FILE"
 }
 
+# Load and display memories summary (for context awareness)
+show_memories_summary() {
+    local has_memories=false
+
+    # Check if any memories exist (beyond templates)
+    for file in "$MEMORY_DIR/decisions.md" "$MEMORY_DIR/patterns.md" "$MEMORY_DIR/blockers.md"; do
+        if [ -f "$file" ]; then
+            local count=$(grep -c "^## " "$file" 2>/dev/null || echo "0")
+            if [ "$count" -gt 1 ]; then
+                has_memories=true
+                break
+            fi
+        fi
+    done
+
+    if [ "$has_memories" = true ]; then
+        echo ""
+        echo -e "${CYAN}━━━ PROJECT MEMORIES ━━━${NC}"
+
+        if [ -f "$MEMORY_DIR/decisions.md" ]; then
+            local count=$(grep -c "^## " "$MEMORY_DIR/decisions.md" 2>/dev/null || echo "0")
+            [ "$count" -gt 1 ] && echo -e "  ${GREEN}●${NC} Decisions: $((count - 1)) recorded"
+        fi
+
+        if [ -f "$MEMORY_DIR/patterns.md" ]; then
+            local count=$(grep -c "^## " "$MEMORY_DIR/patterns.md" 2>/dev/null || echo "0")
+            [ "$count" -gt 1 ] && echo -e "  ${GREEN}●${NC} Patterns: $((count - 1)) recorded"
+        fi
+
+        if [ -f "$MEMORY_DIR/blockers.md" ]; then
+            local count=$(grep -c "^## " "$MEMORY_DIR/blockers.md" 2>/dev/null || echo "0")
+            [ "$count" -gt 1 ] && echo -e "  ${YELLOW}●${NC} Blockers: $((count - 1)) recorded"
+        fi
+
+        echo ""
+        echo -e "${DIM}Read: .claude/.autoworkflow/memories/*.md${NC}"
+        echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+        echo ""
+    fi
+}
+
 # Main execution
 main() {
+    aw_log_hook "session-check.sh" "START"
+
     local is_new_session=false
 
     # Initialize session
     if init_session; then
         is_new_session=true
+        aw_log "HOOK" "session-check.sh" "NEW_SESSION"
     fi
 
     # Reset turn state on each user message
@@ -476,6 +524,7 @@ main() {
 
     # Check if init is needed (package installed but not set up)
     if check_init_needed; then
+        aw_log "HOOK" "session-check.sh" "INIT_NEEDED"
         exit 0
     fi
 
@@ -485,10 +534,17 @@ main() {
     fi
 
     # Check for missing blueprint (prompts user for documentation)
-    check_blueprint
+    if ! check_blueprint; then
+        aw_log "HOOK" "session-check.sh" "DOCS_REQUIRED"
+    fi
+
+    # Show memories summary (if any exist)
+    show_memories_summary
 
     # Show current state if not idle
     show_state
+
+    aw_log_hook "session-check.sh" "COMPLETE"
 }
 
 main

package/.claude/settings.json

@@ -144,7 +144,16 @@
     "- phase: Current phase (ANALYZE, PLAN, etc.)",
     "- task-type: Classified task type",
     "- verify-iteration: Current verify loop count",
-    "- gate-status: Last gate check result"
+    "- gate-status: Last gate check result",
+    "",
+    "### Memory System (Persistent Context)",
+    "Edit these files directly using the Edit tool:",
+    "- `.claude/.autoworkflow/memories/decisions.md` - After PLAN: record architectural choices",
+    "- `.claude/.autoworkflow/memories/patterns.md` - After IMPLEMENT: record discovered patterns",
+    "- `.claude/.autoworkflow/memories/blockers.md` - When errors: record issues and workarounds",
+    "- `.claude/.autoworkflow/memories/context.md` - Before COMMIT: update session summary",
+    "",
+    "Format: ## Title, *Date*, Content, ---"
   ],
 
   "workflow": {

package/CLAUDE.md

@@ -124,35 +124,77 @@ All state stored in `.claude/.autoworkflow/`:
 
 ---
 
-## Memory System (Serena-inspired)
+## Logging System
 
-Persistent context that survives across sessions. Stored in `.claude/.autoworkflow/memories/`.
+Real-time visibility into hook execution, gates, and workflow events.
 
-| File | Purpose |
-|------|---------|
-| `decisions.md` | Document architectural/implementation choices |
-| `patterns.md` | Record discovered codebase patterns |
-| `blockers.md` | Track known issues and workarounds |
-| `context.md` | Session continuity (auto-generated) |
+**Log Location:** `.claude/.autoworkflow/logs/aw.log`
 
-**Memory Commands:**
+**CLI Commands:**
 ```bash
-# Save a decision
-.claude/hooks/phase-transition.sh memory-save decisions "auth-approach" "Chose JWT over sessions for stateless API"
+npx autoworkflow logs          # Watch logs in real-time
+npx autoworkflow logs --recent # Show last 50 entries
+npx autoworkflow logs --all    # Show all logs
+npx autoworkflow logs --clear  # Clear logs
+npx autoworkflow logs --stats  # Show statistics
+```
+
+**Or use tail directly:**
+```bash
+tail -f .claude/.autoworkflow/logs/aw.log
+```
+
+**Log Categories:**
+| Category | Events |
+|----------|--------|
+| HOOK | Hook start/complete |
+| PHASE | Phase transitions |
+| GATE | Gate checks (pass/block) |
+| VERIFY | Verification iterations |
+| MEMORY | Memory update prompts |
+| COMMIT | Commit events |
+| ERROR | Errors and failures |
+
+**Debug Mode:** Set `AUTOWORKFLOW_DEBUG=1` to see logs in terminal.
 
-# Read memories
-.claude/hooks/phase-transition.sh memory-read decisions
+---
+
+## Memory System (Serena-inspired)
 
-# List all categories
-.claude/hooks/phase-transition.sh memory-list
+Persistent context that survives across sessions. **Claude edits files directly** + hooks prompt at key moments.
 
-# Save context for next session
-.claude/hooks/phase-transition.sh context-save "Implementing user auth"
+**Memory Files:** `.claude/.autoworkflow/memories/`
+| File | Purpose | When to Update |
+|------|---------|----------------|
+| `decisions.md` | Architectural/implementation choices | After PLAN phase |
+| `patterns.md` | Discovered codebase patterns | After IMPLEMENT |
+| `blockers.md` | Known issues and workarounds | When hitting errors |
+| `context.md` | Session continuity | Before COMMIT |
+
+**How it works:**
+1. **Session Start** → Memories summary displayed automatically
+2. **Phase Transitions** → Hooks prompt to update relevant memory
+3. **Claude Edits Directly** → Use Edit tool on memory files
+4. **No Shell Commands** → Just read and edit the markdown files
 
-# Load previous context
-.claude/hooks/phase-transition.sh context-load
+**Memory Format:**
+```markdown
+## [Entry Title]
+*[Date]*
+
+[Content - decisions made, patterns found, blockers hit]
+
+---
 ```
 
+**Automated Prompts:**
+| Trigger | Memory Prompt |
+|---------|---------------|
+| After PLAN | "Record any decisions made" |
+| After IMPLEMENT | "Record any patterns discovered" |
+| Before COMMIT | "Update context for next session" |
+| Error encountered | "Consider recording this blocker" |
+
 ---
 
 ## Reflection Prompts (Serena-inspired)
@@ -239,6 +281,7 @@ npm run format        # Prettier
 | `phase-transition.sh` | Manual call | State management |
 | `audit-runner.sh` | Manual call | Run UI + cycle audits |
 | `blueprint-generator.sh` | Manual call | Enhanced project discovery (8 scans) |
+| `logger.sh` | Sourced by hooks | Centralized logging system |
 
 ---
 

package/bin/cli.js

@@ -72,6 +72,12 @@ Commands:
   ${colors.cyan('update')}            Smart update - core files only, preserve user files
   ${colors.cyan('status')}            Show installed version and what would change
 
+  ${colors.cyan('logs')}              View AutoWorkflow logs (real-time)
+  ${colors.cyan('logs --recent')}     Show last 50 log entries
+  ${colors.cyan('logs --all')}        Show all logs
+  ${colors.cyan('logs --clear')}      Clear all logs
+  ${colors.cyan('logs --stats')}      Show log statistics
+
   ${colors.cyan('help')}              Show this help message
 
 Options:
@@ -82,7 +88,7 @@ Examples:
   npx autoworkflow init          # Fresh install
   npx autoworkflow update        # Update core files only
   npx autoworkflow status        # Check what would change
-  npx autoworkflow init --force  # Full reinstall
+  npx autoworkflow logs          # Watch logs in real-time
 `);
 }
 
@@ -453,6 +459,62 @@ function init(options = {}) {
   console.log(`${colors.dim('Optional: Edit instructions/AI_RULES.md to customize coding standards')}\n`);
 }
 
+// Logs command
+import { spawn } from 'child_process';
+
+function logs() {
+  const cwd = process.cwd();
+  const loggerScript = join(cwd, '.claude', 'hooks', 'logger.sh');
+
+  // Check if logger exists
+  if (!existsSync(loggerScript)) {
+    console.log(`${colors.yellow('⚠')} AutoWorkflow not initialized in this directory.`);
+    console.log(`  Run: npx autoworkflow init`);
+    process.exit(1);
+  }
+
+  // Determine subcommand
+  const subCommand = args[1] || 'live';
+
+  let loggerArg;
+  switch (subCommand) {
+    case '--recent':
+    case '-r':
+      loggerArg = 'recent';
+      break;
+    case '--all':
+    case '-a':
+      loggerArg = 'all';
+      break;
+    case '--clear':
+    case '-c':
+      loggerArg = 'clear';
+      break;
+    case '--stats':
+    case '-s':
+      loggerArg = 'stats';
+      break;
+    default:
+      loggerArg = 'live';
+  }
+
+  // Run the logger script
+  const child = spawn('bash', [loggerScript, loggerArg], {
+    cwd: cwd,
+    stdio: 'inherit',
+    env: { ...process.env, CLAUDE_PROJECT_DIR: cwd }
+  });
+
+  child.on('error', (err) => {
+    console.error(`${colors.red('Error:')} ${err.message}`);
+    process.exit(1);
+  });
+
+  child.on('exit', (code) => {
+    process.exit(code || 0);
+  });
+}
+
 // Main
 switch (command) {
   case 'init':
@@ -464,6 +526,10 @@ switch (command) {
   case 'status':
     status();
     break;
+  case 'logs':
+  case 'log':
+    logs();
+    break;
   case 'help':
   case '--help':
   case '-h':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autoworkflow",
-  "version": "3.9.0",
+  "version": "3.10.0",
   "description": "Automated workflow enforcement for Claude Code via hooks and system prompts",
   "type": "module",
   "bin": {