@ainova-systems/intelligence 0.11.9 → 0.12.1

package/cli/commands/init.sh

@@ -224,9 +224,20 @@ if [ -n "$targets_arg" ]; then
 else
     if [ -d "$root/.claude" ] || [ -f "$root/CLAUDE.md" ]; then targets="$targets claude"; fi
     if [ -d "$root/.cursor" ] || [ -f "$root/.cursorrules" ]; then targets="$targets cursor"; fi
-    if [ -d "$root/.codex" ] || [ -d "$root/.agents" ]; then targets="$targets codex"; fi
+    # `.agents/skills` is the only part of the shared root Codex reads, so it is
+    # the only part that may imply Codex. `.agents/` as a whole cannot: its
+    # `rules/`, `agents/` and `workflows/` siblings belong to Antigravity, and
+    # treating them as a Codex marker would invent a tool the project shows no
+    # trace of.
+    if [ -d "$root/.codex" ] || [ -d "$root/.agents/skills" ]; then targets="$targets codex"; fi
     [ -d "$root/.pi" ] && targets="$targets pi"
     [ -d "$root/.opencode" ] && targets="$targets opencode"
+    if [ -f "$root/GEMINI.md" ] \
+        || [ -d "$root/.agents/rules" ] \
+        || [ -d "$root/.agents/agents" ] \
+        || [ -d "$root/.agents/workflows" ]; then
+        targets="$targets antigravity"
+    fi
     if [ -f "$root/.github/copilot-instructions.md" ] \
         || [ -d "$root/.github/instructions" ] \
         || [ -d "$root/.github/agents" ] \

package/cli/lib/cli-common.sh

@@ -164,6 +164,7 @@ manifest_intelligence_dir() {
 default_target_output() {
     case "$1" in
         agents) printf '%s' "AGENTS.md" ;;
+        antigravity) printf '%s' ".agents" ;;
         copilot) printf '%s' ".github" ;;
         *) printf '.%s' "$1" ;;
     esac

package/cli/lib/gitignore.sh

@@ -15,34 +15,60 @@ gitignore_path_is_ignored() {
     git -C "$root" check-ignore -q --no-index -- "$path"
 }
 
