loki-mode 6.31.0 → 6.32.1

package/README.md

@@ -10,7 +10,7 @@
 [![Autonomi](https://img.shields.io/badge/Autonomi-autonomi.dev-5B4EEA)](https://www.autonomi.dev/)
 [![Docker Pulls](https://img.shields.io/docker/pulls/asklokesh/loki-mode)](https://hub.docker.com/r/asklokesh/loki-mode)
 
-**Current Version: v6.31.0**
+**Current Version: v6.32.0**
 
 ### Traction
 

package/SKILL.md

@@ -3,7 +3,7 @@ name: loki-mode
 description: Multi-agent autonomous startup system. Triggers on "Loki Mode". Takes PRD to deployed product with minimal human intervention. Requires --dangerously-skip-permissions flag.
 ---
 
-# Loki Mode v6.31.0
+# Loki Mode v6.32.1
 
 **You are an autonomous agent. You make decisions. You do not ask questions. You do not stop.**
 
@@ -267,4 +267,4 @@ The following features are documented in skill modules but not yet fully automat
 | Quality gates 3-reviewer system | Implemented (v5.35.0) | 5 specialist reviewers in `skills/quality-gates.md`; execution in run.sh |
 | Benchmarks (HumanEval, SWE-bench) | Infrastructure only | Runner scripts and datasets exist in `benchmarks/`; no published results |
 
-**v6.31.0 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**
+**v6.32.1 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**

package/VERSION

@@ -1 +1 @@
-6.31.0
+6.32.1

package/autonomy/loki

@@ -394,7 +394,7 @@ show_help() {
     echo "  demo             Run interactive demo (~60s simulated session)"
     echo "  init [name]      Project scaffolding with 22 PRD templates"
     echo "  issue <url|num>  [DEPRECATED] Use 'loki run' instead"
-    echo "  watch [sec]      Live TUI session monitor (v6.0.0)"
+    echo "  watch [prd]      Auto-rerun on PRD file changes (v6.33.0)"
     echo "  export <format>  Export session data: json|markdown|csv|timeline (v6.0.0)"
     echo "  stop             Stop execution immediately"
     echo "  cleanup          Kill orphaned processes from crashed sessions"
@@ -424,7 +424,7 @@ show_help() {
     echo "  review [opts]    Standalone code review with quality gates (diff, staged, PR, files)"
     echo "  optimize         Optimize prompts based on session history"
     echo "  enterprise       Enterprise feature management (tokens, OIDC)"
-    echo "  metrics          Prometheus/OpenMetrics metrics from dashboard"
+    echo "  metrics [opts]   Session productivity report (--json, --last N, --save, --share)"
     echo "  dogfood          Show self-development statistics"
     echo "  secrets [cmd]    API key status and validation (status|validate)"
     echo "  reset [target]   Reset session state (all|retries|failed)"
@@ -487,7 +487,7 @@ show_help() {
     echo "  loki start ./prd.md           # Start with PRD file"
     echo "  loki start --bg               # Start in background"
     echo "  loki start --parallel         # Start in parallel mode"
-    echo "  loki watch                    # Live session monitor"
+    echo "  loki watch                    # Watch PRD for changes, auto-rerun"
     echo "  loki export json              # Export session data"
     echo "  loki config set maxTier sonnet  # Cap model cost"
     echo "  loki status                   # Check current status"
@@ -4312,126 +4312,252 @@ EOF
 
 # Show configuration
 #===============================================================================
-# loki watch - Live TUI session monitor (v6.0.0)
+# loki watch - Auto-rerun on PRD file changes (v6.33.0)
 #===============================================================================
 
 cmd_watch() {
-    local interval="${1:-2}"
+    local prd_path=""
+    local run_once=false
+    local poll_interval=2
+    local no_auto_start=false
+    local debounce=3
+    local _watch_child_pid=""
 
-    # Handle --help
-    if [[ "$interval" == "--help" || "$interval" == "-h" ]]; then
-        # fall through to help block
-        :
-    elif ! [[ "$interval" =~ ^[0-9]+(\.[0-9]+)?$ ]]; then
-        echo -e "${RED}Invalid interval: $interval (expected positive number)${NC}"
-        return 1
-    elif [[ "$interval" =~ ^0+(\.0+)?$ ]]; then
-        echo -e "${RED}Invalid interval: $interval (must be greater than 0)${NC}"
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --help|-h)
+                echo -e "${BOLD}loki watch${NC} - Auto-rerun on PRD file changes (v6.33.0)"
+                echo ""
+                echo "Usage: loki watch [prd-path] [options]"
+                echo ""
+                echo "Monitors a PRD file for changes and automatically re-runs Loki Mode"
+                echo "when the file is saved. Enables a tight edit-PRD-see-results loop."
+                echo ""
+                echo "Arguments:"
+                echo "  prd-path            Path to PRD file (default: auto-detect prd.md, PRD.md, or first *.md)"
+                echo ""
+                echo "Options:"
+                echo "  --once              Run once immediately then exit"
+                echo "  --interval N        Poll interval in seconds for fallback watcher (default: 2)"
+                echo "  --no-auto-start     Watch but do not auto-start, just print change timestamps"
+                echo "  --debounce N        Wait N seconds after change before triggering (default: 3)"
+                echo "  --help, -h          Show this help"
+                echo ""
+                echo "File watcher priority:"
+                echo "  1. fswatch (macOS)    -- native filesystem events"
+                echo "  2. inotifywait (Linux) -- inotify-based"
+                echo "  3. stat polling        -- universal fallback"
+                echo ""
+                echo "Examples:"
+                echo "  loki watch                       # Auto-detect PRD and watch"
+                echo "  loki watch ./my-prd.md           # Watch specific file"
+                echo "  loki watch --once                # Run once immediately then exit"
+                echo "  loki watch --no-auto-start       # Just report changes, don't run"
+                echo "  loki watch --debounce 5          # Wait 5s after change before triggering"
+                echo "  loki watch --interval 1          # Poll every 1s (fallback mode)"
+                return 0
+                ;;
+            --once) run_once=true; shift ;;
+            --interval) poll_interval="${2:-2}"; shift 2 ;;
+            --interval=*) poll_interval="${1#*=}"; shift ;;
+            --no-auto-start) no_auto_start=true; shift ;;
+            --debounce) debounce="${2:-3}"; shift 2 ;;
+            --debounce=*) debounce="${1#*=}"; shift ;;
+            -*)
+                echo -e "${RED}Unknown option: $1${NC}"
+                echo "Run 'loki watch --help' for usage."
+                return 1
+                ;;
+            *)
+                if [ -z "$prd_path" ]; then
+                    prd_path="$1"
+                else
+                    echo -e "${RED}Unexpected argument: $1${NC}"
+                    return 1
+                fi
+                shift
+                ;;
+        esac
+    done
+
+    # Validate numeric arguments
+    if ! [[ "$poll_interval" =~ ^[0-9]+$ ]] || [ "$poll_interval" -lt 1 ]; then
+        echo -e "${RED}Invalid --interval: $poll_interval (expected positive integer)${NC}"
         return 1
     fi
