loki-mode 5.8.8 → 5.9.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 zero human intervention. Requires --dangerously-skip-permissions flag.
 ---
 
-# Loki Mode v5.8.0
+# Loki Mode v5.9.0
 
 **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.8.0 | VS Code Chat and Logs views, enterprise security | ~250 lines core**
+**v5.9.0 | Cross-Project Learning, VS Code Chat and Logs views | ~250 lines core**

package/VERSION

@@ -1 +1 @@
-5.8.8
+5.9.0

package/autonomy/.loki/dashboard/index.html

@@ -1648,6 +1648,46 @@
                     </div>
                 </div>
 
+                <!-- Cross-Project Learnings -->
+                <div class="system-card">
+                    <div class="system-card-header">
+                        <span class="system-card-title">
+                            <svg width="14" height="14" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2" fill="none"><path d="M2 3h6a4 4 0 014 4v14a3 3 0 00-3-3H2z"/><path d="M22 3h-6a4 4 0 00-4 4v14a3 3 0 013-3h7z"/></svg>
+                            Cross-Project Learnings
+                        </span>
+                        <span class="system-card-status" id="learnings-status">--</span>
+                    </div>
+                    <div class="memory-bars">
+                        <div class="memory-bar">
+                            <div class="memory-bar-header">
+                                <span class="memory-bar-label">Patterns</span>
+                                <span class="memory-bar-value" id="learnings-patterns">0</span>
+                            </div>
+                            <div class="memory-bar-track">
+                                <div class="memory-bar-fill semantic" id="learnings-patterns-bar" style="width: 0%;"></div>
+                            </div>
+                        </div>
+                        <div class="memory-bar">
+                            <div class="memory-bar-header">
+                                <span class="memory-bar-label">Mistakes</span>
+                                <span class="memory-bar-value" id="learnings-mistakes">0</span>
+                            </div>
+                            <div class="memory-bar-track">
+                                <div class="memory-bar-fill episodic" id="learnings-mistakes-bar" style="width: 0%;"></div>
+                            </div>
+                        </div>
+                        <div class="memory-bar">
+                            <div class="memory-bar-header">
+                                <span class="memory-bar-label">Successes</span>
+                                <span class="memory-bar-value" id="learnings-successes">0</span>
+                            </div>
+                            <div class="memory-bar-track">
+                                <div class="memory-bar-fill procedural" id="learnings-successes-bar" style="width: 0%;"></div>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+
                 <!-- Quality Gates -->
                 <div class="system-card">
                     <div class="system-card-header">
@@ -1806,7 +1846,8 @@
         const CONFIG = {
             POLL_INTERVAL: 2000,       // Poll every 2 seconds
             STATE_FILE: '../dashboard-state.json',
-            LOCAL_STORAGE_KEY: 'loki-dashboard-local'
+            LOCAL_STORAGE_KEY: 'loki-dashboard-local',
+            API_URL: 'http://localhost:9898'  // Loki API server for cross-project learnings
         };
 
         // ============================================
@@ -1890,9 +1931,11 @@
         function startPolling() {
             fetchServerState();
             fetchTerminalLogs();
+            fetchLearnings();
             pollInterval = setInterval(() => {
                 fetchServerState();
                 fetchTerminalLogs();
+                fetchLearnings();
             }, CONFIG.POLL_INTERVAL);
         }
 
@@ -2418,6 +2461,64 @@
             }
         }
 
