@ainova-systems/intelligence 0.11.0-rc.5 → 0.11.0-rc.6

package/cli/commands/add.sh

@@ -78,23 +78,24 @@ assert_valid_pkg_name "$name"
 if [ "$mode" = "registry" ]; then
     resolve_package_source "$manifest" "$name"
     url="$RES_URL"; path="$RES_PATH"
+    if [ -z "$url" ]; then
+        echo "ERROR: no trusted registry declares '$name'." >&2
+        echo "  A name installs only through a registry this project added explicitly" >&2
+        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
+        suggest_similar "$manifest" "$name"
+        exit 1
+    fi
     echo "  resolving $name via $RES_VIA -> $url${path:+ ($path)}"
 fi
 
-# The source must exist before anything else is attempted — a name that fell
-# through to the convention is often just a typo, and that must say so, not
-# die mid-pipeline with no message.
+# The source must exist before anything else is attempted — never die
+# mid-pipeline with no message.
 if ! GIT_TERMINAL_PROMPT=0 git ls-remote "$url" >/dev/null 2>&1; then
     echo "ERROR: no reachable repository at $url" >&2
-    if [ "${RES_VIA:-}" = "convention" ]; then
-        echo "  No registry declares '$name', so it resolved by convention to github.com/${name#@}." >&2
-        echo "  Either the name is misspelled ('intelligence search' lists what registries offer)," >&2
-        echo "  the repo is private (check your git credentials), or its registry is not added yet:" >&2
-        echo "    intelligence registry add <registry-repo-url>" >&2
-        suggest_similar "$manifest" "$name"
-    else
-        echo "  Declared by ${RES_VIA:-the manifest} — check the URL and your git access." >&2
-    fi
+    echo "  Declared by ${RES_VIA:-the spec} — check the URL and your git access." >&2
     exit 1
 fi
 
@@ -124,7 +125,11 @@ 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.
+# 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).
+qmap_delete_key "$manifest" "packages" "$name"
 if [ "$mode" = "registry" ]; then
     qmap_set "$manifest" "packages" "$name" "version" "$requested"
 else

package/cli/commands/init.sh

@@ -33,15 +33,24 @@ esac
 root="$(git rev-parse --show-toplevel 2>/dev/null || pwd)"
 root="$(cd "$root" && pwd)"
 
-targets="agents claude"
+# Never invent a tool the project shows no trace of: every per-tool target is
+# DETECTED from repo markers or named explicitly via --targets. Only `agents`
+# (AGENTS.md, the tool-neutral standard every AGENTS-reading tool shares, and
+# the invariant-required carrier once any of them is on) is unconditional.
+targets="agents"
 if [ -n "$targets_arg" ]; then
     targets="agents $(printf '%s' "$targets_arg" | tr ',' ' ')"
 else
+    if [ -d "$root/.claude" ] || [ -f "$root/CLAUDE.md" ]; then targets="$targets claude"; fi
     [ -d "$root/.cursor" ] && targets="$targets cursor"
     [ -d "$root/.codex" ] && targets="$targets codex"
     [ -d "$root/.pi" ] && targets="$targets pi"
     [ -d "$root/.opencode" ] && targets="$targets opencode"
     [ -d "$root/.github" ] && [ -d "$root/.github/instructions" ] && targets="$targets copilot"
+    if [ "$targets" = "agents" ]; then
+        echo "  NOTE: no tool markers found (.claude/, CLAUDE.md, .cursor/, …) — only AGENTS.md is enabled." >&2
+        echo "        Name your tools explicitly: intelligence init --targets claude,cursor  (or edit targets: later)" >&2
+    fi
 fi
 
 manifest="$root/intelligence.yaml"
@@ -88,14 +97,20 @@ manifest="$root/intelligence.yaml"
     echo "#   \"@ainova-systems/core\":"
     echo "#     version: \"^0.3.0\""
     echo ""
