@ainova-systems/intelligence 0.17.1 → 0.17.2

package/engine/lib/adapter-contract.sh

@@ -15,10 +15,6 @@ adapter_contract_preserve() { printf 'preserve\t%s\n' "$1"; }
 adapter_contract_ignore()   { printf 'ignore\t%s\n' "$1"; }
 adapter_contract_include()  { printf 'include\t%s\n' "$1"; }
 
-adapter_contract_function() {
-    printf 'adapter_contract_%s' "$1"
-}
-
 # --- cross-adapter ownership -------------------------------------------------
 #
 # `owned` is exclusive: one adapter writes and prunes that path. `managed` is
@@ -118,7 +114,7 @@ adapter_contract_records() (
     local name="$1" file="$2" output="$3" fn line kind value saw_version=0
     # shellcheck source=/dev/null
     source "$file"
-    fn="$(adapter_contract_function "$name")"
+    printf -v fn 'adapter_contract_%s' "$name"
     declare -F "$fn" >/dev/null 2>&1 || {
         echo "ERROR: adapter '$name' has no $fn contract" >&2
         return 1

package/engine/lib/common.sh

@@ -820,34 +820,38 @@ has_paths() {
 # When you bump these, re-run sync in projects; any project whose config.yaml
 # `models:` section diverges from these will print a drift warning so users
 # know their override is now stale.
-get_model_default() {
-    local ide="$1"
-    local tier="$2"
-    case "$ide:$tier" in
-        claude:heavy)     echo "opus" ;;
-        claude:standard)  echo "sonnet" ;;
-        claude:light)     echo "haiku" ;;
-        cursor:heavy)     echo "inherit" ;;
-        cursor:standard)  echo "inherit" ;;
-        cursor:light)     echo "fast" ;;
-        copilot:heavy)    echo "gpt-5.6-sol" ;;
-        copilot:standard) echo "gpt-5.6-terra" ;;
-        copilot:light)    echo "gpt-5.6-luna" ;;
-        codex:heavy)      echo "gpt-5.6-sol" ;;
-        codex:standard)   echo "gpt-5.6-terra" ;;
-        codex:light)      echo "gpt-5.6-luna" ;;
+# get_model_default_var sets IS_MODEL_DEFAULT; get_model_default prints it.
+get_model_default_var() {
+    case "$1:$2" in
+        claude:heavy)     IS_MODEL_DEFAULT="opus" ;;
+        claude:standard)  IS_MODEL_DEFAULT="sonnet" ;;
+        claude:light)     IS_MODEL_DEFAULT="haiku" ;;
+        cursor:heavy)     IS_MODEL_DEFAULT="inherit" ;;
+        cursor:standard)  IS_MODEL_DEFAULT="inherit" ;;
+        cursor:light)     IS_MODEL_DEFAULT="fast" ;;
+        copilot:heavy)    IS_MODEL_DEFAULT="gpt-5.6-sol" ;;
+        copilot:standard) IS_MODEL_DEFAULT="gpt-5.6-terra" ;;
+        copilot:light)    IS_MODEL_DEFAULT="gpt-5.6-luna" ;;
+        codex:heavy)      IS_MODEL_DEFAULT="gpt-5.6-sol" ;;
+        codex:standard)   IS_MODEL_DEFAULT="gpt-5.6-terra" ;;
+        codex:light)      IS_MODEL_DEFAULT="gpt-5.6-luna" ;;
         # Antigravity accepts only inherit|flash|pro, so standard and light
         # share `flash` — there is no third tier to map onto.
-        antigravity:heavy)     echo "pro" ;;
-        antigravity:standard)  echo "flash" ;;
-        antigravity:light)     echo "flash" ;;
-        opencode:heavy)    echo "anthropic/claude-opus-4-8" ;;
-        opencode:standard) echo "anthropic/claude-sonnet-5" ;;
-        opencode:light)    echo "anthropic/claude-haiku-4-5-20251001" ;;
-        *)                echo "" ;;
+        antigravity:heavy)     IS_MODEL_DEFAULT="pro" ;;
+        antigravity:standard)  IS_MODEL_DEFAULT="flash" ;;
+        antigravity:light)     IS_MODEL_DEFAULT="flash" ;;
+        opencode:heavy)    IS_MODEL_DEFAULT="anthropic/claude-opus-4-8" ;;
+        opencode:standard) IS_MODEL_DEFAULT="anthropic/claude-sonnet-5" ;;
+        opencode:light)    IS_MODEL_DEFAULT="anthropic/claude-haiku-4-5-20251001" ;;
+        *)                IS_MODEL_DEFAULT="" ;;
     esac
 }
 