+        // ============================================
+        // Cross-Project Learnings (API)
+        // ============================================
+        async function fetchLearnings() {
+            try {
+                const response = await fetch(CONFIG.API_URL + '/memory');
+                if (!response.ok) {
+                    updateLearningsUI(null);
+                    return;
+                }
+                const data = await response.json();
+                updateLearningsUI(data);
+            } catch (error) {
+                // API server may not be running
+                updateLearningsUI(null);
+            }
+        }
+
+        function updateLearningsUI(data) {
+            const statusEl = document.getElementById('learnings-status');
+            const patternsEl = document.getElementById('learnings-patterns');
+            const mistakesEl = document.getElementById('learnings-mistakes');
+            const successesEl = document.getElementById('learnings-successes');
+            const patternsBar = document.getElementById('learnings-patterns-bar');
+            const mistakesBar = document.getElementById('learnings-mistakes-bar');
+            const successesBar = document.getElementById('learnings-successes-bar');
+
+            if (!data) {
+                statusEl.textContent = 'Offline';
+                statusEl.className = 'system-card-status warning';
+                return;
+            }
+
+            const patterns = data.patterns || 0;
+            const mistakes = data.mistakes || 0;
+            const successes = data.successes || 0;
+            const total = patterns + mistakes + successes;
+
+            patternsEl.textContent = patterns;
+            mistakesEl.textContent = mistakes;
+            successesEl.textContent = successes;
+
+            // Update progress bars (max 100 for percentage calc)
+            const maxLearnings = Math.max(100, total);
+            patternsBar.style.width = Math.min((patterns / maxLearnings) * 100, 100) + '%';
+            mistakesBar.style.width = Math.min((mistakes / maxLearnings) * 100, 100) + '%';
+            successesBar.style.width = Math.min((successes / maxLearnings) * 100, 100) + '%';
+
+            // Update status
+            if (total === 0) {
+                statusEl.textContent = 'No data';
+                statusEl.className = 'system-card-status';
+            } else {
+                statusEl.textContent = total + ' total';
+                statusEl.className = 'system-card-status healthy';
+            }
+        }
+
         // ============================================
         // GitHub Import
         // ============================================

package/autonomy/api-server.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
- * Loki Mode HTTP API Server (v1.0.0)
+ * Loki Mode HTTP API Server (v1.1.0)
  * Zero npm dependencies - uses only Node.js built-ins
  *
  * Usage:
@@ -8,14 +8,19 @@
  *   loki api start
  *
  * Endpoints:
- *   GET  /health    - Health check
- *   GET  /status    - Session status
- *   GET  /events    - SSE stream
- *   GET  /logs      - Recent log lines
- *   POST /start     - Start session
- *   POST /stop      - Stop session
- *   POST /pause     - Pause session
- *   POST /resume    - Resume session
+ *   GET  /health              - Health check
+ *   GET  /status              - Session status
+ *   GET  /events              - SSE stream
+ *   GET  /logs                - Recent log lines
+ *   POST /start               - Start session
+ *   POST /stop                - Stop session
+ *   POST /pause               - Pause session
+ *   POST /resume              - Resume session
+ *   GET  /memory              - Cross-project learnings summary
+ *   GET  /memory/:type        - Get learnings (patterns|mistakes|successes)
+ *   GET  /memory/search?q=    - Search learnings
+ *   GET  /memory/stats        - Statistics by project/category
+ *   DELETE /memory/:type      - Clear specific learning type
  */
 
 const http = require('http');
@@ -334,6 +339,115 @@ async function handleRequest(req, res) {
         return json({ resumed: true });
     }
 
