diff --git a/Cargo.lock b/Cargo.lock
index 009750e..d4bea7a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -237,6 +237,16 @@ dependencies = [
  "objc2",
 ]
 
+[[package]]
+name = "bstr"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6bb31b46c14244e20ee9984b11bf5c992b91fb6939fea616e3512c8baecdbe5f"
+dependencies = [
+ "memchr",
+ "serde_core",
+]
+
 [[package]]
 name = "bumpalo"
 version = "3.20.3"
@@ -416,6 +426,7 @@ dependencies = [
  "encoding_rs",
  "futures",
  "git2",
+ "ignore",
  "indicatif",
  "itertools 0.15.0",
  "jiff",
@@ -1234,6 +1245,19 @@ dependencies = [
  "url",
 ]
 
+[[package]]
+name = "globset"
+version = "0.4.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07c34a9410465b45bd9787443bc7370f37735bad04b0f0cd57ff1a3186c98988"
+dependencies = [
+ "aho-corasick",
+ "bstr",
+ "log",
+ "regex-automata",
+ "regex-syntax",
+]
+
 [[package]]
 name = "h2"
 version = "0.4.19"
@@ -1556,6 +1580,22 @@ dependencies = [
  "icu_properties",
 ]
 
+[[package]]
+name = "ignore"
+version = "0.4.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00b69833ed729dc5aa7d19541d96d6cf8e9137194207a04916d658e43168402f"
+dependencies = [
+ "crossbeam-deque",
+ "globset",
+ "log",
+ "memchr",
+ "regex-automata",
+ "same-file",
+ "walkdir",
+ "winapi-util",
+]
+
 [[package]]
 name = "indexmap"
 version = "2.14.2"
diff --git a/Cargo.toml b/Cargo.toml
index b0788e3..3c87926 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -26,6 +26,7 @@ dunce = "1.0.5"
 encoding_rs = "0.8.41"
 futures = "0.3.34"
 git2 = { version = "0.21.0", features = ["ssh", "https"] }
+ignore = "0.4.33"
 indicatif = { version = "0.18.6", features = ["tokio", "futures", "rayon"] }
 itertools = "0.15.0"
 num_cpus = "1.17.0"
diff --git a/README.md b/README.md
index ea62764..4f55c17 100644
--- a/README.md
+++ b/README.md
@@ -494,14 +494,19 @@ whenever the clause it introduces carries on past it,
 so the explanation or list starts on a line of its own.
 Text inside backticks, Markdown links, and inline formatting such as `**bold**`, `_italic_`,
 and `~~strikethrough~~` is never broken, and a span that was split by hand is joined back together.
-Semicolons are rewritten as separate sentences, and trailing comments are moved above the code.
+Semicolons are rewritten as separate sentences.
 An em dash becomes a period and a new sentence, or a colon where the text before it names what follows.
 A pair of dashes that encloses an aside becomes a pair of commas,
 and a dash that is kept never ends or starts a line.
 Aligned column blocks, such as the environment table of a usage comment, are left as they are.
 Slash-delimited regex literals are protected across supported source languages.
 When ambiguous slash syntax could hide a multiline string or comment, the remaining source is left unchanged.
+With `--trailing`, a comment sharing a line with code is moved onto its own line above it.
+That rule rewrites code lines and the result often reads worse than the original, so it is off by default.
+A trailing comment whose code line already has a comment above it is reported but not moved,
+since the two notes would be reflowed into one sentence.
 The line limit is read from project config files such as `.editorconfig`, `rustfmt.toml`, and `pyproject.toml`.
+Paths ignored by git are skipped, unless `--no-ignore` says otherwise.
 Files are checked in parallel, one worker per core unless `--jobs` says otherwise,
 and the report is printed in file order so a run is reproducible.
 The default mode reports violations and exits with code 1.
@@ -526,9 +531,11 @@ Options:
   -j, --join-sentences          Also pack consecutive short sentences up to the line limit
   -w, --width <N>               Maximum line length including indentation and comment marker (default: from project config or 120)
   -i, --ignore-project-config   Do not read the line length from project config files such as .editorconfig, rustfmt.toml, or pyproject.toml
-  -R, --rules <RULES>           Rules to enable (default: all) [possible values: too-long, mid-clause, semicolon, em-dash, trailing]
+  -R, --rules <RULES>           Rules to enable (default: every rule except trailing comments) [possible values: too-long, mid-clause, semicolon, em-dash, trailing]
+  -T, --trailing                Also move trailing comments to their own line above the code
   -e, --extensions <EXTENSION>  Only process files with these extensions
-  -x, --exclude <PATTERN>       Skip paths with a directory or file name equal to this text
+  -x, --exclude <PATTERN>       Skip paths with a directory or file name equal to this text, in addition to the default excludes
+  -n, --no-ignore               Do not skip paths ignored by git
   -t, --type <KIND>             Force the file kind, required with --stdin [possible values: rust, c, javascript, go, python, shell, toml, yaml, dockerfile, makefile, ruby, sql, lua, markdown]
   -s, --stdin                   Read text from stdin and write the formatted result to stdout
   -b, --word-break              Allow breaking at a plain word boundary when no clause boundary fits
diff --git a/cli-tools.toml b/cli-tools.toml
index 406c1ed..3e32dd3 100644
--- a/cli-tools.toml
+++ b/cli-tools.toml
@@ -366,7 +366,10 @@ replace = [
 # Read the line length from project config files such as .editorconfig, rustfmt.toml, and pyproject.toml
 # use_project_config = true
 
-# Rules to enable
+# Rules to enable.
+# The "trailing" rule moves a comment sharing a line with code onto its own line above.
+# It rewrites code lines and the result often reads worse than the original,
+# so it is off unless listed here or asked for with --trailing.
 # rules = ["too-long", "mid-clause", "semicolon", "em-dash", "trailing"]
 
 # Also pack consecutive short sentences up to the line limit
@@ -378,9 +381,14 @@ replace = [
 # Only process files with these extensions (empty means all supported file types)
 # extensions = []
 
-# Skip paths with a directory or file name equal to any of these
+# Skip paths with a directory or file name equal to any of these.
+# Setting this replaces the built-in list, while --exclude on the command line adds to it.
 # exclude = ["target", "node_modules", "build", "dist", "cdk.out", "coverage", ".venv", "venv", "vendor"]
 
+# Skip paths ignored by git, using .gitignore, .ignore, the global ignore file, and .git/info/exclude.
+# Only applies inside a git repository, elsewhere the exclude list above is the only filter.
+# use_gitignore = true
+
 # Abbreviations that do not end a sentence (added to the built-in list)
 # abbreviations = []
 
diff --git a/src/bin/semantic_line_breaks/config.rs b/src/bin/semantic_line_breaks/config.rs
index 7b7db81..78d1c12 100644
--- a/src/bin/semantic_line_breaks/config.rs
+++ b/src/bin/semantic_line_breaks/config.rs
@@ -52,6 +52,8 @@ pub struct SlbConfig {
     #[serde(default)]
     pub rules: Vec<String>,
     #[serde(default)]
+    pub use_gitignore: Option<bool>,
+    #[serde(default)]
     pub use_project_config: Option<bool>,
     #[serde(default)]
     pub verbose: bool,
@@ -85,6 +87,7 @@ pub struct Config {
     pub rules: RuleSet,
     pub stdin: bool,
     pub project_width: bool,
+    pub use_gitignore: bool,
     pub verbose: bool,
     pub width: Option<usize>,
 }
@@ -126,7 +129,9 @@ impl Config {
     ///
     /// Command line values win over the config file, which wins over the built-in defaults.
     /// Extension lists (abbreviations, directive prefixes, lowercase words) add to the defaults.
-    /// Clause starters and excludes replace the defaults when given.
+    /// Clause starters replace the defaults when given.
+    /// An exclude list in the config file replaces the defaults,
+    /// while command line excludes add to whichever list was resolved.
     ///
     /// # Errors
     /// Returns an error if the config file cannot be read or parsed or names an unknown rule.
@@ -139,9 +144,9 @@ impl Config {
     /// # Errors
     /// Returns an error if the user config names an unknown rule.
     pub fn from_args_and_user_config(args: &Args, user_config: SlbConfig) -> Result<Self> {
-        let rules = if args.rules.is_empty() {
+        let mut rules = if args.rules.is_empty() {
             if user_config.rules.is_empty() {
-                RuleSet::ALL
+                RuleSet::DEFAULT
             } else {
                 let kinds = user_config
                     .rules
@@ -156,16 +161,22 @@ impl Config {
         } else {
             RuleSet::from_kinds(&args.rules)
         };
+        if args.trailing {
+            rules.trailing_comment = true;
+        }
 
-        let exclude = if args.exclude.is_empty() {
-            if user_config.exclude.is_empty() {
-                cli_tools::strings_from(DEFAULT_EXCLUDES)
-            } else {
-                user_config.exclude
-            }
+        // The command line excludes narrow the walk further,
+        // so they add to the resolved list instead of replacing it.
+        let mut exclude = if user_config.exclude.is_empty() {
+            cli_tools::strings_from(DEFAULT_EXCLUDES)
         } else {
-            args.exclude.clone()
+            user_config.exclude
         };
+        for pattern in &args.exclude {
+            if !exclude.contains(pattern) {
+                exclude.push(pattern.clone());
+            }
+        }
 
         let extensions = if args.extensions.is_empty() {
             user_config.extensions
@@ -193,6 +204,7 @@ impl Config {
             rules,
             stdin: args.stdin,
             project_width: !args.ignore_project_config && user_config.use_project_config.unwrap_or(true),
+            use_gitignore: !args.no_ignore && user_config.use_gitignore.unwrap_or(true),
             verbose: args.verbose || user_config.verbose,
             width: args.width.or(user_config.width),
         })
@@ -308,7 +320,8 @@ mod test_config_from_args {
         assert!(config.rules.em_dash);
         assert!(!config.rules.trailing_comment);
         assert_eq!(config.width, Some(80));
-        assert_eq!(config.exclude, vec!["docs"]);
+        // The fixture config sets exclude = ["target"], and the command line value adds to it.
+        assert_eq!(config.exclude, vec!["target", "docs"]);
         assert!(config.project_width);
     }
 
@@ -319,7 +332,8 @@ mod test_config_from_args {
     fn fixture_config_values_are_merged_with_defaults() {
         let args = Args::try_parse_from(["slb", "--extensions", ".RS"]).expect("arguments should parse");
         let config = Config::from_args(&args).expect("config should build");
-        assert_eq!(config.rules, RuleSet::ALL);
+        // The fixture config lists every rule except the opt-in trailing comment rule.
+        assert_eq!(config.rules, RuleSet::DEFAULT);
         assert_eq!(config.exclude, vec!["target"]);
         assert_eq!(config.extensions, vec!["rs"]);
         assert_eq!(config.clause_starters, vec!["meanwhile"]);
@@ -358,7 +372,8 @@ mod test_config_merge {
     #[test]
     fn an_empty_user_config_gives_the_built_in_defaults() {
         let config = config(&["slb"], "").expect("config should build");
-        assert_eq!(config.rules, RuleSet::ALL);
+        assert_eq!(config.rules, RuleSet::DEFAULT);
+        assert!(!config.rules.trailing_comment);
         assert_eq!(config.exclude, cli_tools::strings_from(DEFAULT_EXCLUDES));
         assert!(config.extensions.is_empty());
         assert!(config.width.is_none());
@@ -398,7 +413,47 @@ mod test_config_merge {
         assert_eq!(config.exclude, vec!["generated"]);
 
         let overridden = config_with_exclude_option();
-        assert_eq!(overridden.exclude, vec!["docs"]);
+        assert_eq!(overridden.exclude, vec!["generated", "docs"]);
+    }
+
+    #[test]
+    fn a_command_line_exclude_adds_to_the_built_in_defaults() {
+        let config = config(&["slb", "--exclude", "docs"], "").expect("config should build");
+        assert!(config.exclude.contains(&"target".to_string()));
+        assert!(config.exclude.contains(&"node_modules".to_string()));
+        assert_eq!(config.exclude.last(), Some(&"docs".to_string()));
+    }
+
+    #[test]
+    fn a_command_line_exclude_already_in_the_list_is_not_repeated() {
+        let config = config(&["slb", "--exclude", "target"], "").expect("config should build");
+        assert_eq!(config.exclude, cli_tools::strings_from(DEFAULT_EXCLUDES));
+    }
+
+    #[test]
+    fn the_trailing_flag_adds_the_trailing_comment_rule() {
+        let default_rules = config(&["slb", "--trailing"], "").expect("config should build");
+        assert_eq!(default_rules.rules, RuleSet::ALL);
+
+        let with_rules = config(&["slb", "--rules", "semicolon", "--trailing"], "").expect("config should build");
+        assert!(with_rules.rules.semicolon);
+        assert!(with_rules.rules.trailing_comment);
+        assert!(!with_rules.rules.line_too_long);
+    }
+
+    #[test]
+    fn gitignore_is_used_unless_turned_off() {
+        assert!(config(&["slb"], "").expect("config should build").use_gitignore);
+        assert!(
+            !config(&["slb", "--no-ignore"], "")
+                .expect("config should build")
+                .use_gitignore
+        );
+        assert!(
+            !config(&["slb"], "[slb]\nuse_gitignore = false\n")
+                .expect("config should build")
+                .use_gitignore
+        );
     }
 
     /// Config with an exclude given on the command line and another one in the user config.
@@ -445,6 +500,6 @@ mod test_config_merge {
         assert_eq!(options.clause_starters, vec!["meanwhile"]);
         assert!(options.abbreviations.contains(&"approx.".to_string()));
         assert!(options.preserve_lowercase.contains(&"ffmpeg".to_string()));
-        assert_eq!(options.rules, RuleSet::ALL);
+        assert_eq!(options.rules, RuleSet::DEFAULT);
     }
 }
diff --git a/src/bin/semantic_line_breaks/files.rs b/src/bin/semantic_line_breaks/files.rs
index aa0b24a..b5eeaaa 100644
--- a/src/bin/semantic_line_breaks/files.rs
+++ b/src/bin/semantic_line_breaks/files.rs
@@ -1,12 +1,13 @@
 //! File discovery and filtering for `slb`.
 //!
-//! Walks the given input paths, skips excluded directories and unsupported file types,
+//! Walks the given input paths, skips ignored and excluded directories and unsupported file types,
 //! and applies the extension filter to build the list of files to process.
 
 use std::path::{Path, PathBuf};
+use std::sync::Arc;
 
 use anyhow::Result;
-use walkdir::WalkDir;
+use ignore::WalkBuilder;
 
 use cli_tools::print_yellow;
 use cli_tools::semantic_line_breaks::FileKind;
@@ -28,6 +29,8 @@ pub fn collect_files(paths: &[PathBuf], config: &Config) -> Result<Vec<(PathBuf,
     };
 
     let excludes_have_separator = config.exclude.iter().any(|pattern| pattern.contains('/'));
+    // The filter runs on the walker's own threads, so it needs an owned handle on the excludes.
+    let excludes = Arc::new(config.exclude.clone());
     let mut files = Vec::new();
     for root in roots {
         if root.is_file() {
@@ -41,14 +44,25 @@ pub fn collect_files(paths: &[PathBuf], config: &Config) -> Result<Vec<(PathBuf,
             }
             continue;
         }
-        // The hidden and system directory skip does not apply to the root,
-        // so an explicitly given directory such as ".github" is still walked.
-        let walker = WalkDir::new(&root).into_iter().filter_entry(|entry| {
-            (entry.depth() == 0 || !cli_tools::should_skip_entry(entry))
-                && !is_excluded(entry.path(), config, excludes_have_separator)
-        });
+        // The standard filters are off so the hidden and system directory skip stays here,
+        // where it can exempt the root and let an explicitly given directory such as ".github" through.
+        // Gitignore rules only apply inside a git repository,
+        // so the exclude list stays as the safety net everywhere else.
+        let filter_excludes = Arc::clone(&excludes);
+        let walker = WalkBuilder::new(&root)
+            .standard_filters(false)
+            .git_ignore(config.use_gitignore)
+            .git_global(config.use_gitignore)
+            .git_exclude(config.use_gitignore)
+            .ignore(config.use_gitignore)
+            .parents(config.use_gitignore)
+            .filter_entry(move |entry| {
+                (entry.depth() == 0 || !cli_tools::should_skip_path(entry.path()))
+                    && !is_excluded(entry.path(), &filter_excludes, excludes_have_separator)
+            })
+            .build();
         for entry in walker.filter_map(Result::ok) {
-            if !entry.file_type().is_file() {
+            if !entry.file_type().is_some_and(|file_type| file_type.is_file()) {
                 continue;
             }
             let path = entry.into_path();
@@ -69,13 +83,13 @@ pub fn collect_files(paths: &[PathBuf], config: &Config) -> Result<Vec<(PathBuf,
 ///
 /// The whole path is only rendered as text when some pattern holds a separator,
 /// since that rendering costs an allocation for every entry of the walk.
-fn is_excluded(path: &Path, config: &Config, any_pattern_has_separator: bool) -> bool {
+fn is_excluded(path: &Path, excludes: &[String], any_pattern_has_separator: bool) -> bool {
     let path_string = if any_pattern_has_separator {
         path.to_string_lossy().replace('\\', "/")
     } else {
         String::new()
     };
-    config.exclude.iter().any(|pattern| {
+    excludes.iter().any(|pattern| {
         if pattern.contains('/') {
             path_string.contains(pattern.trim_matches('/'))
         } else {
@@ -115,7 +129,7 @@ mod test_helpers {
     /// Whether the path is excluded, working out the separator flag the way the walk does.
     pub fn excluded(path: &Path, config: &Config) -> bool {
         let any_pattern_has_separator = config.exclude.iter().any(|pattern| pattern.contains('/'));
-        super::is_excluded(path, config, any_pattern_has_separator)
+        super::is_excluded(path, &config.exclude, any_pattern_has_separator)
     }
 
     /// Build a config from command line arguments as the binary would.
@@ -237,6 +251,57 @@ mod test_collect_files {
         assert_eq!(collected_names(&files), vec!["lib.rs"]);
     }
 
+    #[test]
+    fn gitignored_files_are_not_walked() {
+        let directory = temporary_directory();
+        write(&directory, ".gitignore", "generated/\n");
+        write(&directory, "lib.rs", "// comment\n");
+        write(&directory, "generated/api.rs", "// comment\n");
+        std::process::Command::new("git")
+            .args(["init", "--quiet"])
+            .current_dir(directory.path())
+            .status()
+            .expect("git init should run");
+
+        let files = collect_files(&[directory.path().to_path_buf()], &config_with(vec![], vec![]))
+            .expect("collecting should succeed");
+
+        assert_eq!(collected_names(&files), vec!["lib.rs"]);
+    }
+
+    #[test]
+    fn gitignored_files_are_walked_with_the_ignore_rules_off() {
+        let directory = temporary_directory();
+        write(&directory, ".gitignore", "generated/\n");
+        write(&directory, "lib.rs", "// comment\n");
+        write(&directory, "generated/api.rs", "// comment\n");
+        std::process::Command::new("git")
+            .args(["init", "--quiet"])
+            .current_dir(directory.path())
+            .status()
+            .expect("git init should run");
+
+        let mut config = config_with(vec![], vec![]);
+        config.use_gitignore = false;
+
+        let files = collect_files(&[directory.path().to_path_buf()], &config).expect("collecting should succeed");
+
+        assert_eq!(collected_names(&files), vec!["api.rs", "lib.rs"]);
+    }
+
+    #[test]
+    fn a_gitignore_outside_a_repository_is_not_applied() {
+        let directory = temporary_directory();
+        write(&directory, ".gitignore", "generated/\n");
+        write(&directory, "lib.rs", "// comment\n");
+        write(&directory, "generated/api.rs", "// comment\n");
+
+        let files = collect_files(&[directory.path().to_path_buf()], &config_with(vec![], vec![]))
+            .expect("collecting should succeed");
+
+        assert_eq!(collected_names(&files), vec!["api.rs", "lib.rs"]);
+    }
+
     #[test]
     fn hidden_files_inside_a_directory_are_skipped() {
         let directory = temporary_directory();
diff --git a/src/bin/semantic_line_breaks/main.rs b/src/bin/semantic_line_breaks/main.rs
index 93ff010..f7aeb06 100644
--- a/src/bin/semantic_line_breaks/main.rs
+++ b/src/bin/semantic_line_breaks/main.rs
@@ -56,18 +56,26 @@ pub struct Args {
     #[arg(short, long)]
     ignore_project_config: bool,
 
-    /// Rules to enable (default: all)
+    /// Rules to enable (default: every rule except trailing comments)
     #[arg(short = 'R', long, value_delimiter = ',', value_name = "RULES")]
     rules: Vec<cli_tools::semantic_line_breaks::ViolationKind>,
 
+    /// Also move trailing comments to their own line above the code
+    #[arg(short = 'T', long)]
+    trailing: bool,
+
     /// Only process files with these extensions
     #[arg(short, long, num_args = 1, action = clap::ArgAction::Append, value_name = "EXTENSION")]
     extensions: Vec<String>,
 
-    /// Skip paths with a directory or file name equal to this text
+    /// Skip paths with a directory or file name equal to this text, in addition to the default excludes
     #[arg(short = 'x', long, num_args = 1, action = clap::ArgAction::Append, value_name = "PATTERN")]
     exclude: Vec<String>,
 
+    /// Do not skip paths ignored by git
+    #[arg(short = 'n', long)]
+    no_ignore: bool,
+
     /// Force the file kind, required with --stdin
     #[arg(short = 't', long = "type", value_name = "KIND")]
     kind: Option<FileKind>,
diff --git a/src/lib.rs b/src/lib.rs
index 94b9405..fc8d82b 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -449,6 +449,13 @@ pub fn is_hidden_tokio(entry: &tokio::fs::DirEntry) -> bool {
     name_bytes.first() == Some(&b'.')
 }
 
+/// Check if a path is a hidden file or directory (name starts with '.')
+#[must_use]
+pub fn is_hidden_path(path: &Path) -> bool {
+    path.file_name()
+        .is_some_and(|name| name.as_encoded_bytes().first() == Some(&b'.'))
+}
+
 /// Check if entry is a system directory that should be skipped.
 /// Returns true for OS-specific directories like `$RECYCLE.BIN`, `.Spotlight-V100`, or `lost+found`.
 #[must_use]
@@ -577,6 +584,14 @@ pub fn should_skip_entry(entry: &walkdir::DirEntry) -> bool {
     is_hidden(entry) || is_system_directory(entry)
 }
 
+/// Check if a path should be skipped (hidden or system directory).
+/// Combines `is_hidden_path` and `is_system_directory_path` checks,
+/// for walkers that do not hand out a [`walkdir::DirEntry`].
+#[must_use]
+pub fn should_skip_path(path: &Path) -> bool {
+    is_hidden_path(path) || is_system_directory_path(path)
+}
+
 /// Check if directory is empty (contains no files or subdirectories)
 pub fn is_directory_empty(dir: &Path) -> bool {
     for entry in WalkDir::new(dir).into_iter().filter_map(std::result::Result::ok) {
diff --git a/src/semantic_line_breaks/comments.rs b/src/semantic_line_breaks/comments.rs
index 15093dc..d65cbb6 100644
--- a/src/semantic_line_breaks/comments.rs
+++ b/src/semantic_line_breaks/comments.rs
@@ -12,7 +12,7 @@ use regex::Regex;
 use super::markdown;
 use super::scanner::{ScanState, scan_line_buffered};
 use super::string_syntax::{StringSyntax, string_syntax};
-use super::types::{FileKind, FormatOptions, Region, Violation, ViolationKind};
+use super::types::{CommentStyle, FileKind, FormatOptions, Region, Violation, ViolationKind};
 use crate::{leading_whitespace, starts_with_ignore_case};
 
 /// Matches the opening of a Python docstring and captures indentation, string prefix, quotes, and the rest.
@@ -159,6 +159,22 @@ pub fn split_source_regions_scanned(lines: &[&str], kind: FileKind, scan: &LineS
     regions
 }
 
+/// Whether a line comment already sits directly above the given line.
+///
+/// A comment moved above such a line would be reflowed together with the comment above it,
+/// which merges two separate notes into one sentence, so those lines are reported but not fixed.
+fn has_comment_line_above(lines: &[&str], index: usize, style: &CommentStyle, inside_string: &[bool]) -> bool {
+    let Some(previous) = index.checked_sub(1) else {
+        return false;
+    };
+    if inside_string.get(previous).copied().unwrap_or(false) {
+        return false;
+    }
+    lines
+        .get(previous)
+        .is_some_and(|line| line_marker(line.trim_start(), style.line_markers).is_some())
+}
+
 /// Find trailing comments and build replacement line pairs for each affected line.
 ///
 /// Returns one entry per input line, `Some((comment_line, code_line))` for lines to split,
@@ -185,6 +201,7 @@ pub fn fix_trailing_comments_scanned(
     let Some(syntax) = string_syntax(kind) else {
         return (replacements, violations);
     };
+    let style = kind.comment_style();
     for (index, line) in lines.iter().enumerate() {
         let Some(comment_start) = scan.comment_start.get(index).copied().flatten() else {
             continue;
@@ -195,6 +212,19 @@ pub fn fix_trailing_comments_scanned(
         if is_directive(&trailing.text, options) {
             continue;
         }
+        // A comment moved above a line that already has a comment above it joins that comment block,
+        // and the reflow then merges two separate notes into one sentence.
+        // The move is reported so the line can be fixed by hand, but it is not made automatically.
+        if has_comment_line_above(lines, index, &style, &scan.inside_string) {
+            violations.push(Violation {
+                line: index + 1,
+                column: Some(trailing.column),
+                kind: ViolationKind::TrailingComment,
+                message: "comment shares a line with code, a comment already sits above it".into(),
+                fixable: false,
+            });
+            continue;
+        }
         let indent = leading_whitespace(line);
         let comment_line = format!("{indent}{} {}", syntax.line_marker, trailing.text);
         violations.push(Violation {
@@ -741,6 +771,73 @@ mod test_docstrings {
     }
 }
 
+#[cfg(test)]
+mod test_comment_above_code {
+    use super::test_helpers::*;
+    use super::*;
+
+    #[test]
+    fn a_comment_directly_above_the_code_blocks_the_move() {
+        let lines = [
+            "// Various dotted prefixes all below threshold of 15",
+            "let x = 1; // 6 chars",
+        ];
+        let (replacements, violations) = fix(&lines, FileKind::Rust);
+        assert!(replacements.iter().all(Option::is_none));
+        assert_eq!(violations.len(), 1);
+        assert_eq!(violations[0].kind, ViolationKind::TrailingComment);
+        assert_eq!(violations[0].line, 2);
+        assert!(!violations[0].fixable);
+        assert!(violations[0].message.contains("a comment already sits above it"));
+    }
+
+    #[test]
+    fn a_doc_comment_above_the_code_also_blocks_the_move() {
+        let lines = ["/// documented", "let x = 1; // note"];
+        let (replacements, violations) = fix(&lines, FileKind::Rust);
+        assert!(replacements.iter().all(Option::is_none));
+        assert!(!violations[0].fixable);
+    }
+
+    #[test]
+    fn a_blank_line_above_the_code_still_allows_the_move() {
+        let lines = ["// a note", "", "let x = 1; // 6 chars"];
+        let (replacements, violations) = fix(&lines, FileKind::Rust);
+        assert_eq!(replacements[2], Some(pair("// 6 chars", "let x = 1;")));
+        assert!(violations[0].fixable);
+    }
+
+    #[test]
+    fn code_above_the_code_still_allows_the_move() {
+        let lines = ["let y = 2;", "let x = 1; // 6 chars"];
+        let (replacements, _) = fix(&lines, FileKind::Rust);
+        assert_eq!(replacements[1], Some(pair("// 6 chars", "let x = 1;")));
+    }
+
+    #[test]
+    fn the_first_line_of_a_file_still_allows_the_move() {
+        assert_eq!(
+            replacement("let x = 1; // one", FileKind::Rust),
+            Some(pair("// one", "let x = 1;"))
+        );
+    }
+
+    #[test]
+    fn a_hash_comment_above_the_code_blocks_the_move() {
+        let lines = ["# a note", "value = 1  # 6 chars"];
+        let (replacements, violations) = fix(&lines, FileKind::Python);
+        assert!(replacements.iter().all(Option::is_none));
+        assert!(!violations[0].fixable);
+    }
+
+    #[test]
+    fn a_comment_inside_a_string_above_the_code_does_not_block_the_move() {
+        let lines = ["let text = \"", "// not a comment", "\";", "let x = 1; // note"];
+        let (replacements, _) = fix(&lines, FileKind::Rust);
+        assert_eq!(replacements[3], Some(pair("// note", "let x = 1;")));
+    }
+}
+
 #[cfg(test)]
 mod test_trailing_rust {
     use super::test_helpers::*;
diff --git a/src/semantic_line_breaks/formatter.rs b/src/semantic_line_breaks/formatter.rs
index 7e104d0..d10bd4f 100644
--- a/src/semantic_line_breaks/formatter.rs
+++ b/src/semantic_line_breaks/formatter.rs
@@ -250,7 +250,15 @@ mod test_split_and_assemble {
 #[cfg(test)]
 mod test_format {
     use super::*;
-    use crate::semantic_line_breaks::types::ViolationKind;
+    use crate::semantic_line_breaks::types::{RuleSet, ViolationKind};
+
+    /// Options with every rule on, including the opt-in trailing comment rule.
+    fn all_rules() -> FormatOptions {
+        FormatOptions {
+            rules: RuleSet::ALL,
+            ..FormatOptions::default()
+        }
+    }
 
     #[test]
     fn check_matches_format_violations() {
@@ -284,7 +292,7 @@ mod test_format {
     #[test]
     fn moves_trailing_comment_above_code_with_crlf() {
         let text = "fn f() {\r\n    let x = 1; // one\r\n}\r\n";
-        let result = format(text, FileKind::Rust, &FormatOptions::default());
+        let result = format(text, FileKind::Rust, &all_rules());
         assert_eq!(
             result.fixed_text.as_deref(),
             Some("fn f() {\r\n    // one\r\n    let x = 1;\r\n}\r\n")
@@ -293,6 +301,40 @@ mod test_format {
         assert_eq!(result.violations[0].line, 2);
     }
 
+    #[test]
+    fn a_trailing_comment_under_a_comment_is_reported_but_left_in_place() {
+        let text = concat!(
+            "// Various dotted prefixes all below threshold of 15\n",
+            "std::fs::write(root.join(\"One.Two.File.001.mp4\"), \"\").unwrap(); // 6 chars\n",
+        );
+        let result = format(text, FileKind::Rust, &all_rules());
+        assert_eq!(result.fixed_text, None);
+        assert_eq!(result.violations.len(), 1);
+        assert_eq!(result.violations[0].kind, ViolationKind::TrailingComment);
+        assert_eq!(result.violations[0].line, 2);
+        assert!(!result.violations[0].fixable);
+    }
+
+    #[test]
+    fn a_trailing_comment_without_a_comment_above_is_still_moved() {
+        let text = "let x = 1; // 6 chars\n";
+        let result = format(text, FileKind::Rust, &all_rules());
+        assert_eq!(result.fixed_text.as_deref(), Some("// 6 chars\nlet x = 1;\n"));
+        assert!(result.violations[0].fixable);
+        // The fixed text is stable, the moved comment is not merged into anything.
+        let second = format("// 6 chars\nlet x = 1;\n", FileKind::Rust, &all_rules());
+        assert_eq!(second.fixed_text, None);
+        assert!(second.violations.is_empty());
+    }
+
+    #[test]
+    fn the_trailing_rule_is_off_unless_it_is_enabled() {
+        let text = "let x = 1; // one\n";
+        let result = format(text, FileKind::Rust, &FormatOptions::default());
+        assert_eq!(result.fixed_text, None);
+        assert!(result.violations.is_empty());
+    }
+
     #[test]
     fn ignore_file_marker_disables_formatting() {
         let text = "<!-- slb-ignore-file -->\nthe quick brown fox\njumps over the dog.\n";
@@ -355,7 +397,7 @@ mod test_format {
             "// Keep this comment.\n",
             "const next = 1;\n",
         );
-        let options = FormatOptions::default();
+        let options = all_rules();
         for kind in [FileKind::JavaScript, FileKind::CLike, FileKind::Rust, FileKind::Go] {
             let first = format(text, kind, &options);
             assert_eq!(first.fixed_text.as_deref(), Some(expected), "{kind:?}");
@@ -406,15 +448,23 @@ mod test_format {
             "code //// literal; not prose\n",
             "// wrapped block\n",
             "// content.\n",
-            "// next note\n",
-            "*/ let next = 1;\n",
+            // The block content line above the code keeps the trailing comment in place,
+            // so nothing is inserted inside the block comment.
+            "*/ let next = 1; // next note\n",
         );
-        let options = FormatOptions::default();
+        let options = all_rules();
         for kind in [FileKind::Rust, FileKind::Go, FileKind::CLike, FileKind::JavaScript] {
             let first = format(text, kind, &options);
             assert_eq!(first.fixed_text.as_deref(), Some(expected), "{kind:?}");
             assert_eq!(check(text, kind, &options), first.violations, "{kind:?}");
-            assert_eq!(format(expected, kind, &options), FormatResult::default(), "{kind:?}");
+            // The trailing comment that cannot be moved is still reported, so only the fix is checked.
+            let second = format(expected, kind, &options);
+            assert_eq!(second.fixed_text, None, "{kind:?}");
+            assert!(
+                second.violations.iter().all(|violation| !violation.fixable),
+                "{kind:?}: {:?}",
+                second.violations
+            );
         }
     }
 
@@ -443,7 +493,7 @@ mod test_format {
             "// next note\n",
             "*/ let next = 1;\n",
         );
-        let options = FormatOptions::default();
+        let options = all_rules();
         for kind in [FileKind::Rust, FileKind::Go, FileKind::CLike, FileKind::JavaScript] {
             let first = format(text, kind, &options);
             assert_eq!(first.fixed_text.as_deref(), Some(expected), "{kind:?}");
@@ -456,7 +506,7 @@ mod test_format {
     fn regex_hashes_are_preserved_while_real_hash_comments_are_formatted() {
         let text = "pattern = /[ #/]/ # Match a delimiter.\nnext = 1 # Keep this comment.\n";
         let expected = "# Match a delimiter.\npattern = /[ #/]/\n# Keep this comment.\nnext = 1\n";
-        let options = FormatOptions::default();
+        let options = all_rules();
         for kind in [FileKind::Python, FileKind::Shell, FileKind::Toml, FileKind::Yaml] {
             assert_eq!(
                 format(text, kind, &options).fixed_text.as_deref(),
@@ -469,7 +519,7 @@ mod test_format {
 
     #[test]
     fn quoted_slashes_in_division_and_paths_preserve_code() {
-        let options = FormatOptions::default();
+        let options = all_rules();
         for (kind, code) in [
             (FileKind::Python, r#"value = default / len("/# not a comment")"#),
             (FileKind::Python, r#"value = default / len(["]/# not a comment"])"#),
@@ -534,7 +584,7 @@ mod test_format {
             "// Keep this comment.\n",
             "const next = 1;\n",
         );
-        let options = FormatOptions::default();
+        let options = all_rules();
         assert_eq!(
             format(text, FileKind::JavaScript, &options).fixed_text.as_deref(),
             Some(expected)
diff --git a/src/semantic_line_breaks/regex_literals.rs b/src/semantic_line_breaks/regex_literals.rs
index 8f8e48e..449ef59 100644
--- a/src/semantic_line_breaks/regex_literals.rs
+++ b/src/semantic_line_breaks/regex_literals.rs
@@ -648,10 +648,18 @@ mod test_regex_literals {
         );
         let lines = [
             r"const expression = /[/*]/; /* real block",
-            "// inside the block",
+            "inside the block",
             "*/ const next = 1; // c",
         ];
         assert_eq!(replaced_indices(&lines, FileKind::JavaScript), vec![2]);
+
+        // A comment line just above the code keeps the trailing comment in place.
+        let with_comment_above = [
+            r"const expression = /[/*]/; /* real block",
+            "// inside the block",
+            "*/ const next = 1; // c",
+        ];
+        assert!(replaced_indices(&with_comment_above, FileKind::JavaScript).is_empty());
     }
 
     #[test]
diff --git a/src/semantic_line_breaks/types.rs b/src/semantic_line_breaks/types.rs
index 1c93c2b..13741a2 100644
--- a/src/semantic_line_breaks/types.rs
+++ b/src/semantic_line_breaks/types.rs
@@ -607,6 +607,19 @@ impl RuleSet {
         trailing_comment: true,
     };
 
+    /// Rules enabled when the caller asks for no particular set.
+    ///
+    /// Trailing comment fixing is left out.
+    /// It rewrites code lines and the result often reads worse than the original,
+    /// so it has to be asked for.
+    pub const DEFAULT: Self = Self {
+        line_too_long: true,
+        mid_clause_break: true,
+        semicolon: true,
+        em_dash: true,
+        trailing_comment: false,
+    };
+
     /// No rules enabled.
     pub const NONE: Self = Self {
         line_too_long: false,
@@ -647,7 +660,7 @@ impl RuleSet {
 
 impl Default for RuleSet {
     fn default() -> Self {
-        Self::ALL
+        Self::DEFAULT
     }
 }
 
@@ -669,7 +682,7 @@ impl Default for FormatOptions {
             tab_width: DEFAULT_TAB_WIDTH,
             join_sentences: false,
             allow_word_break: false,
-            rules: RuleSet::ALL,
+            rules: RuleSet::DEFAULT,
             abbreviations: crate::strings_from(DEFAULT_ABBREVIATIONS),
             clause_starters: Vec::new(),
             directive_prefixes: crate::strings_from(DEFAULT_DIRECTIVE_PREFIXES),
@@ -1117,7 +1130,7 @@ mod test_options_and_prefixes {
         let defaults = FormatOptions::default();
         assert_eq!(options.max_width, 72);
         assert_eq!(options.tab_width, DEFAULT_TAB_WIDTH);
-        assert_eq!(options.rules, RuleSet::ALL);
+        assert_eq!(options.rules, RuleSet::DEFAULT);
         assert_eq!(options.abbreviations, defaults.abbreviations);
         assert_eq!(options.directive_prefixes, defaults.directive_prefixes);
         assert_eq!(options.preserve_lowercase, defaults.preserve_lowercase);
@@ -1128,8 +1141,8 @@ mod test_options_and_prefixes {
     }
 
     #[test]
-    fn the_rule_set_defaults_to_all_rules() {
-        assert_eq!(RuleSet::default(), RuleSet::ALL);
+    fn the_rule_set_defaults_to_every_rule_except_trailing_comments() {
+        assert_eq!(RuleSet::default(), RuleSet::DEFAULT);
         assert_eq!(RuleSet::from_kinds(&[]), RuleSet::NONE);
         for kind in [
             ViolationKind::LineTooLong,
@@ -1144,6 +1157,18 @@ mod test_options_and_prefixes {
         }
     }
 
+    #[test]
+    fn the_default_rule_set_differs_from_all_rules_only_in_trailing_comments() {
+        const { assert!(!RuleSet::DEFAULT.trailing_comment) };
+        assert_eq!(
+            RuleSet {
+                trailing_comment: true,
+                ..RuleSet::DEFAULT
+            },
+            RuleSet::ALL
+        );
+    }
+
     #[test]
     fn openers_and_closers_are_recognized() {
         for character in ['(', '[', '{', '"', '\'', '“', '‘', '«'] {
diff --git a/tests/fixtures/sample_config.toml b/tests/fixtures/sample_config.toml
index 4238b45..03ddaa0 100644
--- a/tests/fixtures/sample_config.toml
+++ b/tests/fixtures/sample_config.toml
@@ -99,7 +99,7 @@ verbose = false
 [slb]
 width = 110
 use_project_config = true
-rules = ["too-long", "mid-clause", "semicolon", "em-dash", "trailing"]
+rules = ["too-long", "mid-clause", "semicolon", "em-dash"]
 join_sentences = false
 allow_word_break = false
 extensions = ["rs", "md"]
diff --git a/tests/fixtures/slb/rust_doc_comments.out.rs b/tests/fixtures/slb/rust_doc_comments.out.rs
index 356b0bd..ac927a9 100644
--- a/tests/fixtures/slb/rust_doc_comments.out.rs
+++ b/tests/fixtures/slb/rust_doc_comments.out.rs
@@ -17,8 +17,7 @@
 /// Returns an error when the input is empty.
 pub fn parse(input: &str) -> Header {
     // Use the default width for now.
-    // default width
-    let width = 80;
+    let width = 80; // default width
     // not a URL comment
     let url = "http://example.com";
     Header::new(input, width) // clippy::allow
diff --git a/tests/fixtures/slb/yaml_comments.out.yml b/tests/fixtures/slb/yaml_comments.out.yml
index 53d39db..7cbead2 100644
--- a/tests/fixtures/slb/yaml_comments.out.yml
+++ b/tests/fixtures/slb/yaml_comments.out.yml
@@ -1,6 +1,5 @@
 # Top level comment that wraps in the middle.
-# trailing note
-key: value
+key: value # trailing note
 url: http://example.com/#anchor
 script: |
   echo "# not a comment"
diff --git a/tests/slb_cli_tests.rs b/tests/slb_cli_tests.rs
index 5cf8e17..c1fab3b 100644
--- a/tests/slb_cli_tests.rs
+++ b/tests/slb_cli_tests.rs
@@ -294,7 +294,7 @@ fn a_trailing_comment_is_moved_above_the_code() {
     let directory = temporary_directory();
     let path = write_file(&directory, "trailing.rs", "let width = 80; // default width\n");
 
-    let output = run(&[&argument(&path), "--fix"]);
+    let output = run(&[&argument(&path), "--trailing", "--fix"]);
 
     assert_eq!(exit_code(&output), 0);
     assert_eq!(
@@ -303,12 +303,49 @@ fn a_trailing_comment_is_moved_above_the_code() {
     );
 }
 
+#[test]
+fn a_trailing_comment_is_left_alone_without_the_trailing_flag() {
+    let directory = temporary_directory();
+    let path = write_file(&directory, "trailing.rs", "let width = 80; // default width\n");
+
+    let output = run(&[&argument(&path), "--fix"]);
+
+    assert_eq!(exit_code(&output), 0);
+    assert_eq!(
+        std::fs::read_to_string(&path).expect("file should be readable"),
+        "let width = 80; // default width\n"
+    );
+}
+
+#[test]
+fn a_trailing_comment_under_a_comment_is_reported_but_not_fixed() {
+    let directory = temporary_directory();
+    let path = write_file(
+        &directory,
+        "trailing.rs",
+        "// Various dotted prefixes all below threshold of 15\nlet width = 80; // 6 chars\n",
+    );
+
+    let output = run(&[&argument(&path), "--trailing", "--fix"]);
+
+    assert_eq!(exit_code(&output), 1);
+    assert_eq!(
+        std::fs::read_to_string(&path).expect("file should be readable"),
+        "// Various dotted prefixes all below threshold of 15\nlet width = 80; // 6 chars\n"
+    );
+    assert!(
+        stdout(&output).contains("a comment already sits above it"),
+        "{}",
+        stdout(&output)
+    );
+}
+
 #[test]
 fn a_directive_comment_is_left_on_the_code_line() {
     let directory = temporary_directory();
     let path = write_file(&directory, "directive.rs", "let value = 1; // clippy::all\n");
 
-    let output = run(&[&argument(&path), "--fix"]);
+    let output = run(&[&argument(&path), "--trailing", "--fix"]);
 
     assert_eq!(exit_code(&output), 0);
     assert_eq!(
@@ -351,6 +388,52 @@ fn excluded_directories_are_skipped_when_walking() {
     );
 }
 
+#[test]
+fn a_command_line_exclude_keeps_the_default_excludes() {
+    let directory = temporary_directory();
+    write_file(&directory, "target/long.rs", TWO_SENTENCES);
+    write_file(&directory, "other/long.rs", TWO_SENTENCES);
+    write_file(&directory, "kept/clean.rs", "/// Short comment.\n");
+
+    let output = run(&[&argument(directory.path()), "-w", "40", "--exclude", "other"]);
+
+    assert_eq!(exit_code(&output), 0);
+    assert!(
+        stdout(&output).contains("Checked 1 file, no violations"),
+        "{}",
+        stdout(&output)
+    );
+}
+
+#[test]
+fn gitignored_files_are_skipped_unless_the_ignore_rules_are_off() {
+    let directory = temporary_directory();
+    write_file(&directory, ".gitignore", "generated/\n");
+    write_file(&directory, "generated/long.rs", TWO_SENTENCES);
+    write_file(&directory, "kept/clean.rs", "/// Short comment.\n");
+    Command::new("git")
+        .args(["init", "--quiet"])
+        .current_dir(directory.path())
+        .status()
+        .expect("git init should run");
+
+    let output = run(&[&argument(directory.path()), "-w", "40"]);
+    assert_eq!(exit_code(&output), 0);
+    assert!(
+        stdout(&output).contains("Checked 1 file, no violations"),
+        "{}",
+        stdout(&output)
+    );
+
+    let without_ignore = run(&[&argument(directory.path()), "-w", "40", "--no-ignore", "--quiet"]);
+    assert_eq!(exit_code(&without_ignore), 1);
+    assert!(
+        stdout(&without_ignore).contains("Checked 2 files"),
+        "{}",
+        stdout(&without_ignore)
+    );
+}
+
 #[test]
 fn the_extension_filter_limits_the_walked_files() {
     let directory = temporary_directory();
diff --git a/tests/slb_integration_tests.rs b/tests/slb_integration_tests.rs
index 5490db1..35768bc 100644
--- a/tests/slb_integration_tests.rs
+++ b/tests/slb_integration_tests.rs
@@ -7,7 +7,7 @@
 use std::fs;
 use std::path::{Path, PathBuf};
 
-use cli_tools::semantic_line_breaks::{FileKind, FormatOptions, format};
+use cli_tools::semantic_line_breaks::{FileKind, FormatOptions, RuleSet, format};
 
 /// Directory holding the fixture pairs.
 fn fixture_directory() -> PathBuf {
@@ -41,7 +41,11 @@ fn assert_fixture(input_name: &str, output_name: &str) {
     let input = read_fixture(input_name);
     let expected = read_fixture(output_name);
     let kind = FileKind::from_path(Path::new(output_name)).expect("fixture should have a known kind");
-    let options = FormatOptions::default();
+    // The fixtures cover the opt-in trailing comment rule too, so every rule is on here.
+    let options = FormatOptions {
+        rules: RuleSet::ALL,
+        ..FormatOptions::default()
+    };
 
     let result = format(&input, kind, &options);
     let actual = result.fixed_text.unwrap_or_else(|| input.clone());