@ainova-systems/intelligence 0.17.2 → 0.18.0

package/cli/commands/init.sh

@@ -295,7 +295,8 @@ manifest="$root/intelligence.yaml"
     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 "#                                      tier: frontier|heavy|standard|light,"
+    echo "#                                      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:"

package/cli/internal/check.sh

@@ -102,7 +102,20 @@ while IFS= read -r name; do
             warn "$name is locked but not installed — run 'intelligence sync'"
             continue
         fi
-        ok "$name @ $(pin_label "$m_ref" "$l_res" "$(qmap_field "$lock" "packages" "$name" "sha")")"
+        # Report what the store holds, never what the lock pins: they differ
+        # after a pull that moved the lock and left the ignored store behind.
+        l_url="$(qmap_field "$lock" "packages" "$name" "url")"
+        l_path="$(qmap_field "$lock" "packages" "$name" "path")"
+        l_sha="$(qmap_field "$lock" "packages" "$name" "sha")"
+        if ! store_record_get "$IP_ROOT" "$name"; then
+            warn "$name is installed, but the store does not record which commit it holds; the lock pins $(pin_label "$m_ref" "$l_res" "$l_sha") — run 'intelligence sync'"
+        elif [ "$IS_REC_URL" != "$l_url" ] || [ "$IS_REC_PATH" != "$l_path" ]; then
+            warn "$name was installed from ${IS_REC_URL}${IS_REC_PATH:+ (path $IS_REC_PATH)} but the lock names ${l_url}${l_path:+ (path $l_path)} — run 'intelligence sync'"
+        elif [ "$IS_REC_RESOLVED" != "$l_res" ] || [ "$IS_REC_SHA" != "$l_sha" ]; then
+            warn "$name holds $IS_REC_RESOLVED@$(short_sha "$IS_REC_SHA") but the lock pins $l_res@$(short_sha "$l_sha") — run 'intelligence sync'"
+        else
+            ok "$name @ $(pin_label "$m_ref" "$IS_REC_RESOLVED" "$IS_REC_SHA")"
+        fi
     fi
 done < <(qmap_keys "$manifest" "packages")
 

package/cli/internal/convert-legacy.sh

@@ -406,6 +406,11 @@ trap 'rollback; exit 130' INT TERM
 mv "$stage/.intelligence" "$root/.intelligence"
 cp "$manifest_stage" "$root/intelligence.yaml"
 lock_write_from_tsv "$root/intelligence.lock" "$lock_rows"
+# The staged store holds exactly these rows; record them so sync trusts it.
+while IFS="$LOCK_SEP" read -r rec_name _ rec_url rec_path rec_resolved rec_sha; do
+    [ -n "$rec_name" ] || continue
+    store_record_set "$root" "$rec_name" "$rec_url" "$rec_path" "$rec_resolved" "$rec_sha"
+done < "$lock_rows"
 ensure_manifest_gitignore "$root" "$root/intelligence.yaml"
 ensure_manifest_publisher_ignores "$root" "$root/intelligence.yaml"
 

package/cli/internal/package-add.sh

@@ -123,6 +123,10 @@ if [ -z "$ref" ]; then
 fi
 
 rel=".intelligence/packages/$name"
+# Forget what the directory held before replacing it: an interruption then
+# leaves the package unrecorded, which the next sync repairs, never a stale
+# record vouching for new bytes.
+store_record_remove "$IP_ROOT" "$name"
 sha="$(fetch_package "$url" "${ref:-$resolved_tag}" "$path" "$IP_ROOT/$rel")"
 
 wire_package_sources "$manifest" "$name" "$rel" "$IP_ROOT"
@@ -140,6 +144,7 @@ else
 fi
 
 lock_upsert "$lock" "$name" "$requested" "$url" "$path" "${ref:-$resolved_tag}" "$sha"
+store_record_set "$IP_ROOT" "$name" "$url" "$path" "${ref:-$resolved_tag}" "$sha"
 
 sections=""
 for s in rules agents skills; do

package/cli/internal/package-remove.sh

@@ -43,6 +43,7 @@ unwire_package_sources "$manifest" "$rel"
 qmap_delete_key "$manifest" "packages" "$name"
 lock_remove "$lock" "$name"
 rm -rf "${IP_ROOT:?}/$rel"
+store_record_remove "$IP_ROOT" "$name"
 # Drop the now-empty scope dir so the store stays tidy.
 rmdir "$IP_ROOT/.intelligence/packages/${name%%/*}" 2>/dev/null || true
 echo "- $name"

package/cli/internal/package-update.sh

@@ -174,11 +174,13 @@ while IFS= read -r name; do
     rm -rf "$staging"
     sha="$(fetch_package "$url" "$tag" "$path" "$staging")"
     unwire_package_sources "$manifest" "$rel"