+    // === Memory/Learnings endpoints ===
+    const LEARNINGS_DIR = path.join(process.env.HOME || '', '.loki', 'learnings');
+
+    if (method === 'GET' && pathname === '/memory') {
+        // List summary of all learnings
+        const result = { patterns: 0, mistakes: 0, successes: 0, location: LEARNINGS_DIR };
+
+        for (const type of ['patterns', 'mistakes', 'successes']) {
+            const filepath = path.join(LEARNINGS_DIR, `${type}.jsonl`);
+            if (fs.existsSync(filepath)) {
+                const content = fs.readFileSync(filepath, 'utf8');
+                const count = (content.match(/"description"/g) || []).length;
+                result[type] = count;
+            }
+        }
+        return json(result);
+    }
+
+    if (method === 'GET' && pathname.startsWith('/memory/search')) {
+        const query = url.searchParams.get('q') || '';
+        if (!query) {
+            return json({ error: 'Missing query parameter ?q=' }, 400);
+        }
+
+        const results = [];
+        const queryLower = query.toLowerCase();
+
+        for (const type of ['patterns', 'mistakes', 'successes']) {
+            const filepath = path.join(LEARNINGS_DIR, `${type}.jsonl`);
+            if (!fs.existsSync(filepath)) continue;
+
+            const lines = fs.readFileSync(filepath, 'utf8').split('\n');
+            for (const line of lines) {
+                if (!line.trim()) continue;
+                try {
+                    const entry = JSON.parse(line);
+                    if (entry.description && entry.description.toLowerCase().includes(queryLower)) {
+                        results.push({ type, ...entry });
+                    }
+                } catch {}
+            }
+        }
+        return json({ query, results, count: results.length });
+    }
+
+    if (method === 'GET' && pathname.match(/^\/memory\/(patterns|mistakes|successes)$/)) {
+        const type = pathname.split('/')[2];
+        const filepath = path.join(LEARNINGS_DIR, `${type}.jsonl`);
+        const limit = parseInt(url.searchParams.get('limit')) || 50;
+        const offset = parseInt(url.searchParams.get('offset')) || 0;
+
+        if (!fs.existsSync(filepath)) {
+            return json({ type, entries: [], total: 0 });
+        }
+
+        const entries = [];
+        const lines = fs.readFileSync(filepath, 'utf8').split('\n');
+        for (const line of lines) {
+            if (!line.trim()) continue;
+            try {
+                const entry = JSON.parse(line);
+                if (entry.description) {
+                    entries.push(entry);
+                }
+            } catch {}
+        }
+
+        const total = entries.length;
+        const paginated = entries.slice(offset, offset + limit);
+
+        return json({ type, entries: paginated, total, limit, offset });
+    }
+
+    if (method === 'GET' && pathname === '/memory/stats') {
+        const stats = { byCategory: {}, byProject: {} };
+
+        for (const type of ['patterns', 'mistakes', 'successes']) {
+            const filepath = path.join(LEARNINGS_DIR, `${type}.jsonl`);
+            if (!fs.existsSync(filepath)) continue;
+
+            const lines = fs.readFileSync(filepath, 'utf8').split('\n');
+            let count = 0;
+            for (const line of lines) {
+                if (!line.trim()) continue;
+                try {
+                    const entry = JSON.parse(line);
+                    if (entry.description) {
+                        count++;
+                        const proj = entry.project || 'unknown';
+                        stats.byProject[proj] = (stats.byProject[proj] || 0) + 1;
+                    }
+                } catch {}
+            }
+            stats.byCategory[type] = count;
+        }
+        return json(stats);
+    }
+
+    if (method === 'DELETE' && pathname.match(/^\/memory\/(patterns|mistakes|successes)$/)) {
+        const type = pathname.split('/')[2];
+        const filepath = path.join(LEARNINGS_DIR, `${type}.jsonl`);
+
+        fs.mkdirSync(LEARNINGS_DIR, { recursive: true });
+        const header = JSON.stringify({ version: '1.0', created: new Date().toISOString() });
+        fs.writeFileSync(filepath, header + '\n');
+
+        return json({ cleared: type });
+    }
+
     // 404 for unknown routes
     json({ error: 'not found', path: pathname }, 404);
 }
