@ainova-systems/intelligence 0.11.3 → 0.11.5

package/cli/commands/sync.sh

@@ -57,9 +57,10 @@ if [ "$compact" -eq 0 ]; then
     exit $?
 fi
 
-# Compact mode is intentionally quiet only on success. Buffering the complete
-# combined stream means a failure still returns every diagnostic emitted by
-# lifecycle preflight, locked restore or the engine, together with its real rc.
+# Compact mode keeps actionable one-line warnings on success. Buffering the
+# complete combined stream means a failure still returns every diagnostic
+# emitted by lifecycle preflight, locked restore or the engine, together with
+# its real rc.
 compact_output="$(mktemp -t intelligence-sync-XXXXXX)"
 trap 'rm -f "$compact_output"' EXIT
 rc=0
@@ -76,5 +77,6 @@ if [ -z "$status_line" ] || [ -z "$done_line" ]; then
     echo "ERROR: sync succeeded without its final status contract" >&2
     exit 1
 fi
+grep -E '^(WARNING:|CONTEXT:)' "$compact_output" || true
 echo "$status_line"
 echo "$done_line"

package/cli/intelligence

@@ -47,7 +47,7 @@ Usage: intelligence <command> [args]
     --targets a,b --dir name --bare --no-sync   New-project options
     --force               Accept a dirty worktree during legacy project conversion
   sync [adapter] [--compact]  Restore locked content, then render enabled adapters
-    --compact            On success show only final status; on failure show diagnostics
+    --compact            On success show context, warnings and final status; on failure show diagnostics
   update [@scope/name]    Show an update plan; ask before applying it
     --preview             Show the plan without asking or writing
     --apply               Apply the plan without asking

package/engine/ENGINE_SHA

@@ -1 +1 @@
-81c1719ad7eb845aa0e48ebae0fcf069afb105bd
+bd688bcdb5443d808a72ed4e63805a65255a7d02

package/engine/VERSION

@@ -1 +1 @@
-0.11.3
+0.11.5

package/engine/adapters/agents.sh

@@ -10,6 +10,9 @@
 # Unlike other adapters, the output is a single committed markdown file
 # meant to be read by both humans and LLMs. It must never be hand-edited —
 # every sync regenerates it from scratch.
+#
+# 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"
 