-    echo "# Registries are a TRUST LIST: git repos holding an index.yaml, consulted"
-    echo "# in order — the first to declare a name wins, then the CLI's bundled index,"
-    echo "# then the @org/name -> github.com/org/name convention. Adding one is a"
-    echo "# committed, reviewable act of trust in the names it declares; sources are"
-    echo "# pinned by url+sha in intelligence.lock, and overriding a bundled name"
-    echo "# warns loudly. Managed with 'intelligence registry add|remove'."
-    echo "# registries:"
-    echo "#   - \"https://github.com/acme/intelligence-registry.git\""
+    echo "# Registries are this project's TRUST LIST — the ONLY way a package name"
+    echo "# resolves (there is no built-in catalog and no name->github guessing;"
+    echo "# registry-less installs are always explicit: github:org/repo, git+<url>)."
+    echo "# Git repos holding an index.yaml, consulted in order; first to declare a"
+    echo "# name wins; sources are then pinned by url+sha in intelligence.lock."
+    echo "# Managed with 'intelligence registry add|remove'. Delete a line to"
+    echo "# distrust that catalog — including the default seeded below."
+    if [ "$bare" -eq 1 ] || [ -z "$DEFAULT_REGISTRY_URL" ]; then
+        echo "# registries:"
+        echo "#   - \"https://github.com/acme/intelligence-registry.git\""
+    else
+        echo "registries:"
+        echo "  - \"$DEFAULT_REGISTRY_URL\""
+    fi
 } > "$manifest"
 
 # The package store is restorable state, never committed — the npm model.

package/cli/commands/install.sh

@@ -22,8 +22,44 @@ require_v2
 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
