@ainova-systems/intelligence 0.20.0 → 0.21.0

package/cli/commands/init.sh

@@ -356,7 +356,8 @@ manifest="$root/intelligence.yaml"
 } > "$manifest"
 
 # The package store is restorable state, never committed — the npm model.
-ensure_base_gitignore "$root"
+# Local rules, agents and skills stay on this machine (decision 0021).
+ensure_base_gitignore "$root" "$content_dir"
 for target in $targets; do
     ensure_target_gitignore "$root" "$manifest" "$target"
 done

package/cli/internal/check.sh

@@ -198,6 +198,14 @@ while IFS= read -r target; do
     ok "adapter $target contract v1"
 done < <(target_names "$manifest")
 
+# A local rule, agent or skill is one these patterns name (decision 0021): the
+# engine keeps it out of every committed output, and without the pattern Git
+# would still offer to commit the file itself.
+while IFS= read -r pattern; do
+    ignore_file_has_line "$IP_ROOT/.gitignore" "$pattern" \
+        || warn "local artifact Git policy is missing '$pattern' — run 'intelligence init'"
+done < <(local_artifact_ignore_patterns "$content_dir")
+
 # Lock orphans.
 if [ "$lock_valid" -eq 1 ] && [ -f "$lock" ]; then
     while IFS= read -r name; do
@@ -214,6 +222,7 @@ fi
 # is exactly why doctor names it). Each entry is judged by the directory the
 # engine renders it as, read through the same parser: a package reference by
 # its store path, one that resolves to nothing by why.
+local_specs=()
 for section in rules agents skills; do
     seen=$'\n'
     while IFS=$'\037' read -r src state dir alias holders; do
@@ -269,10 +278,40 @@ for section in rules agents skills; do
                 # authoring later needs no config edit.
                 *) ok "sources.$section '$src' — not created yet (optional)" ;;
             esac
+            continue
         fi
+        # A project-owned source is where a tracked file can carry a local
+        # name; store content is restorable state Git never tracks.
+        case "$dir" in
+            .intelligence/*) ;;
+            *)
+                if [ "$section" = skills ]; then
+                    local_specs+=(":(glob)${dir%/}/*.local/SKILL.md")
+                else
+                    local_specs+=(":(glob)${dir%/}/*.local.md")
+                fi
+                ;;
+        esac
     done < <(read_source_entries "$manifest" "$section")
 done
 
+# A name makes an artifact local (decision 0021), and .gitignore never applies
+# to a file Git already tracks: one committed before its name meant anything,
+# or added by hand, renders only into ignored output while every clone holds
+# it. Git and the engine would disagree about it, so it is named here.
+if [ "${#local_specs[@]}" -gt 0 ] \
+    && git -C "$IP_ROOT" rev-parse --is-inside-work-tree >/dev/null 2>&1; then
+    if tracked_local="$(git -C "$IP_ROOT" -c core.quotePath=false ls-files -- "${local_specs[@]}")"; then
+        while IFS= read -r path; do
+            [ -n "$path" ] || continue
+            case "$path" in */SKILL.md) path="${path%/SKILL.md}/" ;; esac
+            warn "$path is tracked by Git, but its name makes it local: sync renders it only into ignored output — rename it to share it, or 'git rm --cached' it to keep it on this machine"
+        done <<< "$tracked_local"
+    else
+        warn "tracked local artifacts could not be listed — 'git ls-files' failed"
+    fi
+fi
+
 if [ "$problems" -eq 0 ]; then
     echo "all good."
 else

package/cli/lib/gitignore.sh

@@ -312,10 +312,26 @@ ensure_gitignore_header() {
     fi
 }
 
