loki-mode 5.29.0 → 5.30.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.29.0
+# Loki Mode v5.30.0
 
 **You are an autonomous agent. You make decisions. You do not ask questions. You do not stop.**
 
@@ -62,7 +62,11 @@ REFLECT: Did it work? Update CONTINUITY.md with outcome.
    v
 VERIFY: Run tests. Check build. Validate against spec.
    |
-   +--[PASS]--> Mark task complete. Return to REASON.
+   +--[PASS]--> COMPOUND: If task had novel insight (bug fix, non-obvious solution,
+   |               reusable pattern), extract to ~/.loki/solutions/{category}/{slug}.md
+   |               with YAML frontmatter (title, tags, symptoms, root_cause, prevention).
+   |               See skills/compound-learning.md for format.
+   |               Then mark task complete. Return to REASON.
    |
    +--[FAIL]--> Capture error in "Mistakes & Learnings".
                Rollback if needed. Retry with new approach.
@@ -119,7 +123,8 @@ These rules are ABSOLUTE. Violating them is a critical failure.
 ```
 BOOTSTRAP ──[project initialized]──> DISCOVERY
 DISCOVERY ──[PRD analyzed, requirements clear]──> ARCHITECTURE
-ARCHITECTURE ──[design approved, specs written]──> INFRASTRUCTURE
+ARCHITECTURE ──[design approved, specs written]──> DEEPEN_PLAN (standard/complex only)
+DEEPEN_PLAN ──[plan enhanced by 4 research agents]──> INFRASTRUCTURE
 INFRASTRUCTURE ──[cloud/DB ready]──> DEVELOPMENT
 DEVELOPMENT ──[features complete, unit tests pass]──> QA
 QA ──[all tests pass, security clean]──> DEPLOYMENT
@@ -177,6 +182,8 @@ GROWTH ──[continuous improvement loop]──> GROWTH
    - Debugging? Load troubleshooting.md
    - Deploying? Load production.md
    - Parallel features? Load parallel-workflows.md
+   - Architecture planning? Load compound-learning.md (deepen-plan)
+   - Post-verification? Load compound-learning.md (knowledge extraction)
 3. Read the selected module(s)
 4. Execute with that context
 5. When task category changes: Load new modules (old context discarded)
@@ -260,4 +267,4 @@ Auto-detected or force with `LOKI_COMPLEXITY`:
 
 ---
 
-**v5.29.0 | Demo, quick mode, init, cost dashboard, 12 templates, GitHub Action | ~270 lines core**
+**v5.30.0 | Compound learning, specialist reviewers, deepen-plan | ~280 lines core**

package/VERSION

@@ -1 +1 @@
-5.29.0
+5.30.0

package/autonomy/loki

@@ -318,6 +318,7 @@ show_help() {
     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 "  compound [cmd]   Knowledge compounding (list|show|search|run|stats)"
     echo "  council [cmd]    Completion council (status|verdicts|convergence|force-review|report)"
     echo "  dogfood          Show self-development statistics"
     echo "  reset [target]   Reset session state (all|retries|failed)"
@@ -3546,6 +3547,9 @@ main() {
         memory)
             cmd_memory "$@"
             ;;
+        compound)
+            cmd_compound "$@"
+            ;;
         council)
             cmd_council "$@"
             ;;
@@ -4541,6 +4545,282 @@ except Exception as e:
     esac
 }
 
+# Knowledge Compounding - Structured Solutions (v5.30.0)
+# Inspired by Compound Engineering Plugin's docs/solutions/ with YAML frontmatter
+cmd_compound() {
+    local subcommand="${1:-help}"
+    shift 2>/dev/null || true
+
+    local solutions_dir="${HOME}/.loki/solutions"
+
+    case "$subcommand" in
+        list|ls)
+            echo -e "${BOLD}Compound Solutions${NC}"
+            echo ""
+
+            if [ ! -d "$solutions_dir" ]; then
+                echo "  No solutions yet. Solutions are created automatically during"
+                echo "  Loki sessions or manually with 'loki compound run'."
+                echo ""
+                echo "  Location: $solutions_dir"
+                return
+            fi
+
+            local total=0
+            for category in security performance architecture testing debugging deployment general; do
+                local cat_dir="$solutions_dir/$category"
+                if [ -d "$cat_dir" ]; then
+                    local count=$(find "$cat_dir" -name "*.md" 2>/dev/null | wc -l | tr -d ' ')
+                    if [ "$count" -gt 0 ]; then
+                        printf "  %-16s ${GREEN}%d${NC} solutions\n" "$category" "$count"
+                        total=$((total + count))
+                    fi
+                fi
+            done
+
+            if [ "$total" -eq 0 ]; then
+                echo "  No solutions yet."
+            else
+                echo ""
+                echo "  Total: ${total} solutions"
+            fi
+            echo ""
+            echo "  Location: $solutions_dir"
+            echo ""
+            echo "  Use 'loki compound show <category>' to view solutions"
+            ;;
+
+        show)
+            local category="${1:-}"
+            if [ -z "$category" ]; then
+                echo -e "${RED}Error: Specify a category${NC}"
+                echo "Categories: security, performance, architecture, testing, debugging, deployment, general"
+                return 1
+            fi
+
+            local cat_dir="$solutions_dir/$category"
+            if [ ! -d "$cat_dir" ]; then
+                echo "No solutions in category: $category"
+                return
+            fi
+
+            echo -e "${BOLD}Solutions: $category${NC}"
+            echo ""
+
+            for file in "$cat_dir"/*.md; do
+                [ -f "$file" ] || continue
+                # Extract title from YAML frontmatter
+                local title=$(grep '^title:' "$file" 2>/dev/null | head -1 | sed 's/title: *"//;s/"$//')
+                local confidence=$(grep '^confidence:' "$file" 2>/dev/null | head -1 | sed 's/confidence: *//')
+                local project=$(grep '^source_project:' "$file" 2>/dev/null | head -1 | sed 's/source_project: *"//;s/"$//')
+                echo -e "  ${GREEN}*${NC} ${title:-$(basename "$file" .md)}"
+                [ -n "$confidence" ] && echo -e "    confidence: ${confidence}  project: ${project:-unknown}"
+            done
+            echo ""
+            ;;
+
+        search)
+            local query="${1:-}"
+            if [ -z "$query" ]; then
+                echo -e "${RED}Error: Specify a search query${NC}"
+                echo "Usage: loki compound search <query>"
+                return 1
+            fi
+
+            echo -e "${BOLD}Searching solutions for: ${query}${NC}"
+            echo ""
+
+            if [ ! -d "$solutions_dir" ]; then
+                echo "No solutions directory found."
+                return
+            fi
+
+            local found=0
+            while IFS= read -r file; do
+                local title=$(grep '^title:' "$file" 2>/dev/null | head -1 | sed 's/title: *"//;s/"$//')
+                local category=$(grep '^category:' "$file" 2>/dev/null | head -1 | sed 's/category: *//')
+                echo -e "  [${CYAN}${category}${NC}] ${title:-$(basename "$file" .md)}"
+                echo -e "    ${DIM}${file}${NC}"
+                found=$((found + 1))
+            done < <(grep -rl "$query" "$solutions_dir" 2>/dev/null || true)
+
+            if [ "$found" -eq 0 ]; then
+                echo "  No solutions matching: $query"
+            else
+                echo ""
+                echo "  Found: ${found} solutions"
+            fi
+            ;;
+
+        run)
+            echo -e "${BOLD}Compounding learnings into solutions...${NC}"
+            echo ""
+
+            local learnings_dir="${HOME}/.loki/learnings"
+            if [ ! -d "$learnings_dir" ]; then
+                echo "  No learnings directory found at: $learnings_dir"
+                echo "  Run a Loki session first to generate learnings."
+                return
+            fi
+
+            python3 << 'COMPOUND_RUN_SCRIPT'
+import json, os, re
+from datetime import datetime, timezone
+from collections import defaultdict
+learnings_dir = os.path.expanduser("~/.loki/learnings")
+solutions_dir = os.path.expanduser("~/.loki/solutions")
+CATEGORIES = ["security", "performance", "architecture", "testing", "debugging", "deployment", "general"]
+CATEGORY_KEYWORDS = {
+    "security": ["auth", "login", "password", "token", "injection", "xss", "csrf", "cors", "secret", "encrypt", "permission"],
+    "performance": ["cache", "query", "n+1", "memory", "leak", "slow", "timeout", "pool", "index", "optimize", "bundle"],
+    "architecture": ["pattern", "solid", "coupling", "abstraction", "module", "interface", "design", "refactor", "structure"],
+    "testing": ["test", "mock", "fixture", "coverage", "assert", "spec", "e2e", "playwright", "jest", "flaky"],
+    "debugging": ["debug", "error", "trace", "log", "stack", "crash", "exception", "breakpoint", "inspect"],
+    "deployment": ["deploy", "docker", "ci", "cd", "pipeline", "kubernetes", "nginx", "ssl", "domain", "env", "config"],
+}
+def load_jsonl(filepath):
+    entries = []
+    if not os.path.exists(filepath): return entries
+    with open(filepath, 'r') as f:
+        for line in f:
+            try:
+                entry = json.loads(line)
+                if 'description' in entry: entries.append(entry)
+            except: continue
+    return entries
+def classify_category(description):
+    desc_lower = description.lower()
+    scores = {cat: sum(1 for kw in kws if kw in desc_lower) for cat, kws in CATEGORY_KEYWORDS.items()}
+    best = max(scores, key=scores.get)
+    return best if scores[best] > 0 else "general"
+def slugify(text):
+    return re.sub(r'[^a-z0-9]+', '-', text.lower().strip()).strip('-')[:80]
+def solution_exists(solutions_dir, title_slug):
+    for cat in CATEGORIES:
+        cat_dir = os.path.join(solutions_dir, cat)
+        if os.path.exists(cat_dir) and os.path.exists(os.path.join(cat_dir, f"{title_slug}.md")):
+            return True
+    return False
+patterns = load_jsonl(os.path.join(learnings_dir, "patterns.jsonl"))
+mistakes = load_jsonl(os.path.join(learnings_dir, "mistakes.jsonl"))
+successes = load_jsonl(os.path.join(learnings_dir, "successes.jsonl"))
+print(f"  Loaded: {len(patterns)} patterns, {len(mistakes)} mistakes, {len(successes)} successes")
+grouped = defaultdict(list)
+for entry in patterns + mistakes + successes:
+    grouped[classify_category(entry.get('description', ''))].append(entry)
+created = 0
+now = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
+for category, entries in grouped.items():
+    if len(entries) < 2: continue
+    cat_dir = os.path.join(solutions_dir, category)
+    os.makedirs(cat_dir, exist_ok=True)
+    best_entry = max(entries, key=lambda e: len(e.get('description', '')))
+    title = best_entry['description'][:120]
+    slug = slugify(title)
+    if solution_exists(solutions_dir, slug): continue
+    all_words = ' '.join(e.get('description', '') for e in entries).lower()
+    tags = []
+    for kw_list in CATEGORY_KEYWORDS.values():
+        for kw in kw_list:
+            if kw in all_words and kw not in tags: tags.append(kw)
+    tags = tags[:8]
+    symptoms = [e.get('description', '')[:200] for e in entries
+                if any(w in e.get('description', '').lower() for w in ['error', 'fail', 'bug', 'crash', 'issue'])][:4]
+    if not symptoms: symptoms = [entries[0].get('description', '')[:200]]
+    solution_lines = [f"- {e.get('description', '')}" for e in entries
+                      if not any(w in e.get('description', '').lower() for w in ['error', 'fail', 'bug', 'crash'])]
+    if not solution_lines: solution_lines = [f"- {entries[0].get('description', '')}"]
+    project = best_entry.get('project', os.path.basename(os.getcwd()))
+    filepath = os.path.join(cat_dir, f"{slug}.md")
+    with open(filepath, 'w') as f:
+        f.write(f"---\ntitle: \"{title}\"\ncategory: {category}\ntags: [{', '.join(tags)}]\nsymptoms:\n")
+        for s in symptoms: f.write(f'  - "{s}"\n')
+        f.write(f'root_cause: "Identified from {len(entries)} related learnings"\n')
+        f.write(f'prevention: "See solution details below"\nconfidence: {min(0.5 + 0.1 * len(entries), 0.95):.2f}\n')
+        f.write(f'source_project: "{project}"\ncreated: "{now}"\napplied_count: 0\n---\n\n')
+        f.write("## Solution\n\n" + '\n'.join(solution_lines) + '\n\n')
+        f.write(f"## Context\n\nCompounded from {len(entries)} learnings from project: {project}\n")
+    created += 1
+    print(f"  Created: {category}/{slug}.md")
+if created > 0: print(f"\n  Compounded {created} new solution files to {solutions_dir}")
+else: print("  No new solutions to compound (need 2+ related learnings per category)")
+COMPOUND_RUN_SCRIPT
+            ;;
+
+        stats)
+            echo -e "${BOLD}Compound Solution Statistics${NC}"
+            echo ""
+
+            if [ ! -d "$solutions_dir" ]; then
+                echo "  No solutions directory found."
+                return
+            fi
+
+            local total=0
+            local newest=""
+            local oldest=""
+
+            for category in security performance architecture testing debugging deployment general; do
+                local cat_dir="$solutions_dir/$category"
+                if [ -d "$cat_dir" ]; then
+                    local count=$(find "$cat_dir" -name "*.md" 2>/dev/null | wc -l | tr -d ' ')
+                    total=$((total + count))
+                fi
+            done
+
+            echo "  Total solutions: ${total}"
+
+            if [ "$total" -gt 0 ]; then
+                # Find newest and oldest
+                newest=$(find "$solutions_dir" -name "*.md" -exec stat -f '%m %N' {} \; 2>/dev/null | sort -rn | head -1 | cut -d' ' -f2-)
+                oldest=$(find "$solutions_dir" -name "*.md" -exec stat -f '%m %N' {} \; 2>/dev/null | sort -n | head -1 | cut -d' ' -f2-)
+
+                if [ -n "$newest" ]; then
+                    local newest_title=$(grep '^title:' "$newest" 2>/dev/null | head -1 | sed 's/title: *"//;s/"$//')
+                    echo "  Newest: ${newest_title:-$(basename "$newest" .md)}"
+                fi
+                if [ -n "$oldest" ]; then
+                    local oldest_title=$(grep '^title:' "$oldest" 2>/dev/null | head -1 | sed 's/title: *"//;s/"$//')
+                    echo "  Oldest: ${oldest_title:-$(basename "$oldest" .md)}"
+                fi
+            fi
+
+            echo ""
+            echo "  Location: $solutions_dir"
+            ;;
+
+        help|--help|-h)
+            echo -e "${BOLD}loki compound${NC} - Knowledge compounding system"
+            echo ""
+            echo "Extracts structured solutions from cross-project learnings."
+            echo "Solutions are stored as markdown files with YAML frontmatter"
+            echo "at ~/.loki/solutions/{category}/ and fed back into future planning."
+            echo ""
+            echo "Usage: loki compound <command>"
+            echo ""
+            echo "Commands:"
+            echo "  list              List all solutions by category"
+            echo "  show <category>   Show solutions in a category"
+            echo "  search <query>    Search across all solutions"
+            echo "  run               Manually compound current learnings into solutions"
+            echo "  stats             Solution statistics"
+            echo "  help              Show this help"
+            echo ""
+            echo "Categories: security, performance, architecture, testing,"
+            echo "            debugging, deployment, general"
+            echo ""
+            echo "Solutions are created automatically at session end and"
+            echo "loaded during the REASON phase for relevant tasks."
+            ;;
+
+        *)
+            echo -e "${RED}Unknown compound command: $subcommand${NC}"
+            echo "Run 'loki compound help' for usage."
+            return 1
+            ;;
+    esac
+}
+
 # Completion Council management
 cmd_council() {
     local subcommand="${1:-status}"

package/autonomy/run.sh

@@ -3599,6 +3599,264 @@ print("Learning extraction complete")
 EXTRACT_SCRIPT
 }
 
+# ============================================================================
+# Knowledge Compounding - Structured Solutions (v5.30.0)
+# Inspired by Compound Engineering Plugin's docs/solutions/ with YAML frontmatter
+# ============================================================================
+
+compound_session_to_solutions() {
+    # Compound JSONL learnings into structured solution markdown files
+    local learnings_dir="${HOME}/.loki/learnings"
+    local solutions_dir="${HOME}/.loki/solutions"
+
+    if [ ! -d "$learnings_dir" ]; then
+        return
+    fi
+
+    log_info "Compounding learnings into structured solutions..."
+
+    python3 << 'COMPOUND_SCRIPT'
+import json
+import os
+import re
+import hashlib
+from datetime import datetime, timezone
+from collections import defaultdict
+
+learnings_dir = os.path.expanduser("~/.loki/learnings")
+solutions_dir = os.path.expanduser("~/.loki/solutions")
+
+# Fixed categories
+CATEGORIES = ["security", "performance", "architecture", "testing", "debugging", "deployment", "general"]
+
+# Category keyword mapping
+CATEGORY_KEYWORDS = {
+    "security": ["auth", "login", "password", "token", "injection", "xss", "csrf", "cors", "secret", "encrypt", "permission", "role", "session", "cookie", "oauth", "jwt"],
+    "performance": ["cache", "query", "n+1", "memory", "leak", "slow", "timeout", "pool", "index", "optimize", "bundle", "lazy", "render", "batch"],
+    "architecture": ["pattern", "solid", "coupling", "abstraction", "module", "interface", "design", "refactor", "structure", "layer", "separation", "dependency"],
+    "testing": ["test", "mock", "fixture", "coverage", "assert", "spec", "e2e", "playwright", "jest", "flaky", "snapshot"],
+    "debugging": ["debug", "error", "trace", "log", "stack", "crash", "exception", "breakpoint", "inspect", "diagnose"],
+    "deployment": ["deploy", "docker", "ci", "cd", "pipeline", "kubernetes", "k8s", "nginx", "ssl", "domain", "env", "config", "build"],
+}
+
+def load_jsonl(filepath):
+    entries = []
+    if not os.path.exists(filepath):
+        return entries
+    with open(filepath, 'r') as f:
+        for line in f:
+            try:
+                entry = json.loads(line)
+                if 'description' in entry:
+                    entries.append(entry)
+            except:
+                continue
+    return entries
+
+def classify_category(description):
+    desc_lower = description.lower()
+    scores = {}
+    for cat, keywords in CATEGORY_KEYWORDS.items():
+        scores[cat] = sum(1 for kw in keywords if kw in desc_lower)
+    best = max(scores, key=scores.get)
+    return best if scores[best] > 0 else "general"
+
+def slugify(text):
+    slug = re.sub(r'[^a-z0-9]+', '-', text.lower().strip())
+    return slug.strip('-')[:80]
+
+def solution_exists(solutions_dir, title_slug):
+    for cat in CATEGORIES:
+        cat_dir = os.path.join(solutions_dir, cat)
+        if os.path.exists(cat_dir):
+            if os.path.exists(os.path.join(cat_dir, f"{title_slug}.md")):
+                return True
+    return False
+
+# Load all learnings
+patterns = load_jsonl(os.path.join(learnings_dir, "patterns.jsonl"))
+mistakes = load_jsonl(os.path.join(learnings_dir, "mistakes.jsonl"))
+successes = load_jsonl(os.path.join(learnings_dir, "successes.jsonl"))
+
+# Group by category
+grouped = defaultdict(list)
+for entry in patterns + mistakes + successes:
+    cat = classify_category(entry.get('description', ''))
+    grouped[cat].append(entry)
+
+created = 0
+now = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
+
+for category, entries in grouped.items():
+    if len(entries) < 2:
+        continue  # Need at least 2 related entries to compound
+
+    # Create category directory
+    cat_dir = os.path.join(solutions_dir, category)
+    os.makedirs(cat_dir, exist_ok=True)
+
+    # Group similar entries (simple: by shared keywords)
+    # Take the most descriptive entry as the title
+    best_entry = max(entries, key=lambda e: len(e.get('description', '')))
+    title = best_entry['description'][:120]
+    slug = slugify(title)
+
+    if solution_exists(solutions_dir, slug):
+        continue  # Already compounded
+
+    # Extract tags from all entries
+    all_words = ' '.join(e.get('description', '') for e in entries).lower()
+    tags = []
+    for kw_list in CATEGORY_KEYWORDS.values():
+        for kw in kw_list:
+            if kw in all_words and kw not in tags:
+                tags.append(kw)
+    tags = tags[:8]  # Limit to 8 tags
+
+    # Build symptoms from mistake entries
+    symptoms = []
+    for e in entries:
+        desc = e.get('description', '')
+        if any(w in desc.lower() for w in ['error', 'fail', 'bug', 'crash', 'issue', 'problem']):
+            symptoms.append(desc[:200])
+    symptoms = symptoms[:4]
+    if not symptoms:
+        symptoms = [entries[0].get('description', '')[:200]]
+
+    # Build solution content from pattern/success entries
+    solution_lines = []
+    for e in entries:
+        desc = e.get('description', '')
+        if not any(w in desc.lower() for w in ['error', 'fail', 'bug', 'crash']):
+            solution_lines.append(f"- {desc}")
+    if not solution_lines:
+        solution_lines = [f"- {entries[0].get('description', '')}"]
+
+    project = best_entry.get('project', os.path.basename(os.getcwd()))
+
+    # Write solution file
+    filepath = os.path.join(cat_dir, f"{slug}.md")
+    with open(filepath, 'w') as f:
+        f.write(f"---\n")
+        f.write(f'title: "{title}"\n')
+        f.write(f"category: {category}\n")
+        f.write(f"tags: [{', '.join(tags)}]\n")
+        f.write(f"symptoms:\n")
+        for s in symptoms:
+            f.write(f'  - "{s}"\n')
+        f.write(f'root_cause: "Identified from {len(entries)} related learnings across sessions"\n')
+        f.write(f'prevention: "See solution details below"\n')
+        f.write(f"confidence: {min(0.5 + 0.1 * len(entries), 0.95):.2f}\n")
+        f.write(f'source_project: "{project}"\n')
+        f.write(f'created: "{now}"\n')
+        f.write(f"applied_count: 0\n")
+        f.write(f"---\n\n")
+        f.write(f"## Solution\n\n")
+        f.write('\n'.join(solution_lines) + '\n\n')
+        f.write(f"## Context\n\n")
+        f.write(f"Compounded from {len(entries)} learnings ")
+        f.write(f"({len([e for e in entries if e in patterns])} patterns, ")
+        f.write(f"{len([e for e in entries if e in mistakes])} mistakes, ")
+        f.write(f"{len([e for e in entries if e in successes])} successes) ")
+        f.write(f"from project: {project}\n")
+
+    created += 1
+
+if created > 0:
+    print(f"Compounded {created} new solution files to {solutions_dir}")
+else:
+    print("No new solutions to compound (need 2+ related learnings per category)")
+COMPOUND_SCRIPT
+}
+
+load_solutions_context() {
+    # Load relevant structured solutions for the current task context
+    local context="$1"
+    local solutions_dir="${HOME}/.loki/solutions"
+    local output_file=".loki/state/relevant-solutions.json"
+
+    if [ ! -d "$solutions_dir" ]; then
+        echo '{"solutions":[]}' > "$output_file" 2>/dev/null || true
+        return
+    fi
+
+    export LOKI_SOL_CONTEXT="$context"
+    python3 << 'SOLUTIONS_SCRIPT'
+import json
+import os
+import re
+
+solutions_dir = os.path.expanduser("~/.loki/solutions")
+context = os.environ.get("LOKI_SOL_CONTEXT", "").lower()
+context_words = set(context.split())
+
+results = []
+
+for category in os.listdir(solutions_dir):
+    cat_dir = os.path.join(solutions_dir, category)
+    if not os.path.isdir(cat_dir):
+        continue
+    for filename in os.listdir(cat_dir):
+        if not filename.endswith('.md'):
+            continue
+        filepath = os.path.join(cat_dir, filename)
+        try:
+            with open(filepath, 'r') as f:
+                content = f.read()
+        except:
+            continue
+
+        # Parse YAML frontmatter
+        fm_match = re.match(r'^---\n(.*?)\n---', content, re.DOTALL)
+        if not fm_match:
+            continue
+
+        fm = fm_match.group(1)
+        title = re.search(r'title:\s*"([^"]*)"', fm)
+        tags_match = re.search(r'tags:\s*\[([^\]]*)\]', fm)
+        root_cause = re.search(r'root_cause:\s*"([^"]*)"', fm)
+        prevention = re.search(r'prevention:\s*"([^"]*)"', fm)
+        symptoms = re.findall(r'^\s*-\s*"([^"]*)"', fm, re.MULTILINE)
+
+        title_str = title.group(1) if title else filename.replace('.md', '')
+        tags = [t.strip() for t in tags_match.group(1).split(',')] if tags_match else []
+
+        # Score by matching
+        score = 0
+        for tag in tags:
+            if tag.lower() in context:
+                score += 2
+        for symptom in symptoms:
+            for word in symptom.lower().split():
+                if word in context_words and len(word) > 3:
+                    score += 3
+        if category in context:
+            score += 1
+
+        if score > 0:
+            results.append({
+                "score": score,
+                "category": category,
+                "title": title_str,
+                "root_cause": root_cause.group(1) if root_cause else "",
+                "prevention": prevention.group(1) if prevention else "",
+                "file": filepath
+            })
+
+# Sort by score, take top 3
+results.sort(key=lambda x: x["score"], reverse=True)
+top = results[:3]
+
+output = {"solutions": top}
+os.makedirs(".loki/state", exist_ok=True)
+with open(".loki/state/relevant-solutions.json", 'w') as f:
+    json.dump(output, f, indent=2)
+
+if top:
+    print(f"Loaded {len(top)} relevant solutions from cross-project knowledge base")
+SOLUTIONS_SCRIPT
+}
+
 start_dashboard() {
     log_header "Starting Loki Dashboard"
 
@@ -5429,8 +5687,10 @@ main() {
     # Load relevant learnings for this project context
     if [ -n "$PRD_PATH" ] && [ -f "$PRD_PATH" ]; then
         get_relevant_learnings "$(cat "$PRD_PATH" | head -100)"
+        load_solutions_context "$(cat "$PRD_PATH" | head -100)"
     else
         get_relevant_learnings "general development"
+        load_solutions_context "general development"
     fi
 
     # Log session start for audit
@@ -5488,6 +5748,9 @@ main() {
     # Extract and save learnings from this session
     extract_learnings_from_session
 
+    # Compound learnings into structured solution files (v5.30.0)
+    compound_session_to_solutions
+
     # Log session end for audit
     audit_log "SESSION_END" "result=$result,prd=$PRD_PATH"
 

package/dashboard/__init__.py

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

package/docs/INSTALLATION.md

@@ -2,7 +2,7 @@
 
 Complete installation instructions for all platforms and use cases.
 
-**Version:** v5.29.0
+**Version:** v5.30.0
 
 ---
 
@@ -36,7 +36,7 @@ npm install -g loki-mode
 brew tap asklokesh/tap && brew install loki-mode
 
 # Option C: Docker
-docker pull asklokesh/loki-mode:5.26.0
+docker pull asklokesh/loki-mode:5.30.0
 
 # Option D: Git clone
 git clone https://github.com/asklokesh/loki-mode.git ~/.claude/skills/loki-mode
@@ -227,7 +227,7 @@ Run Loki Mode in a container for isolated execution.
 
 ```bash
 # Pull the image
