loki-mode 5.13.1 → 5.14.1

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 zero human intervention. Requires --dangerously-skip-permissions flag.
 ---
 
-# Loki Mode v5.9.0
+# Loki Mode v5.14.1
 
 **You are an autonomous agent. You make decisions. You do not ask questions. You do not stop.**
 
@@ -253,4 +253,4 @@ Auto-detected or force with `LOKI_COMPLEXITY`:
 
 ---
 
-**v5.9.0 | Cross-Project Learning, VS Code Chat and Logs views | ~250 lines core**
+**v5.14.1 | Voice Input, Peer Review Fixes, macOS Compatibility | ~250 lines core**

package/VERSION

@@ -1 +1 @@
-5.13.1
+5.14.1

package/autonomy/api-server.js

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
 /**
- * Loki Mode HTTP API Server (v1.1.0)
+ * Loki Mode HTTP API Server (v1.2.0)
  * Zero npm dependencies - uses only Node.js built-ins
  *
  * Usage:
  *   node autonomy/api-server.js [--port 9898]
+ *   LOKI_API_PORT=9898 node autonomy/api-server.js
  *   loki api start
  *
  * Endpoints:
@@ -28,8 +29,48 @@ const fs = require('fs');
 const path = require('path');
 const { spawn, execSync } = require('child_process');
 
+// Validate port number is in valid range
+function isValidPort(port) {
+    return Number.isInteger(port) && port >= 1 && port <= 65535;
+}
+
+// Parse command line arguments
+function parseArgs() {
+    const args = process.argv.slice(2);
+    let port = null;
+
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--port' || args[i] === '-p') {
+            // Ensure next argument exists and is a number
+            if (i + 1 < args.length) {
+                const val = parseInt(args[i + 1], 10);
+                if (isValidPort(val)) {
+                    port = val;
+                }
+                i++; // Skip the value
+            }
+        } else if (args[i].startsWith('--port=')) {
+            const val = parseInt(args[i].split('=')[1], 10);
+            if (isValidPort(val)) {
+                port = val;
+            }
+        } else if (/^\d+$/.test(args[i])) {
+            // Bare number as port (backwards compatible)
+            const val = parseInt(args[i], 10);
+            if (isValidPort(val)) {
+                port = val;
+            }
+        }
+    }
+
+    return { port };
+}
+
+const cliArgs = parseArgs();
+
 // Configuration
-const PORT = parseInt(process.env.LOKI_API_PORT || process.argv[3] || '9898');
+const PORT = cliArgs.port || parseInt(process.env.LOKI_API_PORT || '9898');
+const MAX_BODY_SIZE = parseInt(process.env.LOKI_API_MAX_BODY || '1048576'); // 1MB default
 const LOKI_DIR = process.env.LOKI_DIR || path.join(process.cwd(), '.loki');
 const STATE_DIR = path.join(LOKI_DIR, 'state');
 const LOG_DIR = path.join(LOKI_DIR, 'logs');
@@ -163,11 +204,22 @@ function broadcast(event, data) {
     }
 }
 
-// Parse JSON body
+// Parse JSON body with size limit
 function parseBody(req) {
-    return new Promise((resolve) => {
+    return new Promise((resolve, reject) => {
         let body = '';
-        req.on('data', chunk => body += chunk);
+        let size = 0;
+
+        req.on('data', chunk => {
+            size += chunk.length;
+            if (size > MAX_BODY_SIZE) {
+                req.destroy();
+                reject(new Error('Request body too large'));
+                return;
+            }
+            body += chunk;
+        });
+
         req.on('end', () => {
             try {
                 resolve(body ? JSON.parse(body) : {});
@@ -175,6 +227,8 @@ function parseBody(req) {
                 resolve({});
             }
         });
+
+        req.on('error', () => resolve({}));
     });
 }
 
@@ -186,8 +240,8 @@ async function handleRequest(req, res) {
 
     // CORS headers
     res.setHeader('Access-Control-Allow-Origin', '*');
-    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
-    res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
 
     if (method === 'OPTIONS') {
         res.writeHead(204);
@@ -232,15 +286,27 @@ async function handleRequest(req, res) {
             }
         }, 2000);
 
-        req.on('close', () => {
+        // Clean up on close, error, or finish
+        const cleanup = () => {
             clearInterval(interval);
             sseClients.delete(res);
-        });
+        };
+
+        req.on('close', cleanup);
+        req.on('error', cleanup);
+        res.on('error', cleanup);
+        res.on('finish', cleanup);
         return;
     }
 
     if (method === 'GET' && pathname === '/logs') {
-        const lines = parseInt(url.searchParams.get('lines')) || 50;
+        let lines = parseInt(url.searchParams.get('lines'), 10);
+        // Validate lines: must be positive, default to 50, cap at 10000
+        if (!Number.isInteger(lines) || lines < 1) {
+            lines = 50;
+        } else if (lines > 10000) {
+            lines = 10000;
+        }
         const logFile = path.join(LOG_DIR, 'session.log');
 
         if (!fs.existsSync(logFile)) {
@@ -254,7 +320,12 @@ async function handleRequest(req, res) {
     }
 
     if (method === 'POST' && pathname === '/start') {
-        const body = await parseBody(req);
+        let body;
+        try {
+            body = await parseBody(req);
+        } catch (err) {
+            return json({ error: err.message }, 413);
+        }
         const prd = body.prd || '';
         const provider = body.provider || 'claude';
         const parallel = body.parallel || false;

package/autonomy/issue-parser.sh

@@ -1,6 +1,6 @@
 #!/bin/bash
 #===============================================================================
-# Loki Mode - GitHub Issue Parser (v5.9.0)
+# Loki Mode - GitHub Issue Parser (v5.14.0)
 # Parses GitHub issues and extracts structured data for PRD generation
 #
 # Usage:

package/autonomy/loki

@@ -137,6 +137,7 @@ show_help() {
     echo "  api [cmd]        HTTP API server (start|stop|status)"
     echo "  sandbox [cmd]    Docker sandbox (start|stop|status|logs|shell|build)"
     echo "  notify [cmd]     Send notifications (test|slack|discord|webhook|status)"
+    echo "  voice [cmd]      Voice input for PRD creation (status|listen|dictate|speak|start)"
     echo "  import           Import GitHub issues as tasks"
     echo "  config [cmd]     Manage configuration (show|init|edit|path)"
     echo "  memory [cmd]     Cross-project learnings (list|show|search|stats)"
@@ -2486,6 +2487,9 @@ main() {
         enterprise)
             cmd_enterprise "$@"
             ;;
+        voice)
+            cmd_voice "$@"
+            ;;
         version|--version|-v)
             cmd_version
             ;;
@@ -3365,6 +3369,99 @@ for check, passed in checks.items():
     esac
 }
 
+# Voice input commands
+cmd_voice() {
+    local subcommand="${1:-status}"
+    local VOICE_SCRIPT="$SKILL_DIR/autonomy/voice.sh"
+
+    # Check fallback locations for voice script
+    if [ ! -f "$VOICE_SCRIPT" ]; then
+        # Try relative to loki CLI location
+        local loki_dir
+        loki_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+        VOICE_SCRIPT="$loki_dir/voice.sh"
+    fi
+
+    if [ ! -f "$VOICE_SCRIPT" ]; then
+        echo -e "${RED}Error: Voice module not found${NC}"
+        echo "Expected at: $SKILL_DIR/autonomy/voice.sh"
+        echo ""
+        echo "Voice input requires the voice.sh module."
+        echo "This feature may not be available in all installations."
+        exit 1
+    fi
+
+    case "$subcommand" in
+        status)
+            "$VOICE_SCRIPT" status
+            ;;
+        listen)
+            echo -e "${BOLD}Starting voice input...${NC}"
+            local text
+            text=$("$VOICE_SCRIPT" listen)
+            if [ -n "$text" ]; then
+                echo ""
+                echo -e "${GREEN}Transcribed text:${NC}"
+                echo "$text"
+            fi
+            ;;
+        dictate)
+            local output="${2:-prd-voice.md}"
+            echo -e "${BOLD}Starting guided PRD dictation...${NC}"
+            echo ""
+            "$VOICE_SCRIPT" dictate "$output"
+            if [ -f "$output" ]; then
+                echo ""
+                echo -e "${GREEN}PRD created: $output${NC}"
+                echo ""
+                echo "Start Loki Mode with:"
+                echo "  loki start $output"
+            fi
+            ;;
+        speak)
+            shift
+            if [ $# -eq 0 ]; then
+                echo -e "${RED}Usage: loki voice speak MESSAGE${NC}"
+                exit 1
+            fi
+            "$VOICE_SCRIPT" speak "$*"
+            ;;
+        start)
+            # Dictate PRD and start Loki Mode
+            local prd_file="${2:-prd-voice-$(date +%Y%m%d%H%M%S).md}"
+            echo -e "${BOLD}Voice-activated PRD creation...${NC}"
+            "$VOICE_SCRIPT" dictate "$prd_file"
+            if [ -f "$prd_file" ]; then
+                echo ""
+                echo -e "${GREEN}PRD created. Starting Loki Mode...${NC}"
+                cmd_start "$prd_file"
+            fi
+            ;;
+        --help|-h|help)
+            echo -e "${BOLD}loki voice${NC} - Voice input for PRD creation"
+            echo ""
+            echo "Usage: loki voice <command> [options]"
+            echo ""
+            echo "Commands:"
+            echo "  status           Check voice input capabilities"
+            echo "  listen           Listen and transcribe voice input"
+            echo "  dictate [FILE]   Guided PRD dictation (default: prd-voice.md)"
+            echo "  speak MESSAGE    Text-to-speech output"
+            echo "  start [FILE]     Dictate PRD and start Loki Mode immediately"
+            echo ""
+            echo "Requirements:"
+            echo "  macOS: Enable Dictation in System Settings > Keyboard"
+            echo "  Or: Set OPENAI_API_KEY for Whisper API transcription"
+            echo "  Or: pip install openai-whisper for local transcription"
+            ;;
+        *)
+            echo -e "${RED}Unknown voice command: $subcommand${NC}"
+            echo "Run 'loki voice help' for usage."
+            exit 1
+            ;;
+    esac
+}
+
 # Enterprise features (optional - requires env vars)
 cmd_enterprise() {
     local subcommand="${1:-status}"

package/autonomy/run.sh

@@ -115,9 +115,30 @@
 #   LOKI_PROMPT_INJECTION - Enable HUMAN_INPUT.md processing (default: false)
 #                           Set to "true" only in trusted environments
 #===============================================================================
+#
+# Compatibility: bash 3.2+ (macOS default), bash 4+ (Linux), WSL
+# Parallel mode (--parallel) requires bash 4.0+ for associative arrays
+#===============================================================================
 
 set -uo pipefail
 
+# Compatibility check: Ensure we're running in bash (not sh, dash, zsh)
+if [ -z "${BASH_VERSION:-}" ]; then
+    echo "[ERROR] This script requires bash. Please run with: bash $0" >&2
+    exit 1
+fi
+
+# Extract major version for feature checks
+BASH_VERSION_MAJOR="${BASH_VERSION%%.*}"
+BASH_VERSION_MINOR="${BASH_VERSION#*.}"
+BASH_VERSION_MINOR="${BASH_VERSION_MINOR%%.*}"
+
+# Warn if bash version is very old (< 3.2)
+if [ "$BASH_VERSION_MAJOR" -lt 3 ] || { [ "$BASH_VERSION_MAJOR" -eq 3 ] && [ "$BASH_VERSION_MINOR" -lt 2 ]; }; then
+    echo "[WARN] Bash version $BASH_VERSION is old. Recommend bash 3.2+ for full compatibility." >&2
+    echo "[WARN] Some features may not work correctly." >&2
+fi
+
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 PROJECT_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
 
@@ -519,8 +540,7 @@ else
 fi
 
 # Track worktree PIDs for cleanup (requires bash 4+ for associative arrays)
-# Check bash version for parallel mode compatibility
-BASH_VERSION_MAJOR="${BASH_VERSION%%.*}"
+# BASH_VERSION_MAJOR is defined at script startup
 if [ "$BASH_VERSION_MAJOR" -ge 4 ] 2>/dev/null; then
     declare -A WORKTREE_PIDS
     declare -A WORKTREE_PATHS
@@ -1325,12 +1345,18 @@ notify_rate_limit() {
 # Parallel Workflow Functions (Git Worktrees)
 #===============================================================================
 
-# Check if parallel mode is supported (bash 4+ required)
+# Check if parallel mode is supported (bash 4+ required for associative arrays)
 check_parallel_support() {
     if [ "$BASH_VERSION_MAJOR" -lt 4 ] 2>/dev/null; then
-        log_error "Parallel mode requires bash 4.0 or higher"
-        log_error "Current bash version: $BASH_VERSION"
-        log_error "On macOS, install newer bash: brew install bash"
+        log_error "Parallel mode requires bash 4.0+ (current: $BASH_VERSION)"
+        log_error "Parallel mode uses associative arrays which require bash 4+"
+        log_error ""
+        log_error "How to upgrade:"
+        log_error "  macOS:  brew install bash && sudo chsh -s /opt/homebrew/bin/bash"
+        log_error "  Ubuntu: sudo apt install bash"
+        log_error "  WSL:    Usually has bash 4+ by default"
+        log_error ""
+        log_error "Or run without --parallel flag for sequential mode (works with bash 3.2+)"
         return 1
     fi
     return 0
@@ -1754,7 +1780,7 @@ run_parallel_orchestrator() {
 
         cat > "$state_file" << EOF
 {
-  "timestamp": "$(date -Iseconds)",
+  "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
   "worktrees": {
 $(for stream in "${!WORKTREE_PATHS[@]}"; do
     local path="${WORKTREE_PATHS[$stream]}"

package/autonomy/voice.sh

@@ -0,0 +1,502 @@
+#!/usr/bin/env bash
+# Loki Mode Voice Input Support (v1.0.0)
+# Enables voice-to-text for PRD dictation and command input
+#
+# Usage:
+#   ./autonomy/voice.sh listen        - Listen for voice input
+#   ./autonomy/voice.sh speak MESSAGE - Text-to-speech output
+#   ./autonomy/voice.sh dictate FILE  - Dictate to file
+#   ./autonomy/voice.sh status        - Check voice capabilities
+#
+# Requires: macOS with Dictation enabled, or Whisper API
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+LOKI_DIR="${LOKI_DIR:-.loki}"
+
+# Colors (only if terminal supports them)
+if [[ -t 1 ]]; then
+    RED='\033[0;31m'
+    GREEN='\033[0;32m'
+    YELLOW='\033[0;33m'
+    BLUE='\033[0;34m'
+    NC='\033[0m'
+else
+    RED='' GREEN='' YELLOW='' BLUE='' NC=''
+fi
+
+log() { echo -e "${BLUE}[loki-voice]${NC} $*"; }
+log_success() { echo -e "${GREEN}[loki-voice]${NC} $*"; }
+log_warn() { echo -e "${YELLOW}[loki-voice]${NC} $*"; }
+log_error() { echo -e "${RED}[loki-voice]${NC} $*" >&2; }
+
+# Detect platform and available voice tools
+detect_platform() {
+    if [[ "$OSTYPE" == "darwin"* ]]; then
+        echo "macos"
+    elif [[ "$OSTYPE" == "linux-gnu"* ]]; then
+        echo "linux"
+    elif [[ "$OSTYPE" == "msys" ]] || [[ "$OSTYPE" == "cygwin" ]]; then
+        echo "windows"
+    else
+        echo "unknown"
+    fi
+}
+
+# Check if voice input is available
+check_voice_input() {
+    local platform
+    platform=$(detect_platform)
+
+    case "$platform" in
+        macos)
+            # Check if dictation is enabled
+            if defaults read com.apple.speech.recognition.AppleSpeechRecognition.prefs DictationIMMEnabled 2>/dev/null | grep -q "1"; then
+                echo "macos-dictation"
+            elif command -v whisper &>/dev/null; then
+                echo "whisper"
+            elif [[ -n "${OPENAI_API_KEY:-}" ]]; then
+                echo "whisper-api"
+            else
+                echo "none"
+            fi
+            ;;
+        linux)
+            if command -v whisper &>/dev/null; then
+                echo "whisper"
+            elif [[ -n "${OPENAI_API_KEY:-}" ]]; then
+                echo "whisper-api"
+            elif command -v arecord &>/dev/null && command -v vosk &>/dev/null; then
+                echo "vosk"
+            else
+                echo "none"
+            fi
+            ;;
+        *)
+            echo "none"
+            ;;
+    esac
+}
+
+# Check if text-to-speech is available
+check_voice_output() {
+    local platform
+    platform=$(detect_platform)
+
+    case "$platform" in
+        macos)
+            if command -v say &>/dev/null; then
+                echo "say"
+            else
+                echo "none"
+            fi
+            ;;
+        linux)
+            if command -v espeak &>/dev/null; then
+                echo "espeak"
+            elif command -v festival &>/dev/null; then
+                echo "festival"
+            else
+                echo "none"
+            fi
+            ;;
+        *)
+            echo "none"
+            ;;
+    esac
+}
+
+# Text-to-speech output
+speak() {
+    local message="$1"
+    local output_method
+    output_method=$(check_voice_output)
+
+    case "$output_method" in
+        say)
+            say -v "Samantha" "$message" 2>/dev/null || say "$message"
+            ;;
+        espeak)
+            espeak "$message"
+            ;;
+        festival)
+            echo "$message" | festival --tts
+            ;;
+        none)
+            log_warn "No text-to-speech available, printing instead"
+            echo "$message"
+            ;;
+    esac
+}
+
+# Temp file cleanup
+declare -a TEMP_FILES
+TEMP_FILES=()
+cleanup_temp_files() {
+    if [[ ${#TEMP_FILES[@]} -gt 0 ]]; then
+        for f in "${TEMP_FILES[@]}"; do
+            rm -f "$f" 2>/dev/null
+        done
+    fi
+}
+trap cleanup_temp_files EXIT
+
+# Create secure temp file
+make_temp_file() {
+    local suffix="${1:-.tmp}"
+    local temp_file
+    temp_file=$(mktemp "/tmp/loki-voice-XXXXXX$suffix")
+    TEMP_FILES+=("$temp_file")
+    echo "$temp_file"
+}
+
+# Record audio using macOS
+record_audio_macos() {
+    local output_file="$1"
+    local duration="${2:-10}"
+
+    log "Recording for ${duration} seconds... Press Ctrl+C to stop early"
+
+    # Use sox or ffmpeg
+    if command -v sox &>/dev/null; then
+        sox -d -r 16000 -c 1 -b 16 "$output_file" trim 0 "$duration" 2>/dev/null
+    elif command -v ffmpeg &>/dev/null; then
+        ffmpeg -f avfoundation -i ":0" -t "$duration" -ar 16000 -ac 1 "$output_file" -y 2>/dev/null
+    else
+        log_error "No audio recording tool found. Install sox: brew install sox"
+        return 1
+    fi
+}
+
+# Record audio using Linux
+record_audio_linux() {
+    local output_file="$1"
+    local duration="${2:-10}"
+
+    log "Recording for ${duration} seconds... Press Ctrl+C to stop early"
+
+    # Use sox, arecord, or ffmpeg
+    if command -v sox &>/dev/null; then
+        sox -d -r 16000 -c 1 -b 16 "$output_file" trim 0 "$duration" 2>/dev/null
+    elif command -v arecord &>/dev/null; then
+        arecord -f S16_LE -r 16000 -c 1 -d "$duration" "$output_file" 2>/dev/null
+    elif command -v ffmpeg &>/dev/null; then
+        ffmpeg -f alsa -i default -t "$duration" -ar 16000 -ac 1 "$output_file" -y 2>/dev/null
+    else
+        log_error "No audio recording tool found. Install: apt install sox alsa-utils"
+        return 1
+    fi
+}
+
+# Record audio (platform-aware)
+record_audio() {
+    local platform
+    platform=$(detect_platform)
+
+    case "$platform" in
+        macos)
+            record_audio_macos "$@"
+            ;;
+        linux)
+            record_audio_linux "$@"
+            ;;
+        *)
+            log_error "Audio recording not supported on $platform"
+            return 1
+            ;;
+    esac
+}
+
+# Transcribe audio using Whisper API
+transcribe_whisper_api() {
+    local audio_file="$1"
+
+    if [[ -z "${OPENAI_API_KEY:-}" ]]; then
+        log_error "OPENAI_API_KEY not set"
+        return 1
+    fi
+
+    local response
+    response=$(curl -s -X POST "https://api.openai.com/v1/audio/transcriptions" \
+        -H "Authorization: Bearer $OPENAI_API_KEY" \
+        -F "file=@$audio_file" \
+        -F "model=whisper-1" \
+        -F "language=en")
+
+    echo "$response" | python3 -c "import sys,json; print(json.load(sys.stdin).get('text', ''))"
+}
+
+# Transcribe audio using local Whisper
+transcribe_whisper_local() {
+    local audio_file="$1"
+    local output_dir
+    output_dir=$(dirname "$audio_file")
+
+    if ! command -v whisper &>/dev/null; then
+        log_error "Whisper not installed. Run: pip install openai-whisper"
+        return 1
+    fi
+
+    # Specify output directory to ensure output goes to same location as audio
+    whisper "$audio_file" --model base --language en --output_format txt --output_dir "$output_dir" 2>/dev/null
+    local txt_file="${audio_file%.wav}.txt"
+    if [[ -f "$txt_file" ]]; then
+        cat "$txt_file"
+        rm -f "$txt_file"
+    else
+        # Fallback: check current directory (older whisper versions)
+        local basename_txt
+        basename_txt=$(basename "${audio_file%.wav}.txt")
+        if [[ -f "$basename_txt" ]]; then
+            cat "$basename_txt"
+            rm -f "$basename_txt"
+        fi
+    fi
+}
+
+# Listen for voice input
+listen() {
+    local input_method
+    input_method=$(check_voice_input)
+
+    log "Voice input method: $input_method"
+
+    case "$input_method" in
+        macos-dictation)
+            log "Starting macOS Dictation..."
+            speak "Starting dictation. Press twice on Function key to begin, then speak your PRD."
+
+            # Open a dialog for dictation
+            osascript <<'EOF'
+tell application "System Events"
+    display dialog "Click OK then press Fn twice to start dictation" buttons {"Cancel", "OK"} default button "OK"
+end tell
+EOF
+            # Wait for user to dictate
+            log "Waiting for dictation input..."
+            log "Press Fn twice to toggle dictation on/off"
+
+            # Use a temporary file approach
+            local temp_file
+            temp_file=$(make_temp_file .txt)
+            # Escape single quotes in temp_file for safe embedding in AppleScript
+            local escaped_temp_file="${temp_file//\'/\'\\\'\'}"
+            osascript <<EOF
+tell application "System Events"
+    set userInput to text returned of (display dialog "Dictate or type your PRD:" default answer "" buttons {"Cancel", "OK"} default button "OK" with title "Loki Mode Voice Input")
+    do shell script "cat > '${escaped_temp_file}'" & " <<HEREDOC
+" & userInput & "
+HEREDOC"
+end tell
+EOF
+            if [[ -f "$temp_file" ]]; then
+                cat "$temp_file"
+                rm -f "$temp_file"
+            fi
+            ;;
+
+        whisper-api)
+            log "Using Whisper API for transcription"
+            local audio_file
+            audio_file=$(make_temp_file .wav)
+
+            speak "Recording will start now. Speak your requirements."
+            record_audio "$audio_file" 30
+
+            log "Transcribing..."
+            transcribe_whisper_api "$audio_file"
+            ;;
+
+        whisper)
+            log "Using local Whisper for transcription"
+            local audio_file
+            audio_file=$(make_temp_file .wav)
+
+            speak "Recording will start now. Speak your requirements."
+            record_audio "$audio_file" 30
+
+            log "Transcribing locally..."
+            transcribe_whisper_local "$audio_file"
+            ;;
+
+        none)
+            log_error "No voice input method available"
+            log "Options:"
+            log "  1. Enable macOS Dictation: System Settings > Keyboard > Dictation"
+            log "  2. Set OPENAI_API_KEY for Whisper API"
+            log "  3. Install local Whisper: pip install openai-whisper"
+            return 1
+            ;;
+    esac
+}
+
+# Dictate to a file
+dictate_to_file() {
+    local output_file="$1"
+
+    log "Dictating to: $output_file"
+    speak "Ready to create a PRD. I'll guide you through the sections."
+
+    local content=""
+
+    # Guide through PRD sections
+    speak "First, what is the name of your project?"
+    local project_name
+    project_name=$(listen)
+    content="# $project_name\n\n"
+
+    speak "Great. Now describe the overview of your project."
+    local overview
+    overview=$(listen)
+    content+="## Overview\n$overview\n\n"
+
+    speak "Now list your requirements. Say done when finished."
+    content+="## Requirements\n"
+
+    while true; do
+        local requirement
+        requirement=$(listen)
+
+        # Use tr for bash 3.2 compatibility (macOS default)
+        local requirement_lower
+        requirement_lower=$(printf '%s' "$requirement" | tr '[:upper:]' '[:lower:]')
+        if [[ "$requirement_lower" == *"done"* ]] || [[ "$requirement_lower" == *"finish"* ]]; then
+            break
+        fi
+
+        content+="- [ ] $requirement\n"
+        speak "Got it. Next requirement, or say done."
+    done
+
+    speak "What tech stack do you want to use?"
+    local tech_stack
+    tech_stack=$(listen)
+    content+="\n## Tech Stack\n$tech_stack\n"
+
+    # Write to file
+    echo -e "$content" > "$output_file"
+
+    speak "PRD created at $output_file"
+    log_success "PRD saved to: $output_file"
+    echo "$output_file"
+}
+
+# Show voice capabilities status
+status() {
+    local platform
+    platform=$(detect_platform)
+
+    echo "=== Loki Mode Voice Status ==="
+    echo ""
+    echo "Platform: $platform"
+    echo ""
+
+    echo "Voice Input:"
+    local input_method
+    input_method=$(check_voice_input)
+    case "$input_method" in
+        macos-dictation)
+            echo "  [OK] macOS Dictation enabled"
+            ;;
+        whisper-api)
+            echo "  [OK] Whisper API available (OPENAI_API_KEY set)"
+            ;;
+        whisper)
+            echo "  [OK] Local Whisper installed"
+            ;;
+        vosk)
+            echo "  [OK] Vosk speech recognition available"
+            ;;
+        none)
+            echo "  [--] No voice input available"
+            echo "  Recommendations:"
+            echo "    - macOS: Enable Dictation in System Settings > Keyboard"
+            echo "    - Set OPENAI_API_KEY for Whisper API"
+            echo "    - pip install openai-whisper for local transcription"
+            ;;
+    esac
+    echo ""
+
+    echo "Voice Output (TTS):"
+    local output_method
+    output_method=$(check_voice_output)
+    case "$output_method" in
+        say)
+            echo "  [OK] macOS 'say' command available"
+            ;;
+        espeak)
+            echo "  [OK] eSpeak available"
+            ;;
+        festival)
+            echo "  [OK] Festival TTS available"
+            ;;
+        none)
+            echo "  [--] No TTS available"
+            ;;
+    esac
+    echo ""
+
+    echo "Audio Recording:"
+    if command -v sox &>/dev/null; then
+        echo "  [OK] sox installed"
+    elif command -v ffmpeg &>/dev/null; then
+        echo "  [OK] ffmpeg installed (fallback)"
+    else
+        echo "  [--] No recording tool (install sox: brew install sox)"
+    fi
+}
+
+# CLI entry point
+main() {
+    local command="${1:-help}"
+    shift || true
+
+    case "$command" in
+        listen)
+            listen
+            ;;
+        speak)
+            if [[ $# -eq 0 ]]; then
+                log_error "Usage: voice.sh speak MESSAGE"
+                exit 1
+            fi
+            speak "$*"
+            ;;
+        dictate)
+            local output="${1:-prd-voice.md}"
+            dictate_to_file "$output"
+            ;;
+        status)
+            status
+            ;;
+        help|--help|-h)
+            echo "Loki Mode Voice Input"
+            echo ""
+            echo "Usage: voice.sh <command> [options]"
+            echo ""
+            echo "Commands:"
+            echo "  listen          Listen for voice input and return text"
+            echo "  speak MESSAGE   Text-to-speech output"
+            echo "  dictate [FILE]  Guided PRD dictation (default: prd-voice.md)"
+            echo "  status          Show voice capabilities"
+            echo ""
+            echo "Environment:"
+            echo "  OPENAI_API_KEY  Required for Whisper API transcription"
+            echo ""
+            echo "Setup:"
+            echo "  macOS: Enable Dictation in System Settings > Keyboard"
+            echo "  Linux: Install sox and whisper: apt install sox && pip install openai-whisper"
+            ;;
+        *)
+            log_error "Unknown command: $command"
+            echo "Run 'voice.sh help' for usage"
+            exit 1
+            ;;
+    esac
+}
+
+# Run if executed directly
+if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
+    main "$@"
+fi

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loki-mode",
-  "version": "5.13.1",
+  "version": "5.14.1",
   "description": "Multi-agent autonomous startup system for Claude Code, Codex CLI, and Gemini CLI",
   "keywords": [
     "claude",