@ainova-systems/intelligence 0.17.1 → 0.17.3

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

package/engine/sync.sh

@@ -41,8 +41,11 @@ if [ "$_vc_rc" -ne 0 ]; then exit "$_vc_rc"; fi
 # so the CLI lifecycle preflight must align the project first. An ABSENT stamp
 # means the same thing — a manifest with no
 # `schema_version` must not silently sync past a schema change.
-_stamp="$(read_schema_version "$_cf")"
-_eng="$(engine_version)"
+read_schema_version_var "$_cf"
+_stamp="$IS_SCHEMA_VERSION"
+engine_version_var
+[ "$IS_ENGINE_VERSION_FOUND" = 1 ] || exit 1
+_eng="$IS_ENGINE_VERSION"
 if [ -z "$_stamp" ]; then
     is_status needs-update "stamped= engine=$_eng (no schema_version)"
     echo "ERROR: the manifest has no schema_version — schema un-applied." >&2
@@ -62,7 +65,12 @@ fi
 REPO_ROOT_RAW="${REPO_ROOT:-$(git rev-parse --show-toplevel 2>/dev/null || dirname "$CONFIG_FILE")}"
 REPO_ROOT="$(cd "$REPO_ROOT_RAW" && pwd)"
 unset REPO_ROOT_RAW
-CONFIG_FILE="$(cd "$(dirname "$CONFIG_FILE")" && pwd)/$(basename "$CONFIG_FILE")"
+case "$CONFIG_FILE" in
+    */*) _cf_dir="${CONFIG_FILE%/*}"; [ -n "$_cf_dir" ] || _cf_dir="/" ;;
+    *) _cf_dir="." ;;
+esac
+CONFIG_FILE="$(cd "$_cf_dir" && pwd)/${CONFIG_FILE##*/}"
+unset _cf_dir
 
 # Layout tokens for generated output (see finalize_output_file in common.sh).
 # Package-shipped rules/agents cannot hardcode the content dir's name — the
@@ -92,13 +100,12 @@ echo ""
 # adapter process substitutions — hits the in-memory copy instead of
 # spawning awk.
 load_targets_cache "$CONFIG_FILE"
-for section in rules agents skills ignore submodules; do
-    load_yaml_list "$CONFIG_FILE" "$section"
-done
+load_yaml_lists "$CONFIG_FILE" rules agents skills ignore submodules
 
 # Lint frontmatter across all source files (rules, agents, skills).
 # Catches issues like unquoted colons that strict YAML consumers reject.
 LINT_FILES=()
+LINT_SKILL_DIRS=()
 for section in rules agents skills; do
     load_yaml_list "$CONFIG_FILE" "$section"
     while IFS= read -r src; do
@@ -106,9 +113,7 @@ for section in rules agents skills; do
         src_dir="$REPO_ROOT/$src"
         [ -d "$src_dir" ] || continue
         if [ "$section" = "skills" ]; then