-docker pull asklokesh/loki-mode:5.26.0
+docker pull asklokesh/loki-mode:5.30.0
 
 # Or use docker-compose
 curl -o docker-compose.yml https://raw.githubusercontent.com/asklokesh/loki-mode/main/docker-compose.yml
@@ -237,10 +237,10 @@ curl -o docker-compose.yml https://raw.githubusercontent.com/asklokesh/loki-mode
 
 ```bash
 # Run with a PRD file
-docker run -v $(pwd):/workspace -w /workspace asklokesh/loki-mode:5.26.0 start ./my-prd.md
+docker run -v $(pwd):/workspace -w /workspace asklokesh/loki-mode:5.30.0 start ./my-prd.md
 
 # Interactive mode
-docker run -it -v $(pwd):/workspace -w /workspace asklokesh/loki-mode:5.26.0
+docker run -it -v $(pwd):/workspace -w /workspace asklokesh/loki-mode:5.30.0
 
 # Using docker-compose
 docker-compose run loki start ./my-prd.md
@@ -253,7 +253,7 @@ Pass your configuration via environment variables:
 ```bash
 docker run -e LOKI_MAX_RETRIES=100 -e LOKI_BASE_WAIT=120 \
   -v $(pwd):/workspace -w /workspace \
-  asklokesh/loki-mode:5.26.0 start ./my-prd.md
+  asklokesh/loki-mode:5.30.0 start ./my-prd.md
 ```
 
 ### Updating
@@ -369,12 +369,12 @@ Pass the provider as an environment variable:
 # Use Codex with Docker
 docker run -e LOKI_PROVIDER=codex \
   -v $(pwd):/workspace -w /workspace \
-  asklokesh/loki-mode:5.26.0 start ./my-prd.md
+  asklokesh/loki-mode:5.30.0 start ./my-prd.md
 
 # Use Gemini with Docker
 docker run -e LOKI_PROVIDER=gemini \
   -v $(pwd):/workspace -w /workspace \
-  asklokesh/loki-mode:5.26.0 start ./my-prd.md
+  asklokesh/loki-mode:5.30.0 start ./my-prd.md
 ```
 
 ### Degraded Mode

