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

package/cli/lib/gitignore.sh

@@ -0,0 +1,215 @@
+#!/bin/bash
+# Generated-output policy derived from each adapter's ownership contract.
+
+gitignore_add_line() {
+    local root="$1" line="$2" file="$1/.gitignore"
+    if [ -f "$file" ] && grep -Fqx -- "$line" "$file"; then
+        return 0
+    fi
+    printf '%s\n' "$line" >> "$file"
+}
+
+gitignore_path_is_ignored() {
+    local root="$1" path="$2"
+    git -C "$root" rev-parse --is-inside-work-tree >/dev/null 2>&1 || return 2
+    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.
+gitignore_add_effective_include() {
+    local root="$1" value="${2#./}" dir parent="" part rc
+    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
+        done < <(printf '%s\n' "$dir" | tr '/' '\n')
+    fi
+
+    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
+}
+
+ensure_gitignore_header() {
+    local root="$1" file="$1/.gitignore"
+    if [ ! -f "$file" ] || ! grep -Fqx '# Intelligence generated state and tool output' "$file"; then
+        if [ -f "$file" ] && [ -s "$file" ] && [ -n "$(tail -c 1 "$file" 2>/dev/null)" ]; then
+            printf '\n' >> "$file"
+        fi
+        printf '%s\n' '# Intelligence generated state and tool output' >> "$file"
+    fi
+}
+
+ensure_base_gitignore() {
+    local root="$1"
+    ensure_gitignore_header "$root"
+    gitignore_add_line "$root" '.intelligence/'
+}
+
+ensure_target_gitignore() {
+    local root="$1" manifest="$2" target="$3" content_dir output kind value records
+    ensure_gitignore_header "$root"
+    content_dir="$(manifest_intelligence_dir "$manifest")"
+    output="$(get_target_output "$manifest" "$target")"
+    [ -n "$output" ] || output="$(default_target_output "$target")"
+    records="$(adapter_records_for "$root" "$content_dir" "$target" "$output")" \
+        || die "adapter '$target' has an invalid ownership contract"
+    while IFS=$'\t' read -r kind value; do
+        case "$kind" in
+            ignore)  gitignore_add_line "$root" "$value" ;;
+            include) gitignore_add_effective_include "$root" "$value" ;;
+        esac
+    done <<< "$records"
+}
+
+ensure_manifest_gitignore() {
+    local root="$1" manifest="$2" target
+    ensure_base_gitignore "$root"
+    while IFS= read -r target; do
+        [ -n "$target" ] || continue
+        if [ "$(is_target_enabled "$manifest" "$target")" = "1" ]; then
+            ensure_target_gitignore "$root" "$manifest" "$target"
+        fi
+    done < <(target_names "$manifest")
+}
+
+# Publishing/build tools do not share Git's ignore policy. In particular,
+# .vscodeignore and .npmignore become the packager's own filter, while Docker
+# always builds from its independent context filter. Only amend files the
+# project already has: their presence is the explicit signal that this root is
+# packaged or sent as a build context.
+publisher_ignore_file_names() {
+    printf '%s\n' .vscodeignore .npmignore .dockerignore
+}
+
+publisher_ignore_add_line() {
+    local file="$1" line="$2"
+    if grep -Fqx -- "$line" "$file" 2>/dev/null; then
+        return 0
+    fi
+    printf '%s\n' "$line" >> "$file"
+    PUBLISH_IGNORE_FILE_CHANGED=1
+}
+
+publisher_ignore_add_path() {
+    local file="$1" path="${2#./}"
+    path="${path%/}"
+    [ -n "$path" ] || return 0
+    publisher_ignore_add_line "$file" "$path"
+    publisher_ignore_add_line "$file" "$path/**"
+}
+
+ensure_manifest_publisher_ignores() {
+    local root="$1" manifest="$2" rel file content_dir target output records kind value
+    content_dir="$(manifest_intelligence_dir "$manifest")"
+    while IFS= read -r rel; do
+        [ -n "$rel" ] || continue
+        file="$root/$rel"
+        [ -f "$file" ] || continue
+        PUBLISH_IGNORE_FILE_CHANGED=0
+        if ! grep -Fqx '# Intelligence development context and generated output' "$file" 2>/dev/null; then
+            if [ -s "$file" ] && [ -n "$(tail -c 1 "$file" 2>/dev/null)" ]; then
+                printf '\n' >> "$file"
+            fi
+            printf '%s\n' '# Intelligence development context and generated output' >> "$file"
+            PUBLISH_IGNORE_FILE_CHANGED=1
+        fi
+        publisher_ignore_add_path "$file" '.intelligence'
+        publisher_ignore_add_line "$file" 'intelligence.yaml'
+        publisher_ignore_add_line "$file" 'intelligence.lock'
+        publisher_ignore_add_path "$file" "$content_dir"
+        while IFS= read -r target; do
+            [ -n "$target" ] || continue
+            [ "$(is_target_enabled "$manifest" "$target")" = "1" ] || continue
+            output="$(get_target_output "$manifest" "$target")"
+            [ -n "$output" ] || output="$(default_target_output "$target")"
+            publisher_ignore_add_path "$file" "$output"
+            records="$(adapter_records_for "$root" "$content_dir" "$target" "$output")" \
+                || die "adapter '$target' has an invalid ownership contract"
+            while IFS=$'\t' read -r kind value; do
+                case "$kind" in
+                    owned|managed|legacy) publisher_ignore_add_path "$file" "$value" ;;
+                esac
+            done <<< "$records"
+        done < <(target_names "$manifest")
+        if [ "$PUBLISH_IGNORE_FILE_CHANGED" -eq 1 ]; then
+            echo "packaging exclusions updated: $rel"
+        fi
+    done < <(publisher_ignore_file_names)
+}
+
+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/"
+    while IFS= read -r target; do
+        [ -n "$target" ] || continue
+        [ "$(is_target_enabled "$manifest" "$target")" = "1" ] || continue
+        output="$(get_target_output "$manifest" "$target")"
+        [ -n "$output" ] || output="$(default_target_output "$target")"
+        records="$(adapter_records_for "$root" "$content_dir" "$target" "$output")" \
+            || return 1
+        while IFS=$'\t' read -r kind value; do
+            case "$kind" in
+                ignore) printf '%s\n' "$value" ;;
+                include) printf '!%s\n' "$value" ;;
+            esac
+        done <<< "$records"
+    done < <(target_names "$manifest")
+}
+
+# Git does not apply ignore rules retroactively to files already in its index.
+# Name each affected path that still exists and print a command which only
+# untracks it. Quarantined legacy paths are already worktree deletions and must
+# not receive a misleading "keep the local copy" instruction.
+report_tracked_managed_ignores() {
+    local root="$1" manifest="$2" patterns tracked path quoted posix_quoted powershell_quoted announced=0
+    git -C "$root" rev-parse --is-inside-work-tree >/dev/null 2>&1 || return 0
+    patterns="$(mktemp -t intelligence-gitignore-XXXXXX)"
+    tracked="$(mktemp -t intelligence-tracked-XXXXXX)"
+    managed_gitignore_patterns "$root" "$manifest" > "$patterns" || {
+        rm -f "$patterns" "$tracked"
+        return 0
+    }
+    git -C "$root" ls-files -z -ci --exclude-from="$patterns" > "$tracked" 2>/dev/null || true
+    rm -f "$patterns"
+    [ -s "$tracked" ] || {
+        rm -f "$tracked"
+        return 0
+    }
+    while IFS= read -r -d '' path; do
+        [ -n "$path" ] || continue
+        [ -e "$root/$path" ] || [ -L "$root/$path" ] || continue
+        if [ "$announced" -eq 0 ]; then
+            echo "  Tracked files still bypass these .gitignore rules. Untrack them without deleting local copies:"
+            announced=1
+        fi
+        if [[ "$path" == *"'"* ]]; then
+            # macOS still ships Bash 3.2; use portable sed rather than newer
+            # parameter-replacement behavior for the embedded quote.
+            posix_quoted="$(printf '%s' "$path" | sed "s/'/'\\\\''/g")"
+            powershell_quoted="$(printf '%s' "$path" | sed "s/'/''/g")"
+            printf "    POSIX:      git rm --cached -- '%s'\n" "$posix_quoted"
+            printf "    PowerShell: git rm --cached -- '%s'\n" "$powershell_quoted"
+        else
+            quoted="'$path'"
+            printf '    git rm --cached -- %s\n' "$quoted"
+        fi
+    done < "$tracked"
+    rm -f "$tracked"
+}

