loki-mode 6.3.1 → 6.5.0

package/autonomy/run.sh

@@ -2642,33 +2642,52 @@ init_loki_dir() {
     # Clean up stale control files ONLY if no other session is running
     # Deleting these while another session is active would destroy its signals
     # Use flock if available to avoid TOCTOU race
-    local lock_file=".loki/session.lock"
-    local can_cleanup=false
-
-    if command -v flock >/dev/null 2>&1 && [ -f "$lock_file" ]; then
-        # Try non-blocking lock - if we get it, no other session is running
-        {
-            if flock -n 201 2>/dev/null; then
+    #
+    # Per-session locking (v6.4.0): When LOKI_SESSION_ID is set, only clean up
+    # that session's files. Global control files (PAUSE/STOP) are only cleaned
+    # when NO sessions are active.
+    local lock_file can_cleanup=false
+
+    if [ -n "${LOKI_SESSION_ID:-}" ]; then
+        # Per-session: check only this session's lock
+        lock_file=".loki/sessions/${LOKI_SESSION_ID}/session.lock"
+        local session_pid_file=".loki/sessions/${LOKI_SESSION_ID}/loki.pid"
+        if command -v flock >/dev/null 2>&1 && [ -f "$lock_file" ]; then
+            { if flock -n 201 2>/dev/null; then can_cleanup=true; fi } 201>"$lock_file"
+        else
+            local existing_pid=""
+            if [ -f "$session_pid_file" ]; then
+                existing_pid=$(cat "$session_pid_file" 2>/dev/null)
+            fi
+            if [ -z "$existing_pid" ] || ! kill -0 "$existing_pid" 2>/dev/null; then
                 can_cleanup=true
             fi
-        } 201>"$lock_file"
+        fi
+        if [ "$can_cleanup" = "true" ]; then
+            rm -f "$session_pid_file" 2>/dev/null
+            rm -f "$lock_file" 2>/dev/null
+        fi
     else
-        # Fallback: check PID file
-        local existing_pid=""
-        if [ -f ".loki/loki.pid" ]; then
-            existing_pid=$(cat ".loki/loki.pid" 2>/dev/null)
+        # Global: original behavior
+        lock_file=".loki/session.lock"
+        if command -v flock >/dev/null 2>&1 && [ -f "$lock_file" ]; then
+            { if flock -n 201 2>/dev/null; then can_cleanup=true; fi } 201>"$lock_file"
+        else
+            local existing_pid=""
+            if [ -f ".loki/loki.pid" ]; then
+                existing_pid=$(cat ".loki/loki.pid" 2>/dev/null)
+            fi
+            if [ -z "$existing_pid" ] || ! kill -0 "$existing_pid" 2>/dev/null; then
+                can_cleanup=true
+            fi
         fi
-        if [ -z "$existing_pid" ] || ! kill -0 "$existing_pid" 2>/dev/null; then
-            can_cleanup=true
+        if [ "$can_cleanup" = "true" ]; then
+            rm -f .loki/PAUSE .loki/STOP .loki/HUMAN_INPUT.md 2>/dev/null
+            rm -f .loki/loki.pid 2>/dev/null
+            rm -f .loki/session.lock 2>/dev/null
         fi
     fi
 
-    if [ "$can_cleanup" = "true" ]; then
-        rm -f .loki/PAUSE .loki/STOP .loki/HUMAN_INPUT.md 2>/dev/null
-        rm -f .loki/loki.pid 2>/dev/null
-        rm -f .loki/session.lock 2>/dev/null
-    fi
-
     mkdir -p .loki/{state,queue,messages,logs,config,prompts,artifacts,scripts}
     mkdir -p .loki/queue
     mkdir -p .loki/state/checkpoints
@@ -7415,12 +7434,13 @@ run_autonomous() {
         audit_agent_action "cli_invoke" "Starting iteration $ITERATION_COUNT" "provider=${PROVIDER_NAME:-claude},tier=$CURRENT_TIER"
 
         # Provider-specific invocation with dynamic tier selection
+        local exit_code=0
         case "${PROVIDER_NAME:-claude}" in
             claude)
                 # Claude: Full features with stream-json output and agent tracking
                 # Uses dynamic tier for model selection based on RARV phase
                 # Pass tier to Python via environment for dashboard display
-                LOKI_CURRENT_MODEL="$tier_param" \
+                { LOKI_CURRENT_MODEL="$tier_param" \
                 claude --dangerously-skip-permissions --model "$tier_param" -p "$prompt" \
             --output-format stream-json --verbose 2>&1 | \
             tee -a "$log_file" "$agent_log" | \
@@ -7628,7 +7648,7 @@ if __name__ == "__main__":
     except BrokenPipeError:
         sys.exit(0)
 '
-                local exit_code=${PIPESTATUS[0]}
+                } && exit_code=0 || exit_code=$?
                 ;;
 
             codex)
