loki-mode 6.73.0 → 6.74.0

package/LICENSE

@@ -1,3 +1,5 @@
+SPDX-License-Identifier: BUSL-1.1
+
 Business Source License 1.1
 
 Parameters

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 minimal human intervention. Requires --dangerously-skip-permissions flag.
 ---
 
-# Loki Mode v6.73.0
+# Loki Mode v6.74.0
 
 **You are an autonomous agent. You make decisions. You do not ask questions. You do not stop.**
 
@@ -21,7 +21,7 @@ Execute these steps IN ORDER at the start of EVERY turn:
    - Load 1-2 modules matching your current phase
    - Register session: Write .loki/session.json with:
      {"pid": null, "startedAt": "<ISO timestamp>", "provider": "<provider>",
-      "invokedVia": "skill", "status": "running"}
+      "invokedVia": "skill", "status": "running", "updatedAt": "<ISO timestamp>"}
 
 2. Read .loki/state/orchestrator.json
    - Extract: currentPhase, tasksCompleted, tasksFailed
@@ -32,6 +32,10 @@ Execute these steps IN ORDER at the start of EVERY turn:
 
 4. Check .loki/PAUSE - IF exists: Stop work, wait for removal.
    Check .loki/STOP - IF exists: End session, update session.json status to "stopped".