package/cli/lib/manifest.sh

@@ -60,16 +60,38 @@ target_exists() {
     ' "$file"
 }
 
+# target_names <manifest> — declared target keys in manifest order.
+target_names() {
+    local file="$1"
+    [ -f "$file" ] || return 0
+    awk '
+        { sub(/\r$/, "") }
+        /^targets:[[:space:]]*$/ { in_targets = 1; next }
+        in_targets && /^[A-Za-z]/ { in_targets = 0 }
+        in_targets && /^  [a-z][a-z0-9_]*:/ {
+            line = $0
+            sub(/^  /, "", line)
+            sub(/:.*/, "", line)
+            print line
+        }
+    ' "$file"
+}
+
 # target_set_enabled <manifest> <name> <true|false> <default-output>
 # Transactionally update only `enabled`, preserving every other target field
 # and comment. A missing target is added in the compact form used by init.
 target_set_enabled() {
     local file="$1" target="$2" enabled="$3" output="$4"
+    local target_missing=1
     [ -f "$file" ] || die "no such file: $file"
     case "$enabled" in true|false) ;; *) die "internal: invalid target state '$enabled'" ;; esac
+    target_exists "$file" "$target" && target_missing=0
     output="$(_yq_esc "$output")"
-    _qmap_stage "$file" -v target="$target" -v enabled="$enabled" -v output="$output" '
+    _qmap_stage "$file" -v target="$target" -v enabled="$enabled" -v output="$output" -v target_missing="$target_missing" '
         function entry() { return "  " target ": { enabled: " enabled ", output: \"" output "\" }" }