@@ -7636,10 +7656,10 @@ if __name__ == "__main__":
                 # Uses positional prompt after exec subcommand
                 # Note: Effort is set via env var, not CLI flag
                 # Uses dynamic tier from RARV phase (tier_param already set above)
-                CODEX_MODEL_REASONING_EFFORT="$tier_param" \
+                { CODEX_MODEL_REASONING_EFFORT="$tier_param" \
                 codex exec --full-auto \
-                    "$prompt" 2>&1 | tee -a "$log_file" "$agent_log"
-                local exit_code=${PIPESTATUS[0]}
+                    "$prompt" 2>&1 | tee -a "$log_file" "$agent_log"; \
+                } && exit_code=0 || exit_code=$?
                 ;;
 
             gemini)
@@ -7653,8 +7673,8 @@ if __name__ == "__main__":
                 # Try primary model, fallback on rate limit
                 local tmp_output
                 tmp_output=$(mktemp)
-                gemini --approval-mode=yolo --model "$model" "$prompt" < /dev/null 2>&1 | tee "$tmp_output" | tee -a "$log_file" "$agent_log"
-                local exit_code=${PIPESTATUS[0]}
+                { gemini --approval-mode=yolo --model "$model" "$prompt" < /dev/null 2>&1 | tee "$tmp_output" | tee -a "$log_file" "$agent_log"; \
+                } && exit_code=0 || exit_code=$?
 
                 if [[ $exit_code -ne 0 ]] && grep -qiE "(rate.?limit|429|quota|resource.?exhausted)" "$tmp_output"; then
                     log_warn "Rate limit hit on $model, falling back to $fallback"
