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

package/cli/lib/cli-common.sh

@@ -54,8 +54,8 @@ source "$CLI_DIR/lib/lockfile.sh"
 # 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`.
+# network; only a cross-version acquisition reaches git. The pin is held
+# exactly at the bundled engine version and moved by lifecycle alignment.
 #
 # Its identity is DATA shipped with the distribution (cli/engine-package.yaml),
 # never a name compiled into cli code — a fork edits the file.
@@ -113,7 +113,7 @@ require_v2() {
     detect_project
     case "$IP_MODE" in
         v2) ;;
-        legacy) die "this is a vendored (v1) setup — run 'intelligence migrate' first, or keep using its own flow" ;;
+        legacy) die "this is a vendored (v1) setup — run 'intelligence init' to migrate it, or keep using its own flow" ;;
         *) die "no intelligence project found here — run 'intelligence init'" ;;
     esac
 }
@@ -126,19 +126,25 @@ manifest_intelligence_dir() {
     printf '%s' "${v:-intelligence}"
 }
 
+default_target_output() {
+    case "$1" in
+        agents) printf '%s' "AGENTS.md" ;;
+        copilot) printf '%s' ".github" ;;
+        *) printf '.%s' "$1" ;;
+    esac
+}
+
 bundled_engine_version() {
     tr -d ' \t\r\n' < "$IS_ENGINE_DIR/VERSION"
 }
 
 # --- The sync package's manifest/lock plumbing ---------------------------
-# sync_pkg_entry <manifest> — write/refresh the package's manifest entry:
-# name + exact pin + explicit url/path, so resolution never depends on any
-# registry (a project registry shadowing the name cannot brick the engine).
+# sync_pkg_entry <manifest> — write/refresh only the requested exact pin.
+# The built-in source lives in engine-package.yaml and resolved source state
+# belongs exclusively to intelligence.lock.
 sync_pkg_entry() {
     local manifest="$1"
     qmap_set "$manifest" "packages" "$SYNC_PKG_NAME" "version" "$(bundled_engine_version)"
-    qmap_set "$manifest" "packages" "$SYNC_PKG_NAME" "url" "$SYNC_PKG_URL"
-    qmap_set "$manifest" "packages" "$SYNC_PKG_NAME" "path" "$SYNC_PKG_PATH"
 }
 
 # sync_pkg_install <root> — materialize the package into the store and lock
