@ainova-systems/intelligence 0.16.0 → 0.17.0

package/README.md

@@ -33,7 +33,7 @@ intelligence sync
 | Command | What it does |
 |---|---|
 | `intelligence init [--preview\|--apply]` | Create, convert, restore or align a project |
-| `intelligence sync [adapter]` | Restore locked content if needed, then render all or one enabled adapter |
+| `intelligence sync [adapter] [--compact] [--force]` | Restore locked content, then render or reuse verified unchanged output; `--force` renders and refreshes repository discovery |
 | `intelligence update [@scope/name] [--latest] [--preview\|--apply]` | Plan or apply project and ranged-package updates; `--latest` crosses one package's range |
 | `intelligence upgrade [--next] [--preview\|--apply]` | Replace the installed CLI with the newest version on its npm channel |
 | `intelligence package add\|remove\|list\|search` | Manage versioned Intelligence Packages |

package/cli/commands/init.sh

@@ -233,6 +233,7 @@ else
     [ -d "$root/.pi" ] && targets="$targets pi"
     [ -d "$root/.opencode" ] && targets="$targets opencode"
     if [ -f "$root/GEMINI.md" ] \
+        || [ -f "$root/.antigravity.md" ] \
         || [ -d "$root/.agents/rules" ] \
         || [ -d "$root/.agents/agents" ] \
         || [ -d "$root/.agents/workflows" ]; then

package/cli/commands/sync.sh

@@ -1,16 +1,18 @@
 #!/bin/bash
-# intelligence sync [target] [--compact] - render intelligence to enabled tools.
+# intelligence sync [target] [--compact] [--force] - render intelligence to enabled tools.
 set -euo pipefail
 source "$CLI_DIR/lib/cli-common.sh"
 
 compact=0
+force=0
 target=""
 while [ $# -gt 0 ]; do
     case "$1" in
         --compact) compact=1 ;;
+        --force) force=1 ;;
         -*) die "unknown option '$1'" ;;
         *)
-            [ -z "$target" ] || die "usage: intelligence sync [adapter] [--compact]"
+            [ -z "$target" ] || die "usage: intelligence sync [adapter] [--compact] [--force]"
             target="$1"
             ;;
     esac
@@ -28,13 +30,10 @@ run_sync() {
             ensure_project_current "$IP_ROOT" || return $?
             restore_project_store_if_missing "$IP_ROOT" || return $?
             export_engine_env "$IP_ROOT" || return $?
-            if [ -n "$target" ]; then
-                bash "$IS_ENGINE_DIR/sync.sh" "$target" || return $?
-            else
-                bash "$IS_ENGINE_DIR/sync.sh" || return $?
-            fi
+            sync_with_cache "$target" "$force" || return $?
             ;;
         legacy)
+            [ "$force" -eq 0 ] || die "--force is unavailable for a legacy Intelligence Sync project - run 'intelligence init' to convert it first"
             [ "$compact" -eq 0 ] || die "--compact is unavailable for a legacy Intelligence Sync project - run 'intelligence init' to convert it first"
             # A vendored project syncs with its own engine: its pin is the
             # contract, and a newer bundled engine must not generate against an

package/cli/intelligence

@@ -46,8 +46,9 @@ Usage: intelligence <command> [args]
   init [--preview|--apply]  Initialize, convert, restore or align this project
     --targets a,b --dir name --bare --no-sync   New-project options
     --force               Accept a dirty worktree during legacy project conversion
-  sync [adapter] [--compact]  Restore locked content, then render enabled adapters
+  sync [adapter] [--compact] [--force]  Restore locked content, then render enabled adapters
     --compact            On success show context, warnings and final status; on failure show diagnostics
+    --force              Render again and refresh discovery of unconfigured source directories
   update [@scope/name]    Show an update plan; ask before applying it
     --preview             Show the plan without asking or writing
     --apply               Apply the plan without asking

package/cli/internal/check.sh

@@ -110,6 +110,9 @@ done < <(qmap_keys "$manifest" "packages")
 # onboarding backup and Git policy. Validate every declared target, including
 # disabled ones, so a later enable cannot reveal a stale custom adapter.
 content_dir="$(manifest_intelligence_dir "$manifest")"
+# Ownership across enabled adapters: two adapters claiming one owned path prune
+# each other silently, and sync reports success for both.
+adapter_claims_reset
 while IFS= read -r target; do
     [ -n "$target" ] || continue
     output="$(get_target_output "$manifest" "$target")"
@@ -124,6 +127,10 @@ while IFS= read -r target; do
         warn "adapter '$target' has an invalid ownership contract"
         continue
     fi
+    if [ "$(is_target_enabled "$manifest" "$target")" = "1" ]; then
+        adapter_claims_add_records "$target" "$records" \
+            || warn "$IS_ADAPTER_CLAIM_CONFLICT"
+    fi
     while IFS=$'\t' read -r kind value; do
         if [ "$kind" = "requires" ] \
             && [ "$(is_target_enabled "$manifest" "$target")" = "1" ] \

package/cli/internal/target-state.sh

@@ -29,13 +29,32 @@ if [ "$action" = "enable" ]; then
     [ -n "$output" ] || output="$(default_target_output "$name")"
     validate_adapter_contract_for "$IP_ROOT" "$content_dir" "$name" "$output" \
         || die "adapter '$name' has an invalid ownership contract"
+    records="$(adapter_records_for "$IP_ROOT" "$content_dir" "$name" "$output")" \
+        || die "adapter '$name' has an invalid ownership contract"
     while IFS= read -r required; do
         [ -n "$required" ] || continue
         if [ "$(is_target_enabled "$manifest" "$required")" != "1" ]; then
             die "target '$name' requires target '$required' — enable it first"
         fi
-    done < <(adapter_records_for "$IP_ROOT" "$content_dir" "$name" "$output" \
-        | awk -F '\t' '$1 == "requires" { print $2 }')
+    done < <(awk -F '\t' '$1 == "requires" { print $2 }' <<< "$records")
+
+    # Two adapters claiming one owned path prune each other's output, and both
+    # syncs still report success. Refuse here, while the manifest is the only
+    # thing that would have to change.
+    adapter_claims_reset
+    while IFS= read -r enabled_target; do
+        [ -n "$enabled_target" ] || continue
+        [ "$enabled_target" = "$name" ] && continue
+        [ "$(is_target_enabled "$manifest" "$enabled_target")" = "1" ] || continue
+        enabled_output="$(get_target_output "$manifest" "$enabled_target")"
+        [ -n "$enabled_output" ] || enabled_output="$(default_target_output "$enabled_target")"
+        enabled_records="$(adapter_records_for "$IP_ROOT" "$content_dir" "$enabled_target" "$enabled_output" 2>/dev/null)" \
+            || continue
+        adapter_claims_add_records "$enabled_target" "$enabled_records" || true
+    done < <(target_names "$manifest")
+    adapter_claims_add_records "$name" "$records" \
+        || die "$IS_ADAPTER_CLAIM_CONFLICT"
+
     target_set_enabled "$manifest" "$name" true "$output"
     ensure_target_gitignore "$IP_ROOT" "$manifest" "$name"
     ensure_manifest_publisher_ignores "$IP_ROOT" "$manifest"