@@ -8093,6 +8113,10 @@ cleanup() {
         stop_status_monitor
         kill_all_registered
         rm -f "$loki_dir/loki.pid" 2>/dev/null
+        # Clean up per-session PID file if running with session ID
+        if [ -n "${LOKI_SESSION_ID:-}" ]; then
+            rm -f "$loki_dir/sessions/${LOKI_SESSION_ID}/loki.pid" 2>/dev/null
+        fi
         if [ -f "$loki_dir/session.json" ]; then
             _LOKI_SESSION_FILE="$loki_dir/session.json" python3 -c "
 import json, os
@@ -8120,13 +8144,18 @@ except (json.JSONDecodeError, OSError): pass
         stop_dashboard
         stop_status_monitor
         kill_all_registered
-        rm -f .loki/loki.pid .loki/PAUSE 2>/dev/null
+        rm -f "$loki_dir/loki.pid" "$loki_dir/PAUSE" 2>/dev/null
+        # Clean up per-session PID file if running with session ID
+        if [ -n "${LOKI_SESSION_ID:-}" ]; then
+            rm -f "$loki_dir/sessions/${LOKI_SESSION_ID}/loki.pid" 2>/dev/null
+        fi
         # Mark session.json as stopped
-        if [ -f ".loki/session.json" ]; then
-            python3 -c "
-import json
+        if [ -f "$loki_dir/session.json" ]; then
+            _LOKI_SESSION_FILE="$loki_dir/session.json" python3 -c "
+import json, os
+sf = os.environ['_LOKI_SESSION_FILE']
 try:
-    with open('.loki/session.json', 'r+') as f:
+    with open(sf, 'r+') as f:
         d = json.load(f); d['status'] = 'stopped'
         f.seek(0); f.truncate(); json.dump(d, f)
 except (json.JSONDecodeError, OSError): pass
@@ -8325,7 +8354,13 @@ main() {
         mkdir -p .loki/logs
 
         local log_file=".loki/logs/background-$(date +%Y%m%d-%H%M%S).log"
-        local pid_file=".loki/loki.pid"
+        local pid_file
+        if [ -n "${LOKI_SESSION_ID:-}" ]; then
+            mkdir -p ".loki/sessions/${LOKI_SESSION_ID}"
+            pid_file=".loki/sessions/${LOKI_SESSION_ID}/loki.pid"
+        else
+            pid_file=".loki/loki.pid"
+        fi
         local project_path=$(pwd)
         local project_name=$(basename "$project_path")
 
@@ -8419,12 +8454,22 @@ main() {
     # Initialize session continuity file with empty template
     update_continuity
 
-    # Session lock: prevent concurrent sessions on same repo
-    # Use flock for atomic locking to prevent TOCTOU race conditions
-    local pid_file=".loki/loki.pid"
-    local lock_file=".loki/session.lock"
+    # Session lock: prevent concurrent sessions
+    # Per-session locking (v6.4.0): LOKI_SESSION_ID enables multiple concurrent
+    # sessions (e.g., loki run 52 -d && loki run 54 -d). Each session gets its
+    # own PID/lock files under .loki/sessions/<id>/.
+    # Without LOKI_SESSION_ID, the global .loki/loki.pid lock is used (single session).
+    local pid_file lock_file
+    if [ -n "${LOKI_SESSION_ID:-}" ]; then
+        mkdir -p ".loki/sessions/${LOKI_SESSION_ID}"
+        pid_file=".loki/sessions/${LOKI_SESSION_ID}/loki.pid"
+        lock_file=".loki/sessions/${LOKI_SESSION_ID}/session.lock"
+    else
+        pid_file=".loki/loki.pid"
+        lock_file=".loki/session.lock"
+    fi
 
-    # Try to acquire exclusive lock with flock (if available)
+    # Use flock for atomic locking to prevent TOCTOU race conditions
     if command -v flock >/dev/null 2>&1; then
         # Create lock file
         touch "$lock_file"
@@ -8435,8 +8480,13 @@ main() {
 
         # Try to acquire exclusive lock (non-blocking)
         if ! flock -n 200 2>/dev/null; then
-            log_error "Another Loki session is already running (locked)"
-            log_error "Stop it first with: loki stop"
+            if [ -n "${LOKI_SESSION_ID:-}" ]; then
+                log_error "Session '${LOKI_SESSION_ID}' is already running (locked)"
+                log_error "Stop it first with: loki stop ${LOKI_SESSION_ID}"
+            else
+                log_error "Another Loki session is already running (locked)"
+                log_error "Stop it first with: loki stop"
+            fi
             exit 1
         fi
 
@@ -8446,8 +8496,13 @@ main() {
             existing_pid=$(cat "$pid_file" 2>/dev/null)
             # Skip if it's our own PID or parent PID (background mode writes PID before child starts)
             if [ -n "$existing_pid" ] && [ "$existing_pid" != "$$" ] && [ "$existing_pid" != "$PPID" ] && kill -0 "$existing_pid" 2>/dev/null; then
-                log_error "Another Loki session is already running (PID: $existing_pid)"
-                log_error "Stop it first with: loki stop"
+                if [ -n "${LOKI_SESSION_ID:-}" ]; then
+                    log_error "Session '${LOKI_SESSION_ID}' is already running (PID: $existing_pid)"
+                    log_error "Stop it first with: loki stop ${LOKI_SESSION_ID}"
+                else
+                    log_error "Another Loki session is already running (PID: $existing_pid)"
+                    log_error "Stop it first with: loki stop"
+                fi
                 exit 1
             fi
         fi
@@ -8459,8 +8514,13 @@ main() {
             existing_pid=$(cat "$pid_file" 2>/dev/null)
             # Skip if it's our own PID or parent PID (background mode writes PID before child starts)
             if [ -n "$existing_pid" ] && [ "$existing_pid" != "$$" ] && [ "$existing_pid" != "$PPID" ] && kill -0 "$existing_pid" 2>/dev/null; then
-                log_error "Another Loki session is already running (PID: $existing_pid)"
-                log_error "Stop it first with: loki stop"
+                if [ -n "${LOKI_SESSION_ID:-}" ]; then
+                    log_error "Session '${LOKI_SESSION_ID}' is already running (PID: $existing_pid)"
+                    log_error "Stop it first with: loki stop ${LOKI_SESSION_ID}"
+                else
+                    log_error "Another Loki session is already running (PID: $existing_pid)"
+                    log_error "Stop it first with: loki stop"
+                fi
                 exit 1
             fi
         fi
@@ -8468,6 +8528,10 @@ main() {
 
     # Write PID file for ALL modes (foreground + background)
     echo "$$" > "$pid_file"
+    # Store session ID in state for dashboard/status visibility
+    if [ -n "${LOKI_SESSION_ID:-}" ]; then
+        echo "${LOKI_SESSION_ID}" > ".loki/sessions/${LOKI_SESSION_ID}/session_id"
+    fi
 
     # Initialize PID registry and clean up orphans from previous sessions
     init_pid_registry
@@ -8674,13 +8738,19 @@ main() {
     fi
     stop_dashboard
     stop_status_monitor
-    rm -f .loki/loki.pid 2>/dev/null
+    local loki_dir="${TARGET_DIR:-.}/.loki"
+    rm -f "$loki_dir/loki.pid" 2>/dev/null
+    # Clean up per-session PID file if running with session ID
+    if [ -n "${LOKI_SESSION_ID:-}" ]; then
+        rm -f "$loki_dir/sessions/${LOKI_SESSION_ID}/loki.pid" 2>/dev/null
+    fi
     # Mark session.json as stopped
-    if [ -f ".loki/session.json" ]; then
-        python3 -c "
-import json
+    if [ -f "$loki_dir/session.json" ]; then
+        _LOKI_SESSION_FILE="$loki_dir/session.json" python3 -c "
+import json, os
+sf = os.environ['_LOKI_SESSION_FILE']
 try:
-    with open('.loki/session.json', 'r+') as f:
+    with open(sf, 'r+') as f:
         d = json.load(f); d['status'] = 'stopped'
         f.seek(0); f.truncate(); json.dump(d, f)
 except (json.JSONDecodeError, OSError): pass

package/autonomy/sandbox.sh

@@ -68,28 +68,32 @@ PROMPT_INJECTION_ENABLED="${LOKI_PROMPT_INJECTION:-false}"
 
 # Preset definitions: "host_path:container_path:mode"
 # Container runs as user 'loki' (UID 1000), so mount to /home/loki/
-declare -A DOCKER_MOUNT_PRESETS
-DOCKER_MOUNT_PRESETS=(
-    # Note: gh and git are also hardcoded in start_sandbox() defaults
-    [gh]="$HOME/.config/gh:/home/loki/.config/gh:ro"
-    [git]="$HOME/.gitconfig:/home/loki/.gitconfig:ro"
-    [ssh]="$HOME/.ssh/known_hosts:/home/loki/.ssh/known_hosts:ro"
-    [aws]="$HOME/.aws:/home/loki/.aws:ro"
-    [azure]="$HOME/.azure:/home/loki/.azure:ro"
-    [kube]="$HOME/.kube:/home/loki/.kube:ro"
-    [terraform]="$HOME/.terraform.d:/home/loki/.terraform.d:ro"
-    [gcloud]="$HOME/.config/gcloud:/home/loki/.config/gcloud:ro"
-    [npm]="$HOME/.npmrc:/home/loki/.npmrc:ro"
-)
+# Uses functions instead of declare -A for bash 3.2 compatibility (macOS default)
+_get_mount_preset() {
+    case "$1" in
+        gh)        echo "$HOME/.config/gh:/home/loki/.config/gh:ro" ;;
+        git)       echo "$HOME/.gitconfig:/home/loki/.gitconfig:ro" ;;
+        ssh)       echo "$HOME/.ssh/known_hosts:/home/loki/.ssh/known_hosts:ro" ;;
+        aws)       echo "$HOME/.aws:/home/loki/.aws:ro" ;;
+        azure)     echo "$HOME/.azure:/home/loki/.azure:ro" ;;
+        kube)      echo "$HOME/.kube:/home/loki/.kube:ro" ;;
+        terraform) echo "$HOME/.terraform.d:/home/loki/.terraform.d:ro" ;;
+        gcloud)    echo "$HOME/.config/gcloud:/home/loki/.config/gcloud:ro" ;;
+        npm)       echo "$HOME/.npmrc:/home/loki/.npmrc:ro" ;;
+        *)         echo "" ;;
+    esac
+}
 
 # Environment variables auto-passed per preset (comma-separated)
