loki-mode 6.16.1 → 6.17.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 minimal human intervention. Requires --dangerously-skip-permissions flag.
 ---
 
-# Loki Mode v6.16.1
+# Loki Mode v6.17.1
 
 **You are an autonomous agent. You make decisions. You do not ask questions. You do not stop.**
 
@@ -267,4 +267,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.16.1 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**
+**v6.17.1 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**

package/VERSION

@@ -1 +1 @@
-6.16.1
+6.17.1

package/autonomy/loki

@@ -433,6 +433,7 @@ show_help() {
     echo "  worktree [cmd]   Parallel worktree management (list|merge|clean|status)"
     echo "  agent [cmd]      Agent type dispatch (list|info|run|start|review)"
     echo "  remote [PRD]     Start remote session (connect from phone/browser, Claude Pro/Max)"
+  echo "  trigger          Event-driven autonomous execution (schedules, webhooks)"
     echo "  version          Show version"
     echo "  help             Show this help"
     echo ""
@@ -7725,6 +7726,290 @@ print('Template validated. Lifecycle hooks active.')
     esac
 }
 
+# Event-driven trigger management (v6.17.0)
+cmd_trigger() {
+    local subcmd="${1:-help}"
+    shift || true
+
+    local trigger_server_script
+    trigger_server_script="$(dirname "$(readlink -f "${BASH_SOURCE[0]}")")/trigger-server.py"
+    local trigger_schedule_script
+    trigger_schedule_script="$(dirname "$(readlink -f "${BASH_SOURCE[0]}")")/trigger-schedule.py"
+    local pid_file=".loki/triggers/server.pid"
+
+    case "$subcmd" in
+        start)
+            local port=""
+            local secret=""
+            local dry_run_flag=""
+            while [[ $# -gt 0 ]]; do
+                case "$1" in
+                    --port) port="$2"; shift 2 ;;
+                    --port=*) port="${1#--port=}"; shift ;;
+                    --secret) secret="$2"; shift 2 ;;
+                    --secret=*) secret="${1#--secret=}"; shift ;;
+                    --dry-run) dry_run_flag="--dry-run"; shift ;;
+                    *) shift ;;
+                esac
+            done
+            if [[ -f "$pid_file" ]]; then
+                local existing_pid
+                existing_pid=$(cat "$pid_file" 2>/dev/null)
+                if kill -0 "$existing_pid" 2>/dev/null; then
+                    echo "Trigger server already running (pid=$existing_pid)"
+                    return 0
+                fi
+            fi
+            local args=()
+            [[ -n "$port" ]] && args+=("--port" "$port")
+            [[ -n "$secret" ]] && args+=("--secret" "$secret")
+            [[ -n "$dry_run_flag" ]] && args+=("--dry-run")
+            mkdir -p .loki/triggers
+            nohup python3 "$trigger_server_script" "${args[@]}" \
+                > .loki/triggers/server.log 2>&1 &
+            local server_pid=$!
+            echo "$server_pid" > "$pid_file"
+            sleep 0.5
+            if kill -0 "$server_pid" 2>/dev/null; then
+                echo "Trigger server started (pid=$server_pid)"
+                local p="${port:-7373}"
+                echo "Webhook endpoint: POST http://localhost:$p/webhook"
+            else
+                echo -e "${RED}Trigger server failed to start. Check .loki/triggers/server.log${NC}"
+                return 1
+            fi
+            ;;
+        stop)
+            if [[ ! -f "$pid_file" ]]; then
+                echo "Trigger server not running (no pid file)"
+                return 0
+            fi
+            local pid
+            pid=$(cat "$pid_file" 2>/dev/null)
+            if [[ -z "$pid" ]]; then
+                echo "Trigger server not running"
+                rm -f "$pid_file"
+                return 0
+            fi
+            if kill "$pid" 2>/dev/null; then
+                echo "Trigger server stopped (pid=$pid)"
+                rm -f "$pid_file"
+            else
+                echo "Trigger server was not running (pid=$pid)"
+                rm -f "$pid_file"
+            fi
+            ;;
+        status)
+            if [[ -f "$pid_file" ]]; then
+                local pid
+                pid=$(cat "$pid_file" 2>/dev/null)
+                if kill -0 "$pid" 2>/dev/null; then
+                    echo "Trigger server: running (pid=$pid)"
+                    if command -v curl >/dev/null 2>&1; then
+                        local config_port
+                        config_port=$(python3 -c "
+import json, pathlib
+p = pathlib.Path('.loki/triggers/config.json')
+print(json.loads(p.read_text()).get('port', 7373) if p.exists() else 7373)
+" 2>/dev/null || echo "7373")
+                        curl -sf "http://localhost:$config_port/status" 2>/dev/null | \
+                            python3 -m json.tool 2>/dev/null || true
+                    fi
+                else
+                    echo "Trigger server: stopped (stale pid=$pid)"
+                    rm -f "$pid_file"
+                fi
+            else
+                echo "Trigger server: not running"
+            fi
+            local sched_file=".loki/triggers/schedules.json"
+            if [[ -f "$sched_file" ]]; then
+                local count
+                count=$(python3 -c "import json; d=json.load(open('$sched_file')); print(len(d) if isinstance(d,list) else len(d.get('schedules',[])))" 2>/dev/null || echo "?")
+                echo "Schedules configured: $count"
+            else
+                echo "Schedules configured: 0"
+            fi
+            ;;
+        list)
+            python3 "$trigger_schedule_script" list
+            ;;
+        add)
+            local add_type="${1:-}"
+            shift || true
+            if [[ "$add_type" == "schedule" ]]; then
+                local name="${1:-}"
+                local cron_expr="${2:-}"
+                local action="${3:-}"
+                shift 3 || true
+                if [[ -z "$name" || -z "$cron_expr" || -z "$action" ]]; then
+                    echo "Usage: loki trigger add schedule <name> <cron_expr> <action> [args...]"
+                    echo ""
+                    echo "Example:"
+                    echo "  loki trigger add schedule daily-review '0 9 * * 1-5' quality-review"
+                    echo "  loki trigger add schedule auto-issue '*/30 * * * *' run 42"
+                    return 1
+                fi
+                python3 "$trigger_schedule_script" add "$name" "$cron_expr" "$action" "$@"
+            else
+                echo "Usage: loki trigger add schedule <name> <cron_expr> <action> [args...]"
+                return 1
+            fi
+            ;;
+        remove)
+            local name="${1:-}"
+            if [[ -z "$name" ]]; then
+                echo "Usage: loki trigger remove <name>"
+                return 1
+            fi
+            python3 "$trigger_schedule_script" remove "$name"
+            ;;
+        daemon)
+            local dry_run_flag=""
+            [[ "${1:-}" == "--dry-run" ]] && dry_run_flag="--dry-run"
+            python3 "$trigger_schedule_script" daemon $dry_run_flag
+            ;;
+        test)
+            local event_type="${1:-issues}"
+            shift || true
+            local repo=""
+            local issue_num=""
+            while [[ $# -gt 0 ]]; do
+                case "$1" in
+                    --repo) repo="$2"; shift 2 ;;
+                    --repo=*) repo="${1#--repo=}"; shift ;;
+                    --issue) issue_num="$2"; shift 2 ;;
+                    --issue=*) issue_num="${1#--issue=}"; shift ;;
+                    *) shift ;;
+                esac
+            done
+            local config_port
+            config_port=$(python3 -c "
+import json, pathlib
+p = pathlib.Path('.loki/triggers/config.json')
+print(json.loads(p.read_text()).get('port', 7373) if p.exists() else 7373)
+" 2>/dev/null || echo "7373")
+
+            local payload
+            case "$event_type" in
+                issues)
+                    local num="${issue_num:-1}"
+                    local r="${repo:-owner/repo}"
+                    payload="{\"action\":\"opened\",\"issue\":{\"number\":$num,\"title\":\"Test issue\"},\"repository\":{\"full_name\":\"$r\"}}"
+                    ;;
+                pull_request)
+                    local num="${issue_num:-1}"
+                    local r="${repo:-owner/repo}"
+                    payload="{\"action\":\"synchronize\",\"pull_request\":{\"number\":$num,\"title\":\"Test PR\"},\"repository\":{\"full_name\":\"$r\"}}"
+                    ;;
+                workflow_run)
+                    local r="${repo:-owner/repo}"
+                    payload="{\"action\":\"completed\",\"workflow_run\":{\"name\":\"CI\",\"conclusion\":\"failure\"},\"repository\":{\"full_name\":\"$r\"}}"
+                    ;;
+                *)
+                    echo "Supported event types: issues, pull_request, workflow_run"
+                    return 1
+                    ;;
+            esac
+
+            if command -v curl >/dev/null 2>&1; then
+                echo "Sending test $event_type event to http://localhost:$config_port/webhook"
+                curl -sf -X POST \
+                    -H "Content-Type: application/json" \
+                    -H "X-GitHub-Event: $event_type" \
+                    -d "$payload" \
+                    "http://localhost:$config_port/webhook" | python3 -m json.tool 2>/dev/null || \
+                    echo "Server not running or request failed. Start with: loki trigger start"
+            else
+                echo "curl not available. Cannot send test event."
+                return 1
+            fi
+            ;;
+        logs)
+            local tail_n="50"
+            while [[ $# -gt 0 ]]; do
+                case "$1" in
+                    --tail) tail_n="$2"; shift 2 ;;
+                    --tail=*) tail_n="${1#--tail=}"; shift ;;
+                    *) shift ;;
+                esac
+            done
+            local log_file=".loki/triggers/events.log"
+            if [[ -f "$log_file" ]]; then
+                tail -n "$tail_n" "$log_file" | python3 -c "
+import sys, json
+for line in sys.stdin:
+    line = line.strip()
+    if not line:
+        continue
+    try:
+        e = json.loads(line)
+        print('[%s] %-15s %-12s %-8s %s' % (
+            e.get('timestamp','?'),
+            e.get('event','?'),
+            e.get('action','?'),
+            e.get('status','?'),
+            e.get('summary',''),
+        ))
+    except Exception:
+        print(line)
+" 2>/dev/null || cat "$log_file" | tail -n "$tail_n"
+            else
+                echo "No events logged yet. (.loki/triggers/events.log does not exist)"
+            fi
+            local server_log=".loki/triggers/server.log"
+            if [[ -f "$server_log" ]]; then
+                echo ""
+                echo "--- Server log (last $tail_n lines) ---"
+                tail -n "$tail_n" "$server_log"
+            fi
+            ;;
+        help|--help|-h)
+            echo -e "${BOLD}loki trigger${NC} - Event-driven autonomous execution"
+            echo ""
+            echo "Usage: loki trigger <subcommand> [options]"
+            echo ""
+            echo "Subcommands:"
+            echo "  start [--port PORT] [--secret SECRET] [--dry-run]"
+            echo "                        Start the webhook receiver server (default port: 7373)"
+            echo "  stop                  Stop the webhook receiver server"
+            echo "  status                Show server and schedule status"
+            echo "  list                  List configured schedules"
+            echo "  add schedule <name> <cron_expr> <action> [args...]"
+            echo "                        Add a cron-based schedule trigger"
+            echo "  remove <name>         Remove a schedule trigger"
+            echo "  daemon [--dry-run]    Run one pass of schedule checks (call from cron)"
+            echo "  test <event-type> [--repo owner/repo] [--issue NUM]"
+            echo "                        Send a test webhook event (event-types: issues, pull_request, workflow_run)"
+            echo "  logs [--tail N]       Show recent trigger event log (default: last 50)"
+            echo "  help                  Show this help"
+            echo ""
+            echo "Webhook events handled:"
+            echo "  issues (opened)        -> loki run <issue_number> --pr --detach"
+            echo "  pull_request (sync)    -> loki run <pr_number> --detach"
+            echo "  workflow_run (failure) -> loki run --detach"
+            echo ""
+            echo "Schedule cron format: minute hour day-of-month month day-of-week"
+            echo "  Examples:"
+            echo "    '0 9 * * 1-5'   - 9am Mon-Fri"
+            echo "    '*/30 * * * *'  - Every 30 minutes"
+            echo "    '0 0 * * 0'     - Midnight Sunday"
+            echo ""
+            echo "Examples:"
+            echo "  loki trigger start --port 7373 --secret mywebhooksecret"
+            echo "  loki trigger add schedule daily-review '0 9 * * 1-5' quality-review"
+            echo "  loki trigger test issues --repo owner/repo --issue 42"
+            echo "  loki trigger logs --tail 20"
+            echo "  loki trigger stop"
+            ;;
+        *)
+            echo -e "${RED}Unknown trigger command: $subcmd${NC}"
+            echo "Run 'loki trigger help' for usage."
+            return 1
+            ;;
+    esac
+}
+
 # Main command dispatcher
 main() {
     if [ $# -eq 0 ]; then
@@ -7882,6 +8167,9 @@ main() {
         remote|rc)
             cmd_remote "$@"
             ;;
+        trigger)
+            cmd_trigger "$@"
+            ;;
         version|--version|-v)
             cmd_version
             ;;

