@ainova-systems/intelligence 0.11.0-rc.7 → 0.11.0-rc.9

package/cli/{commands/add.sh → internal/package-add.sh}

@@ -1,5 +1,5 @@
 #!/bin/bash
-# intelligence add <spec> [--name @scope/name] [--no-sync]
+# Internal package add operation.
 #
 # Specs:
 #   @scope/name[@range]            resolved ONLY through the manifest's trusted registries
@@ -9,7 +9,7 @@ set -euo pipefail
 source "$CLI_DIR/lib/cli-common.sh"
 
 spec="${1:-}"
-[ -n "$spec" ] || die "usage: intelligence add <@scope/name[@range] | github:org/repo[#path] | git+<url>[@ref][#path]>"
+[ -n "$spec" ] || die "usage: intelligence package add <@scope/name[@range] | github:org/repo[#path] | git+<url>[@ref][#path]>"
 shift || true
 
 no_sync=0
@@ -85,7 +85,7 @@ if [ "$mode" = "registry" ]; then
         echo "  ('intelligence registry list' shows them). Either add its registry:" >&2
         echo "    intelligence registry add <registry-repo-url>" >&2
         echo "  or install from an explicit source you name yourself:" >&2
-        echo "    intelligence add github:org/repo   |   intelligence add git+<url>[@ref][#path]" >&2
+        echo "    intelligence package add github:org/repo   |   intelligence package add git+<url>[@ref][#path]" >&2
         suggest_similar "$manifest" "$name"
         exit 1
     fi
@@ -117,6 +117,7 @@ if [ -z "$ref" ]; then
             die "'$name' has no stable version tags at $url — a registry package must be versioned; use github:/git+ with @<ref> to pin a branch or commit"
         fi
         echo "  NOTE: no version tags at $url — pinning the default branch head" >&2
+        ref="HEAD"
     fi
 fi
 
@@ -125,22 +126,16 @@ sha="$(fetch_package "$url" "${ref:-$resolved_tag}" "$path" "$IP_ROOT/$rel")"
 
 wire_package_sources "$manifest" "$name" "$rel" "$IP_ROOT"
 
-# Manifest entry: a registry package records its range; a direct one records
-# its source so resolution never has to guess it again. The entry is replaced
-# WHOLE — re-adding under a different spec must not leave the old spec's
-# fields behind (a stale ref: would freeze update, a stale url: would pin the
-# old source).
+# The manifest records requested intent only. The resolved source URL/path,
+# tag/ref and SHA live in the required lock. Re-adding a package is the
+# explicit operation for changing its trusted source.
 qmap_delete_key "$manifest" "packages" "$name"
-if [ "$mode" = "registry" ]; then
+if [ -n "$ref" ]; then
+    qmap_set "$manifest" "packages" "$name" "ref" "$ref"
+elif [ -n "$requested" ]; then
     qmap_set "$manifest" "packages" "$name" "version" "$requested"
 else
-    qmap_set "$manifest" "packages" "$name" "url" "$url"
-    [ -n "$path" ] && qmap_set "$manifest" "packages" "$name" "path" "$path"
-    if [ -n "$ref" ]; then
-        qmap_set "$manifest" "packages" "$name" "ref" "$ref"
-    elif [ -n "$requested" ]; then
-        qmap_set "$manifest" "packages" "$name" "version" "$requested"
-    fi
+    die "internal: package '$name' has neither a requested version nor ref"
 fi
 
 lock_upsert "$lock" "$name" "$requested" "$url" "$path" "${ref:-$resolved_tag}" "$sha"

package/cli/{commands/list.sh → internal/package-list.sh}

@@ -1,5 +1,5 @@
 #!/bin/bash
-# intelligence list — packages with requested / locked / installed state.
+# Internal package list operation.
 set -euo pipefail
 source "$CLI_DIR/lib/cli-common.sh"
 
@@ -14,8 +14,13 @@ while IFS= read -r name; do
     range="$(qmap_field "$manifest" "packages" "$name" "version")"
     ref="$(qmap_field "$manifest" "packages" "$name" "ref")"
     resolved="$(qmap_field "$lock" "packages" "$name" "resolved")"