@@ -55,30 +58,26 @@ agents_md_append_agents_table() {
     local rows=""
     local count=0
 
-    while IFS= read -r src; do
-        [ -z "$src" ] && continue
-        local dir
-        dir="$(resolve_source_dir "$repo_root" "$src")"
-        [ -d "$dir" ] || continue
-        # Byte-order (LC_ALL=C) sort so generated output is identical across
-        # platforms — bash glob order follows LC_COLLATE, which differs between
-        # Linux CI (UTF-8, ignores `-`) and Git Bash (C, byte order).
-        while IFS= read -r f; do
-            [ -f "$f" ] || continue
-            local name rel tier access desc
-            name="$(basename "$f" .md)"
-            rel="$(repo_rel_link "$repo_root" "$f")"
-            tier=$(get_frontmatter_value "tier" "$f")
-            access=$(get_frontmatter_value "access" "$f")
-            desc=$(get_frontmatter_value "description" "$f")
-            if [ -n "$rel" ]; then
-                rows+="| [$name]($rel) | ${tier:--} | ${access:--} | ${desc:--} |"$'\n'
+    local f
+    local -a files=()
+    while IFS= read -r f; do
+        [ -n "$f" ] && files+=("$f")
+    done < <(source_artifact_files "$repo_root" "$config_file" "agents")
+
+    if [ "${#files[@]}" -gt 0 ]; then
+        local path tier access desc name
+        while IFS=$'\x1f' read -r path tier access desc; do
+            [ -n "$path" ] || continue
+            name="${path##*/}"; name="${name%.md}"
+            repo_rel_link_var "$repo_root" "$path"
+            if [ -n "$IS_REPO_REL" ]; then
+                rows+="| [$name]($IS_REPO_REL) | ${tier:--} | ${access:--} | ${desc:--} |"$'\n'
             else
                 rows+="| $name | ${tier:--} | ${access:--} | ${desc:--} |"$'\n'
             fi
             count=$((count + 1))
-        done < <(find "$dir" -maxdepth 1 -type f -name '*.md' -print | LC_ALL=C sort)
-    done < <(read_yaml_list "$config_file" "agents")
+        done < <(frontmatter_index "tier,access,description" "${files[@]}")
+    fi
 
     [ "$count" -eq 0 ] && return 0
 
@@ -102,31 +101,26 @@ agents_md_append_skills_table() {
     local rows=""
     local count=0
 
-    while IFS= read -r src; do
-        [ -z "$src" ] && continue
-        local dir
-        dir="$(resolve_source_dir "$repo_root" "$src")"
-        [ -d "$dir" ] || continue
-        # Byte-order (LC_ALL=C) sort so generated output is identical across
-        # platforms — see the note in agents_md_append_agents_table.
-        while IFS= read -r skill_dir; do
-            [ -d "$skill_dir" ] || continue
-            local dirname
-            dirname="$(basename "$skill_dir")"
-            case "$dirname" in _*) continue ;; esac
-            local skill_file="${skill_dir%/}/SKILL.md"
-            [ -f "$skill_file" ] || continue
-            local rel desc
-            rel="$(repo_rel_link "$repo_root" "$skill_file")"
-            desc=$(get_frontmatter_value "description" "$skill_file")
-            if [ -n "$rel" ]; then
-                rows+="| [$dirname]($rel) | ${desc:--} |"$'\n'
+    local f dirname
+    local -a skill_files=()
+    while IFS= read -r f; do
+        [ -n "$f" ] && skill_files+=("$f")
+    done < <(source_artifact_files "$repo_root" "$config_file" "skills")
+
+    if [ "${#skill_files[@]}" -gt 0 ]; then
+        local path desc
+        while IFS=$'\x1f' read -r path desc; do
+            [ -n "$path" ] || continue
+            dirname="${path%/SKILL.md}"; dirname="${dirname##*/}"
+            repo_rel_link_var "$repo_root" "$path"
+            if [ -n "$IS_REPO_REL" ]; then
+                rows+="| [$dirname]($IS_REPO_REL) | ${desc:--} |"$'\n'
             else
                 rows+="| $dirname | ${desc:--} |"$'\n'
             fi
             count=$((count + 1))
-        done < <(find "$dir" -mindepth 1 -maxdepth 1 -type d -print | LC_ALL=C sort)
-    done < <(read_yaml_list "$config_file" "skills")
+        done < <(frontmatter_index "description" "${skill_files[@]}")
+    fi
 
     [ "$count" -eq 0 ] && return 0
 
@@ -151,33 +145,32 @@ agents_md_append_rules_list() {
     local count=0
     local global_rule_files=()
 
-    while IFS= read -r src; do
-        [ -z "$src" ] && continue
-        local dir
-        dir="$(resolve_source_dir "$repo_root" "$src")"
-        [ -d "$dir" ] || continue
-        # Byte-order (LC_ALL=C) sort so generated output — and the inline order
-        # of always-on rules below — is identical across platforms. See the
-        # note in agents_md_append_agents_table.
-        while IFS= read -r f; do
-            [ -f "$f" ] || continue
-            local name rel scope
-            name="$(basename "$f" .md)"
-            rel="$(repo_rel_link "$repo_root" "$f")"
+    local f
+    local -a files=()
+    while IFS= read -r f; do
+        [ -n "$f" ] && files+=("$f")
+    done < <(source_artifact_files "$repo_root" "$config_file" "rules")
+
+    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 [ "$(has_paths "$f")" != "0" ]; then
+            if [ "$hp" != "0" ]; then
                 scope="scoped"
             else
-                global_rule_files+=("$f")
+                global_rule_files+=("$path")
             fi
-            if [ -n "$rel" ]; then
-                lines+="- [$name]($rel) ($scope)"$'\n'
+            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 < <(find "$dir" -maxdepth 1 -type f -name '*.md' -print | LC_ALL=C sort)
-    done < <(read_yaml_list "$config_file" "rules")
+        done < <(frontmatter_index "paths#" "${files[@]}")
+    fi
 
     [ "$count" -eq 0 ] && return 0
 
@@ -206,28 +199,25 @@ agents_md_append_rules_list() {
             echo "<!-- Inlined from always-on rules in $content_rel/rules/ -->"
             echo ""
         } >> "$output"
-        local rf
-        for rf in "${global_rule_files[@]}"; do
-            awk '
-                BEGIN { 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 }
-            ' "$rf" >> "$output"
-            echo "" >> "$output"
-        done
+        # 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"
         echo "  rules: ${#global_rule_files[@]} global rule(s) inlined"
     fi
 }
 
 # Main entry point for AGENTS.md adapter
 adapter_contract_agents() {
-    local output="$1"
-    if [[ "$output" == */ ]] || [[ "$output" != *.md ]]; then
-        output="${output%/}/AGENTS.md"
-    fi
+    local output
+    output="$(agents_output_path "$1")"
     adapter_contract_version 1
     adapter_contract_owned "$output"
     adapter_contract_legacy "AGENTS.md"
@@ -244,10 +234,8 @@ sync_to_agents() {
     # 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 [[ "$output_file" == */ ]] || [[ "$output_file" != *.md ]]; then
-        output_file="${output_file%/}/AGENTS.md"
-    fi
+    local output_file
+    output_file="$(agents_output_path "$output_dir")"
 
     mkdir -p "$(dirname "$output_file")"
 

package/engine/adapters/claude.sh

@@ -5,6 +5,9 @@
 # Rules: copy as-is (paths: frontmatter preserved)
 # Skills: copy skill directories in full (SKILL.md + bundled resources)
 # Agents: tier -> model, access -> tools/disallowedTools
+#
+# 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"
 
@@ -29,18 +32,24 @@ sync_claude_rules() {
     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
-        dir="$(resolve_source_dir "$repo_root" "$src")"
+        local dir="$repo_root/$src"
         [ -d "$dir" ] || continue
         for f in "$dir"/*.md; do
             [ -f "$f" ] || continue
-            cp "$f" "$output_dir/rules/"
-            finalize_output_file "$output_dir/rules/$(basename "$f")"
-            echo "  rule: $(basename "$f")"
+            files+=("$f")
         done
-    done < <(read_yaml_list "$config_file" "rules")
+    done <<< "$list"
+    [ "${#files[@]}" -gt 0 ] || return 0
+    finalize_copy_files "$output_dir/rules" "${files[@]}"
+    for f in "${files[@]}"; do
+        echo "  rule: ${f##*/}"
+    done
 }
 
 # Sync skills to Claude format (copy skill directories in full)
@@ -49,75 +58,98 @@ sync_claude_skills() {
     local config_file="$2"
     local output_dir="$3"
 
+    local src d skill_name
+    local -a skill_dirs=()
+    load_yaml_list "$config_file" "skills"
+    local list="$IS_YAML_LIST"
     while IFS= read -r src; do
         [ -z "$src" ] && continue
-        local dir
-        dir="$(resolve_source_dir "$repo_root" "$src")"
+        local dir="$repo_root/$src"
         [ -d "$dir" ] || continue
         for d in "$dir"/*/; do
             [ -d "$d" ] || continue
-            local skill_name
-            skill_name="$(basename "$d")"
             [ -f "$d/SKILL.md" ] || continue
-            copy_skill_bundle "$d" "$output_dir/skills/$skill_name"
-            echo "  skill: $skill_name"
+            skill_dirs+=("$d")
         done
-    done < <(read_yaml_list "$config_file" "skills")
-}
-
-# Sync a single agent file to Claude format
-sync_claude_agent() {
-    local src="$1"
-    local config_file="$2"
-    local output_dir="$3"
-    local name
-    name="$(basename "$src")"
-
-    local tier access
-    tier=$(get_frontmatter_value "tier" "$src")
-    access=$(get_frontmatter_value "access" "$src")
-
-    local model tools extra
-    model=$(get_model "$config_file" "claude" "$tier")
-    tools=$(map_access_to_claude_tools "$access")
-    extra=$(map_access_to_claude_disallowed "$access")
-
-    # Transform: remove tier/access, inject tools/model/disallowedTools before closing ---
-    awk -v model="$model" -v tools="$tools" -v extra="$extra" '
-        BEGIN { count=0 }
-        /^tier:/  { next }
-        /^access:/ { next }
-        {
-            sub(/\r$/, "")
-        }
-        /^---$/ { count++ }
-        count==2 && /^---$/ {
-            if (tools != "") print "tools: " tools
-            if (extra != "") print "disallowedTools: " extra
-            print "model: " model
-        }
-        { print }
-    ' "$src" > "$output_dir/agents/$name"
-    finalize_output_file "$output_dir/agents/$name"
-    echo "  agent: $name (tier=$tier -> model=$model, access=$access)"
+    done <<< "$list"
+    [ "${#skill_dirs[@]}" -gt 0 ] || return 0
+    copy_skill_bundle_dirs "$output_dir/skills" "${skill_dirs[@]}"
+    for d in "${skill_dirs[@]}"; do
+        skill_name="${d%/}"
+        echo "  skill: ${skill_name##*/}"
+    done
 }
 
-# Sync all agents to Claude format
+# Sync all agents to Claude format: one frontmatter pass resolves
+# tier/access for every file, one transform pass writes every output.
 sync_claude_agents() {
     local repo_root="$1"
     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
-        dir="$(resolve_source_dir "$repo_root" "$src")"
+        local dir="$repo_root/$src"
         [ -d "$dir" ] || continue
         for f in "$dir"/*.md; do
             [ -f "$f" ] || continue
-            sync_claude_agent "$f" "$config_file" "$output_dir"
+            files+=("$f")
         done
-    done < <(read_yaml_list "$config_file" "agents")
+    done <<< "$list"
+    [ "${#files[@]}" -gt 0 ] || return 0
+
+    load_model_tiers "$config_file" "claude"
+
+    local path tier access spec="" report=""
+    while IFS=$'\x1f' read -r path tier access; do
+        [ -n "$path" ] || continue
+        resolve_model_var "$tier"
+        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"$'\n'
+        report+="  agent: ${path##*/} (tier=$tier -> model=$IS_MODEL, access=$access)"$'\n'
+    done < <(frontmatter_index "tier,access" "${files[@]}")
+
+    # The transform used to run per file with the values injected via -v;
+    # the batched form carries them per file through the environment (awk -v
+    # would reprocess backslash escapes).
+    is_fin_awk_vars
+    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")
+            for (i = 1; i <= n; i++) {
+                if (recs[i] == "") continue
+                split(recs[i], f, US)
+                MODEL[f[1]] = f[2]; TOOLS[f[1]] = f[3]; EXTRA[f[1]] = f[4]
+            }
+        }
+        FNR == 1 {
+            if (out != "") close(out)
+            out = dst "/" base_name(FILENAME)
+            count = 0
+        }
+        /^tier:/  { next }
+        /^access:/ { next }
+        { sub(/\r$/, "") }
+        /^---$/ { count++ }
+        count == 2 && /^---$/ {
+            if (TOOLS[FILENAME] != "") print fin_line("tools: " TOOLS[FILENAME]) > out
+            if (EXTRA[FILENAME] != "") print fin_line("disallowedTools: " EXTRA[FILENAME]) > out
+            print fin_line("model: " MODEL[FILENAME]) > out
+        }
+        { print fin_line($0) > out }
+    ' "${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##*/}"
+    done
+    printf '%s' "$report"
 }
 
 # Main entry point for Claude adapter