package/autonomy/run.sh

@@ -8617,6 +8617,8 @@ if __name__ == "__main__":
             fi
         fi
 
+        log_step "Post-iteration: running inter-iteration checks..."
+
         # App Runner: restart on code changes (v5.45.0)
         if [ "${APP_RUNNER_INITIALIZED:-}" = "true" ] && type app_runner_should_restart &>/dev/null; then
             if app_runner_should_restart; then
@@ -8661,10 +8663,12 @@ if __name__ == "__main__":
         create_checkpoint "iteration-${ITERATION_COUNT} complete" "iteration-${ITERATION_COUNT}"
 
         # Quality gates (v6.10.0 - escalation ladder)
+        log_step "Post-iteration: running quality gates..."
         local gate_failures=""
         if [ "${LOKI_HARD_GATES:-true}" = "true" ]; then
             # Static analysis gate
             if [ "${PHASE_STATIC_ANALYSIS:-true}" = "true" ]; then
+                log_info "Quality gate: static analysis..."
                 if enforce_static_analysis; then
                     clear_gate_failure "static_analysis"
                 else
@@ -8676,6 +8680,7 @@ if __name__ == "__main__":
             fi
             # Test coverage gate
             if [ "${PHASE_UNIT_TESTS:-true}" = "true" ]; then
