loki-mode 6.12.5 → 6.13.1

package/README.md

@@ -9,7 +9,7 @@
 [![Agent Types](https://img.shields.io/badge/Agent%20Types-41-blue)]()
 [![Autonomi](https://img.shields.io/badge/Autonomi-autonomi.dev-5B4EEA)](https://www.autonomi.dev/)
 
-**Current Version: v6.6.1**
+**Current Version: v6.13.0**
 
 ---
 

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.12.5
+# Loki Mode v6.13.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.12.5 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**
+**v6.13.1 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**

package/VERSION

@@ -1 +1 @@
-6.12.5
+6.13.1

package/autonomy/loki

@@ -5597,293 +5597,253 @@ cmd_sandbox() {
     exec "$SANDBOX_SH" "$subcommand" "$@"
 }
 
-# Demo mode - simulated session showing multi-agent orchestration
+# Demo mode - build a real project from a bundled PRD template
 cmd_demo() {
     # Handle --help
     if [[ "${1:-}" == "--help" || "${1:-}" == "-h" ]]; then
-        echo -e "${BOLD}loki demo${NC} - Run interactive demo"
+        echo -e "${BOLD}loki demo${NC} - Build a real project from a bundled template"
         echo ""
-        echo "Simulates a full autonomous session in ~60 seconds."
-        echo "Starts the dashboard on port 57374 for real-time visualization."
+        echo "Creates a temporary directory, copies the Simple Todo App PRD, and"
+        echo "runs 'loki start' to build it end-to-end. Shows a summary when done"
+        echo "and offers to open the result in a browser."
         echo ""
-        echo "Usage: loki demo"
+        echo "Usage: loki demo [options]"
+        echo ""
+        echo "Options:"
+        echo "  --dir PATH    Use a specific directory instead of a temp dir"
+        echo "  --keep        Keep the temp directory on exit (default: kept)"
+        echo "  --provider P  AI provider to use (default: claude)"
+        echo "  --dry-run     Show what would happen without running"
+        echo ""
+        echo "Examples:"
+        echo "  loki demo                        # Build todo app in temp dir"
+        echo "  loki demo --dir ~/demo-project   # Build in specific directory"
+        echo "  loki demo --provider codex       # Use Codex instead of Claude"
         return 0
     fi
 
-    local version=$(get_version)
-    local demo_duration=60
+    local version
+    version=$(get_version)
     local demo_prd="$SKILL_DIR/templates/simple-todo-app.md"
+    local demo_dir=""
+    local provider=""
+    local dry_run=false
+    local start_args=()
 
-    # Fall back to examples/ if templates/ doesn't exist yet
+    # Parse arguments
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --dir)
+                if [[ -z "${2:-}" ]]; then
+                    echo -e "${RED}Error: --dir requires a path${NC}"
+                    return 1
+                fi
+                demo_dir="$2"
+                shift 2
+                ;;
+            --dir=*)
+                demo_dir="${1#*=}"
+                shift
+                ;;
+            --provider)
+                if [[ -z "${2:-}" ]]; then
+                    echo -e "${RED}Error: --provider requires a value${NC}"
+                    return 1
+                fi
+                provider="$2"
+                shift 2
+                ;;
+            --provider=*)
+                provider="${1#*=}"
+                shift
+                ;;
+            --keep)
+                # kept by default now, accepted for compat
+                shift
+                ;;
+            --dry-run)
+                dry_run=true
+                shift
+                ;;
+            *)
+                echo -e "${RED}Unknown option: $1${NC}"
+                echo "Run 'loki demo --help' for usage."
+                return 1
+                ;;
+        esac
+    done
+
+    # Fall back to examples/ if templates/ doesn't exist
     if [ ! -f "$demo_prd" ]; then
         demo_prd="$SKILL_DIR/examples/simple-todo-app.md"
     fi
 
     if [ ! -f "$demo_prd" ]; then
         echo -e "${RED}Error: Demo PRD not found${NC}"
-        echo "Expected at: $demo_prd"
-        exit 1
+        echo "Expected at: $SKILL_DIR/templates/simple-todo-app.md"
+        return 1
     fi
 
-    echo -e "${BOLD}Loki Mode v$version - Interactive Demo${NC}"
-    echo ""
-    echo -e "${CYAN}This demo simulates a full autonomous session in ~60 seconds.${NC}"
-    echo -e "${CYAN}Watch multi-agent orchestration, quality gates, and phase transitions.${NC}"
-    echo ""
-    echo -e "PRD: ${BOLD}Simple Todo App${NC}"
-    echo -e "Dashboard: ${BLUE}http://127.0.0.1:57374${NC}"
-    echo ""
-
-    # Track if we created .loki for cleanup
-    local demo_created_loki=false
-    if [ ! -d "$LOKI_DIR" ]; then
-        demo_created_loki=true
+    # Set up the demo directory
+    if [ -z "$demo_dir" ]; then
+        demo_dir=$(mktemp -d "${TMPDIR:-/tmp}/loki-demo-XXXXXX")
+    else
+        # Expand ~ if present
+        demo_dir="${demo_dir/#\~/$HOME}"
+        mkdir -p "$demo_dir"
     fi
 