package/package.json

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

package/skills/00-index.md

@@ -27,6 +27,7 @@
 | Scale patterns (50+ agents) | `parallel-workflows.md` + `references/cursor-learnings.md` |
 | GitHub issues, PRs, syncing | `github-integration.md` |
 | Multi-provider (Codex, Gemini) | `providers.md` |
+| Plan deepening, knowledge extraction | `compound-learning.md` |
 
 ## Module Descriptions
 
@@ -108,6 +109,13 @@
 - Filter by labels, milestone, assignee
 - Requires `gh` CLI authenticated
 
+### compound-learning.md (v5.30.0)
+**When:** After architecture phase (deepen plan), after verification (extract learnings)
+- Deepen-plan: 4 parallel research agents enhance plans before implementation
+- Knowledge compounding: Extract structured solutions from task outcomes
+- Solution retrieval: Load relevant cross-project solutions during REASON phase
+- Composable phases: plan, deepen, work, review, compound
+
 ### providers.md (v5.0.0)
 **When:** Using non-Claude providers (Codex, Gemini), understanding degraded mode
 - Provider comparison matrix

package/skills/agents.md

@@ -91,37 +91,50 @@ Success: Endpoint works, tests pass, matches OpenAPI spec.
 
 ---
 
-## Parallel Review Pattern
+## Specialist Review Pattern (v5.30.0)
 