+                log_info "Quality gate: test coverage..."
                 if enforce_test_coverage; then
                     clear_gate_failure "test_coverage"
                 else
@@ -8687,6 +8692,7 @@ if __name__ == "__main__":
             fi
             # Code review gate (upgraded from advisory, with escalation)
             if [ "$PHASE_CODE_REVIEW" = "true" ] && [ "$ITERATION_COUNT" -gt 0 ]; then
+                log_info "Quality gate: code review..."
                 if run_code_review; then
                     clear_gate_failure "code_review"
                 else
@@ -8717,9 +8723,11 @@ if __name__ == "__main__":
             fi
         else
             if [ "$PHASE_CODE_REVIEW" = "true" ] && [ "$ITERATION_COUNT" -gt 0 ]; then
+                log_info "Quality gate: code review (advisory)..."
                 run_code_review || log_warn "Code review found issues - check .loki/quality/reviews/"
             fi
         fi
+        log_info "Quality gates complete."
 
         # Automatic episode capture after every RARV iteration (v6.15.0)
         # Captures RARV phase, git changes, and iteration context automatically
@@ -8745,6 +8753,7 @@ if __name__ == "__main__":
 
             # Completion Council check (v5.25.0) - multi-agent voting on completion
             # Runs before completion promise check since council is more comprehensive
