loki-mode 7.57.0 → 7.58.1

package/SKILL.md

@@ -3,7 +3,7 @@ name: loki-mode
 description: Autonomous spec-driven build system with a built-in trust layer. It does not call work done until it is verified (RARV-C closure loop, 8 quality gates, completion council, verified-completion evidence gate). Triggers on "Loki Mode". Takes a spec (PRD, GitHub issue, OpenAPI doc, etc.) to deployed product with minimal human intervention. Provider-agnostic. Requires --dangerously-skip-permissions flag.
 ---
 
-# Loki Mode v7.57.0
+# Loki Mode v7.58.1
 
 **You are an autonomous agent. You make decisions. You do not ask questions. You do not stop.**
 
@@ -406,4 +406,4 @@ See `CHANGELOG.md` entries [7.5.7], [7.5.8], [7.5.13] for the per-fix list and r
 
 ---
 
-**v7.57.0 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**
+**v7.58.1 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**

package/VERSION

@@ -1 +1 @@
-7.57.0
+7.58.1

package/autonomy/loki

@@ -2044,7 +2044,7 @@ cmd_start() {
         case "$effective_provider" in
             claude) echo "  npm install -g @anthropic-ai/claude-code" ;;
             codex)  echo "  npm install -g @openai/codex" ;;
-            cline)  echo "  npm install -g @anthropic-ai/cline" ;;
+            cline)  echo "  npm install -g cline" ;;
             aider)  echo "  pip install aider-chat" ;;
             *)      echo "  Check the provider documentation for installation." ;;
         esac
@@ -8049,10 +8049,37 @@ cmd_doctor() {
     echo ""
 
     echo -e "${CYAN}AI Providers:${NC}"
-    doctor_check "Claude CLI"          claude   optional || true
-    doctor_check "Codex CLI"           codex    optional || true
-    doctor_check "Cline CLI"           cline    optional || true
-    doctor_check "Aider CLI"           aider    optional || true
+    # C1 (doctor UX): when an individual provider CLI is missing, print the
+    # EXACT install command right under the WARN line so the user never has to
+    # look it up. doctor_check returns 1 when the CLI is absent; we capture that
+    # and emit the canonical install command for that provider. Honest: this
+    # only PRINTS the command -- the offer-to-run path lives below, gated on a
+    # TTY, and only when NO provider at all is installed.
+    doctor_provider_install_cmd() {
+        case "$1" in
+            claude) echo "npm install -g @anthropic-ai/claude-code" ;;
+            codex)  echo "npm install -g @openai/codex" ;;
+            cline)  echo "npm install -g cline" ;;
+            aider)  echo "pip install aider-chat" ;;
+            *)      echo "" ;;
+        esac
+    }
+    doctor_check_provider() {
+        local _label="$1" _cmd="$2"
+        if ! doctor_check "$_label" "$_cmd" optional; then
+            local _install
+            _install=$(doctor_provider_install_cmd "$_cmd")
+            # Route the per-provider install hint to STDERR (fd 2), mirroring the
+            # doctor_probe_note stderr-only pattern above. This keeps the
+            # parity-captured STDOUT byte-identical to the Bun route (which emits
+            # no per-provider Install line) while the user still sees the hint.
+            [ -n "$_install" ] && echo -e "         ${YELLOW}Install: ${_install}${NC}" >&2
+        fi
+    }
+    doctor_check_provider "Claude CLI"  claude || true
+    doctor_check_provider "Codex CLI"   codex  || true
+    doctor_check_provider "Cline CLI"   cline  || true
+    doctor_check_provider "Aider CLI"   aider  || true
 
     # Check if at least one provider is installed (detect_any_provider is the
     # shared helper from provider-offer.sh, extracted from this exact loop).
@@ -8161,11 +8188,36 @@ cmd_doctor() {
         echo -e "  ${YELLOW}WARN${NC}  sentence-transformers - not installed (loki memory vectors setup)"
         warn_count=$((warn_count + 1))
     fi
-    # ChromaDB check
-    if curl -sf http://localhost:8100/api/v2/heartbeat >/dev/null 2>&1; then
+    # C3 (doctor UX): the next checks are bounded network probes, not instant
+    # local lookups. They are the slowest part of doctor (a stale/unreachable
+    # host could otherwise hang on curl's default ~2min connect timeout). We
+    # (a) bound every probe with --connect-timeout/--max-time so a dead host
+    # fails fast, and (b) print a transient progress note to stderr on a TTY so
+    # the user knows doctor is doing network work, not stuck. The note goes to
+    # stderr only -- the parity-captured stdout stays byte-identical across the
+    # bash and Bun routes.
+    doctor_probe_note() {
+        # return 0 is mandatory: [ -t 2 ] returns 1 off a TTY, and under
+        # set -euo pipefail a bare call here aborts the whole doctor run on
+        # CI/headless (the v7.58.1 Bun-Parity crash).
+        [ -t 2 ] && printf '  %s...\r' "$1" >&2
+        return 0
+    }
+    doctor_probe_clear() {
+        # Erase the transient progress line so it does not linger above the
+        # PASS/WARN result. Only on a TTY (where the note was printed).
+        # return 0: same set -e safety as doctor_probe_note.
+        [ -t 2 ] && printf '\r\033[K' >&2
+        return 0
+    }
+    # ChromaDB check (bounded network probe)
+    doctor_probe_note "Probing ChromaDB (port 8100)"
+    if curl -sf --connect-timeout 2 --max-time 5 http://localhost:8100/api/v2/heartbeat >/dev/null 2>&1; then
+        doctor_probe_clear
         echo -e "  ${GREEN}PASS${NC}  ChromaDB server (port 8100)"
         pass_count=$((pass_count + 1))
     else
+        doctor_probe_clear
         echo -e "  ${YELLOW}WARN${NC}  ChromaDB - not running (docker start loki-chroma)"
         warn_count=$((warn_count + 1))
     fi
@@ -8189,10 +8241,13 @@ cmd_doctor() {
     # MiroFish check (optional service)
     local _mf_url="${LOKI_MIROFISH_URL:-http://localhost:5001}"
     if docker inspect loki-mirofish &>/dev/null 2>&1 || [[ -n "${LOKI_MIROFISH_URL:-}" ]]; then
-        if curl -sf "$_mf_url/health" >/dev/null 2>&1; then
+        doctor_probe_note "Probing MiroFish ($_mf_url)"
+        if curl -sf --connect-timeout 2 --max-time 5 "$_mf_url/health" >/dev/null 2>&1; then
+            doctor_probe_clear
             echo -e "  ${GREEN}PASS${NC}  MiroFish server ($_mf_url)"
             pass_count=$((pass_count + 1))
         else
+            doctor_probe_clear
             echo -e "  ${YELLOW}WARN${NC}  MiroFish - not running (loki start --mirofish-docker <image>)"
             warn_count=$((warn_count + 1))
         fi
@@ -9939,7 +9994,7 @@ QPRDEOF
         case "$_quick_provider" in
             claude) echo "  npm install -g @anthropic-ai/claude-code" ;;
             codex)  echo "  npm install -g @openai/codex" ;;