+    store_record_remove "$IP_ROOT" "$name"
     rm -rf "${IP_ROOT:?}/$rel"
     mkdir -p "$(dirname "$IP_ROOT/$rel")"
     mv "$staging" "$IP_ROOT/$rel"
     wire_package_sources "$manifest" "$name" "$rel" "$IP_ROOT"
     lock_upsert "$lock" "$name" "$requested" "$url" "$path" "$tag" "$sha"
+    store_record_set "$IP_ROOT" "$name" "$url" "$path" "$tag" "$sha"
     # The widened intent is recorded only once its content is installed and
     # wired: a manifest saying ^0.6.1 over a failed fetch would describe a
     # state the project never reached.

package/cli/internal/restore.sh

@@ -82,14 +82,16 @@ if [ -n "$missing" ]; then
             read -r resolved_tag _ <<< "$(remote_tag_for_version "$url" "$picked")"
         fi
         rel=".intelligence/packages/$name"
+        store_record_remove "$IP_ROOT" "$name"
         sha="$(fetch_package "$url" "${ref:-$resolved_tag}" "$path" "$IP_ROOT/$rel")"
         wire_package_sources "$manifest" "$name" "$rel" "$IP_ROOT"
         lock_upsert "$lock" "$name" "$range" "$url" "$path" "${ref:-$resolved_tag}" "$sha"
+        store_record_set "$IP_ROOT" "$name" "$url" "$path" "${ref:-$resolved_tag}" "$sha"
         echo "+ $name@${resolved_tag:-${ref:-HEAD}} (resolved)"
     done
 fi
 
-# Restore every locked package that is not already in the store.
+# Restore every locked package the store does not hold at its locked commit.
 if [ -f "$lock" ]; then
     while IFS="$LOCK_SEP" read -r name _requested url path resolved sha; do
         [ -n "$name" ] || continue
@@ -97,10 +99,11 @@ if [ -f "$lock" ]; then
         # on their way into rm -rf paths, and its urls into git argv.
         assert_valid_pkg_name "$name"
         rel=".intelligence/packages/$name"
-        # --frozen never trusts what is already on disk: a pre-existing
-        # (possibly substituted) store dir would otherwise be synced with no
-        # sha verification at all.
-        if [ -d "$IP_ROOT/$rel" ] && [ "$force" -eq 0 ] && [ "$frozen" -eq 0 ]; then
+        # A directory counts only with a record of the lock row it satisfies:
+        # one present without it may hold any commit. --frozen never trusts
+        # what is already on disk: a pre-existing (possibly substituted) store
+        # dir would otherwise be synced with no sha verification at all.
+        if [ -d "$IP_ROOT/$rel" ] && [ "$force" -eq 0 ] && [ "$frozen" -eq 0 ]             && store_record_matches "$IP_ROOT" "$name" "$url" "$path" "$resolved" "$sha"; then
             continue
         fi
         # Fetch into staging and commit to the store only after the integrity
@@ -109,9 +112,11 @@ if [ -f "$lock" ]; then
         staging="$IP_ROOT/.intelligence/.staging-$$"
         rm -rf "$staging"
         fetch_package "$url" "$resolved" "$path" "$staging" "$sha" >/dev/null
+        store_record_remove "$IP_ROOT" "$name"
         rm -rf "${IP_ROOT:?}/$rel"
         mkdir -p "$(dirname "$IP_ROOT/$rel")"
         mv "$staging" "$IP_ROOT/$rel"
+        store_record_set "$IP_ROOT" "$name" "$url" "$path" "$resolved" "$sha"
         wire_package_sources "$manifest" "$name" "$rel" "$IP_ROOT"
         echo "= $name@${resolved:-HEAD}"
     done < <(lock_to_tsv "$lock")

package/cli/lib/cli-common.sh