+            log_step "Post-iteration: checking completion council..."
             if type council_should_stop &>/dev/null && council_should_stop; then
                 echo ""
                 log_header "COMPLETION COUNCIL: PROJECT COMPLETE"
@@ -8776,7 +8785,7 @@ if __name__ == "__main__":
             fi
 
             # SUCCESS exit - continue IMMEDIATELY to next iteration (no wait!)
-            log_info "Iteration complete. Continuing to next iteration..."
+            log_step "Starting next iteration..."
             ((retry++))
             continue  # Immediately start next iteration, no exponential backoff
         fi

package/autonomy/trigger-schedule.py

@@ -0,0 +1,367 @@
+#!/usr/bin/env python3
+"""
+trigger-schedule.py - Schedule-based trigger daemon for loki-mode.
+
+Reads .loki/triggers/schedules.json and runs loki commands on cron-like schedules.
+Called periodically via `loki trigger daemon`.
+
+Schedule entry format:
+    {
+        "name": "daily-quality-review",
+        "cron_expr": "0 9 * * 1-5",
+        "action": "quality-review",
+        "args": [],
+        "enabled": true,
+        "last_run": null
+    }
+
+Supported actions:
+    run <issue-ref>     - Run loki run on an issue/ref
+    status              - Run loki status
+    quality-review      - Run loki review
+
+Usage:
+    python3 autonomy/trigger-schedule.py [--once] [--dry-run]
+"""
+
+import argparse
+import json
+import logging
+import os
+import subprocess
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+def get_loki_dir():
+    """Return .loki/triggers directory, creating it if needed."""
+    loki_dir = Path(".loki") / "triggers"
+    loki_dir.mkdir(parents=True, exist_ok=True)
+    return loki_dir
+
+
+def load_schedules():
+    """Load schedules from .loki/triggers/schedules.json."""
+    schedules_path = get_loki_dir() / "schedules.json"
+    if not schedules_path.exists():
+        return []
+    try:
+        with open(schedules_path) as f:
+            data = json.load(f)
+        if isinstance(data, list):
+            return data
+        return data.get("schedules", [])
+    except (json.JSONDecodeError, OSError) as e:
+        logging.error("Failed to load schedules: %s", e)
+        return []
+
+
+def save_schedules(schedules):
+    """Save schedules back to .loki/triggers/schedules.json."""
+    schedules_path = get_loki_dir() / "schedules.json"
+    with open(schedules_path, "w") as f:
+        json.dump(schedules, f, indent=2)
+
+
+def parse_cron_field(field, min_val, max_val):
+    """
+    Parse a single cron field.
+    Returns a set of matching integers.
+    Supports: * (any), N (exact), N-M (range), */N (step), N,M,... (list)
+    """
+    result = set()
+    if field == "*":
+        return set(range(min_val, max_val + 1))
+
+    for part in field.split(","):
+        part = part.strip()
+        if "/" in part:
+            range_part, step_str = part.split("/", 1)
+            step = int(step_str)
+            if range_part == "*":
+                start, end = min_val, max_val
+            elif "-" in range_part:
+                s, e = range_part.split("-", 1)
+                start, end = int(s), int(e)
+            else:
+                start = int(range_part)
+                end = max_val
+            result.update(range(start, end + 1, step))
+        elif "-" in part:
+            s, e = part.split("-", 1)
+            result.update(range(int(s), int(e) + 1))
+        else:
+            result.add(int(part))
+
+    return result
+
+
+def cron_matches(cron_expr, dt):
+    """
+    Check if a datetime matches a cron expression.
+    Format: minute hour day-of-month month day-of-week
+    Day-of-week: 0=Sunday, 1=Monday, ..., 6=Saturday
+    """
+    parts = cron_expr.strip().split()
+    if len(parts) != 5:
+        raise ValueError("Invalid cron expression (expected 5 fields): %s" % cron_expr)
+
+    minute_field, hour_field, dom_field, month_field, dow_field = parts
+
+    minutes = parse_cron_field(minute_field, 0, 59)
+    hours = parse_cron_field(hour_field, 0, 23)
+    doms = parse_cron_field(dom_field, 1, 31)
+    months = parse_cron_field(month_field, 1, 12)
+    # Python weekday: 0=Monday, ..., 6=Sunday
+    # Cron weekday: 0=Sunday, 1=Monday, ..., 6=Saturday
+    # Convert python weekday to cron dow
+    python_dow = dt.weekday()  # 0=Mon
+    cron_dow = (python_dow + 1) % 7  # 0=Sun, 1=Mon, ...
+    dows = parse_cron_field(dow_field, 0, 6)
+
+    return (
+        dt.minute in minutes
+        and dt.hour in hours
+        and dt.day in doms
+        and dt.month in months
+        and cron_dow in dows
+    )
+
+
+def should_run(schedule, now):
+    """
+    Determine if a schedule should fire now.
+    Compares current minute-resolution timestamp to last_run.
+    """
+    if not schedule.get("enabled", True):
+        return False
+
+    try:
+        matches = cron_matches(schedule["cron_expr"], now)
+    except (ValueError, KeyError) as e:
+        logging.warning("Invalid cron for '%s': %s", schedule.get("name", "?"), e)
+        return False
+
+    if not matches:
+        return False
+
+    last_run = schedule.get("last_run")
+    if last_run:
+        try:
+            # Check if we already ran this minute
+            last_dt = datetime.fromisoformat(last_run.replace("Z", "+00:00"))
+            if last_dt.year == now.year and last_dt.month == now.month and \
+               last_dt.day == now.day and last_dt.hour == now.hour and \
+               last_dt.minute == now.minute:
+                return False
+        except (ValueError, AttributeError):
+            pass
+
+    return True
+
+
+def build_loki_args(schedule):
+    """Build the loki CLI argument list from a schedule entry."""
+    action = schedule.get("action", "")
+    args = schedule.get("args", [])
+
+    if action == "status":
+        return ["status"]
+    elif action == "quality-review":
+        return ["review"] + list(args)
+    elif action.startswith("run"):
+        # action is "run" with args, or "run <issue-ref>"
+        extra = list(args)
+        if not extra and " " in action:
+            # action = "run 123"
+            parts = action.split(None, 1)
+            extra = [parts[1]]
+        return ["run"] + extra
+    else:
+        # Generic: split action and prepend
+        return action.split() + list(args)
+
+
+def run_schedule(schedule, dry_run=False):
+    """Execute a scheduled loki command."""
+    loki_args = build_loki_args(schedule)
+    cmd = ["loki"] + loki_args
+    name = schedule.get("name", "unnamed")
+
+    if dry_run:
+        logging.info("[DRY-RUN] Schedule '%s' would run: %s", name, " ".join(cmd))
+        return True
+
+    logging.info("Schedule '%s' firing: %s", name, " ".join(cmd))
+    try:
+        proc = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+        logging.info("Schedule '%s' started pid=%d", name, proc.pid)
+        return True
+    except (FileNotFoundError, OSError) as e:
+        logging.error("Schedule '%s' failed: %s", name, e)
+        return False
+
+
+def log_event(name, action_desc, status):
+    """Log schedule fire to events.log."""
+    log_path = get_loki_dir() / "events.log"
+    timestamp = datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ")
+    entry = {
+        "timestamp": timestamp,
+        "event": "schedule",
+        "action": action_desc,
+        "summary": name,
+        "status": status,
+    }
+    with open(log_path, "a") as f:
+        f.write(json.dumps(entry) + "\n")
+
+
+def run_daemon(dry_run=False, once=False):
+    """
+    Check all schedules and fire those that match the current minute.
+    If once=True, run one pass and exit (used for cron job invocation).
+    """
+    now = datetime.now()
+    schedules = load_schedules()
+    changed = False
+
+    for i, schedule in enumerate(schedules):
+        if should_run(schedule, now):
+            success = run_schedule(schedule, dry_run=dry_run)
+            status = "fired" if success else "error"
+            log_event(schedule.get("name", "?"), schedule.get("action", "?"), status)
+            if not dry_run:
+                schedules[i]["last_run"] = now.strftime("%Y-%m-%dT%H:%M:%SZ")
+                changed = True
+
+    if changed:
+        save_schedules(schedules)
+
+    if not schedules:
+        logging.debug("No schedules configured.")
+
+    return True
+
+
+def list_schedules():
+    """Print all configured schedules."""
+    schedules = load_schedules()
+    if not schedules:
+        print("No schedules configured.")
+        print("Add schedules to .loki/triggers/schedules.json")
+        return
+
+    print("Configured schedules:")
+    for s in schedules:
+        enabled = "enabled" if s.get("enabled", True) else "disabled"
+        last_run = s.get("last_run") or "never"
+        print("  %-30s  %-20s  %-12s  %s  (last: %s)" % (
+            s.get("name", "?"),
+            s.get("cron_expr", "?"),
+            s.get("action", "?"),
+            enabled,
+            last_run,
+        ))
+
+
+def add_schedule(name, cron_expr, action, extra_args, enabled=True):
+    """Add or update a schedule entry."""
+    schedules = load_schedules()
+    # Check for existing
+    for i, s in enumerate(schedules):
+        if s.get("name") == name:
+            schedules[i] = {
+                "name": name,
+                "cron_expr": cron_expr,
+                "action": action,
+                "args": list(extra_args),
+                "enabled": enabled,
+                "last_run": s.get("last_run"),
+            }
+            save_schedules(schedules)
+            print("Updated schedule: %s" % name)
+            return
+    schedules.append({
+        "name": name,
+        "cron_expr": cron_expr,
+        "action": action,
+        "args": list(extra_args),
+        "enabled": enabled,
+        "last_run": None,
+    })
+    save_schedules(schedules)
+    print("Added schedule: %s" % name)
+
+
+def remove_schedule(name):
+    """Remove a schedule by name."""
+    schedules = load_schedules()
+    before = len(schedules)
+    schedules = [s for s in schedules if s.get("name") != name]
+    if len(schedules) == before:
+        print("Schedule not found: %s" % name)
+        return False
+    save_schedules(schedules)
+    print("Removed schedule: %s" % name)
+    return True
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="loki-mode schedule-based trigger daemon"
+    )
+    subparsers = parser.add_subparsers(dest="command")
+
+    # daemon - run one pass
+    daemon_parser = subparsers.add_parser("daemon", help="Run one pass of schedule checks")
+    daemon_parser.add_argument("--dry-run", action="store_true", help="Preview without running")
+
+    # list
+    subparsers.add_parser("list", help="List configured schedules")
+
+    # add
+    add_parser = subparsers.add_parser("add", help="Add a schedule")
+    add_parser.add_argument("name")
+    add_parser.add_argument("cron_expr")
+    add_parser.add_argument("action")
+    add_parser.add_argument("args", nargs="*")
+    add_parser.add_argument("--disabled", action="store_true")
+
+    # remove
+    remove_parser = subparsers.add_parser("remove", help="Remove a schedule")
+    remove_parser.add_argument("name")
+
+    args = parser.parse_args()
+
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s [%(levelname)s] %(message)s",
+        datefmt="%Y-%m-%dT%H:%M:%SZ",
+    )
+
+    if args.command == "daemon" or args.command is None:
+        dry_run = getattr(args, "dry_run", False)
+        run_daemon(dry_run=dry_run, once=True)
+    elif args.command == "list":
+        list_schedules()
+    elif args.command == "add":
+        add_schedule(
+            args.name,
+            args.cron_expr,
+            args.action,
+            args.args,
+            enabled=not args.disabled,
+        )
+    elif args.command == "remove":
+        success = remove_schedule(args.name)
+        sys.exit(0 if success else 1)
+
+
+if __name__ == "__main__":
+    main()