-# Git cannot re-include a child of an excluded directory. Add explicit parent
-# reinclusions, then make sure both parent and child negations occur after any
-# pre-existing rule that still wins. The check-ignore probe also catches broad
-# patterns such as an old `.claude/` or `.cursor/**`, not just exact matches.
+# True when the file's last lines are exactly these, in order.
+gitignore_tail_is() {
+    local file="$1"; shift
+    [ -f "$file" ] || return 1
+    local want tail_lines
+    want="$(printf '%s\n' "$@")"
+    tail_lines="$(tail -n "$#" -- "$file")"
+    [ "$tail_lines" = "$want" ]
+}
+
+# Git cannot re-include a child of an excluded directory, so an include needs an
+# explicit negation for every parent. A negation only wins when it comes after
+# the rule excluding the parent, and the only repair an append can make is to
+# move the whole chain last — so the repair runs when, and only when, the chain
+# is not already there.
+#
+# Probe the include TARGET, never a parent with a trailing slash: `dir/*` — the
+# ignore this very policy writes — matches `dir/` because `*` matches the empty
+# string, so a parent probe answers "still ignored" in the healthy end state.
+# Keyed on that, the repair re-appended a line already last, which cannot change
+# the answer, and the file grew by one line on every run.
 gitignore_add_effective_include() {
-    local root="$1" value="${2#./}" dir parent="" part rc
+    local root="$1" value="${2#./}" dir parent="" part line rc
+    local -a negations=()
     dir="${value%/*}"
     if [ "$dir" != "$value" ]; then
         while IFS= read -r part; do
             [ -n "$part" ] || continue
             if [ -n "$parent" ]; then parent="$parent/$part"; else parent="$part"; fi
-            gitignore_add_line "$root" "!$parent/"
-            if gitignore_path_is_ignored "$root" "$parent/"; then
-                printf '!%s/\n' "$parent" >> "$root/.gitignore"
-            else
-                rc=$?
-                [ "$rc" -eq 1 ] || [ "$rc" -eq 2 ] || return "$rc"
-            fi
+            negations+=("!$parent/")
         done < <(printf '%s\n' "$dir" | tr '/' '\n')
     fi
+    negations+=("!$value")
 
-    gitignore_add_line "$root" "!$value"
-    if gitignore_path_is_ignored "$root" "$value"; then
-        printf '!%s\n' "$value" >> "$root/.gitignore"
-    else
-        rc=$?
-        [ "$rc" -eq 1 ] || [ "$rc" -eq 2 ] || return "$rc"
-    fi
+    for line in "${negations[@]}"; do
+        gitignore_add_line "$root" "$line"
+    done
+
+    # `|| rc=$?` keeps the probe out of `set -e`'s reach: its honest "not
+    # ignored" is exit 1, and a bare call would abort the whole command there.
+    rc=0
+    gitignore_path_is_ignored "$root" "$value" || rc=$?
+    case "$rc" in
+        0) ;;
+        1|2) return 0 ;;
+        *) return "$rc" ;;
+    esac
+
+    # Still ignored: an earlier negation is shadowed by a later rule. Move the
+    # chain last. Already last means appending cannot help — leave it, and let
+    # `status --check` report the re-inclusion this policy could not make
+    # effective rather than growing the file forever.
+    gitignore_tail_is "$root/.gitignore" "${negations[@]}" && return 0
+    printf '%s\n' "${negations[@]}" >> "$root/.gitignore"
 }
 
 ensure_gitignore_header() {

package/engine/ENGINE_SHA

@@ -1 +1 @@
-fe187a9bee5923603cec51798bd1ea5c2860593e
+9a4af90d8c755b5486a4a67af7c53c1be23f4641

package/engine/VERSION

@@ -1 +1 @@
-0.11.9
+0.12.1

package/engine/adapters/antigravity.sh

@@ -0,0 +1,197 @@
+#!/bin/bash
+# intelligence-sync: Google Antigravity adapter
+# Transforms source prompts to Antigravity's native resource model.
+#
+# Rules:
+#   - Always-on (no `paths:`) -> SKIPPED here. Antigravity reads AGENTS.md
+#     natively at the workspace root, and the `agents` adapter inlines
+#     always-on rule content into it. Emitting copies under .agents/rules/
+#     would double-load the same text.
+#   - Path-scoped (with `paths:`) -> .agents/rules/<name>.md carrying
+#     `trigger: glob` and `globs:` (activation modes: always_on, manual,
+#     model_decision, glob). Antigravity documents a 12,000-character limit
+#     per rule file, so scoped rules stay short.
+#   - GEMINI.md outranks AGENTS.md in Antigravity's rule precedence, so the
+#     contract quarantines it at onboarding: left in place it would silently
+#     override every synced rule.
+# Skills:
+#   - Copied to .agents/skills/ (Agent Skills open standard, shared with
+#     Codex, Pi and opencode). Antigravity reads that fixed workspace path,
+#     never the configured output, and selects skills by description.
+# Agents:
+#   - Converted to .agents/agents/<name>.md. `name` and `description` are
+#     required; `model` accepts only inherit|flash|pro; `subagent: true` with
+#     `mainAgent: false` matches how every other adapter exposes Intelligence
+#     agents — as delegates, not as chat personas. A readonly agent gets an
+#     explicit `tools:` allowlist.
+#
+# 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.
+
+source "$(dirname "${BASH_SOURCE[0]}")/../lib/common.sh"
+
+adapter_contract_antigravity() {
+    local output="${1%/}"
+    adapter_contract_version 1
+    adapter_contract_requires agents
+    adapter_contract_owned "$output/rules"
+    adapter_contract_owned "$output/agents"
+    adapter_contract_managed ".agents/skills"
+    adapter_contract_legacy "GEMINI.md"
+    adapter_contract_ignore "GEMINI.md"
+    adapter_contract_ignore "$output/rules/"
+    adapter_contract_ignore "$output/agents/"
+    adapter_contract_ignore ".agents/skills/"
+}
+
+sync_antigravity_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"
+
+    # 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
+        echo "  -> Rules: 0 scoped (AGENTS.md carries always-on)"
+        return 0
+    fi
+
+    # Path-scoped rule -> Glob activation (paths -> globs)
+    is_fin_awk_vars
+    awk "${IS_FIN_V[@]}" -v dst="$output_dir/rules" "$IS_AWK_LIB"'
+        FNR == 1 {
+            if (out != "") close(out)
+            out = dst "/" base_name(FILENAME)
+        }
+        {
+            sub(/\r$/, "")
+            sub(/^paths:/, "globs:")
+        }
+        FNR == 1 {
+            print fin_line($0) > out
+            print fin_line("trigger: glob") > out
+            next
+        }
+        { print fin_line($0) > out }
+        END { if (out != "") close(out) }
+    ' "${scoped[@]}"
+
+    for f in "${scoped[@]}"; do
+        base="${f##*/}"
+        echo "  rule: $base (scoped)"
+    done
+    echo "  -> Rules: ${#scoped[@]} scoped"
+}
+
+sync_antigravity_agents() {
+    local repo_root="$1"
+    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 count=0
+    if [ "${#files[@]}" -gt 0 ]; then
+        load_model_tiers "$config_file" "antigravity"
+
+        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}"
+            resolve_model_var "$tier"
+
+            local header
+            yaml_dq_escape_var "$name"
+            header="${LS}---"
+            header+="${LS}name: \"$IS_YAML_ESCAPED\""
+            yaml_dq_escape_var "$description"
+            header+="${LS}description: \"$IS_YAML_ESCAPED\""
+            if [ -n "$IS_MODEL" ]; then
+                yaml_dq_escape_var "$IS_MODEL"
+                header+="${LS}model: \"$IS_YAML_ESCAPED\""
+            fi
+            header+="${LS}subagent: true"
+            header+="${LS}mainAgent: false"
+            # A readonly agent gets an explicit allowlist. It holds only tool
+            # identifiers the official docs name, because an unknown entry in
+            # an allowlist silently removes a capability rather than failing:
+            # a directory-listing tool is left out until one is documented.
+            # An unrestricted agent declares no list and inherits the main
+            # agent's tools, which is Antigravity's default.
+            if [ "$access" = "readonly" ]; then
+                header+="${LS}tools:"
+                header+="${LS}  - view_file"
+                header+="${LS}  - grep_search"
+                header+="${LS}  - search_web"
+                header+="${LS}  - read_url_content"
+            fi
+            header+="${LS}---"
+            header+="${LS}"
+            header+="${LS}<!-- Generated by intelligence-sync. Do not edit manually. -->"
+            header+="${LS}"
+
+            spec+="$path"$'\x1f'"$agents_dir/$name.md"$'\x1f'"strip"$'\x1f'"1"$'\x1f'"none"$'\x1f'"$header"$'\x1f\n'
+            report+="  agent: $name.md"$'\n'
+            count=$((count + 1))
+        done < <(frontmatter_index "tier,access,description" "${files[@]}")
+
+        emit_wrapped_bodies "$spec"
+        printf '%s' "$report"
+    fi
+
+    echo "  -> Agents: $count"
+}
+
+sync_to_antigravity() {
+    local repo_root="$1"
+    local config_file="$2"
+    local output_dir="$3"
+
+    echo "=== Antigravity ==="
+
+    rm -rf "$output_dir/rules" "$output_dir/agents"
+    mkdir -p "$output_dir/rules" "$output_dir/agents"
+
+    sync_antigravity_rules "$repo_root" "$config_file" "$output_dir"
+
+    # Skills -> .agents/skills/ (open standard; Antigravity reads that fixed
+    # workspace path). `sync_open_skill_dirs` owns clean + populate of this
+    # shared dir, and replays it when Codex, Pi or opencode already filled it.
+    sync_open_skill_dirs "$repo_root" "$config_file" "$repo_root/.agents/skills"
+
+    sync_antigravity_agents "$repo_root" "$config_file" "$output_dir/agents"
+}