+
+5. EVERY TURN: Update .loki/session.json "updatedAt" field to current ISO timestamp.
+   This keeps the dashboard aware the skill session is alive. Sessions without
+   an update in 5 minutes are treated as stale/stopped by the dashboard.
 ```
 
 ---
@@ -137,7 +141,7 @@ GROWTH ──[continuous improvement loop]──> GROWTH
 
 | File | Read | Write |
 |------|------|-------|
-| `.loki/session.json` | Session start | Session start (register), session end (update status) |
+| `.loki/session.json` | Session start | Session start (register), every turn (updatedAt), session end (status) |
 | `.loki/state/orchestrator.json` | Every turn | On phase change |
 | `.loki/queue/pending.json` | Every turn | When claiming/completing tasks |
 | `.loki/queue/current-task.json` | Before each ACT | When claiming task |
@@ -268,4 +272,4 @@ The following features are documented in skill modules but not yet fully automat
 | Quality gates 3-reviewer system | Implemented (v5.35.0) | 5 specialist reviewers in `skills/quality-gates.md`; execution in run.sh |
 | Benchmarks (HumanEval, SWE-bench) | Infrastructure only | Runner scripts and datasets exist in `benchmarks/`; no published results |
 
-**v6.73.0 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**
+**v6.74.0 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**

package/VERSION

@@ -1 +1 @@
-6.73.0
+6.74.0

package/dashboard/__init__.py

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

package/dashboard/server.py

@@ -345,8 +345,12 @@ async def _push_loki_state_loop() -> None:
 
     Reads dashboard-state.json every 2s when running (30s when idle) and
     broadcasts a state_update message so clients don't rely solely on polling.
+
+    When dashboard-state.json is absent (skill-invoked sessions), reads state
+    from session.json + orchestrator.json + queue files instead.
     """
     last_mtime: float = 0.0
+    _last_skill_hash: str = ""  # Track skill-session state changes
     while True:
         try:
             if not manager.active_connections:
@@ -355,6 +359,9 @@ async def _push_loki_state_loop() -> None:
 
             loki_dir = _get_loki_dir()
             state_file = loki_dir / "dashboard-state.json"
+            _session_file = loki_dir / "session.json"
+
+            _broadcast_sent = False
 
             if state_file.exists():
                 try:
@@ -397,6 +404,15 @@ async def _push_loki_state_loop() -> None:
                             except (ValueError, OSError, ProcessLookupError):
                                 pass
 
+                        # Also check session.json for skill sessions
+                        if not _pid_alive and _session_file.exists():
+                            try:
+                                _sd = _safe_json_read(_session_file, {})
+                                if _sd.get("status") == "running":
+                                    _pid_alive = True
+                            except (json.JSONDecodeError, KeyError):
+                                pass
+
                         status_str = raw.get("mode", "autonomous")
                         if not _pid_alive:
                             status_str = "stopped"
@@ -423,9 +439,128 @@ async def _push_loki_state_loop() -> None:
                             "type": "status_update",
                             "data": payload,
                         })
+                        _broadcast_sent = True
                     except (json.JSONDecodeError, OSError, KeyError):
                         pass
 
+            # Skill-session fallback: when dashboard-state.json is missing,
+            # read state from session.json + orchestrator.json + queue files
+            if not _broadcast_sent and _session_file.exists():
+                try:
+                    _sd = _safe_json_read(_session_file, {})
+                    if _sd.get("status") == "running":
+                        # Validate freshness (5 min staleness threshold)
+                        _sk_ts = _sd.get("updatedAt") or _sd.get("startedAt", "")
+                        _sk_fresh = True
+                        if _sk_ts:
+                            try:
+                                _sk_dt = datetime.fromisoformat(
+                                    _sk_ts.replace("Z", "+00:00")
+                                )
+                                if _sk_dt.tzinfo is None:
+                                    _sk_dt = _sk_dt.replace(tzinfo=timezone.utc)
+                                if (datetime.now(timezone.utc) - _sk_dt).total_seconds() > 300:
+                                    _sk_fresh = False
+                            except (ValueError, AttributeError):
+                                pass
+                        else:
+                            try:
+                                if time.time() - _session_file.stat().st_mtime > 300:
+                                    _sk_fresh = False
+                            except OSError:
+                                pass
+
+                        if _sk_fresh:
+                            # Read version from VERSION file
+                            _sk_version = ""
+                            _vf = _Path(os.path.dirname(os.path.dirname(__file__))) / "VERSION"
+                            if _vf.is_file():
+                                try:
+                                    _sk_version = _vf.read_text().strip()
+                                except OSError:
+                                    pass
+
+                            # Read orchestrator state
+                            _sk_phase = ""
+                            _sk_iteration = 0
+                            _sk_complexity = "standard"
+                            _orch_f = loki_dir / "state" / "orchestrator.json"
+                            if _orch_f.exists():
+                                try:
+                                    _orch = _safe_json_read(_orch_f, {})
+                                    _sk_phase = _orch.get("currentPhase", "") or ""
+                                    _sk_iteration = _orch.get("iteration", 0)
+                                    _sk_complexity = _orch.get("complexity", "standard") or "standard"
+                                except (json.JSONDecodeError, KeyError):
+                                    pass
+
+                            # Read pending tasks
+                            _sk_pending = 0
+                            _sk_current_task = ""
+                            _pf = loki_dir / "queue" / "pending.json"
+                            if _pf.exists():
+                                try:
+                                    _pd = _safe_json_read(_pf, [])
+                                    _pt = _pd.get("tasks", _pd) if isinstance(_pd, dict) else _pd
+                                    if isinstance(_pt, list):
+                                        _sk_pending = len(_pt)
+                                except (json.JSONDecodeError, KeyError, AttributeError):
+                                    pass
+
+                            _ipf = loki_dir / "queue" / "in-progress.json"
+                            if _ipf.exists():
+                                try:
+                                    _ipd = _safe_json_read(_ipf, [])
+                                    _ipt = _ipd.get("tasks", _ipd) if isinstance(_ipd, dict) else _ipd
+                                    if isinstance(_ipt, list) and _ipt:
+                                        _f = _ipt[0]
+                                        if isinstance(_f, dict):
+                                            _sk_current_task = (
+                                                _f.get("title", "")
+                                                or _f.get("payload", {}).get("action", "")
+                                                or _f.get("id", "")
+                                            )
+                                except (json.JSONDecodeError, KeyError, AttributeError):
+                                    pass
+
+                            if not _sk_current_task:
+                                _ctf = loki_dir / "queue" / "current-task.json"
+                                if _ctf.exists():
+                                    try:
+                                        _ct = _safe_json_read(_ctf, {})
+                                        if isinstance(_ct, dict):
+                                            _sk_current_task = (
+                                                _ct.get("title", "")
+                                                or _ct.get("payload", {}).get("action", "")
+                                                or _ct.get("id", "")
+                                            )
+                                    except (json.JSONDecodeError, KeyError, AttributeError):
+                                        pass
+
+                            # Build a change hash to avoid redundant broadcasts
+                            _sk_hash = f"{_sk_phase}:{_sk_iteration}:{_sk_pending}:{_sk_current_task}"
+                            if _sk_hash != _last_skill_hash:
+                                _last_skill_hash = _sk_hash
+                                payload = {
+                                    "status": "running",
+                                    "phase": _sk_phase,
+                                    "iteration": _sk_iteration,
+                                    "complexity": _sk_complexity,
+                                    "mode": "autonomous",
+                                    "provider": _sd.get("provider", "claude"),
+                                    "running_agents": 0,
+                                    "pending_tasks": _sk_pending,
+                                    "current_task": _sk_current_task,
+                                    "version": _sk_version,
+                                }
+                                await manager.broadcast({
+                                    "type": "status_update",
+                                    "data": payload,
+                                })
+                                _broadcast_sent = True
+                except (json.JSONDecodeError, OSError, KeyError):
+                    pass
+
             # Poll faster when a session is running
             pid_file = loki_dir / "loki.pid"
             is_running = False
@@ -437,6 +572,15 @@ async def _push_loki_state_loop() -> None:
                 except (ValueError, OSError, ProcessLookupError):
                     pass
 
+            # Also consider skill sessions as "running" for poll interval
+            if not is_running and _session_file.exists():
+                try:
+                    _sd2 = _safe_json_read(_session_file, {})
+                    if _sd2.get("status") == "running":
+                        is_running = True
+                except (json.JSONDecodeError, KeyError):
+                    pass
+
             await asyncio.sleep(2.0 if is_running else 30.0)
         except asyncio.CancelledError:
             return
@@ -598,9 +742,12 @@ async def get_status() -> StatusResponse:
     running_agents = 0
 
     # Read dashboard state (with retry for concurrent writes)
+    _has_dashboard_state = False
     if state_file.exists():
         try:
             state = _safe_json_read(state_file, {})
+            if state:
+                _has_dashboard_state = True
             phase = state.get("phase", "")
             iteration = state.get("iteration", 0)
             complexity = state.get("complexity", "standard")
@@ -641,14 +788,113 @@ async def get_status() -> StatusResponse:
             pass
 
     # Also check session.json for skill-invoked sessions
+    _skill_session = False
     if not running and session_file.exists():
         try:
             sd = _safe_json_read(session_file, {})
             if sd.get("status") == "running":
-                running = True
+                # Validate freshness: session.json must have been updated within
+                # the last 5 minutes to be considered active (skill agents update
+                # it each turn).  Fall back to file mtime if no timestamp field.
+                _session_fresh = True
+                _session_ts = sd.get("updatedAt") or sd.get("startedAt", "")
+                if _session_ts:
+                    try:
+                        _sdt = datetime.fromisoformat(
+                            _session_ts.replace("Z", "+00:00")
+                        )
+                        if _sdt.tzinfo is None:
+                            _sdt = _sdt.replace(tzinfo=timezone.utc)
+                        _age = (datetime.now(timezone.utc) - _sdt).total_seconds()
+                        if _age > 300:
+                            _session_fresh = False
+                    except (ValueError, AttributeError):
+                        pass
+                else:
+                    # No timestamp -- check file mtime
+                    try:
+                        _mtime = session_file.stat().st_mtime
+                        _age = time.time() - _mtime
+                        if _age > 300:
+                            _session_fresh = False
+                    except OSError:
+                        pass
+
+                if _session_fresh:
+                    running = True
+                    _skill_session = True
+                    # Pull provider from session.json if available
+                    _sp = sd.get("provider", "")
+                    if _sp:
+                        provider = _sp
         except (json.JSONDecodeError, KeyError):
             pass
 
+    # When running as a skill (no dashboard-state.json), read state from
+    # the orchestrator and queue files that the skill agent writes directly.
+    if _skill_session and not _has_dashboard_state:
+        orch_file = loki_dir / "state" / "orchestrator.json"
+        if orch_file.exists():
+            try:
+                orch = _safe_json_read(orch_file, {})
+                phase = orch.get("currentPhase", phase) or phase
+                iteration = orch.get("iteration", iteration)
+                complexity = orch.get("complexity", complexity) or complexity
+                _metrics = orch.get("metrics", {})
+                if isinstance(_metrics, dict):
+                    _tc = _metrics.get("tasksCompleted", 0)
+                    _tf = _metrics.get("tasksFailed", 0)
+                    if isinstance(_tc, (int, float)):
+                        pass  # available for future use
+            except (json.JSONDecodeError, KeyError):
+                pass
+
+        # Read pending task count from queue files
+        _q_pending = loki_dir / "queue" / "pending.json"
+        if _q_pending.exists():
+            try:
+                _qd = _safe_json_read(_q_pending, [])
+                _tasks = _qd.get("tasks", _qd) if isinstance(_qd, dict) else _qd
+                if isinstance(_tasks, list):
+                    pending_tasks = len(_tasks)
+            except (json.JSONDecodeError, KeyError, AttributeError):
+                pass
+
+        # Read current task from in-progress queue
+        _q_inprog = loki_dir / "queue" / "in-progress.json"
+        if _q_inprog.exists():
+            try:
+                _ipd = _safe_json_read(_q_inprog, [])
+                _ip_tasks = _ipd.get("tasks", _ipd) if isinstance(_ipd, dict) else _ipd
+                if isinstance(_ip_tasks, list) and _ip_tasks:
+                    _first = _ip_tasks[0]
+                    if isinstance(_first, dict):
+                        current_task = (
+                            _first.get("title", "")
+                            or _first.get("payload", {}).get("action", "")
+                            or _first.get("id", "")
+                        )
+            except (json.JSONDecodeError, KeyError, AttributeError):
+                pass
+
+        # Read current-task.json (skill agents write this when claiming a task)
+        _q_current = loki_dir / "queue" / "current-task.json"
+        if not current_task and _q_current.exists():
+            try:
+                _ct = _safe_json_read(_q_current, {})
+                if isinstance(_ct, dict):
+                    current_task = (
+                        _ct.get("title", "")
+                        or _ct.get("payload", {}).get("action", "")
+                        or _ct.get("id", "")
+                    )
+            except (json.JSONDecodeError, KeyError, AttributeError):
+                pass
+
+        # Skill sessions are autonomous by definition
+        if not mode:
+            mode = "autonomous"
+
     # Determine status string
     if not running:
         status = "stopped"

package/docs/DEMOS.md

@@ -0,0 +1,80 @@
+# Loki Mode -- Interactive Content Index
+
+Complete listing of all interactive HTML experiences in the Loki Mode repository. 18 files total across three categories.
+
+## Walkthroughs (11 HTML files)
+
+Located in `docs/walkthrough/`.
+
+| File | Title | Description | Size |
+|------|-------|-------------|------|
+| `index.html` | Build Your First App | Step-by-step tutorial from PRD to deployment | 43 KB |
+| `architecture.html` | System Architecture | Interactive SVG diagram of the full system | 34 KB |
+| `comparison.html` | Feature Comparison | Loki Mode vs competitor feature matrix | 26 KB |
+| `gallery.html` | Project Gallery | 24 example projects across categories | 37 KB |
+| `video-placeholder.html` | Build Process Animation | CSS-animated build walkthrough | 25 KB |
+| `build-demo.html` | Full Build Video Demo | 12-iteration build replay with timeline | 18 KB |
+| `ide-demo.html` | Purple Lab IDE Demo | Browser-based IDE mockup with editor and build panel | 17 KB |
+| `enterprise-demo.html` | Enterprise Features Demo | Audit logging, RBAC, security, compliance | 13 KB |
+| `provider-race-demo.html` | Multi-Provider Race Demo | Claude vs Codex vs Gemini animated race | 17 KB |
+| `memory-demo.html` | Memory System Demo | Three-layer memory with interactive exploration | 19 KB |
+| `dashboard-demo.html` | Dashboard Monitoring Demo | Real-time dashboard with live build log | 17 KB |
+
+**Hub page**: `docs/walkthrough/hub.html` links to all walkthroughs with categories and estimated durations.
+
+## Demo Apps (6 HTML files)
+
+Located in `examples/`. Each was generated by Loki Mode from a single prompt.
+
+| File | Title | Description | Size |
+|------|-------|-------------|------|
+| `demo-saas-dashboard.html` | SaaS Dashboard | KPI cards, sparklines, revenue chart, activity feed | 9 KB |
+| `demo-task-manager.html` | Task Manager | Kanban board with drag-and-drop and localStorage | 9 KB |
+| `demo-chat-app.html` | Chat App | Real-time chat with typing indicators and auto-scroll | 8 KB |
+| `demo-landing-page.html` | Landing Page | Hero, features, pricing, FAQ accordion, newsletter | 15 KB |
+| `demo-portfolio.html` | Portfolio | Animated gradients, skill bars, project cards, contact form | 12 KB |
+| `demo-ecommerce.html` | E-Commerce | Product filters, sorting, star ratings, cart counter | 12 KB |
+
+## Product Website (1 HTML file)
+
+| File | Title | Description | Size |
+|------|-------|-------------|------|
+| `website/index.html` | Loki Mode Product Website | Full landing page with hero, terminal animation, features, pricing | 38 KB |
+
+## Summary
+
+| Category | Count | Total Size |
+|----------|-------|------------|
+| Walkthroughs | 11 | 266 KB |
+| Demo Apps | 6 | 65 KB |
+| Product Website | 1 | 38 KB |
+| **Total** | **18** | **369 KB** |
+
+## Viewing Locally
+
+All files are self-contained HTML. Open directly in any browser:
+
+```bash
+# Open the demo hub (links to everything)
+open docs/walkthrough/hub.html
+
+# Open a specific walkthrough
+open docs/walkthrough/architecture.html
+
+# Open a demo app
+open examples/demo-saas-dashboard.html
+
+# Or serve the entire repo with a local server
+python3 -m http.server 8080
+# Then visit http://localhost:8080/docs/walkthrough/hub.html
+```
+
+## Design
+
+All interactive content shares these characteristics:
+
+- **Self-contained** -- Single HTML file with embedded CSS and JavaScript
+- **No build step** -- Open in any browser, works offline (except Google Fonts)
+- **Dark theme** -- Consistent dark design with purple accent (#553DE9)
+- **Responsive** -- Adapts to mobile, tablet, and desktop viewports
+- **No external dependencies** -- No npm packages, no CDN libraries, no frameworks

package/docs/INSTALLATION.md

@@ -2,7 +2,7 @@
 
 The flagship product of [Autonomi](https://www.autonomi.dev/). Complete installation instructions for all platforms and use cases.
 
-**Version:** v6.73.0
+**Version:** v6.74.0
 
 ---
 

package/docs/walkthrough/README.md

@@ -0,0 +1,50 @@
+# Loki Mode Walkthroughs
+
+Interactive HTML walkthroughs demonstrating Loki Mode's capabilities. Each file is self-contained -- no external dependencies, no build step. Open in any browser.
+
+## Walkthrough Files
+
+| File | Description | Size |
+|------|-------------|------|
+| `index.html` | **Build Your First App** -- Step-by-step tutorial walking through a complete Loki Mode build from PRD to deployment | 43 KB |
+| `architecture.html` | **System Architecture** -- Interactive SVG diagram showing the full Loki Mode architecture: RARV cycle, providers, memory, quality gates | 34 KB |
+| `comparison.html` | **Feature Comparison** -- Side-by-side comparison of Loki Mode vs alternative AI build tools with interactive feature matrix | 26 KB |
+| `gallery.html` | **Project Gallery** -- Showcase of 24 example projects built with Loki Mode across SaaS, CLI, mobile, and enterprise categories | 37 KB |
+| `video-placeholder.html` | **Build Process Animation** -- CSS-animated walkthrough of the build process with terminal replay and phase transitions | 25 KB |
+| `build-demo.html` | **Full Build Video Demo** -- Replay of a complete SaaS dashboard build showing all 12 iterations with timeline and progress tracking | 18 KB |
+| `ide-demo.html` | **Purple Lab IDE Demo** -- Interactive mockup of the browser-based Purple Lab IDE with file explorer, editor, and Loki Mode status panel | 17 KB |
+| `enterprise-demo.html` | **Enterprise Features Demo** -- Audit logging, RBAC, security architecture, compliance, and governance capabilities for organizations | 13 KB |
+| `provider-race-demo.html` | **Multi-Provider Race Demo** -- Animated race comparing Claude, Codex, and Gemini building the same app simultaneously | 17 KB |
+| `memory-demo.html` | **Memory System Demo** -- Interactive exploration of episodic, semantic, and procedural memory layers with progressive disclosure | 19 KB |
+| `dashboard-demo.html` | **Dashboard Monitoring Demo** -- Real-time monitoring dashboard mockup with build log, agent status, task queue, and KPI tracking | 17 KB |
+
+## Hub Page
+
+Open `hub.html` for a landing page that links to all walkthroughs with descriptions and categories.
+
+## How to View
+
+```bash
+# Open directly in browser
+open docs/walkthrough/hub.html
+
+# Or serve locally
+cd docs/walkthrough && python3 -m http.server 8080
+# Then visit http://localhost:8080/hub.html
+```
+
+## Design Conventions
+
+All walkthroughs share a consistent design language:
+
+- **Dark theme** with purple accent (#553DE9)
+- **Inter** font for UI text, **JetBrains Mono** for code
+- **Responsive** layouts that work on mobile, tablet, and desktop
+- **Self-contained** HTML with embedded CSS and JavaScript
+- **No external dependencies** beyond Google Fonts (optional, degrades gracefully)
+
+## Related Content
+
+- **Demo Apps**: See `examples/` for 6 functional app demos built by Loki Mode
+- **Product Website**: See `website/index.html` for the full product landing page
+- **Master Index**: See `docs/DEMOS.md` for a complete listing of all interactive content

package/mcp/__init__.py

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loki-mode",
-  "version": "6.73.0",
+  "version": "6.74.0",
   "description": "Loki Mode by Autonomi - Multi-agent autonomous startup system for Claude Code, Codex CLI, and Gemini CLI",
   "keywords": [
     "agent",