loki-mode 6.14.0 → 6.15.1

package/README.md

@@ -9,7 +9,7 @@
 [![Agent Types](https://img.shields.io/badge/Agent%20Types-41-blue)]()
 [![Autonomi](https://img.shields.io/badge/Autonomi-autonomi.dev-5B4EEA)](https://www.autonomi.dev/)
 
-**Current Version: v6.14.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.14.0
+# Loki Mode v6.15.1
 
 **You are an autonomous agent. You make decisions. You do not ask questions. You do not stop.**
 
@@ -267,4 +267,4 @@ The following features are documented in skill modules but not yet fully automat
 | Quality gates 3-reviewer system | Implemented (v5.35.0) | 5 specialist reviewers in `skills/quality-gates.md`; execution in run.sh |
 | Benchmarks (HumanEval, SWE-bench) | Infrastructure only | Runner scripts and datasets exist in `benchmarks/`; no published results |
 
-**v6.14.0 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**
+**v6.15.1 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**

package/VERSION

@@ -1 +1 @@
-6.14.0
+6.15.1

package/autonomy/bmad-adapter.py

@@ -147,6 +147,7 @@ class BmadArtifacts:
         self.prd_path: Optional[Path] = None
         self.architecture_path: Optional[Path] = None
         self.epics_path: Optional[Path] = None
+        self.sprint_status_path: Optional[Path] = None
         self.output_dir: Optional[Path] = None
         self.errors: List[str] = []
         self._discover()
@@ -202,6 +203,11 @@ class BmadArtifacts:
         if epics_path.exists():
             self.epics_path = epics_path
 
+        # Find sprint-status.yml (optional)
+        sprint_path = self.output_dir / "sprint-status.yml"
+        if sprint_path.exists():
+            self.sprint_status_path = sprint_path
+
     @property
     def is_valid(self) -> bool:
         """True if at least a PRD was found."""
@@ -213,6 +219,7 @@ class BmadArtifacts:
             "prd": str(self.prd_path) if self.prd_path else None,
             "architecture": str(self.architecture_path) if self.architecture_path else None,
             "epics": str(self.epics_path) if self.epics_path else None,
+            "sprint_status": str(self.sprint_status_path) if self.sprint_status_path else None,
         }
 
 
@@ -438,6 +445,73 @@ def parse_epics(epics_path: Path) -> List[Dict[str, Any]]:
     return epics
 
 
+# -- Sprint Status Parsing (stdlib-only YAML) ---------------------------------
+
+def parse_sprint_status(path: Path) -> set:
+    """Parse sprint-status.yml and return a set of completed story names.
+
+    Uses a simple line-by-line parser for the specific BMAD sprint-status
+    format (no PyYAML dependency). Recognizes stories with status
+    'completed' or 'done' (case-insensitive).
+
+    Expected format:
+        epics:
+          - name: "Epic Name"
+            status: in-progress
+            stories:
+              - name: "Story title"
+                status: completed
+    """
+    text = _safe_read(path)
+    completed: set = set()
+    current_name: Optional[str] = None
+    in_stories = False
+
+    for line in text.split("\n"):
+        stripped = line.strip()
+        if not stripped or stripped.startswith("#"):
+            continue
+
+        # Detect stories: block start
+        if stripped == "stories:":
+            in_stories = True
+            current_name = None
+            continue
+
+        # Detect epics: block start (reset stories context)
+        if stripped == "epics:":
+            in_stories = False
+            current_name = None
+            continue
+
+        # Top-level list item under epics resets stories context
+        # (indentation: "  - name:" for epics vs "      - name:" for stories)
+        indent = len(line) - len(line.lstrip())
+
+        if in_stories:
+            # Story name line: "      - name: ..." or "        name: ..."
+            name_match = re.match(r'^-?\s*name:\s*["\']?(.*?)["\']?\s*$', stripped)
+            if name_match:
+                current_name = name_match.group(1).strip()
+                continue
+
+            # Story status line
+            status_match = re.match(r'^status:\s*["\']?(.*?)["\']?\s*$', stripped)
+            if status_match:
+                status = status_match.group(1).strip().lower()
+                if status in ("completed", "done") and current_name:
+                    completed.add(current_name)
+                current_name = None
+                continue
+
+            # A new epic-level item resets context
+            if indent <= 4 and stripped.startswith("- name:"):
+                in_stories = False
+                current_name = None
+
+    return completed
+
+
 # -- Architecture Summary -----------------------------------------------------
 
 def summarize_architecture(arch_path: Path) -> str:
@@ -593,6 +667,7 @@ def write_outputs(
     arch_summary: Optional[str],
     tasks_json: Optional[List[Dict[str, Any]]],
     validation_report: Optional[List[Dict[str, str]]],
+    completed_stories: Optional[set] = None,
 ) -> List[str]:
     """Write all output files to the specified directory.
 
@@ -633,6 +708,12 @@ def write_outputs(
         _write_atomic(val_path, "\n".join(val_lines) + "\n")
         written.append(str(val_path))
 
+    # bmad-completed-stories.json
+    if completed_stories:
+        completed_path = output_dir / "bmad-completed-stories.json"
+        _write_atomic(completed_path, json.dumps(sorted(completed_stories), indent=2))
+        written.append(str(completed_path))
+
     return written
 
 
@@ -674,6 +755,11 @@ def run(
     if artifacts.epics_path:
         epics_data = parse_epics(artifacts.epics_path)
 
+    # 4b. Parse sprint status (optional)
+    completed_stories: Optional[set] = None
+    if artifacts.sprint_status_path:
+        completed_stories = parse_sprint_status(artifacts.sprint_status_path)
+
     # 5. Build combined metadata
     combined_metadata: Dict[str, Any] = {
         "project_classification": classification,
@@ -714,6 +800,7 @@ def run(
         arch_summary=arch_summary,
         tasks_json=epics_data,
         validation_report=validation_report,
+        completed_stories=completed_stories,
     )
 
     print(f"BMAD adapter: processed {artifacts.prd_path}")
@@ -722,7 +809,10 @@ def run(
         print(f"  Classification: {classification.get('project_type', 'unknown')} / {classification.get('complexity', 'unknown')}")
     print(f"  Artifacts: PRD={'found' if artifacts.prd_path else 'MISSING'}, "
           f"Architecture={'found' if artifacts.architecture_path else 'missing'}, "
-          f"Epics={'found' if artifacts.epics_path else 'missing'}")
+          f"Epics={'found' if artifacts.epics_path else 'missing'}, "
+          f"SprintStatus={'found' if artifacts.sprint_status_path else 'missing'}")
+    if completed_stories:
+        print(f"  Completed stories (will skip): {len(completed_stories)}")
     print(f"  Output files written to {abs_output_dir}/:")
     for path in written:
         print(f"    - {Path(path).name}")

package/autonomy/loki

@@ -756,7 +756,7 @@ cmd_start() {
 
         # Run the BMAD adapter to normalize artifacts
         echo -e "${CYAN}Running BMAD adapter...${NC}"
-        local adapter_script="${SCRIPT_DIR:-$(dirname "$0")}/bmad-adapter.py"
+        local adapter_script="$(dirname "$(resolve_script_path "$0")")/bmad-adapter.py"
         if [[ ! -f "$adapter_script" ]]; then
             echo -e "${RED}Error: BMAD adapter not found at $adapter_script${NC}"
             echo "Please ensure autonomy/bmad-adapter.py exists."
@@ -808,7 +808,7 @@ cmd_start() {
 
         # Run the OpenSpec adapter to normalize artifacts
         echo -e "${CYAN}Running OpenSpec adapter...${NC}"
-        local adapter_script="${SCRIPT_DIR:-$(dirname "$0")}/openspec-adapter.py"
+        local adapter_script="$(dirname "$(resolve_script_path "$0")")/openspec-adapter.py"
         if [[ ! -f "$adapter_script" ]]; then
             echo -e "${RED}Error: OpenSpec adapter not found at $adapter_script${NC}"
             echo "Please ensure autonomy/openspec-adapter.py exists."

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:-.}"
@@ -7802,6 +7879,7 @@ import sys
 
 bmad_tasks_path = ".loki/bmad-tasks.json"
 pending_path = ".loki/queue/pending.json"
+completed_stories_path = ".loki/bmad-completed-stories.json"
 
 try:
     with open(bmad_tasks_path, "r") as f:
@@ -7810,6 +7888,17 @@ except (json.JSONDecodeError, FileNotFoundError) as e:
     print(f"Warning: Could not read BMAD tasks: {e}", file=sys.stderr)
     sys.exit(0)
 
+# Load completed stories from sprint-status (if available)
+completed_stories = set()
+if os.path.exists(completed_stories_path):
+    try:
+        with open(completed_stories_path, "r") as f:
+            completed_list = json.load(f)
+            if isinstance(completed_list, list):
+                completed_stories = {s.lower() for s in completed_list if isinstance(s, str)}
+    except (json.JSONDecodeError, FileNotFoundError):
+        pass
+
 # Extract stories from BMAD structure
 # Supports both flat list and nested epic/story format
 stories = []
@@ -7837,6 +7926,21 @@ if not stories:
     print("No BMAD stories found to queue", file=sys.stderr)
     sys.exit(0)
 
+# Filter out completed stories from sprint-status
+skipped_count = 0
+if completed_stories:
+    filtered = []
+    for story in stories:
+        if isinstance(story, dict):
+            title = story.get("title", story.get("name", "")).lower()
+            if title and title in completed_stories:
+                skipped_count += 1
+                continue
+        filtered.append(story)
+    stories = filtered
+    if skipped_count > 0:
+        print(f"Skipped {skipped_count} completed stories (from sprint-status.yml)", file=sys.stderr)
+
 # Load existing pending tasks (if any)
 existing = []
 if os.path.exists(pending_path):
@@ -7877,7 +7981,10 @@ for i, story in enumerate(stories):
 with open(pending_path, "w") as f:
     json.dump(existing, f, indent=2)
 
-print(f"Added {len(stories)} BMAD stories to task queue")
+msg = f"Added {len(stories)} BMAD stories to task queue"
+if skipped_count > 0:
+    msg += f" (skipped {skipped_count} completed)"
+print(msg)
 BMAD_QUEUE_EOF
 
     if [[ $? -ne 0 ]]; then
@@ -8614,13 +8721,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 +8782,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.14.0"
+__version__ = "6.15.1"
 
 # 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.14.0
+**Version:** v6.15.1
 
 ---
 

package/mcp/__init__.py

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

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.14.0",
+  "version": "6.15.1",
   "description": "Loki Mode by Autonomi - Multi-agent autonomous startup system for Claude Code, Codex CLI, and Gemini CLI",
   "keywords": [
     "agent",