loki-mode 6.13.1 → 6.15.0

package/README.md

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

package/SKILL.md

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

package/VERSION

@@ -1 +1 @@
-6.13.1
+6.15.0

package/autonomy/loki

@@ -419,6 +419,7 @@ show_help() {
     echo "  checkpoint|cp    Save/restore session checkpoints"
     echo "  projects         Multi-project registry management"
     echo "  audit [cmd]      Agent audit log and quality scanning (log|scan)"
+    echo "  review [dir]     Run quality gates on any project (standalone, no AI needed)"
     echo "  optimize         Optimize prompts based on session history"
     echo "  enterprise       Enterprise feature management (tokens, OIDC)"
     echo "  metrics          Prometheus/OpenMetrics metrics from dashboard"
@@ -7848,6 +7849,9 @@ main() {
         audit)
             cmd_audit "$@"
             ;;
+        review)
+            cmd_review "$@"
+            ;;
         optimize)
             cmd_optimize "$@"
             ;;
@@ -7895,6 +7899,223 @@ main() {
     esac
 }
 
+# Standalone project review - run quality gates on any codebase (v6.14.0)
+cmd_review() {
+    local target_dir="."
+    local json_output=""
+    local verbose=""
+
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --json) json_output="true"; shift ;;
+            --verbose|-v) verbose="true"; shift ;;
+            --help|-h)
+                echo -e "${BOLD}loki review${NC} - Run quality gates on any project (standalone)"
+                echo ""
+                echo "Usage: loki review [directory] [options]"
+                echo ""
+                echo "Arguments:"
+                echo "  directory       Path to project (default: current directory)"
+                echo ""
+                echo "Options:"
+                echo "  --json          Machine-readable JSON output"
+                echo "  --verbose, -v   Show detailed output per gate"
+                echo "  --help, -h      Show this help"
+                echo ""
+                echo "Gates: project-type, lint, tests, security, dependencies, structure"
+                echo "Exit code: 0 if all pass, 1 if any fail"
+                return 0
+                ;;
+            -*) echo -e "${RED}Unknown option: $1${NC}"; return 1 ;;
+            *) target_dir="$1"; shift ;;
+        esac
+    done
+
+    # Resolve and validate directory
+    target_dir="$(cd "$target_dir" 2>/dev/null && pwd)" || {
+        echo -e "${RED}Error: Directory not found: $target_dir${NC}"; return 1
+    }
+
+    local project_type="unknown"
+    local results=()  # gate:status pairs
+    local total_pass=0 total_warn=0 total_fail=0
+    local gate_details=()
+
+    # Helper: record gate result
+    _review_gate() {
+        local gate="$1" status="$2" detail="${3:-}"
+        results+=("$gate:$status")
+        gate_details+=("$gate:$detail")
+        case "$status" in
+            PASS) total_pass=$((total_pass + 1)) ;;
+            WARN) total_warn=$((total_warn + 1)) ;;
+            FAIL) total_fail=$((total_fail + 1)) ;;
+        esac
+    }
+
+    # Gate 1: Detect project type
+    if [ -f "$target_dir/package.json" ]; then
+        project_type="node"
+    elif [ -f "$target_dir/pyproject.toml" ] || [ -f "$target_dir/setup.py" ] || [ -f "$target_dir/requirements.txt" ]; then
+        project_type="python"
+    elif [ -f "$target_dir/go.mod" ]; then
+        project_type="go"
+    elif [ -f "$target_dir/Cargo.toml" ]; then
+        project_type="rust"
+    fi
+    if [ "$project_type" != "unknown" ]; then
+        _review_gate "project-type" "PASS" "Detected: $project_type"
+    else
+        _review_gate "project-type" "WARN" "Could not detect project type"
+    fi
+
+    # Gate 2: Lint check
+    local lint_output="" lint_status="PASS"
+    case "$project_type" in
+        node)
+            if [ -f "$target_dir/.eslintrc.js" ] || [ -f "$target_dir/.eslintrc.json" ] || [ -f "$target_dir/.eslintrc.yml" ] || [ -f "$target_dir/eslint.config.js" ] || [ -f "$target_dir/eslint.config.mjs" ]; then
+                lint_output=$(cd "$target_dir" && npx eslint . --max-warnings=0 2>&1) || lint_status="FAIL"
+            else
+                lint_output="No ESLint config found"; lint_status="WARN"
+            fi ;;
+        python)
+            if command -v ruff &>/dev/null; then
+                lint_output=$(cd "$target_dir" && ruff check . 2>&1) || lint_status="FAIL"
+            elif command -v pylint &>/dev/null; then
+                lint_output=$(cd "$target_dir" && pylint --recursive=y . 2>&1) || lint_status="FAIL"
+            else
+                lint_output="No linter available (install ruff or pylint)"; lint_status="WARN"
+            fi ;;
+        go)
+            if command -v golangci-lint &>/dev/null; then
+                lint_output=$(cd "$target_dir" && golangci-lint run 2>&1) || lint_status="FAIL"
+            else
+                lint_output=$(cd "$target_dir" && go vet ./... 2>&1) || lint_status="FAIL"
+            fi ;;
+        rust)
+            lint_output=$(cd "$target_dir" && cargo clippy -- -D warnings 2>&1) || lint_status="FAIL"
+            ;;
+        *) lint_output="Skipped (unknown project type)"; lint_status="WARN" ;;
+    esac
+    _review_gate "lint" "$lint_status" "$lint_output"
+
+    # Gate 3: Tests
+    local test_output="" test_status="PASS"
+    case "$project_type" in
+        node)
+            if grep -q '"test"' "$target_dir/package.json" 2>/dev/null; then
+                test_output=$(cd "$target_dir" && npm test 2>&1) || test_status="FAIL"
+            else
+                test_output="No test script in package.json"; test_status="WARN"
+            fi ;;
+        python)
+            if command -v pytest &>/dev/null; then
+                test_output=$(cd "$target_dir" && pytest --tb=short 2>&1) || test_status="FAIL"
+            else
+                test_output="pytest not available"; test_status="WARN"
+            fi ;;
+        go) test_output=$(cd "$target_dir" && go test ./... 2>&1) || test_status="FAIL" ;;
+        rust) test_output=$(cd "$target_dir" && cargo test 2>&1) || test_status="FAIL" ;;
+        *) test_output="Skipped (unknown project type)"; test_status="WARN" ;;
+    esac
+    _review_gate "tests" "$test_status" "$test_output"
+
+    # Gate 4: Security - grep for hardcoded secrets
+    local secret_output="" secret_status="PASS"
+    local secret_patterns='(API_KEY|SECRET_KEY|PASSWORD|TOKEN|PRIVATE_KEY)\s*[=:]\s*["\x27][A-Za-z0-9+/=_-]{8,}'
+    secret_output=$(grep -rEn "$secret_patterns" "$target_dir" \
+        --include="*.js" --include="*.ts" --include="*.py" --include="*.go" --include="*.rs" \
+        --include="*.jsx" --include="*.tsx" --include="*.java" --include="*.rb" \
+        --exclude-dir=node_modules --exclude-dir=.git --exclude-dir=vendor \
+        --exclude-dir=__pycache__ --exclude-dir=.venv --exclude-dir=target 2>/dev/null) || true
+    if [ -n "$secret_output" ]; then
+        secret_status="FAIL"
+        secret_output="Potential hardcoded secrets found:
+$secret_output"
+    else
+        secret_output="No hardcoded secrets detected"
+    fi
+    _review_gate "security" "$secret_status" "$secret_output"
+
+    # Gate 5: Dependency audit
+    local dep_output="" dep_status="PASS"
+    case "$project_type" in
+        node)
+            if [ -f "$target_dir/package-lock.json" ] || [ -f "$target_dir/yarn.lock" ]; then
+                dep_output=$(cd "$target_dir" && npm audit --production 2>&1) || dep_status="WARN"
+            else
+                dep_output="No lockfile found"; dep_status="WARN"
+            fi ;;
+        python)
+            if command -v pip-audit &>/dev/null; then
+                dep_output=$(cd "$target_dir" && pip-audit 2>&1) || dep_status="WARN"
+            else
+                dep_output="pip-audit not available"; dep_status="WARN"
+            fi ;;
+        *) dep_output="No dependency audit available for $project_type"; dep_status="WARN" ;;
+    esac
+    _review_gate "dependencies" "$dep_status" "$dep_output"
+
+    # Gate 6: Structure check
+    local struct_output="" struct_status="PASS" struct_issues=()
+    [ ! -f "$target_dir/README.md" ] && [ ! -f "$target_dir/README.rst" ] && [ ! -f "$target_dir/README" ] && struct_issues+=("Missing README")
+    local file_count
+    file_count=$(find "$target_dir" -type f -not -path '*/.git/*' -not -path '*/node_modules/*' -not -path '*/vendor/*' -not -path '*/__pycache__/*' -not -path '*/.venv/*' -not -path '*/target/*' 2>/dev/null | wc -l | tr -d ' ')
+    [ "$file_count" -gt 5000 ] && struct_issues+=("Large project: $file_count files")
+    local huge_files
+    huge_files=$(find "$target_dir" -type f -size +1M -not -path '*/.git/*' -not -path '*/node_modules/*' -not -path '*/vendor/*' -not -path '*/target/*' 2>/dev/null | head -5)
+    [ -n "$huge_files" ] && struct_issues+=("Files >1MB found: $(echo "$huge_files" | wc -l | tr -d ' ')")
+    if [ ${#struct_issues[@]} -gt 0 ]; then
+        struct_status="WARN"
+        struct_output=$(printf '%s\n' "${struct_issues[@]}")
+    else
+        struct_output="README present, $file_count files, no oversized files"
+    fi
+    _review_gate "structure" "$struct_status" "$struct_output"
+
+    # Output results
+    if [ -n "$json_output" ]; then
+        local gates_json="["
+        local first="true"
+        for r in "${results[@]}"; do
+            local gate="${r%%:*}" status="${r#*:}"
+            [ "$first" = "true" ] && first="" || gates_json+=","
+            gates_json+="{\"gate\":\"$gate\",\"status\":\"$status\"}"
+        done
+        gates_json+="]"
+        printf '{"directory":"%s","project_type":"%s","pass":%d,"warn":%d,"fail":%d,"gates":%s}\n' \
+            "$target_dir" "$project_type" "$total_pass" "$total_warn" "$total_fail" "$gates_json"
+    else
+        echo -e "${BOLD}Loki Review: $target_dir${NC}"
+        echo -e "Project type: ${CYAN}$project_type${NC}"
+        echo "---"
+        for r in "${results[@]}"; do
+            local gate="${r%%:*}" status="${r#*:}"
+            case "$status" in
+                PASS) echo -e "  ${GREEN}[PASS]${NC} $gate" ;;
+                WARN) echo -e "  ${YELLOW}[WARN]${NC} $gate" ;;
+                FAIL) echo -e "  ${RED}[FAIL]${NC} $gate" ;;
+            esac
+        done
+        echo "---"
+        echo -e "Results: ${GREEN}$total_pass passed${NC}, ${YELLOW}$total_warn warnings${NC}, ${RED}$total_fail failed${NC}"
+
+        if [ -n "$verbose" ]; then
+            echo ""
+            echo -e "${BOLD}Details:${NC}"
+            for d in "${gate_details[@]}"; do
+                local gate="${d%%:*}" detail="${d#*:}"
+                echo -e "\n${CYAN}[$gate]${NC}"
+                echo "$detail" | head -30
+            done
+        fi
+    fi
+
+    # Exit code: 1 if any failures
+    [ "$total_fail" -gt 0 ] && return 1
+    return 0
+}
+
 # Worktree management (v6.7.0)
 cmd_worktree() {
     local subcommand="${1:-list}"

package/autonomy/run.sh

@@ -7267,6 +7267,83 @@ except Exception as e:
 PYEOF
 }
 
