loki-mode 6.60.0 → 6.62.0

package/memory/engine.py

@@ -290,10 +290,10 @@ class MemoryEngine:
         """
         # Parse date from episode ID (format: ep-YYYY-MM-DD-XXX)
         parts = episode_id.split("-")
-        if len(parts) >= 4:
+        if len(parts) >= 5 and len(parts[1]) == 4 and len(parts[2]) == 2 and len(parts[3]) == 2:
             date_str = f"{parts[1]}-{parts[2]}-{parts[3]}"
         else:
-            # Search all directories
+            # Non-standard ID format; search all directories
             return self._search_episode(episode_id)
 
         data = self.storage.read_json(f"episodic/{date_str}/task-{episode_id}.json")
@@ -355,26 +355,9 @@ class MemoryEngine:
         Returns:
             Pattern ID
         """
-        pattern_dict = pattern.to_dict() if hasattr(pattern, "to_dict") else pattern.__dict__.copy()
-        pattern_id = pattern_dict.get("id", f"sem-{self._generate_id()}")
-        pattern_dict["id"] = pattern_id
-
-        # Load existing patterns
-        patterns_data = self.storage.read_json("semantic/patterns.json") or {"patterns": []}
-
-        # Check if pattern exists and update, otherwise append
-        existing_idx = None
-        for idx, p in enumerate(patterns_data["patterns"]):
-            if p.get("id") == pattern_id:
-                existing_idx = idx
-                break
-
-        if existing_idx is not None:
-            patterns_data["patterns"][existing_idx] = pattern_dict
-        else:
-            patterns_data["patterns"].append(pattern_dict)
-
-        self.storage.write_json("semantic/patterns.json", patterns_data)
+        # Delegate to storage.save_pattern() which performs the
+        # read-modify-write under a single file lock, preventing races.
+        pattern_id = self.storage.save_pattern(pattern)
 
         # Update index
         self._update_index_with_pattern(pattern_dict)
@@ -1191,10 +1174,54 @@ class MemoryEngine:
         collection: str,
         top_k: int,
     ) -> List[Dict[str, Any]]:
