loki-mode 5.40.1 → 5.42.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 zero human intervention. Requires --dangerously-skip-permissions flag.
 ---
 
-# Loki Mode v5.40.1
+# Loki Mode v5.42.0
 
 **You are an autonomous agent. You make decisions. You do not ask questions. You do not stop.**
 
@@ -127,8 +127,8 @@ GROWTH ──[continuous improvement loop]──> GROWTH
 - Load only 1-2 skill modules at a time (from skills/00-index.md)
 - Use Task tool with subagents for exploration (isolates context)
 - IF context feels heavy: Create `.loki/signals/CONTEXT_CLEAR_REQUESTED`
-- **Context Window Tracking (v5.40.1):** Dashboard gauge, timeline, and per-agent breakdown at `GET /api/context`
-- **Notification Triggers (v5.40.1):** Configurable alerts when context exceeds thresholds, tasks fail, or budget limits hit. Manage via `GET/PUT /api/notifications/triggers`
+- **Context Window Tracking (v5.40.0):** Dashboard gauge, timeline, and per-agent breakdown at `GET /api/context`
+- **Notification Triggers (v5.40.0):** Configurable alerts when context exceeds thresholds, tasks fail, or budget limits hit. Manage via `GET/PUT /api/notifications/triggers`
 
 ---
 
@@ -258,8 +258,8 @@ The following features are documented in skill modules but not yet fully automat
 |---------|--------|-------|
 | PRE-ACT goal drift detection | Planned | Agent-level attention check before each action; no automated enforcement yet |
 | CONTINUITY.md working memory | Implemented (v5.35.0) | Auto-managed by run.sh, updated each iteration |
-| GitHub issue import | Planned | Config flags exist (`LOKI_GITHUB_IMPORT`); `gh` CLI integration partial |
+| GitHub integration | Implemented (v5.42.0) | Import, sync-back, PR creation, export. CLI: `loki github`, API: `/api/github/*` |
 | 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.40.1 | fix: 46-bug audit across all distributions, JSON injection, Docker mounts, auth hardening | ~260 lines core**
+**v5.42.0 | feat: GitHub sync-back, PR creation, export (fully wired) | ~260 lines core**

package/VERSION

@@ -1 +1 @@
-5.40.1
+5.42.0

package/autonomy/loki

@@ -14,6 +14,7 @@
 #   loki status           - Show current status
 #   loki dashboard        - Open dashboard in browser
 #   loki import           - Import GitHub issues
+#   loki github [cmd]     - GitHub integration (sync|export|pr|status)
 #   loki help             - Show this help
 #===============================================================================
 