package/engine/lib/common.sh

@@ -830,6 +830,11 @@ get_model_default() {
         codex:heavy)      echo "gpt-5.6-sol" ;;
         codex:standard)   echo "gpt-5.6-terra" ;;
         codex:light)      echo "gpt-5.6-luna" ;;
+        # Antigravity accepts only inherit|flash|pro, so standard and light
+        # share `flash` — there is no third tier to map onto.
+        antigravity:heavy)     echo "pro" ;;
+        antigravity:standard)  echo "flash" ;;
+        antigravity:light)     echo "flash" ;;
         opencode:heavy)    echo "anthropic/claude-opus-4-8" ;;
         opencode:standard) echo "anthropic/claude-sonnet-5" ;;
         opencode:light)    echo "anthropic/claude-haiku-4-5-20251001" ;;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ainova-systems/intelligence",
-  "version": "0.11.9",
+  "version": "0.12.1",
   "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/references/adapters.md

@@ -163,6 +163,7 @@ Intelligence routes always-on rules once through `AGENTS.md` for tools that cons
 | Built-in | Always-on rules | Scoped rules |
 |---|---|---|
 | `agents` | Inline in `AGENTS.md` | List with links |
+| `antigravity` | Omit; reads `AGENTS.md` | `.agents/rules/*.md` with `trigger: glob` and `globs:` |
 | `claude` | Copy | Copy with `paths:` preserved |
 | `cursor` | Omit; reads `AGENTS.md` | `.mdc` with `globs:` |
 | `copilot` | Omit; reads `AGENTS.md` | `.instructions.md` with `applyTo:` |