@@ -303,9 +303,11 @@ sync_pkg_entry() {
 sync_pkg_install() {
     local root="$1" ver sha
     ver="$(bundled_engine_version)"
+    store_record_remove "$root" "$SYNC_PKG_NAME"
     sha="$(fetch_package "$SYNC_PKG_URL" "v$ver" "$SYNC_PKG_PATH" "$root/$SYNC_PKG_STORE")"
     wire_package_sources "$root/intelligence.yaml" "$SYNC_PKG_NAME" "$SYNC_PKG_STORE" "$root"
     lock_upsert "$root/intelligence.lock" "$SYNC_PKG_NAME" "$ver" "$SYNC_PKG_URL" "$SYNC_PKG_PATH" "v$ver" "$sha"
+    store_record_set "$root" "$SYNC_PKG_NAME" "$SYNC_PKG_URL" "$SYNC_PKG_PATH" "v$ver" "$sha"
     echo "  engine content installed: $SYNC_PKG_STORE (v$ver)"
 }
 
@@ -477,6 +479,65 @@ check_project_lock() {
     validate_project_lock "$1" "$mode"
 }
 
+# --- What the store holds (decision 0012) ---------------------------------
+# The store keeps plain files only, so which commit a package directory holds is
+# recorded beside the packages, never inside one (the engine would render it):
+# .intelligence/packages/.installed, one row per package — name, url, path,
+# resolved, sha, separated like the lock's rows — written whenever a package is
+# installed from the lock row it now satisfies. A directory without a row, or
+# with one that differs from the lock, is not what the lock pins.
+STORE_RECORD=".intelligence/packages/.installed"
+
+# store_record_get <root> <name> — set IS_REC_URL / _PATH / _RESOLVED / _SHA;
+# returns 1 when the store records nothing for <name>.
+store_record_get() {
+    local file="$1/$STORE_RECORD" name url path resolved sha
+    IS_REC_URL="" IS_REC_PATH="" IS_REC_RESOLVED="" IS_REC_SHA=""
+    [ -f "$file" ] || return 1
+    while IFS="$LOCK_SEP" read -r name url path resolved sha; do
+        [ "$name" = "$2" ] || continue
+        IS_REC_URL="$url" IS_REC_PATH="$path" IS_REC_RESOLVED="$resolved" IS_REC_SHA="$sha"
+        return 0
+    done < "$file"
+    return 1
+}
+
+# store_record_matches <root> <name> <url> <path> <resolved> <sha>
+store_record_matches() {
+    store_record_get "$1" "$2" || return 1
+    [ "$IS_REC_URL" = "$3" ] && [ "$IS_REC_PATH" = "$4" ] \
+        && [ "$IS_REC_RESOLVED" = "$5" ] && [ "$IS_REC_SHA" = "$6" ]
+}
+
+# store_record_set <root> <name> <url> <path> <resolved> <sha> — record what
+# <name> now holds; store_record_remove <root> <name> forgets it. Both rewrite
+# the file through a temp file, so a reader never sees half a row.
+store_record_set() {
+    _store_record_write "$@"
+}
+
+store_record_remove() {
+    _store_record_write "$1" "$2"
+}
+
+_store_record_write() {
+    local root="$1" target="$2" file="$1/$STORE_RECORD" tmp name rest
+    mkdir -p "$root/.intelligence/packages" || die "cannot create $root/.intelligence/packages"
+    tmp="$file.tmp.$$"
+    {
+        if [ -f "$file" ]; then
+            while IFS="$LOCK_SEP" read -r name rest; do
+                [ -n "$name" ] && [ "$name" != "$target" ] || continue
+                printf '%s%s%s\n' "$name" "$LOCK_SEP" "$rest"
+            done < "$file"
+        fi
+        [ "$#" -lt 6 ] || printf '%s%s%s%s%s%s%s%s%s\n' "$target" "$LOCK_SEP" "$3" "$LOCK_SEP" "$4" "$LOCK_SEP" "$5" "$LOCK_SEP" "$6"
+    } > "$tmp" || { rm -f "$tmp"; die "cannot write $file"; }
+    mv -f "$tmp" "$file" || { rm -f "$tmp"; die "cannot write $file"; }
+}
+
+# project_store_missing <root> — a package the manifest or lock names is absent
+# from the store, or holds something other than its lock row pins.
 project_store_missing() {
     local root="$1" manifest="$1/intelligence.yaml" name src
     while IFS= read -r name; do
@@ -493,6 +554,17 @@ project_store_missing() {
             esac
         done < <(read_yaml_list "$manifest" "$section")
     done
+    # Present is not enough: a `git pull` moves the lock and leaves the ignored
+    # store on the commit it held before.
+    local rows _requested url path resolved sha
+    [ -f "$root/intelligence.lock" ] || return 1
+    rows="$(lock_to_tsv "$root/intelligence.lock")"
+    while IFS="$LOCK_SEP" read -r name _requested url path resolved sha; do
+        [ -n "$name" ] || continue
+        assert_valid_pkg_name "$name"
+        [ -d "$root/.intelligence/packages/$name" ] || return 0
+        store_record_matches "$root" "$name" "$url" "$path" "$resolved" "$sha" || return 0
+    done <<< "$rows"
     return 1
 }
 

package/engine/ENGINE_SHA

@@ -1 +1 @@
-97484ac7ccc2e093642b833edfa8cae7bfe47c9e
+1bf045d314f2c2f58a70d5a74130b5f5376b56e4

package/engine/VERSION

@@ -1 +1 @@
-0.17.2
+0.18.0

package/engine/adapters/codex.sh

@@ -103,7 +103,8 @@ sync_codex_agents() {
             name="${path##*/}"; name="${name%.md}"
             resolve_model_var "$tier"
             case "$tier" in
-                heavy)    effort="high" ;;
+                frontier) effort="xhigh" ;;
+                heavy|"") effort="high" ;;
                 standard) effort="medium" ;;
                 light)    effort="low" ;;
                 *)        effort="medium" ;;

