loki-mode 5.52.4 → 5.54.0

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 v5.52.4
+# Loki Mode v5.54.0
 
 **You are an autonomous agent. You make decisions. You do not ask questions. You do not stop.**
 
@@ -263,4 +263,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 |
 
-**v5.52.4 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**
+**v5.54.0 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**

package/VERSION

@@ -1 +1 @@
-5.52.4
+5.54.0

package/autonomy/loki

@@ -409,7 +409,8 @@ show_help() {
     echo "  council [cmd]    Completion council (status|verdicts|convergence|force-review|report)"
     echo "  checkpoint|cp    Save/restore session checkpoints"
     echo "  projects         Multi-project registry management"
-    echo "  audit            Agent action audit log"
+    echo "  audit [cmd]      Agent audit log and quality scanning (log|scan)"
+    echo "  optimize         Optimize prompts based on session history"
     echo "  enterprise       Enterprise feature management (tokens, OIDC)"
     echo "  metrics          Prometheus/OpenMetrics metrics from dashboard"
     echo "  dogfood          Show self-development statistics"
@@ -431,6 +432,7 @@ show_help() {
     echo "  --no-dashboard   Disable web dashboard"
     echo "  --sandbox        Run in Docker sandbox for isolation"
     echo "  --skip-memory    Skip loading memory context at startup"
+    echo "  --compliance PRESET  Enable compliance mode (default|healthcare|fintech|government)"
     echo "  --budget USD     Set cost budget limit (display in dashboard/status)"
     echo ""
     echo "Options for 'issue':"
@@ -484,6 +486,7 @@ cmd_start() {
                 echo "  --no-dashboard        Disable web dashboard"
                 echo "  --sandbox             Run in Docker sandbox"
                 echo "  --skip-memory         Skip loading memory context at startup"
+                echo "  --compliance PRESET   Enable compliance mode (default|healthcare|fintech|government)"
                 echo "  --budget USD          Cost budget limit (auto-pause when exceeded)"
                 echo "  --yes, -y             Skip confirmation prompts (auto-confirm)"
                 echo ""
@@ -550,6 +553,22 @@ cmd_start() {
                 export LOKI_SKIP_MEMORY=true
                 shift
                 ;;
+            --compliance)
+                if [[ -n "${2:-}" ]]; then
+                    export LOKI_COMPLIANCE_PRESET="$2"
+                    echo -e "${CYAN}Compliance mode: $2${NC}"
+                    shift 2
+                else
+                    echo -e "${RED}--compliance requires a preset name (default, healthcare, fintech, government)${NC}"
+                    exit 1
+                fi
+                ;;
+            --compliance=*)
+                local compliance_val="${1#*=}"
+                export LOKI_COMPLIANCE_PRESET="$compliance_val"
+                echo -e "${CYAN}Compliance mode: $compliance_val${NC}"
+                shift
+                ;;
             --yes|-y)
                 export LOKI_AUTO_CONFIRM=true
                 shift
@@ -4688,6 +4707,108 @@ except Exception:
     esac
 }
 