@@ -186,7 +187,7 @@ copy_skill_bundle "$source_skill_dir" "$output_dir/skills/$skill_name"
 
 Do not use plain `cp` for skill bundles. `copy_skill_bundle` preserves non-Markdown assets, avoids materializing symlink targets, normalizes Markdown, expands layout tokens and quotes `description` and `argument-hint` where strict YAML readers require strings.
 
-Codex, Pi and OpenCode share `.agents/skills/`. Any adapter writing that open-standard directory must call `sync_open_skill_dirs`; it is the single lifecycle owner for immediate skill subdirectories.
+Antigravity, Codex, Pi and OpenCode share `.agents/skills/`. Any adapter writing that open-standard directory must call `sync_open_skill_dirs`; it is the single lifecycle owner for immediate skill subdirectories.
 
 ### Agents
 
@@ -300,6 +301,7 @@ For a built-in adapter, add the same assertions to the repository's smoke or lif
 | Adapter | Primary output |
 |---|---|
 | `agents` | `AGENTS.md` |
+| `antigravity` | `.agents/rules`, `.agents/agents`, `.agents/skills` |
 | `claude` | `.claude/rules`, `.claude/agents`, `.claude/skills` |
 | `cursor` | `.cursor/rules`, `.cursor/agents`, `.cursor/skills` |
 | `copilot` | `.github/instructions`, `.github/agents`, `.github/skills` |

package/packages/sync/references/conventions.md

@@ -156,7 +156,7 @@ Agent instructions in Markdown.
 
 An agent stays thin: **Expertise** → **Boundaries** → **Build & Verify**. Its role, limits and proof of completion belong here; reusable constraints belong in rules and reusable procedures belong in skills.
 