-    state="missing — run 'intelligence install'"
-    [ -d "$IP_ROOT/.intelligence/packages/$name" ] && state="installed"
+    if [ ! -f "$lock" ]; then
+        state="lock missing — restore committed intelligence.lock"
+    elif [ -d "$IP_ROOT/.intelligence/packages/$name" ]; then
+        state="installed"
+    else
+        state="store missing — run 'intelligence sync'"
+    fi
     printf '%s  %s  locked:%s  %s\n' \
         "$name" \
         "${ref:+ref:$ref}${ref:-${range:-*}}" \
@@ -24,5 +29,5 @@ while IFS= read -r name; do
 done < <(qmap_keys "$manifest" "packages")
 
 if [ "$count" -eq 0 ]; then
-    echo "No packages. Add one: intelligence add @ainova-systems/core"
+    echo "No packages. Add one: intelligence package add @ainova-systems/core"
 fi

package/cli/{commands/remove.sh → internal/package-remove.sh}

@@ -1,10 +1,10 @@
 #!/bin/bash
-# intelligence remove <@scope/name> [--no-sync]
+# Internal package remove operation.
 set -euo pipefail
 source "$CLI_DIR/lib/cli-common.sh"
 
 name="${1:-}"
-[ -n "$name" ] || die "usage: intelligence remove <@scope/name>"
+[ -n "$name" ] || die "usage: intelligence package remove <@scope/name>"
 shift || true
 no_sync=0 force=0
 for a in "$@"; do
@@ -24,7 +24,7 @@ if [ "$name" = "$SYNC_PKG_NAME" ] && [ "$force" -eq 0 ]; then
     echo "ERROR: $SYNC_PKG_NAME is the engine's own content — removing it drops every" >&2
     echo "  intelligence-* meta-skill, the authoring rule and the engine agents from" >&2
     echo "  the outputs. The sync engine itself keeps working (it ships with the CLI)." >&2
-    echo "  If that is what you want: intelligence remove $SYNC_PKG_NAME --force" >&2
+    echo "  If that is what you want: intelligence package remove $SYNC_PKG_NAME --force" >&2
     exit 1
 fi
 assert_valid_pkg_name "$name"

package/cli/{commands/search.sh → internal/package-search.sh}

@@ -1,5 +1,5 @@
 #!/bin/bash
-# intelligence search [term] — what the registries offer, and what this project
+# Internal package search operation: what the registries offer and what this project
 # already has. The catalogue view `list` deliberately is not: `list` answers
 # "what does this project depend on", `search` answers "what could it".
 #
@@ -27,7 +27,7 @@ pkg_state() {
     elif [ -d "$IP_ROOT/.intelligence/packages/$name" ]; then
         printf 'installed %s' "$(qmap_field "$IP_ROOT/intelligence.lock" "packages" "$name" "resolved")"
     else
-        printf 'declared (run install)'
+        printf 'declared (run sync)'
     fi
 }
 
@@ -75,9 +75,9 @@ if [ "$rows" -eq 0 ]; then
     else
         echo "No trusted registries (or they offer nothing) — intelligence registry add <repo-url>."
     fi
-    echo "Explicit installs need no registry: intelligence add github:org/repo"
+    echo "Explicit installs need no registry: intelligence package add github:org/repo"
     exit 0
 fi
 
 echo ""
-echo "add one: intelligence add <name>   |   private registry: intelligence registry add <repo-url>"
+echo "add one: intelligence package add <name>   |   private registry: intelligence registry add <repo-url>"

package/cli/internal/package-update.sh

