loki-mode 5.28.0 → 5.28.1

package/SKILL.md

@@ -3,7 +3,7 @@ name: loki-mode
 description: Multi-agent autonomous startup system. Triggers on "Loki Mode". Takes PRD to deployed product with zero human intervention. Requires --dangerously-skip-permissions flag.
 ---
 
-# Loki Mode v5.28.0
+# Loki Mode v5.28.1
 
 **You are an autonomous agent. You make decisions. You do not ask questions. You do not stop.**
 
@@ -260,4 +260,4 @@ Auto-detected or force with `LOKI_COMPLEXITY`:
 
 ---
 
-**v5.28.0 | Demo, quick mode, init, cost dashboard, 12 templates, GitHub Action | ~270 lines core**
+**v5.28.1 | Demo, quick mode, init, cost dashboard, 12 templates, GitHub Action | ~270 lines core**

package/VERSION

@@ -1 +1 @@
-5.28.0
+5.28.1

package/autonomy/completion-council.sh

@@ -76,6 +76,7 @@ council_init() {
     cat > "$COUNCIL_STATE_DIR/state.json" << 'COUNCIL_EOF'
 {
     "initialized": true,
+    "enabled": true,
     "total_votes": 0,
     "approve_votes": 0,
     "reject_votes": 0,

package/autonomy/loki

@@ -1280,7 +1280,7 @@ cmd_dashboard_start() {
 
     # Start the dashboard server in background
     # LOKI_SKILL_DIR tells server.py where to find static files
-    LOKI_SKILL_DIR="$SKILL_DIR" PYTHONPATH="$SKILL_DIR" LOKI_DASHBOARD_HOST="$host" LOKI_DASHBOARD_PORT="$port" \
+    LOKI_DIR="$LOKI_DIR" LOKI_SKILL_DIR="$SKILL_DIR" PYTHONPATH="$SKILL_DIR" LOKI_DASHBOARD_HOST="$host" LOKI_DASHBOARD_PORT="$port" \
         nohup "$python_cmd" -m dashboard.server > "$log_file" 2>&1 &
     local new_pid=$!
 
@@ -3853,13 +3853,11 @@ if count == 0:
             echo -e "${BOLD}Search Results for: $query${NC}"
             echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
 
-            local query_escaped="${query//\'/\'\\\'\'}"
-            python3 -c "
-import json
-import os
+            LOKI_SEARCH_QUERY="$query" LOKI_LEARNINGS_DIR="$learnings_dir" python3 -c "
+import json, os
 
-learnings_dir = '$learnings_dir'
-query = '${query_escaped}'.lower()
+learnings_dir = os.environ['LOKI_LEARNINGS_DIR']
+query = os.environ['LOKI_SEARCH_QUERY'].lower()
 
 for filename in ['patterns.jsonl', 'mistakes.jsonl', 'successes.jsonl']:
     filepath = os.path.join(learnings_dir, filename)

package/autonomy/run.sh

@@ -1467,7 +1467,7 @@ create_worktree() {
 
         # Initialize environment (detect and run appropriate install)
         (
-            cd "$worktree_path"
+            cd "$worktree_path" || exit 1
             if [ -f "package.json" ]; then
                 npm install --silent 2>/dev/null || true
             elif [ -f "requirements.txt" ]; then
@@ -1558,7 +1558,7 @@ spawn_worktree_session() {
     log_step "Spawning ${PROVIDER_DISPLAY_NAME:-Claude} session: $stream_name"
 
     (
-        cd "$worktree_path"
+        cd "$worktree_path" || exit 1
         # Provider-specific invocation for parallel sessions
         case "${PROVIDER_NAME:-claude}" in
             claude)
@@ -1695,7 +1695,7 @@ merge_feature() {
     log_step "Merging feature: $feature"
 
     (
-        cd "$TARGET_DIR"
+        cd "$TARGET_DIR" || exit 1
 
         # Ensure we're on main
         git checkout main 2>/dev/null
@@ -2079,9 +2079,36 @@ init_loki_dir() {
 EOF
     fi
 
+    # Write pricing.json with provider-specific model rates
+    _write_pricing_json
+
     log_info "Loki directory initialized: .loki/"
 }
 
+# Write .loki/pricing.json based on active provider
+_write_pricing_json() {
+    local provider="${LOKI_PROVIDER:-claude}"
+    local updated
+    updated=$(date -u +%Y-%m-%d)
+
+    cat > ".loki/pricing.json" << PRICING_EOF
+{
+  "provider": "${provider}",
+  "updated": "${updated}",
+  "source": "static",
+  "models": {
+    "opus":            {"input": 5.00,  "output": 25.00, "label": "Opus 4.6",       "provider": "claude"},
+    "sonnet":          {"input": 3.00,  "output": 15.00, "label": "Sonnet 4.5",     "provider": "claude"},
+    "haiku":           {"input": 1.00,  "output": 5.00,  "label": "Haiku 4.5",      "provider": "claude"},
+    "gpt-5.3-codex":   {"input": 1.50,  "output": 12.00, "label": "GPT-5.3 Codex", "provider": "codex"},
+    "gemini-3-pro":    {"input": 1.25,  "output": 10.00, "label": "Gemini 3 Pro",   "provider": "gemini"},
+    "gemini-3-flash":  {"input": 0.10,  "output": 0.40,  "label": "Gemini 3 Flash", "provider": "gemini"}
+  }
+}
+PRICING_EOF
+    log_info "Pricing data written: .loki/pricing.json (provider: ${provider})"
+}
+
 #===============================================================================
 # Gemini Invocation with Rate Limit Fallback
 #===============================================================================
@@ -2384,6 +2411,7 @@ write_dashboard_state() {
     "path": "$project_path"
   },
   "mode": "$mode",
+  "provider": "${PROVIDER_NAME:-claude}",
   "phase": "$current_phase",
   "complexity": "$complexity",
   "iteration": $ITERATION_COUNT,
@@ -2539,6 +2567,30 @@ track_iteration_complete() {
             --context "{\"iteration\":$iteration,\"exit_code\":$exit_code}"
     fi
 
+    # Write efficiency tracking file for /api/cost endpoint
+    mkdir -p .loki/metrics/efficiency
+    local model_tier="sonnet"
+    if [ "${PROVIDER_NAME:-claude}" = "claude" ]; then
+        model_tier="sonnet"
+    elif [ "${PROVIDER_NAME:-claude}" = "codex" ]; then
+        model_tier="gpt-5.3-codex"
+    elif [ "${PROVIDER_NAME:-claude}" = "gemini" ]; then
+        model_tier="gemini-3-pro"
+    fi
+    local phase="$current_phase"
+    [ -z "$phase" ] && phase=$(python3 -c "import json; print(json.load(open('.loki/state/orchestrator.json')).get('currentPhase', 'unknown'))" 2>/dev/null || echo "unknown")
+    cat > ".loki/metrics/efficiency/iteration-${iteration}.json" << EFF_EOF
+{
+  "iteration": $iteration,
+  "model": "$model_tier",
+  "phase": "$phase",
+  "duration_ms": $duration_ms,
+  "provider": "${PROVIDER_NAME:-claude}",
+  "status": "$status_str",
+  "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)"
+}
+EFF_EOF
+
     # Get task from in-progress
     local in_progress_file=".loki/queue/in-progress.json"
     local completed_file=".loki/queue/completed.json"
@@ -3562,11 +3614,16 @@ start_dashboard() {
         # Check if it's our own dashboard
         local existing_pid=$(lsof -ti :$DASHBOARD_PORT 2>/dev/null | head -1)
         if [ -n "$existing_pid" ]; then
-            # Kill existing dashboard on this port
-            log_step "Killing existing dashboard on port $DASHBOARD_PORT..."
-            kill "$existing_pid" 2>/dev/null || true
-            sleep 1
-            break
+            # Only kill if it's a Python/uvicorn dashboard process
+            local proc_cmd=$(ps -p "$existing_pid" -o comm= 2>/dev/null || true)
+            if [[ "$proc_cmd" == *python* ]] || [[ "$proc_cmd" == *uvicorn* ]]; then
+                log_step "Killing existing dashboard on port $DASHBOARD_PORT (PID: $existing_pid)..."
+                kill "$existing_pid" 2>/dev/null || true
+                sleep 1
+                break
+            else
+                log_info "Port $DASHBOARD_PORT in use by non-dashboard process ($proc_cmd), skipping..."
+            fi
         fi
         ((DASHBOARD_PORT++))
         if [ "$DASHBOARD_PORT" -gt 65535 ]; then

package/dashboard/__init__.py

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

package/dashboard/server.py

@@ -539,7 +539,7 @@ async def list_tasks(
                     payload = task.get("payload", {})
                     all_tasks.append({
                         "id": task_id,
-                        "title": payload.get("action", task.get("type", "Task")),
+                        "title": task.get("title", payload.get("action", task.get("type", "Task"))),
                         "description": payload.get("description", ""),
                         "status": mapped_status,
                         "priority": payload.get("priority", "medium"),
@@ -556,6 +556,8 @@ async def list_tasks(
             ("pending.json", "pending"),
             ("in-progress.json", "in_progress"),
             ("completed.json", "done"),
+            ("failed.json", "done"),
+            ("dead-letter.json", "done"),
         ]:
             fpath = queue_dir / queue_file
             if fpath.exists():
@@ -1139,13 +1141,10 @@ def _sanitize_agent_id(agent_id: str) -> str:
         )
     return agent_id
 
-_LOKI_DIR = _get_loki_dir()
-
-
 @app.get("/api/memory/summary")
 async def get_memory_summary():
     """Get memory system summary from .loki/memory/."""
-    memory_dir = _LOKI_DIR / "memory"
+    memory_dir = _get_loki_dir() / "memory"
     summary = {
         "episodic": {"count": 0, "latestDate": None},
         "semantic": {"patterns": 0, "antiPatterns": 0},
@@ -1206,7 +1205,7 @@ async def get_memory_summary():
 @app.get("/api/memory/episodes")
 async def list_episodes(limit: int = 50):
     """List episodic memory entries."""
-    ep_dir = _LOKI_DIR / "memory" / "episodic"
+    ep_dir = _get_loki_dir() / "memory" / "episodic"
     episodes = []
     if ep_dir.exists():
         files = sorted(ep_dir.glob("*.json"), reverse=True)[:limit]
@@ -1221,7 +1220,7 @@ async def list_episodes(limit: int = 50):
 @app.get("/api/memory/episodes/{episode_id}")
 async def get_episode(episode_id: str):
     """Get a specific episodic memory entry."""
-    ep_dir = _LOKI_DIR / "memory" / "episodic"
+    ep_dir = _get_loki_dir() / "memory" / "episodic"
     if not ep_dir.exists():
         raise HTTPException(status_code=404, detail="Episode not found")
     # Try direct filename match
@@ -1238,7 +1237,7 @@ async def get_episode(episode_id: str):
 @app.get("/api/memory/patterns")
 async def list_patterns():
     """List semantic patterns."""
-    sem_dir = _LOKI_DIR / "memory" / "semantic"
+    sem_dir = _get_loki_dir() / "memory" / "semantic"
     patterns_file = sem_dir / "patterns.json"
     if patterns_file.exists():
         try:
@@ -1262,7 +1261,7 @@ async def get_pattern(pattern_id: str):
 @app.get("/api/memory/skills")
 async def list_skills():
     """List procedural skills."""
-    skills_dir = _LOKI_DIR / "memory" / "skills"
+    skills_dir = _get_loki_dir() / "memory" / "skills"
     skills = []
     if skills_dir.exists():
         for f in sorted(skills_dir.glob("*.json")):
@@ -1276,7 +1275,7 @@ async def list_skills():
 @app.get("/api/memory/skills/{skill_id}")
 async def get_skill(skill_id: str):
     """Get a specific procedural skill."""
-    skills_dir = _LOKI_DIR / "memory" / "skills"
+    skills_dir = _get_loki_dir() / "memory" / "skills"
     if not skills_dir.exists():
         raise HTTPException(status_code=404, detail="Skill not found")
     for f in skills_dir.glob("*.json"):
@@ -1292,7 +1291,7 @@ async def get_skill(skill_id: str):
 @app.get("/api/memory/economics")
 async def get_token_economics():
     """Get token usage economics."""
-    econ_file = _LOKI_DIR / "memory" / "token_economics.json"
+    econ_file = _get_loki_dir() / "memory" / "token_economics.json"
     if econ_file.exists():
         try:
             return json.loads(econ_file.read_text())
@@ -1304,7 +1303,7 @@ async def get_token_economics():
 @app.post("/api/memory/consolidate")
 async def consolidate_memory(hours: int = 24):
     """Trigger memory consolidation (stub - returns current state)."""
-    return {"status": "ok", "message": f"Consolidation for last {hours}h", "consolidated": 0}
+    return {"status": "ok", "message": f"Consolidation for last {hours}h", "consolidated": 0, "patternsCreated": 0, "patternsMerged": 0, "episodesProcessed": 0}
 
 
 @app.post("/api/memory/retrieve")
@@ -1316,7 +1315,7 @@ async def retrieve_memory(query: dict = None):
 @app.get("/api/memory/index")
 async def get_memory_index():
     """Get memory index (Layer 1 - lightweight discovery)."""
-    index_file = _LOKI_DIR / "memory" / "index.json"
+    index_file = _get_loki_dir() / "memory" / "index.json"
     if index_file.exists():
         try:
             return json.loads(index_file.read_text())
@@ -1328,7 +1327,7 @@ async def get_memory_index():
 @app.get("/api/memory/timeline")
 async def get_memory_timeline():
     """Get memory timeline (Layer 2 - progressive disclosure)."""
-    timeline_file = _LOKI_DIR / "memory" / "timeline.json"
+    timeline_file = _get_loki_dir() / "memory" / "timeline.json"
     if timeline_file.exists():
         try:
             return json.loads(timeline_file.read_text())
@@ -1371,7 +1370,7 @@ async def get_learning_metrics(
         "success_patterns": [],
         "tool_efficiencies": [],
     }
-    agg_file = _LOKI_DIR / "metrics" / "aggregation.json"
+    agg_file = _get_loki_dir() / "metrics" / "aggregation.json"
     if agg_file.exists():
         try:
             agg_data = json.loads(agg_file.read_text())
@@ -1386,7 +1385,7 @@ async def get_learning_metrics(
         "totalSignals": len(events),
         "signalsByType": by_type,
         "signalsBySource": by_source,
-        "avgConfidence": 0,
+        "avgConfidence": round(sum(e.get("data", {}).get("confidence", 0) for e in events) / max(len(events), 1), 4),
         "aggregation": aggregation,
     }
 
@@ -1431,7 +1430,7 @@ async def get_learning_signals(
 @app.get("/api/learning/aggregation")
 async def get_learning_aggregation():
     """Get latest learning aggregation result."""
-    agg_file = _LOKI_DIR / "metrics" / "aggregation.json"
+    agg_file = _get_loki_dir() / "metrics" / "aggregation.json"
     if agg_file.exists():
         try:
             return json.loads(agg_file.read_text())
@@ -1443,7 +1442,7 @@ async def get_learning_aggregation():
 @app.post("/api/learning/aggregate")
 async def trigger_aggregation():
     """Aggregate learning signals from events.jsonl into structured metrics."""
-    events_file = _LOKI_DIR / "events.jsonl"
+    events_file = _get_loki_dir() / "events.jsonl"
     preferences: dict = {}
     error_patterns: dict = {}
     success_patterns: dict = {}
@@ -1491,17 +1490,19 @@ async def trigger_aggregation():
             pass
 
     # Build structured result
-    pref_list = [{"key": k, "count": v} for k, v in sorted(preferences.items(), key=lambda x: -x[1])]
-    error_list = [{"type": k, "count": v} for k, v in sorted(error_patterns.items(), key=lambda x: -x[1])]
-    success_list = [{"name": k, "count": v} for k, v in sorted(success_patterns.items(), key=lambda x: -x[1])]
+    pref_list = [{"preference_key": k, "preferred_value": k, "frequency": v, "confidence": min(1.0, v / 10)} for k, v in sorted(preferences.items(), key=lambda x: -x[1])]
+    error_list = [{"error_type": k, "resolution_rate": 0.0, "frequency": v, "confidence": min(1.0, v / 10)} for k, v in sorted(error_patterns.items(), key=lambda x: -x[1])]
+    success_list = [{"pattern_name": k, "avg_duration_seconds": 0, "frequency": v, "confidence": min(1.0, v / 10)} for k, v in sorted(success_patterns.items(), key=lambda x: -x[1])]
     tool_list = []
     for tname, stats in sorted(tool_stats.items(), key=lambda x: -x[1]["count"]):
         avg_ms = stats["total_ms"] / stats["count"] if stats["count"] else 0
+        sr = round(stats["successes"] / stats["count"], 4) if stats["count"] else 0
         tool_list.append({
-            "tool": tname,
+            "tool_name": tname,
+            "efficiency_score": sr,
             "count": stats["count"],
-            "avg_duration_ms": round(avg_ms, 2),
-            "success_rate": round(stats["successes"] / stats["count"], 4) if stats["count"] else 0,
+            "avg_execution_time_ms": round(avg_ms, 2),
+            "success_rate": sr,
         })
 
     result = {
@@ -1513,7 +1514,7 @@ async def trigger_aggregation():
     }
 
     # Write to metrics directory
-    metrics_dir = _LOKI_DIR / "metrics"
+    metrics_dir = _get_loki_dir() / "metrics"
     metrics_dir.mkdir(parents=True, exist_ok=True)
     try:
         (metrics_dir / "aggregation.json").write_text(json.dumps(result, indent=2))
@@ -1574,7 +1575,7 @@ def _parse_time_range(time_range: str) -> Optional[datetime]:
 
 def _read_events(time_range: str = "7d") -> list:
     """Read events from .loki/events.jsonl with time filter."""
-    events_file = _LOKI_DIR / "events.jsonl"
+    events_file = _get_loki_dir() / "events.jsonl"
     if not events_file.exists():
         return []
 
@@ -1607,7 +1608,7 @@ def _read_events(time_range: str = "7d") -> list:
 @app.post("/api/control/pause")
 async def pause_session():
     """Pause the current session by creating PAUSE file."""
-    pause_file = _LOKI_DIR / "PAUSE"
+    pause_file = _get_loki_dir() / "PAUSE"
     pause_file.parent.mkdir(parents=True, exist_ok=True)
     pause_file.write_text(datetime.now().isoformat())
     return {"success": True, "message": "Session paused"}
@@ -1617,7 +1618,7 @@ async def pause_session():
 async def resume_session():
     """Resume a paused session by removing PAUSE/STOP files."""
     for fname in ["PAUSE", "STOP"]:
-        fpath = _LOKI_DIR / fname
+        fpath = _get_loki_dir() / fname
         try:
             fpath.unlink(missing_ok=True)
         except Exception:
@@ -1628,12 +1629,12 @@ async def resume_session():
 @app.post("/api/control/stop")
 async def stop_session():
     """Stop the session by creating STOP file and sending SIGTERM."""
-    stop_file = _LOKI_DIR / "STOP"
+    stop_file = _get_loki_dir() / "STOP"
     stop_file.parent.mkdir(parents=True, exist_ok=True)
     stop_file.write_text(datetime.now().isoformat())
 
     # Try to kill the process
-    pid_file = _LOKI_DIR / "loki.pid"
+    pid_file = _get_loki_dir() / "loki.pid"
     if pid_file.exists():
         try:
             pid = int(pid_file.read_text().strip())
@@ -1642,7 +1643,7 @@ async def stop_session():
             pass
 
     # Mark session.json as stopped
-    session_file = _LOKI_DIR / "session.json"
+    session_file = _get_loki_dir() / "session.json"
     if session_file.exists():
         try:
             sd = json.loads(session_file.read_text())
@@ -1658,17 +1659,53 @@ async def stop_session():
 # Cost Visibility API
 # =============================================================================
 
-# Standard API pricing per million tokens (USD)
-_MODEL_PRICING = {
-    "opus":   {"input": 15.00, "output": 75.00},
-    "sonnet": {"input": 3.00,  "output": 15.00},
-    "haiku":  {"input": 0.25,  "output": 1.25},
+# Static fallback pricing per million tokens (USD) - updated 2026-02-07
+# At runtime, overridden by .loki/pricing.json if available
+_DEFAULT_PRICING = {
+    # Claude (Anthropic)
+    "opus":   {"input": 5.00, "output": 25.00},
+    "sonnet": {"input": 3.00, "output": 15.00},
+    "haiku":  {"input": 1.00, "output": 5.00},
+    # OpenAI Codex
+    "gpt-5.3-codex": {"input": 1.50, "output": 12.00},
+    # Google Gemini
+    "gemini-3-pro":  {"input": 1.25, "output": 10.00},
+    "gemini-3-flash": {"input": 0.10, "output": 0.40},
 }
 
+# Active pricing - starts with defaults, updated from .loki/pricing.json
+_MODEL_PRICING = dict(_DEFAULT_PRICING)
+
+
+def _load_pricing_from_file() -> dict:
+    """Load pricing from .loki/pricing.json if available."""
+    loki_dir = _get_loki_dir()
+    pricing_file = loki_dir / "pricing.json"
+    if pricing_file.exists():
+        try:
+            data = json.loads(pricing_file.read_text())
+            models = data.get("models", {})
+            if models:
+                return models
+        except (json.JSONDecodeError, IOError):
+            pass
+    return {}
+
+
+def _get_model_pricing() -> dict:
+    """Get current model pricing, preferring .loki/pricing.json over defaults."""
+    file_pricing = _load_pricing_from_file()
+    if file_pricing:
+        merged = dict(_DEFAULT_PRICING)
+        merged.update(file_pricing)
+        return merged
+    return _MODEL_PRICING
+
 
 def _calculate_model_cost(model: str, input_tokens: int, output_tokens: int) -> float:
     """Calculate USD cost for a model's token usage."""
-    pricing = _MODEL_PRICING.get(model.lower(), _MODEL_PRICING.get("sonnet", {}))
+    pricing_table = _get_model_pricing()
+    pricing = pricing_table.get(model.lower(), pricing_table.get("sonnet", {}))
     input_cost = (input_tokens / 1_000_000) * pricing.get("input", 3.00)
     output_cost = (output_tokens / 1_000_000) * pricing.get("output", 15.00)
     return input_cost + output_cost
@@ -1773,6 +1810,72 @@ async def get_cost():
     }
 
 
+# =============================================================================
+# Pricing API
+# =============================================================================
+
+_PROVIDER_LABELS = {
+    "opus": "Opus 4.6",
+    "sonnet": "Sonnet 4.5",
+    "haiku": "Haiku 4.5",
+    "gpt-5.3-codex": "GPT-5.3 Codex",
+    "gemini-3-pro": "Gemini 3 Pro",
+    "gemini-3-flash": "Gemini 3 Flash",
+}
+
+_MODEL_PROVIDERS = {
+    "opus": "claude",
+    "sonnet": "claude",
+    "haiku": "claude",
+    "gpt-5.3-codex": "codex",
+    "gemini-3-pro": "gemini",
+    "gemini-3-flash": "gemini",
+}
+
+
+@app.get("/api/pricing")
+async def get_pricing():
+    """Get current model pricing. Reads from .loki/pricing.json if available, falls back to static defaults."""
+    loki_dir = _get_loki_dir()
+    pricing_file = loki_dir / "pricing.json"
+
+    # Try to read from .loki/pricing.json first
+    if pricing_file.exists():
+        try:
+            data = json.loads(pricing_file.read_text())
+            if data.get("models"):
+                return data
+        except (json.JSONDecodeError, IOError):
+            pass
+
+    # Determine active provider
+    provider = "claude"
+    provider_file = loki_dir / "state" / "provider"
+    if provider_file.exists():
+        try:
+            provider = provider_file.read_text().strip()
+        except IOError:
+            pass
+
+    # Build response from static defaults
+    pricing_table = _get_model_pricing()
+    models = {}
+    for model_key, rates in pricing_table.items():
+        models[model_key] = {
+            "input": rates["input"],
+            "output": rates["output"],
+            "label": _PROVIDER_LABELS.get(model_key, model_key),
+            "provider": _MODEL_PROVIDERS.get(model_key, "unknown"),
+        }
+
+    return {
+        "provider": provider,
+        "updated": "2026-02-07",
+        "source": "static",
+        "models": models,
+    }
+
+
 # =============================================================================
 # Completion Council API (v5.25.0)
 # =============================================================================
@@ -1780,7 +1883,7 @@ async def get_cost():
 @app.get("/api/council/state")
 async def get_council_state():
     """Get current Completion Council state."""
-    state_file = _LOKI_DIR / "council" / "state.json"
+    state_file = _get_loki_dir() / "council" / "state.json"
     if state_file.exists():
         try:
             return json.loads(state_file.read_text())
@@ -1792,7 +1895,7 @@ async def get_council_state():
 @app.get("/api/council/verdicts")
 async def get_council_verdicts(limit: int = 20):
     """Get council vote history (decision log)."""
-    state_file = _LOKI_DIR / "council" / "state.json"
+    state_file = _get_loki_dir() / "council" / "state.json"
     verdicts = []
     if state_file.exists():
         try:
@@ -1802,7 +1905,7 @@ async def get_council_verdicts(limit: int = 20):
             pass
 
     # Also read individual vote files for detail
-    votes_dir = _LOKI_DIR / "council" / "votes"
+    votes_dir = _get_loki_dir() / "council" / "votes"
     detailed_verdicts = []
     if votes_dir.exists():
         for vote_dir in sorted(votes_dir.iterdir(), reverse=True):
@@ -1841,7 +1944,7 @@ async def get_council_verdicts(limit: int = 20):
 @app.get("/api/council/convergence")
 async def get_council_convergence():
     """Get convergence tracking data for visualization."""
-    convergence_file = _LOKI_DIR / "council" / "convergence.log"
+    convergence_file = _get_loki_dir() / "council" / "convergence.log"
     data_points = []
     if convergence_file.exists():
         try:
@@ -1863,7 +1966,7 @@ async def get_council_convergence():
 @app.get("/api/council/report")
 async def get_council_report():
     """Get the final council completion report."""
-    report_file = _LOKI_DIR / "council" / "report.md"
+    report_file = _get_loki_dir() / "council" / "report.md"
     if report_file.exists():
         return {"report": report_file.read_text()}
     return {"report": None}
@@ -1872,7 +1975,7 @@ async def get_council_report():
 @app.post("/api/council/force-review")
 async def force_council_review():
     """Force an immediate council review (writes signal file)."""
-    signal_dir = _LOKI_DIR / "signals"
+    signal_dir = _get_loki_dir() / "signals"
     signal_dir.mkdir(parents=True, exist_ok=True)
     (signal_dir / "COUNCIL_REVIEW_REQUESTED").write_text(
         datetime.now().isoformat()
@@ -1887,7 +1990,7 @@ async def force_council_review():
 @app.get("/api/agents")
 async def get_agents():
     """Get all active and recent agents."""
-    agents_file = _LOKI_DIR / "state" / "agents.json"
+    agents_file = _get_loki_dir() / "state" / "agents.json"
     agents = []
     if agents_file.exists():
         try:
@@ -1909,7 +2012,7 @@ async def get_agents():
 
     # Fallback: read agents from dashboard-state.json if agents.json is empty
     if not agents:
-        state_file = _LOKI_DIR / "dashboard-state.json"
+        state_file = _get_loki_dir() / "dashboard-state.json"
         if state_file.exists():
             try:
                 state = json.loads(state_file.read_text())
@@ -1943,7 +2046,7 @@ async def get_agents():
 @app.post("/api/agents/{agent_id}/kill")
 async def kill_agent(agent_id: str):
     """Kill a specific agent by ID."""
-    agents_file = _LOKI_DIR / "state" / "agents.json"
+    agents_file = _get_loki_dir() / "state" / "agents.json"
     if not agents_file.exists():
         raise HTTPException(404, "No agents file found")
 
@@ -1990,7 +2093,7 @@ async def kill_agent(agent_id: str):
 async def pause_agent(agent_id: str):
     """Pause a specific agent by writing a pause signal."""
     agent_id = _sanitize_agent_id(agent_id)
-    signal_dir = _LOKI_DIR / "signals"
+    signal_dir = _get_loki_dir() / "signals"
     signal_dir.mkdir(parents=True, exist_ok=True)
     (signal_dir / f"PAUSE_AGENT_{agent_id}").write_text(
         datetime.now().isoformat()
@@ -2002,7 +2105,7 @@ async def pause_agent(agent_id: str):
 async def resume_agent(agent_id: str):
     """Resume a paused agent."""
     agent_id = _sanitize_agent_id(agent_id)
-    signal_file = _LOKI_DIR / "signals" / f"PAUSE_AGENT_{agent_id}"
+    signal_file = _get_loki_dir() / "signals" / f"PAUSE_AGENT_{agent_id}"
     try:
         signal_file.unlink(missing_ok=True)
     except Exception:
@@ -2013,7 +2116,7 @@ async def resume_agent(agent_id: str):
 @app.get("/api/logs")
 async def get_logs(lines: int = 100):
     """Get recent log entries from session log files."""
-    log_dir = _LOKI_DIR / "logs"
+    log_dir = _get_loki_dir() / "logs"
     entries = []
 
     # Regex for full timestamp: [2026-02-07T01:32:00] [INFO] msg  or  2026-02-07 01:32:00 INFO msg