@@ -346,14 +460,18 @@ server.listen(PORT, () => {
     console.log(`Listening on http://localhost:${PORT}`);
     console.log('');
     console.log('Endpoints:');
-    console.log('  GET  /health  - Health check');
-    console.log('  GET  /status  - Session status');
-    console.log('  GET  /events  - SSE stream (real-time updates)');
-    console.log('  GET  /logs    - Recent log lines (?lines=50)');
-    console.log('  POST /start   - Start session');
-    console.log('  POST /stop    - Stop session');
-    console.log('  POST /pause   - Pause after current task');
-    console.log('  POST /resume  - Resume paused session');
+    console.log('  GET  /health           - Health check');
+    console.log('  GET  /status           - Session status');
+    console.log('  GET  /events           - SSE stream (real-time updates)');
+    console.log('  GET  /logs             - Recent log lines (?lines=50)');
+    console.log('  POST /start            - Start session');
+    console.log('  POST /stop             - Stop session');
+    console.log('  POST /pause            - Pause after current task');
+    console.log('  POST /resume           - Resume paused session');
+    console.log('  GET  /memory           - Cross-project learnings summary');
+    console.log('  GET  /memory/:type     - Get learnings by type');
+    console.log('  GET  /memory/search?q= - Search learnings');
+    console.log('  GET  /memory/stats     - Statistics');
     console.log('');
     console.log(`LOKI_DIR: ${LOKI_DIR}`);
     console.log(`SKILL_DIR: ${SKILL_DIR}`);

package/autonomy/loki

@@ -137,6 +137,8 @@ show_help() {
     echo "  sandbox [cmd]    Docker sandbox (start|stop|status|logs|shell|build)"
     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)"
+    echo "  reset [target]   Reset session state (all|retries|failed)"
     echo "  version          Show version"
     echo "  help             Show this help"
     echo ""
@@ -1127,6 +1129,9 @@ main() {
         reset)
             cmd_reset "$@"
             ;;
+        memory)
+            cmd_memory "$@"
+            ;;
         version|--version|-v)
             cmd_version
             ;;
@@ -1210,4 +1215,257 @@ with open('$LOKI_DIR/autonomy-state.json', 'w') as f:
     esac
 }
 