-    # Set up demo .loki directory
-    mkdir -p "$LOKI_DIR"/{queue,memory,metrics/efficiency,state,council,logs,dashboard}
+    echo -e "${BOLD}Loki Mode v$version - Demo${NC}"
+    echo ""
+    echo -e "  PRD:       Simple Todo App"
+    echo -e "  Directory: ${CYAN}$demo_dir${NC}"
+    if [ -n "$provider" ]; then
+        echo -e "  Provider:  $provider"
+    else
+        echo -e "  Provider:  claude (default)"
+    fi
+    echo ""
 
-    # Write initial session.json
-    local demo_pid=$$
-    local start_time
-    start_time=$(date -u +%Y-%m-%dT%H:%M:%SZ)
-    cat > "$LOKI_DIR/session.json" << SESSEOF
-{
-  "status": "running",
-  "pid": $demo_pid,
-  "provider": "claude",
-  "started": "$start_time",
-  "project": "$(pwd)",
-  "mode": "demo"
-}
-SESSEOF
-    echo "$demo_pid" > "$LOKI_DIR/loki.pid"
-
-    # Start dashboard server
-    local dashboard_started=false
-    if command -v python3 &> /dev/null && [ -f "$SKILL_DIR/dashboard/server.py" ]; then
-        # Kill any existing dashboard on this port
-        local existing_pids
-        existing_pids=$(lsof -ti :57374 2>/dev/null || true)
-        if [ -n "$existing_pids" ]; then
-            echo "$existing_pids" | xargs kill 2>/dev/null || true
-            sleep 1
-        fi
+    # Copy PRD into demo directory
+    cp "$demo_prd" "$demo_dir/prd.md"
 
-        # Set up dashboard venv
-        if ! ensure_dashboard_venv; then
-            echo -e "${YELLOW}Warning: Dashboard dependencies not available, continuing without dashboard${NC}"
-        fi
-        local demo_python="$DASHBOARD_PYTHON"
+    # Initialize git repo if not already one
+    if [ ! -d "$demo_dir/.git" ]; then
+        git -C "$demo_dir" init -q 2>/dev/null || true
+    fi
 
-        LOKI_DIR="$LOKI_DIR" PYTHONPATH="$SKILL_DIR" "$demo_python" -m uvicorn dashboard.server:app \
-            --host 127.0.0.1 --port 57374 --log-level warning &>/dev/null &
-        local dash_pid=$!
-        echo "$dash_pid" > "$LOKI_DIR/dashboard/dashboard.pid"
+    if [ "$dry_run" = true ]; then
+        echo -e "${YELLOW}[dry-run] Would run:${NC}"
+        echo "  cd $demo_dir"
+        echo -n "  loki start prd.md --simple --yes"
+        [ -n "$provider" ] && echo -n " --provider $provider"
+        echo ""
+        echo ""
+        echo -e "${DIM}PRD copied to: $demo_dir/prd.md${NC}"
+        return 0
+    fi
 
-        # Wait for dashboard to be ready
-        local wait_count=0
-        while [ $wait_count -lt 10 ]; do
-            if curl -s http://127.0.0.1:57374/health &>/dev/null; then
-                dashboard_started=true
-                echo -e "${GREEN}Dashboard started${NC} at http://127.0.0.1:57374"
-                break
-            fi
-            sleep 0.5
-            wait_count=$((wait_count + 1))
-        done
+    echo -e "${DIM}Starting autonomous build...${NC}"
+    echo -e "${DIM}(Press Ctrl+C to stop at any time)${NC}"
+    echo ""
 
-        if [ "$dashboard_started" = false ]; then
-            echo -e "${YELLOW}Warning: Dashboard failed to start, continuing without it${NC}"
-        fi
+    # Build start args
+    start_args+=("prd.md" "--simple" "--yes")
+    if [ -n "$provider" ]; then
+        start_args+=("--provider" "$provider")
     fi
 
+    # Run loki start from the demo directory
+    local start_exit=0
+    (cd "$demo_dir" && cmd_start "${start_args[@]}") || start_exit=$?
+
     echo ""
-    echo -e "${DIM}------- Demo Session Starting -------${NC}"
+    echo -e "${DIM}---------------------------------------${NC}"
+    echo -e "${BOLD}Demo Complete${NC}"
+    echo -e "${DIM}---------------------------------------${NC}"
     echo ""
 