-            while IFS= read -r f; do
-                [ -n "$f" ] && LINT_FILES+=("$f")
-            done < <(find "$src_dir" -mindepth 2 -maxdepth 2 -name 'SKILL.md' 2>/dev/null)
+            LINT_SKILL_DIRS+=("$src_dir")
         else
             for f in "$src_dir"/*.md; do
                 [ -f "$f" ] && LINT_FILES+=("$f")
@@ -116,10 +121,27 @@ for section in rules agents skills; do
         fi
     done <<< "$IS_YAML_LIST"
 done
+# One find for every skills source: it walks its start points in order.
+if [ "${#LINT_SKILL_DIRS[@]}" -gt 0 ]; then
+    while IFS= read -r f; do
+        [ -n "$f" ] && LINT_FILES+=("$f")
+    done < <(find "${LINT_SKILL_DIRS[@]}" -mindepth 2 -maxdepth 2 -name 'SKILL.md' 2>/dev/null)
+fi
 if [ "${#LINT_FILES[@]}" -gt 0 ]; then
     lint_frontmatter_files "${LINT_FILES[@]}"
 fi
 
+# Sources stay read-only for the whole run (validate_output_path refuses an
+# output inside one), so read_source_artifact_files enumerates each section
+# once, in this shell, and its later callers — the agents adapter, the shared
+# skill directory, the context report — replay it. Adapters that list sources
+# with in-shell globs spawn nothing and keep their own, locale-ordered listing.
+# shellcheck disable=SC2034  # read by read_source_artifact_files in lib/common.sh
+IS_SOURCE_FILES_MEMO=1
+for section in rules agents skills; do
+    read_source_artifact_files "$REPO_ROOT" "$CONFIG_FILE" "$section"
+done
+
 # Adapters come from two places, discovered by filename (minus `.sh`,
 # `_template` excluded):
 #
@@ -152,7 +174,8 @@ for adapters_dir in "$SCRIPT_DIR/adapters" "$INTELLIGENCE_DIR/adapters"; do
     [ -d "$adapters_dir" ] || continue
     for adapter_file in "$adapters_dir"/*.sh; do
         [ -f "$adapter_file" ] || continue
-        adapter_name="$(basename "$adapter_file" .sh)"
+        adapter_name="${adapter_file##*/}"
+        adapter_name="${adapter_name%.sh}"
         [ "$adapter_name" = "_template" ] && continue
         register_adapter "$adapter_name" "$adapter_file"
     done
@@ -170,6 +193,15 @@ SYNC_TX_ACTIVE=0
 SYNC_TX_SEEN_LIST=$'\n'
 SYNC_TX_COUNT=0
 