@@ -0,0 +1,103 @@
+#!/bin/bash
+# Internal package range update operation.
+#
+# Resolve requested versions/refs against each package's locked source and
+# rewrite the lock. `update <name>` limits the pass to one package; re-adding
+# is the explicit operation for changing a source URL/path.
+set -euo pipefail
+source "$CLI_DIR/lib/cli-common.sh"
+
+only="" no_sync=0 preview=0
+while [ $# -gt 0 ]; do
+    case "$1" in
+        --no-sync) no_sync=1 ;;
+        --preview) preview=1 ;;
+        @*) only="$1" ;;
+        *) die "unknown argument '$1'" ;;
+    esac
+    shift || true
+done
+
+require_v2
+manifest="$IP_ROOT/intelligence.yaml"
+lock="$IP_ROOT/intelligence.lock"
+
+moved=0 found=0
+while IFS= read -r name; do
+    [ -n "$name" ] || continue
+    # Manifest keys are untrusted input on their way into store paths.
+    assert_valid_pkg_name "$name"
+    [ -n "$only" ] && [ "$name" != "$only" ] && continue
+    # A named package that exists is "found" whatever happens next — a skip
+    # message followed by "not in the manifest" would contradict itself.
+    found=1
+    if [ "$name" = "$SYNC_PKG_NAME" ]; then
+        echo "  $name: engine content follows the installed CLI — skipped"
+        continue
+    fi
+    current="$(qmap_field "$lock" "packages" "$name" "resolved")"
+    locked_requested="$(qmap_field "$lock" "packages" "$name" "requested")"
+    url="$(qmap_field "$lock" "packages" "$name" "url")"
+    path="$(qmap_field "$lock" "packages" "$name" "path")"
+    [ -n "$url" ] || die "$name has no source in intelligence.lock — restore the committed lock or re-add the package"
+    ref="$(qmap_field "$manifest" "packages" "$name" "ref")"
+    range="$(qmap_field "$manifest" "packages" "$name" "version")"
+    [ -n "$ref" ] || [ -n "$range" ] || die "$name has neither version nor ref in the manifest"
+
+    if [ -n "$ref" ]; then
+        tag="$ref"
+        requested=""
+    else
+        picked="$(list_remote_versions "$url" | semver_pick_highest "$range")"
+        [ -n "$picked" ] || { echo "  $name: nothing satisfies '$range' at $url" >&2; continue; }
+        read -r tag _ <<< "$(remote_tag_for_version "$url" "$picked")"
+        requested="$range"
+    fi
+    if [ "$tag" = "$current" ] && [ "$requested" != "$locked_requested" ]; then
+        if [ "$preview" -eq 1 ]; then
+            echo "  $name: request ${locked_requested:-<none>} -> ${requested:-<ref>} (keeps $current)"
+        else
+            locked_sha="$(qmap_field "$lock" "packages" "$name" "sha")"
+            lock_upsert "$lock" "$name" "$requested" "$url" "$path" "$current" "$locked_sha"
+            echo "  $name: request ${locked_requested:-<none>} -> ${requested:-<ref>} (kept $current)"
+        fi
+        moved=$((moved + 1))
+        continue
+    fi
+    if [ "$tag" = "$current" ]; then
+        echo "  $name: ${current:-<none>} (up to date)"
+        continue
+    fi
+    if [ "$preview" -eq 1 ]; then
+        echo "  $name: ${current:-<none>} -> $tag"
+        moved=$((moved + 1))
+        continue
+    fi
+    rel=".intelligence/packages/$name"
+    # Fetch into staging FIRST: a failed clone must leave the current install
+    # fully wired and intact. Only after success is the old shape unwired
+    # (the new version may have dropped a section dir), the store swapped,
+    # and the new shape wired.
+    staging="$IP_ROOT/.intelligence/.staging-$$"
+    rm -rf "$staging"
+    sha="$(fetch_package "$url" "$tag" "$path" "$staging")"
+    unwire_package_sources "$manifest" "$rel"
+    rm -rf "${IP_ROOT:?}/$rel"
+    mkdir -p "$(dirname "$IP_ROOT/$rel")"
+    mv "$staging" "$IP_ROOT/$rel"
+    wire_package_sources "$manifest" "$name" "$rel" "$IP_ROOT"
+    lock_upsert "$lock" "$name" "$requested" "$url" "$path" "$tag" "$sha"
+    echo "  $name: ${current:-<none>} -> $tag"
+    moved=$((moved + 1))
+done < <(qmap_keys "$manifest" "packages")
+
+[ -n "$only" ] && [ "$found" -eq 0 ] && die "package '$only' is not in the manifest"
+if [ "$preview" -eq 1 ]; then
+    echo "updates available: $moved package(s)"
+else
+    echo "updated: $moved package(s)"
+fi
+
+if [ "$preview" -eq 0 ] && [ "$moved" -gt 0 ] && [ "$no_sync" -eq 0 ]; then
+    exec bash "$CLI_DIR/commands/sync.sh"
+fi

package/cli/{commands/install.sh → internal/restore.sh}

@@ -1,5 +1,5 @@
 #!/bin/bash
-# intelligence install [--frozen] [--force] [--no-sync]
+# Internal locked-store restore operation.
 #
 # Restore .intelligence/ from intelligence.lock — the fresh-clone command.
 # --frozen additionally refuses any manifest/lock divergence (CI mode) and
