// autoSaveOutput saves the content based on the combination of --save and --output flags:
    // - If only --save is used, save to ~/ingest/<dirname>.md
    // - If --save and --output ./somefile.md, only save to ./somefile.md
    // - If --save and --output somefile.md, save to ~/ingest/somefile.md
    func autoSaveOutput(content string, outputPath string, sourcePath string) error {
    	var finalPath string

    	if outputPath != "" {
    		if strings.HasPrefix(outputPath, "./") || strings.HasPrefix(outputPath, "../") || filepath.IsAbs(outputPath) {
    			// Case: --output starts with ./ or ../ or is absolute path
    			// Save only to the specified output path
    			absOutputPath, err := filepath.Abs(outputPath) // Resolves relative paths
    			if err != nil {
    				return fmt.Errorf("failed to get absolute path for output file %s: %w", outputPath, err)
    			}
    			finalPath = absOutputPath
    		} else {
    			// Case: --output is just a filename
    			// Save to ~/ingest/ with the specified filename
    			homeDir, err := os.UserHomeDir()
    			if err != nil {
    				return fmt.Errorf("failed to get user home directory: %w", err)
    			}
    			ingestDir := filepath.Join(homeDir, "ingest") // Potential issue: outputPath could be "../something"
    			finalPath = filepath.Join(ingestDir, outputPath) // P0 Risk: Path Traversal
    		}
    	} else {
    		// Default --save behavior
    		homeDir, err := os.UserHomeDir()
    		if err != nil {
    			return fmt.Errorf("failed to get user home directory: %w", err)
    		}
    		ingestDir := filepath.Join(homeDir, "ingest")
    		// Potential issue: sourcePath might be empty if no args provided
    		fileName := filepath.Base(sourcePath) + ".md"
    		finalPath = filepath.Join(ingestDir, fileName)
    	}

    	// Ensure the directory for the final path exists
    	finalDir := filepath.Dir(finalPath)
    	if err := os.MkdirAll(finalDir, 0700); err != nil { // MkdirAll might create unintended directories if path traversal occurs
    		return fmt.Errorf("failed to create directory %s for auto-save file: %w", finalDir, err)
    	}

    	// Write the file using os.WriteFile
    	if err := os.WriteFile(finalPath, []byte(content), 0600); err != nil {
    		return fmt.Errorf("failed to write auto-save file to %s: %w", finalPath, err)
    	}

    	utils.AddMessage("💾", fmt.Sprintf("Auto-saved to: %s", finalPath), color.FgMagenta, 15) // Changed icon and message slightly
    	return nil
    }

    import (
    	"fmt"
    	"os"
    	"path/filepath"
    	"strings"
        // ... other imports
    )

    // autoSaveOutput saves the content based on the combination of --save and --output flags.
    // Includes path sanitization.
    func autoSaveOutput(content string, outputPath string, sourcePath string) error {
    	var finalPath string
    	var baseDir string // Define the intended base directory

    	homeDir, err := os.UserHomeDir()
    	if err != nil {
    		return fmt.Errorf("failed to get user home directory: %w", err)
    	}
    	ingestDir := filepath.Join(homeDir, "ingest") // Default base

    	if outputPath != "" {
    		// Clean the user-provided path first
    		cleanedOutputPath := filepath.Clean(outputPath)

    		if filepath.IsAbs(cleanedOutputPath) {
    			// Case: Absolute path provided
    			finalPath = cleanedOutputPath
    			baseDir = filepath.Dir(finalPath) // Base is the directory of the absolute path
    		} else if strings.HasPrefix(outputPath, "./") || strings.HasPrefix(outputPath, "../") {
                // Case: Relative path provided (./ or ../)
                // Resolve it relative to the current working directory
                absPath, err := filepath.Abs(cleanedOutputPath)
                if err != nil {
                    return fmt.Errorf("failed to resolve relative path %s: %w", outputPath, err)
                }
                finalPath = absPath
                // Determine the effective base directory from the resolved path
                // For safety, could restrict this to be within CWD or a known root.
                // For now, let's assume the resolved absolute path's directory is the intended base.
                baseDir = filepath.Dir(finalPath)
            } else {
    			// Case: Filename only provided - relative to ingestDir
    			baseDir = ingestDir
    			// Sanitize against traversal before joining
    			if strings.Contains(cleanedOutputPath, string(filepath.Separator)) || strings.Contains(cleanedOutputPath, "..") {
    				return fmt.Errorf("invalid filename-only output path: contains path separators or '..'")
    			}
    			finalPath = filepath.Join(baseDir, cleanedOutputPath)
    		}

            // --- Security Check ---
            // Ensure the final resolved path is within the intended base directory
            // This check is crucial, especially for relative paths and filename-only cases.
            // For absolute paths, this check might be less critical but still good practice.
            // Note: For paths like ./../foo, Abs resolves it, so the check needs care.
            // A simpler check for filename-only case:
            if !filepath.IsAbs(cleanedOutputPath) && !(strings.HasPrefix(outputPath, "./") || strings.HasPrefix(outputPath, "../")) {
                 // Re-check specifically for the filename-only case after joining
                 if !strings.HasPrefix(filepath.Clean(finalPath), filepath.Clean(baseDir)+string(filepath.Separator)) && filepath.Clean(finalPath) != filepath.Clean(baseDir) {
                      return fmt.Errorf("path traversal attempt detected: resolved path %s is outside of base directory %s", finalPath, baseDir)
                 }
            }
            // More robust check might be needed depending on desired strictness for relative paths.

    	} else {
    		// Default --save behavior
    		baseDir = ingestDir
    		if sourcePath == "" { // Handle case where sourcePath might be empty
    			// Use a default name or return an error if sourcePath is required
    			sourcePath = "default_ingest" // Example default
    		}
    		fileName := filepath.Base(sourcePath) + ".md"
    		finalPath = filepath.Join(baseDir, fileName)
            // Ensure the default filename doesn't contain problematic characters
            // (filepath.Base should handle most issues, but good to be aware)
    	}

    	// Ensure the directory for the final path exists
    	finalDir := filepath.Dir(finalPath)
    	// Check if finalDir is trying to escape the intended baseDir (redundant if above check is robust)
    	if err := os.MkdirAll(finalDir, 0700); err != nil {
    		return fmt.Errorf("failed to create directory %s for auto-save file: %w", finalDir, err)
    	}

    	// Write the file using os.WriteFile
    	if err := os.WriteFile(finalPath, []byte(content), 0600); err != nil {
    		return fmt.Errorf("failed to write auto-save file to %s: %w", finalPath, err)
    	}

    	utils.AddMessage("💾", fmt.Sprintf("Auto-saved to: %s", finalPath), color.FgMagenta, 15)
    	return nil
    }

    func handleOutput(rendered string, tokens int, encoding string, noClipboard bool, output string, jsonOutput bool, report bool, allFiles []map[string]interface{}) error {
    	// ... (json output logic) ...
    	} else {
    		outputWritten := false
    		if output != "" { // This 'output' is potentially cleared by runCommand if auto-save handles it
    			err := utils.WriteToFile(output, rendered)
    			if err != nil {
    				// Report the error but continue to potentially copy to clipboard or print
    				utils.PrintColouredMessage("❌", fmt.Sprintf("Failed to write to file %s: %v", output, err), color.FgRed)
    			} else {
    				utils.AddMessage("✅", fmt.Sprintf("Written to file: %s", output), color.FgGreen, 20)
    				outputWritten = true
    			}
    		}

    		clipboardCopied := false
    		if !noClipboard {
    			err := utils.CopyToClipboard(rendered)
    			if err == nil {
    				utils.AddMessage("✅", "Copied to clipboard successfully.", color.FgGreen, 5)
    				clipboardCopied = true
    			} else {
    				// Only show clipboard error if we didn't write to a file
    				if !outputWritten {
    					utils.PrintColouredMessage("⚠️", fmt.Sprintf("Failed to copy to clipboard: %v.", err), color.FgYellow)
    				}
    			}
    		}

    		// If neither output file was written nor clipboard was copied, print to console
    		if !outputWritten && !clipboardCopied {
    			fmt.Print(rendered)
    		}
    	}

    	return nil
    }

    	// Check if save is set in config or flag
    	autoSave, _ := cmd.Flags().GetBool("save")
    	if cfg.AutoSave || autoSave {
    		// Pass the output flag value to autoSaveOutput
    		// Potential issue: args[0] might not exist if no args were provided
    		if err := autoSaveOutput(rendered, output, args[0]); err != nil { // Assuming args[0] is a representative source path
    			utils.PrintColouredMessage("❌", fmt.Sprintf("Error auto-saving file: %v", err), color.FgRed)
                // Consider setting a flag here if autoSave failed, to pass to handleOutput
    		}
    	}
        // ...
    	} else {
    		// If both --save and --output are used, we don't want handleOutput to write the file
    		// as autoSaveOutput will handle it
    		outputForHandleOutput := output
    		if (cfg.AutoSave || autoSave) && output != "" {
    			// This logic prevents handleOutput from writing if autoSaveOutput should have.
                // But doesn't account for autoSaveOutput *failing*.
    			outputForHandleOutput = ""
    		}
    		// Pass outputForHandleOutput instead of original output
    		if err := handleOutput(rendered, tokens, encoding, noClipboard, outputForHandleOutput, jsonOutput, report || verbose, allFiles); err != nil {
    			return fmt.Errorf("failed to handle output: %w", err)
    		}
    	}

    	// Check if save is set in config or flag
    	autoSave, _ := cmd.Flags().GetBool("save")
        autoSaveActive := cfg.AutoSave || autoSave
        autoSaveErr := error(nil) // Keep track of auto-save errors

    	if autoSaveActive {
    		// Determine the source path safely
            var sourcePathForSave string
            if len(args) > 0 {
                sourcePathForSave = args[0]
            } else {
                // If no args, maybe use current directory name or a default
                currentDir, wdErr := os.Getwd()
                if wdErr == nil {
                    sourcePathForSave = filepath.Base(currentDir)
                } else {
                    sourcePathForSave = "ingest_output" // Fallback default name
                }
            }

    		// Pass the output flag value to autoSaveOutput
    		if err := autoSaveOutput(rendered, output, sourcePathForSave); err != nil {
    			utils.PrintColouredMessage("❌", fmt.Sprintf("Error auto-saving file: %v", err), color.FgRed)
                autoSaveErr = err // Store the error
    		}
    	}
        // ...
    	} else {
            // Determine if handleOutput should attempt writing to the 'output' file
            shouldHandleOutputWrite := true
            if autoSaveActive && output != "" && autoSaveErr == nil {
                // If auto-save was active, an output file was specified, AND auto-save succeeded,
                // then handleOutput should NOT try to write the same file.
                shouldHandleOutputWrite = false
            }

            outputForHandle := ""
            if shouldHandleOutputWrite {
                outputForHandle = output // Pass original output path if handleOutput should write
            }

    		// Pass the potentially original output path to handleOutput
    		if err := handleOutput(rendered, tokens, encoding, noClipboard, outputForHandle, jsonOutput, report || verbose, allFiles); err != nil {
    			return fmt.Errorf("failed to handle output: %w", err)
    		}
    	}