@@ -323,6 +324,7 @@ show_help() {
     echo "  notify [cmd]     Send notifications (test|slack|discord|webhook|status)"
     echo "  voice [cmd]      Voice input for PRD creation (status|listen|dictate|speak|start)"
     echo "  import           Import GitHub issues as tasks"
+    echo "  github [cmd]     GitHub integration (sync|export|pr|status)"
     echo "  config [cmd]     Manage configuration (show|init|edit|path)"
     echo "  completions [bash|zsh]  Output shell completion scripts"
     echo "  memory [cmd]     Cross-project learnings (list|show|search|stats)"
@@ -515,7 +517,7 @@ cmd_start() {
     if [ -n "$prd_file" ]; then
         args+=("$prd_file")
     else
-        # No PRD file specified -- warn and confirm before consuming API credits
+        # No PRD file specified -- warn and confirm before starting
         # Auto-confirm in CI environments or when LOKI_AUTO_CONFIRM is set
         # LOKI_AUTO_CONFIRM takes precedence when explicitly set;
         # fall back to CI env var only when LOKI_AUTO_CONFIRM is unset
@@ -524,10 +526,10 @@ cmd_start() {
             echo -e "${YELLOW}Warning: No PRD file specified. Auto-confirming (CI mode).${NC}"
         else
             echo -e "${YELLOW}Warning: No PRD file specified.${NC}"
-            echo "Loki Mode will start autonomous execution in the current directory"
-            echo "without a requirements document."
+            echo "Loki Mode will analyze the existing codebase and generate"
+            echo "a PRD automatically. No requirements document needed."
             echo ""
-            echo -e "This will consume API credits. Continue? [y/N] \c"
+            echo -e "Continue? [y/N] \c"
             read -r confirm
             if [[ ! "$confirm" =~ ^[Yy] ]]; then
                 echo "Aborted. Usage: loki start <path-to-prd.md>"
@@ -1832,6 +1834,183 @@ cmd_import() {
     fi
 }
 
+# GitHub integration management (v5.41.0)
+cmd_github() {
+    local subcmd="${1:-help}"
+    shift 2>/dev/null || true
+
+    case "$subcmd" in
+        sync)
+            # Sync completed tasks back to GitHub issues
+            if [ ! -d "$LOKI_DIR" ]; then
+                echo -e "${RED}No active Loki session found${NC}"
+                exit 1
+            fi
+
+            if ! command -v gh &>/dev/null; then
+                echo -e "${RED}Error: gh CLI not found. Install with: brew install gh${NC}"
+                exit 1
+            fi
+
+            if ! gh auth status &>/dev/null; then
+                echo -e "${RED}Error: gh CLI not authenticated. Run: gh auth login${NC}"
+                exit 1
+            fi
+
+            export LOKI_GITHUB_SYNC=true
+            source "$RUN_SH" 2>/dev/null || true
+
+            echo -e "${GREEN}Syncing completed tasks to GitHub...${NC}"
+            if type sync_github_completed_tasks &>/dev/null; then
+                sync_github_completed_tasks
+                echo -e "${GREEN}Sync complete.${NC}"
+
+                # Show what was synced
+                if [ -f "$LOKI_DIR/github/synced.log" ]; then
+                    local count
+                    count=$(wc -l < "$LOKI_DIR/github/synced.log" | tr -d ' ')
+                    echo -e "${DIM}Total synced status updates: $count${NC}"
+                fi
+            else
+                echo -e "${YELLOW}Sync function not available.${NC}"
+            fi
+            ;;
+
+        export)
+            # Export local tasks as GitHub issues
+            if [ ! -d "$LOKI_DIR" ]; then
+                echo -e "${RED}No active Loki session found${NC}"
+                exit 1
+            fi
+
+            if ! command -v gh &>/dev/null; then
+                echo -e "${RED}Error: gh CLI not found. Install with: brew install gh${NC}"
+                exit 1
+            fi
+
+            echo -e "${GREEN}Exporting local tasks to GitHub issues...${NC}"
+            source "$RUN_SH" 2>/dev/null || true
+            if type export_tasks_to_github &>/dev/null; then
+                export_tasks_to_github
+                echo -e "${GREEN}Export complete.${NC}"
+            else
+                echo -e "${YELLOW}Export function not available.${NC}"
+            fi
+            ;;
+
+        pr)
+            # Create PR from completed work
+            if ! command -v gh &>/dev/null; then
+                echo -e "${RED}Error: gh CLI not found. Install with: brew install gh${NC}"
+                exit 1
+            fi
+
+            local feature_name="${1:-Loki Mode changes}"
+            export LOKI_GITHUB_PR=true
+            source "$RUN_SH" 2>/dev/null || true
+
+            echo -e "${GREEN}Creating pull request: $feature_name${NC}"
+            if type create_github_pr &>/dev/null; then
+                create_github_pr "$feature_name"
+            else
+                echo -e "${YELLOW}PR function not available.${NC}"
+            fi
+            ;;
+
+        status)
+            # Show GitHub integration status
+            echo -e "${BOLD}GitHub Integration Status${NC}"
+            echo ""
+
+            # gh CLI
+            if command -v gh &>/dev/null; then
+                echo -e "  gh CLI:       ${GREEN}installed$(gh --version 2>/dev/null | head -1 | sed 's/gh version /v/')${NC}"
+                if gh auth status &>/dev/null 2>&1; then
+                    echo -e "  Auth:         ${GREEN}authenticated${NC}"
+                else
+                    echo -e "  Auth:         ${RED}not authenticated${NC}"
+                fi
+            else
+                echo -e "  gh CLI:       ${RED}not installed${NC}"
+            fi
+
+            # Repo detection
+            local repo=""
+            repo=$(git remote get-url origin 2>/dev/null | sed 's|.*github.com[:/]||;s|\.git$||' || echo "")
+            if [ -n "$repo" ]; then
+                echo -e "  Repository:   ${GREEN}$repo${NC}"
+            else
+                echo -e "  Repository:   ${YELLOW}not detected${NC}"
+            fi
+
+            # Config flags
+            echo ""
+            echo -e "${BOLD}Configuration${NC}"
+            echo -e "  LOKI_GITHUB_IMPORT:  ${LOKI_GITHUB_IMPORT:-false}"
+            echo -e "  LOKI_GITHUB_SYNC:    ${LOKI_GITHUB_SYNC:-false}"
+            echo -e "  LOKI_GITHUB_PR:      ${LOKI_GITHUB_PR:-false}"
+            echo -e "  LOKI_GITHUB_LABELS:  ${LOKI_GITHUB_LABELS:-(all)}"
+            echo -e "  LOKI_GITHUB_LIMIT:   ${LOKI_GITHUB_LIMIT:-100}"
+
+            # Sync log
+            if [ -f "$LOKI_DIR/github/synced.log" ]; then
+                echo ""
+                echo -e "${BOLD}Sync History${NC}"
+                local total
+                total=$(wc -l < "$LOKI_DIR/github/synced.log" | tr -d ' ')
+                echo -e "  Total synced updates: $total"
+                echo -e "  Recent:"
+                tail -5 "$LOKI_DIR/github/synced.log" | sed 's/^/    /'
+            fi
+
+            # Imported tasks
+            if [ -f "$LOKI_DIR/queue/pending.json" ]; then
+                local gh_tasks
+                gh_tasks=$(python3 -c "
+import json
+try:
+    with open('$LOKI_DIR/queue/pending.json') as f:
+        data = json.load(f)
+    tasks = data.get('tasks', data) if isinstance(data, dict) else data
+    gh = [t for t in tasks if t.get('source') == 'github']
+    print(len(gh))
+except: print(0)
+" 2>/dev/null || echo "0")
+                echo ""
+                echo -e "${BOLD}Imported Issues${NC}"
+                echo -e "  GitHub tasks in queue: $gh_tasks"
+            fi
+            ;;
+
+        help|*)
+            echo -e "${BOLD}loki github${NC} - GitHub integration management"
+            echo ""
+            echo "Commands:"
+            echo "  status       Show GitHub integration status"
+            echo "  sync         Sync completed task status back to GitHub issues"
+            echo "  export       Export local tasks as new GitHub issues"
+            echo "  pr [name]    Create pull request from completed work"
+            echo ""
+            echo "Environment Variables:"
+            echo "  LOKI_GITHUB_IMPORT=true    Import open issues as tasks on start"
+            echo "  LOKI_GITHUB_SYNC=true      Sync status back to issues during session"
+            echo "  LOKI_GITHUB_PR=true        Create PR when session completes successfully"
+            echo "  LOKI_GITHUB_LABELS=bug     Filter issues by label (comma-separated)"
+            echo "  LOKI_GITHUB_MILESTONE=v2   Filter by milestone"
+            echo "  LOKI_GITHUB_ASSIGNEE=me    Filter by assignee"
+            echo "  LOKI_GITHUB_LIMIT=50       Max issues to import (default: 100)"
+            echo "  LOKI_GITHUB_PR_LABEL=loki  Label to add to created PRs"
+            echo ""
+            echo "Examples:"
+            echo "  loki github status"
+            echo "  loki github sync"
+            echo "  loki github export"
+            echo "  loki github pr \"Add user authentication\""
+            echo "  LOKI_GITHUB_SYNC=true loki start --github ./prd.md"
+            ;;
+    esac
+}
+
 # Parse GitHub issue using issue-parser.sh
 cmd_issue_parse() {
     local issue_ref=""
@@ -4278,6 +4457,9 @@ main() {
         import)
             cmd_import
             ;;
+        github)
+            cmd_github "$@"
+            ;;
         issue)
             cmd_issue "$@"
             ;;