+# Prompt optimization via dashboard API
+cmd_optimize() {
+    local sessions=10
+    local dry_run=""
+
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --sessions) if [[ -z "${2:-}" ]]; then echo -e "${RED}Error: --sessions requires a value${NC}"; exit 1; fi; sessions="$2"; shift 2 ;;
+            --sessions=*) sessions="${1#*=}"; shift ;;
+            --dry-run) dry_run="true"; shift ;;
+            --help|-h)
+                echo -e "${BOLD}loki optimize${NC} - Optimize prompts based on session history"
+                echo ""
+                echo "Usage: loki optimize [options]"
+                echo ""
+                echo "Analyzes recent session failures and proposes prompt improvements."
+                echo "Requires the dashboard API to be running (loki serve)."
+                echo ""
+                echo "Options:"
+                echo "  --sessions N   Number of recent sessions to analyze (default: 10)"
+                echo "  --dry-run      Show proposed changes without applying"
+                echo ""
+                echo "Examples:"
+                echo "  loki optimize                  # Optimize using last 10 sessions"
+                echo "  loki optimize --sessions 20    # Analyze last 20 sessions"
+                echo "  loki optimize --dry-run        # Preview changes only"
+                exit 0
+                ;;
+            *)
+                echo -e "${RED}Unknown option: $1${NC}"
+                echo "Run 'loki optimize --help' for usage."
+                exit 1
+                ;;
+        esac
+    done
+
+    local port="${LOKI_DASHBOARD_PORT:-57374}"
+    local host="127.0.0.1"
+    local dry_run_param="false"
+    if [ -n "$dry_run" ]; then
+        dry_run_param="true"
+    fi
+    local url="http://${host}:${port}/api/prompt-optimize?sessions=${sessions}&dry_run=${dry_run_param}"
+
+    echo -e "${BOLD}Analyzing sessions for prompt optimization...${NC}"
+    echo -e "${DIM}Sessions: $sessions | Dry run: ${dry_run_param}${NC}"
+    echo ""
+
+    local response http_code
+    response=$(curl -s -w "\n%{http_code}" -X POST "$url" 2>/dev/null) || true
+    http_code=$(echo "$response" | tail -1)
+    response=$(echo "$response" | sed '$d')
+    if [ -z "$http_code" ] || [ "$http_code" = "000" ]; then
+        echo -e "${RED}Error: Could not connect to dashboard API at http://${host}:${port}${NC}"
+        echo "Make sure the dashboard is running: loki serve"
+        exit 1
+    fi
+    if [ "$http_code" -ge 400 ] 2>/dev/null; then
+        echo -e "${RED}Error: Dashboard API returned HTTP $http_code${NC}"
+        [ -n "$response" ] && echo "$response"
+        exit 1
+    fi
+
+    if ! command -v python3 &>/dev/null; then
+        echo "$response" | jq . 2>/dev/null || echo "$response"
+    else
+        echo "$response" | python3 -c "
+import json, sys
+data = json.loads(sys.stdin.read())
+
+failures = data.get('failures_analyzed', 0)
+changes = data.get('changes', [])
+version = data.get('version', None)
+
+print(f'Failures analyzed: {failures}')
+print(f'Changes proposed:  {len(changes)}')
+print('---')
+
+for i, change in enumerate(changes, 1):
+    prompt = change.get('prompt', '?')
+    rationale = change.get('rationale', 'No rationale provided')
+    old = change.get('old_value', '')
+    new = change.get('new_value', '')
+    print(f'')
+    print(f'  {i}. {prompt}')
+    print(f'     Rationale: {rationale}')
+    if old:
+        print(f'     Old: {old[:80]}...' if len(old) > 80 else f'     Old: {old}')
+    if new:
+        print(f'     New: {new[:80]}...' if len(new) > 80 else f'     New: {new}')
+
+if version is not None:
+    print(f'')
+    print(f'Prompts optimized to version {version}')
+elif not changes:
+    print(f'')
+    print('No optimization changes proposed.')
+print()
+" 2>/dev/null || echo "$response"
+    fi
+}
+
 # Main command dispatcher
 main() {
     if [ $# -eq 0 ]; then
@@ -4803,6 +4924,9 @@ main() {
         audit)
             cmd_audit "$@"
             ;;
+        optimize)
+            cmd_optimize "$@"
+            ;;
         metrics)
             cmd_metrics "$@"
             ;;
@@ -4826,7 +4950,7 @@ main() {
     esac
 }
 