+# Cross-project memory/learnings management
+cmd_memory() {
+    local subcommand="${1:-list}"
+    local learnings_dir="${HOME}/.loki/learnings"
+
+    # Ensure directory exists
+    mkdir -p "$learnings_dir"
+
+    case "$subcommand" in
+        list|ls)
+            echo -e "${BOLD}Cross-Project Learnings${NC}"
+            echo ""
+
+            local patterns=0 mistakes=0 successes=0
+            [ -f "$learnings_dir/patterns.jsonl" ] && patterns=$(grep -c '"description"' "$learnings_dir/patterns.jsonl" 2>/dev/null) || patterns=0
+            [ -f "$learnings_dir/mistakes.jsonl" ] && mistakes=$(grep -c '"description"' "$learnings_dir/mistakes.jsonl" 2>/dev/null) || mistakes=0
+            [ -f "$learnings_dir/successes.jsonl" ] && successes=$(grep -c '"description"' "$learnings_dir/successes.jsonl" 2>/dev/null) || successes=0
+
+            echo -e "  Patterns:  ${GREEN}$patterns${NC}"
+            echo -e "  Mistakes:  ${YELLOW}$mistakes${NC}"
+            echo -e "  Successes: ${CYAN}$successes${NC}"
+            echo ""
+            echo "Location: $learnings_dir"
+            echo ""
+            echo "Use 'loki memory show <type>' to view entries"
+            ;;
+
+        show)
+            local type="${2:-all}"
+
+            case "$type" in
+                patterns|pattern)
+                    echo -e "${BOLD}Patterns${NC}"
+                    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+                    if [ -f "$learnings_dir/patterns.jsonl" ]; then
+                        python3 -c "
+import json
+with open('$learnings_dir/patterns.jsonl', 'r') as f:
+    for line in f:
+        try:
+            e = json.loads(line)
+            if 'description' in e:
+                print(f\"[{e.get('project', 'unknown')}] {e['description'][:100]}\")
+        except: pass
+" 2>/dev/null || echo "No patterns found"
+                    fi
+                    ;;
+
+                mistakes|mistake)
+                    echo -e "${BOLD}Mistakes${NC}"
+                    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+                    if [ -f "$learnings_dir/mistakes.jsonl" ]; then
+                        python3 -c "
+import json
+with open('$learnings_dir/mistakes.jsonl', 'r') as f:
+    for line in f:
+        try:
+            e = json.loads(line)
+            if 'description' in e:
+                print(f\"[{e.get('project', 'unknown')}] {e['description'][:100]}\")
+        except: pass
+" 2>/dev/null | tail -20 || echo "No mistakes found"
+                    fi
+                    ;;
+
+                successes|success)
+                    echo -e "${BOLD}Successes${NC}"
+                    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+                    if [ -f "$learnings_dir/successes.jsonl" ]; then
+                        python3 -c "
+import json
+with open('$learnings_dir/successes.jsonl', 'r') as f:
+    for line in f:
+        try:
+            e = json.loads(line)
+            if 'description' in e:
+                print(f\"[{e.get('project', 'unknown')}] {e['description'][:100]}\")
+        except: pass
+" 2>/dev/null | tail -20 || echo "No successes found"
+                    fi
+                    ;;
+
+                all|*)
+                    cmd_memory show patterns
+                    echo ""
+                    cmd_memory show mistakes
+                    echo ""
+                    cmd_memory show successes
+                    ;;
+            esac
+            ;;
+
+        search)
+            local query="$2"
+            if [ -z "$query" ]; then
+                echo -e "${RED}Usage: loki memory search <query>${NC}"
+                exit 1
+            fi
+
+            echo -e "${BOLD}Search Results for: $query${NC}"
+            echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+
+            python3 -c "
+import json
+import os
+
+learnings_dir = '$learnings_dir'
+query = '$query'.lower()
+
+for filename in ['patterns.jsonl', 'mistakes.jsonl', 'successes.jsonl']:
+    filepath = os.path.join(learnings_dir, filename)
+    if not os.path.exists(filepath):
+        continue
+
+    category = filename.replace('.jsonl', '')
+    with open(filepath, 'r') as f:
+        for line in f:
+            try:
+                e = json.loads(line)
+                desc = e.get('description', '').lower()
+                if query in desc:
+                    print(f\"[{category}] [{e.get('project', 'unknown')}] {e['description'][:80]}...\")
+            except: pass
+" 2>/dev/null
+            ;;
+
+        clear)
+            local type="${2:-}"
+
+            if [ -z "$type" ]; then
+                echo -e "${YELLOW}This will delete ALL cross-project learnings.${NC}"
+                echo -n "Are you sure? (yes/no): "
+                read -r confirm
+                if [ "$confirm" = "yes" ]; then
+                    rm -rf "$learnings_dir"
+                    mkdir -p "$learnings_dir"
+                    echo '{"version":"1.0","created":"'"$(date -u +%Y-%m-%dT%H:%M:%SZ)"'"}' > "$learnings_dir/patterns.jsonl"
+                    echo '{"version":"1.0","created":"'"$(date -u +%Y-%m-%dT%H:%M:%SZ)"'"}' > "$learnings_dir/mistakes.jsonl"
+                    echo '{"version":"1.0","created":"'"$(date -u +%Y-%m-%dT%H:%M:%SZ)"'"}' > "$learnings_dir/successes.jsonl"
+                    echo -e "${GREEN}All learnings cleared${NC}"
+                else
+                    echo "Cancelled"
+                fi
+            else
+                case "$type" in
+                    patterns|mistakes|successes)
+                        echo '{"version":"1.0","created":"'"$(date -u +%Y-%m-%dT%H:%M:%SZ)"'"}' > "$learnings_dir/${type}.jsonl"
+                        echo -e "${GREEN}Cleared $type${NC}"
+                        ;;
+                    *)
+                        echo -e "${RED}Unknown type: $type${NC}"
+                        echo "Valid types: patterns, mistakes, successes"
+                        exit 1
+                        ;;
+                esac
+            fi
+            ;;
+
+        export)
+            local output="${2:-learnings-export.json}"
+
+            python3 -c "
+import json
+import os
+
+learnings_dir = '$learnings_dir'
+result = {'patterns': [], 'mistakes': [], 'successes': []}
+
+for category in ['patterns', 'mistakes', 'successes']:
+    filepath = os.path.join(learnings_dir, f'{category}.jsonl')
+    if os.path.exists(filepath):
+        with open(filepath, 'r') as f:
+            for line in f:
+                try:
+                    e = json.loads(line)
+                    if 'description' in e:
+                        result[category].append(e)
+                except: pass
+
+with open('$output', 'w') as f:
+    json.dump(result, f, indent=2)
+print(f'Exported to $output')
+" 2>/dev/null
+            ;;
+
+        stats)
+            echo -e "${BOLD}Learning Statistics${NC}"
+            echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+
+            python3 -c "
+import json
+import os
+from collections import Counter
+
+learnings_dir = '$learnings_dir'
+projects = Counter()
+categories = Counter()
+
+for filename in ['patterns.jsonl', 'mistakes.jsonl', 'successes.jsonl']:
+    filepath = os.path.join(learnings_dir, filename)
+    if not os.path.exists(filepath):
+        continue
+
+    category = filename.replace('.jsonl', '')
+    with open(filepath, 'r') as f:
+        for line in f:
+            try:
+                e = json.loads(line)
+                if 'description' in e:
+                    projects[e.get('project', 'unknown')] += 1
+                    categories[category] += 1
+            except: pass
+
+print('By Category:')
+for cat, count in categories.most_common():
+    print(f'  {cat}: {count}')
+
+print()
+print('By Project:')
+for proj, count in projects.most_common(10):
+    print(f'  {proj}: {count}')
+" 2>/dev/null
+            ;;
+
+        --help|-h|help)
+            echo -e "${BOLD}loki memory${NC} - Manage cross-project learnings"
+            echo ""
+            echo "Usage: loki memory <command> [args]"
+            echo ""
+            echo "Commands:"
+            echo "  list              Show summary of all learnings"
+            echo "  show [type]       Show entries (patterns|mistakes|successes|all)"
+            echo "  search <query>    Search across all learnings"
+            echo "  stats             Show statistics by project and category"
+            echo "  export [file]     Export to JSON file"
+            echo "  clear [type]      Clear learnings (all or specific type)"
+            echo ""
+            echo "Examples:"
+            echo "  loki memory list"
+            echo "  loki memory show mistakes"
+            echo "  loki memory search 'rate limit'"
+            echo "  loki memory stats"
+            echo "  loki memory export backup.json"
+            ;;
+
+        *)
+            echo -e "${RED}Unknown memory command: $subcommand${NC}"
+            echo "Run 'loki memory help' for usage."
+            exit 1
+            ;;
+    esac
+}
+
 main "$@"