package/autonomy/trigger-server.py

@@ -0,0 +1,309 @@
+#!/usr/bin/env python3
+"""
+trigger-server.py - GitHub webhook receiver for loki-mode event-driven execution.
+
+Listens for GitHub webhook events and automatically runs `loki run` in response.
+Supports signature validation, dry-run mode, and event logging.
+
+Usage:
+    python3 autonomy/trigger-server.py [--port PORT] [--secret SECRET] [--dry-run]
+"""
+
+import argparse
+import hashlib
+import hmac
+import http.server
+import json
+import logging
+import os
+import subprocess
+import sys
+import threading
+import time
+from datetime import datetime
+from pathlib import Path
+
+
+def get_loki_dir():
+    """Return .loki/triggers directory, creating it if needed."""
+    loki_dir = Path(".loki") / "triggers"
+    loki_dir.mkdir(parents=True, exist_ok=True)
+    return loki_dir
+
+
+def load_config():
+    """Load trigger config from .loki/triggers/config.json."""
+    config_path = get_loki_dir() / "config.json"
+    defaults = {
+        "port": 7373,
+        "secret": "",
+        "dry_run": False,
+        "enabled_events": ["issues", "pull_request", "workflow_run"],
+    }
+    if config_path.exists():
+        try:
+            with open(config_path) as f:
+                stored = json.load(f)
+            defaults.update(stored)
+        except (json.JSONDecodeError, OSError):
+            pass
+    return defaults
+
+
+def save_config(config):
+    """Save trigger config to .loki/triggers/config.json."""
+    config_path = get_loki_dir() / "config.json"
+    with open(config_path, "w") as f:
+        json.dump(config, f, indent=2)
+
+
+def log_event(event_type, action, payload_summary, status):
+    """Append event to .loki/triggers/events.log."""
+    log_path = get_loki_dir() / "events.log"
+    timestamp = datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ")
+    entry = {
+        "timestamp": timestamp,
+        "event": event_type,
+        "action": action,
+        "summary": payload_summary,
+        "status": status,
+    }
+    with open(log_path, "a") as f:
+        f.write(json.dumps(entry) + "\n")
+
+
+def validate_signature(secret, body, signature_header):
+    """Validate GitHub HMAC-SHA256 webhook signature."""
+    if not secret:
+        return True  # No secret configured - accept all
+    if not signature_header:
+        return False
+    expected = "sha256=" + hmac.new(
+        secret.encode("utf-8"), body, hashlib.sha256
+    ).hexdigest()
+    return hmac.compare_digest(expected, signature_header)
+
+
+def send_notification(message):
+    """Send desktop notification via loki syslog."""
+    try:
+        subprocess.run(
+            ["loki", "syslog", message],
+            timeout=5,
+            capture_output=True,
+        )
+    except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
+        pass
+
+
+def run_loki_command(args, dry_run=False):
+    """Run a loki command, or print it if dry_run is True."""
+    cmd = ["loki"] + args
+    if dry_run:
+        logging.info("[DRY-RUN] Would run: %s", " ".join(cmd))
+        return True
+    logging.info("Running: %s", " ".join(cmd))
+    try:
+        proc = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+        # Don't wait - detached execution
+        logging.info("Started process pid=%d", proc.pid)
+        return True
+    except (FileNotFoundError, OSError) as e:
+        logging.error("Failed to run %s: %s", " ".join(cmd), e)
+        return False
+
+
+def handle_issues_event(payload, dry_run=False):
+    """Handle issues event: opened -> loki run <issue_number> --pr --detach."""
+    action = payload.get("action", "")
+    if action != "opened":
+        return None, "skipped (action=%s)" % action
+    issue = payload.get("issue", {})
+    issue_number = issue.get("number")
+    repo = payload.get("repository", {})
+    repo_full_name = repo.get("full_name", "")
+    if not issue_number:
+        return None, "skipped (no issue number)"
+    args = ["run", str(issue_number), "--pr", "--detach"]
+    if repo_full_name:
+        args = ["run", "%s#%s" % (repo_full_name, issue_number), "--pr", "--detach"]
+    summary = "issue #%s opened in %s" % (issue_number, repo_full_name)
+    success = run_loki_command(args, dry_run=dry_run)
+    status = "fired" if success else "error"
+    if success:
+        send_notification("Trigger fired: %s" % summary)
+    return summary, status
+
+
+def handle_pull_request_event(payload, dry_run=False):
+    """Handle pull_request event: synchronize -> loki run <pr_number> --detach."""
+    action = payload.get("action", "")
+    if action != "synchronize":
+        return None, "skipped (action=%s)" % action
+    pr = payload.get("pull_request", {})
+    pr_number = pr.get("number")
+    repo = payload.get("repository", {})
+    repo_full_name = repo.get("full_name", "")
+    if not pr_number:
+        return None, "skipped (no PR number)"
+    args = ["run", str(pr_number), "--detach"]
+    if repo_full_name:
+        args = ["run", "%s#%s" % (repo_full_name, pr_number), "--detach"]
+    summary = "PR #%s synchronized in %s" % (pr_number, repo_full_name)
+    success = run_loki_command(args, dry_run=dry_run)
+    status = "fired" if success else "error"
+    if success:
+        send_notification("Trigger fired: %s" % summary)
+    return summary, status
+
+
+def handle_workflow_run_event(payload, dry_run=False):
+    """Handle workflow_run event: completed+failure -> loki run with context."""
+    action = payload.get("action", "")
+    if action != "completed":
+        return None, "skipped (action=%s)" % action
+    wf = payload.get("workflow_run", {})
+    conclusion = wf.get("conclusion", "")
+    if conclusion != "failure":
+        return None, "skipped (conclusion=%s)" % conclusion
+    wf_name = wf.get("name", "unknown")
+    repo = payload.get("repository", {})
+    repo_full_name = repo.get("full_name", "")
+    summary = "workflow '%s' failed in %s" % (wf_name, repo_full_name)
+    # Run loki run with failure context note
+    args = ["run", "--detach"]
+    success = run_loki_command(args, dry_run=dry_run)
+    status = "fired" if success else "error"
+    if success:
+        send_notification("Trigger fired: CI failure - %s" % summary)
+    return summary, status
+
+
+class WebhookHandler(http.server.BaseHTTPRequestHandler):
+    """HTTP request handler for GitHub webhooks."""
+
+    dry_run = False
+    secret = ""
+
+    def log_message(self, format, *args):
+        logging.info("%s - %s", self.address_string(), format % args)
+
+    def do_GET(self):
+        if self.path == "/health":
+            self._send_json(200, {"status": "ok", "service": "loki-trigger-server"})
+        elif self.path == "/status":
+            config = load_config()
+            self._send_json(200, {
+                "status": "running",
+                "dry_run": self.dry_run,
+                "port": config.get("port", 7373),
+                "enabled_events": config.get("enabled_events", []),
+            })
+        else:
+            self._send_json(404, {"error": "not found"})
+
+    def do_POST(self):
+        if self.path != "/webhook":
+            self._send_json(404, {"error": "not found"})
+            return
+
+        content_length = int(self.headers.get("Content-Length", 0))
+        body = self.rfile.read(content_length)
+
+        event_type = self.headers.get("X-GitHub-Event", "")
+        signature = self.headers.get("X-Hub-Signature-256", "")
+
+        if not validate_signature(self.secret, body, signature):
+            logging.warning("Invalid webhook signature")
+            self._send_json(401, {"error": "invalid signature"})
+            return
+
+        try:
+            payload = json.loads(body)
+        except json.JSONDecodeError:
+            self._send_json(400, {"error": "invalid JSON"})
+            return
+
+        action = payload.get("action", "")
+        summary = None
+        status = "unhandled"
+
+        if event_type == "issues":
+            summary, status = handle_issues_event(payload, dry_run=self.dry_run)
+        elif event_type == "pull_request":
+            summary, status = handle_pull_request_event(payload, dry_run=self.dry_run)
+        elif event_type == "workflow_run":
+            summary, status = handle_workflow_run_event(payload, dry_run=self.dry_run)
+        else:
+            status = "unsupported event: %s" % event_type
+
+        log_event(event_type, action, summary or "", status)
+        self._send_json(200, {"event": event_type, "action": action, "status": status})
+
+    def _send_json(self, code, data):
+        body = json.dumps(data).encode("utf-8")
+        self.send_response(code)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+
+def write_pid_file():
+    """Write PID to .loki/triggers/server.pid."""
+    pid_path = get_loki_dir() / "server.pid"
+    with open(pid_path, "w") as f:
+        f.write(str(os.getpid()))
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="loki-mode GitHub webhook trigger server"
+    )
+    parser.add_argument("--port", type=int, default=None, help="Port to listen on (default: 7373)")
+    parser.add_argument("--secret", default=None, help="GitHub webhook secret for HMAC validation")
+    parser.add_argument("--dry-run", action="store_true", help="Preview triggers without running loki")
+    args = parser.parse_args()
+
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s [%(levelname)s] %(message)s",
+        datefmt="%Y-%m-%dT%H:%M:%SZ",
+    )
+
+    config = load_config()
+    port = args.port if args.port is not None else config.get("port", 7373)
+    secret = args.secret if args.secret is not None else config.get("secret", "")
+    dry_run = args.dry_run or config.get("dry_run", False)
+
+    # Update config with resolved values
+    config["port"] = port
+    config["secret"] = secret
+    config["dry_run"] = dry_run
+    save_config(config)
+
+    WebhookHandler.dry_run = dry_run
+    WebhookHandler.secret = secret
+
+    server = http.server.HTTPServer(("", port), WebhookHandler)
+    write_pid_file()
+
+    mode_label = " [DRY-RUN]" if dry_run else ""
+    logging.info("Loki trigger server starting on port %d%s", port, mode_label)
+    logging.info("Webhook endpoint: POST http://localhost:%d/webhook", port)
+    logging.info("Health check: GET http://localhost:%d/health", port)
+
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        logging.info("Trigger server stopped.")
+        pid_path = get_loki_dir() / "server.pid"
+        pid_path.unlink(missing_ok=True)
+
+
+if __name__ == "__main__":
+    main()

package/dashboard/__init__.py

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

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.16.1
+**Version:** v6.17.1
 
 ---
 

package/mcp/__init__.py

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

package/package.json

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