-            cline)  echo "  npm install -g @anthropic-ai/cline" ;;
+            cline)  echo "  npm install -g cline" ;;
             aider)  echo "  pip install aider-chat" ;;
             *)      echo "  Check the provider documentation for installation." ;;
         esac

package/dashboard/__init__.py

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

package/dashboard/server.py

@@ -3865,34 +3865,40 @@ 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 -- use heapq to avoid sorting all files
-    import heapq
-    ep_dir = _get_loki_dir() / "memory" / "episodic"
-    episodes = []
-    if ep_dir.exists():
-        all_files = ep_dir.glob("*.json")
-        # nlargest by filename (timestamps sort lexicographically) avoids full sort
-        files = heapq.nlargest(limit, all_files, key=lambda f: f.name)
-        for f in files:
+    # Both backends below are blocking (SQLite queries / a glob+read loop over
+    # many JSON files) and only build a local list, so offload the whole read
+    # off the event loop to keep status + WS heartbeat responsive.
+    def _load_episodes() -> list:
+        # Try SQLite backend first
+        storage = _get_memory_storage()
+        if storage is not None:
             try:
-                episodes.append(json.loads(f.read_text()))
+                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
-    return episodes
+
+        # Fallback to JSON files -- use heapq to avoid sorting all files
+        import heapq
+        ep_dir = _get_loki_dir() / "memory" / "episodic"
+        episodes = []
+        if ep_dir.exists():
+            all_files = ep_dir.glob("*.json")
+            # nlargest by filename (timestamps sort lexicographically) avoids full sort
+            files = heapq.nlargest(limit, all_files, key=lambda f: f.name)
+            for f in files:
+                try:
+                    episodes.append(json.loads(f.read_text()))
+                except Exception:
+                    pass
+        return episodes
+
+    return await asyncio.to_thread(_load_episodes)
 
 
 @app.get("/api/memory/episodes/{episode_id}", dependencies=[Depends(auth.require_scope("read"))])
@@ -3969,30 +3975,35 @@ 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():
-        for f in sorted(skills_dir.glob("*.json")):
+    # Blocking SQLite query / glob+read loop; offload the whole read so the
+    # event loop (status + WS heartbeat) stays responsive.
+    def _load_skills() -> list:
+        # Try SQLite first
+        storage = _get_memory_storage()
+        if storage is not None:
             try:
-                skills.append(json.loads(f.read_text()))
+                ids = storage.list_skills()
+                skills = []
+                for sid in ids:
+                    s = storage.load_skill(sid)
+                    if s:
+                        skills.append(s)
+                return skills
             except Exception:
                 pass
-    return skills
+
+        # Fallback to JSON
+        skills_dir = _get_loki_dir() / "memory" / "skills"
+        skills = []
+        if skills_dir.exists():
+            for f in sorted(skills_dir.glob("*.json")):
+                try:
+                    skills.append(json.loads(f.read_text()))
+                except Exception:
+                    pass
+        return skills
+
+    return await asyncio.to_thread(_load_skills)
 
 
 @app.get("/api/memory/skills/{skill_id}", dependencies=[Depends(auth.require_scope("read"))])