package/autonomy/run.sh

@@ -3071,15 +3071,17 @@ extract_learnings_from_session() {
 
     log_info "Extracting learnings from session..."
 
-    # Parse CONTINUITY.md for Mistakes & Learnings section
-    python3 << EXTRACT_SCRIPT
+    # Parse CONTINUITY.md for all learning types
+    python3 << 'EXTRACT_SCRIPT'
 import re
 import json
 import os
+import hashlib
 from datetime import datetime, timezone
 
 continuity_file = ".loki/CONTINUITY.md"
 learnings_dir = os.path.expanduser("~/.loki/learnings")
+os.makedirs(learnings_dir, exist_ok=True)
 
 if not os.path.exists(continuity_file):
     exit(0)
@@ -3087,22 +3089,95 @@ if not os.path.exists(continuity_file):
 with open(continuity_file, 'r') as f:
     content = f.read()
 
-# Find Mistakes & Learnings section
+project = os.path.basename(os.getcwd())
+timestamp = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
+
+def get_existing_hashes(filepath):
+    """Get hashes of existing entries to avoid duplicates"""
+    hashes = set()
+    if os.path.exists(filepath):
+        with open(filepath, 'r') as f:
+            for line in f:
+                try:
+                    entry = json.loads(line)
+                    if 'description' in entry:
+                        h = hashlib.md5(entry['description'].encode()).hexdigest()
+                        hashes.add(h)
+                except:
+                    continue
+    return hashes
+
+def save_entries(filepath, entries, category):
+    """Save entries avoiding duplicates"""
+    existing = get_existing_hashes(filepath)
+    saved = 0
+    with open(filepath, 'a') as f:
+        for desc in entries:
+            h = hashlib.md5(desc.encode()).hexdigest()
+            if h not in existing:
+                entry = {
+                    "timestamp": timestamp,
+                    "project": project,
+                    "category": category,
+                    "description": desc.strip()
+                }
+                f.write(json.dumps(entry) + "\n")
+                existing.add(h)
+                saved += 1
+    return saved
+
+def extract_bullets(text):
+    """Extract bullet points from text"""
+    return [b.strip() for b in re.findall(r'[-*]\s+(.+)', text) if b.strip()]
+
+# === Extract Mistakes & Learnings ===
 mistakes_match = re.search(r'## Mistakes & Learnings\n(.*?)(?=\n## |\Z)', content, re.DOTALL)
 if mistakes_match:
-    mistakes_text = mistakes_match.group(1)
-    # Extract bullet points
-    bullets = re.findall(r'[-*]\s+(.+)', mistakes_text)
-    for bullet in bullets:
-        entry = {
-            "timestamp": datetime.now(timezone.utc).isoformat().replace("+00:00", "Z"),
-            "project": os.path.basename(os.getcwd()),
-            "category": "session",
-            "description": bullet.strip()
-        }
-        with open(f"{learnings_dir}/mistakes.jsonl", 'a') as f:
-            f.write(json.dumps(entry) + "\n")
-        print(f"Extracted: {bullet[:50]}...")
+    bullets = extract_bullets(mistakes_match.group(1))
+    saved = save_entries(f"{learnings_dir}/mistakes.jsonl", bullets, "session")
+    if saved > 0:
+        print(f"Extracted {saved} new mistakes")
+
+# === Extract Patterns (from various sections) ===
+pattern_sections = [
+    r'## Patterns Used\n(.*?)(?=\n## |\Z)',
+    r'## Solutions Applied\n(.*?)(?=\n## |\Z)',
+    r'## Key Approaches\n(.*?)(?=\n## |\Z)',
+    r'## What Worked\n(.*?)(?=\n## |\Z)',
+]
+patterns = []
+for pattern in pattern_sections:
+    match = re.search(pattern, content, re.DOTALL)
+    if match:
+        patterns.extend(extract_bullets(match.group(1)))
+
+# Also extract lines starting with "Pattern:" or "Solution:"
+patterns.extend(re.findall(r'(?:Pattern|Solution|Approach):\s*(.+)', content))
+
+if patterns:
+    saved = save_entries(f"{learnings_dir}/patterns.jsonl", patterns, "session")
+    if saved > 0:
+        print(f"Extracted {saved} new patterns")
+
+# === Extract Successes (completed tasks) ===
+success_sections = [
+    r'## Completed Tasks\n(.*?)(?=\n## |\Z)',
+    r'## Achievements\n(.*?)(?=\n## |\Z)',
+    r'## Done\n(.*?)(?=\n## |\Z)',
+]
+successes = []
+for pattern in success_sections:
+    match = re.search(pattern, content, re.DOTALL)
+    if match:
+        successes.extend(extract_bullets(match.group(1)))
+
+# Also extract [x] completed checkboxes
+successes.extend(re.findall(r'\[x\]\s+(.+)', content, re.IGNORECASE))
+
+if successes:
+    saved = save_entries(f"{learnings_dir}/successes.jsonl", successes, "session")
+    if saved > 0:
+        print(f"Extracted {saved} new successes")
 
 print("Learning extraction complete")
 EXTRACT_SCRIPT

package/package.json

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