-    if [[ "$interval" == "--help" || "$interval" == "-h" ]]; then
-        echo -e "${BOLD}loki watch${NC} - Live session monitor (v6.0.0)"
-        echo ""
-        echo "Usage: loki watch [interval]"
-        echo ""
-        echo "Options:"
-        echo "  interval    Refresh interval in seconds (default: 2)"
-        echo ""
-        echo "Displays:"
-        echo "  - Current iteration and RARV phase"
-        echo "  - Provider and model tier"
-        echo "  - Task queue status"
-        echo "  - Recent log lines"
-        echo "  - Cost tracking"
-        echo ""
-        echo "Press Ctrl+C to exit."
-        exit 0
+    if ! [[ "$debounce" =~ ^[0-9]+$ ]] || [ "$debounce" -lt 0 ]; then
+        echo -e "${RED}Invalid --debounce: $debounce (expected non-negative integer)${NC}"
+        return 1
     fi
 
-    if [ ! -d "$LOKI_DIR" ]; then
-        echo -e "${RED}No active session found.${NC}"
-        echo "Start a session with: loki start <prd>"
-        exit 1
+    # Auto-detect PRD file if not specified
+    if [ -z "$prd_path" ]; then
+        if [ -f "prd.md" ]; then
+            prd_path="prd.md"
+        elif [ -f "PRD.md" ]; then
+            prd_path="PRD.md"
+        else
+            # Find first .md file in current directory
+            local first_md
+            first_md=$(ls -1 *.md 2>/dev/null | head -1 || true)
+            if [ -n "$first_md" ]; then
+                prd_path="$first_md"
+            else
+                echo -e "${RED}No PRD file found.${NC}"
+                echo "Specify a file: loki watch ./my-prd.md"
+                echo "Or create one: prd.md, PRD.md, or any .md file in current directory."
+                return 1
+            fi
+        fi
     fi
 
-    echo -e "${BOLD}Loki Mode Watch${NC} (refresh: ${interval}s, Ctrl+C to exit)"
-    echo ""
-
-    trap 'echo ""; echo "Watch stopped."; return 0' INT TERM
+    if [ ! -f "$prd_path" ]; then
+        echo -e "${RED}PRD file not found: $prd_path${NC}"
+        return 1
+    fi
 
-    while true; do
-        clear
-        echo -e "${BOLD}Loki Mode Watch${NC} $(date '+%H:%M:%S') (refresh: ${interval}s)"
-        echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    # Resolve to absolute path
+    prd_path="$(cd "$(dirname "$prd_path")" && pwd)/$(basename "$prd_path")"
+    local prd_basename
+    prd_basename="$(basename "$prd_path")"
+
+    # --once mode: run immediately and exit
+    if [ "$run_once" = true ]; then
+        echo -e "${BOLD}loki watch${NC} --once: running loki start ${prd_basename}"
+        "$0" start "$prd_path"
+        return $?
+    fi
 