+get_model_default() {
+    get_model_default_var "$1" "$2"
+    echo "$IS_MODEL_DEFAULT"
+}
+
 # Read a nested key from config.yaml: section -> sub -> key.
 # Resolves `models.<ide>.<tier>` overrides and `packs.<name>.<field>`.
 #
@@ -859,12 +863,16 @@ get_model_default() {
 # The sub-key is matched LITERALLY (`index(...) == 1`), never interpolated into
 # a regex: a pack name may contain `.`, which as a pattern is any character, so
 # `packs.a.b` would happily read a pack named `axb`.
-get_nested_yaml_value() {
-    local file="$1"
-    local section="$2"
-    local sub="$3"
-    local key="$4"
-    awk -v section="$section" -v subname="$sub" -v key="$key" '
+#
+# _nested_yaml_values <plain|tagged> <file> <section> <sub> <key>... — one pass
+# for any number of keys, first occurrence of each. `plain` prints the value
+# alone (one key); `tagged` prints `key<US>value`, US being \037.
+_nested_yaml_values() {
+    local tagged=0 file="$2" section="$3" sub="$4"
+    [ "$1" = tagged ] && tagged=1
+    shift 4
+    awk -v section="$section" -v subname="$sub" -v keys="$*" -v tagged="$tagged" '
+        BEGIN { n = split(keys, want, " "); left = n }
         { sub(/\r$/, "") }
         $0 ~ "^" section ":[[:space:]]*$" { in_section=1; in_sub=0; next }
         in_section && /^[a-zA-Z]/ && $0 !~ "^" section ":" { in_section=0; in_sub=0 }
@@ -872,24 +880,34 @@ get_nested_yaml_value() {
             if (substr($0, length(subname) + 4) ~ /^[[:space:]]*$/) { in_sub=1; next }
         }
         in_section && in_sub && /^  [A-Za-z0-9_]/ { in_sub=0 }
-        in_section && in_sub && index($0, "    " key ":") == 1 {
-            val = $0
-            sub(/^[[:space:]]*[^:]*:[[:space:]]*/, "", val)
-            if (val ~ /^"/ || val ~ /^\047/) {
-                q = substr(val, 1, 1)
-                val = substr(val, 2)
-                i = index(val, q)
-                if (i > 0) val = substr(val, 1, i - 1)
-            } else {
-                sub(/[[:space:]]+#.*$/, "", val)
-                sub(/[[:space:]]+$/, "", val)
+        in_section && in_sub {
+            for (k = 1; k <= n; k++) {
+                if ((k in done) || index($0, "    " want[k] ":") != 1) continue
+                val = $0
+                sub(/^[[:space:]]*[^:]*:[[:space:]]*/, "", val)
+                if (val ~ /^"/ || val ~ /^\047/) {
+                    q = substr(val, 1, 1)
+                    val = substr(val, 2)
+                    i = index(val, q)
+                    if (i > 0) val = substr(val, 1, i - 1)
+                } else {
+                    sub(/[[:space:]]+#.*$/, "", val)
+                    sub(/[[:space:]]+$/, "", val)
+                }
+                if (tagged) printf "%s\037%s\n", want[k], val
+                else print val
+                done[k] = 1
+                if (--left == 0) exit
+                break
             }
-            print val
-            exit
         }
     ' "$file"
 }
 
+get_nested_yaml_value() {
+    _nested_yaml_values plain "$1" "$2" "$3" "$4"
+}
+
 # Resolve a model: config.yaml `models:` override wins, otherwise default.
 # Usage: get_model "$CONFIG_FILE" "claude" "$tier"
 get_model() {
@@ -911,14 +929,27 @@ get_model() {
 # once per adapter run (IS_MODEL_HEAVY / IS_MODEL_STANDARD / IS_MODEL_LIGHT)
 # so per-file loops map tier -> model without forking. resolve_model_var
 # consumes them; a non-standard tier value still goes through get_model so a
-# `models:` override for it keeps working.
+# `models:` override for it keeps working. One manifest pass reads all three.
 load_model_tiers() {
-    local config_file="$1" ide="$2"
+    local config_file="$1" ide="$2" overrides="" tier val heavy="" standard="" light=""
     IS_MODEL_CFG="$config_file"
     IS_MODEL_IDE="$ide"
-    IS_MODEL_HEAVY="$(get_model "$config_file" "$ide" "heavy")"
-    IS_MODEL_STANDARD="$(get_model "$config_file" "$ide" "standard")"
-    IS_MODEL_LIGHT="$(get_model "$config_file" "$ide" "light")"
+    if [ -n "$config_file" ] && [ -f "$config_file" ]; then
+        overrides="$(_nested_yaml_values tagged "$config_file" "models" "$ide" heavy standard light)"
+    fi
+    while IFS=$'\037' read -r tier val; do
+        case "$tier" in
+            heavy) heavy="$val" ;;
+            standard) standard="$val" ;;
+            light) light="$val" ;;
+        esac
+    done <<< "$overrides"
+    get_model_default_var "$ide" heavy
+    IS_MODEL_HEAVY="${heavy:-$IS_MODEL_DEFAULT}"
+    get_model_default_var "$ide" standard
+    IS_MODEL_STANDARD="${standard:-$IS_MODEL_DEFAULT}"
+    get_model_default_var "$ide" light
+    IS_MODEL_LIGHT="${light:-$IS_MODEL_DEFAULT}"
 }
 
 # resolve_model_var <tier> — set IS_MODEL from the tiers load_model_tiers
@@ -968,7 +999,8 @@ report_model_drift() {
     while IFS=$'\t' read -r ide tier from_config; do
         [ -z "$from_config" ] && continue
         local default
-        default=$(get_model_default "$ide" "$tier")
+        get_model_default_var "$ide" "$tier"
+        default="$IS_MODEL_DEFAULT"
         [ "$from_config" = "$default" ] && continue
         if [ $printed_header -eq 0 ]; then
             echo ""
@@ -1361,13 +1393,32 @@ warn_unsynced() {
 # its writer's exit status entirely. Assembling in the caller's shell leaves no
 # writer whose failure can be lost, and the remaining pipeline is checked. An
 # enumeration that cannot answer must stop the run, never shorten the answer.
+#
+# With IS_SOURCE_FILES_MEMO=1 a section is enumerated once and later calls
+# replay that answer. Only the engine sets it: a sync never writes into a
+# source (validate_output_path refuses), so each caller would otherwise re-run
+# the same find and sort for every source directory.
 read_source_artifact_files() {
     local repo_root="$1"
     local config_file="$2"
     local section="$3"
-    local src f dir listing
+    local src f dir listing memo_key="" key_var="" list_var="" joined=""
 
     IS_SOURCE_FILES=()
+    case "${IS_SOURCE_FILES_MEMO:-0}:$section" in
+        1:rules|1:agents|1:skills)
+            key_var="IS_SF_${section}_KEY"
+            list_var="IS_SF_${section}_LIST"
+            memo_key="$repo_root"$'\n'"$config_file"
+            if [ "${!key_var:-}" = "$memo_key" ]; then
+                listing="${!list_var:-}"
+                while IFS= read -r f; do
+                    [ -n "$f" ] && IS_SOURCE_FILES+=("$f")
+                done <<< "$listing"
+                return 0
+            fi
+            ;;
+    esac
     load_yaml_list "$config_file" "$section"
     while IFS= read -r src; do
         [ -n "$src" ] || continue
@@ -1400,18 +1451,28 @@ read_source_artifact_files() {
                 f="$f/SKILL.md"
             fi
             IS_SOURCE_FILES+=("$f")
+            joined="$joined$f"$'\n'
         done <<< "$listing"
     done <<< "$IS_YAML_LIST"
+    if [ -n "$memo_key" ]; then
+        printf -v "$list_var" '%s' "$joined"
+        printf -v "$key_var" '%s' "$memo_key"
+    fi
 }
 
 # Apply the agents adapter's lexical output rule without consulting filesystem
 # state. An omitted output uses the generic adapter default directory.
-agents_output_path() {
+agents_output_path_var() {
     local output="${1:-.agents}"
     if [[ "$output" == */ ]] || [[ "$output" != *.md ]]; then
         output="${output%/}/AGENTS.md"
     fi
-    printf '%s\n' "$output"
+    IS_AGENTS_OUTPUT_PATH="$output"
+}
+
+agents_output_path() {
+    agents_output_path_var "$@"
+    printf '%s\n' "$IS_AGENTS_OUTPUT_PATH"
 }
 
 # Report source prompt pressure independently of adapter formats. "Always-on"
@@ -1420,6 +1481,43 @@ agents_output_path() {
 # them only when a skill explicitly reads them. When the shared agents target
 # exists, also report its rendered size; policy for any tool-specific limit
 # stays in that tool's adapter.
+# count_matching_files <dir> <name-glob> [<dir> <name-glob>]... — fill
+# IS_FILE_COUNTS with one count per pair, what `find <dir> -name <glob> | wc -l`
+# reports for each, from a single find. The directories must be siblings, not
+# nested in one another; a missing one fails the call, as find would.
+count_matching_files() {
+    local -a dirs=() globs=() expr=()
+    local listing path base i n
+    while [ "$#" -ge 2 ]; do
+        dirs+=("$1")
+        globs+=("$2")
+        shift 2
+    done
+    n=${#dirs[@]}
+    IS_FILE_COUNTS=()
+    for ((i = 0; i < n; i++)); do
+        IS_FILE_COUNTS[i]=0
+        [ "$i" -eq 0 ] || expr+=(-o)
+        expr+=(-name "${globs[i]}")
+    done
+    [ "$n" -gt 0 ] || return 0
+    listing="$(find "${dirs[@]}" \( "${expr[@]}" \) -print 2>/dev/null)" || return 1
+    [ -n "$listing" ] || return 0
+    while IFS= read -r path; do
+        base="${path##*/}"
+        for ((i = 0; i < n; i++)); do
+            case "$path" in
+                "${dirs[i]}"|"${dirs[i]}"/*) ;;
+                *) continue ;;
+            esac
+            # shellcheck disable=SC2254  # the glob is the pattern being matched
+            case "$base" in
+                ${globs[i]}) IS_FILE_COUNTS[i]=$((IS_FILE_COUNTS[i] + 1)) ;;
+            esac
+        done
+    done <<< "$listing"
+}
+
 context_files_bytes() {
     if [ "$#" -eq 0 ]; then
         echo 0
@@ -1453,22 +1551,43 @@ report_context_source_sizes() {
     read_source_artifact_files "$repo_root" "$config_file" "skills"
     [ "${#IS_SOURCE_FILES[@]}" -eq 0 ] || skill_files=("${IS_SOURCE_FILES[@]}")
 
-    local always_bytes custom_bytes agents_output agents_bytes=0 agents_status="disabled"
-    always_bytes="$(context_files_bytes "${always_on_rules[@]+"${always_on_rules[@]}"}")"
-    custom_bytes="$(context_files_bytes \
-        "${scoped_rules[@]+"${scoped_rules[@]}"}" \
-        "${agent_files[@]+"${agent_files[@]}"}" \
-        "${skill_files[@]+"${skill_files[@]}"}")"
+    local always_bytes=0 custom_bytes=0 agents_output agents_bytes=0 agents_status="disabled"
+    local always_n custom_n listing size rest idx=0
+    local -a measured=()
+    always_n=${#always_on_rules[@]}
+    custom_n=$(( ${#scoped_rules[@]} + ${#agent_files[@]} + ${#skill_files[@]} ))
+    measured=(
+        "${always_on_rules[@]+"${always_on_rules[@]}"}"
+        "${scoped_rules[@]+"${scoped_rules[@]}"}"
+        "${agent_files[@]+"${agent_files[@]}"}"
+        "${skill_files[@]+"${skill_files[@]}"}")
     target_enabled_var "$config_file" "agents"
     if [ "$IS_TGT_ENABLED" = "1" ]; then
         agents_status="not-generated"
         target_output_var "$config_file" "agents"
-        agents_output="$(agents_output_path "${IS_TGT_OUTPUT:-.agents}")"
+        agents_output_path_var "${IS_TGT_OUTPUT:-.agents}"
+        agents_output="$IS_AGENTS_OUTPUT_PATH"
         if [ -f "$repo_root/$agents_output" ]; then
-            agents_bytes="$(context_files_bytes "$repo_root/$agents_output")"
+            measured+=("$repo_root/$agents_output")
             agents_status="generated"
         fi
     fi
+    # One wc for every group: its per-file lines come back in argument order,
+    # and each group's sum is what a separate `wc` total would have reported.
+    if [ "${#measured[@]}" -gt 0 ]; then
+        listing="$(LC_ALL=C wc -c "${measured[@]}")"
+        while read -r size rest; do
+            [ "$idx" -lt "${#measured[@]}" ] || break
+            if [ "$idx" -lt "$always_n" ]; then
+                always_bytes=$((always_bytes + size))
+            elif [ "$idx" -lt $((always_n + custom_n)) ]; then
+                custom_bytes=$((custom_bytes + size))
+            else
+                agents_bytes=$((agents_bytes + size))
+            fi
+            idx=$((idx + 1))
+        done <<< "$listing"
+    fi
 
     printf 'CONTEXT: always-on=%s bytes (%s rules); custom=%s bytes (%s scoped rules, %s agents, %s skills); agents-md=%s bytes; agents-md-status=%s\n' \
         "$always_bytes" "${#always_on_rules[@]}" "$custom_bytes" \
@@ -1554,6 +1673,56 @@ load_yaml_list() {
     esac
 }
 
+# load_yaml_lists <file> <section>... — warm the load_yaml_list cache for several
+# sections in one manifest pass. Each section runs read_yaml_list's own state
+# machine, so every cached value is what load_yaml_list would have stored.
+load_yaml_lists() {
+    local file="$1" out line s v j
+    shift
+    for s in "$@"; do
+        case "$s" in
+            rules|agents|skills|ignore|submodules) ;;
+            *) return 1 ;;
+        esac
+    done
+    out="$(awk -v sections="$*" '
+        BEGIN { n = split(sections, want, " ") }
+        { sub(/\r$/, "") }
+        {
+            for (k = 1; k <= n; k++) {
+                s = want[k]
+                if ($0 ~ /^[a-z]/) { cur[k] = ""; dep[k] = 0 }
+                if ($0 ~ /^  [a-z]/) { cur[k] = ""; dep[k] = 0 }
+                if ($0 ~ "^" s ":") { cur[k] = s; dep[k] = 0; continue }
+                if ($0 ~ "^  " s ":") { cur[k] = s; dep[k] = 2; continue }
+                if (cur[k] == s && dep[k] == 0 && /^  - /) {
+                    val = $0
+                    sub(/^  - /, "", val)
+                    gsub(/["\047]/, "", val)
+                    print s "\037" val
+                }
+                if (cur[k] == s && dep[k] == 2 && /^    - /) {
+                    val = $0
+                    sub(/^    - /, "", val)
+                    gsub(/["\047]/, "", val)
+                    print s "\037" val
+                }
+            }
+        }
+    ' "$file")"
+    for s in "$@"; do
+        j=""
+        while IFS= read -r line; do
+            [ "${line%%$'\037'*}" = "$s" ] || continue
+            v="${line#*$'\037'}"
+            j="$j$v"$'\n'
+        done <<< "$out"
+        while [[ "$j" == *$'\n' ]]; do j="${j%$'\n'}"; done
+        printf -v "IS_YL_${s}_FILE" '%s' "$file"
+        printf -v "IS_YL_${s}_VAL" '%s' "$j"
+    done
+}
+
 # load_targets_cache <file> — parse the whole targets: section once into the
 # global IS_TGT_TSV (one `name<TAB>enabled<TAB>output` row per target),
 # matching is_target_enabled and get_target_output semantics: inline and block

package/engine/lib/contract.sh

@@ -20,19 +20,40 @@
 # schema is this?" before parsing the rest.
 IS_SCHEMA_VERSION_KEY="schema_version"
 
+# read_schema_version_var <config_file> — set IS_SCHEMA_VERSION to the applied
+# version, "" if absent; IS_SCHEMA_VERSION_FOUND=1 when the key exists. Read in
+# this shell, not by awk: every lifecycle command and the engine ask before
+# anything else, and on Git Bash each spawned reader costs tens of milliseconds.
+# The value is the text after the first colon, minus surrounding whitespace, one
+# leading quote and one trailing quote.
+read_schema_version_var() {
+    local cf="$1" line v
+    IS_SCHEMA_VERSION=""
+    IS_SCHEMA_VERSION_FOUND=0
+    [ -f "$cf" ] || return 0
+    while IFS= read -r line || [ -n "$line" ]; do
+        line="${line%$'\r'}"
+        case "$line" in
+            "$IS_SCHEMA_VERSION_KEY:"*) ;;
+            *) continue ;;
+        esac
+        v="${line#*:}"
+        v="${v#"${v%%[![:space:]]*}"}"
+        case "$v" in \"*|\'*) v="${v#?}" ;; esac
+        v="${v%"${v##*[![:space:]]}"}"
+        case "$v" in *\"|*\') v="${v%?}" ;; esac
+        v="${v%"${v##*[![:space:]]}"}"
+        IS_SCHEMA_VERSION="$v"
+        IS_SCHEMA_VERSION_FOUND=1
+        return 0
+    done < "$cf"
+}
+
 # read_schema_version <config_file> → applied version, or "" if absent.
 read_schema_version() {
-    local cf="$1"
-    [ -f "$cf" ] || return 0
-    awk -v k="$IS_SCHEMA_VERSION_KEY" '
-        { sub(/\r$/, "") }
-        $0 ~ "^" k ":" {
-            v = $0; sub(/^[^:]*:[[:space:]]*/, "", v)
-            gsub(/^["\047]|["\047][[:space:]]*$/, "", v)
-            sub(/[[:space:]]+$/, "", v)
-            print v; exit
-        }
-    ' "$cf"
+    read_schema_version_var "$1"
+    [ "$IS_SCHEMA_VERSION_FOUND" = 1 ] || return 0
+    printf '%s\n' "$IS_SCHEMA_VERSION"
 }
 
 # stamp_schema_version <config_file> <version> — idempotent, transactional upsert of
@@ -74,12 +95,29 @@ is_status() {
     fi
 }
 
-# Engine version = scripts/VERSION next to this lib (BASH_SOURCE works when
+# Engine version = VERSION one level above this lib (BASH_SOURCE works when
 # sourced). Empty if unreadable — callers treat empty as "no guard".
+# engine_version_var sets IS_ENGINE_VERSION, and IS_ENGINE_VERSION_FOUND=1 when
+# the file exists; it reads the file once per process.
+engine_version_var() {
+    [ -z "${IS_ENGINE_VERSION_FOUND:-}" ] || return 0
+    local lib="${BASH_SOURCE[0]}" vf content=""
+    case "$lib" in
+        */*) lib="${lib%/*}" ;;
+        *) lib="." ;;
+    esac
+    vf="$lib/../VERSION"
+    IS_ENGINE_VERSION=""
+    IS_ENGINE_VERSION_FOUND=0
+    [ -f "$vf" ] || return 0
+    IFS= read -r -d '' content < "$vf" || true
+    IS_ENGINE_VERSION="${content//[$' \t\r\n']/}"
+    IS_ENGINE_VERSION_FOUND=1
+}
+
 engine_version() {
-    local vf
-    vf="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." 2>/dev/null && pwd)/VERSION"
-    [ -f "$vf" ] && tr -d ' \t\r\n' < "$vf"
+    engine_version_var
+    [ "$IS_ENGINE_VERSION_FOUND" = 1 ] && printf '%s' "$IS_ENGINE_VERSION"
 }
 
 # _ver_gt A B → true if semver A is strictly greater than B (numeric x.y.z;
@@ -118,9 +156,11 @@ _ver_major() {
 #     a project stamped ahead exactly as it found it (project_needs_upgrade).
 check_version_compat() {
     local cf="$1" stamp eng
-    stamp="$(read_schema_version "$cf")"
+    read_schema_version_var "$cf"
+    stamp="$IS_SCHEMA_VERSION"
     [ -n "$stamp" ] || return 0
-    eng="$(engine_version)"
+    engine_version_var
+    eng="$IS_ENGINE_VERSION"
     [ -n "$eng" ] || return 0
     _ver_gt "$stamp" "$eng" || return 0
     if [ "$(_ver_major "$stamp")" -gt "$(_ver_major "$eng")" ]; then