+# 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"
+        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"
+        [ -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
+        found=0
+        while IFS= read -r m; do
+            [ "$m" = "$name" ] && found=1
+        done < <(qmap_keys "$manifest" "packages")
+        [ "$found" -eq 1 ] || die "--frozen: $name is locked but absent from the manifest"
+    done < <(qmap_keys "$lock" "packages")
+fi
+
 # Manifest packages missing from the lock: resolve them now (npm install
-# semantics). Under --frozen that is an error instead.
+# semantics). Under --frozen the drift gate above has already refused.
 missing=""
 while IFS= read -r name; do
     [ -n "$name" ] || continue
@@ -32,7 +68,6 @@ while IFS= read -r name; do
     fi
 done < <(qmap_keys "$manifest" "packages")
 if [ -n "$missing" ]; then
-    [ "$frozen" -eq 1 ] && die "lockfile is missing packages:$missing — run 'intelligence install' without --frozen"
     for name in $missing; do
         # The engine-content package needs no remote resolution: its pin IS
         # the bundled engine version and it seeds from the bundle, offline.
@@ -70,16 +105,25 @@ if [ -f "$lock" ]; then
         if [ -d "$IP_ROOT/$rel" ] && [ "$force" -eq 0 ]; then
             continue
         fi
-        got="$(fetch_package "$url" "$resolved" "$path" "$IP_ROOT/$rel")"
+        # Fetch into staging and commit to the store only after the integrity
+        # verdict: content that violates the lock must never be left where a
+        # re-run (whose dir-exists check skips verification) would sync it.
+        staging="$IP_ROOT/.intelligence/.staging-$$"
+        rm -rf "$staging"
+        got="$(fetch_package "$url" "$resolved" "$path" "$staging")"
         # An empty sha (bundle-seeded content on a dev build) means unknown,
         # not moved — only two known-and-different shas are a finding.
         if [ -n "$sha" ] && [ -n "$got" ] && [ "$got" != "$sha" ]; then
             if [ "$frozen" -eq 1 ]; then
+                rm -rf "$staging"
                 die "$name: fetched $got but the lock pins $sha — the ref moved; refusing under --frozen"
             fi
             echo "  WARN: $name resolved to $got, lock had $sha — updating the lock" >&2
             lock_upsert "$lock" "$name" "$requested" "$url" "$path" "$resolved" "$got"
         fi
+        rm -rf "${IP_ROOT:?}/$rel"
+        mkdir -p "$(dirname "$IP_ROOT/$rel")"
+        mv "$staging" "$IP_ROOT/$rel"
         wire_package_sources "$manifest" "$name" "$rel" "$IP_ROOT"
         echo "= $name@${resolved:-HEAD}"
     done < <(lock_to_tsv "$lock")

package/cli/commands/migrate.sh

@@ -44,13 +44,6 @@ stamp="$(read_engine_stamp "$config")"
 eng="$(bundled_engine_version)"
 [ -n "$stamp" ] && _ver_gt "$stamp" "$eng" && die "project schema $stamp is newer than this CLI's engine $eng — update the CLI first"
 
-# A schema gap is closed by the engine's own proven chain before conversion.
-if [ "$dry_run" -eq 0 ] && { [ -z "$stamp" ] || _ver_gt "$eng" "$stamp"; }; then
-    echo "== applying the engine migration chain ($stamp -> $eng) =="
-    run_migrations "$umbrella" "$(basename "$module_dir")" "" || die "engine migration chain failed (IS_STATUS above) — nothing converted"
-    stamp_version "$config" "$eng"
-fi
-
 # ---- Stage ----------------------------------------------------------------
 stage="$root/.intelligence-migrate-stage.$$"
 [ "$dry_run" -eq 1 ] && stage="$(mktemp -d -t intelligence-migrate-XXXXXX 2>/dev/null || mktemp -d)"
@@ -58,6 +51,24 @@ cleanup_stage() { rm -rf "$stage"; }
 trap cleanup_stage EXIT INT TERM
 mkdir -p "$stage/.intelligence/packages"
 
+# A schema gap is closed by the engine's own proven chain before conversion.
+# Dry-run must preview the SAME pipeline, so it runs the chain too — against
+# a staged copy of the umbrella, leaving the project untouched.
+if [ -z "$stamp" ] || _ver_gt "$eng" "$stamp"; then
+    if [ "$dry_run" -eq 1 ]; then
+        echo "== applying the engine migration chain ($stamp -> $eng) to a staged copy =="
+        cp -R "$umbrella" "$stage/umbrella"
+        run_migrations "$stage/umbrella" "$(basename "$module_dir")" "" > "$stage/chain.log" 2>&1 \
+            || { tail -5 "$stage/chain.log" >&2; die "engine migration chain failed in the staged copy — a real migrate would fail the same way"; }
+        stamp_version "$stage/umbrella/config.yaml" "$eng"
+        config="$stage/umbrella/config.yaml"
+    else
+        echo "== applying the engine migration chain ($stamp -> $eng) =="
+        run_migrations "$umbrella" "$(basename "$module_dir")" "" || die "engine migration chain failed (IS_STATUS above) — nothing converted"
+        stamp_version "$config" "$eng"
+    fi
+fi
+
 echo "== staging =="
 # Engine content arrives as the @ainova-systems/sync package, seeded from the
 # bundle (fetch_package's guard — no network).
@@ -212,6 +223,13 @@ fi
 
 # ---- Commit ---------------------------------------------------------------
 echo "== committing =="
+# .gitignore is part of the transaction: rollback must leave it exactly as
+# found, absent included.
+gitignore_existed=0
+if [ -f "$root/.gitignore" ]; then
+    gitignore_existed=1
+    cp "$root/.gitignore" "$stage/gitignore.orig"
+fi
 if [ ! -f "$root/.gitignore" ] || ! grep -q '^\.intelligence/' "$root/.gitignore"; then
     {
         [ -f "$root/.gitignore" ] && [ -n "$(tail -c 1 "$root/.gitignore" 2>/dev/null)" ] && echo ""
@@ -221,6 +239,11 @@ if [ ! -f "$root/.gitignore" ] || ! grep -q '^\.intelligence/' "$root/.gitignore
 fi
 rollback() {
     rm -rf "$root/.intelligence" "$root/intelligence.yaml" "$root/intelligence.lock"
+    if [ "$gitignore_existed" -eq 1 ]; then
+        cp "$stage/gitignore.orig" "$root/.gitignore"
+    else
+        rm -f "$root/.gitignore"
+    fi
     echo "rolled back — the vendored setup is untouched" >&2
 }
 mv "$stage/.intelligence" "$root/.intelligence"

package/cli/commands/registry.sh

@@ -28,15 +28,7 @@ case "$sub" in
             done < <(registries_list "$IP_ROOT/intelligence.yaml")
             [ "$found" -eq 0 ] && echo "  (none)"
         fi
-        bundled="$(default_index_file)"
-        if [ -n "$bundled" ]; then
-            echo "Bundled index:"
-            while IFS= read -r name; do
-                [ -n "$name" ] || continue
-                echo "  $name -> $(qmap_field "$bundled" "packages" "$name" "url")"
-            done < <(qmap_keys "$bundled" "packages")
-        fi
-        echo "Fallback: @org/name -> https://github.com/org/name.git"
+        echo "Names resolve ONLY through the list above. Registry-less installs are explicit: github:org/repo, git+<url>."
         ;;
     add)
         url="${2:-}"

package/cli/commands/search.sh

@@ -4,7 +4,7 @@
 # "what does this project depend on", `search` answers "what could it".
 #
 # Sources, in resolution order (a name found earlier wins, exactly as `add`
-# resolves it): every scope bound in the manifest, then the bundled index.
+# resolves it): the manifest's trusted registries, in order.
 set -euo pipefail
 source "$CLI_DIR/lib/cli-common.sh"
 
@@ -69,15 +69,13 @@ if [ -n "$manifest" ]; then
         emit_index "$index" "$url"
     done < <(registries_list "$manifest")
 fi
-emit_index "$(default_index_file)" "bundled"
-
 if [ "$rows" -eq 0 ]; then
     if [ -n "$term" ]; then
-        echo "Nothing matching '$term' in the configured registries."
+        echo "Nothing matching '$term' in this project's trusted registries."
     else
-        echo "No registries hold any packages."
+        echo "No trusted registries (or they offer nothing) — intelligence registry add <repo-url>."
     fi
-    echo "Any git repo with rules/, agents/ or skills/ is a package: intelligence add @org/repo"
+    echo "Explicit installs need no registry: intelligence add github:org/repo"
     exit 0
 fi
 

package/cli/commands/update.sh

@@ -21,10 +21,13 @@ require_v2
 manifest="$IP_ROOT/intelligence.yaml"
 lock="$IP_ROOT/intelligence.lock"
 
-moved=0 checked=0
+moved=0 found=0
 while IFS= read -r name; do
     [ -n "$name" ] || continue
     [ -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 moves with the engine — 'intelligence upgrade' owns it"
         continue
@@ -32,22 +35,34 @@ while IFS= read -r name; do
     ref="$(qmap_field "$manifest" "packages" "$name" "ref")"
     [ -n "$ref" ] && { echo "  $name: pinned to ref '$ref' — skipped"; continue; }
     range="$(qmap_field "$manifest" "packages" "$name" "version")"
+    # An exact version is a pin, same as ref: — update never moves pins.
+    if [ -n "$range" ] && semver_is_stable "$range"; then
+        echo "  $name: pinned to $range — edit the manifest to move it"
+        continue
+    fi
     url="$(qmap_field "$manifest" "packages" "$name" "url")"
     path="$(qmap_field "$manifest" "packages" "$name" "path")"
     if [ -z "$url" ]; then
         resolve_package_source "$manifest" "$name"
         url="$RES_URL"; path="$RES_PATH"
     fi
-    checked=$((checked + 1))
     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")"
     current="$(qmap_field "$lock" "packages" "$name" "resolved")"
-    if [ "$tag" = "$current" ]; then
+    cur_url="$(qmap_field "$lock" "packages" "$name" "url")"
+    cur_path="$(qmap_field "$lock" "packages" "$name" "path")"
+    # Same tag is not enough: a registry may re-point a name's source while
+    # keeping the version — the move doctor warns about must be actionable
+    # here, so url/path changes refetch too.
+    if [ "$tag" = "$current" ] && [ "$url" = "$cur_url" ] && [ "$path" = "$cur_path" ]; then
         echo "  $name: ${current:-<none>} (up to date)"
         continue
     fi
     rel=".intelligence/packages/$name"
+    # The new version may have dropped a top-level section dir: unwire the old
+    # shape first, or a dangling store-backed source bricks the next sync.
+    unwire_package_sources "$manifest" "$rel"
     sha="$(fetch_package "$url" "$tag" "$path" "$IP_ROOT/$rel")"
     wire_package_sources "$manifest" "$name" "$rel" "$IP_ROOT"
     lock_upsert "$lock" "$name" "$range" "$url" "$path" "$tag" "$sha"
@@ -55,7 +70,7 @@ while IFS= read -r name; do
     moved=$((moved + 1))
 done < <(qmap_keys "$manifest" "packages")
 
-[ -n "$only" ] && [ "$checked" -eq 0 ] && die "package '$only' is not in the manifest"
+[ -n "$only" ] && [ "$found" -eq 0 ] && die "package '$only' is not in the manifest"
 echo "updated: $moved package(s)"
 
 if [ "$moved" -gt 0 ] && [ "$no_sync" -eq 0 ]; then

package/cli/engine-package.yaml

@@ -0,0 +1,14 @@
+# What THIS CLI distribution ships as its engine-content package, and which
+# registry its init seeds into new manifests. Data, not code: a fork or an
+# enterprise mirror edits this file (or its copy in the npm build) — nothing
+# in cli/ names a vendor.
+#
+# The engine-content package is the one package whose content documents the
+# engine scripts bundled with the CLI: init writes this entry into the
+# manifest (visible, removable), its pin always equals the engine VERSION,
+# `upgrade` moves it, and at the matching version it materializes from the
+# bundle without network.
+name: "@ainova-systems/sync"
+url: "https://github.com/ainova-systems/intelligence-sync.git"
+path: "intelligence/sync"
+default_registry: "https://github.com/ainova-systems/intelligence-registry.git"

package/cli/lib/cli-common.sh

@@ -24,15 +24,23 @@ source "$CLI_DIR/lib/semver.sh"
 source "$CLI_DIR/lib/registry.sh"
 source "$CLI_DIR/lib/lockfile.sh"
 
-# The engine's own content as a package: OPTIONAL but auto-selected at init.
-# Package by UX (manifest entry, lockfile row, list/search/remove), bundle by
-# mechanics — at the version the CLI ships, it materializes from the npm
-# bundle without network; only a cross-version install reaches git. The pin
-# is held exactly at the bundled engine version and moved only by `upgrade`.
-SYNC_PKG_NAME="@ainova-systems/sync"
-SYNC_PKG_URL="https://github.com/ainova-systems/intelligence-sync.git"
-SYNC_PKG_PATH="intelligence/sync"
-SYNC_PKG_STORE=".intelligence/packages/@ainova-systems/sync"
+# The engine-content package: OPTIONAL but auto-selected at init. Package by
+# UX (manifest entry, lockfile row, list/search/remove), bundle by mechanics —
+# at the version the CLI ships, it materializes from the npm bundle without
+# network; only a cross-version install reaches git. The pin is held exactly
+# at the bundled engine version and moved only by `upgrade`.
+#
+# Its identity is DATA shipped with the distribution (cli/engine-package.yaml),
+# never a name compiled into cli code — a fork edits the file.
+_EPKG="$CLI_DIR/engine-package.yaml"
+SYNC_PKG_NAME="$(top_scalar "$_EPKG" "name")"
+SYNC_PKG_URL="$(top_scalar "$_EPKG" "url")"
+SYNC_PKG_PATH="$(top_scalar "$_EPKG" "path")"
+# Read by commands (init seeds it) — per-file shellcheck cannot see that.
+# shellcheck disable=SC2034
+DEFAULT_REGISTRY_URL="$(top_scalar "$_EPKG" "default_registry")"
+[ -n "$SYNC_PKG_NAME" ] || die "corrupt CLI installation: $_EPKG is missing or has no 'name'"
+SYNC_PKG_STORE=".intelligence/packages/$SYNC_PKG_NAME"
 
 # --- Project detection ---------------------------------------------------
 # Sets: IP_MODE (v2|legacy|none), IP_ROOT, IP_UMBRELLA, IP_MODULE_DIR.
@@ -127,7 +135,7 @@ export_engine_env() {
     export CONFIG_FILE="$root/intelligence.yaml"
     export REPO_ROOT="$root"
     export IS_UMBRELLA_REL="$umbrella"
-    export IS_MODULE_REL=".intelligence/engine"
+    export IS_MODULE_REL="$SYNC_PKG_STORE"
     export IS_SYNC_CMD="intelligence sync"
     export IS_MANIFEST_NAME="intelligence.yaml"
     export IS_PROTECTED_DIRS="$umbrella:.intelligence"

package/cli/lib/manifest.sh

@@ -24,6 +24,16 @@ assert_valid_pkg_name() {
     case "$1" in
         *[!@/A-Za-z0-9._-]*|*/*/*) die "invalid package name '$1' — allowed: letters, digits, . _ -, one '/'" ;;
     esac
+    # Both segments become store path components fed to rm -rf: an empty one
+    # ('@scope/') resolves to the whole scope dir, and a dot segment walks the
+    # tree — either would turn one bad --name into deleting other packages.
+    local scope="${1%%/*}" short="${1#*/}"
+    case "${scope#@}" in
+        ""|.|..) die "invalid package name '$1' — empty or dot scope" ;;
+    esac
+    case "$short" in
+        ""|.|..) die "invalid package name '$1' — empty or dot name" ;;
+    esac
 }
 
 # qmap_keys <file> <block> — quoted keys, one per line.