+# Independent work runs concurrently unless INTELLIGENCE_SYNC_SERIAL=1 asks for
+# the one-at-a-time order every earlier engine used (decision 0011). Every
+# background job is listed in SYNC_BG_PIDS so an early exit stops it before
+# anything is restored or removed.
+SYNC_PARALLEL=1
+[ "${INTELLIGENCE_SYNC_SERIAL:-0}" != "1" ] || SYNC_PARALLEL=0
+SYNC_BG_PIDS=()
+SYNC_COPY_INDEXES=()
+
 snapshot_sync_path() {
     local adapter_name="$1" rel="$2" src index present=0
     case "$SYNC_TX_SEEN_LIST" in
@@ -180,7 +212,15 @@ snapshot_sync_path() {
     index="$SYNC_TX_COUNT"
     src="$REPO_ROOT/$rel"
     if [ -e "$src" ] || [ -L "$src" ]; then
-        cp -a "$src" "$SYNC_TX_DIR/data/$index"
+        # Copies of distinct paths into distinct slots: they can overlap, and
+        # The snapshot wait before the render collects every status.
+        if [ "$SYNC_PARALLEL" = 1 ]; then
+            cp -a "$src" "$SYNC_TX_DIR/data/$index" 2> "$SYNC_TX_DIR/copy.$index.err" &
+            SYNC_BG_PIDS+=("$!")
+            SYNC_COPY_INDEXES+=("$index")
+        else
+            cp -a "$src" "$SYNC_TX_DIR/data/$index"
+        fi
         present=1
     fi
     printf '%s\t%s\t%s\n' "$index" "$rel" "$present" >> "$SYNC_TX_INDEX"
@@ -200,10 +240,36 @@ restore_sync_snapshot() {
     done < "$SYNC_TX_INDEX"
 }
 
+# stop_sync_jobs — reap every background job before restoring or removing
+# anything, so no copy or adapter can write after that point. It waits rather
+# than kills: killing a job's shell would leave its cp or awk still writing.
+# Ctrl-C already reaches every job through the terminal's process group.
+stop_sync_jobs() {
+    local pid
+    for pid in "${SYNC_BG_PIDS[@]+"${SYNC_BG_PIDS[@]}"}"; do
+        wait "$pid" 2>/dev/null
+    done
+    SYNC_BG_PIDS=()
+}
+
+# wait_sync_jobs — collect every background job's status; the first failure
+# becomes this shell's, as it would have had the work run in the foreground.
+wait_sync_jobs() {
+    local pid rc=0 first=0
+    for pid in "${SYNC_BG_PIDS[@]+"${SYNC_BG_PIDS[@]}"}"; do
+        rc=0
+        wait "$pid" || rc=$?
+        [ "$first" -ne 0 ] || first="$rc"
+    done
+    SYNC_BG_PIDS=()
+    return "$first"
+}
+
 finish_sync_transaction() {
     local rc=$?
     trap - EXIT INT TERM
     set +e
+    stop_sync_jobs
     if [ "${SYNC_TX_ACTIVE:-0}" = "1" ] && [ "$rc" -ne 0 ]; then
         restore_sync_snapshot
         echo "ERROR: sync failed; all adapter-owned paths were restored to their pre-sync state." >&2
@@ -228,6 +294,8 @@ note_agents_dependent() {
     [ -n "$agents_dependents" ] && agents_dependents="$agents_dependents, "
     agents_dependents="$agents_dependents$1"
 }
+SELECTED_RECORDS=()
+RENDER_PARALLEL="$SYNC_PARALLEL"
 preflight_idx=0
 while [ "$preflight_idx" -lt "${#ADAPTERS[@]}" ]; do
     adapter="${ADAPTERS[$preflight_idx]}"
@@ -255,6 +323,14 @@ while [ "$preflight_idx" -lt "${#ADAPTERS[@]}" ]; do
     fi
 
     validate_output_path "$REPO_ROOT" "$CONFIG_FILE" "$adapter" "$REPO_ROOT/$output"
+    # The scheduler below reads ownership and requirements from these records.
+    # A project adapter is executable code whose reads no contract declares, so
+    # its presence keeps the whole render serial.
+    SELECTED_RECORDS+=("$records")
+    case "$adapter_file" in
+        "$SCRIPT_DIR/adapters/"*) ;;
+        *) RENDER_PARALLEL=0 ;;
+    esac
     while IFS=$'\t' read -r kind value; do
         [ "$kind" = "requires" ] || continue
         [ "$value" = "agents" ] && note_agents_dependent "$adapter"
@@ -280,15 +356,30 @@ if [ -n "$agents_dependents" ]; then
     target_output_var "$CONFIG_FILE" "agents"
     # Resolved, not lexical: `./` renders `./AGENTS.md`, which IS the
     # workspace-root file every dependent adapter reads.
-    adapter_contract_rel_path "$(agents_output_path "${IS_TGT_OUTPUT:-.agents}")"
+    agents_output_path_var "${IS_TGT_OUTPUT:-.agents}"
+    adapter_contract_rel_path "$IS_AGENTS_OUTPUT_PATH"
     agents_rel="$IS_ADAPTER_REL_PATH"
     if [ "$agents_rel" != "AGENTS.md" ]; then
         echo "WARNING: targets.agents.output renders '$agents_rel', not the workspace-root AGENTS.md. These adapters skip always-on rules because AGENTS.md carries them, and they read it at the root only: $agents_dependents. No tool loads those rules from '$agents_rel'." >&2
     fi
 fi
+# Every snapshot copy has landed before any adapter writes. Their diagnostics
+# print in path order once all have finished, so a failed copy reads the same
+# whichever finished first; it reports after preflight checked every adapter,
+# where the serial order stopped at that adapter (decision 0011).
+snapshot_rc=0
+wait_sync_jobs || snapshot_rc=$?
+for index in "${SYNC_COPY_INDEXES[@]+"${SYNC_COPY_INDEXES[@]}"}"; do
+    [ ! -s "$SYNC_TX_DIR/copy.$index.err" ] || cat "$SYNC_TX_DIR/copy.$index.err" >&2
+done
+[ "$snapshot_rc" -eq 0 ] || exit "$snapshot_rc"
 SYNC_TX_ACTIVE=1
 
-synced=0
+# The run list: selected, enabled adapters in discovery order, refused with the
+# same messages the one-at-a-time loop gave. Preflight validated every output.
+RUN_NAMES=()
+RUN_FILES=()
+RUN_DIRS=()
 adapter_count=${#ADAPTERS[@]}
 adapter_idx=0
 
@@ -328,14 +419,192 @@ while [ "$adapter_idx" -lt "$adapter_count" ]; do
     # output, and `agents` overwrites whatever single file it is handed. Both
     # turn a bad config line into a destructive write.
     validate_output_path "$REPO_ROOT" "$CONFIG_FILE" "$adapter" "$output_dir"
+    RUN_NAMES+=("$adapter")
+    RUN_FILES+=("$adapter_file")
+    RUN_DIRS+=("$output_dir")
+done
+synced=${#RUN_NAMES[@]}
 
-    # Source adapter and run.
+# run_adapter <index> — source one adapter and render it.
+run_adapter() {
     # shellcheck source=/dev/null
-    source "$adapter_file"
-    "sync_to_$adapter" "$REPO_ROOT" "$CONFIG_FILE" "$output_dir"
+    source "${RUN_FILES[$1]}"
+    "sync_to_${RUN_NAMES[$1]}" "$REPO_ROOT" "$CONFIG_FILE" "${RUN_DIRS[$1]}"
     echo ""
-    synced=$((synced + 1))
-done
+}
+
+# managed_paths_meet <a> <b> — two resolved paths are one tree: equal, or one
+# inside the other.
+managed_paths_meet() {
+    [ "$1" = "$2" ] && return 0
+    case "$1" in "$2"/*) return 0 ;; esac
+    case "$2" in "$1"/*) return 0 ;; esac
+    return 1
+}
+
+# plan_concurrent_render — fill RUN_CHAIN (each adapter's chain, named by its
+# first member) and CHAIN_WAVE (when that chain may start), from the contract
+# records preflight kept. Adapters that manage one tree form a chain and run in
+# list order inside one job: they share that tree, and sync_open_skill_dirs
+# replays the first one's work in the same shell. An adapter that requires
+# another starts in a later wave than the chain holding it — Codex reads the
+# rendered AGENTS.md. Returns 1 when no safe plan exists; the render is then
+# serial.
+plan_concurrent_render() {
+    local n="$synced" i j k kind value old value_chain
+    local -a paths=() path_chain=()
+    [ "${#SELECTED_RECORDS[@]}" -eq "$n" ] || return 1
+    RUN_CHAIN=()
+    CHAIN_WAVE=()
+    for ((i = 0; i < n; i++)); do
+        RUN_CHAIN[i]=$i
+        CHAIN_WAVE[i]=0
+    done
+    for ((i = 0; i < n; i++)); do
+        while IFS=$'\t' read -r kind value; do
+            [ "$kind" = managed ] || continue
+            normalize_path_var "$REPO_ROOT/$value"
+            value="$IS_NORM_PATH"
+            for ((k = 0; k < ${#paths[@]}; k++)); do
+                managed_paths_meet "${paths[k]}" "$value" || continue
+                old="${RUN_CHAIN[i]}"
+                [ "$old" != "${path_chain[k]}" ] || continue
+                # Merge into the chain whose first member comes earlier.
+                if [ "$old" -lt "${path_chain[k]}" ]; then
+                    old="${path_chain[k]}"
+                    value_chain="${RUN_CHAIN[i]}"
+                else
+                    value_chain="${path_chain[k]}"
+                fi
+                for ((j = 0; j < n; j++)); do
+                    [ "${RUN_CHAIN[j]}" != "$old" ] || RUN_CHAIN[j]="$value_chain"
+                done
+                for ((j = 0; j < ${#paths[@]}; j++)); do
+                    [ "${path_chain[j]}" != "$old" ] || path_chain[j]="$value_chain"
+                done
+            done
+            paths+=("$value")
+            path_chain+=("${RUN_CHAIN[i]}")
+        done <<< "${SELECTED_RECORDS[i]}"
+    done
+    # Relax requirement edges; a plan still moving after n rounds has a cycle.
+    local round changed want
+    for ((round = 0; round <= n; round++)); do
+        changed=0
+        for ((i = 0; i < n; i++)); do
+            while IFS=$'\t' read -r kind value; do
+                [ "$kind" = requires ] || continue
+                for ((j = 0; j < n; j++)); do
+                    [ "${RUN_NAMES[j]}" = "$value" ] || continue
+                    [ "${RUN_CHAIN[j]}" != "${RUN_CHAIN[i]}" ] || continue
+                    want=$(( CHAIN_WAVE[RUN_CHAIN[j]] + 1 ))
+                    if [ "${CHAIN_WAVE[RUN_CHAIN[i]]}" -lt "$want" ]; then
+                        CHAIN_WAVE[RUN_CHAIN[i]]="$want"
+                        changed=1
+                    fi
+                done
+            done <<< "${SELECTED_RECORDS[i]}"
+        done
+        [ "$changed" = 1 ] || return 0
+    done
+    return 1
+}
+
+# render_concurrently — run each wave's chains as background jobs, one output
+# buffer per adapter. Buffers print in list order as soon as every earlier
+# adapter's has printed, so progress still streams adapter by adapter. A failed
+# adapter ends the run with its own status after the buffers of the adapters
+# that completed before it in the list; the EXIT handler then restores every
+# snapshot, exactly as when the adapters ran one at a time.
+render_concurrently() {
+    local n="$synced" buf="$SYNC_TX_DIR/out" wave last_wave=0 c k pid rc
+    local printed=0 failed=-1 failed_rc=0
+    local -a wave_pids=() wave_chains=() files=() job_rc=()
+    mkdir -p "$buf"
+    for ((c = 0; c < n; c++)); do
+        [ "${CHAIN_WAVE[c]}" -le "$last_wave" ] || last_wave="${CHAIN_WAVE[c]}"
+    done
+    for ((wave = 0; wave <= last_wave; wave++)); do
+        wave_pids=()
+        wave_chains=()
+        for ((c = 0; c < n; c++)); do
+            [ "${RUN_CHAIN[c]}" = "$c" ] && [ "${CHAIN_WAVE[c]}" = "$wave" ] || continue
+            (
+                for ((k = 0; k < n; k++)); do
+                    [ "${RUN_CHAIN[k]}" = "$c" ] || continue
+                    run_adapter "$k" > "$buf/$k" 2>&1
+                    : > "$buf/$k.ok"
+                done
+            ) &
+            wave_pids+=("$!")
+            wave_chains+=("$c")
+            SYNC_BG_PIDS+=("$!")
+        done
+        for ((k = 0; k < ${#wave_pids[@]}; k++)); do
+            rc=0
+            wait "${wave_pids[k]}" || rc=$?
+            job_rc[wave_chains[k]]="$rc"
+            # Stream while the wave runs: every buffer whose predecessors have
+            # all printed goes out now. Only completed adapters are marked, so
+            # nothing printed here can precede a failure in list order.
+            files=()
+            while [ "$printed" -lt "$n" ] && [ -f "$buf/$printed.ok" ]; do
+                files+=("$buf/$printed")
+                printed=$((printed + 1))
+            done
+            [ "${#files[@]}" -eq 0 ] || cat "${files[@]}"
+        done
+        SYNC_BG_PIDS=()
+        # The first adapter in list order that started and did not finish.
+        for ((k = 0; k < n; k++)); do
+            if [ -f "$buf/$k" ] && [ ! -f "$buf/$k.ok" ]; then
+                failed=$k
+                failed_rc="${job_rc[RUN_CHAIN[k]]:-1}"
+                [ "$failed_rc" != 0 ] || failed_rc=1
+                break
+            fi
+        done
+        # A job that failed before its adapter's buffer existed still fails
+        # the run, charged to the first member of that chain not marked done.
+        if [ "$failed" -lt 0 ]; then
+            for ((k = 0; k < ${#wave_chains[@]}; k++)); do
+                rc="${job_rc[wave_chains[k]]}"
+                [ "$rc" = 0 ] && continue
+                for ((c = 0; c < n; c++)); do
+                    [ "${RUN_CHAIN[c]}" = "${wave_chains[k]}" ] && [ ! -f "$buf/$c.ok" ] || continue
+                    failed=$c
+                    break
+                done
+                [ "$failed" -ge 0 ] || failed="${wave_chains[k]}"
+                failed_rc="$rc"
+                break
+            done
+        fi
+        files=()
+        if [ "$failed" -ge 0 ]; then
+            for ((k = printed; k <= failed; k++)); do
+                [ -f "$buf/$k" ] && files+=("$buf/$k")
+            done
+            [ "${#files[@]}" -eq 0 ] || cat "${files[@]}"
+            exit "$failed_rc"
+        fi
+        while [ "$printed" -lt "$n" ] && [ -f "$buf/$printed.ok" ]; do
+            files+=("$buf/$printed")
+            printed=$((printed + 1))
+        done
+        [ "${#files[@]}" -eq 0 ] || cat "${files[@]}"
+    done
+}
+
+if [ "$RENDER_PARALLEL" = 1 ] && [ "$synced" -gt 1 ] && plan_concurrent_render; then
+    render_concurrently
+else
+    adapter_idx=0
+    while [ "$adapter_idx" -lt "$synced" ]; do
+        run_adapter "$adapter_idx"
+        adapter_idx=$((adapter_idx + 1))
+    done
+fi
 
 if [ $synced -eq 0 ]; then
     if [ -n "$TARGET_FILTER" ]; then
@@ -348,18 +617,35 @@ if [ $synced -eq 0 ]; then
 fi
 
 SYNC_TX_ACTIVE=0
-rm -rf "$SYNC_TX_DIR"
-trap - EXIT INT TERM
-
-# Warn about unsynced directories
-warn_unsynced "$REPO_ROOT" "$CONFIG_FILE"
 
-# Report adapter-agnostic source context pressure on every successful sync.
-report_context_source_sizes "$REPO_ROOT" "$CONFIG_FILE"
-
-# Report model overrides that drift from intelligence-sync defaults
-# (helpful when defaults move forward — e.g., gpt-5.5 -> gpt-5.6).
-report_model_drift "$CONFIG_FILE"
+# After rendering, three read-only reports, in this order:
+#   - directories that look like sources but are not wired in (a repository-wide
+#     scan, so it runs only once every output exists);
+#   - adapter-agnostic source context pressure;
+#   - model overrides that drift from intelligence-sync defaults (helpful when
+#     defaults move forward — e.g., gpt-5.5 -> gpt-5.6).
+# Concurrently, the scan runs beside the other two and beside removing the
+# snapshots; the buffers print in the order above.
+if [ "$SYNC_PARALLEL" = 1 ]; then
+    rm -rf "$SYNC_TX_DIR/data" &
+    SYNC_BG_PIDS+=("$!")
+    warn_unsynced "$REPO_ROOT" "$CONFIG_FILE" > "$SYNC_TX_DIR/unsynced" 2>&1 &
+    SYNC_BG_PIDS+=("$!")
+    {
+        report_context_source_sizes "$REPO_ROOT" "$CONFIG_FILE"
+        report_model_drift "$CONFIG_FILE"
+    } > "$SYNC_TX_DIR/reports" 2>&1
+    wait_sync_jobs
+    cat "$SYNC_TX_DIR/unsynced" "$SYNC_TX_DIR/reports"
+    rm -rf "$SYNC_TX_DIR"
+    trap - EXIT INT TERM
+else
+    rm -rf "$SYNC_TX_DIR"
+    trap - EXIT INT TERM
+    warn_unsynced "$REPO_ROOT" "$CONFIG_FILE"
+    report_context_source_sizes "$REPO_ROOT" "$CONFIG_FILE"
+    report_model_drift "$CONFIG_FILE"
+fi
 
 echo ""
 # sync.sh never changes project schemas (the CLI preflight owns that), so

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ainova-systems/intelligence",
-  "version": "0.17.1",
+  "version": "0.17.3",
   "description": "Build, version and distribute AI agent intelligence across your organization — one CLI, versioned Intelligence Packages, and a sync engine for Claude Code, Cursor, Copilot, Codex, Pi and OpenCode.",
   "bin": {
     "intelligence": "bin/intelligence.js"

package/packages/sync/references/adapters.md

@@ -98,6 +98,13 @@ other's output and both runs report success. A filtered `sync <adapter>` is
 checked the same way: it prunes the same paths while never loading the adapter
 whose output it destroys.
 
+The contract also orders rendering. Built-in adapters render concurrently:
+adapters whose `managed` paths meet run one after another in list order, and an
+adapter starts only after every target it `requires` has finished. An adapter
+that reads another adapter's output while it renders therefore declares
+`requires` on it. A project adapter keeps the whole render serial, because its
+reads are not part of any contract.
+
 For an existing `.vscodeignore`, `.npmignore`, or `.dockerignore`, enable/init
 also excludes the configured adapter output plus its `owned`, `managed`, and
 `legacy` paths from published or build artifacts. This packaging policy is

package/packages/sync/references/conventions.md

@@ -121,7 +121,7 @@ Practice:
 - **`latest` and `*` are for a package you own and release in lockstep.** Anywhere else they hand an upstream author write access to your agents' behavior between two syncs.
 - **Never pin a range to dodge a broken release.** Pin the exact version (`1.4.2`), record why, and remove the pin when the fix ships — a narrowed range hides the reason and outlives the incident.
 
-Commit `intelligence.lock`. It records requested versions, source URLs and paths, resolved refs and commit SHAs. After cloning, `intelligence sync` restores a missing store strictly from that lock before rendering; manifest/lock or SHA drift is refused. Re-run `package add` when deliberately changing a source.
+Commit `intelligence.lock`. It records requested versions, source URLs and paths, resolved refs and commit SHAs. After cloning, or after a pull that moved the lock, `intelligence sync` restores every package the store lacks or holds at another commit, strictly from that lock, before rendering; manifest/lock or SHA drift is refused. Re-run `package add` when deliberately changing a source.
 
 `@ainova-systems/sync` is ordinary package content exact-pinned to the bundled engine version. `intelligence init` installs it unless `--bare` is used. Lifecycle preflight keeps that pin and `schema_version` aligned with the installed CLI; package-range updates never move it independently.
 
@@ -416,7 +416,7 @@ The permanent applied-schema key is the top-level scalar `schema_version` in `in
 The public lifecycle is deliberately compact:
 
 - `intelligence init [--preview|--apply]` is universal: it creates a new setup, aligns an existing Intelligence project, or plans/applies conversion of an eligible legacy Intelligence Sync project.
-- `intelligence sync [adapter] [--compact] [--force]` first aligns an existing Intelligence project with the installed CLI and restores a missing store strictly from `intelligence.lock`. It skips rendering when local inputs and outputs match a previous successful run. Changes or missing outputs trigger rendering; `--force` always renders and refreshes the search for unconfigured source directories. An unchanged run replays the last full run's useful diagnostics. Compact mode shows context sizes, actionable warnings and final status on success, and all diagnostics on failure. In CI it refuses an alignment that would change tracked files and points to a local `intelligence init --apply` plus review/commit.
+- `intelligence sync [adapter] [--compact] [--force]` first aligns an existing Intelligence project with the installed CLI and restores every package the store lacks or holds at another commit, strictly from `intelligence.lock`. It skips rendering when local inputs and outputs match a previous successful run. Changes or missing outputs trigger rendering; `--force` always renders and refreshes the search for unconfigured source directories. An unchanged run replays the last full run's useful diagnostics. Compact mode shows context sizes, actionable warnings and final status on success, and all diagnostics on failure. In CI it refuses an alignment that would change tracked files and points to a local `intelligence init --apply` plus review/commit.
 - `intelligence update [@scope/name] [--preview|--apply]` is the only update surface. It prints the CLI/project/package plan; default mode prompts, `--preview` never writes, and `--apply` does not prompt. It never moves `ref:` pins.
 - `intelligence upgrade [--next] [--preview|--apply]` replaces the installed CLI with the newest version on its npm channel (`next` for a prerelease or with `--next`, otherwise `latest`) with the same modes. It touches no project, never downgrades, and refuses an installation that npm did not make.
 - `intelligence package add|remove|list|search` owns package inventory.