-declare -A DOCKER_ENV_PRESETS
-DOCKER_ENV_PRESETS=(
-    [aws]="AWS_REGION,AWS_PROFILE,AWS_DEFAULT_REGION"
-    [azure]="AZURE_SUBSCRIPTION_ID,AZURE_TENANT_ID"
-    [gcloud]="GOOGLE_PROJECT,GOOGLE_REGION,GCLOUD_PROJECT"
-    [terraform]="TF_VAR_*"
-)
+_get_env_preset() {
+    case "$1" in
+        aws)       echo "AWS_REGION,AWS_PROFILE,AWS_DEFAULT_REGION" ;;
+        azure)     echo "AZURE_SUBSCRIPTION_ID,AZURE_TENANT_ID" ;;
+        gcloud)    echo "GOOGLE_PROJECT,GOOGLE_REGION,GCLOUD_PROJECT" ;;
+        terraform) echo "TF_VAR_*" ;;
+        *)         echo "" ;;
+    esac
+}
 
 #===============================================================================
 # Utility Functions
@@ -836,7 +840,8 @@ except: pass
         while IFS= read -r name; do
             [[ -z "$name" ]] && continue
 
-            local preset_value="${DOCKER_MOUNT_PRESETS[$name]:-}"
+            local preset_value
+            preset_value="$(_get_mount_preset "$name")"
             if [[ -z "$preset_value" ]]; then
                 log_warn "Unknown Docker mount preset: $name"
                 continue