package/cli/lib/cli-common.sh

@@ -86,6 +86,7 @@ source "$CLI_DIR/lib/lockfile.sh"
 source "$CLI_DIR/lib/adapter-lifecycle.sh"
 source "$CLI_DIR/lib/gitignore.sh"
 source "$CLI_DIR/lib/onboarding.sh"
+source "$CLI_DIR/lib/sync-cache.sh"
 
 # The engine-content package: OPTIONAL but auto-selected at init. Package by
 # UX (manifest entry, lockfile row, list/search/remove), bundle by mechanics —

package/cli/lib/gitignore.sh

@@ -1,12 +1,56 @@
 #!/bin/bash
 # Generated-output policy derived from each adapter's ownership contract.
 
+# The line that separates what this policy manages from what the project wrote
+# before Intelligence touched the file: everything the CLI appends lands after
+# it, so it is also the boundary of what the CLI may rewrite.
+IS_GITIGNORE_HEADER='# Intelligence generated state and tool output'
+
+# Line endings held in variables, never written as `$'\r'` at the point of use:
+# inside a command substitution bash does not expand that form, so the very same
+# expression stops stripping the CR depending on where it is called from.
+IS_CR=$'\r'
+IS_LF=$'\n'
+IS_CRLF=$'\r\n'
+
+# An ignore file checked out on Windows can hold CRLF, and a CR belongs to the
+# pattern Git matches — so these two helpers decide presence ignoring it, and
+# append in whatever ending the file already uses. Comparing with the CR
+# attached made every existing line look absent on Linux and macOS (where it is
+# part of the line, unlike under MSYS), so each alignment appended an LF copy of
+# a line that was already there and the file grew forever.
+
+# ignore_file_eol_var <file> — set IS_IGNORE_EOL from the file's first line.
+ignore_file_eol_var() {
+    local file="$1" first=""
+    IS_IGNORE_EOL="$IS_LF"
+    [ -s "$file" ] || return 0
+    IFS= read -r first < "$file" || true
+    case "$first" in
+        *"$IS_CR") IS_IGNORE_EOL="$IS_CRLF" ;;
+    esac
+}
+
+# ignore_file_has_line <file> <line> — true when the file lists exactly this
+# line, with or without a trailing CR.
+ignore_file_has_line() {
+    local file="$1" line="$2"
+    [ -f "$file" ] || return 1
+    grep -Fqx -- "$line" "$file" 2>/dev/null && return 0
+    grep -Fqx -- "$line$IS_CR" "$file" 2>/dev/null
+}
+
+# ignore_file_append_line <file> <line> — append in the file's own ending.
+ignore_file_append_line() {
+    local file="$1" line="$2"
+    ignore_file_eol_var "$file"
+    printf '%s%s' "$line" "$IS_IGNORE_EOL" >> "$file"
+}
+
 gitignore_add_line() {
     local root="$1" line="$2" file="$1/.gitignore"
-    if [ -f "$file" ] && grep -Fqx -- "$line" "$file"; then
-        return 0
-    fi
-    printf '%s\n' "$line" >> "$file"
+    ignore_file_has_line "$file" "$line" && return 0
+    ignore_file_append_line "$file" "$line"
 }
 
 gitignore_path_is_ignored() {
@@ -21,10 +65,102 @@ gitignore_tail_is() {
     [ -f "$file" ] || return 1
     local want tail_lines
     want="$(printf '%s\n' "$@")"
-    tail_lines="$(tail -n "$#" -- "$file")"
+    # CR stripped for the comparison only — the chain is the same chain whether
+    # the file is LF or CRLF.
+    tail_lines="$(tail -n "$#" -- "$file" | tr -d '\r')"
     [ "$tail_lines" = "$want" ]
 }
 
+# gitignore_collapse_duplicates <root> <probe-path> <line…> — keep only the LAST
+# occurrence of each given line inside the region this policy owns (its header
+# to end of file).
+#
+# This removes residue, never meaning: Git applies the last matching rule, so
+# identical earlier copies of a line decide nothing. The copies exist because
+# the 0.12.0 repair appended the whole negation chain on every alignment — a
+# project carries one chain per run it made, and 0.12.1 only stopped the growth.
+#
+# Lines above the header predate Intelligence and are left untouched, including
+# a hand-written copy of a line this policy also writes. The probe path is
+# re-checked afterwards: a collapse that somehow changed what Git ignores is
+# rolled back rather than committed.
+gitignore_collapse_duplicates() {
+    local root="$1" probe="$2"; shift 2
+    local file="$root/.gitignore" tmp backup before=0 after=0
+    local -a lines=() managed=("$@") last_idx=()
+    local line key i mi n hdr=-1 keep final_newline=1
+    [ -f "$file" ] || return 0
+
+    # Read and write the file's own bytes, without awk: on Windows it reads in
+    # text mode and would hand back every line stripped of its CR, rewriting a
+    # CRLF file as LF. A line's CR is significant to Git, and either way the
+    # lines this function does not remove must survive byte-for-byte.
+    line=""
+    while IFS= read -r line; do
+        lines[${#lines[@]}]="$line"
+        line=""
+    done < "$file"
+    # `read` returns 1 at EOF but still fills `line` when the file's last line
+    # carries no newline; preserve that ending instead of adding one.
+    if [ -n "$line" ]; then
+        lines[${#lines[@]}]="$line"
+        final_newline=0
+    fi
+    n=${#lines[@]}
+    for ((i = 0; i < n; i++)); do
+        if [ "${lines[i]%"$IS_CR"}" = "$IS_GITIGNORE_HEADER" ]; then hdr=$i; break; fi
+    done
+    [ "$hdr" -ge 0 ] || return 0
+
+    # Where each managed line last occurs below the header. Indexed arrays and
+    # arithmetic `for` only — Bash 3.2 has no associative arrays.
+    for ((mi = 0; mi < ${#managed[@]}; mi++)); do
+        last_idx[mi]=-1
+        for ((i = hdr + 1; i < n; i++)); do
+            [ "${lines[i]%"$IS_CR"}" = "${managed[mi]}" ] && last_idx[mi]=$i
+        done
+    done
+
+    tmp="$file.cli.tmp"
+    {
+        for ((i = 0; i < n; i++)); do
+            keep=1
+            if [ "$i" -gt "$hdr" ]; then
+                key="${lines[i]%"$IS_CR"}"
+                for ((mi = 0; mi < ${#managed[@]}; mi++)); do
+                    if [ "$key" = "${managed[mi]}" ] && [ "$i" -ne "${last_idx[mi]}" ]; then
+                        keep=0
+                        break
+                    fi
+                done
+            fi
+            [ "$keep" -eq 1 ] || continue
+            if [ "$i" -eq $((n - 1)) ] && [ "$final_newline" -eq 0 ]; then
+                printf '%s' "${lines[i]}"
+            else
+                printf '%s\n' "${lines[i]}"
+            fi
+        done
+    } > "$tmp"
+    if [ ! -s "$tmp" ] || cmp -s "$tmp" "$file"; then
+        rm -f "$tmp"
+        return 0
+    fi
+
+    before=0
+    gitignore_path_is_ignored "$root" "$probe" || before=$?
+    backup="$file.cli.bak"
+    cp -- "$file" "$backup"
+    mv -- "$tmp" "$file"
+    after=0
+    gitignore_path_is_ignored "$root" "$probe" || after=$?
+    if [ "$after" != "$before" ]; then
+        mv -- "$backup" "$file"
+        return 0
+    fi
+    rm -f "$backup"
+}
+
 # Git cannot re-include a child of an excluded directory, so an include needs an
 # explicit negation for every parent. A negation only wins when it comes after
 # the rule excluding the parent, and the only repair an append can make is to
@@ -59,7 +195,7 @@ gitignore_add_effective_include() {
     gitignore_path_is_ignored "$root" "$value" || rc=$?
     case "$rc" in
         0) ;;
-        1|2) return 0 ;;
+        1|2) gitignore_collapse_duplicates "$root" "$value" "${negations[@]}"; return 0 ;;
         *) return "$rc" ;;
     esac
 
@@ -67,17 +203,25 @@ gitignore_add_effective_include() {
     # chain last. Already last means appending cannot help — leave it, and let
     # `status --check` report the re-inclusion this policy could not make
     # effective rather than growing the file forever.
-    gitignore_tail_is "$root/.gitignore" "${negations[@]}" && return 0
-    printf '%s\n' "${negations[@]}" >> "$root/.gitignore"
+    if ! gitignore_tail_is "$root/.gitignore" "${negations[@]}"; then
+        for line in "${negations[@]}"; do
+            ignore_file_append_line "$root/.gitignore" "$line"
+        done
+    fi
+    # Either way the chain now stands last, so any earlier copy of it is the
+    # residue an older CLI appended; collapsing runs on both paths so a project
+    # converges on one copy whether or not this run had to move anything.
+    gitignore_collapse_duplicates "$root" "$value" "${negations[@]}"
 }
 
 ensure_gitignore_header() {
     local root="$1" file="$1/.gitignore"
-    if [ ! -f "$file" ] || ! grep -Fqx '# Intelligence generated state and tool output' "$file"; then
+    if ! ignore_file_has_line "$file" "$IS_GITIGNORE_HEADER"; then
         if [ -f "$file" ] && [ -s "$file" ] && [ -n "$(tail -c 1 "$file" 2>/dev/null)" ]; then
-            printf '\n' >> "$file"
+            ignore_file_eol_var "$file"
+            printf '%s' "$IS_IGNORE_EOL" >> "$file"
         fi
-        printf '%s\n' '# Intelligence generated state and tool output' >> "$file"
+        ignore_file_append_line "$file" "$IS_GITIGNORE_HEADER"
     fi
 }
 
@@ -125,10 +269,8 @@ publisher_ignore_file_names() {
 
 publisher_ignore_add_line() {
     local file="$1" line="$2"
-    if grep -Fqx -- "$line" "$file" 2>/dev/null; then
-        return 0
-    fi
-    printf '%s\n' "$line" >> "$file"
+    ignore_file_has_line "$file" "$line" && return 0
+    ignore_file_append_line "$file" "$line"
     PUBLISH_IGNORE_FILE_CHANGED=1
 }
 
@@ -148,11 +290,12 @@ ensure_manifest_publisher_ignores() {
         file="$root/$rel"
         [ -f "$file" ] || continue
         PUBLISH_IGNORE_FILE_CHANGED=0
-        if ! grep -Fqx '# Intelligence development context and generated output' "$file" 2>/dev/null; then
+        if ! ignore_file_has_line "$file" '# Intelligence development context and generated output'; then
             if [ -s "$file" ] && [ -n "$(tail -c 1 "$file" 2>/dev/null)" ]; then
-                printf '\n' >> "$file"
+                ignore_file_eol_var "$file"
+                printf '%s' "$IS_IGNORE_EOL" >> "$file"
             fi
-            printf '%s\n' '# Intelligence development context and generated output' >> "$file"
+            ignore_file_append_line "$file" '# Intelligence development context and generated output'
             PUBLISH_IGNORE_FILE_CHANGED=1
         fi
         publisher_ignore_add_path "$file" '.intelligence'

package/cli/lib/sync-cache.sh

@@ -0,0 +1,202 @@
+#!/bin/bash
+# Optional CLI optimization. Cache data never supplies paths or executable code:
+# every dependency is derived again from the manifest and built-in contracts.
+
+sync_cache_safe_path() {
+    local path="$1" probe="$1"
+    case "$path" in *[[:cntrl:]]*|*\\*|*\"*) return 1 ;; esac
+    # Include ancestors: find does not report a link above its starting path.
+    while [ -n "$probe" ] && [ "$probe" != / ]; do
+        case "$probe" in "$REPO_ROOT"|"$CLI_DIR"|"$IS_ENGINE_DIR") break ;; esac
+        [ ! -L "$probe" ] || return 1
+        probe="${probe%/*}"
+    done
+}
+
+# One checked enumeration and one batch hash, including names, directory/file
+# types and executable bits. Timestamps cannot prove content is unchanged.
+# Unsupported paths/types are a cache miss, never an incomplete fingerprint.
+sync_cache_fingerprint() (
+    local work="$1" path kind executable seen=$'\n'
+    local -a existing
+    existing=()
+    shift
+    : > "$work/entries" || return 1
+    : > "$work/files" || return 1
+    : > "$work/list" || return 1
+    for path in "$@"; do
+        sync_cache_safe_path "$path" || return 1
+        # Shared managed destinations are declared by several adapters. Walking
+        # the same tree again only multiplies filesystem probes on Windows.
+        case "$seen" in *$'\n'"$path"$'\n'*) continue ;; esac
+        seen="$seen$path"$'\n'
+        if [ -e "$path" ]; then
+            existing+=("$path")
+        else
+            printf 'missing\t%s\n' "$path" >> "$work/entries" || return 1
+        fi
+    done
+    if [ "${#existing[@]}" -gt 0 ]; then
+        find "${existing[@]}" -print0 > "$work/list" || return 1
+    fi
+    while IFS= read -r -d '' path; do
+        # Starting-path ancestors were checked above. find does not follow
+        # links, so checking each returned entry once covers the entire tree.
+        case "$path" in *[[:cntrl:]]*|*\\*|*\"*) return 1 ;; esac
+        [ ! -L "$path" ] || return 1
+        executable=0
+        if [ -f "$path" ]; then
+            kind='file'
+            [ ! -x "$path" ] || executable=1
+            printf '%s\n' "$path" >> "$work/files" || return 1
+        elif [ -d "$path" ]; then
+            kind=directory
+        else
+            return 1
+        fi
+        printf '%s\t%s\t%s\n' "$kind" "$executable" "$path" >> "$work/entries" || return 1
+    done < "$work/list"
+    # find order need not be stable. Sort both streams; preserve path-to-hash
+    # association by feeding the sorted file list into a single git process.
+    LC_ALL=C sort -u "$work/entries" > "$work/sorted" || return 1
+    LC_ALL=C sort -u "$work/files" > "$work/paths" || return 1
+    if command -v cygpath >/dev/null 2>&1; then
+        # Git for Windows does not translate POSIX paths received on stdin.
+        cygpath -m -f "$work/paths" > "$work/native" || return 1
+    else
+        cp "$work/paths" "$work/native" || return 1
+    fi
+    git hash-object --no-filters --stdin-paths < "$work/native" > "$work/hashes" || return 1
+    cat "$work/sorted" "$work/paths" "$work/hashes" | git hash-object --stdin || return 1
+)
+
+sync_cache_dependencies() {
+    local src section adapter file output records kind value
+    SC_INPUTS=("$CONFIG_FILE" "$REPO_ROOT/intelligence.lock"
+        "$CLI_DIR/intelligence" "$CLI_DIR/engine-package.yaml"
+        "$CLI_DIR/commands" "$CLI_DIR/internal" "$CLI_DIR/lib" "$IS_ENGINE_DIR"
+        "$REPO_ROOT/$IS_CONTENT_REL/adapters")
+    SC_OUTPUTS=()
+    # Project adapters can read arbitrary files or environment and execute any
+    # code. Their dependencies cannot be inferred from their write contract.
+    for file in "$REPO_ROOT/$IS_CONTENT_REL/adapters"/*.sh; do
+        [ ! -e "$file" ] && [ ! -L "$file" ] || return 1
+    done
+    for section in rules agents skills; do
+        load_yaml_list "$CONFIG_FILE" "$section"
+        while IFS= read -r src; do
+            [ -n "$src" ] || continue
+            adapter_contract_safe_concrete_path "$src" || return 1
+            case "$src" in .|./|.intelligence|.intelligence/|.intelligence/sync-cache*) return 1 ;; esac
+            SC_INPUTS+=("$REPO_ROOT/$src")
+        done <<< "$IS_YAML_LIST"
+    done
+    load_targets_cache "$CONFIG_FILE"
+    for file in "$IS_ENGINE_DIR/adapters"/*.sh; do
+        adapter="${file##*/}"; adapter="${adapter%.sh}"
+        [ "$adapter" != _template ] || continue
+        target_enabled_var "$CONFIG_FILE" "$adapter"
+        [ "$IS_TGT_ENABLED" = 1 ] || continue
+        case "$adapter" in agents|antigravity|claude|codex|copilot|cursor|opencode|pi) ;; *) return 1 ;; esac
+        target_output_var "$CONFIG_FILE" "$adapter"
+        output="${IS_TGT_OUTPUT:-.$adapter}"
+        records="$(adapter_contract_records "$adapter" "$file" "$output")" || return 1
+        while IFS=$'\t' read -r kind value; do
+            case "$kind" in owned|managed) SC_OUTPUTS+=("$REPO_ROOT/$value") ;; esac
+        done <<< "$records"
+    done
+    [ "${#SC_OUTPUTS[@]}" -gt 0 ]
+}
+
+sync_cache_input_hash() {
+    local fingerprint
+    fingerprint="$(sync_cache_fingerprint "$1" "${SC_INPUTS[@]}")" || return 1
+    # Explicit environment values that affect rendering, discovery or parsing.
+    # No secrets or inherited environment dump are persisted.
+    printf '%s\n' "$fingerprint" "$2" "$REPO_ROOT" "$CONFIG_FILE" \
+        "$IS_CONTENT_REL" "$IS_MODULE_REL" "$IS_SYNC_CMD" "$IS_MANIFEST_NAME" \
+        "$IS_PROTECTED_DIRS" "$BASH_VERSION" "${OSTYPE:-}" "${LANG:-}" \
+        "${LC_ALL:-}" "${LC_CTYPE:-}" "${LC_COLLATE:-}" "${PATH:-}" "$(umask)" | git hash-object --stdin
+}
+
+sync_cache_directory() {
+    local path="$REPO_ROOT/.intelligence/sync-cache" physical root_physical probe expected
+    sync_cache_safe_path "$path/state" || return 1
+    root_physical="$(cd "$REPO_ROOT" && pwd -P)" || return 1
+    probe="$path"; expected="$root_physical/.intelligence/sync-cache"
+    while [ ! -e "$probe" ]; do probe="${probe%/*}"; expected="${expected%/*}"; done
+    physical="$(cd "$probe" && pwd -P)" || return 1
+    [ "$physical" = "$expected" ] || return 1
+    if [ "${1:-}" = create ]; then mkdir -p "$path" || return 1; fi
+    SC_DIRECTORY="$path"
+}
+
+sync_cache_read() {
+    local file="$1" input="$2" output="$3" work="$4" header report_hash actual
+    [ -f "$file" ] && [ ! -L "$file" ] || return 1
+    IFS= read -r header < "$file" || return 1
+    case "$header" in "intelligence-sync-cache-v1 $input $output "*) ;; *) return 1 ;; esac
+    report_hash="${header##* }"
+    case "$report_hash" in ''|*[!a-f0-9]*) return 1 ;; esac
+    [ "${#report_hash}" -eq 40 ] || [ "${#report_hash}" -eq 64 ] || return 1
+    tail -n +2 "$file" > "$work/report" || return 1
+    actual="$(git hash-object --stdin < "$work/report")" || return 1
+    [ "$actual" = "$report_hash" ] || return 1
+    grep -q '^IS_STATUS=ok\($\| \)' "$work/report" || return 1
+    grep -q '^=== Done:' "$work/report" || return 1
+}
+
+# Keep actionable diagnostics, including the multi-line unsynced-directory
+# report that compact mode intentionally omits. Never replay renderer progress.
+sync_cache_report() {
+    awk '
+        /^(WARNING:|  WARN:)/ { warning=1; print; next }
+        warning && /^    / { print; next }
+        { warning=0 }
+        /^(CONTEXT:|IS_STATUS=ok|=== Done:|=== WARNING:|  NOT SYNCED:|  Wire one in:)/ { print }
+    ' "$1"
+}
+
+sync_with_cache() (
+    local target="$1" force="$2" work before after outputs report_hash rc=0 cacheable=0
+    work="$(mktemp -d -t intelligence-cache-XXXXXX)" || return 1
+    trap 'rm -rf "$work"' EXIT
+    if sync_cache_dependencies && sync_cache_directory; then
+        before="$(sync_cache_input_hash "$work" "$target")" || before=""
+        [ -z "$before" ] || cacheable=1
+    fi
+    if [ "$cacheable" = 1 ] && [ "$force" = 0 ]; then
+        outputs="$(sync_cache_fingerprint "$work" "${SC_OUTPUTS[@]}")" || outputs=""
+        if [ -n "$outputs" ] && sync_cache_read "$SC_DIRECTORY/state" "$before" "$outputs" "$work"; then
+            echo '  Unchanged: verified sources and generated output; skipped rendering (use --force to refresh discovery).'
+            cat "$work/report"
+            return 0
+        fi
+    fi
+    # A failed or interrupted attempt must not leave a success cache reusable.
+    if [ "$cacheable" = 1 ]; then
+        rm -f "$SC_DIRECTORY/state" || cacheable=0
+    fi
+    # Buffer once so success diagnostics can be replayed without asking the
+    # engine to know about persistent CLI state. Preserve the engine exit code.
+    bash "$IS_ENGINE_DIR/sync.sh" "$target" > "$work/log" 2>&1 || rc=$?
+    cat "$work/log"
+    [ "$rc" = 0 ] || return "$rc"
+    [ "$cacheable" = 1 ] || return 0
+    after="$(sync_cache_input_hash "$work" "$target")" || return 0
+    [ "$before" = "$after" ] || return 0
+    outputs="$(sync_cache_fingerprint "$work" "${SC_OUTPUTS[@]}")" || return 0
+    sync_cache_report "$work/log" > "$work/report" || return 0
+    report_hash="$(git hash-object --stdin < "$work/report")" || return 0
+    # Recheck containment before publishing. mktemp+rename avoids following a
+    # pre-existing state-file link, and readers see only complete records.
+    sync_cache_directory create || return 0
+    local staged
+    staged="$(mktemp "$SC_DIRECTORY/state-XXXXXX")" || return 0
+    if { printf 'intelligence-sync-cache-v1 %s %s %s\n' "$after" "$outputs" "$report_hash"; cat "$work/report"; } > "$staged"; then
+        mv -f "$staged" "$SC_DIRECTORY/state" || rm -f "$staged"
+    else
+        rm -f "$staged"
+    fi
+    return 0
+)

package/engine/ENGINE_SHA

@@ -1 +1 @@
-179b1e89ade2ac7d833750458de1babe0c7a6d90
+f23e407da080869b07481730d81b6ebce73a1d2e

package/engine/VERSION

@@ -1 +1 @@
-0.16.0
+0.17.0

package/engine/adapters/antigravity.sh

@@ -2,18 +2,32 @@
 # intelligence-sync: Google Antigravity adapter
 # Transforms source prompts to Antigravity's native resource model.
 #
+# Vendor sources checked 2026-09-20: antigravity.google/docs/{rules-workflows,
+# skills,subagents} and /docs/cli/{best-practices,gcli-migration}. Where this
+# adapter goes past what they state, the comment says so — the vendor documents
+# less than the product implements, and an unmarked guess is what drifts.
+#
 # Rules:
-#   - Always-on (no `paths:`) -> SKIPPED here. Antigravity reads AGENTS.md
-#     natively at the workspace root, and the `agents` adapter inlines
-#     always-on rule content into it. Emitting copies under .agents/rules/
-#     would double-load the same text.
+#   - Always-on (no `paths:`) -> SKIPPED here. The CLI docs tell a project to
+#     "Create a GEMINI.md or AGENTS.md file at your workspace root", and the
+#     `agents` adapter inlines always-on rule content into AGENTS.md. Emitting
+#     copies under .agents/rules/ would double-load the same text.
 #   - Path-scoped (with `paths:`) -> .agents/rules/<name>.md carrying
-#     `trigger: glob` and `globs:` (activation modes: always_on, manual,
-#     model_decision, glob). Antigravity documents a 12,000-character limit
-#     per rule file, so scoped rules stay short.
-#   - GEMINI.md outranks AGENTS.md in Antigravity's rule precedence, so the
-#     contract quarantines it at onboarding: left in place it would silently
-#     override every synced rule.
+#     `trigger: glob` and `globs:`. NOT vendor-documented: the rules page names
+#     four activation modes in prose (manual, always on, model decision, glob
+#     pattern) and no frontmatter key, format or example anywhere. These keys
+#     follow the Windsurf-lineage convention Antigravity inherits; re-check
+#     them whenever that page grows a real schema.
+#   - "Rules files are limited to 12,000 characters each" is documented, so a
+#     generated scoped rule above the limit warns (targets.antigravity.
+#     warn_rule_limit).
+#   - Workspace-root instruction files outrank AGENTS.md where both are read:
+#     GEMINI.md over AGENTS.md, and .antigravity.md over GEMINI.md in the CLI.
+#     The docs host states neither order — nor AGENTS.md support on its rules
+#     page — so both come from the CLI pages above plus third-party reports of
+#     IDE 1.20.3. The contract quarantines both files at onboarding either way:
+#     left in place, either silently overrides every synced rule, and a file
+#     the project does not have costs nothing to declare.
 # Skills:
 #   - Copied to .agents/skills/ (Agent Skills open standard, shared with
 #     Codex, Pi and opencode). Antigravity reads that fixed workspace path,
@@ -38,17 +52,47 @@ adapter_contract_antigravity() {
     adapter_contract_owned "$output/agents"
     adapter_contract_managed ".agents/skills"
     adapter_contract_legacy "GEMINI.md"
+    adapter_contract_legacy ".antigravity.md"
     adapter_contract_ignore "GEMINI.md"
+    adapter_contract_ignore ".antigravity.md"
     adapter_contract_ignore "$output/rules/"
     adapter_contract_ignore "$output/agents/"
     adapter_contract_ignore ".agents/skills/"
 }
 
+# Documented Antigravity limit: "Rules files are limited to 12,000 characters
+# each." A rule over it is not truncated visibly — the tool decides what to do
+# with it — so sync reports the overflow instead of guessing. A project may
+# match another effective limit or turn the warning off.
+# The count is awk's `length()`, which is characters where the awk build is
+# locale-aware and bytes where it is not; the two agree on ASCII rules.
+# Sets IS_AG_RULE_LIMIT (0 disables the check).
+antigravity_rule_limit() {
+    local config_file="$1"
+    local setting
+    setting="$(get_target_field "$config_file" "antigravity" "warn_rule_limit")"
+    case "$setting" in
+        ''|true) IS_AG_RULE_LIMIT=12000 ;;
+        false)   IS_AG_RULE_LIMIT=0 ;;
+        *[!0-9]*|0|0*)
+            echo "ERROR: targets.antigravity.warn_rule_limit must be true, false, or a positive character count without leading zeros." >&2
+            return 1
+            ;;
+        *) IS_AG_RULE_LIMIT="$setting" ;;
+    esac
+}
+
 sync_antigravity_rules() {
     local repo_root="$1"
     local config_file="$2"
     local output_dir="$3"
 
+    # Read before the early return: a malformed setting is a manifest error
+    # whether or not this project happens to have a scoped rule today.
+    local rule_limit
+    antigravity_rule_limit "$config_file" || return 1
+    rule_limit="$IS_AG_RULE_LIMIT"
+
     local src f
     local -a files=()
     load_yaml_list "$config_file" "rules"
@@ -78,25 +122,50 @@ sync_antigravity_rules() {
         return 0
     fi
 
-    # Path-scoped rule -> Glob activation (paths -> globs)
+    # Path-scoped rule -> Glob activation (paths -> globs). The rewrite is
+    # anchored inside the frontmatter block: a body line may legitimately start
+    # with `paths:` (a rule documenting rule syntax does exactly that), and
+    # rewriting it would corrupt the text it teaches.
+    #
+    # stdout carries nothing but the character-count overflow report, so the
+    # limit check costs no extra process.
+    local overflow
     is_fin_awk_vars
-    awk "${IS_FIN_V[@]}" -v dst="$output_dir/rules" "$IS_AWK_LIB"'
+    overflow="$(awk "${IS_FIN_V[@]}" -v dst="$output_dir/rules" -v limit="$rule_limit" "$IS_AWK_LIB"'
+        function emit(line,   rendered) {
+            rendered = fin_line(line)
+            print rendered > out
+            chars[out] += length(rendered) + 1
+        }
         FNR == 1 {
             if (out != "") close(out)
             out = dst "/" base_name(FILENAME)
+            chars[out] = 0
+            fm = 0
         }
-        {
-            sub(/\r$/, "")
-            sub(/^paths:/, "globs:")
-        }
+        { sub(/\r$/, "") }
         FNR == 1 {
-            print fin_line($0) > out
-            print fin_line("trigger: glob") > out
+            if ($0 == "---") fm = 1
+            emit($0)
+            emit("trigger: glob")
             next
         }
-        { print fin_line($0) > out }
-        END { if (out != "") close(out) }
-    ' "${scoped[@]}"
+        fm == 1 && $0 == "---" { fm = 2; emit($0); next }
+        fm == 1 { sub(/^paths:/, "globs:") }
+        { emit($0) }
+        END {
+            if (out != "") close(out)
+            if (limit > 0)
+                for (f in chars)
+                    if (chars[f] > limit) printf "%s\t%d\n", f, chars[f]
+        }
+    ' "${scoped[@]}" | sort)"
+
+    local over_file over_chars
+    while IFS=$'\t' read -r over_file over_chars; do
+        [ -n "$over_file" ] || continue
+        echo "WARNING: Antigravity limits a rule file to $rule_limit characters: ${over_file#"$repo_root/"} renders $over_chars; split the rule, shorten it, set targets.antigravity.warn_rule_limit to the effective limit, or set it to false to disable this warning." >&2
+    done <<< "$overflow"
 
     for f in "${scoped[@]}"; do
         base="${f##*/}"
@@ -146,18 +215,20 @@ sync_antigravity_agents() {
             fi
             header+="${LS}subagent: true"
             header+="${LS}mainAgent: false"
-            # A readonly agent gets an explicit allowlist. It holds only tool
-            # identifiers the official docs name, because an unknown entry in
-            # an allowlist silently removes a capability rather than failing:
-            # a directory-listing tool is left out until one is documented.
+            # A readonly agent gets an explicit allowlist, and it may hold only
+            # names the vendor documents: "Specifying an unmapped or misspelled
+            # tool name in the `tools` list may cause the subagent process to
+            # hang during execution." The subagents page names four —
+            # view_file, replace_file_content, grep_search, run_command — and
+            # publishes no master list, so readonly takes the two that read.
+            # Web and directory tools appear in leaked prompt dumps only; a
+            # hang is too expensive a bet on an unpublished name.
             # An unrestricted agent declares no list and inherits the main
             # agent's tools, which is Antigravity's default.
             if [ "$access" = "readonly" ]; then
                 header+="${LS}tools:"
                 header+="${LS}  - view_file"
                 header+="${LS}  - grep_search"
-                header+="${LS}  - search_web"
-                header+="${LS}  - read_url_content"
             fi
             header+="${LS}---"
             header+="${LS}"
@@ -176,6 +247,31 @@ sync_antigravity_agents() {
     echo "  -> Agents: $count"
 }
 
+# Antigravity's resource paths are fixed, not configured: the docs call
+# .agents/ a default with backward compatibility for .agent/, and name no
+# setting that moves it. A configured output anywhere else therefore renders
+# rules and agents the tool will never load, and leaves whatever the default
+# path already holds behind as the only thing it does read. Sync still writes
+# the requested path — rendering elsewhere for inspection is legitimate — but
+# it says what the tool will actually see.
+antigravity_warn_unread_output() {
+    local repo_root="$1"
+    local output_dir="$2"
+
+    # Compare the resolved path, not its spelling: `.agents`, `./.agents` and
+    # `.agents//` are the same directory, and the writer reaches it either way.
+    adapter_contract_rel_path "${output_dir#"$repo_root"/}"
+    local rel="$IS_ADAPTER_REL_PATH"
+    case "$rel" in
+        .agents|.agent) return 0 ;;
+    esac
+
+    echo "WARNING: Antigravity reads .agents/rules and .agents/agents (legacy .agent/), never a configured output: targets.antigravity.output '$rel' renders rules and agents no Antigravity surface loads." >&2
+    if [ -d "$repo_root/.agents/rules" ] || [ -d "$repo_root/.agents/agents" ]; then
+        echo "         .agents/ still holds output from an earlier run; that stale copy is what Antigravity loads. Remove it, or set the output back to .agents." >&2
+    fi
+}
+
 sync_to_antigravity() {
     local repo_root="$1"
     local config_file="$2"
@@ -183,6 +279,8 @@ sync_to_antigravity() {
 
     echo "=== Antigravity ==="
 
+    antigravity_warn_unread_output "$repo_root" "$output_dir"
+
     rm -rf "$output_dir/rules" "$output_dir/agents"
     mkdir -p "$output_dir/rules" "$output_dir/agents"
 

package/engine/adapters/cursor.sh

@@ -62,7 +62,10 @@ sync_cursor_rules() {
     done < <(frontmatter_index "paths#" "${files[@]}")
     [ "${#scoped[@]}" -gt 0 ] || return 0
 
-    # Path-scoped rule -> Auto Attached (paths -> globs)
+    # Path-scoped rule -> Auto Attached (paths -> globs). The rewrite is
+    # anchored inside the frontmatter block: a body line may legitimately start
+    # with `paths:` (a rule documenting rule syntax does exactly that), and
+    # rewriting it would corrupt the text it teaches.
     is_fin_awk_vars
     awk "${IS_FIN_V[@]}" -v dst="$output_dir/rules" "$IS_AWK_LIB"'
         FNR == 1 {
@@ -70,12 +73,17 @@ sync_cursor_rules() {
             nm = base_name(FILENAME)
             sub(/\.md$/, ".mdc", nm)
             out = dst "/" nm
+            fm = 0
         }
-        {
-            sub(/\r$/, "")
-            sub(/^paths:/, "globs:")
+        { sub(/\r$/, "") }
+        FNR == 1 {
+            if ($0 == "---") fm = 1
+            print fin_line($0) > out
+            print fin_line("alwaysApply: false") > out
+            next
         }
-        FNR == 1 { print fin_line($0) > out; print fin_line("alwaysApply: false") > out; next }
+        fm == 1 && $0 == "---" { fm = 2; print fin_line($0) > out; next }
+        fm == 1 { sub(/^paths:/, "globs:") }
         { print fin_line($0) > out }
     ' "${scoped[@]}"
     for f in "${scoped[@]}"; do

package/engine/lib/adapter-contract.sh

@@ -19,6 +19,79 @@ adapter_contract_function() {
     printf 'adapter_contract_%s' "$1"
 }
 
+# --- cross-adapter ownership -------------------------------------------------
+#
+# `owned` is exclusive: one adapter writes and prunes that path. `managed` is
+# shared on purpose — .agents/skills is filled by Antigravity, Codex, Pi and
+# opencode from identical content — so two `managed` claims on one path are
+# legal. Any other collision means two adapters prune each other: whichever
+# runs last wins, the earlier adapter's output is gone, and both report
+# success. `intelligence sync codex` with codex output set to `.agents` did
+# exactly that to Antigravity's agents.
+#
+# Claims are compared by resolved path, never by spelling: `.agents`,
+# `./.agents` and `.agents//` name one directory, `validate_output_path`
+# resolves them alike, and a lexical comparison would miss the collision that
+# actually happens on disk. (normalize_path_var comes from lib/common.sh, which
+# both the engine and the CLI source before this file.)
+#
+# State is one "adapter<TAB>kind<TAB>path" record per line in IS_ADAPTER_CLAIMS.
+# A conflict is reported through IS_ADAPTER_CLAIM_CONFLICT, never printed and
+# never captured in a subshell: the accumulator has to survive the call.
+# shellcheck disable=SC2034  # IS_ADAPTER_CLAIM_CONFLICT is read by callers in the engine and the CLI
+adapter_claims_reset() {
+    IS_ADAPTER_CLAIMS=""
+    IS_ADAPTER_CLAIM_CONFLICT=""
+}
+
+# adapter_contract_rel_path <path> — the repo-relative spelling every claim and
+# every output comparison uses. Sets IS_ADAPTER_REL_PATH ("" for the repo root).
+adapter_contract_rel_path() {
+    normalize_path_var "$1"
+    IS_ADAPTER_REL_PATH="${IS_NORM_PATH#/}"
+}
+
+# adapter_claims_add <adapter> <kind> <path>
+# Registers the claim, or sets IS_ADAPTER_CLAIM_CONFLICT and returns 1.
+# shellcheck disable=SC2034  # the conflict text is consumed by the caller
+adapter_claims_add() {
+    local adapter="$1" kind="$2" path
+    adapter_contract_rel_path "$3"
+    path="$IS_ADAPTER_REL_PATH"
+    local prev_adapter prev_kind prev_path
+    while IFS=$'\t' read -r prev_adapter prev_kind prev_path; do
+        [ -n "$prev_adapter" ] || continue
+        [ "$prev_adapter" = "$adapter" ] && continue
+        case "$path" in
+            "$prev_path"|"$prev_path"/*) ;;
+            *) case "$prev_path" in "$path"/*) ;; *) continue ;; esac ;;
+        esac
+        # Two `managed` claims agree by design; anything else prunes.
+        [ "$kind" = "owned" ] || [ "$prev_kind" = "owned" ] || continue
+        if [ "$path" = "$prev_path" ]; then
+            IS_ADAPTER_CLAIM_CONFLICT="adapters '$prev_adapter' ($prev_kind) and '$adapter' ($kind) both claim '$path'; an owned path belongs to one adapter, so whichever syncs last prunes the other's output"
+        else
+            IS_ADAPTER_CLAIM_CONFLICT="adapter '$adapter' claims '$path' ($kind) nested in '$prev_path' ($prev_kind) claimed by '$prev_adapter'; whichever syncs last prunes the other's output"
+        fi
+        return 1
+    done <<< "$IS_ADAPTER_CLAIMS"
+    IS_ADAPTER_CLAIMS="$IS_ADAPTER_CLAIMS$adapter"$'\t'"$kind"$'\t'"$path"$'\n'
+}
+
+# adapter_claims_add_records <adapter> <records>
+# Feeds every owned/managed record of one adapter through adapter_claims_add.
+# Returns 1 on the first conflict, which stays in IS_ADAPTER_CLAIM_CONFLICT.
+adapter_claims_add_records() {
+    local adapter="$1" records="$2" kind value
+    while IFS=$'\t' read -r kind value; do
+        case "$kind" in
+            owned|managed) ;;
+            *) continue ;;
+        esac
+        adapter_claims_add "$adapter" "$kind" "$value" || return 1
+    done <<< "$records"
+}
+
 # Reject records that could address anything outside the repository. Contract
 # paths are always repo-relative; ignore/include records may contain globs.
 adapter_contract_safe_path() {

package/engine/sync.sh

@@ -214,23 +214,50 @@ finish_sync_transaction() {
 trap finish_sync_transaction EXIT
 trap 'exit 130' INT TERM
 
+# Ownership is checked across EVERY enabled adapter, not only the selected one:
+# `intelligence sync codex` still prunes a path another adapter owns, so a
+# filtered run that skipped the check would be the one that destroys output.
+adapter_claims_reset
+agents_dependents=""
+
+# note_agents_dependent <adapter> — collect the AGENTS.md consumers for the
+# root-path warning below. The list is built with its separators so no pattern
+# substitution is needed: Bash 3.2 is the floor, and its ${v//} keeps the
+# backslash of an escaped separator.
+note_agents_dependent() {
+    [ -n "$agents_dependents" ] && agents_dependents="$agents_dependents, "
+    agents_dependents="$agents_dependents$1"
+}
 preflight_idx=0
 while [ "$preflight_idx" -lt "${#ADAPTERS[@]}" ]; do
     adapter="${ADAPTERS[$preflight_idx]}"
     adapter_file="${ADAPTER_FILES[$preflight_idx]}"
     preflight_idx=$((preflight_idx + 1))
-    if [ -n "$TARGET_FILTER" ] && [ "$adapter" != "$TARGET_FILTER" ]; then
-        continue
-    fi
     target_enabled_var "$CONFIG_FILE" "$adapter"
     [ "$IS_TGT_ENABLED" = "1" ] || continue
     target_output_var "$CONFIG_FILE" "$adapter"
     output="$IS_TGT_OUTPUT"
     [ -n "$output" ] || output=".$adapter"
-    validate_output_path "$REPO_ROOT" "$CONFIG_FILE" "$adapter" "$REPO_ROOT/$output"
     records="$(adapter_contract_records "$adapter" "$adapter_file" "$output")" || exit 1
+
+    if ! adapter_claims_add_records "$adapter" "$records"; then
+        echo "ERROR: $IS_ADAPTER_CLAIM_CONFLICT." >&2
+        echo "       Give each adapter its own output: intelligence adapter list" >&2
+        exit 1
+    fi
+
+    if [ -n "$TARGET_FILTER" ] && [ "$adapter" != "$TARGET_FILTER" ]; then
+        # Not selected: its claims are registered, its output is not touched.
+        while IFS=$'\t' read -r kind value; do
+            [ "$kind" = "requires" ] && [ "$value" = "agents" ] && note_agents_dependent "$adapter"
+        done <<< "$records"
+        continue
+    fi
+
+    validate_output_path "$REPO_ROOT" "$CONFIG_FILE" "$adapter" "$REPO_ROOT/$output"
     while IFS=$'\t' read -r kind value; do
         [ "$kind" = "requires" ] || continue
+        [ "$value" = "agents" ] && note_agents_dependent "$adapter"
         target_enabled_var "$CONFIG_FILE" "$value"
         if [ "$IS_TGT_ENABLED" != "1" ]; then
             echo "ERROR: targets.$adapter requires enabled target '$value'." >&2
@@ -244,6 +271,21 @@ while [ "$preflight_idx" -lt "${#ADAPTERS[@]}" ]; do
         esac
     done <<< "$records"
 done
+
+# Every adapter that requires `agents` skips always-on rules because AGENTS.md
+# carries them — and each of those tools reads AGENTS.md at the workspace root
+# only. Rendered anywhere else, the always-on rules reach no tool at all, and a
+# stale root copy from an earlier run is what they keep reading.
+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_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
 SYNC_TX_ACTIVE=1
 
 synced=0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ainova-systems/intelligence",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "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

@@ -89,6 +89,15 @@ or unsupported contracts before enabling or syncing an adapter. `owned` and
 `managed` paths form the transactional write-set: if any adapter fails, the
 engine restores every selected adapter path to its pre-sync state.
 
+`owned` is exclusive across enabled adapters. Two adapters may declare the same
+`managed` path — that is how Antigravity, Codex, Pi and OpenCode share
+`.agents/skills` — but an `owned` path that another enabled adapter also claims,
+or that nests inside one, is refused by `sync`, `adapter enable` and
+`status --check`. Without that refusal the adapter that syncs last prunes the
+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.
+
 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
@@ -177,6 +186,21 @@ Every successful sync prints an adapter-agnostic `CONTEXT:` summary with source
 
 The Codex adapter checks its `project_doc_max_bytes` default (32 KiB). When generated `AGENTS.md` exceeds it, sync prints the byte count and a sufficient Codex setting. The warning says "may truncate" because a developer can already have a larger override. `targets.codex.warn_project_doc_limit` accepts `true` or omission for the default threshold, a positive byte count to match another effective limit, or `false` to disable the Intelligence warning. Both inline and block target forms work, and the field does not change Codex configuration. The warning remains visible in `sync --compact`.
 
+The Antigravity adapter checks the 12,000-character limit its documentation
+states for a rule file. A generated scoped rule above it is reported with its
+rendered character count, because the tool decides what to do with the excess
+and never says so. `targets.antigravity.warn_rule_limit` accepts `true` or
+omission for the documented limit, a positive character count to match another
+effective limit, or `false` to disable the warning.
+
+Antigravity also reads `.agents/rules` and `.agents/agents` only — its paths are
+fixed, not configurable — so a `targets.antigravity.output` anywhere else warns
+that nothing will load the result, and names an earlier `.agents/` copy still on
+disk. The same applies to `AGENTS.md`: every adapter that requires the `agents`
+target skips always-on rules because `AGENTS.md` carries them, and each reads it
+at the workspace root, so a `targets.agents.output` elsewhere warns and lists the
+adapters whose always-on rules then reach no tool.
+
 ### Skills
 
 Skills follow the [Agent Skills standard](https://agentskills.io). Copy each skill directory as a complete bundle—not only `SKILL.md`—because its body may reference `references/`, `scripts/` or `assets/` beside it.

package/packages/sync/references/conventions.md

@@ -333,6 +333,7 @@ By default, commit the manifest, lock, project-owned content, `AGENTS.md`, and s
 CLAUDE.md
 .cursorrules
 GEMINI.md
+.antigravity.md
 
 # Generated Claude and Cursor content; shared settings remain trackable
 .claude/*
@@ -415,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]` first aligns an existing Intelligence project with the installed CLI, restores a missing store strictly from `intelligence.lock`, then renders. 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 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 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.

package/packages/sync/skills/intelligence-sync/SKILL.md

@@ -10,8 +10,10 @@ context: fork
 1. Run `intelligence sync` (or `intelligence sync <adapter>` when one adapter
    was requested). For Intelligence projects, this command first aligns project schema/content
    with the installed CLI and restores a missing package store strictly from
-   `intelligence.lock`.
-2. Require final `IS_STATUS=ok`; relay per-adapter counts and any integrity,
+   `intelligence.lock`. Unchanged inputs and outputs can reuse a successful run.
+   Use `--force` when a fresh render or a new search for unconfigured source
+   directories is requested; an unchanged run replays the previous diagnostics.
+2. Require final `IS_STATUS=ok`; relay reported counts and any integrity,
    model-drift or unsynced-source warnings.
 3. In CI, a required tracked project upgrade is intentionally refused. Report
    the instruction to run `intelligence init --apply` locally, review and