-**Code review uses 3 parallel reviewers with different focus areas:**
+**Code review uses 3 specialist reviewers selected from a pool of 5 named experts.**
+
+See `quality-gates.md` for full specialist definitions, selection rules, and prompt templates.
+
+**Pool:** security-sentinel, performance-oracle, architecture-strategist, test-coverage-auditor, dependency-analyst
+
+**Selection:** architecture-strategist always included + top 2 by trigger keyword match against diff.
 
 ```python
-# Launch all 3 in ONE message (parallel execution)
+# Launch all 3 in ONE message (parallel, blind)
 Task(
     subagent_type="general-purpose",
-    model="opus",
-    description="Review: correctness",
-    prompt="Review for bugs, logic errors, edge cases. Files: {files}"
+    model="sonnet",
+    description="Review: Architecture Strategist",
+    prompt="You are Architecture Strategist. Review ONLY for: SOLID violations, "
+           "coupling, wrong patterns, missing abstractions. Files: {files}. Diff: {diff}. "
+           "Output: VERDICT (PASS/FAIL) + FINDINGS with severity."
 )
 Task(
     subagent_type="general-purpose",
-    model="opus",
-    description="Review: security",
-    prompt="Review for vulnerabilities, injection, auth issues. Files: {files}"
+    model="sonnet",
+    description="Review: Security Sentinel",
+    prompt="You are Security Sentinel. Review ONLY for: injection, XSS, auth bypass, "
+           "secrets, input validation, OWASP Top 10. Files: {files}. Diff: {diff}. "
+           "Output: VERDICT (PASS/FAIL) + FINDINGS with severity."
 )
 Task(
     subagent_type="general-purpose",
-    model="opus",
-    description="Review: performance",
-    prompt="Review for N+1 queries, memory leaks, slow operations. Files: {files}"
+    model="sonnet",
+    description="Review: {selected_specialist}",
+    prompt="You are {name}. Review ONLY for: {focus}. "
+           "Files: {files}. Diff: {diff}. "
+           "Output: VERDICT (PASS/FAIL) + FINDINGS with severity."
 )
 ```
 
 **Rules:**
