loki-mode 6.60.0 → 6.62.0

package/integrations/vibe-kanban.md

@@ -0,0 +1,289 @@
+# Vibe Kanban Integration
+
+Loki Mode can optionally integrate with [Vibe Kanban](https://github.com/BloopAI/vibe-kanban) to provide a visual dashboard for monitoring autonomous execution.
+
+## Why Use Vibe Kanban with Loki Mode?
+
+| Feature | Loki Mode Alone | + Vibe Kanban |
+|---------|-----------------|---------------|
+| Task visualization | File-based queues | Visual kanban board |
+| Progress monitoring | Log files | Real-time dashboard |
+| Manual intervention | Edit queue files | Drag-and-drop tasks |
+| Code review | Automated 3-reviewer | + Visual diff review |
+| Parallel agents | Background subagents | Isolated git worktrees |
+
+## Quick Start Guide
+
+### Step 1: Start Vibe Kanban
+
+```bash
+npx vibe-kanban
+```
+
+This will:
+- Start the Vibe Kanban server
+- Automatically open the UI in your browser
+- Keep the server running (leave this terminal open)
+
+### Step 2: Run Loki Mode
+
+Open a NEW terminal in your project directory:
+
+```bash
+# Option A: Using Autonomy Runner (Recommended)
+./autonomy/run.sh ./prd.md
+
+# Option B: Manual Mode via Claude Code
+claude --dangerously-skip-permissions
+# Then: "Loki Mode with PRD at ./prd.md"
+```
+
+### Step 3: Sync Tasks to Vibe Kanban (One Script)
+
+Open another terminal in the same project directory:
+
+```bash
+# One-time sync
+./scripts/sync-to-vibe-kanban.sh
+
+# Or continuous sync (watches for changes)
+./scripts/vibe-sync-watcher.sh
+```
+
+You should see output like:
+```
+[INFO] Project: your-project-name
+[INFO] Path: /Users/username/git/your-project
+[INFO] Database: /Users/username/Library/Application Support/ai.bloop.vibe-kanban/db.sqlite
+[INFO] Project ID: A1B2C3D4E5F6...
+[INFO] Phase: DEVELOPMENT
+[INFO]   pending: 5 tasks
+[INFO]   in-progress: 3 tasks
+[INFO] Synced 8 tasks to Vibe Kanban
+```
+
+### Step 4: View Tasks in Vibe Kanban
+
+Tasks appear immediately in Vibe Kanban (no refresh needed). All synced tasks have `[Loki]` prefix for identification.
+
+## Setup
+
+### 1. Install Vibe Kanban
+
+```bash
+npx vibe-kanban
+```
+
+### 2. Enable Integration in Loki Mode
+
+Set environment variable before running:
+
+```bash
+export LOKI_VIBE_KANBAN=true
+./scripts/loki-wrapper.sh ./docs/requirements.md
+```
+
+Or create `.loki/config/integrations.yaml`:
+
+```yaml
+vibe-kanban:
+  enabled: true
+  sync_interval: 30  # seconds
+  export_path: ~/.vibe-kanban/loki-tasks/
+```
+
+## How It Works
+
+### Direct SQLite Sync (v2.37.1+)
+
+The sync script writes directly to Vibe Kanban's SQLite database:
+
+```
+Loki Mode (.loki/queue/)     sync-to-vibe-kanban.sh     Vibe Kanban (SQLite)
+         │                            │                          │
+         ├─ pending.json ────────────►├─────────────────────────►│ todo
+         ├─ in-progress.json ────────►├─────────────────────────►│ inprogress
+         ├─ completed.json ──────────►├─────────────────────────►│ done
+         └─ failed.json ─────────────►├─────────────────────────►│ cancelled
+```
+
+**Database Location:**
+- macOS: `~/Library/Application Support/ai.bloop.vibe-kanban/db.sqlite`
+- Linux: `~/.local/share/ai.bloop.vibe-kanban/db.sqlite` or `~/.config/ai.bloop.vibe-kanban/db.sqlite`
+
+### Status Mapping
+
+| Loki Status | Vibe Kanban Status |
+|-------------|-------------------|
+| pending | todo |
+| in-progress | inprogress |
+| completed | done |
+| failed | cancelled |
+
+### Task Identification
+
+All synced tasks use `[Loki]` prefix in title for safe identification. On each sync:
+1. Delete all `[Loki]` tasks for the project
+2. Re-insert current tasks from queue files
+
+This ensures clean sync without duplicates.
+
+## Export Script
+
+Add this to export Loki Mode tasks to Vibe Kanban:
+
+```bash
+#!/bin/bash
+# scripts/export-to-vibe-kanban.sh
+
+LOKI_DIR=".loki"
+EXPORT_DIR="${VIBE_KANBAN_DIR:-~/.vibe-kanban/loki-tasks}"
+
+mkdir -p "$EXPORT_DIR"
+
+# Export pending tasks
+if [ -f "$LOKI_DIR/queue/pending.json" ]; then
+    python3 << EOF
+import json
+import os
+
+with open("$LOKI_DIR/queue/pending.json") as f:
+    tasks = json.load(f)
+
+export_dir = os.path.expanduser("$EXPORT_DIR")
+
+for task in tasks:
+    vibe_task = {
+        "id": f"loki-{task['id']}",
+        "title": task.get('payload', {}).get('description', task['type']),
+        "description": json.dumps(task.get('payload', {}), indent=2),
+        "status": "todo",
+        "agent": "claude-code",
+        "tags": [task['type'], f"priority-{task.get('priority', 5)}"],
+        "metadata": {
+            "lokiTaskId": task['id'],
+            "lokiType": task['type'],
+            "createdAt": task.get('createdAt', '')
+        }
+    }
+
+    with open(f"{export_dir}/{task['id']}.json", 'w') as out:
+        json.dump(vibe_task, out, indent=2)
+
+print(f"Exported {len(tasks)} tasks to {export_dir}")
+EOF
+fi
+```
+
+## Real-Time Sync (Advanced)
+
+For real-time sync, run the watcher alongside Loki Mode:
+
+```bash
+#!/bin/bash
+# scripts/vibe-sync-watcher.sh
+
+LOKI_DIR=".loki"
+
+# Watch for queue changes and sync
+while true; do
+    # Use fswatch on macOS, inotifywait on Linux
+    if command -v fswatch &> /dev/null; then
+        fswatch -1 "$LOKI_DIR/queue/"
+    else
+        inotifywait -e modify,create "$LOKI_DIR/queue/" 2>/dev/null
+    fi
+
+    ./scripts/export-to-vibe-kanban.sh
+    sleep 2
+done
+```
+
+## Benefits of Combined Usage
+
+### 1. Visual Progress Tracking
+See all active Loki agents as tasks moving across your kanban board.
+
+### 2. Safe Isolation
+Vibe Kanban runs each agent in isolated git worktrees, perfect for Loki's parallel development.
+
+### 3. Human-in-the-Loop Option
+Pause autonomous execution, review changes visually, then resume.
+
+### 4. Multi-Project Dashboard
+If running Loki Mode on multiple projects, see all in one Vibe Kanban instance.
+
+## Comparison: When to Use What
+
+| Scenario | Recommendation |
+|----------|----------------|
+| Fully autonomous, no monitoring | Loki Mode + Wrapper only |
+| Need visual progress dashboard | Add Vibe Kanban |
+| Want manual task prioritization | Use Vibe Kanban to reorder |
+| Code review before merge | Use Vibe Kanban's diff viewer |
+| Multiple concurrent PRDs | Vibe Kanban for project switching |
+
+## Troubleshooting
+
+### Issue: "Exported 0 tasks total"
+
+**Cause:** No tasks in `.loki/queue/` yet.
+
+**Solutions:**
+1. Make sure Loki Mode is actually running and has created tasks
+2. Check if `.loki/queue/` directory exists: `ls -la .loki/queue/`
+3. Verify queue files have content: `cat .loki/queue/pending.json`
+4. If running manual mode, Loki creates tasks as it works - give it time to start
+
+### Issue: "AttributeError: 'str' object has no attribute 'get'"
+
+**Cause:** Task payload was a string instead of expected JSON object (fixed in v2.35.1).
+
+**Solution:** Update to latest version or apply the fix from PR #9.
+
+### Issue: "STATUS.txt does not exist"
+
+**Cause:** `.loki/STATUS.txt` is only created when using the autonomy runner.
+
+**Solutions:**
+- Use autonomy runner: `./autonomy/run.sh ./prd.md` instead of manual Claude Code
+- Or check task queues directly: `ls -la .loki/queue/`
+- Monitor orchestrator state: `cat .loki/state/orchestrator.json | jq`
+
+### Issue: "Tasks not appearing in Vibe Kanban"
+
+**Checklist:**
+1. Is Vibe Kanban running? Check http://127.0.0.1:53380
+2. Did you run the export script? `./scripts/export-to-vibe-kanban.sh`
+3. Check export directory has files: `ls ~/.vibe-kanban/loki-tasks/`
+4. Refresh the Vibe Kanban browser window
+5. Check Vibe Kanban is configured to watch that directory
+
+### Issue: "No real-time updates"
+
+**Explanation:** The export script runs on-demand, not automatically.
+
+**Solutions:**
+1. Run `./scripts/vibe-sync-watcher.sh` for automatic sync
+2. Or manually run export script periodically: `watch -n 10 ./scripts/export-to-vibe-kanban.sh`
+3. Or refresh manually when you want to check progress
+
+## Expected Workflow
+
+**Important:** This is a manual integration, not automatic. Here's what to expect:
+
+1. Start Vibe Kanban (terminal 1, keeps running)
+2. Start Loki Mode (terminal 2, keeps running)
+3. Wait for Loki to create some tasks
+4. Run export script (terminal 3, one-time or via watcher)
+5. Refresh Vibe Kanban in browser to see tasks
+
+**Loki does NOT automatically push to Vibe Kanban.** You must run the export script.
+
+## Future Integration Ideas
+
+- [ ] Bidirectional sync (Vibe → Loki)
+- [ ] Automatic background sync without watcher script
+- [ ] Vibe Kanban MCP server for agent communication
+- [ ] Shared agent profiles between tools
+- [ ] Unified logging dashboard

package/mcp/__init__.py

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

package/mcp/server.py

@@ -592,6 +592,10 @@ async def loki_memory_store_pattern(
     Returns:
         Pattern ID if successful
     """
+    # Validate confidence range
+    if not (0.0 <= confidence <= 1.0):
+        return json.dumps({"success": False, "error": "confidence must be between 0.0 and 1.0"})
+
     _emit_tool_event_async(
         'loki_memory_store_pattern', 'start',
         parameters={'pattern': pattern, 'category': category, 'confidence': confidence}
@@ -646,8 +650,10 @@ async def loki_task_queue_list() -> str:
         if manager and STATE_MANAGER_AVAILABLE:
             queue = manager.get_state("state/task-queue.json")
             if queue:
+                # Strip internal fields before returning
+                response = {k: v for k, v in queue.items() if k not in ("_next_id", "version")}
                 _emit_tool_event_async('loki_task_queue_list', 'complete', result_status='success')
-                return json.dumps(queue, default=str)
+                return json.dumps(response, default=str)
             # If no queue found via StateManager, return empty
             result = json.dumps({"tasks": [], "message": "No task queue found"})
             _emit_tool_event_async('loki_task_queue_list', 'complete', result_status='success')
@@ -663,8 +669,10 @@ async def loki_task_queue_list() -> str:
         with safe_open(queue_path, 'r') as f:
             queue = json.load(f)
 
+        # Strip internal fields before returning
+        response = {k: v for k, v in queue.items() if k not in ("_next_id", "version")}
         _emit_tool_event_async('loki_task_queue_list', 'complete', result_status='success')
-        return json.dumps(queue, default=str)
+        return json.dumps(response, default=str)
     except PathTraversalError as e:
         logger.error(f"Path traversal attempt blocked: {e}")
         _emit_tool_event_async('loki_task_queue_list', 'complete', result_status='error', error='Access denied')
@@ -694,6 +702,14 @@ async def loki_task_queue_add(
     Returns:
         Task ID if successful
     """
+    # Validate priority and phase enums
+    valid_priorities = {"low", "medium", "high", "critical"}
+    valid_phases = {"discovery", "architecture", "development", "testing", "deployment"}
+    if priority not in valid_priorities:
+        return json.dumps({"success": False, "error": f"priority must be one of: {', '.join(sorted(valid_priorities))}"})
+    if phase not in valid_phases:
+        return json.dumps({"success": False, "error": f"phase must be one of: {', '.join(sorted(valid_phases))}"})
+
     _emit_tool_event_async(
         'loki_task_queue_add', 'start',
         parameters={'title': title, 'priority': priority, 'phase': phase}
@@ -716,7 +732,17 @@ async def loki_task_queue_add(
                 queue = {"tasks": [], "version": "1.0"}
 
         # Create new task with monotonic counter to avoid ID collisions after deletions
-        next_id = queue.get("_next_id", len(queue['tasks']) + 1)
+        # When _next_id is missing, scan existing IDs to find the max and use max+1
+        if "_next_id" not in queue:
+            existing_ids = []
+            for t in queue.get("tasks", []):
+                try:
+                    existing_ids.append(int(t["id"].replace("task-", "")))
+                except (ValueError, KeyError):
+                    pass
+            next_id = (max(existing_ids) + 1) if existing_ids else 1
+        else:
+            next_id = queue["_next_id"]
         task_id = f"task-{next_id:04d}"
         queue["_next_id"] = next_id + 1
         task = {
@@ -768,6 +794,14 @@ async def loki_task_queue_update(
     Returns:
         Updated task if successful
     """
+    # Validate status and priority enums when provided
+    valid_statuses = {"pending", "in_progress", "completed", "blocked"}
+    valid_priorities = {"low", "medium", "high", "critical"}
+    if status is not None and status not in valid_statuses:
+        return json.dumps({"success": False, "error": f"status must be one of: {', '.join(sorted(valid_statuses))}"})
+    if priority is not None and priority not in valid_priorities:
+        return json.dumps({"success": False, "error": f"priority must be one of: {', '.join(sorted(valid_priorities))}"})
+
     _emit_tool_event_async(
         'loki_task_queue_update', 'start',
         parameters={'task_id': task_id, 'status': status, 'priority': priority}
@@ -793,9 +827,9 @@ async def loki_task_queue_update(
         # Find and update task
         for task in queue["tasks"]:
             if task["id"] == task_id:
-                if status:
+                if status is not None:
                     task["status"] = status
-                if priority:
+                if priority is not None:
                     task["priority"] = priority
                 task["updated_at"] = datetime.now(timezone.utc).isoformat()
 
@@ -850,7 +884,7 @@ async def loki_state_get() -> str:
                 state["autonomy_state"] = autonomy_data
         else:
             # Fallback to direct file read
-            state_path = safe_path_join('.loki', 'state', 'autonomy-state.json')
+            state_path = safe_path_join('.loki', 'autonomy-state.json')
             if os.path.exists(state_path):
                 with safe_open(state_path, 'r') as f:
                     state["autonomy_state"] = json.load(f)
@@ -1056,8 +1090,15 @@ async def loki_start_project(prd_content: str = "", prd_path: str = "") -> str:
         if not content:
             return json.dumps({"error": "No PRD content or path provided"})
 
-        # Initialize project state
-        os.makedirs('.loki/state', exist_ok=True)
+        # Initialize project state using safe path operations
+        state_dir = safe_path_join('.loki', 'state')
+        safe_makedirs(state_dir, exist_ok=True)
+
+        # Persist PRD content so downstream tools can access it
+        prd_dest = safe_path_join('.loki', 'state', 'prd.md')
+        with safe_open(prd_dest, 'w') as f:
+            f.write(content)
+
         project = {
             "status": "initialized",
             "prd_length": len(content),
@@ -1201,10 +1242,11 @@ async def loki_checkpoint_restore(checkpoint_id: str = "") -> str:
         if not target:
             return json.dumps({"error": f"Checkpoint not found: {checkpoint_id}"})
 
-        # Write checkpoint state as current state
+        # Write checkpoint state as current state, stripping the injected "id" field
+        restored_state = {k: v for k, v in target.items() if k != "id"}
         state_path = safe_path_join('.loki', 'state', 'orchestrator.json')
         with safe_open(state_path, 'w') as f:
-            json.dump(target, f, indent=2)
+            json.dump(restored_state, f, indent=2)
 
         _emit_tool_event_async('loki_checkpoint_restore', 'complete', result_status='success')
         return json.dumps({"restored": True, "checkpoint_id": checkpoint_id})
@@ -1310,7 +1352,10 @@ async def loki_code_search(
         file_filter: Filter by file path substring (e.g., "autonomy/", "dashboard/") (optional)
         type_filter: Filter by chunk type: "function", "class", "header", "section", "file" (optional)
     """
-    _emit_tool_event_async('loki_code_search', 'start', query=query)
+    _emit_tool_event_async('loki_code_search', 'start',
+                           parameters={'query': query, 'n_results': n_results,
+                                       'language': language, 'file_filter': file_filter,
+                                       'type_filter': type_filter})
 
     collection = _get_chroma_collection()
     if collection is None:
@@ -1362,7 +1407,7 @@ async def loki_code_search(
                 "name": meta.get("name", ""),
                 "type": meta.get("type", ""),
                 "language": meta.get("language", ""),
-                "relevance": round(1 - dist, 4),  # Convert distance to similarity
+                "relevance": round(max(0.0, 1.0 - dist / 2.0), 4),  # L2 distance to similarity
                 "preview": preview,
             })
 
@@ -1390,6 +1435,17 @@ async def loki_code_search_stats() -> str:
 
     try:
         count = collection.count()
+
+        # Short-circuit on empty collection to avoid limit=0 error
+        if count == 0:
+            return json.dumps({
+                "total_chunks": 0,
+                "unique_files": 0,
+                "by_language": {},
+                "by_type": {},
+                "reindex_command": "python3.12 tools/index-codebase.py --reset",
+            })
+
         results = collection.get(limit=count, include=["metadatas"])
 
         langs = {}
@@ -1448,19 +1504,13 @@ async def mem_search(
             _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)
+        # Use 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 = []
@@ -1530,48 +1580,25 @@ async def mem_timeline(
         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"),
-                    })
+        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"),
+                    "duration_seconds": ep.get("duration_seconds"),
+                    "files_modified": ep.get("files_modified", [])[:5],
+                })
 
         result = json.dumps({
             "actions": actions,
@@ -1624,12 +1651,8 @@ async def mem_get(
         # 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)
+        from memory.storage import MemoryStorage
+        storage = MemoryStorage(base_path)
 
         entries = {}
         for mem_id in id_list:

package/memory/consolidation.py

@@ -225,6 +225,9 @@ class ConsolidationPipeline:
             if not merged:
                 self.storage.save_pattern(anti_pattern)
                 all_patterns.append(anti_pattern)
+                # Add to existing_patterns so subsequent anti-patterns in this
+                # run are checked against it, preventing current-run duplicates.
+                existing_patterns.append(anti_pattern)
                 result.anti_patterns_created += 1
 
         # 7. Create Zettelkasten links
@@ -294,6 +297,7 @@ class ConsolidationPipeline:
                 label=self._generate_cluster_label([episode])
             )
             used.add(i)
+            member_indices = [i]
 
             # Find similar episodes
             for j, other_episode in enumerate(episodes):
@@ -304,10 +308,11 @@ class ConsolidationPipeline:
                 if similarity >= threshold:
                     cluster.episodes.append(other_episode)
                     used.add(j)
+                    member_indices.append(j)
 
-            # Update centroid
+            # Update centroid using tracked indices (avoids O(n) list.index())
             if len(cluster.episodes) > 1:
-                cluster_embeddings = [embeddings[episodes.index(ep)] for ep in cluster.episodes]
+                cluster_embeddings = [embeddings[idx] for idx in member_indices]
                 cluster.centroid = np.mean(cluster_embeddings, axis=0)
                 cluster.label = self._generate_cluster_label(cluster.episodes)
 
@@ -408,13 +413,23 @@ class ConsolidationPipeline:
         """Convert episode to text for embedding."""
         parts = [episode.goal]
 
-        # Add action summaries
+        # Add action summaries (handle both ActionEntry objects and dicts)
         for action in episode.action_log[:5]:  # Limit to first 5 actions
-            parts.append(f"{action.tool}: {action.input[:100]}")
+            if isinstance(action, dict):
+                tool = action.get("tool", action.get("action", ""))
+                inp = action.get("input", action.get("target", ""))
+            else:
+                tool = action.tool
+                inp = action.input
+            parts.append(f"{tool}: {str(inp)[:100]}")
 
-        # Add error types
+        # Add error types (handle both ErrorEntry objects and dicts)
         for error in episode.errors_encountered:
-            parts.append(f"Error: {error.error_type}")
+            if isinstance(error, dict):
+                err_type = error.get("error_type", error.get("type", ""))
+            else:
+                err_type = error.error_type
+            parts.append(f"Error: {err_type}")
 
         return " ".join(parts)