-# Agent action audit log
+# Agent action audit log and quality scanning
 cmd_audit() {
     local subcommand="${1:-help}"
     local audit_file="$LOKI_DIR/logs/agent-audit.jsonl"
@@ -4885,16 +5009,138 @@ print(f'  {\"TOTAL\":25s} {sum(counts.values())}')
                 echo "  python3 required for count summary"
             fi
             ;;
+        scan)
+            shift
+            local preset="default"
+            local do_export=""
+
+            while [[ $# -gt 0 ]]; do
+                case "$1" in
+                    --preset) if [[ -z "${2:-}" ]]; then echo -e "${RED}Error: --preset requires a value${NC}"; exit 1; fi; preset="$2"; shift 2 ;;
+                    --preset=*) preset="${1#*=}"; shift ;;
+                    --export) do_export="true"; shift ;;
+                    --help|-h)
+                        echo -e "${BOLD}loki audit scan${NC} - Run quality scan"
+                        echo ""
+                        echo "Usage: loki audit scan [options]"
+                        echo ""
+                        echo "Options:"
+                        echo "  --preset NAME   Compliance preset (default|healthcare|fintech|government)"
+                        echo "  --export        Save report to .loki/quality/report-{date}.json"
+                        echo ""
+                        exit 0
+                        ;;
+                    *) echo -e "${RED}Unknown option: $1${NC}"; exit 1 ;;
+                esac
+            done
+
+            case "$preset" in
+                default|healthcare|fintech|government) ;;
+                *) echo -e "${RED}Error: Invalid preset '$preset'. Must be one of: default, healthcare, fintech, government${NC}"; exit 1 ;;
+            esac
+
+            local port="${LOKI_DASHBOARD_PORT:-57374}"
+            local host="127.0.0.1"
+            local url="http://${host}:${port}/api/quality-scan?preset=${preset}"
+
+            echo -e "${BOLD}Running quality scan...${NC} (preset: $preset)"
+            echo ""
+
+            local response http_code
+            response=$(curl -s -w "\n%{http_code}" -X POST "$url" 2>/dev/null) || true
+            http_code=$(echo "$response" | tail -1)
+            response=$(echo "$response" | sed '$d')
+            if [ -z "$http_code" ] || [ "$http_code" = "000" ]; then
+                echo -e "${RED}Error: Could not connect to dashboard API at http://${host}:${port}${NC}"
+                echo "Make sure the dashboard is running: loki serve"
+                exit 1
+            fi
+            if [ "$http_code" -ge 400 ] 2>/dev/null; then
+                echo -e "${RED}Error: Dashboard API returned HTTP $http_code${NC}"
+                [ -n "$response" ] && echo "$response"
+                exit 1
+            fi
+
+            if ! command -v python3 &>/dev/null; then
+                echo "$response" | jq . 2>/dev/null || echo "$response"
+            else
+                echo "$response" | python3 -c "
+import json, sys
+data = json.loads(sys.stdin.read())
+
+score = data.get('score', 0)
+grade = data.get('grade', '?')
+print(f'Quality Score: {score}/100  Grade: {grade}')
+print('---')
+
+# Category scores
+categories = data.get('categories', {})
+if categories:
+    print()
+    print('Category Scores:')
+    for cat, cat_score in sorted(categories.items()):
+        print(f'  {cat:20s} {cat_score}/100')
+
+# Findings by severity
+findings = data.get('findings', [])
+if findings:
+    print()
+    print('Findings:')
+    for f in findings:
+        sev = f.get('severity', 'info')
+        msg = f.get('message', '')
+        cat = f.get('category', '')
+        if sev == 'critical':
+            print(f'  \033[0;31m[CRITICAL]\033[0m {cat}: {msg}')
+        elif sev == 'major':
+            print(f'  \033[1;33m[MAJOR]\033[0m    {cat}: {msg}')
+        else:
+            print(f'  [MINOR]    {cat}: {msg}')
+print()
+" 2>/dev/null || echo "$response"
+            fi
+
+            # Export report if requested
+            if [ -n "$do_export" ]; then
+                local report_dir="$LOKI_DIR/quality"
+                mkdir -p "$report_dir"
+                local date_str
+                date_str=$(date +%Y-%m-%d)
+                local report_file="$report_dir/report-${date_str}.json"
+
+                local report_url="http://${host}:${port}/api/quality-report?format=json"
+                local report_data
+                report_data=$(curl -sf "$report_url" 2>/dev/null) || true
+                if [ -n "$report_data" ]; then
+                    echo "$report_data" > "$report_file"
+                    echo -e "${GREEN}Report exported to $report_file${NC}"
+                else
+                    # Fall back to scan response
+                    echo "$response" > "$report_file"
+                    echo -e "${GREEN}Report exported to $report_file${NC}"
+                fi
+            fi
+            ;;
+        --preset|--export)
+            # Handle flags passed directly to 'loki audit' (shortcut for 'loki audit scan')
+            cmd_audit scan "$@"
+            return
+            ;;
         --help|-h|help)
-            echo -e "${BOLD}loki audit${NC} - Agent action audit log"
+            echo -e "${BOLD}loki audit${NC} - Agent audit log and quality scanning"
             echo ""
-            echo "Usage: loki audit <subcommand>"
+            echo "Usage: loki audit <subcommand> [options]"
             echo ""
             echo "Subcommands:"
             echo "  log [N]     Show last N audit log entries (default: 50)"
             echo "  count       Count actions by type"
+            echo "  scan        Run quality scan against dashboard API"
             echo "  help        Show this help"
             echo ""