package/autonomy/run.sh

@@ -1273,10 +1273,12 @@ create_github_pr() {
     local pr_body=".loki/reports/pr-body.md"
     mkdir -p "$(dirname "$pr_body")"
 
+    local version
+    version=$(cat "${SCRIPT_DIR%/*}/VERSION" 2>/dev/null || echo "unknown")
     cat > "$pr_body" << EOF
 ## Summary
 
-Automated implementation by Loki Mode v4.1.0
+Automated implementation by Loki Mode v$version ($ITERATION_COUNT iterations, provider: ${PROVIDER_NAME:-claude})
 
 ### Feature: $feature_name
 
@@ -1349,24 +1351,105 @@ sync_github_status() {
         return 1
     fi
 
+    # Track synced issues to avoid duplicate comments
+    mkdir -p .loki/github
+    local sync_log=".loki/github/synced.log"
+    local sync_key="${issue_number}:${status}"
+    if [ -f "$sync_log" ] && grep -qF "$sync_key" "$sync_log" 2>/dev/null; then
+        return 0  # Already synced this status
+    fi
+
     case "$status" in
         "in_progress")
             gh issue comment "$issue_number" --repo "$repo" \
-                --body "Loki Mode: Task in progress - ${message:-implementing solution...}" \
+                --body "**Loki Mode** -- Working on this issue (iteration $ITERATION_COUNT)" \
                 2>/dev/null || true
             ;;
         "completed")
+            local branch
+            branch=$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo "main")
+            local commit
+            commit=$(git rev-parse --short HEAD 2>/dev/null || echo "unknown")
             gh issue comment "$issue_number" --repo "$repo" \
-                --body "Loki Mode: Implementation complete. ${message:-}" \
+                --body "**Loki Mode** -- Implementation complete on \`$branch\` ($commit). ${message:-}" \
                 2>/dev/null || true
             ;;
         "closed")
             gh issue close "$issue_number" --repo "$repo" \
                 --reason "completed" \
-                --comment "Loki Mode: Fixed. ${message:-}" \
+                --comment "**Loki Mode** -- Resolved. ${message:-}" \
                 2>/dev/null || true
             ;;
     esac
+
+    # Record sync to avoid duplicates
+    echo "$sync_key" >> "$sync_log"
+}
+
+# Sync all completed GitHub-sourced tasks back to their issues
+# Called after each iteration and at session end
+sync_github_completed_tasks() {
+    if [ "$GITHUB_SYNC" != "true" ]; then
+        return 0
+    fi
+
+    if ! check_github_cli; then
+        return 0
+    fi
+
+    local completed_file=".loki/queue/completed.json"
+    if [ ! -f "$completed_file" ]; then
+        return 0
+    fi
+
+    # Find GitHub-sourced tasks in completed queue that haven't been synced
+    python3 -c "
+import json, sys
+try:
+    with open('$completed_file') as f:
+        tasks = json.load(f)
+    for t in tasks:
+        tid = t.get('id', '')
+        if tid.startswith('github-'):
+            print(tid)
+except Exception:
+    pass
+" 2>/dev/null | while read -r task_id; do
+        sync_github_status "$task_id" "completed"
+    done
+}
+
+# Sync GitHub-sourced tasks currently in-progress
+sync_github_in_progress_tasks() {
+    if [ "$GITHUB_SYNC" != "true" ]; then
+        return 0
+    fi
+
+    if ! check_github_cli; then
+        return 0
+    fi
+
+    local pending_file=".loki/queue/pending.json"
+    if [ ! -f "$pending_file" ]; then
+        return 0
+    fi
+
+    # Find GitHub-sourced tasks in pending queue (about to be worked on)
+    python3 -c "
+import json
+try:
+    with open('$pending_file') as f:
+        data = json.load(f)
+    tasks = data.get('tasks', data) if isinstance(data, dict) else data
+    for t in tasks:
+        tid = t.get('id', '')
+        if tid.startswith('github-'):
+            print(tid)
+except Exception:
+    pass
+" 2>/dev/null | while read -r task_id; do
+        sync_github_status "$task_id" "in_progress"
+    done
 }
 
 # Export tasks to GitHub issues (reverse sync)