package/engine/lib/common.sh

@@ -661,6 +661,7 @@ sync_open_skill_dirs() {
     # target gets it — not just this open-standard dir.
     if [ "$count" -gt 0 ]; then
         copy_skill_bundle_dirs "$output_dir" "${skill_dirs[@]}"
+        open_skill_invocation_policies "$output_dir" || return 1
     fi
 
     log+="  -> Skills: $count"$'\n'
@@ -670,6 +671,44 @@ sync_open_skill_dirs() {
     IS_OPEN_SKILLS_LOG="$log"
 }
 
+# open_skill_invocation_policies <open_skills_dir> — `disable-model-invocation:
+# true` keeps a skill out of automatic selection in Claude Code, Cursor and
+# Copilot, but Codex ignores that key and reads the same intent from
+# `agents/openai.yaml` beside SKILL.md. Source skills stay tool-neutral: the
+# policy file is derived here, in the open-standard tree Codex reads, so every
+# adapter sharing that tree writes the same bytes. A skill that ships its own
+# `agents/openai.yaml` keeps it — that is the author configuring Codex directly.
+open_skill_invocation_policies() {
+    local output_dir="$1" path flag rows
+    local -a skill_mds=() policy_dirs=() policies=()
+    for path in "$output_dir"/*/SKILL.md; do
+        [ -f "$path" ] && [ ! -L "$path" ] && skill_mds+=("$path")
+    done
+    [ "${#skill_mds[@]}" -gt 0 ] || return 0
+    # Captured, not streamed: a reader cut short must fail the render rather
+    # than quietly drop a policy and hand the skill back to the model.
+    rows="$(frontmatter_index "disable-model-invocation" "${skill_mds[@]}")" || {
+        echo "ERROR: could not read skill frontmatter under $output_dir" >&2
+        return 1
+    }
+    while IFS=$'\x1f' read -r path flag; do
+        [ "$flag" = "true" ] || continue
+        path="${path%/SKILL.md}/agents"
+        # A symlinked `agents` would carry the write outside the output tree.
+        [ -L "$path" ] && continue
+        [ -e "$path/openai.yaml" ] || [ -L "$path/openai.yaml" ] && continue
+        policy_dirs+=("$path")
+        policies+=("$path/openai.yaml")
+    done <<< "$rows"
+    [ "${#policies[@]}" -gt 0 ] || return 0
+    mkdir -p "${policy_dirs[@]}"
+    for path in "${policies[@]}"; do
+        printf '%s\n' '# Generated by intelligence-sync from disable-model-invocation in SKILL.md. Do not edit manually.' \
+            'policy:' '  allow_implicit_invocation: false' > "$path"
+    done
+    finalize_output_files "${policies[@]}"
+}
+
 # Lint YAML frontmatter for common pitfalls (unquoted colons, leading tabs).
 # Print warnings to stderr; do not fail. Strict consumers (Codex CLI) reject
 # these files with cryptic messages — catching them in sync gives better DX.
@@ -816,33 +855,47 @@ has_paths() {
 
 # --- Tier/Access Mappings ---
 
-# Hardcoded defaults: ide:tier -> model name.
+# Hardcoded defaults: ide:tier -> model name. Where a tool has fewer models
+# than there are tiers, tiers share one (decision 0013). cli/tests/unit-engine.sh
+# pins this table independently, so a bump updates its expected matrix too.
 # When you bump these, re-run sync in projects; any project whose config.yaml
 # `models:` section diverges from these will print a drift warning so users
 # know their override is now stale.
 # get_model_default_var sets IS_MODEL_DEFAULT; get_model_default prints it.
 get_model_default_var() {
     case "$1:$2" in
+        # Haiku 4.5 retires no sooner than 2026-10-15 and has no successor, so
+        # light shares standard's Sonnet on every Claude-backed target.
+        claude:frontier)  IS_MODEL_DEFAULT="fable" ;;
         claude:heavy)     IS_MODEL_DEFAULT="opus" ;;
         claude:standard)  IS_MODEL_DEFAULT="sonnet" ;;
-        claude:light)     IS_MODEL_DEFAULT="haiku" ;;
+        claude:light)     IS_MODEL_DEFAULT="sonnet" ;;
+        # Cursor documents only `inherit` or a concrete model ID, so every
+        # tier follows the session model unless the manifest pins one.
+        cursor:frontier)  IS_MODEL_DEFAULT="inherit" ;;
         cursor:heavy)     IS_MODEL_DEFAULT="inherit" ;;
         cursor:standard)  IS_MODEL_DEFAULT="inherit" ;;
-        cursor:light)     IS_MODEL_DEFAULT="fast" ;;
-        copilot:heavy)    IS_MODEL_DEFAULT="gpt-5.6-sol" ;;
-        copilot:standard) IS_MODEL_DEFAULT="gpt-5.6-terra" ;;
-        copilot:light)    IS_MODEL_DEFAULT="gpt-5.6-luna" ;;
-        codex:heavy)      IS_MODEL_DEFAULT="gpt-5.6-sol" ;;
-        codex:standard)   IS_MODEL_DEFAULT="gpt-5.6-terra" ;;
-        codex:light)      IS_MODEL_DEFAULT="gpt-5.6-luna" ;;
-        # Antigravity accepts only inherit|flash|pro, so standard and light
-        # share `flash` — there is no third tier to map onto.
+        cursor:light)     IS_MODEL_DEFAULT="inherit" ;;
+        # GPT-6 has no mid model, so frontier and heavy share Astra; Codex
+        # separates them by reasoning effort instead.
+        copilot:frontier) IS_MODEL_DEFAULT="gpt-6-astra" ;;
+        copilot:heavy)    IS_MODEL_DEFAULT="gpt-6-astra" ;;
+        copilot:standard) IS_MODEL_DEFAULT="gpt-6.1-sol" ;;
+        copilot:light)    IS_MODEL_DEFAULT="gpt-6-luna" ;;
+        codex:frontier)   IS_MODEL_DEFAULT="gpt-6-astra" ;;
+        codex:heavy)      IS_MODEL_DEFAULT="gpt-6-astra" ;;
+        codex:standard)   IS_MODEL_DEFAULT="gpt-6.1-sol" ;;
+        codex:light)      IS_MODEL_DEFAULT="gpt-6-luna" ;;
+        # Antigravity accepts only inherit|flash|pro, so frontier and heavy
+        # share `pro` and standard and light share `flash`.
+        antigravity:frontier)  IS_MODEL_DEFAULT="pro" ;;
         antigravity:heavy)     IS_MODEL_DEFAULT="pro" ;;
         antigravity:standard)  IS_MODEL_DEFAULT="flash" ;;
         antigravity:light)     IS_MODEL_DEFAULT="flash" ;;
-        opencode:heavy)    IS_MODEL_DEFAULT="anthropic/claude-opus-4-8" ;;
-        opencode:standard) IS_MODEL_DEFAULT="anthropic/claude-sonnet-5" ;;
-        opencode:light)    IS_MODEL_DEFAULT="anthropic/claude-haiku-4-5-20251001" ;;
+        opencode:frontier) IS_MODEL_DEFAULT="anthropic/claude-fable-5-1" ;;
+        opencode:heavy)    IS_MODEL_DEFAULT="anthropic/claude-opus-5-5" ;;
+        opencode:standard) IS_MODEL_DEFAULT="anthropic/claude-sonnet-5-5" ;;
+        opencode:light)    IS_MODEL_DEFAULT="anthropic/claude-sonnet-5-5" ;;
         *)                IS_MODEL_DEFAULT="" ;;
     esac
 }
@@ -925,25 +978,29 @@ get_model() {
     fi
 }
 
-# load_model_tiers <config_file> <ide> — resolve the three standard tiers
-# once per adapter run (IS_MODEL_HEAVY / IS_MODEL_STANDARD / IS_MODEL_LIGHT)
-# so per-file loops map tier -> model without forking. resolve_model_var
-# consumes them; a non-standard tier value still goes through get_model so a
-# `models:` override for it keeps working. One manifest pass reads all three.
+# load_model_tiers <config_file> <ide> — resolve the four standard tiers
+# once per adapter run (IS_MODEL_FRONTIER / IS_MODEL_HEAVY /
+# IS_MODEL_STANDARD / IS_MODEL_LIGHT) so per-file loops map tier -> model
+# without forking. resolve_model_var consumes them; a non-standard tier value
+# still goes through get_model so a `models:` override for it keeps working.
+# One manifest pass reads all four.
 load_model_tiers() {
-    local config_file="$1" ide="$2" overrides="" tier val heavy="" standard="" light=""
+    local config_file="$1" ide="$2" overrides="" tier val frontier="" heavy="" standard="" light=""
     IS_MODEL_CFG="$config_file"
     IS_MODEL_IDE="$ide"
     if [ -n "$config_file" ] && [ -f "$config_file" ]; then
-        overrides="$(_nested_yaml_values tagged "$config_file" "models" "$ide" heavy standard light)"
+        overrides="$(_nested_yaml_values tagged "$config_file" "models" "$ide" frontier heavy standard light)"
     fi
     while IFS=$'\037' read -r tier val; do
         case "$tier" in
+            frontier) frontier="$val" ;;
             heavy) heavy="$val" ;;
             standard) standard="$val" ;;
             light) light="$val" ;;
         esac
     done <<< "$overrides"
+    get_model_default_var "$ide" frontier
+    IS_MODEL_FRONTIER="${frontier:-$IS_MODEL_DEFAULT}"
     get_model_default_var "$ide" heavy
     IS_MODEL_HEAVY="${heavy:-$IS_MODEL_DEFAULT}"
     get_model_default_var "$ide" standard
@@ -957,6 +1014,7 @@ load_model_tiers() {
 # shellcheck disable=SC2034  # IS_MODEL is the return channel read by adapters
 resolve_model_var() {
     case "$1" in
+        frontier) IS_MODEL="$IS_MODEL_FRONTIER" ;;
         heavy|"") IS_MODEL="$IS_MODEL_HEAVY" ;;
         standard) IS_MODEL="$IS_MODEL_STANDARD" ;;
         light)    IS_MODEL="$IS_MODEL_LIGHT" ;;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ainova-systems/intelligence",
-  "version": "0.17.2",
+  "version": "0.18.0",
   "description": "Build, version and distribute AI agent intelligence across your organization — one CLI, versioned Intelligence Packages, and a sync engine for Claude Code, Cursor, Copilot, Codex, Pi and OpenCode.",
   "bin": {
     "intelligence": "bin/intelligence.js"

package/packages/sync/agents/intelligence-operator.md

@@ -5,8 +5,6 @@ tier: standard
 access: full
 skills:
   - intelligence-sync
-  - intelligence-upgrade
-  - intelligence-manage-adapters
 ---
 
 # Intelligence operator
@@ -28,6 +26,11 @@ the operation in prose.
 - **Every flow goes through its skill.** The steps and their guards live in `intelligence-sync`,
   `intelligence-upgrade` and `intelligence-manage-adapters`;
   improvising around them produces an unverified version of the same work.
+- **Upgrades and adapter changes are the owner's to start.** `intelligence-upgrade` moves CLI and
+  package versions, the lock and migrations; `intelligence-manage-adapters` adds or removes whole
+  tool outputs. Both are decisions about the layer, so they run only when the owner invokes them,
+  and a sync never previews an update or inspects adapters on its own. Name the command the owner
+  can run and stop there.
 - **Operating is not authoring.** A change to what an artifact says - a rule body, an agent persona,
   a skill's steps - belongs to `intelligence-architect` and the authoring meta-skills. This agent
   ships what exists and never decides what should exist.

package/packages/sync/references/adapters.md

@@ -152,12 +152,12 @@ Use the engine library instead of copying parsers or file-handling logic.
 | `frontmatter_index(keys, file...)` | Read several frontmatter scalars for many files in one pass (`\x1f`-separated rows; special key `paths#` counts `paths:` lines). |
 | `has_frontmatter(file)` / `has_paths(file)` | Inspect source shape. |
 | `strip_frontmatter(file)` | Emit the body without its first frontmatter block. |
-| `get_model(config, tool, tier)` | Resolve a `heavy`, `standard` or `light` model, including manifest overrides. |
+| `get_model(config, tool, tier)` | Resolve a `frontier`, `heavy`, `standard` or `light` model, including manifest overrides. |
 | `get_model_default(tool, tier)` | Read the built-in model default. |
-| `load_model_tiers(config, tool)` / `resolve_model_var(tier)` | Resolve the three standard tiers once, then map per file without subprocesses. |
+| `load_model_tiers(config, tool)` / `resolve_model_var(tier)` | Resolve the four standard tiers once, then map per file without subprocesses. |
 | `copy_skill_bundle(src, dest)` | Copy `SKILL.md` and all resources safely, normalize Markdown and quote free-text frontmatter. |
 | `copy_skill_bundle_dirs(dest_root, src...)` | Batch form: copy every skill directory into `dest_root/<name>` with one copy and one finalize pass. |
-| `sync_open_skill_dirs(root, config, dest)` | Own and populate a shared Agent Skills directory such as `.agents/skills/`. |
+| `sync_open_skill_dirs(root, config, dest)` | Own and populate a shared Agent Skills directory such as `.agents/skills/`, deriving Codex's `agents/openai.yaml` for a skill with `disable-model-invocation: true`. |
 | `finalize_output_file(file)` | Expand layout tokens and normalize line endings; required for every emitted text file. |
 | `finalize_output_files(file...)` / `finalize_copy_files(dest, src...)` | Batch forms: finalize in place, or copy-and-finalize into a directory, in one process. |
 | `emit_wrapped_bodies(spec)` | Emit many header + source-body + tail outputs in one process (see `engine/lib/common.sh` for the spec format). |

package/packages/sync/references/conventions.md

@@ -121,7 +121,7 @@ Practice:
 - **`latest` and `*` are for a package you own and release in lockstep.** Anywhere else they hand an upstream author write access to your agents' behavior between two syncs.
 - **Never pin a range to dodge a broken release.** Pin the exact version (`1.4.2`), record why, and remove the pin when the fix ships — a narrowed range hides the reason and outlives the incident.
 
-Commit `intelligence.lock`. It records requested versions, source URLs and paths, resolved refs and commit SHAs. After cloning, `intelligence sync` restores a missing store strictly from that lock before rendering; manifest/lock or SHA drift is refused. Re-run `package add` when deliberately changing a source.
+Commit `intelligence.lock`. It records requested versions, source URLs and paths, resolved refs and commit SHAs. After cloning, or after a pull that moved the lock, `intelligence sync` restores every package the store lacks or holds at another commit, strictly from that lock, before rendering; manifest/lock or SHA drift is refused. Re-run `package add` when deliberately changing a source.
 
 `@ainova-systems/sync` is ordinary package content exact-pinned to the bundled engine version. `intelligence init` installs it unless `--bare` is used. Lifecycle preflight keeps that pin and `schema_version` aligned with the installed CLI; package-range updates never move it independently.
 
@@ -185,11 +185,14 @@ Do not instruct an agent to read rules or restate their content. Claude loads it
 
 ### Tier mappings
 
-| Tier | Claude | Cursor | Copilot / Codex | OpenCode | Typical use |
-|---|---|---|---|---|---|
-| `heavy` | `opus` | `inherit` | `gpt-5.6-sol` | `anthropic/claude-opus-4-8` | implementation, complex reasoning, migration |
-| `standard` | `sonnet` | `inherit` | `gpt-5.6-terra` | `anthropic/claude-sonnet-5` | review, validation, analysis |
-| `light` | `haiku` | `fast` | `gpt-5.6-luna` | `anthropic/claude-haiku-4-5-20251001` | lookups and simple formatting |
+| Tier | Claude | Cursor | Copilot / Codex | OpenCode | Antigravity | Typical use |
+|---|---|---|---|---|---|---|
+| `frontier` | `fable` | `inherit` | `gpt-6-astra` | `anthropic/claude-fable-5-1` | `pro` | long-horizon autonomous work, the hardest reasoning, where capability outweighs cost |
+| `heavy` | `opus` | `inherit` | `gpt-6-astra` | `anthropic/claude-opus-5-5` | `pro` | implementation, complex reasoning, migration |
+| `standard` | `sonnet` | `inherit` | `gpt-6.1-sol` | `anthropic/claude-sonnet-5-5` | `flash` | review, validation, analysis |
+| `light` | `sonnet` | `inherit` | `gpt-6-luna` | `anthropic/claude-sonnet-5-5` | `flash` | lookups and simple formatting |
+
+Codex also receives a reasoning effort per tier — `xhigh`, `high`, `medium`, `low` — which is what separates `frontier` from `heavy` in Codex. Copilot has no effort field, so its `frontier` and `heavy` agents are identical. Claude's Haiku 4.5 is retiring with no successor announced, so `light` shares `standard`'s Sonnet in Claude and OpenCode; Cursor and Antigravity have fewer native levels than there are tiers, so several tiers share one value there too.
 
 The vocabulary is tool-neutral. Adapters resolve it through `get_model()`. Override a default under `models.<tool>.<tier>` in `intelligence.yaml` only when the project needs a pin; sync reports drift when that override differs from the current default.
 
@@ -251,6 +254,8 @@ argument-hint: "<route-name>"
 
 Standard optional fields (`license`, `compatibility`, `metadata`, `allowed-tools`) and tool extensions pass through unchanged. A tool ignores fields it does not understand.
 
+`disable-model-invocation: true` makes a skill one only the owner starts, as a slash command: use it for a procedure that changes versions, the lock or generated outputs, where an agent selecting it unasked is the failure. Claude Code, Cursor and Copilot read the field itself; Codex does not, so sync writes `agents/openai.yaml` with `allow_implicit_invocation: false` beside the skill in `.agents/skills/`. Keep the source to the field — a skill that ships its own `agents/openai.yaml` keeps it unchanged.
+
 These limits reject a skill instead of degrading it:
 
 | Field | Limit | Failure mode |
@@ -416,7 +421,7 @@ The permanent applied-schema key is the top-level scalar `schema_version` in `in
 The public lifecycle is deliberately compact:
 
 - `intelligence init [--preview|--apply]` is universal: it creates a new setup, aligns an existing Intelligence project, or plans/applies conversion of an eligible legacy Intelligence Sync project.
-- `intelligence sync [adapter] [--compact] [--force]` first aligns an existing Intelligence project with the installed CLI and restores a missing store strictly from `intelligence.lock`. It skips rendering when local inputs and outputs match a previous successful run. Changes or missing outputs trigger rendering; `--force` always renders and refreshes the search for unconfigured source directories. An unchanged run replays the last full run's useful diagnostics. Compact mode shows context sizes, actionable warnings and final status on success, and all diagnostics on failure. In CI it refuses an alignment that would change tracked files and points to a local `intelligence init --apply` plus review/commit.
+- `intelligence sync [adapter] [--compact] [--force]` first aligns an existing Intelligence project with the installed CLI and restores every package the store lacks or holds at another commit, strictly from `intelligence.lock`. It skips rendering when local inputs and outputs match a previous successful run. Changes or missing outputs trigger rendering; `--force` always renders and refreshes the search for unconfigured source directories. An unchanged run replays the last full run's useful diagnostics. Compact mode shows context sizes, actionable warnings and final status on success, and all diagnostics on failure. In CI it refuses an alignment that would change tracked files and points to a local `intelligence init --apply` plus review/commit.
 - `intelligence update [@scope/name] [--preview|--apply]` is the only update surface. It prints the CLI/project/package plan; default mode prompts, `--preview` never writes, and `--apply` does not prompt. It never moves `ref:` pins.
 - `intelligence upgrade [--next] [--preview|--apply]` replaces the installed CLI with the newest version on its npm channel (`next` for a prerelease or with `--next`, otherwise `latest`) with the same modes. It touches no project, never downgrades, and refuses an installation that npm did not make.
 - `intelligence package add|remove|list|search` owns package inventory.

package/packages/sync/rules/intelligence-authoring.md

@@ -109,6 +109,6 @@ The goal is subtraction, above. These are only the line past which something is
 
 ## Verifying a change to this layer
 
-The per-artifact authoring checks belong to `intelligence-update-context`. Session learning, repository onboarding, and accepted review findings use that same procedure. Invoke `intelligence-learn-from-session` to capture a lesson or workflow, `intelligence-learn-from-repository` for initial migration and recovery, and `intelligence-review-context` for audits and reductions. Operational work uses `intelligence-sync`, `intelligence-upgrade`, or `intelligence-manage-adapters`.
+The per-artifact authoring checks belong to `intelligence-update-context`. Session learning, repository onboarding, and accepted review findings use that same procedure. Invoke `intelligence-learn-from-session` to capture a lesson or workflow, `intelligence-learn-from-repository` for initial migration and recovery, and `intelligence-review-context` for audits and reductions. Operational work uses `intelligence-sync`. `intelligence-upgrade` and `intelligence-manage-adapters` change versions and generated outputs, so only the owner invokes them.
 
 A change to this layer is done when `<sync-cmd>` reports `IS_STATUS=ok` and the skill you invoked reports clean.

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

@@ -3,6 +3,7 @@ name: intelligence-manage-adapters
 description: "Enable, disable, or remove adapters and assess generated-output cleanup"
 argument-hint: "<enable|disable|remove> <adapter-name>"
 agent: intelligence-operator
+disable-model-invocation: true
 ---
 
 # Manage adapters

package/packages/sync/skills/intelligence-update-context/references/agents.md

@@ -4,9 +4,11 @@
    `<domain>-<role>` and determine its expertise from the source evidence.
 2. Select tier and access: implementation normally uses `heavy` and `full`;
    review or validation uses `standard` and `readonly`; simple lookup uses
-   `light` and `readonly`. Check the target's actual permission mapping when
-   external read tools are required. If native read-only restrictions exclude
-   those tools, use `full` only with a clear read-only boundary in the body.
+   `light` and `readonly`. Reserve `frontier` for long-horizon work whose
+   difficulty justifies the most capable and most expensive model. Check the
+   target's actual permission mapping when external read tools are required.
+   If native read-only restrictions exclude those tools, use `full` only with a
+   clear read-only boundary in the body.
 3. Keep the body thin: Expertise, Boundaries, and Build & Verify. Carry its own
    completion criteria and limitations. Reference constraints by name instead
    of copying rules, and put reusable procedures in skills.

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

@@ -3,6 +3,7 @@ name: intelligence-upgrade
 description: "Upgrade Intelligence and installed packages with migration checks"
 argument-hint: "[@scope/name]"
 agent: intelligence-operator
+disable-model-invocation: true
 ---
 
 # Upgrade Intelligence and packages