@@ -133,9 +165,7 @@ sync_to_claude() {
     # 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 | while read -r d; do
-            rm -rf "$d"
-        done
+        find "$output_dir/skills" -mindepth 1 -maxdepth 1 -type d -exec rm -rf {} +
     fi
     mkdir -p "$output_dir/rules" "$output_dir/skills" "$output_dir/agents"
 

package/engine/adapters/codex.sh

@@ -10,6 +10,9 @@
 #   reads from $REPO_ROOT/.agents/skills exclusively per official docs)
 # Agents: -> .codex/agents/{name}.toml (name, description, model,
 #   model_reasoning_effort, sandbox_mode, developer_instructions)
+#
+# 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"
 
@@ -23,6 +26,44 @@ adapter_contract_codex() {
     adapter_contract_ignore "$output/agents/"
 }
 
+# Codex-specific guard for its documented project-instruction byte budget.
+# A personal/project Codex config may already raise the actual limit, so the
+# manifest exposes one warning setting: false disables it, while a positive
+# byte count matches an effective limit the adapter cannot discover itself.
+codex_warn_project_doc_size() {
+    local repo_root="$1"
+    local config_file="$2"
+    local warning_setting warning_limit=32768
+    warning_setting="$(get_target_field "$config_file" "codex" "warn_project_doc_limit")"
+    case "$warning_setting" in
+        ''|true) ;;
+        false) return 0 ;;
+        *[!0-9]*|0|0*)
+            echo "ERROR: targets.codex.warn_project_doc_limit must be true, false, or a positive byte count without leading zeros." >&2
+            return 1
+            ;;
+        *) warning_limit="$warning_setting" ;;
+    esac
+
+    target_output_var "$config_file" "agents"
+    local output
+    output="$(agents_output_path "${IS_TGT_OUTPUT:-.agents}")"
+
+    local output_file="$repo_root/$output"
+    [ -f "$output_file" ] || return 0
+
+    local bytes
+    bytes="$(context_files_bytes "$output_file")"
+    [ "$bytes" -gt "$warning_limit" ] || return 0
+
+    local recommended="$warning_limit"
+    while [ "$recommended" -lt "$bytes" ]; do
+        recommended=$((recommended * 2))
+    done
+
+    echo "WARNING: Codex may truncate $output: $bytes bytes exceeds the $warning_limit-byte Intelligence warning threshold; set project_doc_max_bytes = $recommended in Codex config.toml and restart Codex, reduce/split the instructions, set targets.codex.warn_project_doc_limit to the effective byte limit, or set it to false to disable this warning."
+}
+
 # Sync skills to Codex format (.agents/skills/{name}/SKILL.md)
 sync_codex_skills() {
     local repo_root="$1"
@@ -38,24 +79,29 @@ sync_codex_agents() {
     local config_file="$2"
     local output_dir="$3"
 
-    local count=0
+    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
-        dir="$(resolve_source_dir "$repo_root" "$src")"
+        local dir="$repo_root/$src"
         [ -d "$dir" ] || continue
         for f in "$dir"/*.md; do
             [ -f "$f" ] || continue
-            local name
-            name="$(basename "$f" .md)"
-
-            local tier access description
-            tier=$(get_frontmatter_value "tier" "$f")
-            access=$(get_frontmatter_value "access" "$f")
-            description=$(get_frontmatter_value "description" "$f")
+            files+=("$f")
+        done
+    done <<< "$list"
 
-            local model effort sandbox
-            model=$(get_model "$config_file" "codex" "$tier")
+    local count=0
+    if [ "${#files[@]}" -gt 0 ]; then
+        load_model_tiers "$config_file" "codex"
+
+        local path tier access description name effort sandbox 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"
             case "$tier" in
                 heavy)    effort="high" ;;
                 standard) effort="medium" ;;
@@ -66,43 +112,27 @@ sync_codex_agents() {
                 readonly) sandbox="read-only" ;;
                 *)        sandbox="workspace-write" ;;
             esac
-
-            local body
-            body=$(awk '
-                BEGIN { in_fm=0; past_fm=0 }
-                { sub(/\r$/, "") }
-                /^---$/ {
-                    if (!past_fm) { in_fm = !in_fm; if (!in_fm) { past_fm=1 }; next }
-                }
-                past_fm { print }
-            ' "$f")
-
-            # Escape backslashes used in Markdown paths, then neutralize any
-            # closing TOML triple-quote sequence in the agent body.
-            local body_safe
-            body_safe="${body//\\/\\\\}"
-            body_safe="${body_safe//\"\"\"/\"\"\\\"}"
-
             local name_escaped description_escaped
-            name_escaped=$(toml_escape "$name")
-            description_escaped=$(toml_escape "$description")
-
-            {
-                echo "name = \"$name_escaped\""
-                echo "description = \"$description_escaped\""
-                echo "model = \"$model\""
-                echo "model_reasoning_effort = \"$effort\""
-                echo "sandbox_mode = \"$sandbox\""
-                echo ""
-                echo "developer_instructions = \"\"\""
-                echo "$body_safe"
-                echo "\"\"\""
-            } > "$output_dir/$name.toml"
-            finalize_output_file "$output_dir/$name.toml"
+            toml_escape_var "$name";        name_escaped="$IS_TOML_ESCAPED"
+            toml_escape_var "$description"; description_escaped="$IS_TOML_ESCAPED"
+
+            local header
+            header="${LS}name = \"$name_escaped\""
+            header+="${LS}description = \"$description_escaped\""
+            header+="${LS}model = \"$IS_MODEL\""
+            header+="${LS}model_reasoning_effort = \"$effort\""
+            header+="${LS}sandbox_mode = \"$sandbox\""
+            header+="${LS}"
+            header+="${LS}developer_instructions = \"\"\""
+
+            spec+="$path"$'\x1f'"$output_dir/$name.toml"$'\x1f'"fence"$'\x1f'"1"$'\x1f'"toml"$'\x1f'"$header"$'\x1f'"${LS}\"\"\""$'\n'
+            report+="  agent: $name.toml"$'\n'
             count=$((count + 1))
-            echo "  agent: $name.toml"
-        done
-    done < <(read_yaml_list "$config_file" "agents")
+        done < <(frontmatter_index "tier,access,description" "${files[@]}")
+
+        emit_wrapped_bodies "$spec"
+        printf '%s' "$report"
+    fi
 
     echo "  -> Agents: $count"
 }
@@ -125,4 +155,6 @@ sync_to_codex() {
     rm -rf "$agents_dir"
     mkdir -p "$agents_dir"
     sync_codex_agents "$repo_root" "$config_file" "$agents_dir"
+
+    codex_warn_project_doc_size "$repo_root" "$config_file"
 }