@@ -23,30 +23,22 @@ manifest="$IP_ROOT/intelligence.yaml"
 lock="$IP_ROOT/intelligence.lock"
 
 # --frozen is the reproducibility contract: the lock must agree with the
-# manifest on the package SET and on every requested-source field before a
+# manifest on the package SET and on every requested-intent field before a
 # single byte is restored. Anything less lets a manifest edit ride on a stale
 # lock — the exact drift the flag exists to refuse.
 if [ "$frozen" -eq 1 ]; then
     while IFS= read -r name; do
         [ -n "$name" ] || continue
         [ -n "$(qmap_field "$lock" "packages" "$name" "url")" ] \
-            || die "--frozen: $name is in the manifest but not in intelligence.lock"
+            || die "locked restore: $name is in the manifest but not in intelligence.lock"
         m_ver="$(qmap_field "$manifest" "packages" "$name" "version")"
         m_ref="$(qmap_field "$manifest" "packages" "$name" "ref")"
-        m_url="$(qmap_field "$manifest" "packages" "$name" "url")"
-        m_path="$(qmap_field "$manifest" "packages" "$name" "path")"
         l_req="$(qmap_field "$lock" "packages" "$name" "requested")"
         l_res="$(qmap_field "$lock" "packages" "$name" "resolved")"
-        l_url="$(qmap_field "$lock" "packages" "$name" "url")"
-        l_path="$(qmap_field "$lock" "packages" "$name" "path")"
         [ -z "$m_ver" ] || [ "$m_ver" = "$l_req" ] \
-            || die "--frozen: $name requests '$m_ver' but the lock recorded '$l_req' — run 'intelligence install' without --frozen"
+            || die "locked restore: $name requests '$m_ver' but the lock recorded '$l_req' — reconcile the manifest and lock"
         [ -z "$m_ref" ] || [ "$m_ref" = "$l_res" ] \
             || die "--frozen: $name pins ref '$m_ref' but the lock resolved '$l_res'"
-        [ -z "$m_url" ] || [ "$m_url" = "$l_url" ] \
-            || die "--frozen: $name declares url '$m_url' but the lock recorded '$l_url'"
-        [ -z "$m_path" ] || [ "$m_path" = "$l_path" ] \
-            || die "--frozen: $name declares path '$m_path' but the lock recorded '$l_path'"
     done < <(qmap_keys "$manifest" "packages")
     while IFS= read -r name; do
         [ -n "$name" ] || continue
@@ -76,14 +68,11 @@ if [ -n "$missing" ]; then
             sync_pkg_install "$IP_ROOT"
             continue
         fi
-        url="$(qmap_field "$manifest" "packages" "$name" "url")"
-        path="$(qmap_field "$manifest" "packages" "$name" "path")"
         ref="$(qmap_field "$manifest" "packages" "$name" "ref")"
         range="$(qmap_field "$manifest" "packages" "$name" "version")"
-        if [ -z "$url" ]; then
-            resolve_package_source "$manifest" "$name"
-            url="$RES_URL"; path="$RES_PATH"
-        fi
+        resolve_package_source "$manifest" "$name"
+        url="$RES_URL"; path="$RES_PATH"
+        [ -n "$url" ] || die "no trusted registry declares '$name' and it is absent from intelligence.lock"
         resolved_tag=""
         if [ -z "$ref" ]; then
             picked="$(list_remote_versions "$url" | semver_pick_highest "$range")"

package/cli/internal/target-state.sh

