@ainova-systems/intelligence 0.20.0 → 0.22.0

package/engine/adapters/claude.sh

@@ -6,6 +6,11 @@
 # Skills: copy skill directories in full (SKILL.md + bundled resources),
 #   effort -> Claude's effort level
 # Agents: tier -> model, effort -> effort, access -> tools/disallowedTools
+# Plugin: with `targets.claude.plugin: true`, the Claude Code mod in
+#   adapters/claude-plugin/ is rendered into <output>/skills/intelligence/
+#   (decision 0022). Claude Code loads a plugin from a project's skills
+#   directory, so the plugin lives inside a path this contract already owns:
+#   ownership, Git policy, snapshots and `sync --check` need no new record.
 #
 # Every per-file loop batches its work into one awk process (see the batched
 # helpers in lib/common.sh): process spawns dominate sync time on Windows.
@@ -29,29 +34,67 @@ adapter_contract_claude() {
     adapter_contract_include "$output/settings.json"
 }
 
+# claude_plugin_var <manifest> — the one reader of targets.claude.plugin. Sets
+# IS_CLAUDE_PLUGIN to 1 when the project renders the Claude Code plugin and 0
+# for the default; returns 1 for a value target_bool_var refuses.
+claude_plugin_var() {
+    local rc=0
+    target_bool_var "$1" claude plugin || rc=1
+    IS_CLAUDE_PLUGIN="$IS_TARGET_BOOL"
+    return "$rc"
+}
+
+# The directory name the plugin takes under <output>/skills: a source skill
+# rendered under this name would be overwritten, so sync refuses the pair.
+IS_CLAUDE_PLUGIN_NAME=intelligence
+
+# render_claude_plugin <output_dir> — copy the plugin template byte for byte,
+# stamp the engine version into its manifest and normalize line endings. The
+# template is in the engine's adapter directory, never in the content package:
+# it is executable tooling, and the bundle copies all of engine/. It is found
+# through the engine root, so a project's own claude.sh renders it too.
+render_claude_plugin() {
+    local output_dir="$1" tpl
+    local dst="$output_dir/skills/$IS_CLAUDE_PLUGIN_NAME"
+    # Rendered beside the destination, under a name no skill can take, and
+    # swapped in only when it differs: a running session reloads the mod on
+    # every file change, and announces each reload in its transcript.
+    local tmp="$output_dir/skills/.$IS_CLAUDE_PLUGIN_NAME.render.$$"
+    engine_root_var
+    tpl="$IS_ENGINE_ROOT/adapters/claude-plugin"
+    engine_version_var
+    rm -rf "$tmp"
+    mkdir -p "$tmp/.claude-plugin" "$tmp/hooks"
+    cp "$tpl/hooks/hooks.json" "$tpl/hooks/register.js" "$tmp/hooks/"
+    cp "$tpl/README.md" "$tmp/README.md"
+    awk -v v="$IS_ENGINE_VERSION" '{ sub(/__INTELLIGENCE_VERSION__/, v); print }' \
+        "$tpl/.claude-plugin/plugin.json" > "$tmp/.claude-plugin/plugin.json"
+    finalize_output_files "$tmp/.claude-plugin/plugin.json" "$tmp/hooks/hooks.json" \
+        "$tmp/hooks/register.js" "$tmp/README.md"
+    if [ -d "$dst" ] && [ ! -L "$dst" ] && diff -r -q "$tmp" "$dst" >/dev/null 2>&1; then
+        rm -rf "$tmp"
+    else
+        rm -rf "$dst"
+        mv "$tmp" "$dst"
+    fi
+    echo "  plugin: $IS_CLAUDE_PLUGIN_NAME (Claude Code mod $IS_ENGINE_VERSION)"
+}
+
 # Sync rules to Claude format (copy as-is, normalize LF)
 sync_claude_rules() {
     local repo_root="$1"
     local config_file="$2"
     local output_dir="$3"
 
-    local src f
-    local -a files=()
-    load_yaml_list "$config_file" "rules"
-    local list="$IS_YAML_LIST"
-    while IFS= read -r src; do
-        [ -z "$src" ] && continue
-        local dir="$repo_root/$src"
-        [ -d "$dir" ] || continue
-        for f in "$dir"/*.md; do
-            [ -f "$f" ] || continue
-            files+=("$f")
-        done
-    done <<< "$list"
-    [ "${#files[@]}" -gt 0 ] || return 0
-    finalize_copy_files "$output_dir/rules" "${files[@]}"
-    for f in "${files[@]}"; do
-        echo "  rule: ${f##*/}"
+    local name
+    # Every source reaches this adapter through the source catalog (decision
+    # 0021): rendered names, overrides and local artifacts are settled there.
+    output_rel_var "$repo_root" "$output_dir"
+    source_artifacts_var "$repo_root" "$config_file" rules claude "$IS_OUTPUT_REL/rules/{}.md"
+    [ "${#IS_SOURCE_FILES[@]}" -gt 0 ] || return 0
+    finalize_copy_named "$output_dir/rules" "$IS_SOURCE_NAME_MAP" "${IS_SOURCE_FILES[@]}"
+    for name in "${IS_SOURCE_NAMES[@]}"; do
+        echo "  rule: $name.md"
     done
 }
 