-        # Session status
-        if [ -f "$LOKI_DIR/PAUSE" ]; then
-            echo -e "Status: ${YELLOW}PAUSED${NC}"
-        elif [ -f "$LOKI_DIR/STOP" ]; then
-            echo -e "Status: ${RED}STOPPED${NC}"
-        elif [ -f "$LOKI_DIR/loki.pid" ] && kill -0 "$(cat "$LOKI_DIR/loki.pid" 2>/dev/null)" 2>/dev/null; then
-            echo -e "Status: ${GREEN}RUNNING${NC}"
-        else
-            echo -e "Status: ${DIM}IDLE${NC}"
+    # Graceful shutdown handler
+    _watch_cleanup() {
+        echo ""
+        echo "Watch stopped."
+        if [ -n "$_watch_child_pid" ] && kill -0 "$_watch_child_pid" 2>/dev/null; then
+            echo "Stopping running loki session (PID $_watch_child_pid)..."
+            kill "$_watch_child_pid" 2>/dev/null
+            wait "$_watch_child_pid" 2>/dev/null || true
         fi
-
-        # Iteration and phase
-        if [ -f "$LOKI_DIR/state/iteration" ]; then
-            local iter
-            iter=$(cat "$LOKI_DIR/state/iteration" 2>/dev/null || echo "?")
-            echo -e "Iteration: $iter"
+        # Kill any background watcher process
+        if [ -n "${_watch_bg_pid:-}" ] && kill -0 "$_watch_bg_pid" 2>/dev/null; then
+            kill "$_watch_bg_pid" 2>/dev/null
+            wait "$_watch_bg_pid" 2>/dev/null || true
         fi
+        exit 0
+    }
+    trap '_watch_cleanup' INT TERM
 
-        # Provider info
-        local prov="${LOKI_PROVIDER:-claude}"
-        if [ -f "$LOKI_DIR/state/provider" ]; then
-            prov=$(cat "$LOKI_DIR/state/provider" 2>/dev/null || echo "$prov")
-        fi
-        echo -e "Provider: $prov"
+    local last_run="never"
 
-        # Queue status
-        echo ""
-        echo -e "${CYAN}Task Queue:${NC}"
-        for queue in pending in-progress completed failed; do
-            local queue_file="$LOKI_DIR/queue/${queue}.json"
-            if [ -f "$queue_file" ]; then
-                local count
-                count=$(_QUEUE_FILE="$queue_file" python3 -c "import json, os; print(len(json.load(open(os.environ['_QUEUE_FILE']))))" 2>/dev/null || echo "0")
-                echo "  $queue: $count"
-            fi
-        done
+    echo -e "${BOLD}loki watch${NC} -- monitoring ${prd_basename} for changes"
+    echo "Watching: $prd_path"
+    echo "Debounce: ${debounce}s | Ctrl+C to exit"
+    if [ "$no_auto_start" = true ]; then
+        echo "Mode: observe only (--no-auto-start)"
+    fi
+    echo ""
 
-        # Cost tracking
-        if [ -f "$LOKI_DIR/state/cost-tracker.json" ]; then
-            echo ""
-            echo -e "${CYAN}Cost:${NC}"
-            _LOKI_COST_FILE="$LOKI_DIR/state/cost-tracker.json" python3 -c "
-import json, os
-with open(os.environ['_LOKI_COST_FILE']) as f:
-    data = json.load(f)
-total = data.get('total_cost_usd', 0)
-budget = data.get('budget_limit', 0)
-print(f'  Total: \${total:.4f}')
-if budget > 0:
-    print(f'  Budget: \${budget:.2f} ({total/budget*100:.1f}% used)')
-" 2>/dev/null || true
+    _watch_status_line() {
+        echo -e "\rWatching ${prd_basename} -- last run: ${last_run} -- next: on change"
+    }
+
+    _watch_trigger() {
+        local change_time
+        change_time="$(date '+%H:%M:%S')"
+
+        if [ "$no_auto_start" = true ]; then
+            echo "PRD changed: ${change_time}"
+            return 0
         fi
 
-        # Recent log
-        echo ""
-        echo -e "${CYAN}Recent Activity:${NC}"
-        local log_file="$LOKI_DIR/logs/loki-run.log"
-        if [ -f "$log_file" ]; then
-            tail -5 "$log_file" 2>/dev/null | sed 's/^/  /'
-        else
-            echo "  (no log file)"
+        # Kill any currently running loki session
+        if [ -n "$_watch_child_pid" ] && kill -0 "$_watch_child_pid" 2>/dev/null; then
+            echo "Stopping previous loki session (PID $_watch_child_pid)..."
+            kill "$_watch_child_pid" 2>/dev/null
+            wait "$_watch_child_pid" 2>/dev/null || true
+            _watch_child_pid=""
         fi
 
         echo ""
         echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+        echo "PRD changed -- starting loki... (${change_time})"
+        echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+        echo ""
 
-        sleep "$interval"
-    done
+        "$0" start "$prd_path" &
+        _watch_child_pid=$!
+        last_run="$change_time"
+    }
+
+    # Determine watcher backend
+    local watcher="poll"
+    if command -v fswatch &>/dev/null; then
+        watcher="fswatch"
+    elif command -v inotifywait &>/dev/null; then
+        watcher="inotifywait"
+    fi
+
+    echo "Watcher: $watcher"
+    _watch_status_line
+
+    case "$watcher" in
+        fswatch)
+            # Use fswatch for native macOS filesystem events
+            fswatch -1 --latency "$debounce" "$prd_path" | while read -r _event; do
+                _watch_trigger
+                _watch_status_line
+                # Re-attach fswatch for next change
+                fswatch -1 --latency "$debounce" "$prd_path" > /dev/null 2>&1 || true
+            done
+            # Fallback: loop-based fswatch for continuous watching
+            while true; do
+                fswatch -1 --latency "$debounce" "$prd_path" > /dev/null 2>&1
+                _watch_trigger
+                _watch_status_line
+            done
+            ;;
+        inotifywait)
+            while true; do
+                inotifywait -qq -e modify "$prd_path" 2>/dev/null
+                if [ "$debounce" -gt 0 ]; then
+                    sleep "$debounce"
+                fi
+                _watch_trigger
+                _watch_status_line
+            done
+            ;;
+        poll)
+            # Universal fallback: stat-based polling
+            local last_mtime
+            last_mtime=$(stat -f '%m' "$prd_path" 2>/dev/null || stat -c '%Y' "$prd_path" 2>/dev/null || echo "0")
+            local debounce_pending=false
+            local debounce_deadline=0
+
+            while true; do
+                sleep "$poll_interval"
+                local current_mtime
+                current_mtime=$(stat -f '%m' "$prd_path" 2>/dev/null || stat -c '%Y' "$prd_path" 2>/dev/null || echo "0")
+
+                if [ "$current_mtime" != "$last_mtime" ]; then
+                    last_mtime="$current_mtime"
+                    if [ "$debounce" -gt 0 ]; then
+                        # Start debounce window
+                        debounce_pending=true
+                        debounce_deadline=$(( $(date +%s) + debounce ))
+                    else
+                        _watch_trigger
+                        _watch_status_line
+                    fi
+                fi
+
+                # Check debounce deadline
+                if [ "$debounce_pending" = true ] && [ "$(date +%s)" -ge "$debounce_deadline" ]; then
+                    debounce_pending=false
+                    _watch_trigger
+                    _watch_status_line
+                fi
+            done
+            ;;
+    esac
 }
 
 #===============================================================================