@@ -0,0 +1,57 @@
+#!/bin/bash
+# Internal adapter target-state operation.
+#
+# Change only the manifest. Syncing and deleting generated output are separate
+# explicit actions: a generic target command cannot infer a custom adapter's
+# ownership safely.
+set -euo pipefail
+source "$CLI_DIR/lib/cli-common.sh"
+
+action="${1:-}"
+name="${2:-}"
+[ $# -le 2 ] || die "internal target state: expected <enable|disable> <name>"
+case "$action" in enable|disable) ;; *) die "internal target state: expected <enable|disable> <name>" ;; esac
+[ -n "$name" ] || die "internal target state: missing adapter name"
+assert_valid_target_name "$name"
+
+require_v2
+manifest="$IP_ROOT/intelligence.yaml"
+content_dir="$(manifest_intelligence_dir "$manifest")"
+
+if [ "$action" = "enable" ]; then
+    project_adapter="$IP_ROOT/$content_dir/adapters/$name.sh"
+    bundled_adapter="$IS_ENGINE_DIR/adapters/$name.sh"
+    if [ ! -f "$project_adapter" ] && [ ! -f "$bundled_adapter" ]; then
+        die "adapter '$name' not found — create it first: intelligence adapter create $name"
+    fi
+
+    # These adapters intentionally omit always-on rules because their tools
+    # read AGENTS.md. Do not create a manifest that full sync must refuse.
+    case "$name" in
+        cursor|copilot|codex|pi|opencode)
+            if [ "$(is_target_enabled "$manifest" "agents")" != "1" ]; then
+                die "target '$name' requires target 'agents' — enable it first"
+            fi
+            ;;
+    esac
+
+    output="$(get_target_output "$manifest" "$name")"
+    [ -n "$output" ] || output="$(default_target_output "$name")"
+    target_set_enabled "$manifest" "$name" true "$output"
+    echo "enabled: $name (output: $output)"
+    exit 0
+fi
+
+target_exists "$manifest" "$name" || die "target '$name' is not in the manifest"
+if [ "$name" = "agents" ]; then
+    for dependent in cursor copilot codex pi opencode; do
+        if [ "$(is_target_enabled "$manifest" "$dependent")" = "1" ]; then
+            die "target 'agents' is required by enabled target '$dependent' — disable '$dependent' first"
+        fi
+    done
+fi
+output="$(get_target_output "$manifest" "$name")"
+[ -n "$output" ] || output="$(default_target_output "$name")"
+target_set_enabled "$manifest" "$name" false "$output"
+echo "disabled: $name"
+echo "  generated output was kept; remove only paths owned by this adapter"

package/cli/internal/upgrade-v2.sh

