@prmichaelsen/remember-mcp 3.15.4 → 3.15.5

package/agent/scripts/acp.package-install.sh

@@ -19,10 +19,12 @@ INSTALL_PATTERNS=false
 INSTALL_COMMANDS=false
 INSTALL_DESIGNS=false
 INSTALL_FILES=false
+INSTALL_INDICES=false
 PATTERN_FILES=()
 COMMAND_FILES=()
 DESIGN_FILES=()
 FILE_FILES=()
+INDEX_FILES=()
 LIST_ONLY=false
 GLOBAL_INSTALL=false
 INSTALL_EXPERIMENTAL=false
@@ -49,7 +51,7 @@ while [[ $# -gt 0 ]]; do
         --patterns)
             INSTALL_PATTERNS=true
             shift
-            while [[ $# -gt 0 && ! $1 =~ ^-- ]]; do
+            while [[ $# -gt 0 && ! $1 =~ ^- ]]; do
                 PATTERN_FILES+=("$1")
                 shift
             done
@@ -57,7 +59,7 @@ while [[ $# -gt 0 ]]; do
         --commands)
             INSTALL_COMMANDS=true
             shift
-            while [[ $# -gt 0 && ! $1 =~ ^-- ]]; do
+            while [[ $# -gt 0 && ! $1 =~ ^- ]]; do
                 COMMAND_FILES+=("$1")
                 shift
             done
@@ -65,7 +67,7 @@ while [[ $# -gt 0 ]]; do
         --designs)
             INSTALL_DESIGNS=true
             shift
-            while [[ $# -gt 0 && ! $1 =~ ^-- ]]; do
+            while [[ $# -gt 0 && ! $1 =~ ^- ]]; do
                 DESIGN_FILES+=("$1")
                 shift
             done
@@ -73,11 +75,19 @@ while [[ $# -gt 0 ]]; do
         --files)
             INSTALL_FILES=true
             shift
-            while [[ $# -gt 0 && ! $1 =~ ^-- ]]; do
+            while [[ $# -gt 0 && ! $1 =~ ^- ]]; do
                 FILE_FILES+=("$1")
                 shift
             done
             ;;
+        --indices)
+            INSTALL_INDICES=true
+            shift
+            while [[ $# -gt 0 && ! $1 =~ ^- ]]; do
+                INDEX_FILES+=("$1")
+                shift
+            done
+            ;;
         --list)
             LIST_ONLY=true
             shift
@@ -98,11 +108,12 @@ if [ -z "$REPO_URL" ]; then
 fi
 
 # Default: install everything if no selective flags specified
-if [[ "$INSTALL_PATTERNS" == false && "$INSTALL_COMMANDS" == false && "$INSTALL_DESIGNS" == false && "$INSTALL_FILES" == false ]]; then
+if [[ "$INSTALL_PATTERNS" == false && "$INSTALL_COMMANDS" == false && "$INSTALL_DESIGNS" == false && "$INSTALL_FILES" == false && "$INSTALL_INDICES" == false ]]; then
     INSTALL_PATTERNS=true
     INSTALL_COMMANDS=true
     INSTALL_DESIGNS=true
     INSTALL_FILES=true
+    INSTALL_INDICES=true
 fi
 
 echo "${BLUE}📦 ACP Package Installer (Optimized)${NC}"
@@ -122,9 +133,15 @@ TEMP_DIR=$(mktemp -d)
 trap "rm -rf $TEMP_DIR" EXIT
 
 echo "Cloning repository..."
-if ! git clone --depth 1 "$REPO_URL" "$TEMP_DIR" &>/dev/null; then
+if [ -d "$REPO_URL" ]; then
+    # Local directory - copy contents instead of clone
+    cp -r "$REPO_URL"/* "$TEMP_DIR/" 2>/dev/null || cp -r "$REPO_URL"/.[!.]* "$TEMP_DIR/" 2>/dev/null || true
+    echo "${GREEN}✓${NC} Local directory copied"
+elif ! git clone --depth 1 "$REPO_URL" "$TEMP_DIR" &>/dev/null; then
     echo "${RED}Error: Failed to clone repository${NC}"
     exit 1
+else
+    echo "${GREEN}✓${NC} Repository cloned"
 fi
 
 echo "${GREEN}✓${NC} Repository cloned"
@@ -160,12 +177,6 @@ COMMIT_HASH=$(get_commit_hash "$TEMP_DIR")
 info "Commit: $COMMIT_HASH"
 echo ""
 
-# List mode (unchanged)
-if [ "$LIST_ONLY" = true ]; then
-    # ... (same as original)
-    exit 0
-fi
-
 # Validate dependencies
 if [ -f "$TEMP_DIR/package.yaml" ]; then
     if ! validate_project_dependencies "$TEMP_DIR/package.yaml"; then
@@ -181,6 +192,7 @@ INSTALL_DIRS=()
 [ "$INSTALL_DESIGNS" = true ] && INSTALL_DIRS+=("design")
 [ "$INSTALL_COMMANDS" = true ] && INSTALL_DIRS+=("scripts")
 [ "$INSTALL_FILES" = true ] && INSTALL_DIRS+=("files")
+[ "$INSTALL_INDICES" = true ] && INSTALL_DIRS+=("index")
 
 # Mapping from dir names to manifest keys (dir → manifest key)
 declare -A MANIFEST_KEYS=(
@@ -189,6 +201,7 @@ declare -A MANIFEST_KEYS=(
     ["design"]="designs"
     ["scripts"]="scripts"
     ["files"]="files"
+    ["index"]="indices"
 )
 
 # ============================================================================
@@ -199,9 +212,18 @@ declare -A MANIFEST_KEYS=(
 declare -A ALL_FILES_TO_INSTALL  # Key: dir, Value: space-separated file paths
 declare -A FILE_METADATA  # Key: "dir/filename", Value: "version|experimental"
 
+# Track installed commands for script-command binding resolution
+INSTALLED_COMMANDS=()
+
 INSTALLED_COUNT=0
 SKIPPED_COUNT=0
 
+# Template file metadata (populated during scanning when contents.files exists)
+declare -A FILE_TARGETS    # Key: "files/relpath", Value: target directory path
+declare -A FILE_VARS       # Key: "files/relpath", Value: "VAR1,VAR2,..."
+declare -A COLLECTED_VARS  # Key: "VARNAME", Value: user-provided value
+HAS_FILE_METADATA=false
+
 echo "Scanning for installable files..."
 echo ""
 
@@ -226,6 +248,7 @@ for dir in "${INSTALL_DIRS[@]}"; do
         design) FILE_LIST=DESIGN_FILES ;;
         scripts) FILE_LIST=COMMAND_FILES ;;
         files) FILE_LIST=FILE_FILES ;;
+        index) FILE_LIST=INDEX_FILES ;;
     esac
 
     # Collect files
@@ -242,6 +265,31 @@ for dir in "${INSTALL_DIRS[@]}"; do
             file_path="$SOURCE_DIR/$file_name"
             if [ -f "$file_path" ]; then
                 FILES_TO_PROCESS+=("$file_path")
+
+                # For selective files, also collect metadata from package.yaml
+                if [ "$dir" = "files" ] && [ -f "$TEMP_DIR/package.yaml" ]; then
+                    _sel_idx=0
+                    while true; do
+                        _sel_name=$(yaml_query ".contents.files[$_sel_idx].name" 2>/dev/null || echo "")
+                        [ -z "$_sel_name" ] || [ "$_sel_name" = "null" ] && break
+                        if [ "$_sel_name" = "$file_name" ]; then
+                            HAS_FILE_METADATA=true
+                            _sel_target=$(yaml_query ".contents.files[$_sel_idx].target" 2>/dev/null || echo "")
+                            [ -n "$_sel_target" ] && [ "$_sel_target" != "null" ] && FILE_TARGETS["files/$file_name"]="$_sel_target"
+                            _sel_var_idx=0
+                            _sel_vars=""
+                            while true; do
+                                _sel_var=$(yaml_query ".contents.files[$_sel_idx].variables[$_sel_var_idx]" 2>/dev/null || echo "")
+                                [ -z "$_sel_var" ] || [ "$_sel_var" = "null" ] && break
+                                [ -n "$_sel_vars" ] && _sel_vars="$_sel_vars,$_sel_var" || _sel_vars="$_sel_var"
+                                _sel_var_idx=$((_sel_var_idx + 1))
+                            done
+                            [ -n "$_sel_vars" ] && FILE_VARS["files/$file_name"]="$_sel_vars"
+                            break
+                        fi
+                        _sel_idx=$((_sel_idx + 1))
+                    done
+                fi
             else
                 echo "${YELLOW}⚠${NC}  File not found in $dir/: $file_name"
                 SKIPPED_COUNT=$((SKIPPED_COUNT + 1))
@@ -250,14 +298,54 @@ for dir in "${INSTALL_DIRS[@]}"; do
     else
         # Install all files
         if [ "$dir" = "files" ]; then
-            # files/ directory: recursive scan, all file types
-            while IFS= read -r file; do
-                [ -n "$file" ] && FILES_TO_PROCESS+=("$file")
-            done < <(find "$SOURCE_DIR" -type f)
+            # Check if package.yaml has contents.files metadata
+            _first_file=$(yaml_query ".contents.files[0].name" 2>/dev/null || echo "")
+            if [ -f "$TEMP_DIR/package.yaml" ] && [ -n "$_first_file" ] && [ "$_first_file" != "null" ]; then
+                # Use package.yaml contents.files as source of truth
+                HAS_FILE_METADATA=true
+                _file_idx=0
+                while true; do
+                    _fname=$(yaml_query ".contents.files[$_file_idx].name" 2>/dev/null || echo "")
+                    [ -z "$_fname" ] || [ "$_fname" = "null" ] && break
+
+                    if [ -f "$SOURCE_DIR/$_fname" ]; then
+                        FILES_TO_PROCESS+=("$SOURCE_DIR/$_fname")
+
+                        # Store target metadata
+                        _target=$(yaml_query ".contents.files[$_file_idx].target" 2>/dev/null || echo "")
+                        [ -n "$_target" ] && [ "$_target" != "null" ] && FILE_TARGETS["files/$_fname"]="$_target"
+
+                        # Collect variable names
+                        _var_idx=0
+                        _vars=""
+                        while true; do
+                            _var=$(yaml_query ".contents.files[$_file_idx].variables[$_var_idx]" 2>/dev/null || echo "")
+                            [ -z "$_var" ] || [ "$_var" = "null" ] && break
+                            [ -n "$_vars" ] && _vars="$_vars,$_var" || _vars="$_var"
+                            _var_idx=$((_var_idx + 1))
+                        done
+                        [ -n "$_vars" ] && FILE_VARS["files/$_fname"]="$_vars"
+                    else
+                        echo "  ${YELLOW}⚠${NC}  Declared in package.yaml but not found: agent/files/$_fname"
+                        SKIPPED_COUNT=$((SKIPPED_COUNT + 1))
+                    fi
+
+                    _file_idx=$((_file_idx + 1))
+                done
+            else
+                # Fallback: recursive scan (backward compat for packages without contents.files)
+                while IFS= read -r file; do
+                    [ -n "$file" ] && FILES_TO_PROCESS+=("$file")
+                done < <(find "$SOURCE_DIR" -type f)
+            fi
         elif [ "$dir" = "scripts" ]; then
             while IFS= read -r file; do
                 [ -n "$file" ] && FILES_TO_PROCESS+=("$file")
             done < <(find "$SOURCE_DIR" -maxdepth 1 -name "*.sh" ! -name "*.template.sh" -type f)
+        elif [ "$dir" = "index" ]; then
+            while IFS= read -r file; do
+                [ -n "$file" ] && FILES_TO_PROCESS+=("$file")
+            done < <(find "$SOURCE_DIR" -maxdepth 1 -name "*.yaml" ! -name "*.template.yaml" -type f)
         else
             while IFS= read -r file; do
                 [ -n "$file" ] && FILES_TO_PROCESS+=("$file")
@@ -270,7 +358,7 @@ for dir in "${INSTALL_DIRS[@]}"; do
         continue
     fi
     
-    if [ "$dir" = "files" ]; then
+    if [ "$dir" = "files" ] && [ "$HAS_FILE_METADATA" = false ]; then
         echo "${BLUE}📁 $dir/${NC} (${#FILES_TO_PROCESS[@]} file(s)) → installs to ./"
     else
         echo "${BLUE}📁 $dir/${NC} (${#FILES_TO_PROCESS[@]} file(s))"
@@ -308,10 +396,18 @@ for dir in "${INSTALL_DIRS[@]}"; do
             fi
         fi
 
-        # Check experimental status (skip for files/ — no per-file experimental marking)
+        # Check experimental status
         is_experimental=""
-        if [ "$dir" != "files" ] && [ -f "$TEMP_DIR/package.yaml" ]; then
-            is_experimental=$(grep -A 1000 "^  ${dir}:" "$TEMP_DIR/package.yaml" 2>/dev/null | grep -A 2 "name: ${filename}" | grep "^ *experimental: true" | grep -v "^[[:space:]]*#" | head -1)
+        if [ -f "$TEMP_DIR/package.yaml" ]; then
+            if [ "$dir" = "files" ] && [ "$HAS_FILE_METADATA" = false ]; then
+                : # No per-file experimental marking without metadata
+            elif [ "$dir" = "files" ]; then
+                # Files entries have more fields (name, description, target, required, experimental)
+                # so need a wider context window (-A 6) to catch experimental: true
+                is_experimental=$(grep -A 1000 "^  ${dir}:" "$TEMP_DIR/package.yaml" 2>/dev/null | grep -A 6 "name: ${filename}" | grep "^ *experimental: true" | grep -v "^[[:space:]]*#" | head -1)
+            else
+                is_experimental=$(grep -A 1000 "^  ${dir}:" "$TEMP_DIR/package.yaml" 2>/dev/null | grep -A 2 "name: ${filename}" | grep "^ *experimental: true" | grep -v "^[[:space:]]*#" | head -1)
+            fi
         fi
 
         if [ -n "$is_experimental" ] && [ "$INSTALL_EXPERIMENTAL" = false ]; then
@@ -329,17 +425,30 @@ for dir in "${INSTALL_DIRS[@]}"; do
         # Add to valid files
         VALID_FILES+=("$file")
 
-        # Check for overwrites — files/ targets project root, others target agent/
-        if [ "$dir" = "files" ]; then
+        # Determine target path for overwrite check
+        if [ "$dir" = "files" ] && [ "$HAS_FILE_METADATA" = true ]; then
+            _file_target="${FILE_TARGETS[files/$filename]:-./}"
+            _bname=$(basename "$filename")
+            _bname="${_bname%.template}"
+            target_path="${_file_target}${_bname}"
+        elif [ "$dir" = "files" ]; then
             target_path="./$filename"
         else
             target_path="$INSTALL_BASE_DIR/$dir/$filename"
         fi
 
+        # Build display info for files with metadata
+        _display_extra=""
+        if [ "$dir" = "files" ] && [ "$HAS_FILE_METADATA" = true ]; then
+            _file_vars="${FILE_VARS[files/$filename]:-}"
+            _display_extra=" → $target_path"
+            [ -n "$_file_vars" ] && _display_extra="$_display_extra (variables: $_file_vars)"
+        fi
+
         if [ -f "$target_path" ]; then
-            echo "  ${YELLOW}⚠${NC}  $filename (will overwrite)"
+            echo "  ${YELLOW}⚠${NC}  $filename${_display_extra} (will overwrite)"
         else
-            echo "  ${GREEN}✓${NC} $filename"
+            echo "  ${GREEN}✓${NC} $filename${_display_extra}"
         fi
 
         INSTALLED_COUNT=$((INSTALLED_COUNT + 1))
@@ -355,7 +464,7 @@ for dir in "${INSTALL_DIRS[@]}"; do
 done
 
 # Warn about unrecognized directories in the package
-KNOWN_DIRS="patterns commands design scripts files"
+KNOWN_DIRS="patterns commands design scripts files index"
 if [ -d "$TEMP_DIR/agent" ]; then
     UNRECOGNIZED=()
     while IFS= read -r pkg_dir; do
@@ -386,6 +495,11 @@ echo "Ready to install $INSTALLED_COUNT file(s)"
 [ $SKIPPED_COUNT -gt 0 ] && echo "($SKIPPED_COUNT file(s) will be skipped)"
 echo ""
 
+if [ "$LIST_ONLY" = true ]; then
+    echo "${BLUE}(dry run — no files were installed)${NC}"
+    exit 0
+fi
+
 if [ "$SKIP_CONFIRM" = false ]; then
     read -p "Proceed with installation? (y/N) " -n 1 -r
     echo
@@ -398,40 +512,243 @@ else
 fi
 
 echo ""
+
+# Collect template variables from user (if any files have variables declared)
+if [ ${#FILE_VARS[@]} -gt 0 ]; then
+    echo "${BLUE}Collecting template variables...${NC}"
+
+    # Build list of unique variables across all templates
+    _all_vars=""
+    for _key in "${!FILE_VARS[@]}"; do
+        IFS=',' read -ra _var_arr <<< "${FILE_VARS[$_key]}"
+        for _var in "${_var_arr[@]}"; do
+            if [[ ! ",$_all_vars," =~ ",$_var," ]]; then
+                [ -n "$_all_vars" ] && _all_vars="$_all_vars,$_var" || _all_vars="$_var"
+            fi
+        done
+    done
+
+    # Prompt for each unique variable
+    IFS=',' read -ra _unique_vars <<< "$_all_vars"
+    for _var in "${_unique_vars[@]}"; do
+        read -p "  Enter $_var: " _value
+        COLLECTED_VARS["$_var"]="$_value"
+    done
+
+    echo "${GREEN}✓${NC} Variables collected"
+    echo ""
+fi
+
 echo "Installing files..."
 
 # ============================================================================
 # OPTIMIZATION: Batch file operations
 # ============================================================================
 
+# Check if file should be installed based on experimental status
+should_install_file() {
+    local filename="$1"
+    local file_type="$2"  # commands, patterns, designs, scripts
+
+    # If no package.yaml, install everything
+    if [ ! -f "$TEMP_DIR/package.yaml" ]; then
+        return 0
+    fi
+
+    # Check if file is marked experimental in package.yaml
+    # Extract only the relevant section, then find the specific entry
+    local section=$(grep -A 1000 "^  ${file_type}:" "$TEMP_DIR/package.yaml" 2>/dev/null | grep -B 1000 "^  [a-z]" 2>/dev/null | head -n -1 || true)
+    local is_experimental=$(echo "$section" | grep -A 3 "^    - name: ${filename}$" 2>/dev/null | grep "^ *experimental: true" 2>/dev/null | grep -v "^[[:space:]]*#" | head -1 || true)
+
+    if [ -n "$is_experimental" ]; then
+        if [ "$INSTALL_EXPERIMENTAL" = true ]; then
+            echo "  ${YELLOW}⚠${NC}  Installing experimental: ${filename}"
+            return 0  # Install it
+        else
+            echo "  ${DIM}⊘${NC}  Skipping experimental: ${filename} (use --experimental to install)"
+            return 1  # Skip it
+        fi
+    fi
+
+    return 0  # Install non-experimental files
+}
+
 # Add package to manifest once
 add_package_to_manifest "$PACKAGE_NAME" "$REPO_URL" "$PACKAGE_VERSION" "$COMMIT_HASH"
 
-# Batch copy all files
+# Batch copy all files (skip scripts — handled via script-command binding below)
 for dir in "${!ALL_FILES_TO_INSTALL[@]}"; do
     SOURCE_DIR="$TEMP_DIR/agent/$dir"
 
+    # Skip scripts in first pass — install selectively after commands via script-command binding
+    if [ "$dir" = "scripts" ]; then
+        continue
+    fi
+
     # Copy all files
     for file in ${ALL_FILES_TO_INSTALL[$dir]}; do
         if [ "$dir" = "files" ]; then
-            # files/ installs to project root, preserving subdirectory structure
             rel_path="${file#$SOURCE_DIR/}"
-            target_dir="$(dirname "./$rel_path")"
-            mkdir -p "$target_dir"
-            cp "$file" "./$rel_path"
+
+            if [ "$HAS_FILE_METADATA" = true ]; then
+                # Metadata-aware installation: use target path and variable substitution
+                _file_target="${FILE_TARGETS[files/$rel_path]:-./}"
+                _bname=$(basename "$rel_path")
+                _bname="${_bname%.template}"
+                _dest="${_file_target}${_bname}"
+
+                # Safety validation: reject paths that escape project root
+                if [[ "$_dest" =~ \.\. ]] || [[ "$_dest" =~ ^/ ]]; then
+                    echo "  ${RED}✗${NC} Skipping $rel_path (unsafe target: $_dest)"
+                    continue
+                fi
+
+                mkdir -p "$(dirname "$_dest")"
+
+                # Apply variable substitution if template has variables
+                _file_vars="${FILE_VARS[files/$rel_path]:-}"
+                if [ -n "$_file_vars" ] && [ ${#COLLECTED_VARS[@]} -gt 0 ]; then
+                    cp "$file" "$_dest"
+                    IFS=',' read -ra _var_arr <<< "$_file_vars"
+                    for _var in "${_var_arr[@]}"; do
+                        _value="${COLLECTED_VARS[$_var]:-}"
+                        if [ -n "$_value" ]; then
+                            _escaped=$(printf '%s\n' "$_value" | sed 's/[&/\]/\\&/g')
+                            _sed_i "s|{{${_var}}}|${_escaped}|g" "$_dest"
+                        fi
+                    done
+                else
+                    cp "$file" "$_dest"
+                fi
+            else
+                # Backward compat: install to project root preserving subdirectory structure
+                target_dir="$(dirname "./$rel_path")"
+                mkdir -p "$target_dir"
+                cp "$file" "./$rel_path"
+            fi
         else
             mkdir -p "$INSTALL_BASE_DIR/$dir"
             filename=$(basename "$file")
             cp "$file" "$INSTALL_BASE_DIR/$dir/$filename"
+        fi
 
-            # Make scripts executable
-            if [ "$dir" = "scripts" ]; then
-                chmod +x "$INSTALL_BASE_DIR/$dir/$filename"
-            fi
+        # Track installed commands for script dependency resolution
+        if [ "$dir" = "commands" ]; then
+            filename=$(basename "$file")
+            INSTALLED_COMMANDS+=("$filename")
         fi
     done
 done
 
+# ============================================================================
+# Script-Command Binding: Install scripts based on command dependencies
+# ============================================================================
+
+if [ -f "$TEMP_DIR/package.yaml" ] && [ ${#INSTALLED_COMMANDS[@]} -gt 0 ]; then
+    echo "Resolving script dependencies..."
+    echo "  Installed commands: ${INSTALLED_COMMANDS[@]}"
+
+    # Collect required scripts from installed commands using YAML parser
+    REQUIRED_SCRIPTS=()
+    for cmd in "${INSTALLED_COMMANDS[@]}"; do
+        # Find the command index in the array
+        cmd_index=0
+        while true; do
+            cmd_name=$(yaml_get_nested "$TEMP_DIR/package.yaml" "contents.commands[$cmd_index].name" 2>/dev/null || echo "")
+            if [ -z "$cmd_name" ] || [ "$cmd_name" = "null" ]; then
+                break
+            fi
+
+            if [ "$cmd_name" = "$cmd" ]; then
+                # Found the command, now get its scripts
+                script_index=0
+                while true; do
+                    script=$(yaml_get_nested "$TEMP_DIR/package.yaml" "contents.commands[$cmd_index].scripts[$script_index]" 2>/dev/null || echo "")
+                    if [ -z "$script" ] || [ "$script" = "null" ]; then
+                        break
+                    fi
+
+                    # Add to required scripts (with deduplication)
+                    already_added=false
+                    for existing in "${REQUIRED_SCRIPTS[@]}"; do
+                        if [ "$existing" = "$script" ]; then
+                            already_added=true
+                            break
+                        fi
+                    done
+
+                    if [ "$already_added" = false ]; then
+                        REQUIRED_SCRIPTS+=("$script")
+                    fi
+
+                    script_index=$((script_index + 1))
+                done
+                break
+            fi
+
+            cmd_index=$((cmd_index + 1))
+        done
+    done
+
+    echo "  Found ${#REQUIRED_SCRIPTS[@]} required script(s): ${REQUIRED_SCRIPTS[@]}"
+
+    # Install required scripts and add to ALL_FILES_TO_INSTALL for batch manifest update
+    SCRIPT_FILES_LIST=""
+    if [ ${#REQUIRED_SCRIPTS[@]} -gt 0 ]; then
+        mkdir -p "$INSTALL_BASE_DIR/scripts"
+        for script in "${REQUIRED_SCRIPTS[@]}"; do
+            script_path="$TEMP_DIR/agent/scripts/$script"
+
+            # Check if script exists
+            if [ ! -f "$script_path" ]; then
+                echo "  ${RED}✗${NC} Script not found: $script (declared in package.yaml)"
+                continue
+            fi
+
+            # Check if should install based on experimental status
+            if ! should_install_file "$script" "scripts"; then
+                continue
+            fi
+
+            # Copy script and make executable
+            cp "$script_path" "$INSTALL_BASE_DIR/scripts/$script"
+            chmod +x "$INSTALL_BASE_DIR/scripts/$script"
+
+            # Get file version and store metadata
+            FILE_VERSION=$(get_file_version "$TEMP_DIR/package.yaml" "scripts" "$script")
+
+            # Check experimental status
+            is_experimental=""
+            if [ -f "$TEMP_DIR/package.yaml" ]; then
+                is_experimental=$(grep -A 1000 "^  scripts:" "$TEMP_DIR/package.yaml" 2>/dev/null | grep -A 2 "name: ${script}" | grep "^ *experimental: true" | grep -v "^[[:space:]]*#" | head -1)
+            fi
+            FILE_METADATA["scripts/$script"]="$FILE_VERSION|$is_experimental"
+
+            # Track for batch processing
+            if [ -n "$SCRIPT_FILES_LIST" ]; then
+                SCRIPT_FILES_LIST="$SCRIPT_FILES_LIST $script_path"
+            else
+                SCRIPT_FILES_LIST="$script_path"
+            fi
+        done
+    fi
+
+    # Update ALL_FILES_TO_INSTALL with resolved scripts
+    if [ -n "$SCRIPT_FILES_LIST" ]; then
+        ALL_FILES_TO_INSTALL["scripts"]="$SCRIPT_FILES_LIST"
+    fi
+    echo ""
+elif [ -d "$TEMP_DIR/agent/scripts" ] && [ -n "${ALL_FILES_TO_INSTALL[scripts]+x}" ]; then
+    # Scripts were collected during scan but no package.yaml script-command binding
+    # Install all scripts that passed validation (backward compatibility)
+    for file in ${ALL_FILES_TO_INSTALL[scripts]}; do
+        filename=$(basename "$file")
+        mkdir -p "$INSTALL_BASE_DIR/scripts"
+        cp "$file" "$INSTALL_BASE_DIR/scripts/$filename"
+        chmod +x "$INSTALL_BASE_DIR/scripts/$filename"
+    done
+fi
+
 # ============================================================================
 # OPTIMIZATION: Batch checksum calculation
 # ============================================================================
@@ -445,7 +762,14 @@ for dir in "${!ALL_FILES_TO_INSTALL[@]}"; do
     for file in ${ALL_FILES_TO_INSTALL[$dir]}; do
         if [ "$dir" = "files" ]; then
             rel_path="${file#$SOURCE_DIR/}"
-            ALL_INSTALLED_FILES+=("./$rel_path")
+            if [ "$HAS_FILE_METADATA" = true ]; then
+                _file_target="${FILE_TARGETS[files/$rel_path]:-./}"
+                _bname=$(basename "$rel_path")
+                _bname="${_bname%.template}"
+                ALL_INSTALLED_FILES+=("${_file_target}${_bname}")
+            else
+                ALL_INSTALLED_FILES+=("./$rel_path")
+            fi
         else
             filename=$(basename "$file")
             ALL_INSTALLED_FILES+=("$INSTALL_BASE_DIR/$dir/$filename")
@@ -460,7 +784,7 @@ if [ ${#ALL_INSTALLED_FILES[@]} -gt 0 ]; then
         checksum=$(echo "$line" | awk '{print $1}')
         filepath=$(echo "$line" | awk '{$1=""; print substr($0,2)}')
         CHECKSUMS["$filepath"]="$checksum"
-    done < <(sha256sum "${ALL_INSTALLED_FILES[@]}" 2>/dev/null)
+    done < <(if command -v sha256sum >/dev/null 2>&1; then sha256sum "${ALL_INSTALLED_FILES[@]}" 2>/dev/null; elif command -v shasum >/dev/null 2>&1; then shasum -a 256 "${ALL_INSTALLED_FILES[@]}" 2>/dev/null; fi)
 fi
 
 # ============================================================================
@@ -482,7 +806,14 @@ for dir in "${!ALL_FILES_TO_INSTALL[@]}"; do
         # Determine filename and installed filepath based on dir type
         if [ "$dir" = "files" ]; then
             filename="${file#$SOURCE_DIR/}"
-            filepath="./$filename"
+            if [ "$HAS_FILE_METADATA" = true ]; then
+                _file_target="${FILE_TARGETS[files/$filename]:-./}"
+                _bname=$(basename "$filename")
+                _bname="${_bname%.template}"
+                filepath="${_file_target}${_bname}"
+            else
+                filepath="./$filename"
+            fi
         else
             filename=$(basename "$file")
             filepath="$INSTALL_BASE_DIR/$dir/$filename"
@@ -506,10 +837,29 @@ for dir in "${!ALL_FILES_TO_INSTALL[@]}"; do
             yaml_object_set "$obj_node" "experimental" "true" >/dev/null
         fi
 
+        # For files with metadata: store target path and variables
+        if [ "$dir" = "files" ] && [ "$HAS_FILE_METADATA" = true ]; then
+            yaml_object_set "$obj_node" "target" "$filepath" >/dev/null
+            # Store variable values if this file had variables
+            _file_vars_manifest="${FILE_VARS[files/$filename]:-}"
+            if [ -n "$_file_vars_manifest" ]; then
+                # Create nested map node for variables
+                _vars_node=$(create_node "map" "variables" "" "$obj_node")
+                add_child "$obj_node" "$_vars_node"
+                IFS=',' read -ra _var_names <<< "$_file_vars_manifest"
+                for _vname in "${_var_names[@]}"; do
+                    _vval="${COLLECTED_VARS[$_vname]:-}"
+                    if [ -n "$_vval" ]; then
+                        yaml_object_set "$_vars_node" "$_vname" "$_vval" >/dev/null
+                    fi
+                done
+            fi
+        fi
+
         if [ "$dir" = "scripts" ]; then
             echo "  ${GREEN}✓${NC} Installed $dir/$filename (v$file_version) [executable]"
         elif [ "$dir" = "files" ]; then
-            echo "  ${GREEN}✓${NC} Installed $filename → ./$filename"
+            echo "  ${GREEN}✓${NC} Installed $filename → $filepath"
         else
             echo "  ${GREEN}✓${NC} Installed $dir/$filename (v$file_version)"
         fi