@@ -13833,47 +13959,448 @@ cmd_syslog() {
 
 # Fetch and display Prometheus metrics from dashboard
 cmd_metrics() {
-    local subcommand="${1:-}"
-    local port="${LOKI_DASHBOARD_PORT:-57374}"
-    local host="127.0.0.1"
+    local show_json=false
+    local last_n=0
+    local save_file=false
+    local share_flag=false
 
-    case "$subcommand" in
-        help|--help|-h)
-            echo -e "${BOLD}loki metrics${NC} - Prometheus/OpenMetrics metrics"
-            echo ""
-            echo "Usage: loki metrics [options]"
-            echo ""
-            echo "Fetches metrics from the dashboard API in Prometheus/OpenMetrics format."
-            echo "The dashboard must be running (loki dashboard start or loki serve)."
-            echo ""
-            echo "Options:"
-            echo "  help    Show this help"
-            echo ""
-            echo "Environment:"
-            echo "  LOKI_DASHBOARD_PORT   Dashboard port (default: 57374)"
-            echo ""
-            echo "Examples:"
-            echo "  loki metrics          # Display all metrics"
-            echo "  loki metrics | grep loki_cost_usd   # Filter specific metric"
-            ;;
-        "")
-            # Fetch metrics from dashboard
-            local url="http://${host}:${port}/metrics"
-            local response
-            response=$(curl -sf "$url" 2>/dev/null) || true
-            if [ -z "$response" ]; then
-                echo -e "${RED}Error: Could not connect to dashboard at ${url}${NC}"
-                echo "Make sure the dashboard is running: loki serve"
-                exit 1
-            fi
-            echo "$response"
-            ;;
-        *)
-            echo -e "${RED}Unknown metrics command: $subcommand${NC}"
-            echo "Run 'loki metrics help' for usage."
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --help|-h)
+                echo -e "${BOLD}loki metrics${NC} - Session productivity reporter"
+                echo ""
+                echo "Usage: loki metrics [options]"
+                echo ""
+                echo "Analyzes past Loki Mode session data and generates a productivity"
+                echo "stats report showing agents deployed, iterations completed, files"
+                echo "changed, and estimated time saved."
+                echo ""
+                echo "Options:"
+                echo "  --json               Machine-readable JSON output"
+                echo "  --last N             Analyze only the last N sessions (default: all)"
+                echo "  --save               Write report to METRICS.md in project root"
+                echo "  --share              Upload report as GitHub Gist (via loki share)"
+                echo "  --help, -h           Show this help"
+                echo ""
+                echo "Subcommands:"
+                echo "  prometheus           Fetch Prometheus/OpenMetrics from dashboard"
+                echo ""
+                echo "Examples:"
+                echo "  loki metrics                   # Full productivity report"
+                echo "  loki metrics --json            # Machine-readable output"
+                echo "  loki metrics --last 5          # Last 5 sessions only"
+                echo "  loki metrics --save            # Write METRICS.md"
+                echo "  loki metrics --share           # Share as GitHub Gist"
+                echo "  loki metrics prometheus        # Prometheus metrics from dashboard"
+                exit 0
+                ;;
+            --json) show_json=true; shift ;;
+            --last) last_n="${2:-0}"; shift 2 ;;
+            --last=*) last_n="${1#*=}"; shift ;;
+            --save) save_file=true; shift ;;
+            --share) share_flag=true; shift ;;
+            prometheus)
+                # Legacy Prometheus metrics subcommand
+                shift
+                local port="${LOKI_DASHBOARD_PORT:-57374}"
+                local host="127.0.0.1"
+                local url="http://${host}:${port}/metrics"
+                local response
+                response=$(curl -sf "$url" 2>/dev/null) || true
+                if [ -z "$response" ]; then
+                    echo -e "${RED}Error: Could not connect to dashboard at ${url}${NC}"
+                    echo "Make sure the dashboard is running: loki serve"
+                    exit 1
+                fi
+                echo "$response"
+                exit 0
+                ;;
+            *) echo -e "${RED}Unknown option: $1${NC}"; echo "Run 'loki metrics --help' for usage."; exit 1 ;;
+        esac
+    done
+
+    local loki_dir="${LOKI_DIR:-.loki}"
+
+    if ! command -v python3 &>/dev/null; then
+        echo -e "${RED}python3 is required for metrics generation${NC}"
+        exit 1
+    fi
+
+    local metrics_output
+    metrics_output=$(LOKI_DIR="$loki_dir" \
+        METRICS_JSON="$show_json" \
+        METRICS_LAST_N="$last_n" \
+        METRICS_SAVE="$save_file" \
+        python3 << 'METRICS_SCRIPT'
+import json
+import os
+import sys
+import glob
+import subprocess
+from datetime import datetime
+
+loki_dir = os.environ.get("LOKI_DIR", ".loki")
+show_json = os.environ.get("METRICS_JSON", "false") == "true"
+last_n = int(os.environ.get("METRICS_LAST_N", "0"))
+save_flag = os.environ.get("METRICS_SAVE", "false") == "true"
+
+def load_json(path):
+    try:
+        with open(path) as f:
+            return json.load(f)
+    except Exception:
+        return None
+
+def fmt_number(n):
+    return f"{n:,}"
+
+def load_queue(path):
+    data = load_json(path)
+    if isinstance(data, list):
+        return data
+    if isinstance(data, dict) and "tasks" in data:
+        return data["tasks"]
+    return []
+
+# --- Gather project name ---
+project_name = os.path.basename(os.getcwd())
+
+# --- Session data ---
+sessions_analyzed = 0
+total_iterations = 0
+total_tasks_completed = 0
+total_tasks_failed = 0
+agent_types_seen = set()
+total_duration_seconds = 0
+
+# Count sessions from checkpoints index or autonomy-state
+checkpoint_index = os.path.join(loki_dir, "state", "checkpoints", "index.jsonl")
+session_entries = []
+if os.path.isfile(checkpoint_index):
+    try:
+        with open(checkpoint_index) as f:
+            for line in f:
+                line = line.strip()
+                if line:
+                    try:
+                        session_entries.append(json.loads(line))
+                    except Exception:
+                        pass
+    except Exception:
+        pass
+
+# Orchestrator state
+orch = load_json(os.path.join(loki_dir, "state", "orchestrator.json")) or {}
+current_phase = orch.get("currentPhase", "N/A")
+orch_metrics = orch.get("metrics", {})
+tasks_completed_orch = orch_metrics.get("tasksCompleted", 0)
+tasks_failed_orch = orch_metrics.get("tasksFailed", 0)
+
+# Per-iteration efficiency files
+eff_dir = os.path.join(loki_dir, "metrics", "efficiency")
+iterations = []
+if os.path.isdir(eff_dir):
+    for path in sorted(glob.glob(os.path.join(eff_dir, "iteration-*.json"))):
+        data = load_json(path)
+        if data:
+            iterations.append(data)
+
+# Apply --last N filter
+if last_n > 0 and len(iterations) > last_n:
+    iterations = iterations[-last_n:]
+
+total_iterations = len(iterations) if iterations else max(orch.get("currentIteration", 0), 0)
+
+# Gather agent types from iterations and agents.json
+for it in iterations:
+    model = it.get("model", "")
+    if model:
+        agent_types_seen.add(model)
+    total_duration_seconds += it.get("duration_seconds", 0)
+
+agents_file = os.path.join(loki_dir, "state", "agents.json")
+agents_data = load_json(agents_file)
+if isinstance(agents_data, list):
+    for agent in agents_data:
+        atype = agent.get("agent_type", "")
+        if atype:
+            agent_types_seen.add(atype)
+
+# Queue data for task counts
+completed_tasks = load_queue(os.path.join(loki_dir, "queue", "completed.json"))
+failed_tasks = load_queue(os.path.join(loki_dir, "queue", "failed.json"))
+pending_tasks = load_queue(os.path.join(loki_dir, "queue", "pending.json"))
+in_progress_tasks = load_queue(os.path.join(loki_dir, "queue", "in-progress.json"))
+
+total_tasks_completed = len(completed_tasks) if completed_tasks else tasks_completed_orch
+total_tasks_failed = len(failed_tasks) if failed_tasks else tasks_failed_orch
+total_tasks = total_tasks_completed + total_tasks_failed + len(pending_tasks) + len(in_progress_tasks)
+success_rate = (total_tasks_completed / total_tasks * 100) if total_tasks > 0 else 0.0
+
+# Session count: count unique session directories or fall back to 1 if .loki exists
+sessions_dir = os.path.join(loki_dir, "state", "sessions")
+if os.path.isdir(sessions_dir):
+    sessions_analyzed = len([d for d in os.listdir(sessions_dir) if os.path.isdir(os.path.join(sessions_dir, d))])
+if sessions_analyzed == 0:
+    # Check autonomy-state.json retryCount as proxy for session attempts
+    auto_state = load_json(os.path.join(loki_dir, "autonomy-state.json"))
+    if auto_state:
+        sessions_analyzed = max(1, auto_state.get("retryCount", 1))
+    elif os.path.isdir(loki_dir):
+        sessions_analyzed = 1
+
+# Apply --last N to sessions
+if last_n > 0:
+    sessions_analyzed = min(sessions_analyzed, last_n)
+
+# --- Git stats ---
+lines_added = 0
+lines_removed = 0
+commits_made = 0
+files_changed_git = 0
+tests_written = 0
+
+try:
+    result = subprocess.run(
+        ["git", "log", "--shortstat", "--format="],
+        capture_output=True, text=True, timeout=10
+    )
+    if result.returncode == 0:
+        for line in result.stdout.strip().split("\n"):
+            line = line.strip()
+            if not line:
+                continue
+            parts = line.split(",")
+            for part in parts:
+                part = part.strip()
+                if "file" in part and "changed" in part:
+                    try:
+                        files_changed_git += int(part.split()[0])
+                    except (ValueError, IndexError):
+                        pass
+                elif "insertion" in part:
+                    try:
+                        lines_added += int(part.split()[0])
+                    except (ValueError, IndexError):
+                        pass
+                elif "deletion" in part:
+                    try:
+                        lines_removed += int(part.split()[0])
+                    except (ValueError, IndexError):
+                        pass
+
+    # Count commits
+    result2 = subprocess.run(
+        ["git", "rev-list", "--count", "HEAD"],
+        capture_output=True, text=True, timeout=10
+    )
+    if result2.returncode == 0:
+        commits_made = int(result2.stdout.strip())
+except Exception:
+    pass
+
+# Estimate tests written from git log (files matching test/spec patterns)
+try:
+    result3 = subprocess.run(
+        ["git", "log", "--diff-filter=A", "--name-only", "--format="],
+        capture_output=True, text=True, timeout=10
+    )
+    if result3.returncode == 0:
+        for fname in result3.stdout.strip().split("\n"):
+            fname = fname.strip().lower()
+            if any(kw in fname for kw in ["test", "spec", ".test.", ".spec.", "_test.", "_spec."]):
+                tests_written += 1
+except Exception:
+    pass
+
+# --- Token/cost data ---
+total_cost = sum(it.get("cost_usd", 0) for it in iterations)
+total_input_tokens = sum(it.get("input_tokens", 0) for it in iterations)
+total_output_tokens = sum(it.get("output_tokens", 0) for it in iterations)
+
+# Also check context tracking for cost data
+ctx_file = os.path.join(loki_dir, "context", "tracking.json")
+ctx = load_json(ctx_file)
+if ctx and total_cost == 0:
+    totals = ctx.get("totals", {})
+    total_cost = totals.get("total_cost_usd", 0)
+    total_input_tokens = totals.get("total_input", 0)
+    total_output_tokens = totals.get("total_output", 0)
+
+# --- Time saved estimate ---
+# Each Loki iteration replaces ~15min of manual work
+time_saved_hours = round(total_iterations * 15 / 60, 2)
+
+# --- Memory stats ---
+episodic_count = 0
+semantic_count = 0
+episodic_dir = os.path.join(loki_dir, "memory", "episodic")
+semantic_dir = os.path.join(loki_dir, "memory", "semantic")
+if os.path.isdir(episodic_dir):
+    for root, dirs, files in os.walk(episodic_dir):
+        episodic_count += len([f for f in files if f.endswith(".json")])
+if os.path.isdir(semantic_dir):
+    for root, dirs, files in os.walk(semantic_dir):
+        semantic_count += len([f for f in files if f.endswith(".json")])
+
+# --- Build output ---
+version = "6.32.0"
+try:
+    version_file = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "VERSION")
+    # In heredoc context, __file__ is not reliable; try relative
+    for vf in ["VERSION", "../VERSION", os.path.join(loki_dir, "..", "VERSION")]:
+        if os.path.isfile(vf):
+            with open(vf) as f:
+                version = f.read().strip()
+            break
+except Exception:
+    pass
+
+data = {
+    "project": project_name,
+    "sessions_analyzed": sessions_analyzed,
+    "agent_activity": {
+        "total_iterations": total_iterations,
+        "agent_types": len(agent_types_seen),
+        "tasks_completed": total_tasks_completed,
+        "tasks_failed": total_tasks_failed,
+        "success_rate": round(success_rate, 1)
+    },
+    "code_output": {
+        "files_changed": files_changed_git,
+        "lines_added": lines_added,
+        "lines_removed": lines_removed,
+        "commits": commits_made,
+        "tests_written": tests_written
+    },
+    "tokens": {
+        "input": total_input_tokens,
+        "output": total_output_tokens,
+        "total": total_input_tokens + total_output_tokens,
+        "cost_usd": round(total_cost, 2)
+    },
+    "time_saved": {
+        "hours": time_saved_hours,
+        "iterations": total_iterations,
+        "minutes_per_iteration": 15
+    },
+    "memory": {
+        "episodic_entries": episodic_count,
+        "semantic_patterns": semantic_count
+    },
+    "version": version
+}
+
+if show_json:
+    print(json.dumps(data, indent=2))
+else:
+    # ASCII stats card
+    lines = []
+    lines.append("")
+    lines.append("LOKI MODE PRODUCTIVITY REPORT")
+    lines.append("=" * 40)
+    lines.append(f"Project: {project_name}")
+    lines.append(f"Sessions analyzed: {sessions_analyzed}")
+    lines.append("")
+    lines.append("AGENT ACTIVITY")
+    lines.append(f"  Total iterations:    {fmt_number(total_iterations)}")
+    lines.append(f"  Agent types used:    {len(agent_types_seen)}")
+    lines.append(f"  Tasks completed:     {fmt_number(total_tasks_completed)}")
+    if total_tasks_failed > 0:
+        lines.append(f"  Tasks failed:        {fmt_number(total_tasks_failed)}")
+    if total_tasks > 0:
+        lines.append(f"  Success rate:        {success_rate:.1f}%")
+    lines.append("")
+    lines.append("CODE OUTPUT")
+    lines.append(f"  Files changed:       {fmt_number(files_changed_git)}")
+    lines.append(f"  Lines added:         {fmt_number(lines_added)}")
+    lines.append(f"  Lines removed:       {fmt_number(lines_removed)}")
+    lines.append(f"  Commits:             {fmt_number(commits_made)}")
+    lines.append(f"  Tests written:       {fmt_number(tests_written)}")
+    lines.append("")
+    if total_cost > 0 or total_input_tokens > 0:
+        lines.append("TOKEN USAGE")
+        lines.append(f"  Input tokens:        {fmt_number(total_input_tokens)}")
+        lines.append(f"  Output tokens:       {fmt_number(total_output_tokens)}")
+        lines.append(f"  Estimated cost:      ${total_cost:.2f}")
+        lines.append("")
+    lines.append("TIME SAVED")
+    lines.append(f"  Estimated:           {time_saved_hours} hours")
+    lines.append(f"  (based on {fmt_number(total_iterations)} iterations x 15min each)")
+    lines.append("")
+    if episodic_count > 0 or semantic_count > 0:
+        lines.append("MEMORY")
+        lines.append(f"  Episodic entries:    {fmt_number(episodic_count)}")
+        lines.append(f"  Semantic patterns:   {fmt_number(semantic_count)}")
+        lines.append("")
+    lines.append(f"Generated by Loki Mode v{version} | autonomi.dev")
+    lines.append("Share your stats: loki metrics --share")
+    lines.append("")
+
+    output_text = "\n".join(lines)
+    print(output_text)
+
+    # Save to METRICS.md if requested
+    if save_flag:
+        try:
+            with open("METRICS.md", "w") as f:
+                f.write("# Loki Mode Productivity Report\n\n")
+                f.write(f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
+                f.write("```\n")
+                f.write(output_text.strip())
+                f.write("\n```\n")
+            print("Saved to METRICS.md")
+        except Exception as e:
+            print(f"Error saving METRICS.md: {e}", file=sys.stderr)
+
+METRICS_SCRIPT
+    )
+    local metrics_exit=$?
+
+    if [ $metrics_exit -ne 0 ]; then
+        echo -e "${RED}Failed to generate metrics report${NC}"
+        echo "$metrics_output"
+        exit 1
+    fi
+
+    echo "$metrics_output"
+
+    # Handle --share flag
+    if [ "$share_flag" = true ]; then
+        local tmpfile
+        tmpfile=$(mktemp "/tmp/loki-metrics-XXXXXX.md")
+        echo "$metrics_output" > "$tmpfile"
+
+        if ! command -v gh &>/dev/null; then
+            echo -e "${RED}gh CLI not found -- cannot share${NC}"
+            echo "Install: brew install gh"
+            rm -f "$tmpfile"
             exit 1