+# Automatic episode capture with enriched context (v6.15.0)
+# Captures git changes, files modified, and RARV phase automatically
+# after every iteration -- no manual invocation needed.
+auto_capture_episode() {
+    local iteration="$1"
+    local exit_code="$2"
+    local rarv_phase="$3"
+    local goal="$4"
+    local duration="$5"
+    local log_file="$6"
+    local target_dir="${TARGET_DIR:-.}"
+
+    # Only capture if memory system exists
+    if [ ! -d "$target_dir/.loki/memory" ]; then
+        return
+    fi
+
+    # Collect git context: files modified in this iteration
+    local files_modified=""
+    files_modified=$(cd "$target_dir" && git diff --name-only HEAD 2>/dev/null | head -20 | tr '\n' '|' || true)
+
+    # Collect last git commit if any
+    local git_commit=""
+    git_commit=$(cd "$target_dir" && git rev-parse --short HEAD 2>/dev/null || true)
+
+    # Determine outcome
+    local outcome="success"
+    if [ "$exit_code" -ne 0 ]; then
+        outcome="failure"
+    fi
+
+    # Pass all context via environment variables (prevents injection)
+    _LOKI_PROJECT_DIR="$PROJECT_DIR" _LOKI_TARGET_DIR="$target_dir" \
+    _LOKI_ITERATION="$iteration" _LOKI_EXIT_CODE="$exit_code" \
+    _LOKI_RARV_PHASE="$rarv_phase" _LOKI_GOAL="$goal" \
+    _LOKI_DURATION="$duration" _LOKI_OUTCOME="$outcome" \
+    _LOKI_FILES_MODIFIED="$files_modified" _LOKI_GIT_COMMIT="$git_commit" \
+    python3 << 'PYEOF' 2>/dev/null || true
+import sys
+import os
+
+project_dir = os.environ.get('_LOKI_PROJECT_DIR', '')
+target_dir = os.environ.get('_LOKI_TARGET_DIR', '.')
+iteration = os.environ.get('_LOKI_ITERATION', '0')
+rarv_phase = os.environ.get('_LOKI_RARV_PHASE', 'iteration')
+goal = os.environ.get('_LOKI_GOAL', '')
+duration = os.environ.get('_LOKI_DURATION', '0')
+outcome = os.environ.get('_LOKI_OUTCOME', 'success')
+files_modified = os.environ.get('_LOKI_FILES_MODIFIED', '')
+git_commit = os.environ.get('_LOKI_GIT_COMMIT', '')
+
+sys.path.insert(0, project_dir)
+try:
+    from memory.engine import MemoryEngine, create_storage
+    from memory.schemas import EpisodeTrace
+
+    storage = create_storage(f'{target_dir}/.loki/memory')
+    engine = MemoryEngine(storage=storage, base_path=f'{target_dir}/.loki/memory')
+    engine.initialize()
+
+    trace = EpisodeTrace.create(
+        task_id=f'iteration-{iteration}',
+        agent='loki-orchestrator',
+        phase=rarv_phase.upper() if rarv_phase else 'ACT',
+        goal=goal,
+    )
+    trace.outcome = outcome
+    trace.duration_seconds = int(duration) if duration.isdigit() else 0
+    trace.git_commit = git_commit if git_commit else None
+    trace.files_modified = [f for f in files_modified.split('|') if f] if files_modified else []
+
+    engine.store_episode(trace)
+except Exception:
+    pass  # Silently fail -- memory capture must never break the loop
+PYEOF
+}
+
 # Run memory consolidation pipeline
 run_memory_consolidation() {
     local target_dir="${TARGET_DIR:-.}"
@@ -8614,13 +8691,15 @@ if __name__ == "__main__":
             fi
         fi
 
+        # Automatic episode capture after every RARV iteration (v6.15.0)
+        # Captures RARV phase, git changes, and iteration context automatically
+        auto_capture_episode "$ITERATION_COUNT" "$exit_code" "${rarv_phase:-iteration}" \
+            "${prd_path:-codebase-analysis}" "$duration" "$log_file"
+
         # Check for success - ONLY stop on explicit completion promise
         # There's never a "complete" product - always improvements, bugs, features
         if [ $exit_code -eq 0 ]; then
-            # Store episode trace for successful iteration
-            local task_id="iteration-$ITERATION_COUNT"
-            local goal_desc="${prd_path:-codebase-analysis}"
-            store_episode_trace "$task_id" "success" "iteration" "$goal_desc" "$duration"
+            # Episode trace already captured by auto_capture_episode above (v6.15.0)
 
             # Track iteration for Completion Council convergence detection
             if type council_track_iteration &>/dev/null; then
@@ -8673,10 +8752,7 @@ if __name__ == "__main__":
         fi
 
         # Only apply retry logic for ERRORS (non-zero exit code)
-        # Store episode trace for failed iteration (useful for learning from failures)
-        local task_id="iteration-$ITERATION_COUNT"
-        local goal_desc="${prd_path:-codebase-analysis}"
-        store_episode_trace "$task_id" "failure" "iteration" "$goal_desc" "$duration"
+        # Episode trace already captured by auto_capture_episode above (v6.15.0)
 
         # Checkpoint failed iteration state (v5.57.0)
         create_checkpoint "iteration-${ITERATION_COUNT} failed (exit=$exit_code)" "iteration-${ITERATION_COUNT}-fail"

package/dashboard/__init__.py

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

package/dashboard/server.py

@@ -1622,15 +1622,51 @@ def _sanitize_agent_id(agent_id: str) -> str:
 @app.get("/api/memory/summary")
 async def get_memory_summary():
     """Get memory system summary from .loki/memory/."""
+    # Try SQLite backend first for accurate counts
+    storage = _get_memory_storage()
+    if storage is not None:
+        try:
+            stats = storage.get_stats()
+            summary = {
+                "episodic": {"count": stats.get("episode_count", 0), "latestDate": None},
+                "semantic": {"patterns": stats.get("pattern_count", 0), "antiPatterns": 0},
+                "procedural": {"skills": stats.get("skill_count", 0)},
+                "backend": "sqlite",
+            }
+            # Get latest episode date
+            episode_ids = storage.list_episodes(limit=1)
+            if episode_ids:
+                ep = storage.load_episode(episode_ids[0])
+                if ep:
+                    summary["episodic"]["latestDate"] = ep.get("timestamp", "")
+            # Token economics from JSON (not in SQLite)
+            econ_file = _get_loki_dir() / "memory" / "token_economics.json"
+            if econ_file.exists():
+                try:
+                    econ = json.loads(econ_file.read_text())
+                    summary["tokenEconomics"] = {
+                        "discoveryTokens": econ.get("discoveryTokens", 0),
+                        "readTokens": econ.get("readTokens", 0),
+                        "savingsPercent": econ.get("savingsPercent", 0),
+                    }
+                except Exception:
+                    summary["tokenEconomics"] = {"discoveryTokens": 0, "readTokens": 0, "savingsPercent": 0}
+            else:
+                summary["tokenEconomics"] = {"discoveryTokens": 0, "readTokens": 0, "savingsPercent": 0}
+            return summary
+        except Exception:
+            pass
+
+    # Fallback to JSON file-based counts
     memory_dir = _get_loki_dir() / "memory"
     summary = {
         "episodic": {"count": 0, "latestDate": None},
         "semantic": {"patterns": 0, "antiPatterns": 0},
         "procedural": {"skills": 0},
         "tokenEconomics": {"discoveryTokens": 0, "readTokens": 0, "savingsPercent": 0},
+        "backend": "json",
     }
 
-    # Count episodic memories
     ep_dir = memory_dir / "episodic"
     if ep_dir.exists():
         episodes = sorted(ep_dir.glob("*.json"))
@@ -1642,7 +1678,6 @@ async def get_memory_summary():
             except Exception:
                 pass
 
-    # Count semantic patterns
     sem_dir = memory_dir / "semantic"
     patterns_file = sem_dir / "patterns.json"
     anti_file = sem_dir / "anti-patterns.json"
@@ -1659,12 +1694,10 @@ async def get_memory_summary():
         except Exception:
             pass
 
-    # Count skills
     skills_dir = memory_dir / "skills"
     if skills_dir.exists():
         summary["procedural"]["skills"] = len(list(skills_dir.glob("*.json")))
 
-    # Token economics
     econ_file = memory_dir / "token_economics.json"
     if econ_file.exists():
         try:
@@ -1683,6 +1716,21 @@ async def get_memory_summary():
 @app.get("/api/memory/episodes")
 async def list_episodes(limit: int = Query(default=50, ge=1, le=1000)):
     """List episodic memory entries."""
+    # Try SQLite backend first
+    storage = _get_memory_storage()
+    if storage is not None:
+        try:
+            ids = storage.list_episodes(limit=limit)
+            episodes = []
+            for eid in ids:
+                ep = storage.load_episode(eid)
+                if ep:
+                    episodes.append(ep)
+            return episodes
+        except Exception:
+            pass
+
+    # Fallback to JSON files
     ep_dir = _get_loki_dir() / "memory" / "episodic"
     episodes = []
     if ep_dir.exists():
@@ -1698,11 +1746,21 @@ async def list_episodes(limit: int = Query(default=50, ge=1, le=1000)):
 @app.get("/api/memory/episodes/{episode_id}")
 async def get_episode(episode_id: str):
     """Get a specific episodic memory entry."""
+    # Try SQLite first
+    storage = _get_memory_storage()
+    if storage is not None:
+        try:
+            ep = storage.load_episode(episode_id)
+            if ep:
+                return ep
+        except Exception:
+            pass
+
+    # Fallback to JSON files
     loki_dir = _get_loki_dir()
     ep_dir = loki_dir / "memory" / "episodic"
     if not ep_dir.exists():
         raise HTTPException(status_code=404, detail="Episode not found")
-    # Try direct filename match
     for f in ep_dir.glob("*.json"):
         resolved = os.path.realpath(f)
         if not resolved.startswith(os.path.realpath(str(loki_dir))):
@@ -1719,6 +1777,21 @@ async def get_episode(episode_id: str):
 @app.get("/api/memory/patterns")
 async def list_patterns():
     """List semantic patterns."""
+    # Try SQLite first
+    storage = _get_memory_storage()
+    if storage is not None:
+        try:
+            ids = storage.list_patterns()
+            patterns = []
+            for pid in ids:
+                p = storage.load_pattern(pid)
+                if p:
+                    patterns.append(p)
+            return patterns
+        except Exception:
+            pass
+
+    # Fallback to JSON
     sem_dir = _get_loki_dir() / "memory" / "semantic"
     patterns_file = sem_dir / "patterns.json"
     if patterns_file.exists():
@@ -1743,6 +1816,21 @@ async def get_pattern(pattern_id: str):
 @app.get("/api/memory/skills")
 async def list_skills():
     """List procedural skills."""
+    # Try SQLite first
+    storage = _get_memory_storage()
+    if storage is not None:
+        try:
+            ids = storage.list_skills()
+            skills = []
+            for sid in ids:
+                s = storage.load_skill(sid)
+                if s:
+                    skills.append(s)
+            return skills
+        except Exception:
+            pass
+
+    # Fallback to JSON
     skills_dir = _get_loki_dir() / "memory" / "skills"
     skills = []
     if skills_dir.exists():
@@ -1824,6 +1912,106 @@ async def get_memory_timeline():
     return {"entries": episodes, "lastUpdated": None}
 
 
+# ---------------------------------------------------------------------------
+# Memory Search & Stats (v6.15.0) - SQLite FTS5 powered
+# ---------------------------------------------------------------------------
+
+def _get_memory_storage():
+    """Get the best available memory storage backend (SQLite preferred)."""
+    memory_dir = _get_loki_dir() / "memory"
+    base_path = str(memory_dir)
+    try:
+        import sys
+        project_root = str(_Path(__file__).resolve().parent.parent)
+        if project_root not in sys.path:
+            sys.path.insert(0, project_root)
+        from memory.sqlite_storage import SQLiteMemoryStorage
+        return SQLiteMemoryStorage(base_path=base_path)
+    except Exception:
+        return None
+
+
+@app.get("/api/memory/search")
+async def search_memory(
+    q: str = Query(..., min_length=1, max_length=500, description="Search query"),
+    collection: str = Query(default="all", regex="^(episodes|patterns|skills|all)$"),
+    limit: int = Query(default=20, ge=1, le=100),
+):
+    """Full-text search across memory using FTS5."""
+    storage = _get_memory_storage()
+    if storage is None:
+        return {"results": [], "message": "SQLite memory backend not available"}
+
+    try:
+        results = storage.search_fts(q, collection=collection, limit=limit)
+        compact = []
+        for r in results:
+            entry = {
+                "id": r.get("id", ""),
+                "type": r.get("_type", "unknown"),
+                "summary": (
+                    r.get("goal", "") or
+                    r.get("pattern", "") or
+                    r.get("description", "") or
+                    r.get("name", "")
+                )[:300],
+                "score": round(r.get("_score", 0), 3),
+            }
+            if r.get("outcome"):
+                entry["outcome"] = r["outcome"]
+            if r.get("category"):
+                entry["category"] = r["category"]
+            if r.get("timestamp"):
+                entry["timestamp"] = r["timestamp"]
+            compact.append(entry)
+        return {"results": compact, "count": len(compact), "query": q, "collection": collection}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Search failed: {e}")
+
+
+@app.get("/api/memory/stats")
+async def get_memory_stats():
+    """Get memory system statistics (counts, size, backend info)."""
+    storage = _get_memory_storage()
+    if storage is not None:
+        try:
+            return storage.get_stats()
+        except Exception:
+            pass
+
+    # Fallback: compute stats from JSON files
+    memory_dir = _get_loki_dir() / "memory"
+    ep_count = 0
+    ep_dir = memory_dir / "episodic"
+    if ep_dir.exists():
+        for d in ep_dir.iterdir():
+            if d.is_dir():
+                ep_count += len(list(d.glob("*.json")))
+            elif d.suffix == ".json":
+                ep_count += 1
+
+    pat_count = 0
+    patterns_file = memory_dir / "semantic" / "patterns.json"
+    if patterns_file.exists():
+        try:
+            data = json.loads(patterns_file.read_text())
+            pat_count = len(data) if isinstance(data, list) else len(data.get("patterns", []))
+        except Exception:
+            pass
+
+    skill_count = 0
+    skills_dir = memory_dir / "skills"
+    if skills_dir.exists():
+        skill_count = len(list(skills_dir.glob("*.json")))
+
+    return {
+        "backend": "json",
+        "episode_count": ep_count,
+        "pattern_count": pat_count,
+        "skill_count": skill_count,
+    }
+
+
 # Learning/metrics endpoints
 
 

package/docs/INSTALLATION.md

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

package/mcp/__init__.py

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

package/mcp/server.py

@@ -1376,6 +1376,265 @@ async def loki_code_search_stats() -> str:
         return json.dumps({"error": str(e)})
 
 
+# ============================================================
+# MEMORY SEARCH TOOLS (v6.15.0) - SQLite FTS5 powered
+# ============================================================
+
+@mcp.tool()
+async def mem_search(
+    query: str,
+    collection: str = "all",
+    limit: int = 10,
+) -> str:
+    """
+    Search memory using full-text search (FTS5).
+
+    Fast keyword search across all memory types. Supports AND, OR, NOT
+    operators and prefix matching (e.g. "debug*").
+
+    Args:
+        query: Search query (plain text or FTS5 syntax)
+        collection: Which memories to search (episodes, patterns, skills, all)
+        limit: Maximum results to return
+
+    Returns:
+        JSON array of matching memories with relevance scores
+    """
+    _emit_tool_event_async(
+        'mem_search', 'start',
+        parameters={'query': query, 'collection': collection, 'limit': limit}
+    )
+    try:
+        base_path = safe_path_join('.loki', 'memory')
+        if not os.path.exists(base_path):
+            result = json.dumps({"results": [], "message": "Memory system not initialized"})
+            _emit_tool_event_async('mem_search', 'complete', result_status='success')
+            return result
+
+        # Try SQLite backend first (has FTS5), fall back to keyword search
+        try:
+            from memory.sqlite_storage import SQLiteMemoryStorage
+            storage = SQLiteMemoryStorage(base_path)
+            results = storage.search_fts(query, collection=collection, limit=limit)
+        except (ImportError, Exception):
+            # Fall back to retrieval-based search
+            from memory.retrieval import MemoryRetrieval
+            from memory.storage import MemoryStorage
+            storage = MemoryStorage(base_path)
+            retriever = MemoryRetrieval(storage)
+            context = {"goal": query, "task_type": "exploration"}
+            results = retriever.retrieve_task_aware(context, top_k=limit)
+
+        # Compact results for token efficiency
+        compact = []
+        for r in results:
+            entry = {
+                "id": r.get("id", ""),
+                "type": r.get("_type", r.get("type", "unknown")),
+                "summary": (
+                    r.get("goal", "") or
+                    r.get("pattern", "") or
+                    r.get("description", "") or
+                    r.get("name", "")
+                )[:200],
+            }
+            if r.get("_score"):
+                entry["score"] = round(r["_score"], 3)
+            if r.get("outcome"):
+                entry["outcome"] = r["outcome"]
+            if r.get("category"):
+                entry["category"] = r["category"]
+            compact.append(entry)
+
+        result = json.dumps({"results": compact, "count": len(compact)}, default=str)
+        _emit_tool_event_async('mem_search', 'complete', result_status='success')
+        return result
+    except PathTraversalError as e:
+        logger.error(f"Path traversal attempt blocked: {e}")
+        _emit_tool_event_async('mem_search', 'complete', result_status='error', error='Access denied')
+        return json.dumps({"error": "Access denied", "results": []})
+    except Exception as e:
+        logger.error(f"mem_search failed: {e}")
+        _emit_tool_event_async('mem_search', 'complete', result_status='error', error=str(e))
+        return json.dumps({"error": str(e), "results": []})
+
+
+@mcp.tool()
+async def mem_timeline(
+    around_id: str = "",
+    limit: int = 20,
+    since_hours: int = 24,
+) -> str:
+    """
+    Get chronological context from memory timeline.
+
+    Shows recent actions, key decisions, and episode traces in time order.
+    Use around_id to get context surrounding a specific memory entry.
+
+    Args:
+        around_id: Optional memory ID to center the timeline around
+        limit: Maximum timeline entries to return
+        since_hours: Only show entries from the last N hours (default 24)
+
+    Returns:
+        JSON timeline with actions and decisions
+    """
+    _emit_tool_event_async(
+        'mem_timeline', 'start',
+        parameters={'around_id': around_id, 'limit': limit, 'since_hours': since_hours}
+    )
+    try:
+        base_path = safe_path_join('.loki', 'memory')
+        if not os.path.exists(base_path):
+            result = json.dumps({"timeline": [], "message": "Memory system not initialized"})
+            _emit_tool_event_async('mem_timeline', 'complete', result_status='success')
+            return result
+
+        from datetime import timedelta
+        cutoff = datetime.now(timezone.utc) - timedelta(hours=since_hours)
+
+        try:
+            from memory.sqlite_storage import SQLiteMemoryStorage
+            storage = SQLiteMemoryStorage(base_path)
+
+            # Get timeline actions
+            timeline = storage.get_timeline()
+            actions = timeline.get("recent_actions", [])[:limit]
+
+            # Get recent episodes for richer context
+            episode_ids = storage.list_episodes(since=cutoff, limit=limit)
+            episodes = []
+            for eid in episode_ids:
+                ep = storage.load_episode(eid)
+                if ep:
+                    episodes.append({
+                        "id": ep.get("id"),
+                        "timestamp": ep.get("timestamp"),
+                        "phase": ep.get("phase"),
+                        "goal": (ep.get("goal", "") or "")[:150],
+                        "outcome": ep.get("outcome"),
+                        "duration_seconds": ep.get("duration_seconds"),
+                        "files_modified": ep.get("files_modified", [])[:5],
+                    })
+
+        except (ImportError, Exception):
+            from memory.storage import MemoryStorage
+            storage = MemoryStorage(base_path)
+            timeline = storage.get_timeline()
+            actions = timeline.get("recent_actions", [])[:limit]
+
+            episode_ids = storage.list_episodes(since=cutoff, limit=limit)
+            episodes = []
+            for eid in episode_ids:
+                ep = storage.load_episode(eid)
+                if ep:
+                    episodes.append({
+                        "id": ep.get("id"),
+                        "timestamp": ep.get("timestamp"),
+                        "phase": ep.get("phase"),
+                        "goal": (ep.get("goal", "") or "")[:150],
+                        "outcome": ep.get("outcome"),
+                    })
+
+        result = json.dumps({
+            "actions": actions,
+            "episodes": episodes,
+            "decisions": timeline.get("key_decisions", [])[:10],
+            "active_context": timeline.get("active_context", {}),
+        }, default=str)
+        _emit_tool_event_async('mem_timeline', 'complete', result_status='success')
+        return result
+    except PathTraversalError as e:
+        logger.error(f"Path traversal attempt blocked: {e}")
+        _emit_tool_event_async('mem_timeline', 'complete', result_status='error', error='Access denied')
+        return json.dumps({"error": "Access denied", "timeline": []})
+    except Exception as e:
+        logger.error(f"mem_timeline failed: {e}")
+        _emit_tool_event_async('mem_timeline', 'complete', result_status='error', error=str(e))
+        return json.dumps({"error": str(e), "timeline": []})
+
+
+@mcp.tool()
+async def mem_get(
+    ids: str,
+) -> str:
+    """
+    Fetch full details for one or more memory entries by ID.
+
+    Use after mem_search to get complete data for specific results.
+
+    Args:
+        ids: Comma-separated list of memory IDs to fetch
+
+    Returns:
+        JSON object with full memory details keyed by ID
+    """
+    _emit_tool_event_async(
+        'mem_get', 'start',
+        parameters={'ids': ids}
+    )
+    try:
+        base_path = safe_path_join('.loki', 'memory')
+        if not os.path.exists(base_path):
+            result = json.dumps({"entries": {}, "message": "Memory system not initialized"})
+            _emit_tool_event_async('mem_get', 'complete', result_status='success')
+            return result
+
+        id_list = [i.strip() for i in ids.split(",") if i.strip()]
+        if not id_list:
+            return json.dumps({"entries": {}, "error": "No IDs provided"})
+
+        # Cap at 20 to prevent abuse
+        id_list = id_list[:20]
+
+        try:
+            from memory.sqlite_storage import SQLiteMemoryStorage
+            storage = SQLiteMemoryStorage(base_path)
+        except (ImportError, Exception):
+            from memory.storage import MemoryStorage
+            storage = MemoryStorage(base_path)
+
+        entries = {}
+        for mem_id in id_list:
+            mem_id = mem_id.strip()
+            # Try each collection
+            data = storage.load_episode(mem_id)
+            if data:
+                data["_type"] = "episode"
+                entries[mem_id] = data
+                continue
+
+            data = storage.load_pattern(mem_id)
+            if data:
+                data["_type"] = "pattern"
+                entries[mem_id] = data
+                continue
+
+            data = storage.load_skill(mem_id)
+            if data:
+                data["_type"] = "skill"
+                entries[mem_id] = data
+                continue
+
+            entries[mem_id] = None  # Not found
+
+        result = json.dumps({
+            "entries": entries,
+            "found": sum(1 for v in entries.values() if v is not None),
+            "total_requested": len(id_list),
+        }, default=str)
+        _emit_tool_event_async('mem_get', 'complete', result_status='success')
+        return result
+    except PathTraversalError as e:
+        logger.error(f"Path traversal attempt blocked: {e}")
+        _emit_tool_event_async('mem_get', 'complete', result_status='error', error='Access denied')
+        return json.dumps({"error": "Access denied", "entries": {}})
+    except Exception as e:
+        logger.error(f"mem_get failed: {e}")
+        _emit_tool_event_async('mem_get', 'complete', result_status='error', error=str(e))
+        return json.dumps({"error": str(e), "entries": {}})
+
+
 # ============================================================
 # PROMPTS - Pre-built prompt templates
 # ============================================================

package/memory/__init__.py

@@ -42,12 +42,18 @@ from .schemas import (
 
 from .storage import MemoryStorage, DEFAULT_NAMESPACE
 
+try:
+    from .sqlite_storage import SQLiteMemoryStorage
+except ImportError:
+    SQLiteMemoryStorage = None
+
 from .engine import (
     MemoryEngine,
     EpisodicMemory,
     SemanticMemory,
     ProceduralMemory,
     TASK_STRATEGIES,
+    create_storage,
 )
 
 from .retrieval import (
@@ -110,6 +116,8 @@ __all__ = [
     "ProceduralSkill",
     # Engine
     "MemoryStorage",
+    "SQLiteMemoryStorage",
+    "create_storage",
     "MemoryEngine",
     "EpisodicMemory",
     "SemanticMemory",

package/memory/engine.py

@@ -1295,3 +1295,24 @@ class ProceduralMemory:
     def search(self, query: str, top_k: int = 5) -> List[Dict[str, Any]]:
         """Search skills by similarity."""
         return self._engine.retrieve_by_similarity(query, "procedural", top_k)
+
+
+def create_storage(base_path: str = ".loki/memory", namespace: Optional[str] = None):
+    """
+    Factory function to create the best available storage backend.
+
+    Tries SQLite+FTS5 first (faster search, single file), falls back to
+    JSON-based MemoryStorage if SQLite initialization fails.
+
+    Args:
+        base_path: Base path for memory data
+        namespace: Optional namespace for project isolation
+
+    Returns:
+        SQLiteMemoryStorage or MemoryStorage instance
+    """
+    try:
+        from .sqlite_storage import SQLiteMemoryStorage
+        return SQLiteMemoryStorage(base_path=base_path, namespace=namespace)
+    except Exception:
+        return MemoryStorage(base_path=base_path, namespace=namespace)

package/package.json

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