-Do not instruct an agent to read rules or restate their content. Claude loads its generated rules for its subagents, while Cursor, Copilot, Codex, Pi and OpenCode receive always-on rules through `AGENTS.md`. Duplicating a rule in an agent spends context twice and creates a copy that drifts.
+Do not instruct an agent to read rules or restate their content. Claude loads its generated rules for its subagents, while Cursor, Copilot, Codex, Pi, OpenCode and Antigravity receive always-on rules through `AGENTS.md`. Duplicating a rule in an agent spends context twice and creates a copy that drifts.
 
 ### Tier mappings
 
@@ -196,12 +196,12 @@ Rule content in Markdown.
 
 ### Routing
 
-| Source rule | Claude | Cursor | Copilot | Codex / Pi / OpenCode / `AGENTS.md` |
-|---|---|---|---|---|
-| Scoped | copied with `paths:` | `.mdc` with `globs:` | `.instructions.md` with `applyTo:` | listed in `AGENTS.md`; Pi also gets on-demand files and an extension |
-| Always-on | copied | omitted | omitted | inlined once into `AGENTS.md` |
+| Source rule | Claude | Cursor | Antigravity | Copilot | Codex / Pi / OpenCode / `AGENTS.md` |
+|---|---|---|---|---|---|
+| Scoped | copied with `paths:` | `.mdc` with `globs:` | `.md` with `trigger: glob` and `globs:` | `.instructions.md` with `applyTo:` | listed in `AGENTS.md`; Pi also gets on-demand files and an extension |
+| Always-on | copied | omitted | omitted | omitted | inlined once into `AGENTS.md` |
 
-Cursor, Copilot, Codex, Pi and OpenCode consume `AGENTS.md`, so always-on rules are not duplicated in their tool-specific channels. Claude does not consume `AGENTS.md`, so it receives the full rule set. OpenCode and Codex have no generated path-scoped rule channel; OpenCode users may configure `instructions:` globs themselves.
+Cursor, Copilot, Codex, Pi, OpenCode and Antigravity consume `AGENTS.md`, so always-on rules are not duplicated in their tool-specific channels. Claude does not consume `AGENTS.md`, so it receives the full rule set. OpenCode and Codex have no generated path-scoped rule channel; OpenCode users may configure `instructions:` globs themselves.
 
 Keep always-on rules small. Put narrow framework or component guidance behind `paths:` so unrelated tasks do not pay its context cost.
 
@@ -288,6 +288,7 @@ Every line enters a finite context budget. Prefer subtraction, consolidation and
 | Target | Rules | Skills | Agents |
 |---|---|---|---|
 | `agents` | Always-on inlined; scoped listed in `AGENTS.md` | Listed | Listed |
+| Antigravity | `AGENTS.md` plus scoped `.agents/rules/*.md` | `.agents/skills/` | `.agents/agents/*.md` |
 | Claude | `.claude/rules/` | `.claude/skills/` | `.claude/agents/` |
 | Cursor | scoped `.cursor/rules/*.mdc` | `.cursor/skills/` | `.cursor/agents/` |
 | Copilot | scoped `.github/instructions/*.instructions.md` | `.github/skills/` | `.github/agents/` |
@@ -306,6 +307,7 @@ By default, commit the manifest, lock, project-owned content, `AGENTS.md`, and s
 # Local root instructions migrate into project rules; local preferences stay ignored
 CLAUDE.md
 .cursorrules