+            echo "Quality Scan Options (loki audit scan):"
+            echo "  --preset NAME   Compliance preset (default|healthcare|fintech|government)"
+            echo "  --export        Save report to .loki/quality/report-{date}.json"
+            echo ""
             echo "The agent audit log records actions taken during Loki sessions,"
             echo "including CLI invocations, git commits, and session lifecycle events."
             echo "Log file: $audit_file"

package/dashboard/__init__.py

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

package/dashboard/activity_logger.py

@@ -0,0 +1,231 @@
+"""
+Activity Logger for Loki Mode Dashboard.
+
+Appends structured JSONL entries to ~/.loki/activity.jsonl with automatic
+rotation at 10MB. Provides query and session-diff capabilities.
+"""
+
+import json
+import logging
+import os
+import threading
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Any, Optional
+
+logger = logging.getLogger("loki-activity")
+
+LOKI_DATA_DIR = os.environ.get("LOKI_DATA_DIR", os.path.expanduser("~/.loki"))
+
+# Valid entity types and actions for validation
+VALID_ENTITY_TYPES = {"task", "agent", "phase", "checkpoint"}
+VALID_ACTIONS = {"created", "status_changed", "completed", "failed", "blocked"}
+
+# Rotation threshold in bytes (10MB)
+MAX_FILE_SIZE = 10 * 1024 * 1024
+
+
+class ActivityLogger:
+    """Thread-safe activity logger that writes JSONL to ~/.loki/activity.jsonl."""
+
+    def __init__(self, data_dir: Optional[str] = None) -> None:
+        self._data_dir = Path(data_dir or LOKI_DATA_DIR)
+        self._log_file = self._data_dir / "activity.jsonl"
+        self._lock = threading.Lock()
+        self._data_dir.mkdir(parents=True, exist_ok=True)
+
+    @property
+    def log_file(self) -> Path:
+        """Return the path to the current activity log file."""
+        return self._log_file
+
+    def _rotate_if_needed(self) -> None:
+        """Rotate the log file if it exceeds MAX_FILE_SIZE."""
+        try:
+            if self._log_file.exists() and self._log_file.stat().st_size >= MAX_FILE_SIZE:
+                timestamp = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+                rotated = self._data_dir / f"activity-{timestamp}.jsonl"
+                self._log_file.rename(rotated)
+                logger.info("Rotated activity log to %s", rotated)
+        except OSError as e:
+            logger.warning("Failed to rotate activity log: %s", e)
+
+    def log(
+        self,
+        entity_type: str,
+        entity_id: str,
+        action: str,
+        old_value: Optional[str] = None,
+        new_value: Optional[str] = None,
+        session_id: Optional[str] = None,
+    ) -> dict[str, Any]:
+        """Log an activity entry. Returns the entry dict."""
+        if entity_type not in VALID_ENTITY_TYPES:
+            logger.warning("Invalid entity_type %r (valid: %s)", entity_type, VALID_ENTITY_TYPES)
+        if action not in VALID_ACTIONS:
+            logger.warning("Invalid action %r (valid: %s)", action, VALID_ACTIONS)
+
+        entry: dict[str, Any] = {
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "entity_type": entity_type,
+            "entity_id": entity_id,
+            "action": action,
+            "old_value": old_value,
+            "new_value": new_value,
+            "session_id": session_id,
+        }
+
+        with self._lock:
+            self._rotate_if_needed()
+            try:
+                with open(self._log_file, "a", encoding="utf-8") as f:
+                    f.write(json.dumps(entry, separators=(",", ":")) + "\n")
+            except OSError as e:
+                logger.error("Failed to write activity entry: %s", e)
+
+        return entry
+
+    def query_since(self, timestamp: str) -> list[dict[str, Any]]:
+        """Return activity entries after the given ISO timestamp."""
+        # Normalize Z-suffix so comparisons work consistently
+        timestamp = timestamp.replace("Z", "+00:00")
+        results: list[dict[str, Any]] = []
+
+        if not self._log_file.exists():
+            return results
+
+        with self._lock:
+            try:
+                with open(self._log_file, "r", encoding="utf-8") as f:
+                    for line in f:
+                        line = line.strip()
+                        if not line:
+                            continue
+                        try:
+                            entry = json.loads(line)
+                            entry_ts = entry.get("timestamp", "").replace("Z", "+00:00")
+                            if entry_ts > timestamp:
+                                results.append(entry)
+                        except json.JSONDecodeError:
+                            continue
+            except OSError as e:
+                logger.error("Failed to read activity log: %s", e)
+
+        return results
+
+    def get_session_diff(self, since_timestamp: Optional[str] = None) -> dict[str, Any]:
+        """Return a structured summary of activity since the given timestamp.
+
+        If no timestamp is provided, defaults to the last 24 hours.
+        """
+        if since_timestamp is None:
+            since_dt = datetime.now(timezone.utc) - timedelta(hours=24)
+            since_timestamp = since_dt.isoformat()
+
+        # Normalize Z-suffix before passing to query_since
+        since_timestamp = since_timestamp.replace("Z", "+00:00")
+
+        entries = self.query_since(since_timestamp)
+
+        now = datetime.now(timezone.utc)
+        try:
+            since_dt = datetime.fromisoformat(since_timestamp.replace("Z", "+00:00"))
+        except (ValueError, AttributeError):
+            since_dt = now
+
+        period_hours = max(0.0, (now - since_dt).total_seconds() / 3600)
+
+        # Build summary counts
+        summary = {
+            "total_changes": len(entries),
+            "tasks_created": 0,
+            "tasks_completed": 0,
+            "tasks_blocked": 0,
+            "phases_transitioned": 0,
+            "checkpoints_created": 0,
+            "errors": 0,
+        }
+
+        highlights: list[str] = []
+        decisions: list[dict[str, str]] = []
+
+        for entry in entries:
+            entity_type = entry.get("entity_type", "")
+            action = entry.get("action", "")
+            entity_id = entry.get("entity_id", "")
+
+            if entity_type == "task":
+                if action == "created":
+                    summary["tasks_created"] += 1
+                    highlights.append(f"Task {entity_id} created")
+                elif action == "completed":
+                    summary["tasks_completed"] += 1
+                    highlights.append(f"Task {entity_id} completed")
+                elif action == "blocked":
+                    summary["tasks_blocked"] += 1
+                    highlights.append(f"Task {entity_id} blocked")
+                elif action == "failed":
+                    summary["errors"] += 1
+                    highlights.append(f"Task {entity_id} failed")
+                elif action == "status_changed":
+                    old_val = entry.get("old_value", "")
+                    new_val = entry.get("new_value", "")
+                    highlights.append(f"Task {entity_id}: {old_val} -> {new_val}")
+
+            elif entity_type == "agent":
+                if action == "failed":
+                    summary["errors"] += 1
+                    highlights.append(f"Agent {entity_id} failed")
+                elif action == "created":
+                    highlights.append(f"Agent {entity_id} created")
+                elif action == "status_changed":
+                    old_val = entry.get("old_value", "")
+                    new_val = entry.get("new_value", "")
+                    highlights.append(f"Agent {entity_id}: {old_val} -> {new_val}")
+                    # Agent status changes may represent decisions
+                    if new_val:
+                        decisions.append({
+                            "timestamp": entry.get("timestamp", ""),
+                            "decision": f"Agent {entity_id} transitioned to {new_val}",
+                            "reasoning": f"Status changed from {old_val} to {new_val}",
+                        })
+
+            elif entity_type == "phase":
+                if action == "status_changed":
+                    summary["phases_transitioned"] += 1
+                    old_val = entry.get("old_value", "")
+                    new_val = entry.get("new_value", "")
+                    highlights.append(f"Phase transition: {old_val} -> {new_val}")
+                    decisions.append({
+                        "timestamp": entry.get("timestamp", ""),
+                        "decision": f"Phase transitioned to {new_val}",
+                        "reasoning": f"Moved from {old_val} to {new_val}",
+                    })
+
+            elif entity_type == "checkpoint":
+                if action == "created":
+                    summary["checkpoints_created"] += 1
+                    highlights.append(f"Checkpoint {entity_id} created")
+
+        return {
+            "since": since_timestamp,
+            "period_hours": round(period_hours, 2),
+            "summary": summary,
+            "highlights": highlights,
+            "decisions": decisions,
+        }
+
+
+# Singleton instance
+_instance: Optional[ActivityLogger] = None
+_instance_lock = threading.Lock()
+
+
+def get_activity_logger(data_dir: Optional[str] = None) -> ActivityLogger:
+    """Get or create the singleton ActivityLogger instance."""
+    global _instance
+    if _instance is None:
+        with _instance_lock:
+            if _instance is None:
+                _instance = ActivityLogger(data_dir=data_dir)
+    return _instance