-    # Define demo phases and their durations
-    local phases=("PLANNING" "ARCHITECTURE" "DEVELOPMENT" "TESTING" "CODE_REVIEW" "QUALITY_ASSURANCE" "DEPLOYMENT_PREP")
-    local phase_durations=(6 6 15 10 8 8 7)
-    local agents=("planner" "architect" "frontend-dev" "backend-dev" "test-engineer" "reviewer-1" "reviewer-2" "reviewer-3" "qa-engineer" "deploy-engineer")
-    local tasks=("Analyze PRD requirements" "Design system architecture" "Scaffold React frontend" "Create Express API server" "Set up SQLite database" "Implement todo CRUD operations" "Write unit tests" "Run code review (3 reviewers)" "Quality gate validation" "Prepare deployment artifacts")
-
-    local iteration=1
-    local completed_tasks=0
-    local total_tasks=${#tasks[@]}
-    local elapsed=0
-    local task_idx=0
-
-    # Cleanup handler (guard against double-run)
-    local _demo_cleaned=false
-    cleanup_demo() {
-        if [ "$_demo_cleaned" = true ]; then return; fi
-        _demo_cleaned=true
-        echo ""
-        echo -e "${DIM}------- Demo Session Complete -------${NC}"
-        echo ""
+    # Show summary of what was generated
+    echo -e "${BOLD}Project Directory:${NC} $demo_dir"
+    echo ""
 
-        # Summary
-        echo -e "${BOLD}Session Summary${NC}"
-        echo -e "  Phases completed:  ${#phases[@]}/${#phases[@]}"
-        echo -e "  Tasks completed:   $total_tasks/$total_tasks"
-        echo -e "  Quality gates:     7/7 passed"
-        echo -e "  Agents dispatched: ${#agents[@]}"
-        echo -e "  Iterations:        $iteration"
-        echo -e "  Duration:          ${elapsed}s"
-        echo ""
-        echo -e "${GREEN}All quality gates passed. Project ready for deployment.${NC}"
-        echo ""
-        echo -e "${CYAN}Ready to try it for real?${NC}"
-        echo -e "  loki start ./prd.md        Start with your own PRD"
-        echo -e "  loki init                  Build a PRD interactively"
-        echo -e "  loki quick \"add feature\"   Quick single-task mode"
+    if [ -d "$demo_dir" ]; then
+        # Count generated files (exclude .git and .loki)
+        local file_count
+        file_count=$(find "$demo_dir" -type f \
+            -not -path "$demo_dir/.git/*" \
+            -not -path "$demo_dir/.loki/*" \
+            -not -name "prd.md" \
+            2>/dev/null | wc -l | tr -d ' ')
+
+        local dir_count
+        dir_count=$(find "$demo_dir" -type d \
+            -not -path "$demo_dir/.git" \
+            -not -path "$demo_dir/.git/*" \
+            -not -path "$demo_dir/.loki" \
+            -not -path "$demo_dir/.loki/*" \
+            -not -path "$demo_dir" \
+            2>/dev/null | wc -l | tr -d ' ')
+
+        echo -e "${BOLD}Generated:${NC} $file_count files in $dir_count directories"
         echo ""
 
-        # Mark session stopped
-        if [ -f "$LOKI_DIR/session.json" ]; then
-            LOKI_SESSION_FILE="$LOKI_DIR/session.json" python3 -c "
-import json, os
-p = os.environ['LOKI_SESSION_FILE']
-with open(p, 'r') as f:
-    d = json.load(f)
-d['status'] = 'stopped'
-with open(p, 'w') as f:
-    json.dump(d, f, indent=2)
-" 2>/dev/null || true
+        # Show top-level structure
+        if command -v tree &>/dev/null; then
+            echo -e "${BOLD}Project Structure:${NC}"
+            tree -L 2 --dirsfirst -I '.git|.loki' "$demo_dir" 2>/dev/null || \
+                ls -1 "$demo_dir" 2>/dev/null
+            echo ""
+        else
+            echo -e "${BOLD}Top-level contents:${NC}"
+            ls -1 "$demo_dir" | grep -v '^\.\(git\|loki\)$' || true
+            echo ""
         fi
 
-        # Kill dashboard
-        if [ -f "$LOKI_DIR/dashboard/dashboard.pid" ]; then
-            local dpid
-            dpid=$(cat "$LOKI_DIR/dashboard/dashboard.pid" 2>/dev/null)
-            if [ -n "$dpid" ]; then
-                kill "$dpid" 2>/dev/null || true
+        # Check for common web artifacts and offer to open
+        local has_web=false
+        local open_target=""
+
+        # Check for common entry points
+        for candidate in \
+            "$demo_dir/index.html" \
+            "$demo_dir/dist/index.html" \
+            "$demo_dir/build/index.html" \
+            "$demo_dir/public/index.html" \
+            "$demo_dir/frontend/dist/index.html" \
+            "$demo_dir/client/dist/index.html"; do
+            if [ -f "$candidate" ]; then
+                has_web=true
+                open_target="$candidate"
+                break
+            fi
+        done
+
+        # Check for package.json with start script
+        local has_start_script=false
+        if [ -f "$demo_dir/package.json" ]; then
+            if grep -q '"start"' "$demo_dir/package.json" 2>/dev/null; then
+                has_start_script=true
+            fi
+            if grep -q '"dev"' "$demo_dir/package.json" 2>/dev/null; then
+                has_start_script=true
             fi
-        fi
-        # Also kill by port
-        local port_pids
-        port_pids=$(lsof -ti :57374 2>/dev/null || true)
-        if [ -n "$port_pids" ]; then
-            echo "$port_pids" | xargs kill 2>/dev/null || true
         fi
 
-        # Clean up demo artifacts if we created .loki
-        if [ "$demo_created_loki" = true ] && [ -d "$LOKI_DIR" ]; then
-            rm -rf "$LOKI_DIR"
+        if [ "$has_web" = true ] && [ -n "$open_target" ]; then
+            echo -e "${CYAN}A web frontend was generated.${NC}"
+            echo ""
+            echo -n "Open in browser? [Y/n] "
+            read -r answer </dev/tty 2>/dev/null || answer="n"
+            if [[ -z "$answer" || "$answer" =~ ^[Yy] ]]; then
+                if command -v open &>/dev/null; then
+                    open "$open_target"
+                elif command -v xdg-open &>/dev/null; then
+                    xdg-open "$open_target"
+                else
+                    echo -e "Open this file in your browser: ${BLUE}$open_target${NC}"
+                fi
+            fi
+        elif [ "$has_start_script" = true ]; then
+            echo -e "${CYAN}A start script was found in package.json.${NC}"
+            echo -e "To run the app:"
+            echo -e "  cd $demo_dir && npm install && npm start"
         fi
-    }
+    fi
 
-    trap cleanup_demo EXIT INT TERM
-
-    # Run through phases
-    for phase_idx in "${!phases[@]}"; do
-        local phase="${phases[$phase_idx]}"
-        local duration="${phase_durations[$phase_idx]}"
-
-        echo -e "${BOLD}[$phase]${NC} Phase $((phase_idx + 1))/${#phases[@]}"
-
-        # Write dashboard state for this phase
-        _write_demo_state "$phase" "$iteration" "$completed_tasks" "$total_tasks" "$elapsed"
-
-        # Simulate work within this phase
-        local phase_elapsed=0
-        while [ $phase_elapsed -lt $duration ]; do
-            # Show task progress
-            if [ $task_idx -lt $total_tasks ]; then
-                local task="${tasks[$task_idx]}"
-                local agent="${agents[$((task_idx % ${#agents[@]}))]}"
-                echo -e "  ${CYAN}[agent:$agent]${NC} $task"
-
-                # Write task to queue
-                echo "{\"id\":\"task-$task_idx\",\"title\":\"$task\",\"status\":\"completed\",\"agent\":\"$agent\"}" \
-                    > "$LOKI_DIR/queue/task-$task_idx.json" 2>/dev/null
-
-                completed_tasks=$((completed_tasks + 1))
-                task_idx=$((task_idx + 1))
-            fi
-
-            # Quality gate checks at specific phases
-            if [ "$phase" = "CODE_REVIEW" ]; then
-                echo -e "  ${GREEN}[gate]${NC} Blind review: 3/3 reviewers approve"
-                sleep 1
-                echo -e "  ${GREEN}[gate]${NC} Anti-sycophancy check: devil's advocate triggered"
-                sleep 1
-            elif [ "$phase" = "QUALITY_ASSURANCE" ]; then
-                echo -e "  ${GREEN}[gate]${NC} Static analysis: 0 issues"
-                sleep 1
-                echo -e "  ${GREEN}[gate]${NC} Test coverage: 87% (threshold: 80%)"
-                sleep 1
-                echo -e "  ${GREEN}[gate]${NC} Security scan: no vulnerabilities"
-                sleep 1
-            fi
-
-            iteration=$((iteration + 1))
-            local step_sleep=2
-            if [ $((duration - phase_elapsed)) -lt 3 ]; then
-                step_sleep=1
-            fi
-            sleep $step_sleep
-            phase_elapsed=$((phase_elapsed + step_sleep))
-            elapsed=$((elapsed + step_sleep))
-
-            # Update dashboard state
-            _write_demo_state "$phase" "$iteration" "$completed_tasks" "$total_tasks" "$elapsed"
-        done
+    echo ""
+    echo -e "${BOLD}Next steps:${NC}"
+    echo -e "  cd $demo_dir                   # Explore the generated project"
+    echo -e "  loki start ./your-prd.md       # Build your own project"
+    echo -e "  loki init                      # Create a PRD interactively"
 
+    if [ $start_exit -ne 0 ]; then
         echo ""
-    done
-
-    # Final state - completion council
-    echo -e "${BOLD}[COMPLETION_COUNCIL]${NC} Evaluating project completion..."
-    _write_demo_state "COMPLETION_COUNCIL" "$iteration" "$total_tasks" "$total_tasks" "$elapsed"
-    sleep 2
-    echo -e "  ${GREEN}[council]${NC} Member 1: COMPLETE (all acceptance criteria met)"
-    sleep 1
-    echo -e "  ${GREEN}[council]${NC} Member 2: COMPLETE (tests passing, code reviewed)"
-    sleep 1
-    echo -e "  ${GREEN}[council]${NC} Member 3: COMPLETE (deployment artifacts ready)"
-    sleep 1
-    echo -e "  ${GREEN}[verdict]${NC} Unanimous: PROJECT COMPLETE (3/3 votes)"
-
-    # Write final state
-    _write_demo_state "COMPLETE" "$iteration" "$total_tasks" "$total_tasks" "$elapsed"
-
-    exit 0
-}
-
-# Helper: write dashboard-state.json during demo
-_write_demo_state() {
-    local phase="$1" iteration="$2" completed="$3" total="$4" elapsed="$5"
-    local running_agents=$((RANDOM % 3 + 1))
-    local pending=$((total - completed))
-    local temp_file="$LOKI_DIR/.dashboard-state.json.tmp"
+        echo -e "${YELLOW}Note: loki start exited with code $start_exit.${NC}"
+        echo -e "${YELLOW}The demo directory is preserved at: $demo_dir${NC}"
+    fi
 
-    cat > "$temp_file" << STATEEOF
-{
-  "status": "running",
-  "mode": "demo",
-  "phase": "$phase",
-  "iteration": $iteration,
-  "complexity": "standard",
-  "provider": "claude",
-  "current_task": "",
-  "pending_tasks": $pending,
-  "completed_tasks": $completed,
-  "failed_tasks": 0,
-  "running_agents": $running_agents,
-  "total_agents": 10,
-  "uptime_seconds": $elapsed,
-  "version": "$(get_version)",
-  "agents": [],
-  "council": {
-    "enabled": true,
-    "last_verdict": null,
-    "convergence_score": 0
-  }
-}
-STATEEOF
-    mv "$temp_file" "$LOKI_DIR/dashboard-state.json" 2>/dev/null
+    return $start_exit
 }
 
 # Quick mode - lightweight single-task execution