+GEMINI.md
 
 # Generated Claude and Cursor content; shared settings remain trackable
 .claude/*
@@ -315,8 +317,11 @@ CLAUDE.md
 !.cursor/
 !.cursor/settings.json
 
-# Generated open-standard and Codex content
+# Generated open-standard, Codex and Antigravity content. `.agents/` is a
+# shared workspace root, so only the generated subdirectories are ignored.
 .agents/skills/
+.agents/rules/
+.agents/agents/
 .codex/agents/
 
 # Generated Pi content

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

@@ -25,7 +25,7 @@ Three ways to shorten, in order of what they are worth:
 
 ## Source of truth
 
-Edit the project-owned sources listed in `<manifest>` — the `rules/`, `agents/` and `skills/` directories it names — and `<manifest>` itself. An installed package source is replaced by CLI lifecycle/package operations; change it in its own repository. Everything else is derived: `.claude/`, `.cursor/`, `.github/{instructions,agents,skills}/`, `.codex/`, `.agents/skills/`, `.pi/`, `.opencode/` and `AGENTS.md` are **generated output**, and a hand edit there survives exactly until the next sync.
+Edit the project-owned sources listed in `<manifest>` — the `rules/`, `agents/` and `skills/` directories it names — and `<manifest>` itself. An installed package source is replaced by CLI lifecycle/package operations; change it in its own repository. Everything else is derived: `.claude/`, `.cursor/`, `.github/{instructions,agents,skills}/`, `.codex/`, `.agents/{rules,agents,skills}/`, `.pi/`, `.opencode/` and `AGENTS.md` are **generated output**, and a hand edit there survives exactly until the next sync.
 
 `<module>/` is the installed sync package's content. Package operations replace it, so a local edit there is lost. Fix it upstream instead.
 
@@ -68,7 +68,7 @@ The mistakes that actually happen, in order of frequency:
 
 An agent is **thin**: who it is, where it stops, how it verifies. Nothing else.
 
-- **Do not list rules for an agent to read.** They load on their own — Claude Code loads `.claude/rules/` into every custom subagent's startup context, and Cursor, Copilot, Codex, Pi and opencode receive always-on rules inlined in `AGENTS.md`. Naming a rule is fine; copying it is duplication that drifts.
+- **Do not list rules for an agent to read.** They load on their own — Claude Code loads `.claude/rules/` into every custom subagent's startup context, and Cursor, Copilot, Codex, Pi, OpenCode and Antigravity receive always-on rules inlined in `AGENTS.md`. Naming a rule is fine; copying it is duplication that drifts.
 - **Point at a rule, do not restate it.** Wanting to copy a rule into an agent means the rule is in the wrong place — move it.
 - **Do carry** what is genuinely the agent's own: its boundaries ("if the app will not start, stop — do not hand-write the output"), its verification commands, its definition of done.
 

package/packages/sync/skills/intelligence-add-agent/SKILL.md

@@ -52,7 +52,7 @@ argument-hint: <domain> [description]
 
 6. **Write body** with sections: **Expertise** -> **Boundaries** -> **Build & Verify**
    - An agent is **thin**: who it is, where it stops, how it verifies. Everything else already reaches it.
-   - **Do not tell the agent to read the rules.** Rules load on their own: Claude Code loads `.claude/rules/` into every custom subagent's startup context alongside `CLAUDE.md` (*Subagents → What loads at startup*), and Cursor / Copilot / Codex / Pi / opencode receive always-on rules inlined in `AGENTS.md`. A `Read <content-dir>/rules/<domain>.md before starting` line duplicates content the agent already has — double the tokens, and a second copy that drifts from the rule it copied.
+   - **Do not tell the agent to read the rules.** Rules load on their own: Claude Code loads `.claude/rules/` into every custom subagent's startup context alongside `CLAUDE.md` (*Subagents → What loads at startup*), and Cursor / Copilot / Codex / Pi / opencode / Antigravity receive always-on rules inlined in `AGENTS.md`. A `Read <content-dir>/rules/<domain>.md before starting` line duplicates content the agent already has — double the tokens, and a second copy that drifts from the rule it copied.
    - **Point at a rule, never restate it.** If you want to copy a rule into the agent, the rule is in the wrong place — move it, do not clone it.
    - **Do carry** what is genuinely the agent's own: its boundaries ("if the app is not running, stop — do not hand-write the output"), its verification commands, its definition of done.
    - All content must come from actual codebase analysis.