@@ -273,6 +283,35 @@ registries_remove() {
     '
 }
 
+# sources_add_entry_first <file> <section> <entry> — idempotent insert at the
+# TOP of sources.<section> (creating sources:/section as needed). Package
+# entries go through this so project-owned entries stay later in the list —
+# adapters copy sources in order and the last write wins, which is exactly
+# the documented "your file overrides the package's" behavior.
+sources_add_entry_first() {
+    local file="$1" section="$2" entry="$3"
+    _mig_has_source "$file" "$entry" && return 0
+    _qmap_stage "$file" -v section="$section" -v entry="$entry" '
+        function line() { return "    - \"" entry "\"" }
+        { sub(/\r$/, "") }
+        /^sources:[ \t]*$/ { ins = 1; sourceseen = 1; print; next }
+        ins && /^[^ #]/ {
+            if (!secseen && !done) { print "  " section ":"; print line(); done = 1 }
+            ins = 0
+        }
+        ins && $0 ~ "^  " section ":[ \t]*$" { secseen = 1; print; print line(); done = 1; next }
+        { print }
+        END {
+            if (ins && !secseen && !done) { print "  " section ":"; print line(); done = 1 }
+            if (!sourceseen) {
+                print "sources:"
+                print "  " section ":"
+                print line()
+            }
+        }
+    '
+}
+
 # sources_remove_entry <file> <section> <entry> — remove `- "entry"` from
 # sources.<section>. Inverse of the engine-side _mig_add_source.
 sources_remove_entry() {

package/cli/lib/registry.sh

@@ -1,29 +1,23 @@
 #!/bin/bash
 # Name -> source resolution and package fetching.
 #
-# Resolution order (first registry to DECLARE the name wins):
-#   1. project `registries:` — a trust LIST of registry repos (git repos
-#      holding index.yaml), consulted in manifest order; adding one is an
-#      explicit, committed act of trust in the names it declares
-#   2. the bundled default index (registry/index.yaml next to the CLI)
-#   3. convention: @org/name -> https://github.com/org/name.git, content at
-#      the repo root — the zero-infrastructure default
+# A name resolves ONLY through the manifest's `registries:` trust list (git
+# repos holding index.yaml, consulted in order; the first to declare the name
+# wins). There is deliberately no built-in catalog and no name->github
+# convention: the CLI core knows no vendor, and a name nobody explicitly
+# trusted must never silently turn into an install from a guessed URL.
+# Sources without a registry are always EXPLICIT: github:org/repo, git+<url>.
+# Vendor defaults exist only as lines `init` writes into the manifest —
+# visible, reviewable, deletable.
 #
 # The NAME is the trust anchor a developer reasons with; source integrity is
-# a separate mechanism: the lock pins url+sha, a project-registry hit that
-# shadows a bundled name with a different url warns loudly, and doctor flags
+# a separate mechanism: the lock pins url+sha, and doctor flags
 # resolution/lock url drift.
 #
 # An index is itself fetched with git (never curl): auth, proxies and private
 # hosting all come for free, and the CLI keeps the engine's bash+awk+git-only
 # dependency footprint.
 
-default_index_file() {
-    local f="$CLI_DIR/../registry/index.yaml"
-    [ -f "$f" ] && printf '%s' "$f"
-    return 0
-}
-
 # _fetch_index <registry-repo-url> — clones the registry repo (shallow) and
 # prints the path of its index.yaml; empty on failure. Cached per run+url.
 _fetch_index() {
@@ -49,11 +43,9 @@ _fetch_index() {
 # shellcheck disable=SC2034
 resolve_package_source() {
     local manifest="$1" name="$2"
-    local scope="${name%%/*}" short="${name#*/}"
     RES_URL=""; RES_PATH=""; RES_VIA=""
 
-    local reg_url index bundled burl
-    bundled="$(default_index_file)"
+    local reg_url index
     if [ -n "$manifest" ] && [ -f "$manifest" ]; then
         while IFS= read -r reg_url; do
             [ -n "$reg_url" ] || continue
@@ -66,37 +58,18 @@ resolve_package_source() {
             if [ -n "$RES_URL" ]; then
                 RES_PATH="$(qmap_field "$index" "packages" "$name" "path")"
                 RES_VIA="registry:$reg_url"
-                # Shadowing a bundled name with a DIFFERENT source is legal
-                # (that is what overriding means) but never silent.
-                if [ -n "$bundled" ]; then
-                    burl="$(qmap_field "$bundled" "packages" "$name" "url")"
-                    if [ -n "$burl" ] && [ "$burl" != "$RES_URL" ]; then
-                        echo "  WARN: $name from this registry overrides the bundled source ($burl)" >&2
-                    fi
-                fi
                 return 0
             fi
         done < <(registries_list "$manifest")
     fi
-
-    if [ -n "$bundled" ]; then
-        RES_URL="$(qmap_field "$bundled" "packages" "$name" "url")"
-        if [ -n "$RES_URL" ]; then
-            RES_PATH="$(qmap_field "$bundled" "packages" "$name" "path")"
-            RES_VIA="index"
-            return 0
-        fi
-    fi
-
-    RES_URL="https://github.com/${scope#@}/$short.git"
-    RES_PATH=""
-    RES_VIA="convention"
+    # No trusted registry declares the name. Deliberately NOT an invented
+    # URL: the caller reports it, with suggestions.
     return 0
 }
 
 # suggest_similar <manifest-or-empty> <@scope/name> — "Did you mean" lines to
 # stderr, matched on the short name (singular/plural tolerant) across every
-# project registry and the bundled index.
+# trusted registry.
 suggest_similar() {
     local manifest="$1" name="$2"
     local want cand cshort reg_url index seen=" "
@@ -121,7 +94,6 @@ suggest_similar() {
             _suggest_from "$index"
         done < <(registries_list "$manifest")
     fi
-    _suggest_from "$(default_index_file)"
 }
 
 # fetch_package <url> <ref> <subpath> <dest-dir>
@@ -182,14 +154,14 @@ fetch_package() {
 
 # wire_package_sources <manifest> <@scope/name> <store-rel-dir>
 # The provides convention: whichever of rules/agents/skills the installed
-# package has becomes a sources entry. Reuses the engine's idempotent,
-# comment-preserving _mig_add_source.
+# package has becomes a sources entry — inserted FIRST in its section, so
+# project-owned entries come later and win on same-named artifacts.
 wire_package_sources() {
     local manifest="$1" name="$2" rel="$3" root="$4"
     local section
     for section in rules agents skills; do
         if [ -d "$root/$rel/$section" ]; then
-            _mig_add_source "$manifest" "$section" "$rel/$section"
+            sources_add_entry_first "$manifest" "$section" "$rel/$section"
         fi
     done
 }

package/engine/docs/CLI.md

@@ -27,7 +27,7 @@ No engine code lives in the project. The engine's *scripts* ship inside the npm
 
 | Command | Does |
 |---|---|
-| `init [--targets a,b] [--dir d] [--bare] [--no-sync]` | Detect tools by their marker dirs, write a minimal self-documenting root manifest, `.gitignore` the store, install `@ainova-systems/sync` (unless `--bare`), first sync. No dirs are created — authoring one later needs no config edit. |
+| `init [--targets a,b] [--dir d] [--bare] [--no-sync]` | Enable `agents` (the tool-neutral AGENTS.md) plus every tool DETECTED by repo markers (`.claude`/`CLAUDE.md`, `.cursor`, `.codex`, `.pi`, `.opencode`, `.github/instructions`) or named via `--targets` — a tool is never invented. Writes a minimal self-documenting root manifest, `.gitignore`s the store, installs `@ainova-systems/sync` (unless `--bare`), first sync. No dirs are created. |
 | `add <spec> [--name @s/n] [--no-sync]` | Resolve → fetch → wire sources → manifest entry → lock → sync. Specs: `@scope/name[@range]`, `github:org/repo[#path]`, `git+<url>[@ref][#path]`. |
 | `remove <name> [--force]` | Inverse of add: manifest, sources, lock, store. |
 | `install [--frozen] [--force]` | Restore the store exactly from the lock; resolve manifest packages the lock lacks (`--frozen` refuses instead, and fails on sha drift). |
@@ -44,11 +44,7 @@ No engine code lives in the project. The engine's *scripts* ship inside the npm
 
 **Names are global.** The name is the trust anchor a developer reasons with — the same `@scope/name` means the same package in every project, every lock and every conversation. A registry never renames anything, and two versions of one name cannot coexist in a project: intelligence artifacts land in each tool's flat namespace (`.claude/skills/<name>/`, the `AGENTS.md` tables), so duplicates would collide file-by-file. Need pieces of two versions? That is a different package — fork it under a different name. Need to override one artifact? Put a same-named file in your own content dir; project sources are listed after package sources.
 
-**Name → repo resolution** — the first registry to *declare* the name wins:
-
-1. `registries:` in the manifest — a **trust list** of registry repos (git repos holding an `index.yaml`), consulted in order. Adding one is an explicit, committed, reviewable act of trust in the names it declares; private registries are just private repos, git auth covers access. A project-registry hit that shadows a bundled name with a *different* source warns loudly, and `doctor` flags a name whose current resolution url no longer matches the lock.
-2. The bundled default index (`registry/index.yaml`) — needed exactly when a name is not a repo (monorepos: `@ainova-systems/core` → `intelligence-dev-packs` at `packs/core`).
-3. Convention: `@org/name` → `https://github.com/org/name.git`, content at the repo root. Zero infrastructure: any repo with the three dirs is already a package.
+**Name → repo resolution: the trust list is the ONLY resolver.** `registries:` in the manifest holds registry repos (git repos with an `index.yaml`), consulted in order — the first to declare the name wins. There is deliberately **no built-in catalog and no `@org/name` → github guessing**: the CLI core knows no vendor, and a name nobody explicitly trusted never turns into an install from an invented URL. A name no trusted registry declares is refused with suggestions. Installs without a registry are always **explicit sources**: `github:org/repo`, `git+<url>[@ref][#path]`. Vendor defaults exist only as lines `init` seeds into the manifest — visible, reviewable, deletable (`doctor` still flags a name whose current resolution url no longer matches the lock).
 
 **Versions are git tags.** Ranges (`^1.2.0`, `~1.2.0`, exact, `latest`) match stable `x.y.z` tags (optional `v` prefix) listed via `git ls-remote` — no clone to resolve. `add` without a range picks the highest stable tag and records `^that`. A branch or commit pin is `ref:`, the escape hatch that ranges never touch. Prerelease-suffixed tags are invisible to ranges by design.
 

package/engine/scripts/ENGINE_SHA

@@ -1 +1 @@
-40b7d3a7dd936c5ffb854f9e5f553720c48ef494
+3a5cd174c73bd3918ac0a01df8d54a6f3d98b485

package/engine/scripts/sync.sh

@@ -94,7 +94,7 @@ if [ "${IS_CLI:-0}" = "1" ]; then
     # `/d/...`, and prefix comparisons downstream need one spelling.
     CONFIG_FILE="$(cd "$(dirname "$CONFIG_FILE")" && pwd)/$(basename "$CONFIG_FILE")"
     IS_UMBRELLA_REL="${IS_UMBRELLA_REL:-intelligence}"
-    IS_MODULE_REL="${IS_MODULE_REL:-.intelligence/engine}"
+    IS_MODULE_REL="${IS_MODULE_REL:-.intelligence/packages/@ainova-systems/sync}"
     # Project-owned adapters keep their v1 home: <umbrella>/adapters/.
     INTELLIGENCE_DIR="$REPO_ROOT/$IS_UMBRELLA_REL"
 else

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ainova-systems/intelligence",
-  "version": "0.11.0-rc.5",
+  "version": "0.11.0-rc.6",
   "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"
@@ -8,8 +8,7 @@
   "files": [
     "bin",
     "cli",
-    "engine",
-    "registry"
+    "engine"
   ],
   "engines": {
     "node": ">=18"

package/registry/index.yaml

@@ -1,26 +0,0 @@
-# The default Intelligence Registry index, bundled with the CLI.
-#
-# Maps a package name to the git repo (and path inside it) the package lives
-# in. Needed exactly when a name is not the repo — monorepos like
-# intelligence-dev-packs. A name absent here falls through to the convention:
-# @org/name -> https://github.com/org/name.git, content at the repo root.
-# Organizations override or extend this per scope with `intelligence registry
-# add @scope <registry-repo-url>`.
-#
-# This copy travels inside the CLI package. The same index lives at
-# https://github.com/ainova-systems/intelligence-registry and can be bound
-# explicitly (`intelligence registry add @ainova-systems <url>`) to read the
-# newest entries without waiting for a CLI release.
-packages:
-  "@ainova-systems/sync":
-    url: "https://github.com/ainova-systems/intelligence-sync.git"
-    path: "intelligence/sync"
-    description: "The engine's own content: authoring rule, engine agents and the intelligence-* meta-skills. Auto-installed by init; pinned to the engine version."
-  "@ainova-systems/core":
-    url: "https://github.com/ainova-systems/intelligence-dev-packs.git"
-    path: "packs/core"
-    description: "Engineering discipline for AI-first development: context engineering, artifact-derived status, review and diagnosis loops."
-  "@ainova-systems/spec":
-    url: "https://github.com/ainova-systems/intelligence-dev-packs.git"
-    path: "packs/spec"
-    description: "Spec-driven delivery: specifications, decision records, sliced execution."