-            ;;
-    esac
+        fi
+
+        if ! gh auth status &>/dev/null 2>&1; then
+            echo -e "${RED}GitHub CLI not authenticated${NC}"
+            echo "Run 'gh auth login' to authenticate."
+            rm -f "$tmpfile"
+            exit 1
+        fi
+
+        echo "Uploading metrics report..."
+        local gist_desc="Loki Mode productivity report - ${project_name:-project} ($(date +%Y-%m-%d))"
+        local project_name
+        project_name=$(basename "$(pwd)")
+        local gist_url
+        gist_url=$(gh gist create "$tmpfile" --desc "$gist_desc" --public 2>&1)
+        local gist_exit=$?
+        rm -f "$tmpfile"
+
+        if [ $gist_exit -ne 0 ]; then
+            echo -e "${RED}Failed to create gist${NC}"
+            echo "$gist_url"
+            exit 1
+        fi
+        echo -e "${GREEN}Shared: ${gist_url}${NC}"
+    fi
 }
 
 # Output shell completion scripts

package/bin/postinstall.js

@@ -85,6 +85,30 @@ if (results.some(r => !r.ok)) {
   console.log(`  loki setup-skill`);
 }
 
+// PATH check: warn if npm global bin is not in PATH
+try {
+  const { execSync } = require('child_process');
+  const npmBin = execSync('npm bin -g 2>/dev/null || npm prefix -g', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+  const npmBinDir = npmBin.endsWith('/bin') ? npmBin : npmBin + '/bin';
+  const pathDirs = (process.env.PATH || '').split(':');
+  const lokiBinInPath = pathDirs.some(d => d === npmBinDir || d === npmBin);
+  if (!lokiBinInPath) {
+    console.log('');
+    console.log('[IMPORTANT] The `loki` command may not be in your PATH.');
+    console.log('');
+    console.log('Add the npm global bin directory to your PATH:');
+    console.log(`  export PATH="${npmBinDir}:$PATH"`);
+    console.log('');
+    console.log('To make this permanent, add it to your shell config (~/.zshrc or ~/.bashrc):');
+    console.log(`  echo 'export PATH="${npmBinDir}:$PATH"' >> ~/.zshrc && source ~/.zshrc`);
+    console.log('');
+    console.log('Or use the Homebrew tap (sets PATH automatically):');
+    console.log('  brew tap asklokesh/tap && brew install loki-mode');
+  }
+} catch {
+  // If npm bin check fails, skip PATH warning silently
+}
+
 console.log('');
 console.log('CLI commands:');
 console.log('  loki start ./prd.md              Start with Claude (default)');

package/completions/_loki

@@ -70,6 +70,15 @@ function _loki {
                 issue)
                     _loki_issue
                     ;;
+                metrics)
+                    _arguments \
+                        '--json[Machine-readable JSON output]' \
+                        '--last[Analyze last N sessions]:number:' \
+                        '--save[Write report to METRICS.md]' \
+                        '--share[Upload report as GitHub Gist]' \
+                        '--help[Show help]' \
+                        '1:subcommand:(prometheus)'
+                    ;;
                 share)
                     _arguments \
                         '--private[Create a secret gist]' \