@@ -861,7 +866,8 @@ except: pass
             fi
 
             # Add associated env vars
-            local env_list="${DOCKER_ENV_PRESETS[$name]:-}"
+            local env_list
+            env_list="$(_get_env_preset "$name")"
             if [[ -n "$env_list" ]]; then
                 IFS=',' read -ra env_names <<< "$env_list"
                 local env_name

package/autonomy/telemetry.sh

@@ -52,17 +52,30 @@ loki_telemetry() {
     os_name=$(uname -s 2>/dev/null || echo "unknown")
     arch=$(uname -m 2>/dev/null || echo "unknown")
 
-    # Build properties from remaining args (key=value pairs)
-    local extra_props=""
+    # Build JSON payload safely using Python to prevent injection
+    local extra_args=""
     for arg in "$@"; do
-        local key="${arg%%=*}"
-        local val="${arg#*=}"
-        extra_props="${extra_props},\"${key}\":\"${val}\""
+        extra_args="${extra_args}${extra_args:+ }${arg}"
     done
 
     local payload
-    payload=$(printf '{"api_key":"%s","event":"%s","distinct_id":"%s","properties":{"os":"%s","arch":"%s","version":"%s","channel":"%s"%s}}' \
-        "$LOKI_POSTHOG_KEY" "$event" "$distinct_id" "$os_name" "$arch" "$version" "$channel" "$extra_props")
+    payload=$(python3 -c "
+import json, sys
+props = {'os': sys.argv[1], 'arch': sys.argv[2], 'version': sys.argv[3], 'channel': sys.argv[4]}
+for arg in sys.argv[5:]:
+    if '=' in arg:
+        k, v = arg.split('=', 1)
+        props[k] = v
+print(json.dumps({'api_key': '$LOKI_POSTHOG_KEY', 'event': sys.argv[5] if len(sys.argv) > 5 else '', 'distinct_id': '$distinct_id', 'properties': props}))
+" "$os_name" "$arch" "$version" "$channel" $extra_args 2>/dev/null) || return 0
+    # Re-inject event and distinct_id properly
+    payload=$(python3 -c "
+import json, sys
+d = json.loads(sys.argv[1])
+d['event'] = sys.argv[2]
+d['distinct_id'] = sys.argv[3]
+print(json.dumps(d))
+" "$payload" "$event" "$distinct_id" 2>/dev/null) || return 0
 
     (curl -sS --max-time 3 -X POST "${LOKI_POSTHOG_HOST}/capture/" \
         -H "Content-Type: application/json" \

package/dashboard/__init__.py

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

package/dashboard/migration_engine.py

@@ -886,7 +886,7 @@ Summary: {summary}
             if len(entries) > 50:
                 header = entries[0]
                 recent = entries[-50:]
-                content = header + "\n## Session:".join(recent)
+                content = header + "\n## Session:" + "\n## Session:".join(recent)
             else:
                 content = existing
             content += entry

package/dashboard/server.py

@@ -203,6 +203,14 @@ class TaskResponse(BaseModel):
         from_attributes = True
 
 
+class SessionInfo(BaseModel):
+    """Info about a single running session."""
+    session_id: str
+    pid: int
+    status: str = "running"
+    log_file: str = ""
+
+
 class StatusResponse(BaseModel):
     """Schema for system status response."""
     status: str
@@ -219,6 +227,8 @@ class StatusResponse(BaseModel):
     mode: str = ""
     provider: str = "claude"
     current_task: str = ""
+    # Concurrent sessions (v6.4.0)
+    sessions: list[SessionInfo] = []
 
 
 # WebSocket connection manager
@@ -521,11 +531,77 @@ async def get_status() -> StatusResponse:
         except Exception:
             pass
 
+    # Discover all running sessions (v6.4.0 - concurrent session support)
+    active_session_list: list[SessionInfo] = []
+
+    # Global session
+    if running:
+        try:
+            _global_pid = int(pid_str) if pid_str else 0
+        except (ValueError, TypeError):
+            _global_pid = 0
+        active_session_list.append(SessionInfo(
+            session_id="global",
+            pid=_global_pid,
+            status=status,
+        ))
+
+    # Per-session PIDs under .loki/sessions/<id>/
+    sessions_dir = loki_dir / "sessions"
+    if sessions_dir.is_dir():
+        for session_path in sessions_dir.iterdir():
+            if not session_path.is_dir():
+                continue
+            sid = session_path.name
+            spid_file = session_path / "loki.pid"
+            if spid_file.exists():
+                try:
+                    spid_str = spid_file.read_text().strip()
+                    spid = int(spid_str)
+                    os.kill(spid, 0)
+                    # Find log file if available
+                    log_path = ""
+                    log_candidate = loki_dir / "logs" / f"run-{sid}.log"
+                    if log_candidate.exists():
+                        log_path = str(log_candidate)
+                    active_session_list.append(SessionInfo(
+                        session_id=sid,
+                        pid=spid,
+                        status="running",
+                        log_file=log_path,
+                    ))
+                except (ValueError, OSError, ProcessLookupError):
+                    pass
+
+    # Legacy run-*.pid files
+    for rpf in loki_dir.glob("run-*.pid"):
+        sid = rpf.stem.removeprefix("run-")
+        # Skip if already found in sessions/
+        if any(s.session_id == sid for s in active_session_list):
+            continue
+        try:
+            rpid = int(rpf.read_text().strip())
+            os.kill(rpid, 0)
+            log_path = ""
+            log_candidate = loki_dir / "logs" / f"run-{sid}.log"
+            if log_candidate.exists():
+                log_path = str(log_candidate)
+            active_session_list.append(SessionInfo(
+                session_id=sid,
+                pid=rpid,
+                status="running",
+                log_file=log_path,
+            ))
+        except (ValueError, OSError, ProcessLookupError):
+            pass
+
+    total_active = len(active_session_list)
+
     return StatusResponse(
         status=status,
         version=version,
         uptime_seconds=uptime,
-        active_sessions=1 if running else 0,
+        active_sessions=total_active,
         running_agents=running_agents,
         pending_tasks=pending_tasks,
         database_connected=True,
@@ -535,6 +611,7 @@ async def get_status() -> StatusResponse:
         mode=mode,
         provider=provider,
         current_task=current_task,
+        sessions=active_session_list,
     )
 
 
@@ -1368,7 +1445,7 @@ async def query_audit_logs(
     action: Optional[str] = None,
     resource_type: Optional[str] = None,
     resource_id: Optional[str] = None,
-    limit: int = 100,
+    limit: int = Query(default=100, ge=1, le=1000),
     offset: int = 0,
 ):
     """
@@ -1488,7 +1565,7 @@ async def get_memory_summary():
 
 
 @app.get("/api/memory/episodes")
-async def list_episodes(limit: int = 50):
+async def list_episodes(limit: int = Query(default=50, ge=1, le=1000)):
     """List episodic memory entries."""
     ep_dir = _get_loki_dir() / "memory" / "episodic"
     episodes = []
@@ -1505,11 +1582,15 @@ async def list_episodes(limit: int = 50):
 @app.get("/api/memory/episodes/{episode_id}")
 async def get_episode(episode_id: str):
     """Get a specific episodic memory entry."""
-    ep_dir = _get_loki_dir() / "memory" / "episodic"
+    loki_dir = _get_loki_dir()
+    ep_dir = loki_dir / "memory" / "episodic"
     if not ep_dir.exists():
         raise HTTPException(status_code=404, detail="Episode not found")
     # Try direct filename match
     for f in ep_dir.glob("*.json"):
+        resolved = os.path.realpath(f)
+        if not resolved.startswith(os.path.realpath(str(loki_dir))):
+            raise HTTPException(status_code=403, detail="Access denied")
         try:
             data = json.loads(f.read_text())
             if data.get("id") == episode_id or f.stem == episode_id:
@@ -1560,10 +1641,14 @@ async def list_skills():
 @app.get("/api/memory/skills/{skill_id}")
 async def get_skill(skill_id: str):
     """Get a specific procedural skill."""
-    skills_dir = _get_loki_dir() / "memory" / "skills"
+    loki_dir = _get_loki_dir()
+    skills_dir = loki_dir / "memory" / "skills"
     if not skills_dir.exists():
         raise HTTPException(status_code=404, detail="Skill not found")
     for f in skills_dir.glob("*.json"):
+        resolved = os.path.realpath(f)
+        if not resolved.startswith(os.path.realpath(str(loki_dir))):
+            raise HTTPException(status_code=403, detail="Access denied")
         try:
             data = json.loads(f.read_text())
             if data.get("id") == skill_id or f.stem == skill_id:
@@ -1633,6 +1718,7 @@ def _read_learning_signals(signal_type: Optional[str] = None, limit: int = 50) -
     (learning/emitter.py). Each file contains a single signal object with fields:
     id, type, source, action, timestamp, confidence, outcome, data, context.
     """
+    limit = min(limit, 1000)
     signals_dir = _get_loki_dir() / "learning" / "signals"
     if not signals_dir.exists() or not signals_dir.is_dir():
         return []
@@ -1752,7 +1838,7 @@ async def get_learning_signals(
     timeRange: str = "7d",
     signalType: Optional[str] = None,
     source: Optional[str] = None,
-    limit: int = 50,
+    limit: int = Query(default=50, ge=1, le=1000),
     offset: int = 0,
 ):
     """Get raw learning signals from both events.jsonl and learning signals directory."""
@@ -1957,7 +2043,7 @@ async def trigger_aggregation():
 
 
 @app.get("/api/learning/preferences")
-async def get_learning_preferences(limit: int = 50):
+async def get_learning_preferences(limit: int = Query(default=50, ge=1, le=1000)):
     """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"]
@@ -1969,7 +2055,7 @@ async def get_learning_preferences(limit: int = 50):
 
 
 @app.get("/api/learning/errors")
-async def get_learning_errors(limit: int = 50):
+async def get_learning_errors(limit: int = Query(default=50, ge=1, le=1000)):
     """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"]
@@ -1981,7 +2067,7 @@ async def get_learning_errors(limit: int = 50):
 
 
 @app.get("/api/learning/success")
-async def get_learning_success(limit: int = 50):
+async def get_learning_success(limit: int = Query(default=50, ge=1, le=1000)):
     """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"]
@@ -1993,7 +2079,7 @@ async def get_learning_success(limit: int = 50):
 
 
 @app.get("/api/learning/tools")
-async def get_tool_efficiency(limit: int = 50):
+async def get_tool_efficiency(limit: int = Query(default=50, ge=1, le=1000)):
     """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"]
@@ -2432,7 +2518,7 @@ async def get_council_state():
 
 
 @app.get("/api/council/verdicts")
-async def get_council_verdicts(limit: int = 20):
+async def get_council_verdicts(limit: int = Query(default=20, ge=1, le=1000)):
     """Get council vote history (decision log)."""
     state_file = _get_loki_dir() / "council" / "state.json"
     verdicts = []

package/docs/INSTALLATION.md

@@ -2,11 +2,11 @@
 
 The flagship product of [Autonomi](https://www.autonomi.dev/). Complete installation instructions for all platforms and use cases.
 
-**Version:** v6.3.1
+**Version:** v6.5.0
 
 ---
 
-## What's New in v6.3.1
+## What's New in v6.5.0
 
 ### Dual-Mode Architecture (v6.0.0)
 - `loki run` command for direct autonomous execution

package/events/emit.sh

@@ -43,7 +43,7 @@ fi
 
 # JSON escape helper: handles \, ", and control characters
 json_escape() {
-    printf '%s' "$1" | sed 's/\\/\\\\/g; s/"/\\"/g; s/\t/\\t/g; s/\r/\\r/g' | tr -d '\n'
+    printf '%s' "$1" | sed 's/\\/\\\\/g; s/"/\\"/g; s/\t/\\t/g; s/\r/\\r/g' | awk '{if(NR>1) printf "\\n"; printf "%s", $0}'
 }
 
 # Build payload JSON