@@ -0,0 +1,133 @@
+#!/bin/bash
+# Internal: bring the project to this CLI's engine: apply v2
+# schema migrations, align the engine-content package to the bundled version,
+# restamp schema_version, sync.
+set -euo pipefail
+source "$CLI_DIR/lib/cli-common.sh"
+
+no_sync=0
+while [ $# -gt 0 ]; do
+    case "$1" in
+        --no-sync) no_sync=1 ;;
+        *) die "internal upgrade: unknown option '$1'" ;;
+    esac
+    shift
+done
+
+require_v2
+manifest="$IP_ROOT/intelligence.yaml"
+
+stamp="$(read_schema_version "$manifest")"
+legacy_stamp="$(top_scalar "$manifest" "sync_version")"
+schema_key_count="$(awk '/^schema_version:[[:space:]]*/ { n++ } END { print n + 0 }' "$manifest")"
+legacy_key_count="$(awk '/^sync_version:[[:space:]]*/ { n++ } END { print n + 0 }' "$manifest")"
+eng="$(bundled_engine_version)"
+[ "$schema_key_count" -le 1 ] || die "manifest has duplicate schema_version keys"
+[ "$legacy_key_count" -le 1 ] || die "manifest has duplicate sync_version keys"
+if [ -n "$stamp" ] && _ver_gt "$stamp" "$eng"; then
+    die "manifest schema $stamp is newer than this CLI's engine $eng — update the global CLI first"
+fi
+if [ -n "$legacy_stamp" ] && _ver_gt "$legacy_stamp" "$eng"; then
+    die "manifest schema $legacy_stamp is newer than this CLI's engine $eng — update the global CLI first"
+fi
+
+# --- v2 schema migrations -------------------------------------------------
+# The engine's own chain owns vendored layouts; this one owns the manifest.
+# Same discipline: ascending, append-only, each migration self-detects and
+# no-ops when already applied.
+
+# v2 migration 0: the original RC manifest called the permanent schema key
+# `sync_version`. Rename it without changing its value; the final stamp below
+# then aligns it with this engine. The archived v1 reader remains separate.
+if [ -n "$legacy_stamp" ]; then
+    if [ -n "$stamp" ]; then
+        [ "$stamp" = "$legacy_stamp" ] || die "manifest has conflicting schema_version '$stamp' and sync_version '$legacy_stamp'"
+        _qmap_stage "$manifest" '$0 !~ /^sync_version:[[:space:]]*/'
+    else
+        _qmap_stage "$manifest" '{ sub(/^sync_version:/, "schema_version:"); print }'
+    fi
+    echo "  migrating: sync_version -> schema_version"
+fi
+
+# v2 migration 1: package entries contain requested intent only. Early RCs
+# also copied resolved url/path into the manifest. Preserve the existing lock
+# as the trusted source and remove that duplicate representation. A direct
+# unversioned package becomes an explicit HEAD pin so its manifest entry stays
+# meaningful after the source fields are removed.
+source_fields_migrated=0
+while IFS= read -r name; do
+    [ -n "$name" ] || continue
+    m_url="$(qmap_field "$manifest" "packages" "$name" "url")"
+    m_path="$(qmap_field "$manifest" "packages" "$name" "path")"
+    [ -n "$m_url" ] || [ -n "$m_path" ] || continue
+    m_ver="$(qmap_field "$manifest" "packages" "$name" "version")"
+    m_ref="$(qmap_field "$manifest" "packages" "$name" "ref")"
+    if [ -z "$m_ver" ] && [ -z "$m_ref" ]; then
+        locked_ref="$(qmap_field "$IP_ROOT/intelligence.lock" "packages" "$name" "resolved")"
+        qmap_set "$manifest" "packages" "$name" "ref" "${locked_ref:-HEAD}"
+    fi
+    qmap_delete_field "$manifest" "packages" "$name" "url"
+    qmap_delete_field "$manifest" "packages" "$name" "path"
+    source_fields_migrated=1
+done < <(qmap_keys "$manifest" "packages")
+if [ "$source_fields_migrated" -eq 1 ]; then
+    echo "  migrating: package url/path -> intelligence.lock"
+fi
+
+# v2 migration 2: staged engine content -> the @ainova-systems/sync package.
+# Pre-package manifests listed `.intelligence/engine/{rules,agents,skills}`
+# as sources fed by a CLI-staged copy; that copy is now an ordinary package
+# entry seeded from the bundle. Post-condition: no `.intelligence/engine`
+# source entries, the package present in manifest+lock+store, stale dir gone.
+migrated=0
+for section in rules agents skills; do
+    while IFS= read -r src; do
+        case "$src" in
+            .intelligence/engine/*)
+                sources_remove_entry "$manifest" "$section" "$src"
+                migrated=1
+                ;;
+        esac
+    done < <(read_yaml_list "$manifest" "$section")
+done
+if [ "$migrated" -eq 1 ]; then
+    echo "  migrating: staged engine content -> $SYNC_PKG_NAME package"
+    rm -rf "$IP_ROOT/.intelligence/engine"
+    sync_pkg_entry "$manifest"
+    sync_pkg_install "$IP_ROOT"
+fi
+
+# --- steady state ---------------------------------------------------------
+# Align the engine-content package with the bundled engine. Only a manifest
+# that HAS the entry is touched — a --bare project opted out, and upgrade
+# respects that.
+have_pkg=0
+while IFS= read -r name; do
+    [ "$name" = "$SYNC_PKG_NAME" ] && have_pkg=1
+done < <(qmap_keys "$manifest" "packages")
+if [ "$have_pkg" -eq 1 ] && [ "$migrated" -eq 0 ]; then
+    pinned="$(qmap_field "$manifest" "packages" "$SYNC_PKG_NAME" "version")"
+    if [ "$pinned" != "$eng" ]; then
+        echo "  $SYNC_PKG_NAME: $pinned -> $eng"
+    fi
+    sync_pkg_entry "$manifest"
+    sync_pkg_install "$IP_ROOT"
+fi
+if [ "$have_pkg" -eq 0 ] && [ "$migrated" -eq 0 ]; then
+    echo "  NOTE: $SYNC_PKG_NAME is not in this manifest (bare setup) — engine meta-skills stay uninstalled; 'intelligence package add $SYNC_PKG_NAME' opts back in." >&2
+fi
+
+# A previous RC could leave this managed directory even after its source
+# entries were already removed. Its presence is itself an upgrade predicate,
+# so always close that post-condition.
+if [ -d "$IP_ROOT/.intelligence/engine" ]; then
+    rm -rf "$IP_ROOT/.intelligence/engine"
+    echo "  removed stale .intelligence/engine"
+fi
+
+stamp_schema_version "$manifest" "$eng"
+echo "  schema_version -> $eng"
+
+if [ "$no_sync" -eq 0 ]; then
+    exec bash "$CLI_DIR/commands/sync.sh"
+fi