-- ALWAYS use opus for reviews
-- ALWAYS launch all 3 in single message
+- ALWAYS use sonnet for reviews (balanced quality/cost)
+- ALWAYS launch all 3 in single message (parallel, blind)
 - WAIT for all 3 before aggregating
-- IF unanimous approval: run Devil's Advocate reviewer
+- IF unanimous PASS: run Devil's Advocate reviewer (anti-sycophancy)
+- Critical/High = BLOCK, Medium = TODO, Low = informational
 
 ---
 

package/skills/compound-learning.md

@@ -0,0 +1,274 @@
+# Compound Learning & Deep Planning
+
+**Inspired by:** Compound Engineering Plugin (Every/Kieran Klaassen) -- knowledge compounding philosophy where each unit of work makes subsequent work easier.
+
+---
+
+## Knowledge Compounding (Post-VERIFY)
+
+After VERIFY passes, evaluate whether the task produced a **novel insight** worth preserving. Extract structured solutions that feed back into future planning.
+
+### When to Compound
+
+Extract a solution when the task involved:
+- Fixing a bug with a non-obvious root cause
+- Solving a problem that required research or multiple attempts
+- Discovering a reusable pattern or anti-pattern
+- Hitting a pitfall that future projects could avoid
+- Finding a performance optimization worth documenting
+
+### When NOT to Compound
+
+Skip compounding for:
+- Trivial changes (typos, formatting, renaming)
+- Standard CRUD operations
+- Changes with no novel insight
+- Tasks that completed on first attempt with obvious approach
+
+### Solution File Format
+
+Write to `~/.loki/solutions/{category}/{slug}.md` where slug is the title in kebab-case.
+
+```yaml
+---
+title: "Connection pool exhaustion under load"
+category: performance
+tags: [database, pool, timeout, postgres]
+symptoms:
+  - "ECONNREFUSED on database queries under load"
+  - "Pool timeout exceeded errors in production"
+root_cause: "Default pool size of 10 insufficient for concurrent request volume"
+prevention: "Set pool size to 2x expected concurrent connections, add health checks"
+confidence: 0.85
+source_project: "auth-service"
+created: "2026-02-09T12:00:00Z"
+applied_count: 0
+---
+
+## Solution
+
+Increase the connection pool size in the database configuration. Add a connection
+health check that validates connections before returning them to the pool.
+
+## Context
+
+Discovered when the auth-service started timing out under moderate load (50 rps).
+Default pg pool size of 10 caused request queuing when each request held a connection
+for ~200ms. Fix: pool_size = 2 * max_concurrent_requests.
+
+## Related
+
+- See also: `performance/database-query-optimization.md`
+- See also: `deployment/connection-string-configuration.md`
+```
+
+### Categories
+
+Solutions are organized into 7 fixed categories:
+
+| Category | What Goes Here |
+|----------|---------------|
+| `security` | Auth bugs, injection fixes, secret handling, OWASP findings |
+| `performance` | N+1 queries, memory leaks, caching strategies, bundle optimization |
+| `architecture` | Design patterns, coupling fixes, abstraction improvements, SOLID violations |
+| `testing` | Test strategies, flaky test fixes, coverage improvements, mocking patterns |
+| `debugging` | Root cause analysis techniques, diagnostic approaches, logging patterns |
+| `deployment` | CI/CD fixes, Docker issues, environment config, infrastructure patterns |
+| `general` | Anything that doesn't fit above categories |
+
+### YAML Frontmatter Fields
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| `title` | Yes | Concise description of the problem/solution |
+| `category` | Yes | One of the 7 categories above |
+| `tags` | Yes | Array of keywords for search/matching |
+| `symptoms` | Yes | Observable indicators of the problem |
+| `root_cause` | Yes | Underlying cause (not just the symptom) |
+| `prevention` | Yes | How to avoid this in future projects |
+| `confidence` | No | 0.0-1.0, how broadly applicable (default 0.7) |
+| `source_project` | No | Project where this was discovered |
+| `created` | Yes | ISO 8601 timestamp |
+| `applied_count` | No | Times this solution was loaded for a task (default 0) |
+
+---
+
+## Loading Solutions (REASON Phase)
+
+Before starting a task, check `~/.loki/solutions/` for relevant entries.
+
+### Matching Logic
+
+1. Extract keywords from the current task description/goal
+2. Scan solution files in `~/.loki/solutions/*/`
+3. Score each solution by:
+   - Tag matches against task keywords (2 points each)
+   - Symptom matches against error messages (3 points each)
+   - Category match against current phase (1 point)
+4. Return top 3 solutions sorted by score
+5. Inject into context as: `title | root_cause | prevention`
+
+### Context Injection Format
+
+```
+RELEVANT SOLUTIONS FROM PAST PROJECTS:
+1. [performance] Connection pool exhaustion under load
+   Root cause: Default pool size insufficient for concurrent requests
+   Prevention: Set pool size to 2x concurrent connections
+2. [security] JWT token not validated on WebSocket upgrade
+   Root cause: WebSocket middleware bypassed auth middleware
+   Prevention: Apply auth middleware to ALL transport layers
+```
+
+Keep injection under 500 tokens. Title + root_cause + prevention only.
+
+---
+
+## Deepen-Plan Phase
+
+After the ARCHITECTURE phase produces an initial plan, BEFORE starting DEVELOPMENT, spawn 4 parallel research agents to enhance the plan with concrete findings.
+
+### When to Run
+
+- After ARCHITECTURE phase completes and design is approved
+- Before INFRASTRUCTURE or DEVELOPMENT phase begins
+- **Only for standard/complex complexity tiers** (skip for simple -- overkill)
+- **Only when using Claude provider** (requires Task tool for parallel agents)
+- Skip if the project is a known template with well-understood patterns
+
+### Research Agents (4 parallel -- launch in ONE message)
+
+#### 1. Repo Analyzer
+
+```python
+Task(
+    subagent_type="general-purpose",
+    model="sonnet",
+    description="Research: Repo Analysis",
+    prompt="""Analyze this codebase for patterns relevant to the planned feature.
+
+    Plan summary: {plan_summary}
+
+    Find:
+    - Reusable components and utilities
+    - Established naming conventions and code patterns
+    - Similar past implementations to reference
+    - Shared infrastructure (auth, logging, error handling)
+
+    Output: Bullet list of patterns to follow and components to reuse.
+    Be specific -- include file paths and function names."""
+)
+```
+
+#### 2. Dependency Researcher
+
+```python
+Task(
+    subagent_type="general-purpose",
+    model="sonnet",
+    description="Research: Dependencies",
+    prompt="""Research best practices for these technologies: {tech_stack}
+
+    Check:
+    - Official documentation for recommended patterns
+    - Known pitfalls and common mistakes
+    - Version compatibility between dependencies
+    - Recommended configuration defaults
+
+    Output: Best practices list and pitfalls to avoid.
+    Cite sources where possible."""
+)
+```
+
+#### 3. Edge Case Finder
+
+```python
+Task(
+    subagent_type="general-purpose",
+    model="sonnet",
+    description="Research: Edge Cases",
+    prompt="""Identify edge cases and failure modes for this plan: {plan_summary}
+
+    Check:
+    - Concurrency and race conditions
+    - Network failures and timeouts
+    - Data validation (null, empty, oversized, malformed)
+    - Partial failures and error cascading
+    - Resource exhaustion (memory, connections, disk)
+    - Boundary conditions (first, last, zero, max)
+
+    Output: Prioritized list with suggested handling for each.
+    Mark each as Critical/High/Medium severity."""
+)
+```
+
+#### 4. Security Threat Modeler
+
+```python
+Task(
+    subagent_type="general-purpose",
+    model="sonnet",
+    description="Research: Threat Model",
+    prompt="""Perform threat modeling for this architecture: {architecture_summary}
+
+    Check:
+    - Authentication and authorization flows
+    - Data exposure and privacy concerns
+    - Injection surfaces (SQL, XSS, command, template)
+    - Authorization bypass scenarios
+    - Third-party dependency risks
+    - Supply chain attack surface
+
+    Output: STRIDE-based threat model with specific mitigations.
+    Mark each threat as Critical/High/Medium severity."""
+)
+```
+
+### After All 4 Complete
+
+1. **Update the architecture plan** with findings from all agents
+2. **Add edge cases** as explicit tasks in `.loki/queue/pending.json`
+3. **Save threat model** to `.loki/specs/threat-model.md`
+4. **Log enhancement summary** in CONTINUITY.md under "Plan Deepening Results"
+5. **Proceed** to INFRASTRUCTURE or DEVELOPMENT phase
+
+### Example Output Integration
+
+```markdown
+## Plan Deepening Results (4 agents, 2m 14s)
+
+### Repo Analysis
+- Found existing auth middleware at src/middleware/auth.ts -- reuse for new endpoints
+- Logging pattern uses winston with structured JSON -- follow same pattern
+- Database queries use repository pattern -- add new repository for feature
+
+### Dependencies
+- React Query v5 requires explicit cache invalidation -- don't rely on auto-refetch
+- Prisma 6.x has breaking change in nested writes -- use transactions instead
+
+### Edge Cases (3 Critical, 5 High)
+- [Critical] Concurrent user edits can cause data loss -- add optimistic locking
+- [Critical] File upload >100MB causes OOM -- add streaming upload
+- [High] Network timeout during payment creates orphaned transaction
+
+### Threat Model
+- [Critical] API endpoint /admin/* missing rate limiting
+- [High] User-uploaded filenames not sanitized -- path traversal risk
+```
+
+---
+
+## Composable Phases
+
+These phases can be invoked individually or as part of the full RARV+C cycle:
+
+| Phase | Maps To | What It Does |
+|-------|---------|-------------|
+| `plan` | REASON (first pass) | Analyze PRD, generate architecture, create task queue |
+| `deepen` | REASON (enhanced) | 4 research agents enhance the plan |
+| `work` | ACT | Execute highest-priority task |
+| `review` | REFLECT + VERIFY | 3 specialist reviewers on recent changes |
+| `compound` | COMPOUND | Extract structured solutions from learnings |
+
+When running via `autonomy/run.sh`, the full cycle executes automatically.
+When running via Claude Code skill directly, invoke phases as needed.