-        """Vector similarity search. Requires embeddings to be configured."""
-        # This is a placeholder for vector search implementation
-        # In production, this would use a vector database or local index
-        return self._keyword_search("", collection, top_k)
+        """Vector similarity search using cosine similarity against stored memories."""
+        try:
+            import numpy as np
+        except ImportError:
+            # No numpy available, fall back to keyword search
+            return self._keyword_search("", collection, top_k)
+
+        query_vec = np.asarray(embedding, dtype=np.float32)
+        query_norm = np.linalg.norm(query_vec)
+        if query_norm == 0:
+            return self._keyword_search("", collection, top_k)
+        query_vec = query_vec / query_norm
+
+        # Load memories from the collection using the same paths as _keyword_search
+        items: List[Dict[str, Any]] = []
+        if collection == "episodic":
+            for ep in self.get_recent_episodes(limit=50):
+                items.append(ep.to_dict() if hasattr(ep, "to_dict") else ep.__dict__.copy())
+        elif collection == "semantic":
+            for pattern in self.find_patterns(min_confidence=0.3):
+                items.append(pattern.to_dict() if hasattr(pattern, "to_dict") else pattern.__dict__.copy())
+        elif collection == "procedural":
+            for skill in self.list_skills():
+                items.append(skill.to_dict() if hasattr(skill, "to_dict") else skill.__dict__.copy())
+
+        # Score each item by cosine similarity against its stored embedding
+        scored: List[tuple] = []
+        for item in items:
+            item_embedding = item.get("_embedding")
+            if not item_embedding:
+                continue
+            item_vec = np.asarray(item_embedding, dtype=np.float32)
+            item_norm = np.linalg.norm(item_vec)
+            if item_norm == 0:
+                continue
+            similarity = float(np.dot(query_vec, item_vec / item_norm))
+            scored.append((similarity, item))
+
+        if not scored:
+            # No embeddings stored; fall back to keyword search
+            return self._keyword_search("", collection, top_k)
+
+        scored.sort(key=lambda x: x[0], reverse=True)
+        results = []
+        for score, item in scored[:top_k]:
+            item["_score"] = score
+            results.append(item)
+        return results
 
     def _queue_for_embedding(
         self,

package/memory/layers/index_layer.py

@@ -10,6 +10,8 @@ loading full memory content.
 """
 
 import json
+import os
+import tempfile
 from dataclasses import dataclass, field, asdict
 from datetime import datetime, timezone
 from pathlib import Path
@@ -109,7 +111,7 @@ class IndexLayer:
 
     def _save(self, index: Dict[str, Any]) -> None:
         """
-        Save index to disk.
+        Save index to disk atomically via temp file + os.replace().
 
         Args:
             index: Index dictionary to save
@@ -117,8 +119,19 @@ class IndexLayer:
         self.base_path.mkdir(parents=True, exist_ok=True)
         index["last_updated"] = datetime.now(timezone.utc).isoformat()
 
-        with open(self.index_path, "w") as f:
-            json.dump(index, f, indent=2)
+        fd, tmp_path = tempfile.mkstemp(
+            dir=str(self.base_path), prefix=".tmp_index_", suffix=".json"
+        )
+        try:
+            with os.fdopen(fd, "w", encoding="utf-8") as f:
+                json.dump(index, f, indent=2)
+            os.replace(tmp_path, str(self.index_path))
+        except Exception:
+            try:
+                os.unlink(tmp_path)
+            except OSError:
+                pass
+            raise
 
         self._cache = index
 

package/memory/layers/timeline_layer.py

@@ -9,6 +9,8 @@ providing temporal context before loading full memories.
 """
 
 import json
+import os
+import tempfile
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import List, Dict, Any, Optional
@@ -70,7 +72,7 @@ class TimelineLayer:
 
     def _save(self, timeline: Dict[str, Any]) -> None:
         """
-        Save timeline to disk.
+        Save timeline to disk atomically via temp file + os.replace().
 
         Args:
             timeline: Timeline dictionary to save
@@ -78,8 +80,19 @@ class TimelineLayer:
         self.base_path.mkdir(parents=True, exist_ok=True)
         timeline["last_updated"] = datetime.now(timezone.utc).isoformat()
 
-        with open(self.timeline_path, "w") as f:
-            json.dump(timeline, f, indent=2)
+        fd, tmp_path = tempfile.mkstemp(
+            dir=str(self.base_path), prefix=".tmp_timeline_", suffix=".json"
+        )
+        try:
+            with os.fdopen(fd, "w", encoding="utf-8") as f:
+                json.dump(timeline, f, indent=2)
+            os.replace(tmp_path, str(self.timeline_path))
+        except Exception:
+            try:
+                os.unlink(tmp_path)
+            except OSError:
+                pass
+            raise
 
         self._cache = timeline
 

package/memory/retrieval.py

@@ -1082,7 +1082,10 @@ class MemoryRetrieval:
 
         # Layer 3: Full details for highest priority items
         if budget_remaining > 100:  # At least 100 tokens remaining
-            full_details = self.retrieve_task_aware(context, top_k=10)
+            # Cap top_k based on remaining budget to avoid loading unbounded data.
+            # Estimate ~50 tokens per result as a rough lower bound.
+            max_results = max(1, min(10, budget_remaining // 50))
+            full_details = self.retrieve_task_aware(context, top_k=max_results)
             for detail in full_details:
                 detail["_layer"] = 3
 

package/memory/schemas.py

@@ -23,8 +23,10 @@ def _to_utc_isoformat(dt: datetime) -> str:
     Handles both timezone-aware and timezone-naive datetimes.
     If dt has a non-UTC timezone, converts to UTC first.
     """
-    # If timezone-aware and not UTC, convert to UTC
-    if dt.tzinfo is not None and dt.utcoffset() != timezone.utc.utcoffset(None):
+    # If timezone-aware and not UTC, convert to UTC.
+    # Compare as timedelta values (not by identity) for reliable cross-tz checks.
+    from datetime import timedelta as _td
+    if dt.tzinfo is not None and (dt.utcoffset() or _td(0)) != _td(0):
         dt = dt.astimezone(timezone.utc)
 
     iso = dt.isoformat()

package/memory/storage.py

@@ -13,6 +13,7 @@ import os
 import tempfile
 import shutil
 import fcntl
+import threading
 from datetime import datetime, timezone, timedelta
 from pathlib import Path
 from typing import Optional, List, Dict, Any, Union
@@ -81,6 +82,10 @@ class MemoryStorage:
         else:
             self.base_path = self._root_path
 
+        # Reentrant lock tracking: prevents deadlock when _file_lock is
+        # called on the same path from nested operations in the same thread.
+        self._held_locks: threading.local = threading.local()
+
         self._ensure_directories()
         self._ensure_index()
         self._ensure_timeline()
@@ -193,7 +198,10 @@ class MemoryStorage:
     @contextmanager
     def _file_lock(self, path: Path, exclusive: bool = True):
         """
-        Context manager for file locking.
+        Context manager for reentrant file locking.
+
+        If the current thread already holds the lock for this path,
+        the call is a no-op (avoids deadlock from nested lock acquisition).
 
         Args:
             path: Path to the file to lock
@@ -203,6 +211,17 @@ class MemoryStorage:
             File handle with lock held
         """
         lock_path = path.with_suffix(path.suffix + ".lock")
+        lock_key = str(lock_path)
+
+        # Check if this thread already holds the lock (reentrant case)
+        if not hasattr(self._held_locks, "paths"):
+            self._held_locks.paths = set()
+
+        if lock_key in self._held_locks.paths:
+            # Already held by this thread -- skip to avoid deadlock
+            yield
+            return
+
         lock_path.parent.mkdir(parents=True, exist_ok=True)
 
         lock_file = None
@@ -211,8 +230,10 @@ class MemoryStorage:
             lock_file = open(lock_path, "w")
             lock_type = fcntl.LOCK_EX if exclusive else fcntl.LOCK_SH
             fcntl.flock(lock_file.fileno(), lock_type)
+            self._held_locks.paths.add(lock_key)
             yield
         finally:
+            self._held_locks.paths.discard(lock_key)
             if lock_file is not None:
                 fcntl.flock(lock_file.fileno(), fcntl.LOCK_UN)
                 lock_file.close()
@@ -1196,7 +1217,7 @@ class MemoryStorage:
                 if data:
                     original_importance = data.get("importance", 0.5)
                     memories = self.apply_decay([data], decay_rate, half_life_days)
-                    if memories[0].get("importance") != original_importance:
+                    if abs(memories[0].get("importance", 0.5) - original_importance) > 0.001:
                         self._atomic_write(file_path, memories[0])
                         updated += 1
 
@@ -1220,7 +1241,7 @@ class MemoryStorage:
         for pattern in patterns:
             original = pattern.get("importance", 0.5)
             self.apply_decay([pattern], decay_rate, half_life_days)
-            if pattern.get("importance") != original:
+            if abs(pattern.get("importance", 0.5) - original) > 0.001:
                 updated += 1
 
         if updated > 0:
@@ -1241,7 +1262,7 @@ class MemoryStorage:
             if data:
                 original = data.get("importance", 0.5)
                 self.apply_decay([data], decay_rate, half_life_days)
-                if data.get("importance") != original:
+                if abs(data.get("importance", 0.5) - original) > 0.001:
                     self._atomic_write(file_path, data)
                     updated += 1
 

package/memory/token_economics.py

@@ -557,15 +557,22 @@ class TokenEconomics:
         """
         Get a summary of token economics for this session.
 
+        Caches computed values to avoid redundant filesystem scans
+        when check_thresholds() re-calls get_ratio()/get_savings_percent().
+
         Returns:
             Dictionary with session info, metrics, and computed values
         """
+        # Pre-compute once; check_thresholds reuses the cached baseline.
+        ratio = self.get_ratio()
+        savings = self.get_savings_percent()
+
         return {
             "session_id": self.session_id,
             "started_at": self.started_at.isoformat(),
             "metrics": dict(self.metrics),
-            "ratio": self.get_ratio(),
-            "savings_percent": self.get_savings_percent(),
+            "ratio": ratio,
+            "savings_percent": savings,
             "thresholds_triggered": [a.to_dict() for a in self.check_thresholds()],
         }
 

package/memory/vector_index.py

@@ -290,7 +290,7 @@ class VectorIndex:
             "dimension": self.dimension
         }
 
-        with open(f"{path}.json", "w") as f:
+        with open(f"{path}.json", "w", encoding="utf-8") as f:
             json.dump(sidecar_data, f, indent=2)
 
     def load(self, path: str) -> None:
@@ -318,7 +318,7 @@ class VectorIndex:
         self.dimension = int(data["dimension"][0])
 
         # Load metadata
-        with open(json_path, "r") as f:
+        with open(json_path, "r", encoding="utf-8") as f:
             sidecar_data = json.load(f)
 
         self.ids = sidecar_data["ids"]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loki-mode",
-  "version": "6.60.0",
+  "version": "6.62.0",
   "description": "Loki Mode by Autonomi - Multi-agent autonomous startup system for Claude Code, Codex CLI, and Gemini CLI",
   "keywords": [
     "agent",
@@ -80,6 +80,8 @@
     "dashboard/static/",
     "dashboard/requirements.txt",
     "mcp/",
+    "state/",
+    "integrations/",
     "completions/",
     "src/",
     "web-app/dist/",

package/providers/cline.sh

@@ -90,14 +90,15 @@ provider_version() {
 
 # Invocation function
 # Uses -y (YOLO) for autonomous mode, positional prompt
+# BUG-PROV-009 fix: build model flag as array to prevent word-splitting on model
+# names that contain spaces or special characters
 provider_invoke() {
     local prompt="$1"
     shift
     local model="${LOKI_CLINE_MODEL:-}"
-    local model_flag=""
-    [[ -n "$model" ]] && model_flag="-m $model"
-    # shellcheck disable=SC2086
-    cline -y $model_flag "$prompt" "$@" 2>&1
+    local model_args=()
+    [[ -n "$model" ]] && model_args=("-m" "$model")
+    cline -y "${model_args[@]}" "$prompt" "$@" 2>&1
 }
 
 # Model tier to parameter (Cline uses single model, returns model name)

package/providers/codex.sh

@@ -51,9 +51,28 @@ PROVIDER_MAX_PARALLEL=1
 # Codex uses single model with effort parameter
 # NOTE: gpt-5.3-codex is the official model name for Codex CLI v0.98+
 CODEX_DEFAULT_MODEL="gpt-5.3-codex"
-PROVIDER_MODEL_PLANNING="${LOKI_CODEX_MODEL:-${LOKI_MODEL_PLANNING:-$CODEX_DEFAULT_MODEL}}"
-PROVIDER_MODEL_DEVELOPMENT="${LOKI_CODEX_MODEL:-${LOKI_MODEL_DEVELOPMENT:-$CODEX_DEFAULT_MODEL}}"
-PROVIDER_MODEL_FAST="${LOKI_CODEX_MODEL:-${LOKI_MODEL_FAST:-$CODEX_DEFAULT_MODEL}}"
+
+# Known valid Codex model prefixes for validation (BUG-PROV-002 fix)
+# Generic LOKI_MODEL_* may contain Claude/Gemini model names (e.g. "opus", "sonnet",
+# "gemini-3-pro-preview") which are invalid for Codex. Validate before accepting.
+CODEX_KNOWN_MODELS=("gpt-" "o1-" "o3-" "o4-" "codex-" "ft:gpt-")
+
+_codex_validate_model() {
+    local model="$1"
+    for prefix in "${CODEX_KNOWN_MODELS[@]}"; do
+        if [[ "$model" == ${prefix}* ]]; then
+            echo "$model"
+            return 0
+        fi
+    done
+    # Not a valid Codex model name -- fall back to default
+    echo "$CODEX_DEFAULT_MODEL"
+}
+
+# Provider-specific env (LOKI_CODEX_MODEL) is trusted; generic LOKI_MODEL_* is validated
+PROVIDER_MODEL_PLANNING="$(_codex_validate_model "${LOKI_CODEX_MODEL:-${LOKI_MODEL_PLANNING:-$CODEX_DEFAULT_MODEL}}")"
+PROVIDER_MODEL_DEVELOPMENT="$(_codex_validate_model "${LOKI_CODEX_MODEL:-${LOKI_MODEL_DEVELOPMENT:-$CODEX_DEFAULT_MODEL}}")"
+PROVIDER_MODEL_FAST="$(_codex_validate_model "${LOKI_CODEX_MODEL:-${LOKI_MODEL_FAST:-$CODEX_DEFAULT_MODEL}}")"
 
 # Effort levels (Codex-specific: maps to reasoning time, not model capability)
 PROVIDER_EFFORT_PLANNING="xhigh"
@@ -115,8 +134,11 @@ provider_get_tier_param() {
 }
 
 # Dynamic model resolution (v6.0.0)
-# Resolves a capability tier to a concrete effort level at runtime.
-# Codex uses a single model with effort parameter, so maxTier maps to effort cap.
+# NOTE (BUG-PROV-012): Unlike other providers, Codex resolve_model_for_tier returns
+# an EFFORT LEVEL (xhigh/high/low), not a model name. Codex uses a single model
+# (gpt-5.3-codex) with varying effort. Callers that need the model name should use
+# PROVIDER_MODEL_DEVELOPMENT (or CODEX_DEFAULT_MODEL) directly.
+# The effort value is passed via CODEX_MODEL_REASONING_EFFORT env var at invocation.
 resolve_model_for_tier() {
     local tier="$1"
 

package/providers/gemini.sh

@@ -54,12 +54,39 @@ PROVIDER_MAX_PARALLEL=1
 GEMINI_DEFAULT_PRO="gemini-3-pro-preview"
 GEMINI_DEFAULT_FLASH="gemini-3-flash-preview"
 
-PROVIDER_MODEL_PLANNING="${LOKI_GEMINI_MODEL_PLANNING:-${LOKI_MODEL_PLANNING:-$GEMINI_DEFAULT_PRO}}"
-PROVIDER_MODEL_DEVELOPMENT="${LOKI_GEMINI_MODEL_DEVELOPMENT:-${LOKI_MODEL_DEVELOPMENT:-$GEMINI_DEFAULT_PRO}}"
-PROVIDER_MODEL_FAST="${LOKI_GEMINI_MODEL_FAST:-${LOKI_MODEL_FAST:-$GEMINI_DEFAULT_FLASH}}"
-PROVIDER_MODEL="${PROVIDER_MODEL_PLANNING}"
+# Known valid Gemini model prefixes for validation
+GEMINI_KNOWN_MODELS=("gemini-" "models/gemini-")
+
+# Validate that a model name looks like a Gemini model
+_gemini_validate_model() {
+    local model="$1"
+    local fallback="$2"
+    for prefix in "${GEMINI_KNOWN_MODELS[@]}"; do
+        if [[ "$model" == ${prefix}* ]]; then
+            echo "$model"
+            return 0
+        fi
+    done
+    # Not a valid Gemini model name -- fall back
+    echo "$fallback"
+}
+
+PROVIDER_MODEL_PLANNING="$(_gemini_validate_model "${LOKI_GEMINI_MODEL_PLANNING:-${LOKI_MODEL_PLANNING:-$GEMINI_DEFAULT_PRO}}" "$GEMINI_DEFAULT_PRO")"
+PROVIDER_MODEL_DEVELOPMENT="$(_gemini_validate_model "${LOKI_GEMINI_MODEL_DEVELOPMENT:-${LOKI_MODEL_DEVELOPMENT:-$GEMINI_DEFAULT_PRO}}" "$GEMINI_DEFAULT_PRO")"
+PROVIDER_MODEL_FAST="$(_gemini_validate_model "${LOKI_GEMINI_MODEL_FAST:-${LOKI_MODEL_FAST:-$GEMINI_DEFAULT_FLASH}}" "$GEMINI_DEFAULT_FLASH")"
 PROVIDER_MODEL_FALLBACK="${LOKI_GEMINI_MODEL_FALLBACK:-$GEMINI_DEFAULT_FLASH}"
 
+# BUG-PROV-006 fix: PROVIDER_MODEL is now a function, not a frozen variable.
+# For backward compatibility, set the variable to planning model at load time,
+# but callers should use provider_get_current_model() for runtime resolution.
+PROVIDER_MODEL="${PROVIDER_MODEL_PLANNING}"
+
+# Return the model for the current tier at runtime (not frozen at load time)
+provider_get_current_model() {
+    local tier="${LOKI_CURRENT_TIER:-planning}"
+    resolve_model_for_tier "$tier"
+}
+
 # Thinking levels (Gemini-specific: maps to reasoning depth)
 PROVIDER_THINKING_PLANNING="high"
 PROVIDER_THINKING_DEVELOPMENT="medium"
@@ -106,27 +133,37 @@ provider_version() {
 # Invocation function with rate limit fallback
 # Uses --model flag to specify model, --approval-mode=yolo for autonomous mode
 # Falls back to flash model if pro hits rate limit
+# Accepts optional --model <name> as first args to override default model
+# BUG-PROV-010 fix: uses tee to stream output while still capturing for rate-limit check
 # Note: < /dev/null prevents Gemini from pausing on stdin
 provider_invoke() {
+    local model
+    model=$(provider_get_current_model)
+
+    # Allow callers to pass --model <name> to override
+    if [[ "${1:-}" == "--model" ]] && [[ -n "${2:-}" ]]; then
+        model="$2"
+        shift 2
+    fi
+
     local prompt="$1"
     shift
-    local output
     local exit_code
 
-    # Try primary model first - capture stderr separately to avoid polluting output
-    local stderr_file
+    # Stream output via tee while capturing for rate-limit check
+    local output_file stderr_file
+    output_file=$(mktemp)
     stderr_file=$(mktemp)
-    output=$(gemini --approval-mode=yolo --model "$PROVIDER_MODEL" "$prompt" "$@" < /dev/null 2>"$stderr_file")
-    exit_code=$?
+    gemini --approval-mode=yolo --model "$model" "$prompt" "$@" < /dev/null 2>"$stderr_file" | tee "$output_file"
+    exit_code=${PIPESTATUS[0]}
 
     # Check for rate limit (429) or quota exceeded (check stderr for error indicators)
     if [[ $exit_code -ne 0 ]] && grep -qiE "(rate.?limit|429|quota|resource.?exhausted)" "$stderr_file" 2>/dev/null; then
-        rm -f "$stderr_file"
-        echo "[loki] Rate limit hit on $PROVIDER_MODEL, falling back to $PROVIDER_MODEL_FALLBACK" >&2
+        rm -f "$stderr_file" "$output_file"
+        echo "[loki] Rate limit hit on $model, falling back to $PROVIDER_MODEL_FALLBACK" >&2
         gemini --approval-mode=yolo --model "$PROVIDER_MODEL_FALLBACK" "$prompt" "$@" < /dev/null
     else
-        echo "$output"
-        rm -f "$stderr_file"
+        rm -f "$stderr_file" "$output_file"
         return $exit_code
     fi
 }
@@ -185,8 +222,8 @@ resolve_model_for_tier() {
 }
 
 # Tier-aware invocation with rate limit fallback
-# Uses --model flag to specify model
-# Falls back to flash model if pro hits rate limit
+# BUG-PROV-001 fix: uses resolve_model_for_tier to select actual model for the tier
+# BUG-PROV-010 fix: uses tee to stream output while capturing for rate-limit check
 # Note: < /dev/null prevents Gemini from pausing on stdin
 provider_invoke_with_tier() {
     local tier="$1"
@@ -198,23 +235,22 @@ provider_invoke_with_tier() {
 
     echo "[loki] Using tier: $tier, model: $model" >&2
 
-    local output
     local exit_code
 
-    # Try selected model first - capture stderr separately to avoid polluting output
-    local stderr_file
+    # Stream output via tee while capturing for rate-limit check
+    local output_file stderr_file
+    output_file=$(mktemp)
     stderr_file=$(mktemp)
-    output=$(gemini --approval-mode=yolo --model "$model" "$prompt" "$@" < /dev/null 2>"$stderr_file")
-    exit_code=$?
+    gemini --approval-mode=yolo --model "$model" "$prompt" "$@" < /dev/null 2>"$stderr_file" | tee "$output_file"
+    exit_code=${PIPESTATUS[0]}
 
     # Check for rate limit (429) or quota exceeded - fallback to flash
     if [[ $exit_code -ne 0 ]] && grep -qiE "(rate.?limit|429|quota|resource.?exhausted)" "$stderr_file" 2>/dev/null; then
-        rm -f "$stderr_file"
+        rm -f "$stderr_file" "$output_file"
         echo "[loki] Rate limit hit on $model, falling back to $PROVIDER_MODEL_FALLBACK" >&2
         gemini --approval-mode=yolo --model "$PROVIDER_MODEL_FALLBACK" "$prompt" "$@" < /dev/null
     else
-        echo "$output"
-        rm -f "$stderr_file"
+        rm -f "$stderr_file" "$output_file"
         return $exit_code
     fi
 }

package/providers/loader.sh

@@ -171,9 +171,10 @@ print_capability_matrix() {
 }
 
 # Auto-detect best available provider
+# BUG-PROV-007 fix: includes all 5 supported providers in priority order
+# Priority: Claude (Tier 1, full) > Cline (Tier 2, near-full) > Codex/Gemini/Aider (Tier 3, degraded)
 auto_detect_provider() {
-    # Prefer Claude (full features), then Codex, then Gemini
-    for p in claude codex gemini; do
+    for p in claude cline codex gemini aider; do
         if check_provider_installed "$p"; then
             echo "$p"
             return 0

package/skills/parallel-workflows.md

@@ -55,11 +55,13 @@ cd ../project-feature-auth
 npm install  # or pip install, cargo build, etc.
 ```
 
-### Create Testing Worktree (tracks main)
+### Create Testing Worktree (based on main)
 
 ```bash
-# Testing always runs against latest main
-git worktree add ../project-testing main
+# Testing always runs against latest main via a dedicated branch
+# NOTE: git worktree cannot checkout the same branch in two worktrees,
+# so we create a parallel-testing branch based on main
+git worktree add ../project-testing -b parallel-testing main
 
 # Pull latest before each test run
 cd ../project-testing
@@ -369,16 +371,16 @@ for feature in "${features[@]}"; do
   echo "Spawned: ${feature} (PID: $!)"
 done
 
-# Create testing worktree
+# Create testing worktree (dedicated branch based on main)
 testing_path="../${PROJECT_NAME}-testing"
 if [ ! -d "$testing_path" ]; then
-  git worktree add "$testing_path" main
+  git worktree add "$testing_path" -b parallel-testing main
 fi
 
-# Create docs worktree
+# Create docs worktree (dedicated branch based on main)
 docs_path="../${PROJECT_NAME}-docs"
 if [ ! -d "$docs_path" ]; then
-  git worktree add "$docs_path" main
+  git worktree add "$docs_path" -b parallel-docs main
 fi
 
 echo "Parallel streams initialized"

package/state/__init__.py

@@ -0,0 +1,10 @@
+"""
+Loki Mode State Manager
+
+Centralized state management with file-based caching,
+file watching, and event bus integration.
+"""
+
+from .manager import StateManager, StateChange, ManagedFile
+
+__all__ = ["StateManager", "StateChange", "ManagedFile"]

package/state/index.ts

@@ -0,0 +1,18 @@
+/**
+ * Loki Mode State Manager - TypeScript Entry Point
+ *
+ * Centralized state management with file-based caching,
+ * file watching, and event bus integration.
+ */
+
+export {
+  StateManager,
+  StateChange,
+  ManagedFile,
+  ManagedFileType,
+  StateCallback,
+  Disposable,
+  getStateDiff,
+  getStateManager,
+  resetStateManager,
+} from "./manager";