package/dashboard/__init__.py

@@ -7,7 +7,7 @@ Modules:
     control: Session control API (start/stop/pause/resume)
 """
 
-__version__ = "6.12.5"
+__version__ = "6.13.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.12.5
+**Version:** v6.13.1
 
 ---
 

package/mcp/__init__.py

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

package/package.json

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

package/templates/api-only.md

@@ -1,10 +1,34 @@
 # PRD: REST API Service
 
 ## Overview
-A simple REST API for managing notes. Tests Loki Mode's backend-only capabilities.
+A simple REST API for managing notes. Tests Loki Mode's backend-only capabilities with proper validation, error handling, and test coverage.
 
 ## Target Users
-Developers who need a notes API.
+- Developers who need a lightweight notes API for prototyping
+- Teams evaluating backend code generation quality
+- Frontend developers needing a mock API to build against
+
+## Features
+
+### MVP Features
+1. **Create Note** - Add a new note with title and content
+2. **List Notes** - Retrieve all notes
+3. **Get Note** - Retrieve a single note by ID
+4. **Update Note** - Edit an existing note's title or content
+5. **Delete Note** - Remove a note
+6. **Health Check** - Service health endpoint
+
+### Data Model
+
+```typescript
+interface Note {
+  id: string;
+  title: string;
+  content: string;
+  createdAt: string;       // ISO 8601 timestamp
+  updatedAt: string;       // ISO 8601 timestamp
+}
+```
 
 ## API Endpoints
 
@@ -12,23 +36,23 @@ Developers who need a notes API.
 
 #### GET /api/notes
 - Returns list of all notes
-- Response: `[{ id, title, content, createdAt }]`
+- Response: `[{ id, title, content, createdAt, updatedAt }]`
 
 #### GET /api/notes/:id
 - Returns single note
-- Response: `{ id, title, content, createdAt }`
+- Response: `{ id, title, content, createdAt, updatedAt }`
 - Error: 404 if not found
 
 #### POST /api/notes
 - Creates new note
 - Body: `{ title, content }`
-- Response: `{ id, title, content, createdAt }`
-- Error: 400 if validation fails
+- Response: `{ id, title, content, createdAt, updatedAt }` (201)
+- Error: 400 if validation fails (title required, content required)
 
 #### PUT /api/notes/:id
 - Updates existing note
-- Body: `{ title?, content? }`
-- Response: `{ id, title, content, updatedAt }`
+- Body: `{ title?, content? }` (partial update)
+- Response: `{ id, title, content, createdAt, updatedAt }`
 - Error: 404 if not found
 
 #### DELETE /api/notes/:id
@@ -44,36 +68,70 @@ Developers who need a notes API.
 ## Tech Stack
 - Runtime: Node.js 18+
 - Framework: Express.js
+- Language: TypeScript
 - Database: In-memory (array) for simplicity
-- Validation: zod or joi
-- Testing: Jest + supertest
+- Validation: zod
+- Testing: Vitest + supertest
+
+### Structure
+```
+/
+├── src/
+│   ├── index.ts                 # Express server setup, middleware
+│   ├── routes/
+│   │   ├── notes.ts             # Notes CRUD handlers
+│   │   └── health.ts            # Health check endpoint
+│   ├── middleware/
+│   │   └── errorHandler.ts      # Global error handler
+│   ├── schemas/
+│   │   └── note.ts              # Zod validation schemas
+│   └── types/
+│       └── index.ts             # TypeScript type definitions
+├── tests/
+│   ├── notes.test.ts            # Notes endpoint tests
+│   └── health.test.ts           # Health check test
+├── package.json
+├── tsconfig.json
+└── README.md
+```
 
 ## Requirements
-- Input validation on all endpoints
-- Proper HTTP status codes
-- JSON error responses
-- Request logging
-- Unit tests for each endpoint
+- TypeScript throughout
+- Input validation on all endpoints using zod
+- Proper HTTP status codes (200, 201, 204, 400, 404)
+- JSON error responses: `{ error: "message" }`
+- Request logging (method, path, status code)
+- CORS enabled for development
+
+## Testing
+- API tests: All endpoints with valid input, invalid input, and edge cases (Vitest + supertest)
+- Minimum test cases:
+  - `POST /api/notes` with valid data -> 201 + note object
+  - `POST /api/notes` with missing title -> 400 + error
+  - `POST /api/notes` with missing content -> 400 + error
+  - `GET /api/notes` -> 200 + array
+  - `GET /api/notes/:id` with valid id -> 200 + note
+  - `GET /api/notes/:id` with invalid id -> 404
+  - `PUT /api/notes/:id` with valid data -> 200 + updated note
+  - `PUT /api/notes/:id` with invalid id -> 404
+  - `DELETE /api/notes/:id` -> 204
+  - `DELETE /api/notes/:id` with invalid id -> 404
+  - `GET /health` -> 200 + status object
 
 ## Out of Scope
 - Authentication
-- Database persistence
+- Database persistence (file or SQL)
 - Rate limiting
 - API documentation (OpenAPI)
 - Deployment
 
-## Test Cases
-```
-POST /api/notes with valid data → 201 + note object
-POST /api/notes with missing title → 400 + error
-GET /api/notes → 200 + array
-GET /api/notes/:id with valid id → 200 + note
-GET /api/notes/:id with invalid id → 404
-PUT /api/notes/:id with valid data → 200 + updated note
-DELETE /api/notes/:id → 204
-GET /health → 200 + status object
-```
+## Success Criteria
+- All 6 endpoints return correct status codes and response bodies
+- Validation rejects invalid input with descriptive error messages
+- All tests pass
+- Server starts without errors on `npm start`
+- Health check returns valid response
 
 ---
 
-**Purpose:** Tests backend agent capabilities, code review, and QA without frontend complexity.
+**Purpose:** Tests backend agent capabilities, code review, and QA without frontend complexity. Expect ~15-20 minutes for full execution.

package/templates/e-commerce.md

@@ -12,7 +12,7 @@ A simple e-commerce storefront called "ShopBase" with a product catalog, shoppin
 
 ### MVP Features
 1. **Product Catalog** - Browse products with images, prices, descriptions, and categories
-2. **Product Detail** - Full product page with image gallery, variants (size/color), and reviews
+2. **Product Detail** - Full product page with image gallery and variants (size/color)
 3. **Shopping Cart** - Add/remove items, update quantities, persistent cart (survives refresh)
 4. **Checkout** - Shipping address form, order summary, Stripe payment
 5. **Order Confirmation** - Confirmation page and email receipt

package/templates/full-stack-demo.md

@@ -1,27 +1,34 @@
 # PRD: Full-Stack Demo App
 
 ## Overview
-A complete full-stack application demonstrating Loki Mode's end-to-end capabilities. A simple bookmark manager with tags.
+A complete full-stack application demonstrating Loki Mode's end-to-end capabilities. A bookmark manager called "Stash" with tags, search, and a clean UI.
 
 ## Target Users
-Users who want to save and organize bookmarks.
+- Users who want to save and organize bookmarks with tags
+- Developers testing Loki Mode's full-stack generation pipeline
 
 ## Features
 
 ### Core Features
 1. **Add Bookmark** - Save URL with title and optional tags
-2. **View Bookmarks** - List all bookmarks with search/filter
+   - Acceptance: Form validates URL format, title is required, tags are comma-separated, form clears on submit
+2. **View Bookmarks** - List all bookmarks with search and tag filter
+   - Acceptance: Shows URL, title, tags, and creation date; search filters by title with 300ms debounce; tag chips are clickable for filtering
 3. **Edit Bookmark** - Update title, URL, or tags
-4. **Delete Bookmark** - Remove bookmark
+   - Acceptance: Inline edit or modal form, pre-populated with current values, saves on submit
+4. **Delete Bookmark** - Remove bookmark with confirmation
+   - Acceptance: Confirmation dialog before delete, bookmark removed from list and database
 5. **Tag Management** - Create, view, and filter by tags
+   - Acceptance: Tag sidebar shows all tags with bookmark counts, clicking a tag filters the list, unused tags cleaned up on bookmark delete
 
 ### User Flow
-1. User opens app → sees bookmark list
-2. Clicks "Add Bookmark" → form appears
-3. Enters URL, title, tags → submits
-4. Bookmark appears in list
-5. Can filter by tag or search by title
+1. User opens app -> sees bookmark list (or empty state if none)
+2. Clicks "Add Bookmark" -> form appears
+3. Enters URL, title, tags -> submits
+4. Bookmark appears in list with tag chips
+5. Can filter by tag (click tag) or search by title (search bar)
 6. Can edit or delete any bookmark
+7. Refreshes page -> all state persists from database
 
 ## Tech Stack
 
@@ -42,17 +49,41 @@ Users who want to save and organize bookmarks.
 /
 ├── frontend/
 │   ├── src/
+│   │   ├── App.tsx                      # Main app with layout
 │   │   ├── components/
+│   │   │   ├── BookmarkList.tsx         # List of bookmark cards
+│   │   │   ├── BookmarkCard.tsx         # Single bookmark display
+│   │   │   ├── BookmarkForm.tsx         # Add/edit form
+│   │   │   ├── SearchBar.tsx            # Search input with debounce
+│   │   │   ├── TagSidebar.tsx           # Tag list with counts
+│   │   │   ├── TagChip.tsx              # Clickable tag badge
+│   │   │   ├── ConfirmDialog.tsx        # Delete confirmation
+│   │   │   └── EmptyState.tsx           # Shown when no bookmarks
 │   │   ├── hooks/
+│   │   │   ├── useBookmarks.ts          # CRUD operations via React Query
+│   │   │   └── useTags.ts              # Tag fetching hook
 │   │   ├── types/
-│   │   └── App.tsx
+│   │   │   └── index.ts                # Bookmark and Tag types
+│   │   └── main.tsx
+│   ├── tests/
+│   │   ├── BookmarkCard.test.tsx        # Card rendering and actions
+│   │   ├── BookmarkForm.test.tsx        # Form validation and submit
+│   │   └── SearchBar.test.tsx           # Debounce and filter behavior
 │   ├── package.json
 │   └── vite.config.ts
 ├── backend/
 │   ├── src/
+│   │   ├── index.ts                     # Express server setup
 │   │   ├── routes/
+│   │   │   ├── bookmarks.ts             # Bookmark CRUD handlers
+│   │   │   └── tags.ts                  # Tag list handler
 │   │   ├── db/
-│   │   └── index.ts
+│   │   │   └── index.ts                 # SQLite connection + schema init
+│   │   └── schemas/
+│   │       └── bookmark.ts              # Zod validation schemas
+│   ├── tests/
+│   │   ├── bookmarks.test.ts            # Bookmark API tests
+│   │   └── tags.test.ts                 # Tag API tests
 │   ├── package.json
 │   └── tsconfig.json
 └── README.md
@@ -62,17 +93,20 @@ Users who want to save and organize bookmarks.
 
 ### Bookmarks
 - `GET /api/bookmarks` - List all (query: `?tag=`, `?search=`)
-- `POST /api/bookmarks` - Create new
-- `PUT /api/bookmarks/:id` - Update
-- `DELETE /api/bookmarks/:id` - Delete
+- `POST /api/bookmarks` - Create new (body: `{ url, title, tags? }`)
+- `PUT /api/bookmarks/:id` - Update (body: `{ url?, title?, tags? }`)
+- `DELETE /api/bookmarks/:id` - Delete (returns 204)
 
 ### Tags
-- `GET /api/tags` - List all tags with counts
+- `GET /api/tags` - List all tags with bookmark counts
+
+### Health
+- `GET /health` - Returns `{ status: "ok" }`
 
 ## Database Schema
 ```sql
 CREATE TABLE bookmarks (
-  id INTEGER PRIMARY KEY,
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
   url TEXT NOT NULL,
   title TEXT NOT NULL,
   created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
@@ -80,29 +114,31 @@ CREATE TABLE bookmarks (
 );
 
 CREATE TABLE tags (
-  id INTEGER PRIMARY KEY,
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
   name TEXT UNIQUE NOT NULL
 );
 
 CREATE TABLE bookmark_tags (
-  bookmark_id INTEGER REFERENCES bookmarks(id),
-  tag_id INTEGER REFERENCES tags(id),
+  bookmark_id INTEGER REFERENCES bookmarks(id) ON DELETE CASCADE,
+  tag_id INTEGER REFERENCES tags(id) ON DELETE CASCADE,
   PRIMARY KEY (bookmark_id, tag_id)
 );
 ```
 
 ## Requirements
 - TypeScript throughout
-- Input validation (frontend + backend)
-- Error handling with user feedback
-- Loading states
-- Empty states
-- Responsive design
+- Input validation (frontend + backend): URL format, title required
+- Error handling with user-visible feedback (toast or inline messages)
+- Loading states during API calls
+- Empty states for no bookmarks and no search results
+- Search debounce: 300ms delay before API call
+- Responsive design (single-column on mobile, sidebar on desktop)
 
 ## Testing
-- Backend: Jest + supertest for API tests
-- Frontend: Basic component tests (optional)
-- E2E: Manual testing checklist
+- Backend API tests: Bookmark CRUD, tag listing, search/filter queries (Vitest + supertest)
+- Frontend component tests: BookmarkCard rendering, BookmarkForm validation, SearchBar debounce (Vitest + React Testing Library)
+- Minimum 10 test cases across frontend and backend
+- All tests required to pass (no optional tests)
 
 ## Out of Scope
 - User authentication
@@ -112,10 +148,13 @@ CREATE TABLE bookmark_tags (
 - Real-time sync
 
 ## Success Criteria
-- All CRUD operations work
-- Search and filter work
+- All CRUD operations work end-to-end (create, read, update, delete)
+- Search filters bookmarks by title with debounce
+- Tag filter shows only bookmarks with selected tag
+- Tag counts are accurate
+- Data persists across page refresh
 - No console errors
-- Tests pass
+- All tests pass
 - Code review passes (all 3 reviewers)
 
 ---

package/templates/simple-todo-app.md

@@ -1,48 +1,133 @@
 # PRD: Simple Todo App
 
 ## Overview
-A minimal todo application for testing Loki Mode with a simple, well-defined scope.
+A minimal todo application for testing Loki Mode with a simple, well-defined scope. A single-page app called "Todos" with a React frontend, Express API, and SQLite persistence.
 
 ## Target Users
-Individual users who want a simple way to track tasks.
+- Individual users who want a simple way to track tasks
+- Developers testing Loki Mode's core generation pipeline
 
 ## Features
 
 ### MVP Features
 1. **Add Todo** - Users can add a new todo item with a title
-2. **View Todos** - Display list of all todos
-3. **Complete Todo** - Mark a todo as done
-4. **Delete Todo** - Remove a todo from the list
+2. **View Todos** - Display list of all todos with completion status
+3. **Complete Todo** - Mark a todo as done (toggle)
+4. **Delete Todo** - Remove a todo from the list with confirmation
 
-### Tech Stack (Suggested)
-- Frontend: React + TypeScript
-- Backend: Node.js + Express
-- Database: SQLite (local file)
-- No deployment (local testing only)
+### User Flow
+1. User opens app -> sees todo list (or empty state if none)
+2. Types a title in the input field -> presses Enter or clicks Add
+3. New todo appears at the top of the list, input clears
+4. Clicks checkbox to toggle complete -> visual strikethrough
+5. Clicks delete icon -> confirmation prompt -> todo removed
+6. Refreshes page -> all state persists from database
+
+## Tech Stack
+
+### Frontend
+- React 18 with TypeScript
+- Vite for bundling
+- TailwindCSS for styling
+
+### Backend
+- Node.js 18+
+- Express.js
+- SQLite via better-sqlite3
+- zod for input validation
+
+### Structure
+```
+/
+├── frontend/
+│   ├── src/
+│   │   ├── App.tsx                  # Main app component
+│   │   ├── components/
+│   │   │   ├── TodoList.tsx         # List of todo items
+│   │   │   ├── TodoItem.tsx         # Single todo with checkbox/delete
+│   │   │   ├── AddTodo.tsx          # Input form for new todos
+│   │   │   └── EmptyState.tsx       # Shown when no todos exist
+│   │   ├── hooks/
+│   │   │   └── useTodos.ts         # API fetch/mutate hook
+│   │   ├── types/
+│   │   │   └── index.ts            # Todo type definition
+│   │   └── main.tsx
+│   ├── package.json
+│   └── vite.config.ts
+├── backend/
+│   ├── src/
+│   │   ├── index.ts                # Express server setup
+│   │   ├── routes/
+│   │   │   └── todos.ts            # CRUD route handlers
+│   │   └── db/
+│   │       └── index.ts            # SQLite connection + init
+│   ├── package.json
+│   └── tsconfig.json
+├── tests/
+│   ├── todos.test.ts               # API endpoint tests
+│   └── components/
+│       └── TodoItem.test.tsx        # Component tests
+└── README.md
+```
+
+## Database Schema
+
+```sql
+CREATE TABLE todos (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  title TEXT NOT NULL,
+  completed INTEGER DEFAULT 0,       -- 0 = false, 1 = true
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+```
+
+## API Endpoints
+
+### Todos
+- `GET /api/todos` - List all todos (ordered by created_at DESC)
+- `POST /api/todos` - Create todo (body: `{ title }`, returns created todo)
+- `PATCH /api/todos/:id` - Toggle completion (body: `{ completed }`)
+- `DELETE /api/todos/:id` - Delete todo (returns 204)
+
+### Health
+- `GET /health` - Returns `{ status: "ok" }`
 
 ## Acceptance Criteria
 
 ### Add Todo
 - [ ] Input field for todo title
-- [ ] Submit button
+- [ ] Submit on Enter key or button click
 - [ ] New todo appears in list
 - [ ] Input clears after submit
+- [ ] Empty title is rejected (frontend + backend validation)
 
 ### View Todos
 - [ ] Shows all todos in a list
-- [ ] Shows completion status
-- [ ] Empty state when no todos
+- [ ] Shows completion status (checkbox)
+- [ ] Empty state message when no todos exist
 
 ### Complete Todo
-- [ ] Checkbox or button to mark complete
-- [ ] Visual indicator for completed items
-- [ ] Persists after refresh
+- [ ] Checkbox toggles complete/incomplete
+- [ ] Visual strikethrough for completed items
+- [ ] Persists after page refresh
 
 ### Delete Todo
 - [ ] Delete button on each todo
 - [ ] Confirmation before delete
 - [ ] Removes from list and database
 
+## Requirements
+- TypeScript throughout
+- Input validation on both frontend and backend
+- Proper HTTP status codes (201 for create, 204 for delete, 400 for validation errors)
+- Loading states during API calls
+- Responsive design (usable on mobile)
+
+## Testing
+- API tests: All 4 CRUD endpoints with valid and invalid input (Vitest + supertest)
+- Component tests: TodoItem renders correctly, AddTodo form submission works
+- Minimum 6 test cases covering happy path and error cases
+
 ## Out of Scope
 - User authentication
 - Due dates
@@ -50,11 +135,14 @@ Individual users who want a simple way to track tasks.
 - Mobile app
 - Cloud deployment
 
-## Success Metrics
-- All features functional
-- Tests passing
+## Success Criteria
+- All 4 CRUD features functional end-to-end
+- All tests pass
 - No console errors
+- Empty state displays correctly
+- Data persists across page refresh
+- Input validation rejects empty titles
 
 ---
 
-**Purpose:** This PRD is intentionally simple to allow quick testing of Loki Mode's core functionality without waiting for complex builds or deployments.
+**Purpose:** This PRD is intentionally simple to allow quick testing of Loki Mode's core functionality without waiting for complex builds or deployments. Expect ~15-25 minutes for full execution.