package/skills/quality-gates.md

@@ -263,22 +263,97 @@ velocity_quality_balance:
 
 ---
 
-## Blind Review System
+## Specialist Review Pool (v5.30.0)
 
-**Launch 3 reviewers in parallel in a single message:**
+5 named expert reviewers. Select 3 per review based on change type.
+
+**Inspired by:** Compound Engineering Plugin's 14 named review agents -- specialized expertise catches more issues than generic reviewers.
+
+| Specialist | Focus Area | Trigger Keywords |
+|-----------|-----------|-----------------|
+| **security-sentinel** | OWASP Top 10, injection, auth, secrets, input validation | auth, login, password, token, api, sql, query, cookie, cors, csrf |
+| **performance-oracle** | N+1 queries, memory leaks, caching, bundle size, lazy loading | database, query, cache, render, loop, fetch, load, index, join, pool |
+| **architecture-strategist** | SOLID, coupling, cohesion, patterns, abstraction, dependency direction | *(always included -- design quality affects everything)* |
+| **test-coverage-auditor** | Missing tests, edge cases, error paths, boundary conditions | test, spec, coverage, assert, mock, fixture, expect, describe |
+| **dependency-analyst** | Outdated packages, CVEs, bloat, unused deps, license issues | package, import, require, dependency, npm, pip, yarn, lock |
+
+### Selection Rules
+
+1. **architecture-strategist** is ALWAYS one of the 3 slots
+2. Score remaining 4 specialists by counting trigger keyword matches in the diff content and changed file names
+3. Top 2 scoring specialists fill the remaining slots
+4. **Tie-breaker priority:** security-sentinel > test-coverage-auditor > performance-oracle > dependency-analyst
+5. **No triggers match at all:** Default to security-sentinel + test-coverage-auditor
+
+### Dispatch Pattern
+
+Launch all 3 in ONE message. Each reviewer sees ONLY the diff -- NOT other reviewers' findings (blind review preserved).
 
 ```python
-# ALWAYS launch all 3 in ONE message
-Task(model="sonnet", description="Code review: correctness", prompt="Review for bugs...")
-Task(model="sonnet", description="Code review: security", prompt="Review for vulnerabilities...")
-Task(model="sonnet", description="Code review: performance", prompt="Review for efficiency...")
+# ALWAYS launch all 3 in ONE message (parallel, blind)
+Task(
+    model="sonnet",
+    description="Review: Architecture Strategist",
+    prompt="""You are Architecture Strategist. Your SOLE focus is design quality.
+
+    Review ONLY for: SOLID violations, excessive coupling, wrong patterns,
+    missing abstractions, dependency direction issues, god classes/functions.
+
+    Files changed: {files}
+    Diff: {diff}
+
+    Output format:
+    VERDICT: PASS or FAIL
+    FINDINGS:
+    - [severity] description (file:line)
+    Severity levels: Critical, High, Medium, Low"""
+)
+
+Task(
+    model="sonnet",
+    description="Review: Security Sentinel",
+    prompt="""You are Security Sentinel. Your SOLE focus is security vulnerabilities.
+
+    Review ONLY for: injection (SQL, XSS, command, template), auth bypass,
+    secrets in code, missing input validation, OWASP Top 10, insecure defaults.
+
+    Files changed: {files}
+    Diff: {diff}
+
+    Output format:
+    VERDICT: PASS or FAIL
+    FINDINGS:
+    - [severity] description (file:line)
+    Severity levels: Critical, High, Medium, Low"""
+)
+
+Task(
+    model="sonnet",
+    description="Review: {3rd_selected_specialist}",
+    prompt="""You are {specialist_name}. Your SOLE focus is {focus_area}.
+
+    Review ONLY for: {specific_checks}
+
+    Files changed: {files}
+    Diff: {diff}
+
+    Output format:
+    VERDICT: PASS or FAIL
+    FINDINGS:
+    - [severity] description (file:line)
+    Severity levels: Critical, High, Medium, Low"""
+)
 ```
 
-**Rules:**
+### Rules (unchanged from blind review)
+
 - ALWAYS use sonnet for reviews (balanced quality/cost)
 - NEVER aggregate before all 3 complete
 - ALWAYS re-run ALL 3 after fixes
-- If unanimous approval -> run Devil's Advocate
+- If unanimous PASS -> run Devil's Advocate (anti-sycophancy check)
+- Critical/High findings = BLOCK (must fix before merge)
+- Medium findings = TODO (track but don't block)
+- Low findings = informational only
 
 ---