loki-mode 7.67.0 → 7.69.0

package/dashboard/__init__.py

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

package/dashboard/server.py

@@ -122,32 +122,43 @@ class _RateLimiter:
         self._window = window_seconds
         self._max_keys = max_keys
         self._calls: dict[str, list[float]] = defaultdict(list)
+        # Sync route handlers (plain `def`) run in Starlette's threadpool, so
+        # check() can be entered by several threads at once against this one
+        # shared instance. Without a guard, one thread iterating self._calls
+        # (the empty-key prune or the LRU-eviction sort) while another inserts
+        # or deletes a key raises "dictionary changed size during iteration",
+        # which surfaces to the caller as a 500 on a trivial rate-limit guard.
+        # The lock is held only around the in-memory bookkeeping (no I/O, no
+        # await), so contention is negligible and it cannot deadlock async
+        # callers that reach this via run_in_threadpool.
+        self._lock = threading.Lock()
 
     def check(self, key: str) -> bool:
         now = time.time()
-        # Prune old timestamps for this key
-        self._calls[key] = [t for t in self._calls[key] if now - t < self._window]
-
-        # Remove keys with empty timestamp lists
-        empty_keys = [k for k, v in self._calls.items() if not v]
-        for k in empty_keys:
-            del self._calls[k]
-
-        # Evict least-recently-accessed keys if max_keys exceeded
-        if len(self._calls) > self._max_keys:
-            # Sort by last-access time (most recent timestamp), evict least recent
-            sorted_keys = sorted(
-                self._calls.items(),
-                key=lambda x: max(x[1]) if x[1] else 0
-            )
-            keys_to_remove = len(self._calls) - self._max_keys
-            for k, _ in sorted_keys[:keys_to_remove]:
+        with self._lock:
+            # Prune old timestamps for this key
+            self._calls[key] = [t for t in self._calls[key] if now - t < self._window]
+
+            # Remove keys with empty timestamp lists
+            empty_keys = [k for k, v in self._calls.items() if not v]
+            for k in empty_keys:
                 del self._calls[k]
 
-        if len(self._calls[key]) >= self._max_calls:
-            return False
-        self._calls[key].append(now)
-        return True
+            # Evict least-recently-accessed keys if max_keys exceeded
+            if len(self._calls) > self._max_keys:
+                # Sort by last-access time (most recent timestamp), evict least recent
+                sorted_keys = sorted(
+                    self._calls.items(),
+                    key=lambda x: max(x[1]) if x[1] else 0
+                )
+                keys_to_remove = len(self._calls) - self._max_keys
+                for k, _ in sorted_keys[:keys_to_remove]:
+                    del self._calls[k]
+
+            if len(self._calls[key]) >= self._max_calls:
+                return False
+            self._calls[key].append(now)
+            return True
 
 
 _control_limiter = _RateLimiter(max_calls=10, window_seconds=60)
@@ -8675,6 +8686,17 @@ def _get_migration_imports():
     return _migration_imports
 
 
+def _get_migration_terminal_phase():
+    """Return the last phase in the migration PHASE_ORDER (the terminal phase),
+    or None if the migration engine is unavailable. Used to let the terminal
+    phase be advanced/completed without a successor to_phase (WAVE9 F1)."""
+    try:
+        from dashboard.migration_engine import PHASE_ORDER
+        return PHASE_ORDER[-1] if PHASE_ORDER else None
+    except (ImportError, IndexError):
+        return None
+
+
 @app.get("/api/migration/list", dependencies=[Depends(auth.require_scope("read"))])
 def list_migrations_endpoint():
     """List all migrations."""
@@ -8825,7 +8847,16 @@ def advance_migration(migration_id: str, request_body: dict):
     MigrationPipeline, list_migrations = imports
     from_phase = request_body.get("from_phase")
     to_phase = request_body.get("to_phase")
-    if not from_phase or not to_phase:
+    # The terminal phase (the last in PHASE_ORDER, e.g. "verify") has no
+    # successor, so check_phase_gate can never pass for it and to_phase is
+    # meaningless. Without this carve-out the terminal phase could never be
+    # completed via the API, so overall_status could never reach "completed"
+    # (WAVE9 migration-F1). For the terminal phase we require only from_phase
+    # and skip the gate; advance_phase still validates the phase and the
+    # (ValueError, RuntimeError) -> 409 handler below preserves idempotency.
+    terminal_phase = _get_migration_terminal_phase()
+    is_terminal = terminal_phase is not None and from_phase == terminal_phase
+    if not from_phase or (not to_phase and not is_terminal):
         raise HTTPException(status_code=400, detail="from_phase and to_phase are required")
     # Load pipeline and check phase gate before the try/except to let
     # HTTPException and FileNotFoundError propagate naturally.
@@ -8833,9 +8864,10 @@ def advance_migration(migration_id: str, request_body: dict):
         pipeline = MigrationPipeline.load(migration_id)
     except FileNotFoundError:
         raise HTTPException(status_code=404, detail=f"Migration not found: {migration_id}")
-    passed, reason = pipeline.check_phase_gate(from_phase, to_phase)
-    if not passed:
-        raise HTTPException(status_code=409, detail=reason)
+    if not is_terminal:
+        passed, reason = pipeline.check_phase_gate(from_phase, to_phase)
+        if not passed:
+            raise HTTPException(status_code=409, detail=reason)
     try:
         result = pipeline.advance_phase(from_phase)
         return asdict(result) if hasattr(result, '__dataclass_fields__') else result

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.67.0
+**Version:** v7.69.0
 
 ---
 
@@ -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.67.0 start ./my-spec.md
+  asklokesh/loki-mode:7.69.0 start ./my-spec.md
 ```
 
 ##### docker compose + .env (no host install)