@@ -2622,6 +2705,14 @@ except: print('{\"total\":0,\"unacknowledged\":0}')
   "council": $council_state,
   "budget": $budget_json,
   "context": $context_state,
+  "tokens": $(python3 -c "
+import json
+try:
+    t = json.load(open('.loki/context/tracking.json'))
+    totals = t.get('totals', {})
+    print(json.dumps({'input': totals.get('total_input', 0), 'output': totals.get('total_output', 0), 'cost_usd': totals.get('total_cost_usd', 0)}))
+except: print('null')
+" 2>/dev/null || echo "null"),
   "notifications": $notification_summary
 }
 EOF
@@ -2774,6 +2865,9 @@ track_iteration_complete() {
             --context "{\"iteration\":$iteration,\"exit_code\":$exit_code}"
     fi
 
+    # Track context window usage FIRST to get token data (v5.42.0)
+    track_context_usage "$iteration"
+
     # Write efficiency tracking file for /api/cost endpoint
     mkdir -p .loki/metrics/efficiency
     local model_tier="sonnet"
@@ -2786,6 +2880,25 @@ track_iteration_complete() {
     fi
     local phase="${LAST_KNOWN_PHASE:-}"
     [ -z "$phase" ] && phase=$(python3 -c "import json; print(json.load(open('.loki/state/orchestrator.json')).get('currentPhase', 'unknown'))" 2>/dev/null || echo "unknown")
+
+    # Read token data from context tracker output (v5.42.0)
+    local iter_input=0 iter_output=0 iter_cost=0
+    if [ -f ".loki/context/tracking.json" ]; then
+        read iter_input iter_output iter_cost < <(python3 -c "
+import json
+try:
+    t = json.load(open('.loki/context/tracking.json'))
+    iters = t.get('per_iteration', [])
+    match = [i for i in iters if i.get('iteration') == $iteration]
+    if match:
+        m = match[-1]
+        print(m.get('input_tokens', 0), m.get('output_tokens', 0), m.get('cost_usd', 0))
+    else:
+        print(0, 0, 0)
+except: print(0, 0, 0)
+" 2>/dev/null || echo "0 0 0")
+    fi
+
     cat > ".loki/metrics/efficiency/iteration-${iteration}.json" << EFF_EOF
 {
   "iteration": $iteration,
@@ -2794,16 +2907,19 @@ track_iteration_complete() {
   "duration_ms": $duration_ms,
   "provider": "${PROVIDER_NAME:-claude}",
   "status": "$status_str",
+  "input_tokens": ${iter_input:-0},
+  "output_tokens": ${iter_output:-0},
+  "cost_usd": ${iter_cost:-0},
   "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)"
 }
 EFF_EOF
 
-    # Track context window usage (v5.40.0)
-    track_context_usage "$iteration"
-
     # Check notification triggers (v5.40.0)
     check_notification_triggers "$iteration"
 
+    # Sync completed GitHub tasks back to issues (v5.41.0)
+    sync_github_completed_tasks
+
     # Get task from in-progress
     local in_progress_file=".loki/queue/in-progress.json"
     local completed_file=".loki/queue/completed.json"
@@ -7020,6 +7136,8 @@ main() {
     # Import GitHub issues if enabled (v4.1.0)
     if [ "$GITHUB_IMPORT" = "true" ]; then
         import_github_issues
+        # Notify GitHub that imported issues are being worked on (v5.41.0)
+        sync_github_in_progress_tasks
     fi
 
     # Start web dashboard (if enabled)
@@ -7109,6 +7227,14 @@ main() {
         run_autonomous "$PRD_PATH" || result=$?
     fi
 
+    # Final GitHub sync: sync all completed tasks and create PR (v5.41.0)
+    sync_github_completed_tasks
+    if [ "$GITHUB_PR" = "true" ] && [ "$result" = "0" ]; then
+        local feature_name="${PRD_PATH:-Codebase improvements}"
+        feature_name=$(basename "$feature_name" .md 2>/dev/null || echo "$feature_name")
+        create_github_pr "$feature_name"
+    fi
+
     # Extract and save learnings from this session
     extract_learnings_from_session
 

package/dashboard/__init__.py

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

package/dashboard/server.py

@@ -1500,22 +1500,61 @@ async def get_memory_timeline():
 
 
 # Learning/metrics endpoints
+
+
+def _read_learning_signals(signal_type: Optional[str] = None, limit: int = 50) -> list:
+    """Read learning signals from .loki/learning/signals/*.json files.
+
+    Learning signals are written as individual JSON files by the learning emitter
+    (learning/emitter.py). Each file contains a single signal object with fields:
+    id, type, source, action, timestamp, confidence, outcome, data, context.
+    """
+    signals_dir = _get_loki_dir() / "learning" / "signals"
+    if not signals_dir.exists() or not signals_dir.is_dir():
+        return []
+
+    signals = []
+    try:
+        for fpath in signals_dir.glob("*.json"):
+            try:
+                raw = fpath.read_text()
+                if not raw.strip():
+                    continue
+                sig = json.loads(raw)
+                if signal_type and sig.get("type") != signal_type:
+                    continue
+                signals.append(sig)
+            except (json.JSONDecodeError, OSError):
+                continue
+    except OSError:
+        return []
+
+    # Sort by timestamp descending (newest first)
+    signals.sort(key=lambda s: s.get("timestamp", ""), reverse=True)
+    return signals[:limit]
+
+
 @app.get("/api/learning/metrics")
 async def get_learning_metrics(
     timeRange: str = "7d",
     signalType: Optional[str] = None,
     source: Optional[str] = None,
 ):
-    """Get learning metrics from events and metrics files."""
+    """Get learning metrics from events, metrics files, and learning signals."""
     events = _read_events(timeRange)
 
+    # Also read from learning signals directory
+    all_signals = _read_learning_signals(limit=10000)
+
     # Filter by type and source
     if signalType:
         events = [e for e in events if e.get("data", {}).get("type") == signalType]
+        all_signals = [s for s in all_signals if s.get("type") == signalType]
     if source:
         events = [e for e in events if e.get("data", {}).get("source") == source]
+        all_signals = [s for s in all_signals if s.get("source") == source]
 
-    # Count by type
+    # Count by type from events.jsonl
     by_type: dict = {}
     by_source: dict = {}
     for e in events:
@@ -1524,6 +1563,19 @@ async def get_learning_metrics(
         s = e.get("data", {}).get("source", "unknown")
         by_source[s] = by_source.get(s, 0) + 1
 
+    # Merge counts from learning signals directory
+    for s in all_signals:
+        t = s.get("type", "unknown")
+        by_type[t] = by_type.get(t, 0) + 1
+        src = s.get("source", "unknown")
+        by_source[src] = by_source.get(src, 0) + 1
+
+    total_count = len(events) + len(all_signals)
+
+    # Calculate average confidence across both sources
+    total_conf = sum(e.get("data", {}).get("confidence", 0) for e in events)
+    total_conf += sum(s.get("confidence", 0) for s in all_signals)
+
     # Load aggregation data from file if available
     aggregation = {
         "preferences": [],
@@ -1543,10 +1595,10 @@ async def get_learning_metrics(
             pass
 
     return {
-        "totalSignals": len(events),
+        "totalSignals": total_count,
         "signalsByType": by_type,
         "signalsBySource": by_source,
-        "avgConfidence": round(sum(e.get("data", {}).get("confidence", 0) for e in events) / max(len(events), 1), 4),
+        "avgConfidence": round(total_conf / max(total_count, 1), 4),
         "aggregation": aggregation,
     }
 
@@ -1579,25 +1631,107 @@ async def get_learning_signals(
     limit: int = 50,
     offset: int = 0,
 ):
-    """Get raw learning signals."""
+    """Get raw learning signals from both events.jsonl and learning signals directory."""
     events = _read_events(timeRange)
     if signalType:
         events = [e for e in events if e.get("type") == signalType]
     if source:
         events = [e for e in events if e.get("data", {}).get("source") == source]
-    return events[offset:offset + limit]
+
+    # Also read from learning signals directory
+    file_signals = _read_learning_signals(signal_type=signalType, limit=10000)
+    if source:
+        file_signals = [s for s in file_signals if s.get("source") == source]
+
+    # Merge and sort by timestamp (newest first)
+    combined = events + file_signals
+    combined.sort(key=lambda s: s.get("timestamp", ""), reverse=True)
+    return combined[offset:offset + limit]
 
 
 @app.get("/api/learning/aggregation")
 async def get_learning_aggregation():
-    """Get latest learning aggregation result."""
+    """Get latest learning aggregation result, merging file-based aggregation with live signals."""
+    result = {"preferences": [], "error_patterns": [], "success_patterns": [], "tool_efficiencies": []}
+
+    # Load pre-computed aggregation from file if available
     agg_file = _get_loki_dir() / "metrics" / "aggregation.json"
     if agg_file.exists():
         try:
-            return json.loads(agg_file.read_text())
+            result = json.loads(agg_file.read_text())
         except Exception:
             pass
-    return {"preferences": [], "error_patterns": [], "success_patterns": [], "tool_efficiencies": []}
+
+    # Supplement with live data from learning signals directory
+    success_signals = _read_learning_signals(signal_type="success_pattern", limit=500)
+    tool_signals = _read_learning_signals(signal_type="tool_efficiency", limit=500)
+    error_signals = _read_learning_signals(signal_type="error_pattern", limit=500)
+    pref_signals = _read_learning_signals(signal_type="user_preference", limit=500)
+
+    # Merge success patterns from signals if aggregation file had none
+    if not result.get("success_patterns") and success_signals:
+        pattern_counts: dict = {}
+        for s in success_signals:
+            name = s.get("data", {}).get("pattern_name", s.get("action", "unknown"))
+            pattern_counts[name] = pattern_counts.get(name, 0) + 1
+        result["success_patterns"] = [
+            {"pattern_name": k, "frequency": v, "confidence": min(1.0, v / 10)}
+            for k, v in sorted(pattern_counts.items(), key=lambda x: -x[1])
+        ]
+
+    # Merge tool efficiencies from signals if aggregation file had none
+    if not result.get("tool_efficiencies") and tool_signals:
+        tool_stats: dict = {}
+        for s in tool_signals:
+            data = s.get("data", {})
+            tool_name = data.get("tool_name", s.get("action", "unknown"))
+            if tool_name not in tool_stats:
+                tool_stats[tool_name] = {"count": 0, "total_ms": 0, "successes": 0}
+            tool_stats[tool_name]["count"] += 1
+            tool_stats[tool_name]["total_ms"] += data.get("duration_ms", 0)
+            if data.get("success", s.get("outcome") == "success"):
+                tool_stats[tool_name]["successes"] += 1
+        result["tool_efficiencies"] = []
+        for tname, stats in sorted(tool_stats.items(), key=lambda x: -x[1]["count"]):
+            avg_ms = stats["total_ms"] / stats["count"] if stats["count"] else 0
+            sr = round(stats["successes"] / stats["count"], 4) if stats["count"] else 0
+            result["tool_efficiencies"].append({
+                "tool_name": tname, "efficiency_score": sr,
+                "count": stats["count"], "avg_execution_time_ms": round(avg_ms, 2),
+                "success_rate": sr,
+            })
+
+    # Merge error patterns from signals if aggregation file had none
+    if not result.get("error_patterns") and error_signals:
+        error_counts: dict = {}
+        for s in error_signals:
+            etype = s.get("data", {}).get("error_type", s.get("action", "unknown"))
+            error_counts[etype] = error_counts.get(etype, 0) + 1
+        result["error_patterns"] = [
+            {"error_type": k, "resolution_rate": 0.0, "frequency": v, "confidence": min(1.0, v / 10)}
+            for k, v in sorted(error_counts.items(), key=lambda x: -x[1])
+        ]
+
+    # Merge preferences from signals if aggregation file had none
+    if not result.get("preferences") and pref_signals:
+        pref_counts: dict = {}
+        for s in pref_signals:
+            key = s.get("data", {}).get("preference_key", s.get("action", "unknown"))
+            pref_counts[key] = pref_counts.get(key, 0) + 1
+        result["preferences"] = [
+            {"preference_key": k, "preferred_value": k, "frequency": v, "confidence": min(1.0, v / 10)}
+            for k, v in sorted(pref_counts.items(), key=lambda x: -x[1])
+        ]
+
+    # Add signal counts summary
+    result["signal_counts"] = {
+        "success_patterns": len(success_signals),
+        "tool_efficiency": len(tool_signals),
+        "error_patterns": len(error_signals),
+        "user_preferences": len(pref_signals),
+    }
+
+    return result
 
 
 @app.post("/api/learning/aggregate", dependencies=[Depends(auth.require_scope("control"))])
@@ -1690,34 +1824,50 @@ async def trigger_aggregation():
 
 @app.get("/api/learning/preferences")
 async def get_learning_preferences(limit: int = 50):
-    """Get aggregated user preferences."""
+    """Get aggregated user preferences from events and learning signals directory."""
     events = _read_events("30d")
     prefs = [e for e in events if e.get("type") == "user_preference"]
-    return prefs[:limit]
+    # Also read from learning signals directory
+    file_prefs = _read_learning_signals(signal_type="user_preference", limit=limit)
+    combined = prefs + file_prefs
+    combined.sort(key=lambda s: s.get("timestamp", ""), reverse=True)
+    return combined[:limit]
 
 
 @app.get("/api/learning/errors")
 async def get_learning_errors(limit: int = 50):
-    """Get aggregated error patterns."""
+    """Get aggregated error patterns from events and learning signals directory."""
     events = _read_events("30d")
     errors = [e for e in events if e.get("type") == "error_pattern"]
-    return errors[:limit]
+    # Also read from learning signals directory
+    file_errors = _read_learning_signals(signal_type="error_pattern", limit=limit)
+    combined = errors + file_errors
+    combined.sort(key=lambda s: s.get("timestamp", ""), reverse=True)
+    return combined[:limit]
 
 
 @app.get("/api/learning/success")
 async def get_learning_success(limit: int = 50):
-    """Get aggregated success patterns."""
+    """Get aggregated success patterns from events and learning signals directory."""
     events = _read_events("30d")
     successes = [e for e in events if e.get("type") == "success_pattern"]
-    return successes[:limit]
+    # Also read from learning signals directory
+    file_successes = _read_learning_signals(signal_type="success_pattern", limit=limit)
+    combined = successes + file_successes
+    combined.sort(key=lambda s: s.get("timestamp", ""), reverse=True)
+    return combined[:limit]
 
 
 @app.get("/api/learning/tools")
 async def get_tool_efficiency(limit: int = 50):
-    """Get tool efficiency rankings."""
+    """Get tool efficiency rankings from events and learning signals directory."""
     events = _read_events("30d")
     tools = [e for e in events if e.get("type") == "tool_efficiency"]
-    return tools[:limit]
+    # Also read from learning signals directory
+    file_tools = _read_learning_signals(signal_type="tool_efficiency", limit=limit)
+    combined = tools + file_tools
+    combined.sort(key=lambda s: s.get("timestamp", ""), reverse=True)
+    return combined[:limit]
 
 
 def _parse_time_range(time_range: str) -> Optional[datetime]:
@@ -1957,24 +2107,28 @@ async def get_cost():
             except (json.JSONDecodeError, KeyError, TypeError):
                 pass
 
-    # Also check dashboard-state.json for token data if efficiency dir is empty
+    # Fallback: read from context tracking if efficiency files have no token data
     if total_input == 0 and total_output == 0:
-        state_file = loki_dir / "dashboard-state.json"
-        if state_file.exists():
+        ctx_file = loki_dir / "context" / "tracking.json"
+        if ctx_file.exists():
             try:
-                state = json.loads(state_file.read_text())
-                tokens = state.get("tokens", {})
-                total_input = tokens.get("input", 0)
-                total_output = tokens.get("output", 0)
-                model = state.get("model", "sonnet").lower()
+                ctx = json.loads(ctx_file.read_text())
+                totals = ctx.get("totals", {})
+                total_input = totals.get("total_input", 0)
+                total_output = totals.get("total_output", 0)
                 if total_input > 0 or total_output > 0:
-                    estimated_cost = _calculate_model_cost(model, total_input, total_output)
-                    if model not in by_model:
-                        by_model[model] = {
-                            "input_tokens": total_input,
-                            "output_tokens": total_output,
-                            "cost_usd": estimated_cost,
-                        }
+                    estimated_cost = totals.get("total_cost_usd", 0.0)
+                    # Rebuild by_model and by_phase from per_iteration data
+                    for it in ctx.get("per_iteration", []):
+                        inp = it.get("input_tokens", 0)
+                        out = it.get("output_tokens", 0)
+                        cost = it.get("cost_usd", 0)
+                        model = ctx.get("provider", "sonnet").lower()
+                        if model not in by_model:
+                            by_model[model] = {"input_tokens": 0, "output_tokens": 0, "cost_usd": 0.0}
+                        by_model[model]["input_tokens"] += inp
+                        by_model[model]["output_tokens"] += out
+                        by_model[model]["cost_usd"] += cost
             except (json.JSONDecodeError, KeyError):
                 pass
 
@@ -2789,6 +2943,130 @@ async def get_secrets_status():
     }
 
 
+# =============================================================================
+# GitHub Integration API (v5.41.0)
+# =============================================================================
+
+
+@app.get("/api/github/status")
+async def get_github_status(token: Optional[dict] = Depends(auth.get_current_token)):
+    """Get GitHub integration status and configuration."""
+    loki_dir = _get_loki_dir()
+    result: dict[str, Any] = {
+        "import_enabled": os.environ.get("LOKI_GITHUB_IMPORT", "false") == "true",
+        "sync_enabled": os.environ.get("LOKI_GITHUB_SYNC", "false") == "true",
+        "pr_enabled": os.environ.get("LOKI_GITHUB_PR", "false") == "true",
+        "labels_filter": os.environ.get("LOKI_GITHUB_LABELS", ""),
+        "milestone_filter": os.environ.get("LOKI_GITHUB_MILESTONE", ""),
+        "limit": int(os.environ.get("LOKI_GITHUB_LIMIT", "100")),
+        "imported_tasks": 0,
+        "synced_updates": 0,
+        "repo": None,
+    }
+
+    # Count imported GitHub tasks from pending queue
+    pending_file = loki_dir / "queue" / "pending.json"
+    if pending_file.exists():
+        try:
+            data = json.loads(pending_file.read_text())
+            tasks = data.get("tasks", data) if isinstance(data, dict) else data
+            result["imported_tasks"] = sum(1 for t in tasks if t.get("source") == "github")
+        except Exception:
+            pass
+
+    # Count sync log entries
+    sync_log = loki_dir / "github" / "synced.log"
+    if sync_log.exists():
+        try:
+            result["synced_updates"] = sum(1 for _ in sync_log.open())
+        except Exception:
+            pass
+
+    # Detect repo from git
+    try:
+        import subprocess
+        url = subprocess.run(
+            ["git", "remote", "get-url", "origin"],
+            capture_output=True, text=True, timeout=5,
+            cwd=str(loki_dir.parent) if loki_dir.name == ".loki" else None
+        )
+        if url.returncode == 0:
+            repo = url.stdout.strip()
+            # Parse owner/repo from URL
+            for prefix in ["https://github.com/", "git@github.com:"]:
+                if repo.startswith(prefix):
+                    repo = repo[len(prefix):]
+                    break
+            result["repo"] = repo.removesuffix(".git")
+    except Exception:
+        pass
+
+    return result
+
+
+@app.get("/api/github/tasks")
+async def get_github_tasks(token: Optional[dict] = Depends(auth.get_current_token)):
+    """Get all GitHub-sourced tasks and their sync status."""
+    loki_dir = _get_loki_dir()
+    tasks: list[dict] = []
+
+    # Collect GitHub tasks from all queues
+    for queue_name in ["pending", "in-progress", "completed", "failed"]:
+        queue_file = loki_dir / "queue" / f"{queue_name}.json"
+        if queue_file.exists():
+            try:
+                data = json.loads(queue_file.read_text())
+                items = data.get("tasks", data) if isinstance(data, dict) else data
+                for t in items:
+                    if t.get("source") == "github" or str(t.get("id", "")).startswith("github-"):
+                        t["queue"] = queue_name
+                        tasks.append(t)
+            except Exception:
+                pass
+
+    # Load sync log to annotate sync status
+    synced: set[str] = set()
+    sync_log = loki_dir / "github" / "synced.log"
+    if sync_log.exists():
+        try:
+            synced = set(sync_log.read_text().strip().splitlines())
+        except Exception:
+            pass
+
+    for t in tasks:
+        issue_num = str(t.get("github_issue", ""))
+        if not issue_num:
+            issue_num = str(t.get("id", "")).replace("github-", "")
+        t["synced_statuses"] = [
+            s.split(":")[1] for s in synced if s.startswith(f"{issue_num}:")
+        ]
+
+    return {"tasks": tasks, "total": len(tasks)}
+
+
+@app.get("/api/github/sync-log")
+async def get_github_sync_log(
+    limit: int = Query(default=50, ge=1, le=500),
+    token: Optional[dict] = Depends(auth.get_current_token)
+):
+    """Get the GitHub sync log (status updates sent to issues)."""
+    loki_dir = _get_loki_dir()
+    sync_log = loki_dir / "github" / "synced.log"
+    entries: list[dict] = []
+
+    if sync_log.exists():
+        try:
+            lines = sync_log.read_text().strip().splitlines()
+            for line in lines[-limit:]:
+                parts = line.split(":", 1)
+                if len(parts) == 2:
+                    entries.append({"issue": parts[0], "status": parts[1]})
+        except Exception:
+            pass
+
+    return {"entries": entries, "total": len(entries)}
+
+
 # =============================================================================
 # Process Health / Watchdog API
 # =============================================================================

package/docs/INSTALLATION.md

@@ -2,7 +2,7 @@
 
 Complete installation instructions for all platforms and use cases.
 
-**Version:** v5.40.1
+**Version:** v5.42.0
 
 ---
 

package/mcp/__init__.py

@@ -21,4 +21,4 @@ try:
 except ImportError:
     __all__ = ['mcp']
 
-__version__ = '5.40.1'
+__version__ = '5.42.0'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loki-mode",
-  "version": "5.40.1",
+  "version": "5.42.0",
   "description": "Multi-agent autonomous startup system for Claude Code, Codex CLI, and Gemini CLI",
   "keywords": [
     "claude",

package/skills/github-integration.md

@@ -1,6 +1,6 @@
-# GitHub Integration (v5.25.0)
+# GitHub Integration (v5.41.0)
 
-**When:** Importing issues from GitHub, creating PRs, syncing task status
+**When:** Importing issues from GitHub, creating PRs, syncing task status back
 
 > **Requires:** `gh` CLI authenticated (`gh auth status`)
 
@@ -10,9 +10,13 @@
 
 | Action | Command | Result |
 |--------|---------|--------|
-| Import issues as tasks | `LOKI_GITHUB_IMPORT=true` | Fetches open issues, creates pending tasks |
+| Import issues as tasks | `loki start --github` or `LOKI_GITHUB_IMPORT=true` | Fetches open issues, creates pending tasks |
 | Create PR on completion | `LOKI_GITHUB_PR=true` | Auto-creates PR with task summaries |
-| Sync status back | `LOKI_GITHUB_SYNC=true` | Comments progress on source issues |
+| Sync status back | `LOKI_GITHUB_SYNC=true` | Comments progress on source issues (deduplicated) |
+| Manual sync | `loki github sync` | Sync completed tasks to GitHub now |
+| Export tasks | `loki github export` | Create GitHub issues from local tasks |
+| Manual PR | `loki github pr "feature name"` | Create PR from current work |
+| Check status | `loki github status` | Show config, sync history, imported count |
 | Import from URL | `LOKI_GITHUB_REPO=owner/repo` | Specify repo if not auto-detected |
 
 ---
@@ -167,13 +171,41 @@ LOKI_GITHUB_IMPORT=true \
 
 ---
 
-## Integration with Dashboard
+## CLI Commands
 
-The dashboard shows GitHub-sourced tasks with:
-- GitHub icon badge
-- Direct link to issue
-- Sync status indicator
-- "Import from GitHub" button (calls `gh issue list`)
+```bash
+# Check GitHub integration status
+loki github status
+
+# Sync completed task statuses back to GitHub issues
+loki github sync
+
+# Export local tasks as new GitHub issues
+loki github export
+
+# Create PR from completed work
+loki github pr "Add user authentication"
+```
+
+---
+
+## Dashboard API
+
+| Endpoint | Method | Description |
+|----------|--------|-------------|
+| `/api/github/status` | GET | Integration config, repo, sync count |
+| `/api/github/tasks` | GET | All GitHub-sourced tasks with sync status |
+| `/api/github/sync-log` | GET | History of status updates sent to issues |
+
+---
+
+## Sync Behavior
+
+- **On session start** (`LOKI_GITHUB_IMPORT=true`): Imports issues, posts "in_progress" comment
+- **After each iteration** (`LOKI_GITHUB_SYNC=true`): Syncs completed GitHub tasks
+- **On session end** (`LOKI_GITHUB_PR=true`): Final sync + creates PR with `Closes #N` references
+- **Deduplication**: Sync log at `.loki/github/synced.log` prevents duplicate comments
+- **Manual**: `loki github sync` can be run anytime outside a session
 
 ---
 
@@ -215,4 +247,4 @@ gh repo set-default owner/repo
 
 ---
 
-**v5.25.0 | GitHub Integration | ~100 lines**
+**v5.41.0 | GitHub Integration (full sync-back) | ~250 lines**