@@ -4347,15 +4358,16 @@ async def get_memory_file(
         st = target.stat()
     except Exception:
         raise HTTPException(status_code=500, detail="stat failed")
-    truncated = False
+    truncated = st.st_size > _MEMORY_FILE_MAX_BYTES
+
+    def _read_memory_blob() -> bytes:
+        # Up to a 2 MiB blocking read; offloaded so the single-worker event
+        # loop (and /api/status + WS heartbeat) stays responsive.
+        with open(target, "rb") as fh:
+            return fh.read(_MEMORY_FILE_MAX_BYTES) if truncated else fh.read()
+
     try:
-        if st.st_size > _MEMORY_FILE_MAX_BYTES:
-            with open(target, "rb") as fh:
-                raw = fh.read(_MEMORY_FILE_MAX_BYTES)
-            truncated = True
-        else:
-            with open(target, "rb") as fh:
-                raw = fh.read()
+        raw = await asyncio.to_thread(_read_memory_blob)
         # Decode as UTF-8 with replacement so we never 500 on a stray byte.
         content = raw.decode("utf-8", errors="replace")
     except HTTPException:
@@ -4433,44 +4445,49 @@ async def search_memory(
 @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
+    # SQLite stats query or a directory-walk over many JSON files; both block,
+    # so offload off the event loop.
+    def _compute_stats() -> dict:
+        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
+        # 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")))
+        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,
-    }
+        return {
+            "backend": "json",
+            "episode_count": ep_count,
+            "pattern_count": pat_count,
+            "skill_count": skill_count,
+        }
+
+    return await asyncio.to_thread(_compute_stats)
 
 
 # Learning/metrics endpoints
@@ -4516,10 +4533,10 @@ async def get_learning_metrics(
     source: Optional[str] = None,
 ):
     """Get learning metrics from events, metrics files, and learning signals."""
-    events = _read_events(timeRange)
+    events = await asyncio.to_thread(_read_events, timeRange)
 
     # Also read from learning signals directory
-    all_signals = _read_learning_signals(limit=10000)
+    all_signals = await asyncio.to_thread(_read_learning_signals, limit=10000)
 
     # Filter by type and source
     if signalType:
@@ -4596,7 +4613,7 @@ async def get_learning_trends(
     source: Optional[str] = None,
 ):
     """Get learning trend data."""
-    events = _read_events(timeRange)
+    events = await asyncio.to_thread(_read_events, timeRange)
     # Group by hour for trend data
     by_hour: dict = {}
     for e in events:
@@ -4618,14 +4635,14 @@ async def get_learning_signals(
     offset: int = Query(default=0, ge=0),
 ):
     """Get raw learning signals from both events.jsonl and learning signals directory."""
-    events = _read_events(timeRange)
+    events = await asyncio.to_thread(_read_events, timeRange)
     if signalType:
         events = [e for e in events if e.get("type") == signalType]
     if source:
         events = [e for e in events if e.get("data", {}).get("source") == source]
 
     # Also read from learning signals directory
-    file_signals = _read_learning_signals(signal_type=signalType, limit=10000)
+    file_signals = await asyncio.to_thread(_read_learning_signals, signal_type=signalType, limit=10000)
     if source:
         file_signals = [s for s in file_signals if s.get("source") == source]
 
@@ -4649,10 +4666,10 @@ async def get_learning_aggregation():
             pass
 
     # Supplement with live data from learning signals directory
-    success_signals = _read_learning_signals(signal_type="success_pattern", limit=500)
-    tool_signals = _read_learning_signals(signal_type="tool_efficiency", limit=500)
-    error_signals = _read_learning_signals(signal_type="error_pattern", limit=500)
-    pref_signals = _read_learning_signals(signal_type="user_preference", limit=500)
+    success_signals = await asyncio.to_thread(_read_learning_signals, signal_type="success_pattern", limit=500)
+    tool_signals = await asyncio.to_thread(_read_learning_signals, signal_type="tool_efficiency", limit=500)
+    error_signals = await asyncio.to_thread(_read_learning_signals, signal_type="error_pattern", limit=500)
+    pref_signals = await asyncio.to_thread(_read_learning_signals, signal_type="user_preference", limit=500)
 
     # Merge success patterns from signals if aggregation file had none
     if not result.get("success_patterns") and success_signals:
@@ -4726,6 +4743,14 @@ async def trigger_aggregation():
     if not _read_limiter.check("learning_aggregate"):
         raise HTTPException(status_code=429, detail="Rate limit exceeded")
 
+    # Reads up to 10 MB of events.jsonl, parses every line, then writes the
+    # aggregation.json metrics file. All blocking, all on local state +
+    # filesystem (no shared in-memory state), so offload the whole computation
+    # to a thread to keep the event loop (status + WS heartbeat) responsive.
+    return await asyncio.to_thread(_compute_learning_aggregation)
+
+
+def _compute_learning_aggregation() -> dict:
     events_file = _get_loki_dir() / "events.jsonl"
     preferences: dict = {}
     error_patterns: dict = {}
@@ -4821,10 +4846,10 @@ async def trigger_aggregation():
 @app.get("/api/learning/preferences", dependencies=[Depends(auth.require_scope("read"))])
 async def get_learning_preferences(limit: int = Query(default=50, ge=1, le=1000)):
     """Get aggregated user preferences from events and learning signals directory."""
-    events = _read_events("30d")
+    events = await asyncio.to_thread(_read_events, "30d")
     prefs = [e for e in events if e.get("type") == "user_preference"]
     # Also read from learning signals directory
-    file_prefs = _read_learning_signals(signal_type="user_preference", limit=limit)
+    file_prefs = await asyncio.to_thread(_read_learning_signals, signal_type="user_preference", limit=limit)
     combined = prefs + file_prefs
     combined.sort(key=lambda s: s.get("timestamp", ""), reverse=True)
     return combined[:limit]
@@ -4833,10 +4858,10 @@ async def get_learning_preferences(limit: int = Query(default=50, ge=1, le=1000)
 @app.get("/api/learning/errors", dependencies=[Depends(auth.require_scope("read"))])
 async def get_learning_errors(limit: int = Query(default=50, ge=1, le=1000)):
     """Get aggregated error patterns from events and learning signals directory."""
-    events = _read_events("30d")
+    events = await asyncio.to_thread(_read_events, "30d")
     errors = [e for e in events if e.get("type") == "error_pattern"]
     # Also read from learning signals directory
-    file_errors = _read_learning_signals(signal_type="error_pattern", limit=limit)
+    file_errors = await asyncio.to_thread(_read_learning_signals, signal_type="error_pattern", limit=limit)
     combined = errors + file_errors
     combined.sort(key=lambda s: s.get("timestamp", ""), reverse=True)
     return combined[:limit]
@@ -4845,10 +4870,10 @@ async def get_learning_errors(limit: int = Query(default=50, ge=1, le=1000)):
 @app.get("/api/learning/success", dependencies=[Depends(auth.require_scope("read"))])
 async def get_learning_success(limit: int = Query(default=50, ge=1, le=1000)):
     """Get aggregated success patterns from events and learning signals directory."""
-    events = _read_events("30d")
+    events = await asyncio.to_thread(_read_events, "30d")
     successes = [e for e in events if e.get("type") == "success_pattern"]
     # Also read from learning signals directory
-    file_successes = _read_learning_signals(signal_type="success_pattern", limit=limit)
+    file_successes = await asyncio.to_thread(_read_learning_signals, signal_type="success_pattern", limit=limit)
     combined = successes + file_successes
     combined.sort(key=lambda s: s.get("timestamp", ""), reverse=True)
     return combined[:limit]
@@ -4857,10 +4882,10 @@ async def get_learning_success(limit: int = Query(default=50, ge=1, le=1000)):
 @app.get("/api/learning/tools", dependencies=[Depends(auth.require_scope("read"))])
 async def get_tool_efficiency(limit: int = Query(default=50, ge=1, le=1000)):
     """Get tool efficiency rankings from events and learning signals directory."""
-    events = _read_events("30d")
+    events = await asyncio.to_thread(_read_events, "30d")
     tools = [e for e in events if e.get("type") == "tool_efficiency"]
     # Also read from learning signals directory
-    file_tools = _read_learning_signals(signal_type="tool_efficiency", limit=limit)
+    file_tools = await asyncio.to_thread(_read_learning_signals, signal_type="tool_efficiency", limit=limit)
     combined = tools + file_tools
     combined.sort(key=lambda s: s.get("timestamp", ""), reverse=True)
     return combined[:limit]
@@ -5204,7 +5229,16 @@ def _calculate_model_cost(model: str, input_tokens: int, output_tokens: int) ->
 
 @app.get("/api/cost")
 async def get_cost():
-    """Get cost visibility data from .loki/metrics/efficiency/ and budget.json."""
+    """Get cost visibility data from .loki/metrics/efficiency/ and budget.json.
+
+    The computation globs + reads every per-iteration efficiency JSON file
+    (a blocking multi-file read loop building only local aggregates), so it is
+    offloaded to a thread to keep the event loop responsive.
+    """
+    return await asyncio.to_thread(_compute_cost_snapshot)
+
+
+def _compute_cost_snapshot() -> dict:
     loki_dir = _get_loki_dir()
     efficiency_dir = loki_dir / "metrics" / "efficiency"
     budget_file = loki_dir / "metrics" / "budget.json"
@@ -5471,7 +5505,15 @@ async def get_cost_timeline():
     classifies into ok/warn/exceeded so the UI can warn at 80% before the cap.
     Cost is never fabricated: when nothing was recorded, cost_recorded is False
     and totals are honestly null rather than a misleading $0.00.
+
+    Globs + reads every efficiency iteration file and every proof.json (a
+    blocking multi-file read loop building only local state), so it is offloaded
+    to a thread to keep the event loop responsive.
     """
+    return await asyncio.to_thread(_compute_cost_timeline)
+
+
+def _compute_cost_timeline() -> dict:
     loki_dir = _get_loki_dir()
     efficiency_dir = loki_dir / "metrics" / "efficiency"
 
@@ -5730,51 +5772,59 @@ async def get_council_state():
 
 @app.get("/api/council/verdicts")
 async def get_council_verdicts(limit: int = Query(default=20, ge=1, le=1000)):
-    """Get council vote history (decision log)."""
-    state_file = _get_loki_dir() / "council" / "state.json"
-    verdicts = []
-    if state_file.exists():
-        try:
-            state = json.loads(state_file.read_text())
-            verdicts = state.get("verdicts", [])
-        except Exception:
-            pass
+    """Get council vote history (decision log).
 
-    # Also read individual vote files for detail
-    votes_dir = _get_loki_dir() / "council" / "votes"
-    detailed_verdicts = []
-    if votes_dir.exists():
-        for vote_dir in sorted(votes_dir.iterdir(), reverse=True):
-            if vote_dir.is_dir():
-                verdict_detail = {"iteration": vote_dir.name}
-                # Read evidence
-                evidence_file = vote_dir / "evidence.md"
-                if evidence_file.exists():
-                    try:
-                        verdict_detail["evidence_preview"] = evidence_file.read_text()[:500]
-                    except Exception:
-                        verdict_detail["evidence_preview"] = ""
-                # Read member votes
-                members = []
-                for member_file in sorted(vote_dir.glob("member-*.txt")):
-                    try:
-                        content = member_file.read_text().strip()
-                        members.append({
-                            "member": member_file.stem,
-                            "content": content
-                        })
-                    except Exception:
-                        pass
-                verdict_detail["members"] = members
-                # Read contrarian
-                contrarian_file = vote_dir / "contrarian.txt"
-                if contrarian_file.exists():
-                    verdict_detail["contrarian"] = contrarian_file.read_text().strip()
-                detailed_verdicts.append(verdict_detail)
-                if len(detailed_verdicts) >= limit:
-                    break
+    Walks every vote directory and reads its evidence/member/contrarian files
+    (a blocking multi-file read loop building only local state), so it is
+    offloaded to a thread to keep the event loop responsive.
+    """
+    def _collect_verdicts() -> dict:
+        state_file = _get_loki_dir() / "council" / "state.json"
+        verdicts = []
+        if state_file.exists():
+            try:
+                state = json.loads(state_file.read_text())
+                verdicts = state.get("verdicts", [])
+            except Exception:
+                pass
 
-    return {"verdicts": verdicts, "details": detailed_verdicts}
+        # Also read individual vote files for detail
+        votes_dir = _get_loki_dir() / "council" / "votes"
+        detailed_verdicts = []
+        if votes_dir.exists():
+            for vote_dir in sorted(votes_dir.iterdir(), reverse=True):
+                if vote_dir.is_dir():
+                    verdict_detail = {"iteration": vote_dir.name}
+                    # Read evidence
+                    evidence_file = vote_dir / "evidence.md"
+                    if evidence_file.exists():
+                        try:
+                            verdict_detail["evidence_preview"] = evidence_file.read_text()[:500]
+                        except Exception:
+                            verdict_detail["evidence_preview"] = ""
+                    # Read member votes
+                    members = []
+                    for member_file in sorted(vote_dir.glob("member-*.txt")):
+                        try:
+                            content = member_file.read_text().strip()
+                            members.append({
+                                "member": member_file.stem,
+                                "content": content
+                            })
+                        except Exception:
+                            pass
+                    verdict_detail["members"] = members
+                    # Read contrarian
+                    contrarian_file = vote_dir / "contrarian.txt"
+                    if contrarian_file.exists():
+                        verdict_detail["contrarian"] = contrarian_file.read_text().strip()
+                    detailed_verdicts.append(verdict_detail)
+                    if len(detailed_verdicts) >= limit:
+                        break
+
+        return {"verdicts": verdicts, "details": detailed_verdicts}
+
+    return await asyncio.to_thread(_collect_verdicts)
 
 
 @app.get("/api/council/convergence")
@@ -5849,35 +5899,41 @@ async def get_council_transcripts(
     if not transcripts_dir.exists():
         response: dict = {"transcripts": [], "total": 0, "latest_id": None}
         if type_prefix:
-            response["hook_events"] = _read_events(type_prefix=type_prefix)
+            response["hook_events"] = await asyncio.to_thread(_read_events, type_prefix=type_prefix)
         return response
 
-    records = []
-    for f in sorted(transcripts_dir.glob("iter-*.json"), reverse=True):
-        try:
-            rec = json.loads(f.read_text())
-        except Exception:
-            logger.warning("Skipping corrupt council transcript file: %s", f.name)
-            continue
-        if not isinstance(rec, dict):
-            logger.warning("Skipping non-object council transcript file: %s", f.name)
-            continue
-        if not isinstance(rec.get("iteration_id"), str):
-            logger.warning("Skipping transcript missing iteration_id field: %s", f.name)
-            continue
-        if since_dt is not None:
-            ts_str = rec.get("timestamp", "")
+    def _collect_transcript_records() -> list:
+        # Globs + reads up to `limit` (<=200) JSON transcript files; a blocking
+        # multi-file read loop offloaded so the event loop stays responsive.
+        out: list = []
+        for f in sorted(transcripts_dir.glob("iter-*.json"), reverse=True):
             try:
-                ts = datetime.fromisoformat(ts_str.replace("Z", "+00:00"))
-            except (ValueError, AttributeError):
+                rec = json.loads(f.read_text())
+            except Exception:
+                logger.warning("Skipping corrupt council transcript file: %s", f.name)
                 continue
-            if ts <= since_dt:
+            if not isinstance(rec, dict):
+                logger.warning("Skipping non-object council transcript file: %s", f.name)
                 continue
-        if iter_min is not None and rec.get("iteration", 0) < iter_min:
-            continue
-        records.append(rec)
-        if len(records) >= limit:
-            break
+            if not isinstance(rec.get("iteration_id"), str):
+                logger.warning("Skipping transcript missing iteration_id field: %s", f.name)
+                continue
+            if since_dt is not None:
+                ts_str = rec.get("timestamp", "")
+                try:
+                    ts = datetime.fromisoformat(ts_str.replace("Z", "+00:00"))
+                except (ValueError, AttributeError):
+                    continue
+                if ts <= since_dt:
+                    continue
+            if iter_min is not None and rec.get("iteration", 0) < iter_min:
+                continue
+            out.append(rec)
+            if len(out) >= limit:
+                break
+        return out
+
+    records = await asyncio.to_thread(_collect_transcript_records)
 
     response = {
         "transcripts": records,
@@ -5886,7 +5942,7 @@ async def get_council_transcripts(
     }
     # v7.5.22 Phase D: opt-in hook-event passthrough via _read_events filter.
     if type_prefix:
-        response["hook_events"] = _read_events(type_prefix=type_prefix)
+        response["hook_events"] = await asyncio.to_thread(_read_events, type_prefix=type_prefix)
     return response
 
 
@@ -6107,7 +6163,16 @@ def _sanitize_checkpoint_id(checkpoint_id: str) -> str:
 
 @app.get("/api/checkpoints")
 async def list_checkpoints(limit: int = Query(default=20, ge=1, le=200)):
-    """List recent checkpoints from index.jsonl, enriched with metadata when available."""
+    """List recent checkpoints from index.jsonl, enriched with metadata when available.
+
+    Reads index.jsonl plus a metadata.json and a recursive rglob() file count
+    per checkpoint (a blocking multi-file walk building only local state), so
+    it is offloaded to a thread to keep the event loop responsive.
+    """
+    return await asyncio.to_thread(_collect_checkpoints, limit)
+
+
+def _collect_checkpoints(limit: int) -> list:
     loki_dir = _get_loki_dir()
     index_file = loki_dir / "state" / "checkpoints" / "index.jsonl"
     checkpoints_dir = loki_dir / "state" / "checkpoints"
@@ -6558,17 +6623,18 @@ async def get_logs(lines: int = 100, token: Optional[dict] = Depends(auth.get_cu
                 file_mtime = datetime.fromtimestamp(log_file.stat().st_mtime, tz=timezone.utc).strftime(
                     "%Y-%m-%dT%H:%M:%S"
                 )
-                # Read only the tail to avoid loading huge files into memory
-                tail_lines = []
-                try:
-                    with open(log_file, "rb") as lf:
-                        # Seek from end to find enough lines
+                # Read only the tail to avoid loading huge files into memory.
+                # The up-to-1MB blocking read is offloaded to a thread so the
+                # single-worker event loop (status + WS heartbeat) stays free.
+                def _read_log_tail(lf_path=log_file, n=lines) -> list[str]:
+                    with open(lf_path, "rb") as lf:
                         lf.seek(0, 2)
                         file_size = lf.tell()
-                        # Read at most 1MB from the end (plenty for any reasonable lines count)
                         read_size = min(file_size, 1024 * 1024)
                         lf.seek(max(0, file_size - read_size))
-                        tail_lines = lf.read().decode("utf-8", errors="replace").strip().split("\n")[-lines:]
+                        return lf.read().decode("utf-8", errors="replace").strip().split("\n")[-n:]
+                try:
+                    tail_lines = await asyncio.to_thread(_read_log_tail)
                 except (OSError, UnicodeDecodeError):
                     tail_lines = []
                 for raw_line in tail_lines:
@@ -8035,8 +8101,12 @@ async def get_app_runner_logs(lines: int = Query(default=100, ge=1, le=1000)):
         return {"lines": []}
     try:
         redact = _get_log_redactor()
-        all_lines = _safe_read_text(log_file).splitlines()
-        return {"lines": [redact(ln) for ln in all_lines[-lines:]], "redacted": True}
+        # Reading + redacting the app log is blocking (the log can be large);
+        # offload so the event loop (status + WS heartbeat) is not stalled.
+        def _read_redacted(p=log_file, n=lines):
+            return [redact(ln) for ln in _safe_read_text(p).splitlines()[-n:]]
+        out_lines = await asyncio.to_thread(_read_redacted)
+        return {"lines": out_lines, "redacted": True}
     except OSError:
         return {"lines": []}
 
@@ -8071,8 +8141,10 @@ async def get_app_runner_errors(lines: int = Query(default=50, ge=1, le=500)):
     if log_file.exists():
         try:
             redact = _get_log_redactor()
-            all_lines = _safe_read_text(log_file).splitlines()
-            out_lines = [redact(ln) for ln in all_lines[-lines:]]
+            # Offload the blocking log read + redaction off the event loop.
+            def _read_redacted(p=log_file, n=lines):
+                return [redact(ln) for ln in _safe_read_text(p).splitlines()[-n:]]
+            out_lines = await asyncio.to_thread(_read_redacted)
         except OSError:
             out_lines = []
 
@@ -8790,7 +8862,11 @@ async def get_managed_events(
     """
     try:
         path = _managed_events_path()
-        records = _tail_ndjson(path, limit=limit, since_iso=since, event_type=type)
+        # Tails an ndjson file (rotated at 10MB) via a blocking readlines();
+        # offload so the event loop stays responsive.
+        records = await asyncio.to_thread(
+            _tail_ndjson, path, limit, since, type
+        )
         return {
             "events": records,
             "count": len(records),
@@ -8813,11 +8889,13 @@ async def get_managed_status():
     snapshot = _managed_flags_snapshot()
     # last_fallback_ts is best-effort from the local events file.
     try:
-        events = _tail_ndjson(
+        # Blocking ndjson tail read; offload off the event loop.
+        events = await asyncio.to_thread(
+            _tail_ndjson,
             _managed_events_path(),
-            limit=500,
-            since_iso=None,
-            event_type="managed_agents_fallback",
+            500,
+            None,
+            "managed_agents_fallback",
         )
         snapshot["last_fallback_ts"] = _last_fallback_ts(events)
     except Exception:

package/docs/INSTALLATION.md

@@ -2,7 +2,7 @@
 
 The flagship product of [Autonomi](https://www.autonomi.dev/). Loki Mode is a spec-driven autonomous builder with a built-in trust layer that takes any spec to a deployed product and verifies completion with evidence (quality gates plus a completion council), not just a "done" claim. Complete installation instructions for all platforms and use cases.
 
-**Version:** v7.57.0
+**Version:** v7.58.1
 
 ---
 
@@ -395,7 +395,7 @@ provider works inside the container. Provide auth with your Anthropic API key:
 # Run Loki Mode in Docker (Claude provider, API-key auth)
 docker run --rm -e ANTHROPIC_API_KEY="$ANTHROPIC_API_KEY" \
   -v $(pwd):/workspace -w /workspace \
-  asklokesh/loki-mode:7.57.0 start ./my-spec.md
+  asklokesh/loki-mode:7.58.1 start ./my-spec.md
 ```
 
 ##### docker compose + .env (no host install)

package/loki-ts/dist/loki.js

@@ -1,5 +1,5 @@
 // @bun
-var r6=Object.defineProperty;var t6=($)=>$;function i6($,Q){this[$]=t6.bind(null,Q)}var h=($,Q)=>{for(var Z in Q)r6($,Z,{get:Q[Z],enumerable:!0,configurable:!0,set:i6.bind(Q,Z)})};var L=($,Q)=>()=>($&&(Q=$($=0)),Q);var K$=import.meta.require;var D1={};h(D1,{lokiDir:()=>P,homeLokiDir:()=>n$,findRepoRootForVersion:()=>o$,REPO_ROOT:()=>g});import{resolve as n,dirname as d$}from"path";import{fileURLToPath as e6}from"url";import{existsSync as P$}from"fs";import{homedir as $Q}from"os";function QQ(){let $=S1;for(let Q=0;Q<6;Q++){if(P$(n($,"VERSION"))&&P$(n($,"autonomy/run.sh")))return $;let Z=d$($);if(Z===$)break;$=Z}return n(S1,"..","..","..")}function o$($){let Q=$;for(let Z=0;Z<6;Z++){if(P$(n(Q,"VERSION"))&&P$(n(Q,"autonomy/run.sh")))return Q;let z=d$(Q);if(z===Q)break;Q=z}return n($,"..","..","..")}function P(){return process.env.LOKI_DIR??n(process.cwd(),".loki")}function n$(){return n($Q(),".loki")}var S1,g;var b=L(()=>{S1=d$(e6(import.meta.url));g=QQ()});import{readFileSync as ZQ}from"fs";import{resolve as zQ,dirname as XQ}from"path";import{fileURLToPath as KQ}from"url";function j$(){if($$!==null)return $$;let $="7.57.0";if(typeof $==="string"&&$.length>0)return $$=$,$$;try{let Q=XQ(KQ(import.meta.url)),Z=o$(Q);$$=ZQ(zQ(Z,"VERSION"),"utf-8").trim()}catch{$$="unknown"}return $$}var $$=null;var a$=L(()=>{b()});var b1={};h(b1,{runOrThrow:()=>qQ,run:()=>k,commandVersion:()=>WQ,commandExists:()=>f,ShellError:()=>s$});async function k($,Q={}){let Z=Bun.spawn({cmd:[...$],stdout:"pipe",stderr:"pipe",env:Q.env?{...process.env,...Q.env}:process.env,cwd:Q.cwd}),z,X;if(Q.timeoutMs&&Q.timeoutMs>0)z=setTimeout(()=>{try{Z.kill("SIGTERM")}catch{}X=setTimeout(()=>{try{Z.kill("SIGKILL")}catch{}},2000)},Q.timeoutMs);try{let[q,K,W]=await Promise.all([new Response(Z.stdout).text(),new Response(Z.stderr).text(),Z.exited]);return{stdout:q,stderr:K,exitCode:W}}finally{if(z)clearTimeout(z);if(X)clearTimeout(X)}}async function qQ($,Q={}){let Z=await k($,Q);if(Z.exitCode!==0)throw new s$(`command failed (${Z.exitCode}): ${$.join(" ")}`,Z.exitCode,Z.stdout,Z.stderr);return Z}async function f($){let Q=VQ($),Z=await k(["sh","-c",`command -v ${Q}`],{timeoutMs:5000});if(Z.exitCode===0)return Z.stdout.trim()||null;return null}function VQ($){if(!/^[A-Za-z0-9._/-]+$/.test($))throw Error(`refused to shell-escape suspect token: ${$}`);return $}async function WQ($,Q="--version"){if(!await f($))return null;let z=await k([$,Q],{timeoutMs:5000});if(z.exitCode!==0)return null;return((z.stdout||z.stderr).split(/\r?\n/)[0]?.trim()??"")||null}var s$;var d=L(()=>{s$=class s$ extends Error{message;exitCode;stdout;stderr;constructor($,Q,Z,z){super($);this.message=$;this.exitCode=Q;this.stdout=Z;this.stderr=z;this.name="ShellError"}}});function a($){return JQ?"":$}var JQ,T,S,_,wZ,I,R,y,V;var c=L(()=>{JQ=(process.env.NO_COLOR??"").length>0;T=a("\x1B[0;31m"),S=a("\x1B[0;32m"),_=a("\x1B[1;33m"),wZ=a("\x1B[0;34m"),I=a("\x1B[0;36m"),R=a("\x1B[1m"),y=a("\x1B[2m"),V=a("\x1B[0m")});import{existsSync as wQ}from"fs";async function Q$(){if(G$!==void 0)return G$;let $="/opt/homebrew/bin/python3.12";if(wQ($))return G$=$,$;let Q=await f("python3.12");if(Q)return G$=Q,Q;let Z=await f("python3");return G$=Z,Z}async function Z$($,Q={}){let Z=await Q$();if(!Z)return{stdout:"",stderr:"python3 not found",exitCode:127};return k([Z,"-c",$],Q)}var G$;var q$=L(()=>{d()});var e1={};h(e1,{runStatus:()=>uQ});import{existsSync as v,readFileSync as W$,readdirSync as d1,statSync as o1}from"fs";import{resolve as C,basename as DQ}from"path";import{homedir as CQ}from"os";function n1($){let Q=Math.trunc($);if(Q>=1e6)return`${(Math.trunc(Q/1e6*10)/10).toFixed(1)}M`;if(Q>=1000)return`${(Math.trunc(Q/1000*10)/10).toFixed(1)}K`;return String(Q)}function a1($,Q,Z){if(Q===0)return null;let z=Math.trunc($*100/Q),X=Math.trunc($*k$/Q);if(X>k$)X=k$;let q=k$-X,K=S;if(z>=80)K=T;else if(z>=50)K=_;let W="=".repeat(Math.max(0,X))+" ".repeat(Math.max(0,q)),J=n1($),U=n1(Q);return`  ${R}${Z}${V} ${K}[${W}]${V} ${z}% (${J} / ${U})`}async function hQ(){if(await f("jq"))return!0;return process.stdout.write(`${T}Error: jq is required but not installed.${V}
+var r6=Object.defineProperty;var t6=($)=>$;function i6($,Q){this[$]=t6.bind(null,Q)}var h=($,Q)=>{for(var Z in Q)r6($,Z,{get:Q[Z],enumerable:!0,configurable:!0,set:i6.bind(Q,Z)})};var L=($,Q)=>()=>($&&(Q=$($=0)),Q);var K$=import.meta.require;var D1={};h(D1,{lokiDir:()=>P,homeLokiDir:()=>n$,findRepoRootForVersion:()=>o$,REPO_ROOT:()=>g});import{resolve as n,dirname as d$}from"path";import{fileURLToPath as e6}from"url";import{existsSync as P$}from"fs";import{homedir as $Q}from"os";function QQ(){let $=S1;for(let Q=0;Q<6;Q++){if(P$(n($,"VERSION"))&&P$(n($,"autonomy/run.sh")))return $;let Z=d$($);if(Z===$)break;$=Z}return n(S1,"..","..","..")}function o$($){let Q=$;for(let Z=0;Z<6;Z++){if(P$(n(Q,"VERSION"))&&P$(n(Q,"autonomy/run.sh")))return Q;let z=d$(Q);if(z===Q)break;Q=z}return n($,"..","..","..")}function P(){return process.env.LOKI_DIR??n(process.cwd(),".loki")}function n$(){return n($Q(),".loki")}var S1,g;var b=L(()=>{S1=d$(e6(import.meta.url));g=QQ()});import{readFileSync as ZQ}from"fs";import{resolve as zQ,dirname as XQ}from"path";import{fileURLToPath as KQ}from"url";function j$(){if($$!==null)return $$;let $="7.58.1";if(typeof $==="string"&&$.length>0)return $$=$,$$;try{let Q=XQ(KQ(import.meta.url)),Z=o$(Q);$$=ZQ(zQ(Z,"VERSION"),"utf-8").trim()}catch{$$="unknown"}return $$}var $$=null;var a$=L(()=>{b()});var b1={};h(b1,{runOrThrow:()=>qQ,run:()=>k,commandVersion:()=>WQ,commandExists:()=>f,ShellError:()=>s$});async function k($,Q={}){let Z=Bun.spawn({cmd:[...$],stdout:"pipe",stderr:"pipe",env:Q.env?{...process.env,...Q.env}:process.env,cwd:Q.cwd}),z,X;if(Q.timeoutMs&&Q.timeoutMs>0)z=setTimeout(()=>{try{Z.kill("SIGTERM")}catch{}X=setTimeout(()=>{try{Z.kill("SIGKILL")}catch{}},2000)},Q.timeoutMs);try{let[q,K,W]=await Promise.all([new Response(Z.stdout).text(),new Response(Z.stderr).text(),Z.exited]);return{stdout:q,stderr:K,exitCode:W}}finally{if(z)clearTimeout(z);if(X)clearTimeout(X)}}async function qQ($,Q={}){let Z=await k($,Q);if(Z.exitCode!==0)throw new s$(`command failed (${Z.exitCode}): ${$.join(" ")}`,Z.exitCode,Z.stdout,Z.stderr);return Z}async function f($){let Q=VQ($),Z=await k(["sh","-c",`command -v ${Q}`],{timeoutMs:5000});if(Z.exitCode===0)return Z.stdout.trim()||null;return null}function VQ($){if(!/^[A-Za-z0-9._/-]+$/.test($))throw Error(`refused to shell-escape suspect token: ${$}`);return $}async function WQ($,Q="--version"){if(!await f($))return null;let z=await k([$,Q],{timeoutMs:5000});if(z.exitCode!==0)return null;return((z.stdout||z.stderr).split(/\r?\n/)[0]?.trim()??"")||null}var s$;var d=L(()=>{s$=class s$ extends Error{message;exitCode;stdout;stderr;constructor($,Q,Z,z){super($);this.message=$;this.exitCode=Q;this.stdout=Z;this.stderr=z;this.name="ShellError"}}});function a($){return JQ?"":$}var JQ,T,S,_,wZ,I,R,y,V;var c=L(()=>{JQ=(process.env.NO_COLOR??"").length>0;T=a("\x1B[0;31m"),S=a("\x1B[0;32m"),_=a("\x1B[1;33m"),wZ=a("\x1B[0;34m"),I=a("\x1B[0;36m"),R=a("\x1B[1m"),y=a("\x1B[2m"),V=a("\x1B[0m")});import{existsSync as wQ}from"fs";async function Q$(){if(G$!==void 0)return G$;let $="/opt/homebrew/bin/python3.12";if(wQ($))return G$=$,$;let Q=await f("python3.12");if(Q)return G$=Q,Q;let Z=await f("python3");return G$=Z,Z}async function Z$($,Q={}){let Z=await Q$();if(!Z)return{stdout:"",stderr:"python3 not found",exitCode:127};return k([Z,"-c",$],Q)}var G$;var q$=L(()=>{d()});var e1={};h(e1,{runStatus:()=>uQ});import{existsSync as v,readFileSync as W$,readdirSync as d1,statSync as o1}from"fs";import{resolve as C,basename as DQ}from"path";import{homedir as CQ}from"os";function n1($){let Q=Math.trunc($);if(Q>=1e6)return`${(Math.trunc(Q/1e6*10)/10).toFixed(1)}M`;if(Q>=1000)return`${(Math.trunc(Q/1000*10)/10).toFixed(1)}K`;return String(Q)}function a1($,Q,Z){if(Q===0)return null;let z=Math.trunc($*100/Q),X=Math.trunc($*k$/Q);if(X>k$)X=k$;let q=k$-X,K=S;if(z>=80)K=T;else if(z>=50)K=_;let W="=".repeat(Math.max(0,X))+" ".repeat(Math.max(0,q)),J=n1($),U=n1(Q);return`  ${R}${Z}${V} ${K}[${W}]${V} ${z}% (${J} / ${U})`}async function hQ(){if(await f("jq"))return!0;return process.stdout.write(`${T}Error: jq is required but not installed.${V}
 `),process.stdout.write(`Install with:
 `),process.stdout.write(`  brew install jq    (macOS)
 `),process.stdout.write(`  apt install jq     (Debian/Ubuntu)
@@ -790,4 +790,4 @@ Set LOKI_LEGACY_BASH=1 to force the bash CLI for every command.
 `),2}default:return process.stderr.write(`Unknown command: ${Q}
 `),process.stderr.write(s6),2}}l1();process.on("SIGINT",()=>process.exit(130));process.on("SIGTERM",()=>process.exit(143));var KZ=await XZ(Bun.argv.slice(2));process.exit(KZ);
 
-//# debugId=6D8496B2540606D064756E2164756E21
+//# debugId=D9E2CF477FD688DE64756E2164756E21

package/mcp/__init__.py

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

package/memory/consolidation.py

@@ -221,10 +221,17 @@ class ConsolidationPipeline:
                 if new_pattern:
                     # Try to merge with existing
                     merged = False
-                    for existing in existing_patterns:
+                    for idx, existing in enumerate(existing_patterns):
                         if self._patterns_similar(new_pattern, existing):
                             merged_pattern = self.merge_with_existing(new_pattern, [existing])
                             self.storage.update_pattern(merged_pattern)
+                            # Refresh the in-memory copy so a later new pattern in
+                            # this same run that also merges into this existing
+                            # pattern builds on the just-merged state. Without this,
+                            # the second merge reads the stale pre-merge base and its
+                            # update_pattern() overwrites storage, silently dropping
+                            # the first merge's conditions/source_episodes/confidence.
+                            existing_patterns[idx] = merged_pattern
                             result.patterns_merged += 1
                             merged = True
                             break
@@ -240,11 +247,16 @@ class ConsolidationPipeline:
         for anti_pattern in anti_patterns:
             # Check if similar anti-pattern already exists
             merged = False
-            for existing in existing_patterns:
+            for idx, existing in enumerate(existing_patterns):
                 if (existing.incorrect_approach and
                     self._patterns_similar(anti_pattern, existing, threshold=0.6)):
                     merged_pattern = self.merge_with_existing(anti_pattern, [existing])
                     self.storage.update_pattern(merged_pattern)
+                    # Refresh in-memory copy (same data-loss guard as the cluster
+                    # merge loop above): a later anti-pattern merging into this same
+                    # existing pattern must build on the just-merged state, not the
+                    # stale pre-merge base.
+                    existing_patterns[idx] = merged_pattern
                     result.patterns_merged += 1
                     merged = True
                     break

package/memory/retrieval.py

@@ -855,6 +855,8 @@ class MemoryRetrieval:
         # Filter semantic patterns by last_used
         patterns_data = self.storage.read_json("semantic/patterns.json") or {}
         for pattern in patterns_data.get("patterns", []):
+            if not isinstance(pattern, dict):
+                continue
             last_used = pattern.get("last_used")
             if last_used:
                 try:
@@ -1483,6 +1485,8 @@ class MemoryRetrieval:
         patterns_data = self.storage.read_json("semantic/patterns.json") or {}
 
         for pattern in patterns_data.get("patterns", []):
+            if not isinstance(pattern, dict):
+                continue
             pattern_text = pattern.get("pattern", "").lower()
             category = pattern.get("category", "").lower()
             correct = pattern.get("correct_approach", "").lower()
@@ -1566,6 +1570,8 @@ class MemoryRetrieval:
         # what_fails / why / prevention scoring shape.
         patterns_data = self.storage.read_json("semantic/patterns.json") or {}
         for pat in patterns_data.get("patterns", []):
+            if not isinstance(pat, dict):
+                continue
             if pat.get("category") != "anti-pattern":
                 continue
             what_fails = (pat.get("incorrect_approach", "")
@@ -1633,6 +1639,8 @@ class MemoryRetrieval:
         patterns_data = self.storage.read_json("semantic/patterns.json") or {}
 
         for pattern in patterns_data.get("patterns", []):
+            if not isinstance(pattern, dict):
+                continue
             # Create text for embedding
             text = f"{pattern.get('pattern', '')} {pattern.get('category', '')} {pattern.get('correct_approach', '')}"
 
@@ -1690,6 +1698,8 @@ class MemoryRetrieval:
         # too so embedding-based retrieval sees consolidated anti-patterns.
         patterns_data = self.storage.read_json("semantic/patterns.json") or {}
         for pat in patterns_data.get("patterns", []):
+            if not isinstance(pat, dict):
+                continue
             if pat.get("category") != "anti-pattern":
                 continue
             what_fails = pat.get("incorrect_approach", "") or pat.get("pattern", "")

package/memory/storage.py

@@ -626,6 +626,8 @@ class MemoryStorage:
             # Upsert: update existing pattern or append new
             existing_idx = None
             for i, p in enumerate(patterns_file["patterns"]):
+                if not isinstance(p, dict):
+                    continue
                 if p.get("id") == pattern_id:
                     existing_idx = i
                     break
@@ -672,6 +674,8 @@ class MemoryStorage:
             return None
 
         for pattern in patterns_file.get("patterns", []):
+            if not isinstance(pattern, dict):
+                continue
             if pattern.get("id") == pattern_id:
                 return pattern
 
@@ -695,6 +699,8 @@ class MemoryStorage:
 
         pattern_ids = []
         for pattern in patterns_file.get("patterns", []):
+            if not isinstance(pattern, dict):
+                continue
             if category is None or pattern.get("category") == category:
                 pattern_ids.append(pattern.get("id"))
 
@@ -737,6 +743,8 @@ class MemoryStorage:
             # Find and update pattern
             found = False
             for i, p in enumerate(patterns_file.get("patterns", [])):
+                if not isinstance(p, dict):
+                    continue
                 if p.get("id") == pattern_id:
                     pattern_data["updated_at"] = datetime.now(timezone.utc).isoformat()
                     patterns_file["patterns"][i] = pattern_data
@@ -1364,6 +1372,8 @@ class MemoryStorage:
 
         updated = 0
         for pattern in patterns:
+            if not isinstance(pattern, dict):
+                continue
             original = pattern.get("importance", 0.5)
             self.apply_decay([pattern], decay_rate, half_life_days)
             if abs(pattern.get("importance", 0.5) - original) > 0.001:

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "loki-mode",
   "mcpName": "io.github.asklokesh/loki-mode",
-  "version": "7.57.0",
+  "version": "7.58.1",
   "description": "Loki Mode by Autonomi. Autonomous spec-to-product system: takes a PRD, GitHub issue, OpenAPI/JSON/YAML, or one-line brief to a deployed app via the RARV-C closure loop with 8 quality gates. Provider-agnostic (Claude Code, OpenAI Codex, Cline, Aider).",
   "keywords": [
     "agent",

package/plugins/loki-mode/.claude-plugin/plugin.json

@@ -2,7 +2,7 @@
   "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
   "name": "loki-mode",
   "displayName": "Loki Mode",
-  "version": "7.57.0",
+  "version": "7.58.1",
   "description": "Autonomous spec-to-product build system with a built-in trust layer (RARV-C closure loop, 8 quality gates, completion council). Ships Loki's spec-hardening, drift-detection, and deterministic PR verification commands plus the Loki MCP server.",
   "author": {
     "name": "Autonomi",