@@ -115,6 +124,7 @@ function _loki_commands {
         'voice:Voice input commands'
         'doctor:Check system prerequisites'
         'onboard:Analyze repo and generate CLAUDE.md'
+        'metrics:Session productivity report'
         'share:Share session report as GitHub Gist'
         'version:Show version'
         'completions:Output shell completions'

package/completions/loki.bash

@@ -5,7 +5,7 @@ _loki_completion() {
     _init_completion || return
 
     # Main subcommands (must match autonomy/loki main case statement)
-    local main_commands="start quick demo init stop pause resume status dashboard logs serve api sandbox notify import github issue config provider reset memory compound checkpoint council dogfood projects enterprise voice secrets doctor watchdog audit metrics syslog onboard share version completions help"
+    local main_commands="start quick demo init stop pause resume status dashboard logs serve api sandbox notify import github issue config provider reset memory compound checkpoint council dogfood projects enterprise voice secrets doctor watchdog audit metrics syslog onboard share explain plan report test ci watch version completions help"
 
     # 1. If we are on the first argument (subcommand)
     if [[ $cword -eq 1 ]]; then
@@ -144,6 +144,24 @@ _loki_completion() {
             _filedir -d
             ;;
 
+        metrics)
+            if [[ "$cur" == -* ]]; then
+                COMPREPLY=( $(compgen -W "--json --last --save --share --help" -- "$cur") )
+                return 0
+            fi
+            local metrics_cmds="prometheus"
+            COMPREPLY=( $(compgen -W "${metrics_cmds}" -- "$cur") )
+            ;;
+
+        watch)
+            if [[ "$cur" == -* ]]; then
+                COMPREPLY=( $(compgen -W "--once --interval --no-auto-start --debounce --help" -- "$cur") )
+                return 0
+            fi
+            # Default to file completion for PRD files
+            COMPREPLY=( $(compgen -f -- "$cur") )
+            ;;
+
         share)
             if [[ "$cur" == -* ]]; then
                 COMPREPLY=( $(compgen -W "--private --format --help" -- "$cur") )

package/dashboard/__init__.py

@@ -7,7 +7,7 @@ Modules:
     control: Session control API (start/stop/pause/resume)
 """
 
-__version__ = "6.31.0"
+__version__ = "6.32.1"
 
 # Expose the control app for easy import
 try:

package/docs/INSTALLATION.md

@@ -2,7 +2,7 @@
 
 The flagship product of [Autonomi](https://www.autonomi.dev/). Complete installation instructions for all platforms and use cases.
 
-**Version:** v6.31.0
+**Version:** v6.32.1
 
 ---
 

package/mcp/__init__.py

@@ -57,4 +57,4 @@ try:
 except ImportError:
     __all__ = ['mcp']
 
-__version__ = '6.31.0'
+__version__ = '6.32.0'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loki-mode",
-  "version": "6.31.0",
+  "version": "6.32.1",
   "description": "Loki Mode by Autonomi - Multi-agent autonomous startup system for Claude Code, Codex CLI, and Gemini CLI",
   "keywords": [
     "agent",