@ainova-systems/intelligence 0.11.0-rc.1 → 0.11.0-rc.10

package/README.md

@@ -3,11 +3,11 @@
 **npm for AI agent intelligence.** One CLI that builds, versions and distributes the rules, agents and skills your AI coding tools run on — rendered natively for Claude Code, Cursor, GitHub Copilot, OpenAI Codex, Pi, OpenCode and `AGENTS.md`.
 
 ```bash
-npm install -g @ainova-systems/intelligence
+npm install -g @ainova-systems/intelligence@next
 
 cd your-project
 intelligence init
-intelligence add @ainova-systems/core
+intelligence package add @ainova-systems/core
 intelligence sync
 ```
 
@@ -22,25 +22,28 @@ intelligence/          # your own rules / agents / skills
 AGENTS.md
 ```
 
-Teammates need one command after cloning:
+Teammates need one command after cloning; it restores the locked package store before rendering:
 
 ```bash
-intelligence install
+intelligence sync
 ```
 
 ## Commands
 
 | Command | What it does |
 |---|---|
-| `intelligence init` | Detect your tools, write the manifest, first sync |
-| `intelligence add <pkg>` | `@scope/name[@range]`, `github:org/repo[#path]`, or `git+<url>[@ref][#path]` |
-| `intelligence install [--frozen]` | Restore `.intelligence/` exactly from the lockfile |
-| `intelligence update [pkg]` | Re-resolve version ranges, rewrite the lock |
-| `intelligence sync [target]` | Render intelligence to every enabled tool |
-| `intelligence list` / `doctor` / `status` | Inspect and verify |
-| `intelligence registry add @scope <url>` | Bind a scope to a private registry index |
-| `intelligence migrate` | Convert a vendored intelligence-sync setup to the CLI |
-
-Any git repo with `rules/`, `agents/` or `skills/` at its root is already an Intelligence Package: `intelligence add @your-org/your-repo` resolves it straight from GitHub — versions come from its `x.y.z` git tags. A monorepo of packages needs one line in a registry index.
-
-Requires `git` (and on Windows the bash it ships with — Git for Windows). Engine and docs: [ainova-systems/intelligence-sync](https://github.com/ainova-systems/intelligence-sync).
+| `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 update [@scope/name] [--preview\|--apply]` | Plan or apply project and ranged-package updates |
+| `intelligence package add\|remove\|list\|search` | Manage versioned Intelligence Packages |
+| `intelligence adapter list\|create\|enable\|disable\|remove` | Manage render adapters |
+| `intelligence status [--check]` | Inspect project state and consistency |
+| `intelligence registry list\|add\|remove` | Manage trusted registry repositories |
+
+Any git repo with `rules/`, `agents/` or `skills/` at its root is already an Intelligence Package: install it from an explicit source — `intelligence package add github:your-org/your-repo` — with versions from its `x.y.z` git tags. Names (`@scope/name`) resolve only through registries this project explicitly trusts; a monorepo of packages needs one line in such an index.
+
+Every package has the same compact manifest entry: requested `version` or
+`ref` only. Repository URL/path, resolved tag/ref and commit SHA are recorded
+in the committed `intelligence.lock`.
+
+Requires `git` (and on Windows the bash it ships with — Git for Windows). Engine and docs: [ainova-systems/intelligence](https://github.com/ainova-systems/intelligence).

package/cli/commands/adapter.sh

@@ -0,0 +1,153 @@
+#!/bin/bash
+# intelligence adapter <list|create|enable|disable|remove> [name]
+set -euo pipefail
+source "$CLI_DIR/lib/cli-common.sh"
+
+action="${1:-}"
+name="${2:-}"
+
+adapter_list() {
+    detect_project
+    local manifest="" content_dir="" seen=" " file item enabled output configured
+    if [ "$IP_MODE" = "cli" ]; then
+        manifest="$IP_ROOT/intelligence.yaml"
+        content_dir="$(manifest_intelligence_dir "$manifest")"
+    fi
+
+    printf '%-16s %-10s %-10s %s\n' "NAME" "SOURCE" "STATE" "OUTPUT"
+    # Project adapters come first because they override built-ins by name.
+    if [ -n "$content_dir" ] && [ -d "$IP_ROOT/$content_dir/adapters" ]; then
+        for file in "$IP_ROOT/$content_dir/adapters"/*.sh; do
+            [ -f "$file" ] || continue
+            item="$(basename "$file" .sh)"
+            seen="$seen$item "
+            enabled="disabled"; output="$(default_target_output "$item")"
+            [ "$(is_target_enabled "$manifest" "$item")" = "1" ] && enabled="enabled"
+            configured="$(get_target_output "$manifest" "$item")"
+            [ -z "$configured" ] || output="$configured"
+            printf '%-16s %-10s %-10s %s\n' "$item" "project" "$enabled" "$output"
+        done
+    fi
+    for file in "$IS_ENGINE_DIR/adapters"/*.sh; do
+        [ -f "$file" ] || continue
+        item="$(basename "$file" .sh)"
+        [ "$item" = "_template" ] && continue
+        case "$seen" in *" $item "*) continue ;; esac
+        enabled="disabled"; output="$(default_target_output "$item")"
+        if [ -n "$manifest" ]; then
+            [ "$(is_target_enabled "$manifest" "$item")" = "1" ] && enabled="enabled"
+            configured="$(get_target_output "$manifest" "$item")"
+            [ -z "$configured" ] || output="$configured"
+        fi
+        printf '%-16s %-10s %-10s %s\n' "$item" "built-in" "$enabled" "$output"
+    done
+}
+
+adapter_create() {
+    [ -n "$name" ] && [ $# -eq 0 ] || die "usage: intelligence adapter create <name>"
+    assert_valid_target_name "$name"
+    require_cli_project
+    ensure_project_current "$IP_ROOT"
+    local manifest="$IP_ROOT/intelligence.yaml" content_dir repo_phys probe old_ifs part probe_phys
+    local template adapter_dir adapter_phys dest tmp
+    local -a parts
+    content_dir="$(manifest_intelligence_dir "$manifest")"
+    case "$content_dir" in
+        ""|/*|.|..|../*|*/../*|*/..|.intelligence|.intelligence/*)
+            die "unsafe project.intelligence_dir '$content_dir'"
+            ;;
+    esac
+    repo_phys="$(cd "$IP_ROOT" && pwd -P)"
+    probe="$IP_ROOT"
+    old_ifs="$IFS"; IFS='/'; read -r -a parts <<< "$content_dir"; IFS="$old_ifs"
+    for part in "${parts[@]}"; do
+        [ -n "$part" ] || continue
+        probe="$probe/$part"
+        if [ -e "$probe" ] || [ -L "$probe" ]; then
+            probe_phys="$(cd "$probe" 2>/dev/null && pwd -P)" || die "cannot resolve project content path '$content_dir'"
+            case "$probe_phys" in "$repo_phys"|"$repo_phys"/*) ;; *) die "project.intelligence_dir resolves outside the repository: '$content_dir'" ;; esac
+        fi
+    done
+    template="$IS_ENGINE_DIR/adapters/_template.sh"
+    [ -f "$template" ] || die "corrupt CLI installation: bundled adapter template is missing"
+    adapter_dir="$IP_ROOT/$content_dir/adapters"
+    dest="$adapter_dir/$name.sh"
+    [ ! -e "$dest" ] || die "project adapter already exists: $content_dir/adapters/$name.sh"
+    mkdir -p "$adapter_dir"
+    adapter_phys="$(cd "$adapter_dir" && pwd -P)"
+    case "$adapter_phys" in "$repo_phys"|"$repo_phys"/*) ;; *) die "project adapter directory resolves outside the repository" ;; esac
+    tmp="$(mktemp "$adapter_dir/.${name}.XXXXXX")"
+    trap '[ -z "${tmp:-}" ] || rm -f "$tmp"' EXIT
+    awk -v name="$name" '{ gsub(/<agent-name>/, name); gsub(/<Agent Name>/, name); gsub(/<name>/, name); print }' "$template" > "$tmp"
+    [ -s "$tmp" ] || die "adapter template produced an empty file"
+    mv "$tmp" "$dest"
+    tmp=""
+    echo "created: $content_dir/adapters/$name.sh"
+    echo "  implement sync_to_${name}(), then run: intelligence adapter enable $name"
+}
+
+adapter_remove() {
+    local apply=0 manifest content_dir file answer repo_phys adapter_dir adapter_phys
+    while [ $# -gt 0 ]; do
+        case "$1" in --apply) apply=1 ;; *) die "unknown option '$1'" ;; esac
+        shift
+    done
+    [ -n "$name" ] || die "usage: intelligence adapter remove <name> [--apply]"
+    assert_valid_target_name "$name"
+    require_cli_project
+    ensure_project_current "$IP_ROOT"
+    manifest="$IP_ROOT/intelligence.yaml"
+    content_dir="$(manifest_intelligence_dir "$manifest")"
+    case "$content_dir" in
+        ""|/*|.|..|../*|*/../*|*/..|.intelligence|.intelligence/*)
+            die "unsafe project.intelligence_dir '$content_dir'"
+            ;;
+    esac
+    repo_phys="$(cd "$IP_ROOT" && pwd -P)"
+    adapter_dir="$IP_ROOT/$content_dir/adapters"
+    [ -d "$adapter_dir" ] || die "project adapter '$name' does not exist"
+    adapter_phys="$(cd "$adapter_dir" 2>/dev/null && pwd -P)" || die "cannot resolve project adapter directory"
+    case "$adapter_phys" in "$repo_phys"|"$repo_phys"/*) ;; *) die "project adapter directory resolves outside the repository" ;; esac
+    file="$adapter_dir/$name.sh"
+    [ -f "$file" ] || die "project adapter '$name' does not exist"
+    [ "$(is_target_enabled "$manifest" "$name")" != "1" ] || die "adapter '$name' is enabled — disable it first"
+    echo "remove project adapter source: $content_dir/adapters/$name.sh"
+    if [ "$apply" -ne 1 ]; then
+        [ -t 0 ] || die "removal requires confirmation — rerun with --apply"
+        printf 'Remove it? [y/N] '
+        read -r answer
+        case "$answer" in y|Y|yes|YES) ;; *) echo "removal cancelled"; exit 0 ;; esac
+    fi
+    rm -f "$file"
+    echo "removed: $content_dir/adapters/$name.sh"
+    echo "  generated output was kept"
+}
+
+case "$action" in
+    list)
+        [ $# -eq 1 ] || die "usage: intelligence adapter list"
+        adapter_list
+        ;;
+    create)
+        shift 2 || true
+        adapter_create "$@"
+        ;;
+    enable|disable)
+        [ -n "$name" ] && [ $# -eq 2 ] || die "usage: intelligence adapter <enable|disable> <name>"
+        assert_valid_target_name "$name"
+        require_cli_project
+        ensure_project_current "$IP_ROOT"
+        bash "$CLI_DIR/internal/target-state.sh" "$action" "$name"
+        if [ "$action" = "enable" ]; then
+            exec bash "$CLI_DIR/commands/sync.sh"
+        fi
+        ;;
+    remove)
+        [ -n "$name" ] || die "usage: intelligence adapter remove <name> [--apply]"
+        shift 2 || true
+        adapter_remove "$@"
+        ;;
+    *)
+        die "usage: intelligence adapter <list|create|enable|disable|remove> [name]"
+        ;;
+esac

package/cli/commands/init.sh

@@ -1,94 +1,231 @@
 #!/bin/bash
-# intelligence init [--targets a,b,c] [--no-sync]
+# intelligence init [--targets a,b,c] [--dir name] [--bare] [--no-sync]
+#                   [--preview | --apply] [--force]
 #
 # Set up a project: root manifest, content skeleton, .gitignore, staged
 # engine content, first sync. Targets are detected from IDE markers unless
-# named explicitly; `agents` and `claude` are always on (AGENTS.md is the
-# canonical carrier of always-on rules, Claude Code does not read it).
+# named explicitly. Only `agents` is unconditional: AGENTS.md is the
+# tool-neutral carrier of always-on rules; tool targets come from markers or
+# --targets.
 set -euo pipefail
 source "$CLI_DIR/lib/cli-common.sh"
 
-targets_arg="" no_sync=0
+targets_arg="" no_sync=0 content_dir="intelligence" bare=0
+targets_set=0 dir_set=0 bare_set=0 preview=0 apply=0 force=0
 while [ $# -gt 0 ]; do
     case "$1" in
-        --targets) shift; targets_arg="${1:-}" ;;
+        --targets) shift; targets_arg="${1:-}"; targets_set=1 ;;
+        --dir) shift; content_dir="${1:-}"; dir_set=1 ;;
         --no-sync) no_sync=1 ;;
+        --bare) bare=1; bare_set=1 ;;
+        --preview) preview=1 ;;
+        --apply) apply=1 ;;
+        --force) force=1 ;;
         *) die "unknown option '$1'" ;;
     esac
     shift || true
 done
+[ "$preview" -eq 0 ] || [ "$apply" -eq 0 ] || die "choose either --preview or --apply"
+[ "$targets_set" -eq 0 ] || [ -n "$targets_arg" ] || die "--targets needs a comma-separated adapter list"
+[ -n "$content_dir" ] || die "--dir needs a directory name"
+case "$content_dir" in
+    /*|*..*|.intelligence|.intelligence/*) die "--dir must be a plain directory inside the repo, and not the package store" ;;
+esac
 
 detect_project
 case "$IP_MODE" in
-    v2) die "already set up — manifest at $IP_ROOT/intelligence.yaml (use 'intelligence status')" ;;
-    legacy) die "this is a vendored (v1) setup at $IP_UMBRELLA — run 'intelligence migrate' instead" ;;
+    cli)
+        [ "$targets_set" -eq 0 ] || die "--targets applies only when creating a new project"
+        [ "$dir_set" -eq 0 ] || die "--dir applies only when creating a new project"
+        [ "$bare_set" -eq 0 ] || die "--bare applies only when creating a new project"
+        [ "$force" -eq 0 ] || die "--force applies only when converting a legacy Intelligence Sync project"
+        if [ "$preview" -eq 1 ]; then
+            check_version_compat "$IP_ROOT/intelligence.yaml"
+            echo "project: Intelligence CLI at $IP_ROOT"
+            if project_needs_upgrade "$IP_ROOT"; then
+                echo "  would align project lifecycle with engine $(bundled_engine_version)"
+            else
+                echo "  schema/content already match engine $(bundled_engine_version)"
+            fi
+            if project_has_packages "$IP_ROOT" && [ ! -f "$IP_ROOT/intelligence.lock" ]; then
+                die "manifest declares packages but intelligence.lock is absent — restore the committed lock before applying"
+            fi
+            if project_store_missing "$IP_ROOT"; then
+                echo "  would restore .intelligence/ from intelligence.lock"
+            else
+                echo "  package store already present"
+            fi
+            if [ "$no_sync" -eq 1 ]; then
+                echo "  would stop before intelligence sync"
+            else
+                echo "  would run intelligence sync"
+            fi
+            exit 0
+        fi
+        if [ "$apply" -eq 1 ]; then
+            ensure_project_current "$IP_ROOT" --explicit
+        else
+            ensure_project_current "$IP_ROOT"
+        fi
+        restore_project_store_if_missing "$IP_ROOT"
+        [ "$no_sync" -eq 1 ] && exit 0
+        cd "$IP_ROOT"
+        exec bash "$CLI_DIR/commands/sync.sh"
+        ;;
+    legacy)
+        [ "$targets_set" -eq 0 ] || die "--targets applies only when creating a new project"
+        [ "$dir_set" -eq 0 ] || die "--dir applies only when creating a new project"
+        [ "$bare_set" -eq 0 ] || die "--bare applies only when creating a new project"
+        [ "$no_sync" -eq 0 ] || die "--no-sync cannot skip transactional conversion verification"
+        conversion_args=()
+        [ "$force" -eq 1 ] && conversion_args+=(--force)
+        if [ "$preview" -eq 1 ]; then
+            exec bash "$CLI_DIR/internal/convert-legacy.sh" --dry-run ${conversion_args[@]+"${conversion_args[@]}"}
+        fi
+        if [ "$apply" -eq 1 ]; then
+            exec bash "$CLI_DIR/internal/convert-legacy.sh" ${conversion_args[@]+"${conversion_args[@]}"}
+        fi
+        bash "$CLI_DIR/internal/convert-legacy.sh" --dry-run ${conversion_args[@]+"${conversion_args[@]}"}
+        [ -t 0 ] || die "legacy project conversion requires confirmation — rerun 'intelligence init --apply'"
+        printf 'Apply this conversion? [Y/n] '
+        read -r answer
+        case "$answer" in
+            ""|y|Y|yes|YES) exec bash "$CLI_DIR/internal/convert-legacy.sh" ${conversion_args[@]+"${conversion_args[@]}"} ;;
+            *) echo "conversion cancelled"; exit 0 ;;
+        esac
+        ;;
 esac
 
+[ "$force" -eq 0 ] || die "--force applies only when converting a legacy Intelligence Sync project"
 root="$(git rev-parse --show-toplevel 2>/dev/null || pwd)"
 root="$(cd "$root" && pwd)"
+assert_safe_content_dir "$root" "$content_dir"
 
-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 ',' ' ')"
+    for target in $(printf '%s' "$targets_arg" | tr ',' ' '); do
+        assert_valid_target_name "$target"
+        if [ ! -f "$IS_ENGINE_DIR/adapters/$target.sh" ] \
+            && [ ! -f "$root/$content_dir/adapters/$target.sh" ]; then
+            die "adapter '$target' not found — create it after init with: intelligence adapter create $target"
+        fi
+        case " $targets " in *" $target "*) ;; *) targets="$targets $target" ;; esac
+    done
 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
+
+if [ "$preview" -eq 1 ]; then
+    echo "project: no Intelligence setup found"
+    echo "  would create intelligence.yaml and intelligence.lock"
+    if [ "$bare" -eq 1 ]; then
+        echo "  would omit the bundled sync-content package (--bare)"
+    else
+        echo "  would install the bundled sync-content package"
+    fi
+    if [ "$no_sync" -eq 1 ]; then
+        echo "  would enable adapters:$targets and stop before sync"
+    else
+        echo "  would enable adapters:$targets, then sync"
+    fi
+    exit 0
 fi
 
 manifest="$root/intelligence.yaml"
 {
     echo "# Intelligence manifest — what this project's AI tooling knows and where it goes."
-    echo "# Managed by the intelligence CLI (https://github.com/ainova-systems/intelligence-sync)."
+    echo "# Managed by the intelligence CLI. Reference: https://github.com/ainova-systems/intelligence"
     echo "project:"
     echo "  name: \"$(basename "$root")\""
+    [ "$content_dir" = "intelligence" ] || echo "  intelligence_dir: \"$content_dir\""
     echo ""
-    echo "sync_version: \"$(bundled_engine_version)\""
+    echo "# Schema version of this manifest. The CLI keeps it in step with its engine."
+    echo "schema_version: \"$(bundled_engine_version)\""
     echo ""
+    echo "# Where content comes from. Nothing here has to exist: a directory that is"
+    echo "# absent is skipped, so a project consuming only packages authors nothing of"
+    echo "# its own. To write your own, create the directory and sync — no config edit:"
+    echo "#   $content_dir/rules/context.md      an always-on rule; describe the project,"
+    echo "#                                      its stack, and the constraints to respect"
+    echo "#   $content_dir/agents/<name>.md      a persona (frontmatter: name, description,"
+    echo "#                                      tier: heavy|standard|light, access: full|readonly)"
+    echo "#   $content_dir/skills/<name>/SKILL.md  a procedure invoked as /<name>"
+    echo "# '.intelligence/' is CLI-managed (packages + engine content) — never edit it."
     echo "sources:"
     echo "  rules:"
-    echo "    - \"intelligence/rules\""
-    echo "    - \".intelligence/engine/rules\""
+    echo "    - \"$content_dir/rules\""
     echo "  agents:"
-    echo "    - \"intelligence/agents\""
-    echo "    - \".intelligence/engine/agents\""
+    echo "    - \"$content_dir/agents\""
     echo "  skills:"
-    echo "    - \"intelligence/skills\""
-    echo "    - \".intelligence/engine/skills\""
+    echo "    - \"$content_dir/skills\""
     echo ""
+    echo "# Generated output, one entry per tool. Add or drop tools freely."
     echo "targets:"
     for t in $targets; do
-        case "$t" in
-            agents) echo "  agents: { enabled: true, output: \"AGENTS.md\" }" ;;
-            *) echo "  $t: { enabled: true, output: \".$t\" }" ;;
-        esac
+        echo "  $t: { enabled: true, output: \"$(default_target_output "$t")\" }"
     done
+    echo ""
+    echo "# Packages are managed with 'intelligence package add|search|list':"
+    echo "#   intelligence package add @ainova-systems/core       from the registry"
+    echo "#   intelligence package add github:org/repo            any repo with rules|agents|skills"
+    echo "# packages:"
+    echo "#   \"@ainova-systems/core\":"
+    echo "#     version: \"^0.3.0\""
+    echo ""
+    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"
 
-mkdir -p "$root/intelligence/rules" "$root/intelligence/agents" "$root/intelligence/skills"
-if [ ! -f "$root/intelligence/rules/context.md" ]; then
-    cat > "$root/intelligence/rules/context.md" <<EOF
-# Project Context
-
-<!-- Always-on context every AI tool receives. Describe what this project is,
-     its stack, and the constraints an agent must respect. -->
-EOF
-fi
-
 # The package store is restorable state, never committed — the npm model.
 if [ ! -f "$root/.gitignore" ] || ! grep -q '^\.intelligence/' "$root/.gitignore"; then
     {
         [ -f "$root/.gitignore" ] && [ -n "$(tail -c 1 "$root/.gitignore" 2>/dev/null)" ] && echo ""
-        echo "# intelligence CLI package store (restored by 'intelligence install')"
+        echo "# intelligence CLI package store (restored automatically by 'intelligence sync')"
         echo ".intelligence/"
     } >> "$root/.gitignore"
 fi
 
-ensure_engine_staged "$root"
+# The engine's own content (meta-skills, authoring rule, engine agents) is an
+# ordinary package: auto-selected, opted out with --bare, removable later with
+# 'intelligence package remove @ainova-systems/sync --force'.
+if [ "$bare" -eq 0 ]; then
+    sync_pkg_entry "$manifest"
+    sync_pkg_install "$root"
+fi
+
 echo "initialized: intelligence.yaml (targets:$(printf ' %s' $targets))"
-echo "next: add intelligence packages — e.g. 'intelligence add @ainova-systems/core'"
+[ "$bare" -eq 1 ] && echo "  bare setup: no packages — engine meta-skills not installed"
+echo "  add packages:  intelligence package add @ainova-systems/core   (browse: intelligence package search)"
+echo "  write your own: create $content_dir/rules/context.md, then intelligence sync"
+if [ "$bare" -eq 0 ]; then
+    echo "  tailor this repository: ask your agent to run /intelligence-learn-from-repository after sync"
+fi
+echo "  docs: https://github.com/ainova-systems/intelligence#readme"
 
 if [ "$no_sync" -eq 0 ]; then
     cd "$root"

package/cli/commands/package.sh

@@ -0,0 +1,30 @@
+#!/bin/bash
+# intelligence package <add|remove|list|search> ...
+set -euo pipefail
+source "$CLI_DIR/lib/cli-common.sh"
+
+action="${1:-}"
+[ -n "$action" ] || die "usage: intelligence package <add|remove|list|search> [args]"
+shift
+
+case "$action" in
+    add)
+        require_cli_project
+        ensure_project_current "$IP_ROOT"
+        exec bash "$CLI_DIR/internal/package-add.sh" "$@"
+        ;;
+    remove)
+        require_cli_project
+        ensure_project_current "$IP_ROOT"
+        exec bash "$CLI_DIR/internal/package-remove.sh" "$@"
+        ;;
+    list)
+        exec bash "$CLI_DIR/internal/package-list.sh" "$@"
+        ;;
+    search)
+        exec bash "$CLI_DIR/internal/package-search.sh" "$@"
+        ;;
+    *)
+        die "usage: intelligence package <add|remove|list|search> [args]"
+        ;;
+esac

package/cli/commands/registry.sh

@@ -1,8 +1,10 @@
 #!/bin/bash
-# intelligence registry <list | add @scope <registry-repo-url> | remove @scope>
+# intelligence registry <list | add <registry-repo-url> [--force] | remove <url>>
 #
-# A registry binding is rare, per-scope configuration (npm's @scope:registry
-# analog): the URL of a git repo whose index.yaml maps names to sources.
+# The registries block is a TRUST LIST: git repos holding an index.yaml, in
+# trust order. Adding one is a committed, reviewable act — after it, every
+# name that registry declares installs like a bundled one. No scope labels:
+# names carry their own scope, and the first registry to declare a name wins.
 set -euo pipefail
 source "$CLI_DIR/lib/cli-common.sh"
 
@@ -10,42 +12,75 @@ sub="${1:-list}"
 case "$sub" in
     list)
         detect_project
-        if [ "$IP_MODE" = "v2" ] && [ -f "$IP_ROOT/intelligence.yaml" ]; then
-            echo "Project bindings (intelligence.yaml):"
+        if [ "$IP_MODE" = "cli" ] && [ -f "$IP_ROOT/intelligence.yaml" ]; then
+            echo "Project registries (intelligence.yaml, trust order):"
             found=0
-            while IFS= read -r scope; do
-                [ -n "$scope" ] || continue
+            while IFS= read -r url; do
+                [ -n "$url" ] || continue
                 found=1
-                echo "  $scope -> $(qmap_value "$IP_ROOT/intelligence.yaml" "registries" "$scope")"
-            done < <(qmap_keys "$IP_ROOT/intelligence.yaml" "registries")
+                index="$(_fetch_index "${url#git+}")"
+                if [ -n "$index" ]; then
+                    n="$(qmap_keys "$index" "packages" | grep -c . || true)"
+                    echo "  $url — $n package(s)"
+                else
+                    echo "  $url — UNREACHABLE or no index.yaml"
+                fi
+            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)
-        scope="${2:-}"; url="${3:-}"
-        { [ -n "$scope" ] && [ -n "$url" ]; } || die "usage: intelligence registry add @scope <registry-repo-url>"
-        case "$scope" in @*/*) die "bind a scope (@acme), not a package name" ;; @*) ;; *) die "scope must start with @" ;; esac
-        require_v2
-        qmap_set_value "$IP_ROOT/intelligence.yaml" "registries" "$scope" "$url"
-        echo "$scope -> $url"
+        url="${2:-}"
+        force=0
+        [ "${3:-}" = "--force" ] && force=1
+        [ -n "$url" ] || die "usage: intelligence registry add <registry-repo-url> [--force]"
+        case "$url" in
+            @*) die "registries are added by URL — names carry their own scope. To install a package: intelligence package add $url/<name>" ;;
+        esac
+        assert_safe_source_url "${url#git+}"
+        require_cli_project
+        ensure_project_current "$IP_ROOT"
+        # Fail closed: a URL that cannot produce an index is not a registry,
+        # and recording it would turn a typo here into a confusing failure at
+        # the first add. --force covers the one honest case: the registry is
+        # not published (or reachable) yet.
+        index="$(_fetch_index "${url#git+}")"
+        if [ -n "$index" ]; then
+            n="$(qmap_keys "$index" "packages" | grep -c . || true)"
+            echo "  index.yaml reachable — $n package(s):"
+            qmap_keys "$index" "packages" | sed 's/^/    /'
+        elif [ "$force" -eq 1 ]; then
+            echo "  WARN: no index.yaml at $url — recording anyway (--force)." >&2
+        else
+            echo "ERROR: no index.yaml found at $url — not adding it." >&2
+            echo "  A registry is a git repo with index.yaml at its root, mapping names to sources:" >&2
+            echo "    packages:" >&2
+            echo "      \"@acme/backend\":" >&2
+            echo "        url: \"https://github.com/acme/intelligence.git\"" >&2
+            echo "        path: \"packs/backend\"      # omit when the repo IS the package" >&2
+            echo "  Format and an example: https://github.com/ainova-systems/intelligence-registry" >&2
+            echo "  A single repository needs no registry at all: intelligence package add github:org/repo" >&2
+            echo "  Recording it ahead of a registry that does not exist yet: --force" >&2
+            exit 1
+        fi
+        registries_add "$IP_ROOT/intelligence.yaml" "$url"
+        echo "added: $url"
         ;;
     remove)
-        scope="${2:-}"
-        [ -n "$scope" ] || die "usage: intelligence registry remove @scope"
-        require_v2
-        qmap_delete_key "$IP_ROOT/intelligence.yaml" "registries" "$scope"
-        echo "unbound $scope"
+        url="${2:-}"
+        [ -n "$url" ] || die "usage: intelligence registry remove <url>"
+        require_cli_project
+        ensure_project_current "$IP_ROOT"
+        registries_remove "$IP_ROOT/intelligence.yaml" "$url"
+        # The retired flat-map form also stored scope keys — drop one if the
+        # argument names it, so old manifests clean up with the old command.
+        case "$url" in
+            @*) qmap_delete_key "$IP_ROOT/intelligence.yaml" "registries" "$url" ;;
+        esac
+        echo "removed: $url"
         ;;
     *)
-        die "usage: intelligence registry <list | add @scope <url> | remove @scope>"
+        die "usage: intelligence registry <list | add <url> [--force] | remove <url>>"
         ;;
 esac