@@ -156,14 +162,138 @@ sync_pkg_install() {
 # Everything the IS_CLI mode of sync.sh needs, derived from the manifest.
 export_engine_env() {
     local root="$1"
-    local umbrella
-    umbrella="$(manifest_intelligence_dir "$root/intelligence.yaml")"
+    local content_rel
+    content_rel="$(manifest_intelligence_dir "$root/intelligence.yaml")"
     export IS_CLI=1
     export CONFIG_FILE="$root/intelligence.yaml"
     export REPO_ROOT="$root"
-    export IS_UMBRELLA_REL="$umbrella"
+    export IS_CONTENT_REL="$content_rel"
     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"
+    export IS_PROTECTED_DIRS="$content_rel:.intelligence"
+}
+
+# --- Project lifecycle preflight -----------------------------------------
+# Public commands are intentionally few. They share this state gate so a CLI
+# installed at a newer engine version brings the current v2 project forward
+# before a mutating operation. The npm install itself cannot do that: it runs
+# outside any project and does not know which repositories the user owns.
+
+is_ci_environment() {
+    case "${CI:-}" in
+        1|true|TRUE|True|yes|YES|Yes|on|ON|On) return 0 ;;
+        *) return 1 ;;
+    esac
+}
+
+# Validate a repository-relative project content directory, including every
+# existing symlinked path component. Call before writing a new manifest.
+assert_safe_content_dir() {
+    local root="$1" content_dir="$2" repo_phys probe old_ifs part probe_phys
+    local -a parts
+    case "$content_dir" in
+        ""|/*|.|..|../*|*/../*|*/..|.git|.git/*|.intelligence|.intelligence/*|*\\*|[A-Za-z]:*)
+            die "unsafe content directory '$content_dir'"
+            ;;
+    esac
+    repo_phys="$(cd "$root" && pwd -P)"
+    probe="$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 content directory resolves outside the repository: '$content_dir'" ;;
+            esac
+        fi
+    done
+}
+
+project_needs_upgrade() {
+    local root="$1" manifest="$1/intelligence.yaml" stamp eng pinned locked name
+    [ -f "$manifest" ] || return 1
+    stamp="$(read_schema_version "$manifest")"
+    eng="$(bundled_engine_version)"
+    [ -z "$stamp" ] && return 0
+    [ -n "$(top_scalar "$manifest" "sync_version")" ] && return 0
+    _ver_gt "$eng" "$stamp" && return 0
+    [ -d "$root/.intelligence/engine" ] && return 0
+
+    while IFS= read -r name; do
+        [ -n "$name" ] || continue
+        # Early RC manifests mixed requested intent with resolved source
+        # details. Source URL/path now live only in the required lockfile.
+        [ -n "$(qmap_field "$manifest" "packages" "$name" "url")" ] && return 0
+        [ -n "$(qmap_field "$manifest" "packages" "$name" "path")" ] && return 0
+        if [ "$name" = "$SYNC_PKG_NAME" ]; then
+            pinned="$(qmap_field "$manifest" "packages" "$name" "version")"
+            locked="$(qmap_field "$root/intelligence.lock" "packages" "$name" "resolved")"
+            [ "$pinned" = "$eng" ] || return 0
+            if [ -f "$root/intelligence.lock" ]; then
+                [ -n "$locked" ] || return 0
+                [ "${locked#v}" = "$eng" ] || return 0
+            fi
+        fi
+    done < <(qmap_keys "$manifest" "packages")
+    return 1
+}
+
+# A manifest with packages but no lock has no trustworthy resolved state from
+# which lifecycle alignment can proceed. Never manufacture a partial lock.
+project_has_packages() {
+    local root="$1" name found=1
+    while IFS= read -r name; do
+        [ -n "$name" ] || continue
+        assert_valid_pkg_name "$name"
+        found=0
+    done < <(qmap_keys "$root/intelligence.yaml" "packages")
+    return "$found"
+}
+
+ensure_project_current() {
+    local root="$1" explicit="${2:-}" manifest="$1/intelligence.yaml" stamp eng
+    check_version_compat "$manifest" || return $?
+    if project_has_packages "$root" && [ ! -f "$root/intelligence.lock" ]; then
+        die "manifest declares packages but intelligence.lock is absent — restore the committed lock before running project lifecycle commands"
+    fi
+    project_needs_upgrade "$root" || return 0
+    stamp="$(read_schema_version "$manifest")"
+    eng="$(bundled_engine_version)"
+    if is_ci_environment && [ "$explicit" != "--explicit" ]; then
+        die "project lifecycle requires alignment (stamp ${stamp:-unstamped}, engine $eng) — run 'intelligence init --apply' locally, review and commit the diff"
+    fi
+    echo "  project alignment: stamp ${stamp:-unstamped}, engine $eng"
+    bash "$CLI_DIR/internal/upgrade-v2.sh" --no-sync
+}
+
+project_store_missing() {
+    local root="$1" manifest="$1/intelligence.yaml" name src
+    while IFS= read -r name; do
+        [ -n "$name" ] || continue
+        assert_valid_pkg_name "$name"
+        [ -d "$root/.intelligence/packages/$name" ] || return 0
+    done < <(qmap_keys "$manifest" "packages")
+    for section in rules agents skills; do
+        while IFS= read -r src; do
+            case "$src" in
+                .intelligence/packages/*)
+                    [ -d "$root/$src" ] || return 0
+                    ;;
+            esac
+        done < <(read_yaml_list "$manifest" "$section")
+    done
+    return 1
+}
+
+restore_project_store_if_missing() {
+    local root="$1"
+    project_store_missing "$root" || return 0
+    [ -f "$root/intelligence.lock" ] || die "package store is missing and intelligence.lock is absent — run 'intelligence init'"
+    echo "  restoring package store from intelligence.lock"
+    bash "$CLI_DIR/internal/restore.sh" --frozen --no-sync
 }

package/cli/lib/lockfile.sh

@@ -12,7 +12,7 @@ LOCK_SEP=$'\x1f'
 
 # top_scalar <file> <key> — one top-level scalar (`key: "value"`), quotes and
 # trailing comment stripped. The declared exception to "no new parsing": the
-# engine's read_engine_stamp is hardwired to its own key.
+# engine's read_schema_version is hardwired to its own key.
 top_scalar() {
     [ -f "$1" ] || return 0
     awk -v key="$2" '

package/cli/lib/manifest.sh

@@ -36,6 +36,92 @@ assert_valid_pkg_name() {
     esac
 }
 
+# Target names become adapter filenames and shell function suffixes, so keep
+# them inside the portable shell-identifier subset used by built-in adapters.
+assert_valid_target_name() {
+    case "$1" in
+        ""|[!abcdefghijklmnopqrstuvwxyz]*|*[!abcdefghijklmnopqrstuvwxyz0123456789_]*)
+            die "invalid target name '$1' — expected [a-z][a-z0-9_]*"
+            ;;
+    esac
+}
+
+# target_exists <manifest> <name> — distinguish a disabled target from one
+# that is not declared at all. Both inline and block target shapes count.
+target_exists() {
+    local file="$1" target="$2"
+    [ -f "$file" ] || return 1
+    awk -v target="$target" '
+        { sub(/\r$/, "") }
+        /^targets:[[:space:]]*$/ { in_targets = 1; next }
+        /^[A-Za-z]/ { in_targets = 0 }
+        in_targets && $0 ~ "^  " target ":[[:space:]]*" { found = 1; exit }
+        END { exit(found ? 0 : 1) }
+    ' "$file"
+}
+
+# target_set_enabled <manifest> <name> <true|false> <default-output>
+# Transactionally update only `enabled`, preserving every other target field
+# and comment. A missing target is added in the compact form used by init.
+target_set_enabled() {
+    local file="$1" target="$2" enabled="$3" output="$4"
+    [ -f "$file" ] || die "no such file: $file"
+    case "$enabled" in true|false) ;; *) die "internal: invalid target state '$enabled'" ;; esac
+    output="$(_yq_esc "$output")"
+    _qmap_stage "$file" -v target="$target" -v enabled="$enabled" -v output="$output" '
+        function entry() { return "  " target ": { enabled: " enabled ", output: \"" output "\" }" }
+        function add_enabled_to_inline(line,    p) {
+            p = index(line, "{")
+            if (p > 0) return substr(line, 1, p) " enabled: " enabled "," substr(line, p + 1)
+            return line
+        }
+        function flush_target() {
+            if (in_target && !enabled_seen) print "    enabled: " enabled
+            in_target = 0
+        }
+        function flush_targets() {
+            flush_target()
+            if (in_targets && !target_seen) { print entry(); target_seen = 1 }
+            in_targets = 0
+        }
+        { sub(/\r$/, "") }
+        /^targets:[[:space:]]*$/ { targets_seen = 1; in_targets = 1; print; next }
+        in_targets && /^[A-Za-z]/ { flush_targets() }
+        in_targets && /^  [A-Za-z]/ {
+            flush_target()
+            if ($0 ~ "^  " target ":[[:space:]]*") {
+                target_seen = 1
+                if (match($0, /enabled:[[:space:]]*(true|false)/)) {
+                    print substr($0, 1, RSTART - 1) "enabled: " enabled substr($0, RSTART + RLENGTH)
+                    enabled_seen = 1
+                } else if ($0 ~ /\{/) {
+                    print add_enabled_to_inline($0)
+                    enabled_seen = 1
+                } else {
+                    print
+                    in_target = 1
+                    enabled_seen = 0
+                }
+                next
+            }
+        }
+        in_target && /^    enabled:[[:space:]]*/ {
+            print "    enabled: " enabled
+            enabled_seen = 1
+            next
+        }
+        { last = $0; print }
+        END {
+            flush_targets()
+            if (!targets_seen) {
+                if (last != "") print ""
+                print "targets:"
+                print entry()
+            }
+        }
+    '
+}
+
 # qmap_keys <file> <block> — quoted keys, one per line.
 qmap_keys() {
     [ -f "$1" ] || return 0
@@ -215,6 +301,29 @@ qmap_delete_key() {
     '
 }
 
+# qmap_delete_field <file> <block> <key> <field> — drop one field from a
+# quoted-key entry without disturbing its other fields or surrounding YAML.
+qmap_delete_field() {
+    local file="$1" block="$2" key="$3" field="$4"
+    [ -f "$file" ] || return 0
+    _qmap_stage "$file" -v block="$block" -v key="$key" -v field="$field" '
+        { sub(/\r$/, "") }
+        $0 ~ "^" block ":[ \t]*$" { inb = 1; print; next }
+        inb && /^[^ #]/ { inb = 0; ink = 0 }
+        inb && /^  "/ {
+            s = substr($0, 4); q = index(s, "\"")
+            ink = (q > 0 && substr(s, 1, q - 1) == key)
+            print; next
+        }
+        inb && ink && /^    [A-Za-z_]/ {
+            line = $0; sub(/^    /, "", line)
+            c = index(line, ":")
+            if (c > 0 && substr(line, 1, c - 1) == field) next
+        }
+        { print }
+    '
+}
+
 # --- registries: a trust LIST, not a scope map -----------------------------
 # The block holds registry repo URLs in trust order. Two shapes are read so
 # early manifests keep working: the list form (`- "url"`) and the retired

package/cli/lib/registry.sh

@@ -11,7 +11,7 @@
 # visible, reviewable, deletable.
 #
 # The NAME is the trust anchor a developer reasons with; source integrity is
-# a separate mechanism: the lock pins url+sha, and doctor flags
+# a separate mechanism: the lock pins url+sha, and `status --check` flags
 # resolution/lock url drift.
 #
 # An index is itself fetched with git (never curl): auth, proxies and private
@@ -93,7 +93,7 @@ suggest_similar() {
             cshort="${cand#*/}"; cshort="${cshort%s}"
             if [ "$cshort" = "$want" ] && [ "$cand" != "$name" ]; then
                 seen="$seen$cand "
-                echo "  Did you mean: intelligence add $cand" >&2
+                echo "  Did you mean: intelligence package add $cand" >&2
             fi
         done < <(qmap_keys "$idx" "packages")
     }
@@ -116,8 +116,8 @@ fetch_package() {
     assert_safe_source_url "$url"
     assert_safe_ref "$ref"
     # Bundle seed: the engine-content package at the CLI's own version copies
-    # from the npm bundle — no network, which keeps init / fresh-clone install
-    # / migrate offline exactly like the staging they replace. Keyed on the
+    # from the npm bundle — no network, which keeps init, sync restoration and
+    # archived-project conversion offline. Keyed on the
     # full (url, path, ref) triple; any other version or source falls through
     # to the normal clone.
     if [ "$url" = "$SYNC_PKG_URL" ] && [ "$subpath" = "$SYNC_PKG_PATH" ] \

package/engine/ENGINE_SHA

@@ -1 +1 @@
-557cde6997dce612e0e8a5a11adc2472173dcec0
+af238e67e8a9469edf6d2058e169de52cbeb93af

package/engine/adapters/_template.sh

@@ -1,22 +1,21 @@
 #!/bin/bash
-# intelligence-sync: Adapter template
-# Copy this file to create a new IDE adapter.
+# Intelligence CLI: project adapter template
+# Scaffold this file with: intelligence adapter create <name>
 #
 # This file is NOT executable as-is — `<name>` placeholders below would be
 # parsed by bash as input redirection (`<` operator). Replace every
 # occurrence with your adapter name before sourcing.
 #
 # Required:
-#   1. Name the file: <ide-name>.sh (e.g., myide.sh)
-#   2. Replace every `<name>` placeholder with your adapter name
-#   3. Implement sync_to_<name>() function
-#   4. Add target to config.yaml:
+#   1. Implement sync_to_<name>() and its three content transforms
+#   2. Enable it after implementation: intelligence adapter enable <name>
+#      This adds the target to intelligence.yaml when it is absent:
 #      targets:
 #        <name>: { enabled: true, output: ".<name>" }
 #
 # The sync_to_<name>() function receives:
 #   $1 = repo_root     — absolute path to the project root
-#   $2 = config_file   — absolute path to config.yaml
+#   $2 = config_file   — absolute path to intelligence.yaml
 #   $3 = output_dir    — absolute path to the output directory (e.g., .myide/)
 #
 # Available library functions (from lib/common.sh):
@@ -29,10 +28,12 @@
 #   get_model_default(ide, tier)        — hardcoded default for ide:tier
 #   map_access_to_claude_tools(access)  — full->"" (no tools list; inherits all), readonly->restricted
 #   map_access_to_claude_disallowed(access) — readonly->"Write, Edit", full->""
-#   read_yaml_list(config, section)     — read list from config.yaml
+#   read_yaml_list(manifest, section)   — read a source list from intelligence.yaml
 #   get_target_field(config, target, field) — read a target's config field
 
-source "$(dirname "${BASH_SOURCE[0]}")/../lib/common.sh"
+# Project adapters are sourced by engine/sync.sh after the shared library is
+# loaded. Keep this template position-independent: after scaffolding it lives
+# under the project's content directory, not beside engine/lib/.
 
 # Sync rules for <agent-name>
 # Typical transformations:

package/engine/adapters/agents.sh

@@ -21,8 +21,8 @@ source "$(dirname "${BASH_SOURCE[0]}")/../lib/common.sh"
 # one document Cursor, Copilot and Codex all read as canonical.
 # The defaults only cover an adapter driven directly (tests); sync.sh always
 # exports both.
-agents_md_umbrella_rel() {
-    printf '%s' "${IS_UMBRELLA_REL:-intelligence}"
+agents_md_content_rel() {
+    printf '%s' "${IS_CONTENT_REL:-intelligence}"
 }
 
 agents_md_module_rel() {
@@ -196,14 +196,14 @@ agents_md_append_rules_list() {
     # Path-scoped rules stay in tool-specific channels (.cursor/rules/,
     # .github/instructions/) so monorepo scoping is preserved.
     if [ "${#global_rule_files[@]}" -gt 0 ]; then
-        local umbrella_rel
-        umbrella_rel="$(agents_md_umbrella_rel "$repo_root")"
+        local content_rel
+        content_rel="$(agents_md_content_rel "$repo_root")"
         {
             echo "---"
             echo ""
             echo "## Project Context"
             echo ""
-            echo "<!-- Inlined from always-on rules in $umbrella_rel/rules/ -->"
+            echo "<!-- Inlined from always-on rules in $content_rel/rules/ -->"
             echo ""
         } >> "$output"
         local rf
@@ -240,17 +240,17 @@ sync_to_agents() {
 
     mkdir -p "$(dirname "$output_file")"
 
-    local umbrella_rel module_rel
-    umbrella_rel="$(agents_md_umbrella_rel "$repo_root")"
+    local content_rel module_rel
+    content_rel="$(agents_md_content_rel "$repo_root")"
     module_rel="$(agents_md_module_rel "$repo_root")"
 
     # These two strings are written into a COMMITTED file. An absolute path here
     # means the derivation failed, and a machine-specific path in AGENTS.md is
     # worse than a failed sync — fail loudly instead.
-    case "$umbrella_rel$module_rel" in
+    case "$content_rel$module_rel" in
         /*|*:[\\/]*)
             echo "  ERROR: AGENTS.md paths did not resolve relative to the repo root:" >&2
-            echo "         umbrella='$umbrella_rel' module='$module_rel' repo_root='$repo_root'" >&2
+            echo "         content='$content_rel' module='$module_rel' repo_root='$repo_root'" >&2
             return 1
             ;;
     esac
@@ -261,7 +261,7 @@ sync_to_agents() {
 
     {
         echo "<!-- Generated by intelligence-sync. Do not edit manually. -->"
-        echo "<!-- Source: $umbrella_rel/ | Sync: $sync_cmd -->"
+        echo "<!-- Source: $content_rel/ | Sync: $sync_cmd -->"
         echo ""
     } > "$output_file"
 
@@ -270,7 +270,7 @@ sync_to_agents() {
     {
         echo "## Intelligence"
         echo ""
-        echo "Source of truth: \`$umbrella_rel/\` | Sync: \`$sync_cmd\`"
+        echo "Source of truth: \`$content_rel/\` | Sync: \`$sync_cmd\`"
         echo ""
     } >> "$output_file"
 

package/engine/adapters/opencode.sh

@@ -29,7 +29,7 @@ source "$(dirname "${BASH_SOURCE[0]}")/../lib/common.sh"
 # Strip frontmatter, return body only.
 # Direct call to the shared `strip_frontmatter` helper in lib/common.sh —
 # duplicating the awk block here would violate the "all parsing in common.sh"
-# convention (see CLAUDE.md / docs/CONVENTIONS.md).
+# convention (see CLAUDE.md / packages/sync/references/conventions.md).
 
 sync_opencode_skills() {
     local repo_root="$1"

package/engine/lib/common.sh

@@ -16,16 +16,14 @@ normalize_file_to_lf() {
 
 # --- Layout tokens -----------------------------------------------------------
 #
-# The umbrella folder is named by the project (`intelligence/`, `Intelligence/`,
-# a codename) — so an artifact SHIPPED BY THE ENGINE cannot write that name
-# down. A rule that scopes itself to the intelligence layer needs `paths:` to
-# say "the umbrella", and an agent body needs to name the sync command. Both are
-# spelled with tokens, expanded here at output time:
+# The content directory is named by the project (`intelligence/`,
+# `Intelligence/`, a codename), so package-shipped artifacts cannot hardcode
+# it. Layout-sensitive paths and commands use tokens expanded at output time:
 #
-#   <umbrella>  ->  the repo-relative umbrella dir   (e.g. `Intelligence`)
-#   <module>    ->  the repo-relative engine module  (e.g. `Intelligence/sync`)
+#   <content-dir> -> the repo-relative project content dir (e.g. `Intelligence`)
+#   <module>      -> the repo-relative sync package store path
 #
-# Values come from IS_UMBRELLA_REL / IS_MODULE_REL, which sync.sh derives from
+# Values come from IS_CONTENT_REL / IS_MODULE_REL, which the CLI derives from
 # the detected layout (never hardcoded) and exports before any adapter runs.
 # Expansion happens in EVERY generated file, frontmatter and body alike, so a
 # scoped rule reaches Claude's `paths:`, Cursor's `globs:` and Copilot's
@@ -34,24 +32,18 @@ normalize_file_to_lf() {
 # finalize_output_file <file>
 # The single exit gate for every file an adapter writes: expand layout tokens,
 # then normalize CRLF -> LF. Adapters MUST call this (not normalize_file_to_lf)
-# on each output — a missed call ships a literal `<umbrella>` into an IDE.
+# on each output — a missed call ships a literal `<content-dir>` into an IDE.
 finalize_output_file() {
     local target="$1"
-    local umb="${IS_UMBRELLA_REL:-intelligence}"
-    local mod="${IS_MODULE_REL:-intelligence/sync}"
-    # `<sync-cmd>` is how engine content says "run a sync": vendored setups
-    # expand it to the script invocation (built from $mod, so it reproduces the
-    # exact pre-token string), the CLI overrides it via IS_SYNC_CMD
-    # (`intelligence sync`). `<manifest>` names the project's config file the
-    # same way: `config.yaml` vendored, `intelligence.yaml` under the CLI
-    # (IS_MANIFEST_NAME).
-    local sc="${IS_SYNC_CMD:-bash $mod/scripts/sync.sh}"
-    local mf="${IS_MANIFEST_NAME:-config.yaml}"
+    local content="${IS_CONTENT_REL:-intelligence}"
+    local mod="${IS_MODULE_REL:-.intelligence/packages/@ainova-systems/sync}"
+    local sc="${IS_SYNC_CMD:-intelligence sync}"
+    local mf="${IS_MANIFEST_NAME:-intelligence.yaml}"
     local tmp_file="$target.tmp"
     # Literal (index-based) substitution, not gsub: a regex replacement would
     # give `&` in a path its special meaning, and POSIX awk has no way to pass a
     # replacement string verbatim.
-    awk -v umb="$umb" -v mod="$mod" -v sc="$sc" -v mf="$mf" '
+    awk -v content="$content" -v mod="$mod" -v sc="$sc" -v mf="$mf" '
         function repl(s, from, to,   out, i) {
             out = ""
             while ((i = index(s, from)) > 0) {
@@ -65,7 +57,7 @@ finalize_output_file() {
             $0 = repl($0, "<sync-cmd>", sc)
             $0 = repl($0, "<manifest>", mf)
             $0 = repl($0, "<module>", mod)
-            $0 = repl($0, "<umbrella>", umb)
+            $0 = repl($0, "<content-dir>", content)
             print
         }
     ' "$target" > "$tmp_file"
@@ -798,7 +790,7 @@ warn_unsynced() {
     # from its location — it comes from the env contract the CLI exports.
     local intel_basename
     if [ "${IS_CLI:-0}" = "1" ]; then
-        intel_basename="$(basename "${IS_UMBRELLA_REL:-intelligence}")"
+        intel_basename="$(basename "${IS_CONTENT_REL:-intelligence}")"
     else
         intel_basename="$(basename "$(dirname "$config_file")")"
     fi

package/engine/lib/contract.sh

@@ -1,16 +1,16 @@
 #!/bin/bash
-# shellcheck disable=SC2034  # IS_RC_*/IS_VERSION_KEY are the public bash<->CLI contract, consumed by the scripts that source this lib
+# shellcheck disable=SC2034  # IS_RC_*/IS_SCHEMA_VERSION_KEY are the public bash<->CLI contract, consumed by the scripts that source this lib
 # intelligence-sync: the version and status contract.
 # Source this file — never execute directly.
 #
 # Two things live here, and both are contracts other programs depend on:
-#   * the applied-schema stamp (`sync_version` in the manifest) with its
+#   * the applied-schema stamp (`schema_version` in the manifest) with its
 #     read / write / compare helpers, and
 #   * the IS_STATUS / IS_RC_* codes every engine flow reports.
 #
-# Schema migrations themselves are NOT here: the CLI owns them (v2 migrations
-# live in `intelligence upgrade`), and a v1 project is brought forward by the
-# archived v1 engine before `intelligence migrate` converts it.
+# Schema migrations themselves are NOT here: the CLI owns them behind
+# `intelligence init`, and a v1 project is brought forward by the archived v1
+# engine before `intelligence init` converts it.
 
 # The applied-schema version is a managed key in the manifest.
 #
@@ -18,13 +18,13 @@
 # Anything else in the manifest may be reshaped; the name, location and shape of
 # this key never are - so any engine, however old or new, can always read "what
 # schema is this?" before parsing the rest.
-IS_VERSION_KEY="sync_version"
+IS_SCHEMA_VERSION_KEY="schema_version"
 
-# read_engine_stamp <config_file> → applied version, or "" if absent.
-read_engine_stamp() {
+# read_schema_version <config_file> → applied version, or "" if absent.
+read_schema_version() {
     local cf="$1"
     [ -f "$cf" ] || return 0
-    awk -v k="$IS_VERSION_KEY" '
+    awk -v k="$IS_SCHEMA_VERSION_KEY" '
         { sub(/\r$/, "") }
         $0 ~ "^" k ":" {
             v = $0; sub(/^[^:]*:[[:space:]]*/, "", v)
@@ -35,14 +35,14 @@ read_engine_stamp() {
     ' "$cf"
 }
 
-# stamp_version <config_file> <version> — idempotent, transactional upsert of
+# stamp_schema_version <config_file> <version> — idempotent, transactional upsert of
 # the contract key (replace in place if present, else append at top level).
 # No-op if config.yaml does not exist yet (pre-bootstrap).
-stamp_version() {
+stamp_schema_version() {
     local cf="$1" ver="$2"
     [ -f "$cf" ] || return 0
     local tmp="$cf.ver.tmp"
-    awk -v k="$IS_VERSION_KEY" -v val="$ver" '
+    awk -v k="$IS_SCHEMA_VERSION_KEY" -v val="$ver" '
         { sub(/\r$/, "") }
         $0 ~ "^" k ":" { print k ": \"" val "\""; found=1; next }
         { print }
@@ -62,7 +62,7 @@ IS_RC_CONFIG_MISSING=2      # no manifest found
 IS_RC_AMBIGUOUS=3           # conflicting state; agent/human-only — bash never emits this itself
 IS_RC_AHEAD=4               # project stamped newer than this engine understands
 IS_RC_ABORTED_INCOMPLETE=5  # staged state incomplete; the project was left untouched
-IS_RC_NEEDS_UPDATE=6        # pending schema changes (stamp < engine) — run `intelligence upgrade` first
+IS_RC_NEEDS_UPDATE=6        # pending schema changes (stamp < engine) — run `intelligence init --apply`
 
 # is_status <code-name> [detail] — emit one parseable line for the skill.
 is_status() {
@@ -106,7 +106,7 @@ _ver_gt() {
 # conflict, else 0.
 check_version_compat() {
     local cf="$1" stamp eng
-    stamp="$(read_engine_stamp "$cf")"
+    stamp="$(read_schema_version "$cf")"
     [ -n "$stamp" ] || return 0
     eng="$(engine_version)"
     [ -n "$eng" ] || return 0