+# local_artifact_ignore_patterns <content-dir> — the patterns that make a rule,
+# agent or skill local (decision 0021): a file or skill directory with one of
+# these names never reaches committed output, and Git never commits it. The
+# engine recognizes the same names, so the two cannot disagree; `init` writes
+# them and `status --check` reports one missing.
+local_artifact_ignore_patterns() {
+    local dir="${1#./}"
+    while [ "${dir%/}" != "$dir" ]; do dir="${dir%/}"; done
+    printf '%s\n' "$dir/rules/*.local.md" "$dir/agents/*.local.md" "$dir/skills/*.local/"
+}
+
+# ensure_base_gitignore <root> <content-dir> — the package store and the local
+# artifact patterns of the project's content directory.
 ensure_base_gitignore() {
-    local root="$1"
+    local root="$1" content_dir="$2" line
     ensure_gitignore_header "$root"
     gitignore_add_line "$root" '.intelligence/'
+    while IFS= read -r line; do
+        gitignore_add_line "$root" "$line"
+    done < <(local_artifact_ignore_patterns "$content_dir")
 }
 
 ensure_target_gitignore() {
@@ -343,7 +359,7 @@ ensure_target_gitignore() {
 
 ensure_manifest_gitignore() {
     local root="$1" manifest="$2" target
-    ensure_base_gitignore "$root"
+    ensure_base_gitignore "$root" "$(manifest_intelligence_dir "$manifest")"
     while IFS= read -r target; do
         [ -n "$target" ] || continue
         if [ "$(is_target_enabled "$manifest" "$target")" = "1" ]; then
@@ -420,6 +436,7 @@ managed_gitignore_patterns() {
     local root="$1" manifest="$2" content_dir target output records kind value
     content_dir="$(manifest_intelligence_dir "$manifest")"
     printf '%s\n' '.intelligence/' "$content_dir/_backup/"
+    local_artifact_ignore_patterns "$content_dir"
     while IFS= read -r target; do
         [ -n "$target" ] || continue
         [ "$(is_target_enabled "$manifest" "$target")" = "1" ] || continue

package/engine/ENGINE_SHA

@@ -1 +1 @@
-c8058f91133b86479a03d7ae950191e2d21b68a6
+af0a0fdbc3f505e4f063ae516c9243c92db6e376

package/engine/VERSION

@@ -1 +1 @@
-0.20.0
+0.21.0

package/engine/adapters/_template.sh

@@ -30,9 +30,17 @@
 #   map_effort(tool, effort)            — the tool's level for a neutral effort; "" when none
 #   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(manifest, section)   — read a source list from intelligence.yaml,
-#                                         package references as their store paths
+#   source_artifacts_var(root, config, section, adapter, output)
+#                                       — the sources this adapter renders (below)
+#   finalize_copy_named(dir, map, file...) — copy and finalize files under their rendered names
+#   copy_skill_bundle_dirs_named(tool, dir, map, skill_dir...) — copy skills under their rendered names
 #   get_target_field(config, target, field) — read a target's config field
+#
+# Read sources through source_artifacts_var, never with a glob of your own: it
+# names each artifact (`.draft.md` is `draft`, `me.local.md` is `me`), renders
+# only the later of two same-named artifacts, and leaves a local artifact out of
+# every output path Git tracks (decision 0021). An adapter that globs sources
+# itself can write a teammate's local file into a committed output.
 
 # Project adapters are sourced by engine/sync.sh after the shared library is
 # loaded. Keep this template position-independent: after scaffolding it lives
@@ -61,13 +69,24 @@ adapter_contract_<name>() {
 #   - Copy as-is (like Claude)
 #   - Convert paths: to globs: (like Cursor)
 #   - Merge into single file (like Copilot)
+#
+# source_artifacts_var takes the repo-relative path an artifact lands at, `{}`
+# standing for its name, and fills IS_SOURCE_FILES (the source file, or a
+# skill's SKILL.md), IS_SOURCE_NAMES, IS_SOURCE_SCOPED (1 for a rule with
+# `paths:`), IS_SOURCE_IN_AGENTS (1 when AGENTS.md carries the artifact too)
+# and IS_SOURCE_NAME_MAP, the names finalize_copy_named and
+# copy_skill_bundle_dirs_named write under. It lists only the artifacts whose
+# `targets:` / `exclude_targets:` select this adapter; the shared helpers drop
+# both fields from every copy, and a frontmatter copied by hand must too.
 sync_<name>_rules() {
     local repo_root="$1"
     local config_file="$2"
     local output_dir="$3"
 
-    # TODO: Implement rule sync logic
-    echo "  rules: not implemented"
+    output_rel_var "$repo_root" "$output_dir"
+    source_artifacts_var "$repo_root" "$config_file" rules <name> "$IS_OUTPUT_REL/rules/{}.md"
+    # TODO: Render each of IS_SOURCE_FILES into $output_dir/rules/ under its IS_SOURCE_NAMES entry
+    echo "  rules: ${#IS_SOURCE_FILES[@]} found, not rendered"
 }
 
 # Sync skills for <agent-name>
@@ -76,8 +95,11 @@ sync_<name>_skills() {
     local config_file="$2"
     local output_dir="$3"
 
-    # TODO: Implement skill sync logic
-    echo "  skills: not implemented"
+    output_rel_var "$repo_root" "$output_dir"
+    source_artifacts_var "$repo_root" "$config_file" skills <name> "$IS_OUTPUT_REL/skills/{}"
+    # TODO: Copy each skill directory ("${IS_SOURCE_FILES[i]%/SKILL.md}") with
+    # copy_skill_bundle_dirs_named <name> "$output_dir/skills" "$IS_SOURCE_NAME_MAP" <dir>...
+    echo "  skills: ${#IS_SOURCE_FILES[@]} found, not rendered"
 }
 
 # Sync agents for <agent-name>
@@ -86,8 +108,10 @@ sync_<name>_agents() {
     local config_file="$2"
     local output_dir="$3"
 
-    # TODO: Implement agent sync logic
-    echo "  agents: not implemented"
+    output_rel_var "$repo_root" "$output_dir"
+    source_artifacts_var "$repo_root" "$config_file" agents <name> "$IS_OUTPUT_REL/agents/{}.md"
+    # TODO: Render each of IS_SOURCE_FILES into $output_dir/agents/ under its IS_SOURCE_NAMES entry
+    echo "  agents: ${#IS_SOURCE_FILES[@]} found, not rendered"
 }
 
 # Main entry point

package/engine/adapters/agents.sh

@@ -60,15 +60,19 @@ agents_md_append_agents_table() {
     local rows=""
     local count=0
 
-    local -a files=()
-    read_source_artifact_files "$repo_root" "$config_file" "agents"
-    [ "${#IS_SOURCE_FILES[@]}" -eq 0 ] || files=("${IS_SOURCE_FILES[@]}")
+    local -a files=() names=()
+    source_artifacts_var "$repo_root" "$config_file" agents agents "${output#"$repo_root"/}"
+    if [ "${#IS_SOURCE_FILES[@]}" -gt 0 ]; then
+        files=("${IS_SOURCE_FILES[@]}")
+        names=("${IS_SOURCE_NAMES[@]}")
+    fi
 
     if [ "${#files[@]}" -gt 0 ]; then
-        local path tier access desc name
+        local path tier access desc name i=0
+        # frontmatter_index prints one row per file, in argument order.
         while IFS=$'\x1f' read -r path tier access desc; do
-            [ -n "$path" ] || continue
-            name="${path##*/}"; name="${name%.md}"
+            name="${names[i]}"
+            i=$((i + 1))
             repo_rel_link_var "$repo_root" "$path"
             if [ -n "$IS_REPO_REL" ]; then
                 rows+="| [$name]($IS_REPO_REL) | ${tier:--} | ${access:--} | ${desc:--} |"$'\n'
@@ -101,21 +105,24 @@ agents_md_append_skills_table() {
     local rows=""
     local count=0
 
-    local dirname
-    local -a skill_files=()
-    read_source_artifact_files "$repo_root" "$config_file" "skills"
-    [ "${#IS_SOURCE_FILES[@]}" -eq 0 ] || skill_files=("${IS_SOURCE_FILES[@]}")
+    local name
+    local -a skill_files=() names=()
+    source_artifacts_var "$repo_root" "$config_file" skills agents "${output#"$repo_root"/}"
+    if [ "${#IS_SOURCE_FILES[@]}" -gt 0 ]; then
+        skill_files=("${IS_SOURCE_FILES[@]}")
+        names=("${IS_SOURCE_NAMES[@]}")
+    fi
 
     if [ "${#skill_files[@]}" -gt 0 ]; then
-        local path desc
+        local path desc i=0
         while IFS=$'\x1f' read -r path desc; do
-            [ -n "$path" ] || continue
-            dirname="${path%/SKILL.md}"; dirname="${dirname##*/}"
+            name="${names[i]}"
+            i=$((i + 1))
             repo_rel_link_var "$repo_root" "$path"
             if [ -n "$IS_REPO_REL" ]; then
-                rows+="| [$dirname]($IS_REPO_REL) | ${desc:--} |"$'\n'
+                rows+="| [$name]($IS_REPO_REL) | ${desc:--} |"$'\n'
             else
-                rows+="| $dirname | ${desc:--} |"$'\n'
+                rows+="| $name | ${desc:--} |"$'\n'
             fi
             count=$((count + 1))
         done < <(frontmatter_index "description" "${skill_files[@]}")
@@ -144,30 +151,25 @@ agents_md_append_rules_list() {
     local count=0
     local global_rule_files=()
 
-    local -a files=()
-    read_source_artifact_files "$repo_root" "$config_file" "rules"
-    [ "${#IS_SOURCE_FILES[@]}" -eq 0 ] || files=("${IS_SOURCE_FILES[@]}")
-
-    if [ "${#files[@]}" -gt 0 ]; then
-        local path hp name scope
-        while IFS=$'\x1f' read -r path hp; do
-            [ -n "$path" ] || continue
-            name="${path##*/}"; name="${name%.md}"
-            scope="global"
-            if [ "$hp" != "0" ]; then
-                scope="scoped"
-            else
-                global_rule_files+=("$path")
-            fi
-            repo_rel_link_var "$repo_root" "$path"
-            if [ -n "$IS_REPO_REL" ]; then
-                lines+="- [$name]($IS_REPO_REL) ($scope)"$'\n'
-            else
-                lines+="- $name ($scope)"$'\n'
-            fi
-            count=$((count + 1))
-        done < <(frontmatter_index "paths#" "${files[@]}")
-    fi
+    local i path name scope
+    source_artifacts_var "$repo_root" "$config_file" rules agents "${output#"$repo_root"/}"
+    for ((i = 0; i < ${#IS_SOURCE_FILES[@]}; i++)); do
+        path="${IS_SOURCE_FILES[i]}"
+        name="${IS_SOURCE_NAMES[i]}"
+        scope="global"
+        if [ "${IS_SOURCE_SCOPED[i]}" = 1 ]; then
+            scope="scoped"
+        else
+            global_rule_files+=("$path")
+        fi
+        repo_rel_link_var "$repo_root" "$path"
+        if [ -n "$IS_REPO_REL" ]; then
+            lines+="- [$name]($IS_REPO_REL) ($scope)"$'\n'
+        else
+            lines+="- $name ($scope)"$'\n'
+        fi
+        count=$((count + 1))
+    done
 
     [ "$count" -eq 0 ] && return 0
 
@@ -196,17 +198,7 @@ agents_md_append_rules_list() {
             echo "<!-- Inlined from always-on rules in $content_rel/rules/ -->"
             echo ""
         } >> "$output"
-        # One awk inlines every global rule body, with a blank line after
-        # each — the same output the per-file passes produced.
-        awk '
-            FNR == 1 { if (NR != 1) print ""; in_fm = 0; past_fm = 0 }
-            { sub(/\r$/, "") }
-            /^---$/ {
-                if (!past_fm) { in_fm = !in_fm; if (!in_fm) { past_fm = 1 }; next }
-            }
-            past_fm || !in_fm { print }
-            END { print "" }
-        ' "${global_rule_files[@]}" >> "$output"
+        emit_rule_bodies "${global_rule_files[@]}" >> "$output"
         echo "  rules: ${#global_rule_files[@]} global rule(s) inlined"
     fi
 }

package/engine/adapters/antigravity.sh

@@ -11,7 +11,11 @@
 #   - Always-on (no `paths:`) -> SKIPPED here. The CLI docs tell a project to
 #     "Create a GEMINI.md or AGENTS.md file at your workspace root", and the
 #     `agents` adapter inlines always-on rule content into AGENTS.md. Emitting
-#     copies under .agents/rules/ would double-load the same text.
+#     copies under .agents/rules/ would double-load the same text. An always-on
+#     rule AGENTS.md does not carry — a local one, or one whose targets leave
+#     `agents` out — becomes .agents/rules/<name>.md with `trigger: always_on`,
+#     the same key family as `trigger: glob` and just as undocumented
+#     (decision 0021).
 #   - Path-scoped (with `paths:`) -> .agents/rules/<name>.md carrying
 #     `trigger: glob` and `globs:`. NOT vendor-documented: the rules page names
 #     four activation modes in prose (manual, always on, model decision, glob
@@ -95,45 +99,46 @@ sync_antigravity_rules() {
     antigravity_rule_limit "$config_file" || return 1
     rule_limit="$IS_AG_RULE_LIMIT"
 
-    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"
-
-    # Skip always-on rules: AGENTS.md (canonical) carries them.
-    local path hp base
-    local -a scoped=()
-    if [ "${#files[@]}" -gt 0 ]; then
-        while IFS=$'\x1f' read -r path hp; do
-            [ -n "$path" ] || continue
-            [ "$hp" -eq 0 ] && continue
-            scoped+=("$path")
-        done < <(frontmatter_index "paths#" "${files[@]}")
-    fi
-    if [ "${#scoped[@]}" -eq 0 ]; then
+    # Skip always-on rules AGENTS.md (canonical) carries; one it does not
+    # carry takes the always_on trigger instead (decision 0021).
+    local i always="" always_count=0
+    local -a files=() names=() kinds=()
+    output_rel_var "$repo_root" "$output_dir"
+    source_artifacts_var "$repo_root" "$config_file" rules antigravity "$IS_OUTPUT_REL/rules/{}.md"
+    for ((i = 0; i < ${#IS_SOURCE_FILES[@]}; i++)); do
+        if [ "${IS_SOURCE_SCOPED[i]}" = 1 ]; then
+            kinds+=(scoped)
+        elif [ "${IS_SOURCE_IN_AGENTS[i]}" = 0 ]; then
+            kinds+=(always-on)
+            always="$always${IS_SOURCE_FILES[i]}"$'\n'
+            always_count=$((always_count + 1))
+        else
+            continue
+        fi
+        files+=("${IS_SOURCE_FILES[i]}")
+        names+=("${IS_SOURCE_NAMES[i]}")
+    done
+    if [ "${#files[@]}" -eq 0 ]; then
         echo "  -> Rules: 0 scoped (AGENTS.md carries always-on)"
         return 0
     fi
 
-    # Path-scoped rule -> Glob activation (paths -> globs). The rewrite is
-    # anchored inside the frontmatter block: a body line may legitimately start
-    # with `paths:` (a rule documenting rule syntax does exactly that), and
-    # rewriting it would corrupt the text it teaches.
+    # Path-scoped rule -> Glob activation (paths -> globs); always-on rule ->
+    # `trigger: always_on`, with a frontmatter block of its own when the source
+    # has none. The rewrite is anchored inside the frontmatter block: a body
+    # line may legitimately start with `paths:` (a rule documenting rule
+    # syntax does exactly that), and rewriting it would corrupt the text it
+    # teaches.
     #
     # stdout carries nothing but the character-count overflow report, so the
     # limit check costs no extra process.
     local overflow
     is_fin_awk_vars
-    overflow="$(awk "${IS_FIN_V[@]}" -v dst="$output_dir/rules" -v limit="$rule_limit" "$IS_AWK_LIB"'
+    overflow="$(IS_AG_ALWAYS="$always" IS_NAME_MAP="$IS_SOURCE_NAME_MAP" awk "${IS_FIN_V[@]}" -v dst="$output_dir/rules" -v limit="$rule_limit" "$IS_AWK_LIB"'
+        BEGIN {
+            n = split(ENVIRON["IS_AG_ALWAYS"], al, "\n")
+            for (k = 1; k <= n; k++) if (al[k] != "") ALWAYS[al[k]] = 1
+        }
         function emit(line,   rendered) {
             rendered = fin_line(line)
             print rendered > out
@@ -141,11 +146,21 @@ sync_antigravity_rules() {
         }
         FNR == 1 {
             if (out != "") close(out)
-            out = dst "/" base_name(FILENAME)
+            out = dst "/" art_file(FILENAME, ".md")
             chars[out] = 0
             fm = 0
+            tgt_reset()
         }
         { sub(/\r$/, "") }
+        FNR == 1 && (FILENAME in ALWAYS) {
+            emit("---")
+            emit("trigger: always_on")
+            if ($0 == "---") { fm = 1; next }
+            emit("---")
+            fm = 2
+            emit($0)
+            next
+        }
         FNR == 1 {
             if ($0 == "---") fm = 1
             emit($0)
@@ -153,6 +168,7 @@ sync_antigravity_rules() {
             next
         }
         fm == 1 && $0 == "---" { fm = 2; emit($0); next }
+        fm == 1 && tgt_drop($0) { next }
         fm == 1 { sub(/^paths:/, "globs:") }
         { emit($0) }
         END {
@@ -161,7 +177,7 @@ sync_antigravity_rules() {
                 for (f in chars)
                     if (chars[f] > limit) printf "%s\t%d\n", f, chars[f]
         }
-    ' "${scoped[@]}" | sort)"
+    ' "${files[@]}" | sort)"
 
     local over_file over_chars
     while IFS=$'\t' read -r over_file over_chars; do
@@ -169,11 +185,18 @@ sync_antigravity_rules() {
         echo "WARNING: Antigravity limits a rule file to $rule_limit characters: ${over_file#"$repo_root/"} renders $over_chars; split the rule, shorten it, set targets.antigravity.warn_rule_limit to the effective limit, or set it to false to disable this warning." >&2
     done <<< "$overflow"
 
-    for f in "${scoped[@]}"; do
-        base="${f##*/}"
-        echo "  rule: $base (scoped)"
+    for ((i = 0; i < ${#files[@]}; i++)); do
+        # awk never reads a record from an empty source.
+        if [ "${kinds[i]}" = always-on ] && [ ! -s "${files[i]}" ]; then
+            printf -- '---\ntrigger: always_on\n---\n' > "$output_dir/rules/${names[i]}.md"
+        fi
+        echo "  rule: ${names[i]}.md (${kinds[i]})"
     done
-    echo "  -> Rules: ${#scoped[@]} scoped"
+    if [ "$always_count" -gt 0 ]; then
+        echo "  -> Rules: $(( ${#files[@]} - always_count )) scoped, $always_count always-on"
+    else
+        echo "  -> Rules: ${#files[@]} scoped"
+    fi
 }
 
 sync_antigravity_agents() {
@@ -181,19 +204,13 @@ sync_antigravity_agents() {
     local config_file="$2"
     local agents_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" "$agents_dir"
+    source_artifacts_var "$repo_root" "$config_file" agents antigravity "$IS_OUTPUT_REL/{}.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
@@ -201,8 +218,7 @@ sync_antigravity_agents() {
 
         local path tier access description name 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"
 
             local header