@@ -61,29 +104,38 @@ sync_claude_skills() {
     local config_file="$2"
     local output_dir="$3"
 
-    local src d skill_name
+    local i name clash="" nocase=0
     local -a skill_dirs=()
-    # The inventory decides which skills render, symlinked ones included
-    # (decision 0017); the glob keeps this adapter's own listing order.
-    skill_source_inventory "$repo_root" "$config_file"
-    load_yaml_list "$config_file" "skills"
-    local list="$IS_YAML_LIST"
-    while IFS= read -r src; do
-        [ -z "$src" ] && continue
-        local dir="$repo_root/$src"
-        [ -d "$dir" ] || continue
-        for d in "$dir"/*/; do
-            [ -d "$d" ] || continue
-            [ -f "$d/SKILL.md" ] || continue
-            skill_source_rendered "$d" || continue
-            skill_dirs+=("$d")
+    # The catalog's skills are the ones the inventory renders, symlinked ones
+    # included (decision 0017).
+    output_rel_var "$repo_root" "$output_dir"
+    source_artifacts_var "$repo_root" "$config_file" skills claude "$IS_OUTPUT_REL/skills/{}"
+    [ "${#IS_SOURCE_FILES[@]}" -gt 0 ] || return 0
+    # The plugin takes one skill directory name; a skill rendered under it and
+    # the plugin would each erase the other, so neither is written. Names
+    # compare without case: on Windows and macOS `Intelligence/` is the same
+    # directory. (nocasematch, not ${name,,}: macOS ships bash 3.2.)
+    if [ "${IS_CLAUDE_PLUGIN:-0}" = 1 ]; then
+        shopt -q nocasematch && nocase=1
+        shopt -s nocasematch
+        for ((i = 0; i < ${#IS_SOURCE_FILES[@]}; i++)); do
+            if [[ "${IS_SOURCE_NAMES[i]}" == "$IS_CLAUDE_PLUGIN_NAME" ]]; then
+                clash="${IS_SOURCE_FILES[i]#"$repo_root/"}"
+                break
+            fi
         done
-    done <<< "$list"
-    [ "${#skill_dirs[@]}" -gt 0 ] || return 0
-    copy_skill_bundle_dirs_for claude "$output_dir/skills" "${skill_dirs[@]}"
-    for d in "${skill_dirs[@]}"; do
-        skill_name="${d%/}"
-        echo "  skill: ${skill_name##*/}"
+        [ "$nocase" = 1 ] || shopt -u nocasematch
+        if [ -n "$clash" ]; then
+            echo "ERROR: skill $clash renders as $IS_OUTPUT_REL/skills/$IS_CLAUDE_PLUGIN_NAME, the directory targets.claude.plugin: true reserves for the Claude Code plugin. Rename the skill or set targets.claude.plugin to false." >&2
+            return 1
+        fi
+    fi
+    for ((i = 0; i < ${#IS_SOURCE_FILES[@]}; i++)); do
+        skill_dirs+=("${IS_SOURCE_FILES[i]%/SKILL.md}/")
+    done
+    copy_skill_bundle_dirs_named claude "$output_dir/skills" "$IS_SOURCE_NAME_MAP" "${skill_dirs[@]}"
+    for name in "${IS_SOURCE_NAMES[@]}"; do
+        echo "  skill: $name"
     done
 }
 
@@ -94,32 +146,27 @@ sync_claude_agents() {
     local config_file="$2"
     local output_dir="$3"
 
-    local src f
-    local -a files=()
-    load_yaml_list "$config_file" "agents"
-    local list="$IS_YAML_LIST"
-    while IFS= read -r src; do
-        [ -z "$src" ] && continue
-        local dir="$repo_root/$src"
-        [ -d "$dir" ] || continue
-        for f in "$dir"/*.md; do
-            [ -f "$f" ] || continue
-            files+=("$f")
-        done
-    done <<< "$list"
-    [ "${#files[@]}" -gt 0 ] || return 0
+    local i
+    local -a files=() names=()
+    output_rel_var "$repo_root" "$output_dir"
+    source_artifacts_var "$repo_root" "$config_file" agents claude "$IS_OUTPUT_REL/agents/{}.md"
+    [ "${#IS_SOURCE_FILES[@]}" -gt 0 ] || return 0
+    files=("${IS_SOURCE_FILES[@]}")
+    names=("${IS_SOURCE_NAMES[@]}")
+    local name_map="$IS_SOURCE_NAME_MAP"
 
     load_model_tiers "$config_file" "claude"
 
     local path tier access effort spec="" report=""
+    i=0
     while IFS=$'\x1f' read -r path tier access effort; do
-        [ -n "$path" ] || continue
         resolve_model_var "$tier"
         map_effort_var claude "$effort"
         map_access_to_claude_tools_var "$access"
         map_access_to_claude_disallowed_var "$access"
         spec+="$path"$'\x1f'"$IS_MODEL"$'\x1f'"$IS_CLAUDE_TOOLS"$'\x1f'"$IS_CLAUDE_DISALLOWED"$'\x1f'"$IS_EFFORT"$'\n'
-        report+="  agent: ${path##*/} (tier=$tier -> model=$IS_MODEL, access=$access)"$'\n'
+        report+="  agent: ${names[i]}.md (tier=$tier -> model=$IS_MODEL, access=$access)"$'\n'
+        i=$((i + 1))
     done < <(frontmatter_index "tier,access,effort" "${files[@]}")
 
     # The transform used to run per file with the values injected via -v;
@@ -128,7 +175,7 @@ sync_claude_agents() {
     # becomes Claude's level in place, or goes when there is none; a later
     # one goes too, since frontmatter_index read only the first.
     is_fin_awk_vars
-    IS_MAP_SPEC="$spec" awk "${IS_FIN_V[@]}" -v dst="$output_dir/agents" "$IS_AWK_LIB"'
+    IS_NAME_MAP="$name_map" IS_MAP_SPEC="$spec" awk "${IS_FIN_V[@]}" -v dst="$output_dir/agents" "$IS_AWK_LIB"'
         BEGIN {
             US = sprintf("%c", 31)
             n = split(ENVIRON["IS_MAP_SPEC"], recs, "\n")
@@ -140,16 +187,18 @@ sync_claude_agents() {
         }
         FNR == 1 {
             if (out != "") close(out)
-            out = dst "/" base_name(FILENAME)
+            out = dst "/" art_file(FILENAME, ".md")
             count = 0
             fm = 0
             effort_seen = 0
+            tgt_reset()
         }
         /^tier:/  { next }
         /^access:/ { next }
         { sub(/\r$/, "") }
         FNR == 1 && $0 == "---" { fm = 1 }
         /^---$/ { count++ }
+        fm && count == 1 && !/^---$/ && tgt_drop($0) { next }
         fm && count == 1 && substr($0, 1, 7) == "effort:" {
             if (!effort_seen++ && EFFORT[FILENAME] != "") print fin_line("effort: " EFFORT[FILENAME]) > out
             next
@@ -163,8 +212,8 @@ sync_claude_agents() {
     ' "${files[@]}"
     # awk never reads a record from an empty source; the old per-file shell
     # redirect still created an empty output for it.
-    for f in "${files[@]}"; do
-        [ -s "$f" ] || : > "$output_dir/agents/${f##*/}"
+    for ((i = 0; i < ${#files[@]}; i++)); do
+        [ -s "${files[i]}" ] || : > "$output_dir/agents/${names[i]}.md"
     done
     printf '%s' "$report"
 }
@@ -177,18 +226,39 @@ sync_to_claude() {
 
     echo "=== Claude Code ==="
 
+    # The flag is read before anything is removed: a malformed value refuses
+    # the sync with the reason, and the output stays exactly as it was.
+    claude_plugin_var "$config_file" || {
+        echo "ERROR: targets.claude.plugin must be true or false: true renders the Claude Code plugin into ${output_dir#"$repo_root/"}/skills/$IS_CLAUDE_PLUGIN_NAME, false or omission does not." >&2
+        return 1
+    }
+
     # Clean generated content only — preserve any project-level files
     # the user manages directly (settings.json, settings.local.json,
     # commands/, statusline.sh, etc.).
     rm -rf "$output_dir/rules" "$output_dir/agents"
     if [ -d "$output_dir/skills" ]; then
-        find "$output_dir/skills" -mindepth 1 -maxdepth 1 \( -type d -o -type l \) -exec rm -rf {} +
+        # The plugin directory stays while the flag holds: Claude Code reloads
+        # a mod whose files change, so render_claude_plugin rewrites it only
+        # when its content differs. A skill of that name was refused above.
+        if [ "$IS_CLAUDE_PLUGIN" = 1 ]; then
+            find "$output_dir/skills" -mindepth 1 -maxdepth 1 \( -type d -o -type l \) \
+                ! -name "$IS_CLAUDE_PLUGIN_NAME" -exec rm -rf {} +
+        else
+            find "$output_dir/skills" -mindepth 1 -maxdepth 1 \( -type d -o -type l \) -exec rm -rf {} +
+        fi
     fi
     mkdir -p "$output_dir/rules" "$output_dir/skills" "$output_dir/agents"
 
     sync_claude_rules "$repo_root" "$config_file" "$output_dir"
+    # Called plainly, never on the left of `||`: that would turn errexit off
+    # for every copy inside, and a failed one would no longer fail the sync.
     sync_claude_skills "$repo_root" "$config_file" "$output_dir"
     sync_claude_agents "$repo_root" "$config_file" "$output_dir"
+    # The skills renderer has refused a skill of the plugin's name by now, so
+    # the plugin never lands on top of one. Cleared above with every other
+    # skill directory, it exists only while the flag says so.
+    [ "$IS_CLAUDE_PLUGIN" = 0 ] || render_claude_plugin "$output_dir"
 
     count_matching_files "$output_dir/rules" "*.md" \
         "$output_dir/skills" "SKILL.md" "$output_dir/agents" "*.md"

package/engine/adapters/codex.sh

@@ -6,6 +6,13 @@
 # inlines always-on rules into AGENTS.md, so this adapter only emits skills
 # and subagent definitions.
 #
+# Rules: an always-on rule AGENTS.md does not carry — a local one, or one whose
+#   targets leave `agents` out — goes into AGENTS.override.md beside it
+#   (decision 0021). Codex reads that file instead of AGENTS.md in the same
+#   directory, so it holds the whole AGENTS.md plus those rules. The contract
+#   ignores it, and it exists only while such a rule does; one Intelligence did
+#   not generate is never touched, and refuses a render that needs the path.
+#
 # Skills: copy skill directories in full to .agents/skills/{name}/ (Codex
 #   reads from $REPO_ROOT/.agents/skills exclusively per official docs)
 # Agents: -> .codex/agents/{name}.toml (name, description, model,
@@ -26,8 +33,61 @@ adapter_contract_codex() {
     adapter_contract_requires agents
     adapter_contract_managed ".agents/skills"
     adapter_contract_owned "$output/agents"
+    # Marker-managed: a hand-written override is left alone.
+    adapter_contract_managed "AGENTS.override.md"
     adapter_contract_ignore ".agents/skills/"
     adapter_contract_ignore "$output/agents/"
+    adapter_contract_ignore "AGENTS.override.md"
+}
+
+CODEX_OVERRIDE_MARKER="<!-- Generated by intelligence-sync. Do not edit manually. -->"
+
+# sync_codex_override <repo_root> <config_file> — write AGENTS.override.md
+# while an always-on rule AGENTS.md does not carry is for Codex, and remove a
+# generated one otherwise.
+sync_codex_override() {
+    local repo_root="$1" config_file="$2" override="$1/AGENTS.override.md" first="" agents_file i
+    local -a files=() names=()
+    source_artifacts_var "$repo_root" "$config_file" rules codex "AGENTS.override.md"
+    for ((i = 0; i < ${#IS_SOURCE_FILES[@]}; i++)); do
+        [ "${IS_SOURCE_SCOPED[i]}" = 0 ] && [ "${IS_SOURCE_IN_AGENTS[i]}" = 0 ] || continue
+        files+=("${IS_SOURCE_FILES[i]}")
+        names+=("${IS_SOURCE_NAMES[i]}")
+    done
+    if [ -f "$override" ]; then
+        IFS= read -r first < "$override" || true
+        if [ "${first%$'\r'}" != "$CODEX_OVERRIDE_MARKER" ]; then
+            [ "${#files[@]}" -gt 0 ] || return 0
+            echo "ERROR: AGENTS.override.md was not generated by intelligence-sync, but ${names[*]} need it: always-on rules for Codex that AGENTS.md does not carry go there. Move its guidance into a rule, remove it, then sync." >&2
+            return 1
+        fi
+    fi
+    if [ "${#files[@]}" -eq 0 ]; then
+        rm -f "$override"
+        return 0
+    fi
+    target_output_var "$config_file" "agents"
+    agents_output_path_var "${IS_TGT_OUTPUT:-.agents}"
+    agents_file="$repo_root/$IS_AGENTS_OUTPUT_PATH"
+    {
+        if [ -f "$agents_file" ]; then
+            cat "$agents_file"
+        else
+            printf '%s\n\n' "$CODEX_OVERRIDE_MARKER"
+        fi
+        echo "---"
+        echo ""
+        echo "## Codex Project Context"
+        echo ""
+        echo "<!-- Always-on rules AGENTS.md does not carry. Codex reads this file instead of AGENTS.md. -->"
+        echo ""
+        emit_rule_bodies "${files[@]}"
+    } > "$override"
+    finalize_output_file "$override"
+    for ((i = 0; i < ${#names[@]}; i++)); do
+        echo "  rule: ${names[i]} (always-on, AGENTS.override.md)"
+    done
+    echo "  -> AGENTS.override.md"
 }
 
 # Codex-specific guard for its documented project-instruction byte budget.
@@ -52,6 +112,8 @@ codex_warn_project_doc_size() {
     target_output_var "$config_file" "agents"
     local output
     output="$(agents_output_path "${IS_TGT_OUTPUT:-.agents}")"
+    # Codex reads AGENTS.override.md instead of AGENTS.md when it exists.
+    [ ! -f "$repo_root/AGENTS.override.md" ] || output="AGENTS.override.md"
 
     local output_file="$repo_root/$output"
     [ -f "$output_file" ] || return 0
@@ -83,19 +145,13 @@ sync_codex_agents() {
     local config_file="$2"
     local output_dir="$3"
 
-    local src f
-    local -a files=()
-    load_yaml_list "$config_file" "agents"
-    local list="$IS_YAML_LIST"
-    while IFS= read -r src; do
-        [ -z "$src" ] && continue
-        local dir="$repo_root/$src"
-        [ -d "$dir" ] || continue
-        for f in "$dir"/*.md; do
-            [ -f "$f" ] || continue
-            files+=("$f")
-        done
-    done <<< "$list"
+    local -a files=() names=()
+    output_rel_var "$repo_root" "$output_dir"
+    source_artifacts_var "$repo_root" "$config_file" agents codex "$IS_OUTPUT_REL/{}.toml"
+    if [ "${#IS_SOURCE_FILES[@]}" -gt 0 ]; then
+        files=("${IS_SOURCE_FILES[@]}")
+        names=("${IS_SOURCE_NAMES[@]}")
+    fi
 
     local count=0
     if [ "${#files[@]}" -gt 0 ]; then
@@ -103,8 +159,7 @@ sync_codex_agents() {
 
         local path tier access description effort name sandbox spec="" report="" LS=$'\x1e'
         while IFS=$'\x1f' read -r path tier access description effort; do
-            [ -n "$path" ] || continue
-            name="${path##*/}"; name="${name%.md}"
+            name="${names[count]}"
             resolve_model_var "$tier"
             map_effort_var codex "$effort"
             case "$access" in
@@ -155,5 +210,9 @@ sync_to_codex() {
     mkdir -p "$agents_dir"
     sync_codex_agents "$repo_root" "$config_file" "$agents_dir"
 
+    # Rules AGENTS.md does not carry -> AGENTS.override.md. The contract
+    # requires `agents`, so AGENTS.md has rendered by now.
+    sync_codex_override "$repo_root" "$config_file" || return 1
+
     codex_warn_project_doc_size "$repo_root" "$config_file"
 }

package/engine/adapters/copilot.sh

@@ -8,7 +8,9 @@
 #     natively, and the `agents` adapter inlines always-on rule content
 #     into AGENTS.md. We also do not generate .github/copilot-instructions.md
 #     because Copilot bug copilot-cli#489 makes AGENTS.md ignored when
-#     copilot-instructions.md is present.
+#     copilot-instructions.md is present. An always-on rule AGENTS.md does not
+#     carry — a local one, or one whose targets leave `agents` out — becomes
+#     an .instructions.md file with `applyTo: "**"` (decision 0021).
 # Skills: copy skill directories in full to .github/skills/{name}/
 # Agents: -> .github/agents/{name}.agent.md (description, tools, model)
 #
@@ -53,19 +55,13 @@ adapter_contract_copilot() {
 
 # copilot_commit_output_var <manifest> — the one reader of
 # targets.copilot.commit_output. Sets IS_COPILOT_COMMIT_OUTPUT to 1 when the
-# project commits generated output and 0 for the default; returns 1 for any
-# value other than true or false. No manifest — a caller reading ownership
-# only — is the default.
+# project commits generated output and 0 for the default; returns 1 for a value
+# target_bool_var refuses.
 copilot_commit_output_var() {
-    local manifest="$1" setting
-    IS_COPILOT_COMMIT_OUTPUT=0
-    [ -n "$manifest" ] && [ -f "$manifest" ] || return 0
-    setting="$(get_target_field "$manifest" "copilot" "commit_output")"
-    case "$setting" in
-        ''|false) ;;
-        true) IS_COPILOT_COMMIT_OUTPUT=1 ;;
-        *) return 1 ;;
-    esac
+    local rc=0
+    target_bool_var "$1" copilot commit_output || rc=1
+    IS_COPILOT_COMMIT_OUTPUT="$IS_TARGET_BOOL"
+    return "$rc"
 }
 
 # copilot_paths_rows <file>... — batch form of the old per-file `paths:`
@@ -100,8 +96,8 @@ copilot_paths_rows() {
     ' "$@"
 }
 
-# Sync rules to Copilot format. Only path-scoped rules are emitted —
-# always-on rules live in AGENTS.md (read by Copilot natively).
+# Sync rules to Copilot format. Path-scoped rules are emitted, and an always-on
+# rule only when AGENTS.md (read by Copilot natively) does not carry it.
 sync_copilot_rules() {
     local repo_root="$1"
     local config_file="$2"
@@ -112,35 +108,28 @@ sync_copilot_rules() {
 
     local scoped_count=0
 
-    local src f
-    local -a files=()
-    load_yaml_list "$config_file" "rules"
-    local list="$IS_YAML_LIST"
-    while IFS= read -r src; do
-        [ -z "$src" ] && continue
-        local dir="$repo_root/$src"
-        [ -d "$dir" ] || continue
-        for f in "$dir"/*.md; do
-            [ -f "$f" ] || continue
-            files+=("$f")
-        done
-    done <<< "$list"
-
-    local -a scoped=()
-    if [ "${#files[@]}" -gt 0 ]; then
-        local path hp
-        while IFS=$'\x1f' read -r path hp; do
-            [ -n "$path" ] || continue
-            [ "$hp" -eq 0 ] && continue
-            scoped+=("$path")
-        done < <(frontmatter_index "paths#" "${files[@]}")
-    fi
+    local i always_count=0 spec="" report="" LS=$'\x1e'
+    local -a scoped=() scoped_names=()
+    output_rel_var "$repo_root" "$instructions_dir"
+    source_artifacts_var "$repo_root" "$config_file" rules copilot "$IS_OUTPUT_REL/{}.instructions.md"
+    for ((i = 0; i < ${#IS_SOURCE_FILES[@]}; i++)); do
+        if [ "${IS_SOURCE_SCOPED[i]}" = 1 ]; then
+            scoped+=("${IS_SOURCE_FILES[i]}")
+            scoped_names+=("${IS_SOURCE_NAMES[i]}")
+        elif [ "${IS_SOURCE_IN_AGENTS[i]}" = 0 ]; then
+            # An always-on rule AGENTS.md does not carry applies everywhere.
+            spec+="${IS_SOURCE_FILES[i]}"$'\x1f'"$instructions_dir/${IS_SOURCE_NAMES[i]}.instructions.md"$'\x1f'"fence_nofm"$'\x1f'"0"$'\x1f'"none"$'\x1f'"${LS}---${LS}applyTo: \"**\"${LS}---${LS}"$'\x1f\n'
+            report+="  rule: ${IS_SOURCE_NAMES[i]}.instructions.md (always-on)"$'\n'
+            always_count=$((always_count + 1))
+        fi
+    done
 
     if [ "${#scoped[@]}" -gt 0 ]; then
-        local base paths_line spec="" report="" LS=$'\x1e'
+        local path base paths_line
+        i=0
         while IFS=$'\x1f' read -r path paths_line; do
-            [ -n "$path" ] || continue
-            base="${path##*/}"; base="${base%.md}"
+            base="${scoped_names[i]}"
+            i=$((i + 1))
 
             local header
             header="${LS}---"
@@ -152,12 +141,17 @@ sync_copilot_rules() {
             report+="  rule: $base.instructions.md (scoped)"$'\n'
             scoped_count=$((scoped_count + 1))
         done < <(copilot_paths_rows "${scoped[@]}")
-
+    fi
+    if [ -n "$spec" ]; then
         emit_wrapped_bodies "$spec"
         printf '%s' "$report"
     fi
 
-    echo "  rules: $scoped_count scoped"
+    if [ "$always_count" -gt 0 ]; then
+        echo "  rules: $scoped_count scoped, $always_count always-on"
+    else
+        echo "  rules: $scoped_count scoped"
+    fi
 }
 
 # Sync skills to Copilot format (SKILL.md in .github/skills/)
@@ -166,33 +160,23 @@ sync_copilot_skills() {
     local config_file="$2"
     local output_dir="$3"
 
-    local src d skill_name
+    local i name
     local -a skill_dirs=()
-    # The inventory decides which skills render, symlinked ones included
-    # (decision 0017); the glob keeps this adapter's own listing order.
-    skill_source_inventory "$repo_root" "$config_file"
-    load_yaml_list "$config_file" "skills"
-    local list="$IS_YAML_LIST"
-    while IFS= read -r src; do
-        [ -z "$src" ] && continue
-        local dir="$repo_root/$src"
-        [ -d "$dir" ] || continue
-        for d in "$dir"/*/; do
-            [ -d "$d" ] || continue
-            [ -f "$d/SKILL.md" ] || continue
-            skill_source_rendered "$d" || continue
-            skill_dirs+=("$d")
-        done
-    done <<< "$list"
+    # The catalog's skills are the ones the inventory renders, symlinked ones
+    # included (decision 0017).
+    output_rel_var "$repo_root" "$output_dir"
+    source_artifacts_var "$repo_root" "$config_file" skills copilot "$IS_OUTPUT_REL/skills/{}"
+    for ((i = 0; i < ${#IS_SOURCE_FILES[@]}; i++)); do
+        skill_dirs+=("${IS_SOURCE_FILES[i]%/SKILL.md}/")
+    done
 
     local count=0
     if [ "${#skill_dirs[@]}" -gt 0 ]; then
         # Copilot has no effort field: the copy carries no `effort:`.
-        copy_skill_bundle_dirs_for copilot "$output_dir/skills" "${skill_dirs[@]}"
-        for d in "${skill_dirs[@]}"; do
-            skill_name="${d%/}"
+        copy_skill_bundle_dirs_named copilot "$output_dir/skills" "$IS_SOURCE_NAME_MAP" "${skill_dirs[@]}"
+        for name in "${IS_SOURCE_NAMES[@]}"; do
             count=$((count + 1))
-            echo "  skill: ${skill_name##*/}"
+            echo "  skill: $name"
         done
     fi
 
@@ -205,19 +189,13 @@ sync_copilot_agents() {
     local config_file="$2"
     local output_dir="$3"
 
-    local src f
-    local -a files=()
-    load_yaml_list "$config_file" "agents"
-    local list="$IS_YAML_LIST"
-    while IFS= read -r src; do
-        [ -z "$src" ] && continue
-        local dir="$repo_root/$src"
-        [ -d "$dir" ] || continue
-        for f in "$dir"/*.md; do
-            [ -f "$f" ] || continue
-            files+=("$f")
-        done
-    done <<< "$list"
+    local -a files=() names=()
+    output_rel_var "$repo_root" "$output_dir"
+    source_artifacts_var "$repo_root" "$config_file" agents copilot "$IS_OUTPUT_REL/agents/{}.agent.md"
+    if [ "${#IS_SOURCE_FILES[@]}" -gt 0 ]; then
+        files=("${IS_SOURCE_FILES[@]}")
+        names=("${IS_SOURCE_NAMES[@]}")
+    fi
 
     local count=0
     if [ "${#files[@]}" -gt 0 ]; then
@@ -225,8 +203,7 @@ sync_copilot_agents() {
 
         local path tier access description name tools_line spec="" report="" LS=$'\x1e'
         while IFS=$'\x1f' read -r path tier access description; do
-            [ -n "$path" ] || continue
-            name="${path##*/}"; name="${name%.md}"
+            name="${names[count]}"
             resolve_model_var "$tier"
 
             # Build tools list based on access. Tool aliases per Copilot custom-agent