loki-mode 7.22.0 → 7.23.0

package/SKILL.md

@@ -3,7 +3,7 @@ name: loki-mode
 description: Autonomous spec-driven build system with a built-in trust layer. It does not call work done until it is verified (RARV-C closure loop, 11 quality gates, completion council, verified-completion evidence gate). Triggers on "Loki Mode". Takes a spec (PRD, GitHub issue, OpenAPI doc, etc.) to deployed product with minimal human intervention. Provider-agnostic. Requires --dangerously-skip-permissions flag.
 ---
 
-# Loki Mode v7.22.0
+# Loki Mode v7.23.0
 
 **You are an autonomous agent. You make decisions. You do not ask questions. You do not stop.**
 
@@ -383,4 +383,4 @@ See `CHANGELOG.md` entries [7.5.7], [7.5.8], [7.5.13] for the per-fix list and r
 
 ---
 
-**v7.22.0 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**
+**v7.23.0 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**

package/VERSION

@@ -1 +1 @@
-7.22.0
+7.23.0

package/autonomy/loki

@@ -579,7 +579,7 @@ show_help() {
     echo "  ci [opts]        CI/CD quality gate integration (--pr, --report, --github-comment)"
     echo "  test [opts]      AI-powered test generation (--file, --dir, --changed, --dry-run)"
     echo "  context [cmd]    Context window management (show|files|tools|add|clear)"
-    echo "  code [cmd]       Codebase intelligence (overview|symbols|deps|hotspots|diff)"
+    echo "  code [cmd]       Codebase intelligence (overview|symbols|deps|hotspots|diff|search)"
     echo "  report [opts]    Session report generator (--format text|markdown|html, --output)"
     echo "  share [opts]     Share session report as GitHub Gist (--private, --format)"
     echo "  proof [cmd]      Inspect/share proof-of-run artifacts (list|show|open|share)"
@@ -19712,6 +19712,7 @@ cmd_code() {
             echo "Subcommands:"
             echo "  overview    Generate workspace overview (file types, LOC, structure)"
             echo "  symbols     Search for symbols (functions, classes, variables)"
+            echo "  search      Hybrid grep + semantic codebase search"
             echo "  deps        Show dependency graph for a file or module"
             echo "  hotspots    Find code hotspots (most-changed files, complexity)"
             echo "  diff        Show colored diff of recent changes"
@@ -19720,6 +19721,9 @@ cmd_code() {
             echo "  loki code overview                  # Full codebase overview"
             echo "  loki code overview --silent          # Compact output"
             echo "  loki code symbols 'class.*Service'   # Find service classes"
+            echo "  loki code search 'rate limit backoff'   # Hybrid grep + semantic search"
+            echo "  loki code search 'council vote' --grep-only   # Lexical only"
+            echo "  loki code search 'memory retrieval' --semantic-only --top 15"
             echo "  loki code deps src/main.py           # Show dependencies"
             echo "  loki code hotspots --top 10          # Top 10 changed files"
             echo "  loki code diff                       # Colored diff of uncommitted changes"
@@ -19733,6 +19737,9 @@ cmd_code() {
         symbols)
             _code_symbols "$@"
             ;;
+        search)
+            _code_search "$@"
+            ;;
         deps)
             _code_deps "$@"
             ;;
@@ -19750,6 +19757,76 @@ cmd_code() {
     esac
 }
 
+# Hybrid codebase search: grep + semantic (ChromaDB) fused with RRF.
+# Delegates to tools/hybrid_search.py (needs python3.12 for chromadb). The
+# Python side handles the rg / grep / python-scan fallback and the grep-only
+# degradation when ChromaDB is unreachable, so this stays thin.
+_code_search() {
+    local query=""
+    local -a pyargs=()
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --grep-only) pyargs+=("--grep-only"); shift ;;
+            --semantic-only) pyargs+=("--semantic-only"); shift ;;
+            --budget) pyargs+=("--budget" "${2:-3000}"); shift 2 ;;
+            --top) pyargs+=("--top" "${2:-10}"); shift 2 ;;
+            --json) pyargs+=("--json"); shift ;;
+            -h|--help)
+                echo -e "${BOLD}loki code search${NC} - Hybrid grep + semantic codebase search"
+                echo ""
+                echo "Usage: loki code search \"<query>\" [flags]"
+                echo ""
+                echo "Flags:"
+                echo "  --grep-only        Lexical search only (skip semantic)"
+                echo "  --semantic-only    Semantic search only (skip grep)"
+                echo "  --budget N         Token budget for merged results (default 3000)"
+                echo "  --top N            Max results (default 10)"
+                echo "  --json             Output JSON"
+                echo ""
+                echo "Falls back to grep-only when ChromaDB is unreachable."
+                return 0
+                ;;
+            *)
+                if [[ -z "$query" ]]; then
+                    query="$1"
+                else
+                    query="$query $1"
+                fi
+                shift
+                ;;
+        esac
+    done
+
+    if [[ -z "$query" ]]; then
+        echo -e "${RED}Usage: loki code search \"<query>\" [--grep-only|--semantic-only] [--budget N] [--top N]${NC}"
+        return 1
+    fi
+
+    local script_dir hybrid py
+    script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+    hybrid="$script_dir/tools/hybrid_search.py"
+    if [[ ! -f "$hybrid" ]]; then
+        echo -e "${RED}hybrid_search.py not found at $hybrid${NC}"
+        return 1
+    fi
+
+    # chromadb requires python3.12 on this stack; fall back to python3 for the
+    # grep-only path if 3.12 is absent.
+    if [[ -x /opt/homebrew/bin/python3.12 ]]; then
+        py=/opt/homebrew/bin/python3.12
+    else
+        py="$(command -v python3 || true)"
+    fi
+    if [[ -z "$py" ]]; then
+        echo -e "${RED}python3 not found${NC}"
+        return 1
+    fi
+
+    # Safe array expansion: "${pyargs[@]}" triggers "unbound variable" under
+    # bash 3.2 (macOS default) + set -u when the array is empty (no flags).
+    "$py" "$hybrid" "$query" ${pyargs[@]+"${pyargs[@]}"}
+}
+
 _code_overview() {
     local silent=false
     local target_dir="."

package/autonomy/run.sh

@@ -781,6 +781,21 @@ MAX_PARALLEL_SESSIONS=${LOKI_MAX_PARALLEL_SESSIONS:-3}
 PARALLEL_TESTING=${LOKI_PARALLEL_TESTING:-true}
 PARALLEL_DOCS=${LOKI_PARALLEL_DOCS:-true}
 
+# Dynamic resource-aware session concurrency (Release 3, slice 3).
+# DEFAULT OFF: when LOKI_DYNAMIC_CONCURRENCY is unset, effective_session_cap()
+# returns exactly MAX_PARALLEL_SESSIONS, so behavior is identical to before.
+# Opt in with LOKI_DYNAMIC_CONCURRENCY=1 to scale the session cap down when
+# system CPU or memory is under pressure (read from .loki/state/resources.json).
+DYNAMIC_CONCURRENCY=${LOKI_DYNAMIC_CONCURRENCY:-0}
+# Optional higher ceiling on capable machines. Only takes effect with dynamic
+# concurrency enabled; still resource-gated. Defaults to MAX_PARALLEL_SESSIONS.
+MAX_PARALLEL_SESSIONS_CEILING=${LOKI_MAX_PARALLEL_SESSIONS_CEILING:-$MAX_PARALLEL_SESSIONS}
+# Usage thresholds (percent). At/above CPU or MEM threshold the cap is halved.
+CONCURRENCY_CPU_THRESHOLD=${LOKI_CONCURRENCY_CPU_THRESHOLD:-85}
+CONCURRENCY_MEM_THRESHOLD=${LOKI_CONCURRENCY_MEM_THRESHOLD:-85}
+# Critical threshold (percent). At/above this the cap is forced to 1.
+CONCURRENCY_CRITICAL_THRESHOLD=${LOKI_CONCURRENCY_CRITICAL_THRESHOLD:-95}
+
 # Gate Escalation Ladder (v6.10.0)
 GATE_CLEAR_LIMIT=${LOKI_GATE_CLEAR_LIMIT:-3}
 GATE_ESCALATE_LIMIT=${LOKI_GATE_ESCALATE_LIMIT:-5}
@@ -2759,6 +2774,72 @@ remove_worktree() {
     log_info "Removed worktree: $stream_name"
 }
 
+# Compute the effective parallel-session cap for the current scheduling pass.
+# Default-off contract: when LOKI_DYNAMIC_CONCURRENCY is not "1" this echoes
+# exactly MAX_PARALLEL_SESSIONS with zero file reads and zero subprocesses, so
+# the spawn decision is byte-identical to the pre-feature behavior.
+# When enabled, it starts from the configured ceiling and scales DOWN based on
+# .loki/state/resources.json. All reads are best-effort: a missing, empty, or
+# unparseable file (or non-numeric values) leaves the cap at the ceiling. The
+# result is always clamped to the range [1, ceiling] and never exceeds it.
+effective_session_cap() {
+    # Fast default-off path: identical to today, no I/O, no subprocesses.
+    if [ "${DYNAMIC_CONCURRENCY:-0}" != "1" ]; then
+        echo "$MAX_PARALLEL_SESSIONS"
+        return 0
+    fi
+
+    # Ceiling is the upper bound when dynamic scaling is on.
+    local ceiling="${MAX_PARALLEL_SESSIONS_CEILING:-$MAX_PARALLEL_SESSIONS}"
+    # Guard against a non-numeric or sub-1 ceiling override.
+    case "$ceiling" in
+        ''|*[!0-9]*) ceiling="$MAX_PARALLEL_SESSIONS" ;;
+    esac
+    [ "$ceiling" -lt 1 ] 2>/dev/null && ceiling=1
+
+    local cap="$ceiling"
+    local resources_file=".loki/state/resources.json"
+
+    # No resource data -> best-effort, leave at ceiling.
+    if [ ! -f "$resources_file" ]; then
+        echo "$cap"
+        return 0
+    fi
+
+    # Read usage and status best-effort. Defaults keep the cap at the ceiling
+    # if the file is empty, malformed, or missing keys.
+    local cpu_usage mem_usage status
+    cpu_usage=$(python3 -c "import json; print(json.load(open('$resources_file')).get('cpu', {}).get('usage_percent', 0))" 2>/dev/null || echo "0")
+    mem_usage=$(python3 -c "import json; print(json.load(open('$resources_file')).get('memory', {}).get('usage_percent', 0))" 2>/dev/null || echo "0")
+    status=$(python3 -c "import json; print(json.load(open('$resources_file')).get('overall_status', 'ok'))" 2>/dev/null || echo "ok")
+
+    # usage_percent can be a float (e.g. 85.3). Reduce to an integer part for
+    # comparison and fall back to 0 if anything is non-numeric.
+    cpu_usage="${cpu_usage%%.*}"
+    mem_usage="${mem_usage%%.*}"
+    case "$cpu_usage" in ''|*[!0-9]*) cpu_usage=0 ;; esac
+    case "$mem_usage" in ''|*[!0-9]*) mem_usage=0 ;; esac
+
+    local crit="${CONCURRENCY_CRITICAL_THRESHOLD:-95}"
+    local cpu_thr="${CONCURRENCY_CPU_THRESHOLD:-85}"
+    local mem_thr="${CONCURRENCY_MEM_THRESHOLD:-85}"
+
+    if [ "$cpu_usage" -ge "$crit" ] || [ "$mem_usage" -ge "$crit" ]; then
+        # Critical pressure: drop to a single session.
+        cap=1
+    elif [ "$cpu_usage" -ge "$cpu_thr" ] || [ "$mem_usage" -ge "$mem_thr" ] || [ "$status" != "ok" ]; then
+        # Elevated pressure or a non-ok overall status: halve (integer floor).
+        cap=$(( ceiling / 2 ))
+    fi
+
+    # Clamp to [1, ceiling]. Never runaway, never zero.
+    [ "$cap" -lt 1 ] && cap=1
+    [ "$cap" -gt "$ceiling" ] && cap="$ceiling"
+
+    echo "$cap"
+    return 0
+}
+
 # Spawn a Claude session in a worktree
 spawn_worktree_session() {
     local stream_name="$1"
@@ -2778,9 +2859,11 @@ spawn_worktree_session() {
         fi
     done
 
-    if [ "$active_count" -ge "$MAX_PARALLEL_SESSIONS" ]; then
+    local session_cap
+    session_cap=$(effective_session_cap)
+    if [ "$active_count" -ge "$session_cap" ]; then
         # BUG-PAR-014: Max-sessions rejection queues spawn for retry
-        log_warn "Max parallel sessions reached ($MAX_PARALLEL_SESSIONS). Queuing $stream_name for retry."
+        log_warn "Max parallel sessions reached ($session_cap). Queuing $stream_name for retry."
         mkdir -p "${TARGET_DIR:-.}/.loki/signals"
         echo "{\"stream\":\"$stream_name\",\"task\":\"$(echo "$task_prompt" | head -c 200)\",\"timestamp\":\"$(date -u +%Y-%m-%dT%H:%M:%SZ)\"}" \
             > "${TARGET_DIR:-.}/.loki/signals/SPAWN_QUEUED_${stream_name}"
@@ -3212,7 +3295,9 @@ run_parallel_orchestrator() {
                 ((active_count++))
             fi
         done
-        if [ "$active_count" -lt "$MAX_PARALLEL_SESSIONS" ]; then
+        local _session_cap
+        _session_cap=$(effective_session_cap)
+        if [ "$active_count" -lt "$_session_cap" ]; then
             for queued_signal in "${TARGET_DIR:-.}"/.loki/signals/SPAWN_QUEUED_*; do
                 [ -f "$queued_signal" ] || continue
                 local queued_stream

package/dashboard/__init__.py

@@ -7,7 +7,7 @@ Modules:
     control: Session control API (start/stop/pause/resume)
 """
 
-__version__ = "7.22.0"
+__version__ = "7.23.0"
 
 # 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/). Loki Mode is a spec-driven autonomous builder with a built-in trust layer that takes any spec to a deployed product and verifies completion with evidence (quality gates plus a completion council), not just a "done" claim. Complete installation instructions for all platforms and use cases.
 
-**Version:** v7.22.0
+**Version:** v7.23.0
 
 ---
 

package/loki-ts/dist/loki.js

@@ -1,5 +1,5 @@
 // @bun
-var f8=Object.defineProperty;var u8=($)=>$;function c8($,Q){this[$]=u8.bind(null,Q)}var g=($,Q)=>{for(var Z in Q)f8($,Z,{get:Q[Z],enumerable:!0,configurable:!0,set:c8.bind(Q,Z)})};var k=($,Q)=>()=>($&&(Q=$($=0)),Q);var X1=import.meta.require;var F$={};g(F$,{lokiDir:()=>P,homeLokiDir:()=>o1,findRepoRootForVersion:()=>d1,REPO_ROOT:()=>f});import{resolve as n,dirname as l1}from"path";import{fileURLToPath as p8}from"url";import{existsSync as L1}from"fs";import{homedir as l8}from"os";function d8(){let $=j$;for(let Q=0;Q<6;Q++){if(L1(n($,"VERSION"))&&L1(n($,"autonomy/run.sh")))return $;let Z=l1($);if(Z===$)break;$=Z}return n(j$,"..","..","..")}function d1($){let Q=$;for(let Z=0;Z<6;Z++){if(L1(n(Q,"VERSION"))&&L1(n(Q,"autonomy/run.sh")))return Q;let z=l1(Q);if(z===Q)break;Q=z}return n($,"..","..","..")}function P(){return process.env.LOKI_DIR??n(process.cwd(),".loki")}function o1(){return n(l8(),".loki")}var j$,f;var y=k(()=>{j$=l1(p8(import.meta.url));f=d8()});import{readFileSync as o8}from"fs";import{resolve as n8,dirname as a8}from"path";import{fileURLToPath as s8}from"url";function k1(){if($1!==null)return $1;let $="7.22.0";if(typeof $==="string"&&$.length>0)return $1=$,$1;try{let Q=a8(s8(import.meta.url)),Z=d1(Q);$1=o8(n8(Z,"VERSION"),"utf-8").trim()}catch{$1="unknown"}return $1}var $1=null;var n1=k(()=>{y()});var E$={};g(E$,{runOrThrow:()=>t8,run:()=>j,commandVersion:()=>i8,commandExists:()=>v,ShellError:()=>a1});async function j($,Q={}){let Z=Bun.spawn({cmd:[...$],stdout:"pipe",stderr:"pipe",env:Q.env?{...process.env,...Q.env}:process.env,cwd:Q.cwd}),z,K;if(Q.timeoutMs&&Q.timeoutMs>0)z=setTimeout(()=>{try{Z.kill("SIGTERM")}catch{}K=setTimeout(()=>{try{Z.kill("SIGKILL")}catch{}},2000)},Q.timeoutMs);try{let[H,X,q]=await Promise.all([new Response(Z.stdout).text(),new Response(Z.stderr).text(),Z.exited]);return{stdout:H,stderr:X,exitCode:q}}finally{if(z)clearTimeout(z);if(K)clearTimeout(K)}}async function t8($,Q={}){let Z=await j($,Q);if(Z.exitCode!==0)throw new a1(`command failed (${Z.exitCode}): ${$.join(" ")}`,Z.exitCode,Z.stdout,Z.stderr);return Z}async function v($){let Q=r8($),Z=await j(["sh","-c",`command -v ${Q}`],{timeoutMs:5000});if(Z.exitCode===0)return Z.stdout.trim()||null;return null}function r8($){if(!/^[A-Za-z0-9._/-]+$/.test($))throw Error(`refused to shell-escape suspect token: ${$}`);return $}async function i8($,Q="--version"){if(!await v($))return null;let z=await j([$,Q],{timeoutMs:5000});if(z.exitCode!==0)return null;return((z.stdout||z.stderr).split(/\r?\n/)[0]?.trim()??"")||null}var a1;var d=k(()=>{a1=class a1 extends Error{message;exitCode;stdout;stderr;constructor($,Q,Z,z){super($);this.message=$;this.exitCode=Q;this.stdout=Z;this.stderr=z;this.name="ShellError"}}});function a($){return e8?"":$}var e8,T,N,_,KZ,A,R,h,J;var c=k(()=>{e8=(process.env.NO_COLOR??"").length>0;T=a("\x1B[0;31m"),N=a("\x1B[0;32m"),_=a("\x1B[1;33m"),KZ=a("\x1B[0;34m"),A=a("\x1B[0;36m"),R=a("\x1B[1m"),h=a("\x1B[2m"),J=a("\x1B[0m")});import{existsSync as U7}from"fs";async function Q1(){if(B1!==void 0)return B1;let $="/opt/homebrew/bin/python3.12";if(U7($))return B1=$,$;let Q=await v("python3.12");if(Q)return B1=Q,Q;let Z=await v("python3");return B1=Z,Z}async function Z1($,Q={}){let Z=await Q1();if(!Z)return{stdout:"",stderr:"python3 not found",exitCode:127};return j([Z,"-c",$],Q)}var B1;var H1=k(()=>{d()});var d$={};g(d$,{runStatus:()=>N7});import{existsSync as b,readFileSync as q1,readdirSync as v$,statSync as f$}from"fs";import{resolve as D,basename as P7}from"path";import{homedir as L7}from"os";async function j7(){if(await v("jq"))return!0;return process.stdout.write(`${T}Error: jq is required but not installed.${J}
+var f8=Object.defineProperty;var u8=($)=>$;function c8($,Q){this[$]=u8.bind(null,Q)}var g=($,Q)=>{for(var Z in Q)f8($,Z,{get:Q[Z],enumerable:!0,configurable:!0,set:c8.bind(Q,Z)})};var k=($,Q)=>()=>($&&(Q=$($=0)),Q);var X1=import.meta.require;var F$={};g(F$,{lokiDir:()=>P,homeLokiDir:()=>o1,findRepoRootForVersion:()=>d1,REPO_ROOT:()=>f});import{resolve as n,dirname as l1}from"path";import{fileURLToPath as p8}from"url";import{existsSync as L1}from"fs";import{homedir as l8}from"os";function d8(){let $=j$;for(let Q=0;Q<6;Q++){if(L1(n($,"VERSION"))&&L1(n($,"autonomy/run.sh")))return $;let Z=l1($);if(Z===$)break;$=Z}return n(j$,"..","..","..")}function d1($){let Q=$;for(let Z=0;Z<6;Z++){if(L1(n(Q,"VERSION"))&&L1(n(Q,"autonomy/run.sh")))return Q;let z=l1(Q);if(z===Q)break;Q=z}return n($,"..","..","..")}function P(){return process.env.LOKI_DIR??n(process.cwd(),".loki")}function o1(){return n(l8(),".loki")}var j$,f;var y=k(()=>{j$=l1(p8(import.meta.url));f=d8()});import{readFileSync as o8}from"fs";import{resolve as n8,dirname as a8}from"path";import{fileURLToPath as s8}from"url";function k1(){if($1!==null)return $1;let $="7.23.0";if(typeof $==="string"&&$.length>0)return $1=$,$1;try{let Q=a8(s8(import.meta.url)),Z=d1(Q);$1=o8(n8(Z,"VERSION"),"utf-8").trim()}catch{$1="unknown"}return $1}var $1=null;var n1=k(()=>{y()});var E$={};g(E$,{runOrThrow:()=>t8,run:()=>j,commandVersion:()=>i8,commandExists:()=>v,ShellError:()=>a1});async function j($,Q={}){let Z=Bun.spawn({cmd:[...$],stdout:"pipe",stderr:"pipe",env:Q.env?{...process.env,...Q.env}:process.env,cwd:Q.cwd}),z,K;if(Q.timeoutMs&&Q.timeoutMs>0)z=setTimeout(()=>{try{Z.kill("SIGTERM")}catch{}K=setTimeout(()=>{try{Z.kill("SIGKILL")}catch{}},2000)},Q.timeoutMs);try{let[H,X,q]=await Promise.all([new Response(Z.stdout).text(),new Response(Z.stderr).text(),Z.exited]);return{stdout:H,stderr:X,exitCode:q}}finally{if(z)clearTimeout(z);if(K)clearTimeout(K)}}async function t8($,Q={}){let Z=await j($,Q);if(Z.exitCode!==0)throw new a1(`command failed (${Z.exitCode}): ${$.join(" ")}`,Z.exitCode,Z.stdout,Z.stderr);return Z}async function v($){let Q=r8($),Z=await j(["sh","-c",`command -v ${Q}`],{timeoutMs:5000});if(Z.exitCode===0)return Z.stdout.trim()||null;return null}function r8($){if(!/^[A-Za-z0-9._/-]+$/.test($))throw Error(`refused to shell-escape suspect token: ${$}`);return $}async function i8($,Q="--version"){if(!await v($))return null;let z=await j([$,Q],{timeoutMs:5000});if(z.exitCode!==0)return null;return((z.stdout||z.stderr).split(/\r?\n/)[0]?.trim()??"")||null}var a1;var d=k(()=>{a1=class a1 extends Error{message;exitCode;stdout;stderr;constructor($,Q,Z,z){super($);this.message=$;this.exitCode=Q;this.stdout=Z;this.stderr=z;this.name="ShellError"}}});function a($){return e8?"":$}var e8,T,N,_,KZ,A,R,h,J;var c=k(()=>{e8=(process.env.NO_COLOR??"").length>0;T=a("\x1B[0;31m"),N=a("\x1B[0;32m"),_=a("\x1B[1;33m"),KZ=a("\x1B[0;34m"),A=a("\x1B[0;36m"),R=a("\x1B[1m"),h=a("\x1B[2m"),J=a("\x1B[0m")});import{existsSync as U7}from"fs";async function Q1(){if(B1!==void 0)return B1;let $="/opt/homebrew/bin/python3.12";if(U7($))return B1=$,$;let Q=await v("python3.12");if(Q)return B1=Q,Q;let Z=await v("python3");return B1=Z,Z}async function Z1($,Q={}){let Z=await Q1();if(!Z)return{stdout:"",stderr:"python3 not found",exitCode:127};return j([Z,"-c",$],Q)}var B1;var H1=k(()=>{d()});var d$={};g(d$,{runStatus:()=>N7});import{existsSync as b,readFileSync as q1,readdirSync as v$,statSync as f$}from"fs";import{resolve as D,basename as P7}from"path";import{homedir as L7}from"os";async function j7(){if(await v("jq"))return!0;return process.stdout.write(`${T}Error: jq is required but not installed.${J}
 `),process.stdout.write(`Install with:
 `),process.stdout.write(`  brew install jq    (macOS)
 `),process.stdout.write(`  apt install jq     (Debian/Ubuntu)
@@ -787,4 +787,4 @@ Set LOKI_LEGACY_BASH=1 to force the bash CLI for every command.
 `),2}default:return process.stderr.write(`Unknown command: ${Q}
 `),process.stderr.write(v8),2}}g$();process.on("SIGINT",()=>process.exit(130));process.on("SIGTERM",()=>process.exit(143));var l3=await p3(Bun.argv.slice(2));process.exit(l3);
 
-//# debugId=BA6A18624E28A6CC64756E2164756E21
+//# debugId=54BA5C5C5E9F714F64756E2164756E21

package/mcp/__init__.py

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

package/mcp/server.py

@@ -22,6 +22,7 @@ import logging
 import threading
 import uuid
 from datetime import datetime, timezone
+from pathlib import Path
 from typing import Optional, List, Dict, Any
 
 # Add parent directory to path for imports
@@ -1517,6 +1518,67 @@ CHROMA_HOST = os.environ.get("LOKI_CHROMA_HOST", "localhost")
 CHROMA_PORT = int(os.environ.get("LOKI_CHROMA_PORT", "8100"))
 CHROMA_COLLECTION = os.environ.get("LOKI_CHROMA_COLLECTION", "loki-codebase")
 
+# Code-index freshness manifest (written by tools/index-codebase.py). Resolved
+# relative to the repo root the same way the indexer resolves it, so the two
+# agree on a single location. mcp/server.py -> parent.parent == repo root.
+_CODE_INDEX_REPO_ROOT = Path(__file__).resolve().parent.parent
+CODE_INDEX_MANIFEST_PATH = _CODE_INDEX_REPO_ROOT / ".loki" / "state" / "code-index-manifest.json"
+
+
+def _code_index_staleness() -> dict:
+    """Compare the code-index manifest mtimes against current files on disk.
+
+    Self-contained (no import of tools/index-codebase.py, which loads chromadb
+    at module top under a possibly-different Python). Mirrors the mtime
+    staleness pattern in memory/retrieval.py. A missing manifest degrades to
+    not-stale so the happy path on a fresh repo is unaffected.
+
+    Returns {"stale": bool, "stale_files": int}.
+    """
+    try:
+        data = json.loads(CODE_INDEX_MANIFEST_PATH.read_text())
+        files = data.get("files", {})
+        if not isinstance(files, dict) or not files:
+            return {"stale": False, "stale_files": 0}
+    except Exception:
+        return {"stale": False, "stale_files": 0}
+
+    stale = 0
+    for rel, entry in files.items():
+        abs_path = _CODE_INDEX_REPO_ROOT / rel
+        try:
+            if not abs_path.exists():
+                stale += 1
+            elif os.path.getmtime(abs_path) != entry.get("mtime"):
+                stale += 1
+        except OSError:
+            stale += 1
+    return {"stale": stale > 0, "stale_files": stale}
+
+
+def _maybe_autoreindex_code() -> None:
+    """Opt-in incremental re-index when the manifest is stale.
+
+    Gated behind LOKI_CODE_INDEX_AUTOREINDEX=1 because embeddings cost compute.
+    Default behavior is warn-if-stale (the tools just report the staleness
+    fields). Best-effort: never raises into the caller.
+    """
+    if os.environ.get("LOKI_CODE_INDEX_AUTOREINDEX", "0") != "1":
+        return
+    if not _code_index_staleness().get("stale"):
+        return
+    try:
+        import subprocess
+        indexer = _CODE_INDEX_REPO_ROOT / "tools" / "index-codebase.py"
+        py = "/opt/homebrew/bin/python3.12"
+        if not Path(py).exists():
+            py = sys.executable
+        subprocess.run([py, str(indexer), "--changed"],
+                       cwd=str(_CODE_INDEX_REPO_ROOT),
+                       capture_output=True, timeout=300)
+    except Exception as e:
+        logger.warning(f"Auto-reindex (LOKI_CODE_INDEX_AUTOREINDEX) failed: {e}")
+
 
 def _get_chroma_collection():
     """Get or create ChromaDB collection (lazy connection).
@@ -1581,6 +1643,10 @@ async def loki_code_search(
                                        'language': language, 'file_filter': file_filter,
                                        'type_filter': type_filter})
 
+    # Warn-if-stale (default) or opt-in auto-reindex before querying.
+    _maybe_autoreindex_code()
+    _staleness = _code_index_staleness()
+
     collection = _get_chroma_collection()
     if collection is None:
         return json.dumps({
@@ -1637,7 +1703,13 @@ async def loki_code_search(
 
         _emit_tool_event_async('loki_code_search', 'complete',
                                result_status='success', result_count=len(output))
-        return json.dumps({"query": query, "results": output, "total": len(output)})
+        return json.dumps({
+            "query": query,
+            "results": output,
+            "total": len(output),
+            "stale": _staleness["stale"],
+            "stale_files": _staleness["stale_files"],
+        })
 
     except Exception as e:
         logger.error(f"Code search failed: {e}")
@@ -1659,6 +1731,8 @@ async def loki_code_search_stats() -> str:
     Shows total chunks, files indexed, breakdown by language and type.
     Useful for verifying the index is up to date.
     """
+    _staleness = _code_index_staleness()
+
     collection = _get_chroma_collection()
     if collection is None:
         return json.dumps({"error": "ChromaDB not available"})
@@ -1674,6 +1748,8 @@ async def loki_code_search_stats() -> str:
                 "by_language": {},
                 "by_type": {},
                 "reindex_command": "python3.12 tools/index-codebase.py --reset",
+                "stale": _staleness["stale"],
+                "stale_files": _staleness["stale_files"],
             })
 
         results = collection.get(limit=count, include=["metadatas"])
@@ -1694,6 +1770,8 @@ async def loki_code_search_stats() -> str:
             "by_language": langs,
             "by_type": types,
             "reindex_command": "python3.12 tools/index-codebase.py --reset",
+            "stale": _staleness["stale"],
+            "stale_files": _staleness["stale_files"],
         })
     except Exception as e:
         logger.error(f"Code search stats failed: {e}")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loki-mode",
-  "version": "7.22.0",
+  "version": "7.23.0",
   "description": "Loki Mode by Autonomi. Autonomous spec-to-product system: takes a PRD, GitHub issue, OpenAPI/JSON/YAML, or one-line brief to a deployed app via the RARV-C closure loop with 11 quality gates. Provider-agnostic (Claude Code, OpenAI Codex, Cline, Aider).",
   "keywords": [
     "agent",

package/references/mcp-integration.md

@@ -147,6 +147,71 @@ See `skills/documentation.md` for documentation generation using Repowise.
 
 ---
 
+## Built-in Hybrid Codebase Search (loki_code_search)
+
+Loki Mode ships its own codebase search that does not require any third-party MCP
+server. It is exposed both as MCP tools (`loki_code_search`,
+`loki_code_search_stats`) and as a CLI subcommand (`loki code search`). It combines
+lexical and semantic retrieval over the indexed codebase:
+
+- Lexical: ripgrep / grep (with a python scan fallback)
+- Semantic: ChromaDB over the `loki-codebase` collection
+- Fusion: reciprocal rank fusion (RRF) merges the two ranked lists
+- Truncation: results are deduped by file:line and trimmed to a token budget
+  (greedy, highest fused score first)
+
+When ChromaDB or its docker container is unreachable, search degrades to grep-only
+so it still returns results instead of erroring. The implementation lives in
+`tools/hybrid_search.py`.
+
+### Index freshness and staleness reporting
+
+The semantic index is backed by a manifest at
+`.loki/state/code-index-manifest.json`. The MCP tools (`loki_code_search` and
+`loki_code_search_stats`) compare the manifest against the files on disk and report
+two fields in their JSON output:
+
+- `stale`: boolean, true when one or more indexed files have changed since the last
+  index
+- `stale_files`: count of changed files
+
+Staleness is computed from the manifest alone (no ChromaDB call), and a missing
+manifest degrades to not-stale so a fresh repo is unaffected.
+
+Default behavior is warn-if-stale: the tools report staleness but do not re-index.
+Set `LOKI_CODE_INDEX_AUTOREINDEX=1` to opt into an automatic incremental re-index
+before querying (off by default because embeddings cost compute). The incremental
+re-index is driven by `tools/index-codebase.py --changed`, which re-chunks only
+files whose mtime or sha1 differ from the manifest, upserts the new chunks, deletes
+orphaned chunk IDs for changed files, and drops chunks for files removed from disk.
+
+### CLI usage: `loki code search`
+
+```bash
+loki code search "rate limit backoff"            # hybrid grep + semantic
+loki code search "council vote" --grep-only      # lexical only
+loki code search "memory retrieval" --semantic-only --top 15
+loki code search "build prompt" --budget 4000    # widen the token budget
+loki code search "save state" --json             # machine-readable output
+```
+
+Flags (see `loki code search --help`):
+
+| Flag | Default | Effect |
+|------|---------|--------|
+| `--grep-only` | off | lexical search only (skip semantic) |
+| `--semantic-only` | off | semantic search only (skip grep) |
+| `--budget N` | 3000 | token budget for the merged result set |
+| `--top N` | 10 | maximum number of results |
+| `--json` | off | emit JSON instead of formatted output |
+
+`loki code search` is one of the `loki code` codebase-intelligence subcommands
+(alongside `overview`, `symbols`, `deps`, `hotspots`, and `diff`). It falls back to
+grep-only when ChromaDB is unreachable, and requires python3.12 for the semantic
+path because that is what the chromadb client needs on this stack.
+
+---
+
 ## MCP Configuration Location
 
 Claude Code reads MCP configuration from:

package/skills/00-index.md

@@ -107,6 +107,8 @@
 - Inter-stream communication via signals
 - Auto-merge completed features
 - Orchestrator state management
+- Supervisor / judge pattern (CONTINUE / COMPLETE / ESCALATE / PIVOT)
+- Dynamic resource-aware session concurrency (LOKI_DYNAMIC_CONCURRENCY)
 
 ### github-integration.md
 **When:** Working with GitHub issues, creating PRs, syncing status

package/skills/parallel-workflows.md

@@ -128,6 +128,102 @@ orchestrator_workflow:
 
 ---
 
+## Supervisor / Judge Pattern
+
+A supervisor (or judge) is a decision step the orchestrator runs at milestones to
+decide whether the parallel run should keep going, wrap up, ask a human, or change
+course. It is a pattern, not a separate daemon: the orchestrator already makes this
+call at completion checkpoints. The judge verbs below are adopted from Cursor's
+multi-agent learnings (see `references/cursor-learnings.md`).
+
+### When the supervisor runs
+
+- After a major milestone (a stream merges, a phase completes)
+- When workers report completion
+- When progress stalls (diminishing returns across iterations)
+- Under resource pressure, before deciding to spawn more sessions
+
+### Inputs and outputs
+
+```yaml
+supervisor:
+  inputs:
+    - Current state            # .loki/state/ for each worktree/stream
+    - Original goal            # the PRD / spec / brief
+    - Recent progress          # checklist deltas, merged streams, test results
+    - Resource consumption     # .loki/state/resources.json (CPU, memory, status)
+  outputs:
+    - CONTINUE   # more work needed; keep streams running
+    - COMPLETE   # goal achieved; move to cleanup
+    - ESCALATE   # human intervention needed; raise a PAUSE / handoff
+    - PIVOT      # current approach is not converging; change strategy
+```
+
+The closest implemented analog is the completion council (`council_should_stop()`
+in `autonomy/completion-council.sh`), which decides COMPLETE vs CONTINUE from
+evidence rather than a single self-report. The supervisor pattern extends that
+mental model to the parallel case: it also reads `.loki/state/resources.json` so a
+machine under load steers toward CONTINUE-with-fewer-sessions (or ESCALATE) instead
+of oversubscribing the host.
+
+### Resource state as input
+
+The orchestrator persists a best-effort snapshot to
+`.loki/state/resources.json` (CPU usage percent, memory usage percent, and an
+`overall_status`). The dynamic-concurrency logic below reads the same file, so the
+supervisor's "can I spawn more?" decision and the spawn cap stay consistent.
+
+---
+
+## Dynamic Resource-Aware Session Concurrency
+
+By default Loki Mode caps parallel Claude sessions at a fixed
+`LOKI_MAX_PARALLEL_SESSIONS` (default 3). Opt-in dynamic concurrency lets that cap
+scale DOWN under load instead of oversubscribing the machine. It only ever reduces
+the cap; it never raises it above the configured ceiling.
+
+`effective_session_cap()` (`autonomy/run.sh`) is the single source of truth:
+
+- Default off (`LOKI_DYNAMIC_CONCURRENCY` unset or not `1`): returns exactly
+  `LOKI_MAX_PARALLEL_SESSIONS` with no file reads and no subprocesses, so the spawn
+  decision is byte-identical to the pre-feature behavior.
+- Enabled: starts from `LOKI_MAX_PARALLEL_SESSIONS_CEILING` and reads
+  `.loki/state/resources.json`. At/above the CPU or memory threshold (default 85
+  percent), or when `overall_status` is not `ok`, it halves the cap. At/above the
+  critical threshold (default 95 percent) it forces the cap to 1. The result is
+  always clamped to `[1, ceiling]`. A missing, empty, or unparseable resources file
+  is treated as no-pressure and leaves the cap at the ceiling.
+
+### Env knobs (all read in `autonomy/run.sh`)
+
+```bash
+LOKI_DYNAMIC_CONCURRENCY=1            # opt in; default 0 (off = today's behavior)
+LOKI_MAX_PARALLEL_SESSIONS_CEILING=N # upper bound when dynamic is on;
+                                     #   default = LOKI_MAX_PARALLEL_SESSIONS (3)
+LOKI_CONCURRENCY_CPU_THRESHOLD=85    # CPU percent at/above which the cap halves
+LOKI_CONCURRENCY_MEM_THRESHOLD=85    # memory percent at/above which the cap halves
+LOKI_CONCURRENCY_CRITICAL_THRESHOLD=95  # CPU or memory percent at/above which
+                                        #   the cap is forced to 1
+```
+
+### Honest ceiling: dozens, not thousands
+
+Raising `LOKI_MAX_PARALLEL_SESSIONS_CEILING` is safe because the system
+auto-throttles under pressure, but the realistic target is dozens of adaptive
+concurrent sessions, not hundreds or thousands. Two hard limits cap the useful
+ceiling on a single host:
+
+- The 3-reviewer council is a serialization point: every non-trivial change funnels
+  through blind review before merge, so review throughput, not spawn count, sets the
+  end-to-end pace.
+- Local resources (CPU, memory, API rate limits, disk for worktrees) bound how many
+  Claude sessions a single developer machine can usefully run at once.
+
+So treat dynamic concurrency as a way to set a higher ceiling safely and let the
+host throttle down, not as a path to a thousand subagents.
+
+---
+
 ## Claude Session Per Worktree
 
 Each worktree runs an independent Claude session:

package/skills/quality-gates.md

@@ -110,6 +110,24 @@ LOKI_HANDOFF_MD=1          # write a structured handoff doc to
 Optional: `LOKI_AUTO_LEARNINGS_EPISODE=1` also writes the learning into
 the Python episodic memory layer via `memory.engine.save_episode`.
 
+## Other opt-in environment flags (Release 3)
+
+Two more default-off flags added for hybrid search and parallel concurrency.
+Both are no-ops when unset (behavior identical to before).
+
+```bash
+LOKI_DYNAMIC_CONCURRENCY=1       # scale the parallel-session cap DOWN under
+                                 # CPU/memory pressure (default off). Full
+                                 # knobs and defaults: skills/parallel-workflows.md
+                                 # (Dynamic Resource-Aware Session Concurrency)
+
+LOKI_CODE_INDEX_AUTOREINDEX=1    # auto incremental re-index of the semantic
+                                 # code index before a search when stale
+                                 # (default off = warn-if-stale). Details:
+                                 # references/mcp-integration.md (Built-in
+                                 # Hybrid Codebase Search)
+```
+
 ## Verified-completion evidence gate (v7.19.1, default-on)
 
 The completion council will not accept a "done" claim without evidence. Before