+        function insert_missing_target() {
+            if (in_targets && target_missing && !target_seen) { print entry(); target_seen = 1 }
+        }
         function add_enabled_to_inline(line,    p) {
             p = index(line, "{")
             if (p > 0) return substr(line, 1, p) " enabled: " enabled "," substr(line, p + 1)
@@ -86,8 +108,20 @@ target_set_enabled() {
         }
         { sub(/\r$/, "") }
         /^targets:[[:space:]]*$/ { targets_seen = 1; in_targets = 1; print; next }
+        in_targets && target_missing && target_entry_seen && /^#/ {
+            flush_target()
+            insert_missing_target()
+            print
+            next
+        }
+        in_targets && target_missing && target_entry_seen && !in_target && /^[[:space:]]*$/ {
+            insert_missing_target()
+            print
+            next
+        }
         in_targets && /^[A-Za-z]/ { flush_targets() }
         in_targets && /^  [A-Za-z]/ {
+            target_entry_seen = 1
             flush_target()
             if ($0 ~ "^  " target ":[[:space:]]*") {
                 target_seen = 1

package/cli/lib/onboarding.sh

@@ -0,0 +1,137 @@
+#!/bin/bash
+# Preserve the pre-Intelligence state described by enabled adapter contracts.
+# The snapshot is data-only and explicitly identifies itself as initial
+# onboarding state so recovery skills never mistake it for generated output.
+
+onboarding_source_records() {
+    local root="$1" content_dir="$2" targets="$3" target output
+    for target in $targets; do
+        output="$(default_target_output "$target")"
+        adapter_contract_onboarding_records "$root" "$content_dir" "$target" "$output"
+    done | awk -F '\t' 'NF == 2 && !seen[$1 SUBSEP $2]++'
+}
+
+onboarding_source_paths() {
+    onboarding_source_records "$1" "$2" "$3" \
+        | awk -F '\t' 'NF == 2 && !seen[$2]++ { print $2 }'
+}
+
+onboarding_legacy_paths() {
+    onboarding_source_records "$1" "$2" "$3" \
+        | awk -F '\t' '$1 == "legacy" && !seen[$2]++ { print $2 }'
+}
+
+onboarding_source_count() {
+    local root="$1" content_dir="$2" targets="$3" rel count=0
+    while IFS= read -r rel; do
+        [ -e "$root/$rel" ] || [ -L "$root/$rel" ] || continue
+        count=$((count + 1))
+    done < <(onboarding_source_paths "$root" "$content_dir" "$targets")
+    printf '%s\n' "$count"
+}
+
+preserve_onboarding_sources() {
+    local root="$1" content_dir="$2" targets="$3"
+    local rel src dest backup_rel backup stage target legacy_count=0
+    backup_rel="$content_dir/_backup"
+    backup="$root/$backup_rel"
+    ONBOARDING_BACKUP_COUNT="$(onboarding_source_count "$root" "$content_dir" "$targets")"
+    ONBOARDING_BACKUP_REL=""
+    ONBOARDING_LEGACY_COUNT=0
+    export ONBOARDING_BACKUP_COUNT ONBOARDING_BACKUP_REL ONBOARDING_LEGACY_COUNT
+    [ "$ONBOARDING_BACKUP_COUNT" -gt 0 ] || return 0
+    [ ! -e "$backup" ] || die "onboarding backup already exists at $backup_rel - review or move it before rerunning init"
+
+    mkdir -p "$root/$content_dir"
+    stage="$root/$content_dir/.backup-stage.$$"
+    [ ! -e "$stage" ] || die "temporary onboarding backup path already exists"
+    mkdir -p "$stage"
+
+    {
+        printf '# Intelligence initial-state backup contract v1\n'
+        printf 'state\tinitial-onboarding\n'
+        printf 'source\tpre-intelligence\n'
+        for target in $targets; do printf 'target\t%s\n' "$target"; done
+    } > "$stage/manifest.tsv"
+
+    while IFS= read -r rel; do
+        src="$root/$rel"
+        [ -e "$src" ] || [ -L "$src" ] || continue
+        dest="$stage/$rel"
+        mkdir -p "$(dirname "$dest")"
+        if ! cp -R "$src" "$dest"; then
+            rm -rf "$stage"
+            die "failed to preserve initial AI instruction path '$rel'"
+        fi
+        printf 'path\t%s\n' "$rel" >> "$stage/manifest.tsv"
+    done < <(onboarding_source_paths "$root" "$content_dir" "$targets")
+
+    while IFS= read -r rel; do
+        [ -e "$stage/$rel" ] || [ -L "$stage/$rel" ] || continue
+        printf 'legacy\t%s\n' "$rel" >> "$stage/manifest.tsv"
+        legacy_count=$((legacy_count + 1))
+    done < <(onboarding_legacy_paths "$root" "$content_dir" "$targets")
+
+    # This marker is deliberately outside manifest.tsv: the manifest is the
+    # immutable inventory, while the marker is short-lived transaction state.
+    [ "$legacy_count" -eq 0 ] || : > "$stage/.quarantine-pending"
+
+    mv "$stage" "$backup"
+    ensure_gitignore_header "$root"
+    gitignore_add_line "$root" "$backup_rel/"
+    ONBOARDING_BACKUP_REL="$backup_rel"
+    ONBOARDING_LEGACY_COUNT="$legacy_count"
+    export ONBOARDING_BACKUP_REL ONBOARDING_LEGACY_COUNT
+}
+
+onboarding_quarantine_is_pending() {
+    [ -f "$1/$2/_backup/.quarantine-pending" ]
+}
+
+onboarding_backup_legacy_paths() {
+    local manifest="$1/$2/_backup/manifest.tsv"
+    [ -f "$manifest" ] || return 0
+    awk -F '\t' '$1 == "legacy" && NF == 2 && !seen[$2]++ { print $2 }' "$manifest"
+}
+
+quarantine_onboarding_legacy_sources() {
+    local root="$1" content_dir="$2" rel src backup
+    onboarding_quarantine_is_pending "$root" "$content_dir" || return 0
+    backup="$root/$content_dir/_backup"
+    while IFS= read -r rel; do
+        [ -n "$rel" ] || continue
+        src="$root/$rel"
+        [ -e "$src" ] || [ -L "$src" ] || continue
+        [ -e "$backup/$rel" ] || [ -L "$backup/$rel" ] \
+            || die "initial backup is missing legacy path '$rel'"
+        if [ -d "$src" ] && [ ! -L "$src" ]; then
+            rm -rf -- "$src"
+        else
+            rm -f -- "$src"
+        fi
+    done < <(onboarding_backup_legacy_paths "$root" "$content_dir")
+}
+
+restore_onboarding_legacy_sources() {
+    local root="$1" content_dir="$2" rel src dest backup
+    onboarding_quarantine_is_pending "$root" "$content_dir" || return 0
+    backup="$root/$content_dir/_backup"
+    while IFS= read -r rel; do
+        [ -n "$rel" ] || continue
+        src="$backup/$rel"
+        [ -e "$src" ] || [ -L "$src" ] || continue
+        dest="$root/$rel"
+        if [ -d "$dest" ] && [ ! -L "$dest" ]; then
+            rm -rf -- "$dest"
+        else
+            rm -f -- "$dest"
+        fi
+        mkdir -p "$(dirname "$dest")"
+        cp -R "$src" "$dest" || die "failed to restore legacy onboarding path '$rel'"
+    done < <(onboarding_backup_legacy_paths "$root" "$content_dir")
+}
+
+complete_onboarding_quarantine() {
+    local marker="$1/$2/_backup/.quarantine-pending"
+    [ ! -f "$marker" ] || rm -f -- "$marker"
+}

package/engine/ENGINE_SHA

@@ -1 +1 @@
-af238e67e8a9469edf6d2058e169de52cbeb93af
+e62f3af481c9be3e9782b2f88115758c5cd21669

package/engine/VERSION

@@ -1 +1 @@
-0.11.0
+0.11.1

package/engine/adapters/_template.sh

@@ -7,8 +7,9 @@
 # occurrence with your adapter name before sourcing.
 #
 # Required:
-#   1. Implement sync_to_<name>() and its three content transforms
-#   2. Enable it after implementation: intelligence adapter enable <name>
+#   1. Keep adapter_contract_<name>() accurate for every path this file writes
+#   2. Implement sync_to_<name>() and its three content transforms
+#   3. Enable it after implementation: intelligence adapter enable <name>
 #      This adds the target to intelligence.yaml when it is absent:
 #      targets:
 #        <name>: { enabled: true, output: ".<name>" }
@@ -35,6 +36,22 @@
 # loaded. Keep this template position-independent: after scaffolding it lives
 # under the project's content directory, not beside engine/lib/.
 
+# Ownership contract. Paths are repository-relative and derive from the
+# configured target output passed as $1. `owned` paths are exclusively managed;
+# `managed` paths share a directory with another adapter or hand-authored files.
+# Add `legacy` inputs to the initial backup, `preserve` for settings that must
+# never be replaced, and explicit ignore/include records for Git policy.
+adapter_contract_<name>() {
+    local output="${1%/}"
+    adapter_contract_version 1
+    adapter_contract_owned "$output/rules"
+    adapter_contract_owned "$output/agents"
+    adapter_contract_owned "$output/skills"
+    adapter_contract_ignore "$output/rules/"
+    adapter_contract_ignore "$output/agents/"
+    adapter_contract_ignore "$output/skills/"
+}
+
 # Sync rules for <agent-name>
 # Typical transformations:
 #   - Copy as-is (like Claude)

package/engine/adapters/agents.sh

@@ -223,6 +223,16 @@ agents_md_append_rules_list() {
 }
 
 # Main entry point for AGENTS.md adapter
+adapter_contract_agents() {
+    local output="$1"
+    if [[ "$output" == */ ]] || [[ "$output" != *.md ]]; then
+        output="${output%/}/AGENTS.md"
+    fi
+    adapter_contract_version 1
+    adapter_contract_owned "$output"
+    adapter_contract_legacy "AGENTS.md"
+}
+
 sync_to_agents() {
     local repo_root="$1"
     local config_file="$2"
@@ -231,10 +241,11 @@ sync_to_agents() {
     echo "=== AGENTS.md ==="
 
     # output_dir points at the target file path (e.g., /repo/AGENTS.md).
-    # If it looks like a directory (trailing slash, existing dir, or no .md
-    # extension), append default filename.
+    # If it looks like a directory lexically (trailing slash or no .md
+    # extension), append the default filename. The ownership contract uses the
+    # same rule, so filesystem state cannot make its write-set ambiguous.
     local output_file="$output_dir"
-    if [ -d "$output_file" ] || [[ "$output_file" == */ ]] || [[ "$output_file" != *.md ]]; then
+    if [[ "$output_file" == */ ]] || [[ "$output_file" != *.md ]]; then
         output_file="${output_file%/}/AGENTS.md"
     fi
 

package/engine/adapters/claude.sh

@@ -8,6 +8,21 @@
 
 source "$(dirname "${BASH_SOURCE[0]}")/../lib/common.sh"
 
+adapter_contract_claude() {
+    local output="${1%/}"
+    adapter_contract_version 1
+    adapter_contract_owned "$output/rules"
+    adapter_contract_owned "$output/agents"
+    adapter_contract_owned "$output/skills"
+    adapter_contract_legacy "CLAUDE.md"
+    adapter_contract_legacy "$output/commands"
+    adapter_contract_preserve "$output/settings.json"
+    adapter_contract_preserve "$output/settings.local.json"
+    adapter_contract_ignore "CLAUDE.md"
+    adapter_contract_ignore "$output/*"
+    adapter_contract_include "$output/settings.json"
+}
+
 # Sync rules to Claude format (copy as-is, normalize LF)
 sync_claude_rules() {
     local repo_root="$1"

package/engine/adapters/codex.sh

@@ -13,6 +13,16 @@
 
 source "$(dirname "${BASH_SOURCE[0]}")/../lib/common.sh"
 
+adapter_contract_codex() {
+    local output="${1%/}"
+    adapter_contract_version 1
+    adapter_contract_requires agents
+    adapter_contract_managed ".agents/skills"
+    adapter_contract_owned "$output/agents"
+    adapter_contract_ignore ".agents/skills/"
+    adapter_contract_ignore "$output/agents/"
+}
+
 # Sync skills to Codex format (.agents/skills/{name}/SKILL.md)
 sync_codex_skills() {
     local repo_root="$1"
@@ -111,7 +121,7 @@ sync_to_codex() {
     sync_codex_skills "$repo_root" "$config_file" "$skills_dir"
 
     # Agents -> .codex/agents/
-    local agents_dir="$repo_root/.codex/agents"
+    local agents_dir="$output_dir/agents"
     rm -rf "$agents_dir"
     mkdir -p "$agents_dir"
     sync_codex_agents "$repo_root" "$config_file" "$agents_dir"

package/engine/adapters/copilot.sh

@@ -14,6 +14,17 @@
 
 source "$(dirname "${BASH_SOURCE[0]}")/../lib/common.sh"
 
+adapter_contract_copilot() {
+    local output="${1%/}"
+    adapter_contract_version 1
+    adapter_contract_requires agents
+    adapter_contract_owned "$output/instructions"
+    adapter_contract_owned "$output/prompts"
+    adapter_contract_owned "$output/agents"
+    adapter_contract_owned "$output/skills"
+    adapter_contract_legacy "$output/copilot-instructions.md"
+}
+
 # Sync rules to Copilot format. Only path-scoped rules are emitted —
 # always-on rules live in AGENTS.md (read by Copilot natively).
 sync_copilot_rules() {

package/engine/adapters/cursor.sh

@@ -13,6 +13,21 @@
 
 source "$(dirname "${BASH_SOURCE[0]}")/../lib/common.sh"
 
+adapter_contract_cursor() {
+    local output="${1%/}"
+    adapter_contract_version 1
+    adapter_contract_requires agents
+    adapter_contract_owned "$output/rules"
+    adapter_contract_owned "$output/agents"
+    adapter_contract_owned "$output/skills"
+    adapter_contract_legacy ".cursorrules"
+    adapter_contract_legacy "$output/commands"
+    adapter_contract_preserve "$output/settings.json"
+    adapter_contract_ignore ".cursorrules"
+    adapter_contract_ignore "$output/*"
+    adapter_contract_include "$output/settings.json"
+}
+
 # Sync rules to Cursor format (.md -> .mdc, paths -> globs)
 sync_cursor_rules() {
     local repo_root="$1"

package/engine/adapters/opencode.sh

@@ -26,10 +26,21 @@
 
 source "$(dirname "${BASH_SOURCE[0]}")/../lib/common.sh"
 
+adapter_contract_opencode() {
+    local output="${1%/}"
+    adapter_contract_version 1
+    adapter_contract_requires agents
+    adapter_contract_managed ".agents/skills"
+    adapter_contract_owned "$output/agents"
+    adapter_contract_managed "$output/commands"
+    adapter_contract_ignore ".agents/skills/"
+    adapter_contract_ignore "$output/agents/"
+}
+
 # Strip frontmatter, return body only.
 # Direct call to the shared `strip_frontmatter` helper in lib/common.sh —
-# duplicating the awk block here would violate the "all parsing in common.sh"
-# convention (see CLAUDE.md / packages/sync/references/conventions.md).
+# duplicating the awk block here would fork frontmatter parsing, which the
+# convention keeps in one place.
 
 sync_opencode_skills() {
     local repo_root="$1"

package/engine/adapters/pi.sh

@@ -15,6 +15,20 @@
 
 source "$(dirname "${BASH_SOURCE[0]}")/../lib/common.sh"
 
+adapter_contract_pi() {
+    local output="${1%/}"
+    adapter_contract_version 1
+    adapter_contract_requires agents
+    adapter_contract_managed ".agents/skills"
+    adapter_contract_owned "$output/intelligence-sync"
+    adapter_contract_managed "$output/extensions"
+    adapter_contract_managed "$output/prompts"
+    adapter_contract_ignore ".agents/skills/"
+    adapter_contract_ignore "$output/intelligence-sync/"
+    adapter_contract_ignore "$output/extensions/intelligence-sync-rules.ts"
+    adapter_contract_ignore "$output/prompts/intelligence-agent-*.md"
+}
+
 pi_ts_escape() {
     local s="$1"
     s="${s//\\/\\\\}"
@@ -193,13 +207,12 @@ sync_pi_agents() {
 
             access_note=""
             if [ "$access" = "readonly" ]; then
-                access_note=$(cat <<'EOF'
-## Access Mode
+                # Bash 3.2 (the macOS system shell) misparses an apostrophe in
+                # a quoted heredoc nested inside command substitution.
+                access_note="## Access Mode
 
 Default to read-only analysis. Do not change files or run mutating commands unless the user explicitly asks you to override this agent's normal restriction.
-
-EOF
-)
+"
             fi
 
             {