diff --git a/.taskmaster/docs/atomic-prd.txt b/.taskmaster/docs/atomic-prd.txt
new file mode 100644
index 0000000..3061689
--- /dev/null
+++ b/.taskmaster/docs/atomic-prd.txt
@@ -0,0 +1,208 @@
+# Atomic Identifiers Feature - Product Requirements Document
+
+## Executive Summary
+Add support for treating certain identifiers as "atomic" - indivisible units that should not have word boundaries detected during case transformations. This solves the problem where compound brand names like "DocSpring" or "GitHub" need to maintain their identity as single words in all case styles.
+
+## Problem Statement
+Currently, when renaming identifiers like "DocSpring" or "GitHub", renamify detects word boundaries and generates variants like:
+- `doc_spring` (snake_case)
+- `doc-spring` (kebab-case)
+- `DOC_SPRING` (SCREAMING_SNAKE_CASE)
+
+However, these brand names should be treated as single, indivisible units:
+- `docspring` (snake_case)
+- `docspring` (kebab-case)
+- `DOCSPRING` (SCREAMING_SNAKE_CASE)
+- `DocSpring` (PascalCase - the only time there is a word break)
+
+This is similar to Rails' `inflect.acronym` feature, but for compound words that aren't acronyms.
+
+## User Stories
+
+### Story 1: CLI User with Atomic Identifiers
+As a developer renaming "HubGit" to "GitHub" in my codebase,
+I want to specify that both names are atomic,
+So that `hubgit_api` becomes `github_api` (not `git_hub_api`).
+
+### Story 2: Project with Persistent Atomic Configuration
+As a team maintaining a project with brand names like "DocSpring",
+I want to configure these as atomic in a config file,
+So that all team members automatically get correct renaming behavior.
+
+### Story 3: VS Code Extension User
+As a VS Code user,
+I want checkboxes to mark search/replace terms as atomic,
+So that I can control word boundary detection visually.
+
+### Story 4: Partial Atomic Matching
+As a developer with "FormAPIController" in my code,
+I want atomic "FormAPI" to match and replace the atomic portion correctly,
+So that it becomes "DocSpringController" (not "DocSpringAPIController").
+
+## Functional Requirements
+
+### 1. Core Atomic Detection
+- When an identifier is marked as atomic, it should be treated as a single token
+- Atomic identifiers should not have internal word boundaries detected
+- The atomic property applies to the identifier wherever it appears (standalone or as part of larger identifiers)
+
+### 2. CLI Flags
+- `--atomic` - Both search and replace are atomic
+- `--atomic-search` - Only search term is atomic
+- `--atomic-replace` - Only replace term is atomic
+- `--no-atomic` - Override config, treat as normal
+- `--no-atomic-search` - Override config for search term
+- `--no-atomic-replace` - Override config for replace term
+- Error if user specifies both `--atomic` and `--atomic-search`/`--atomic-replace`
+
+### 3. Configuration File
+- Support `atomic = ["DocSpring", "GitHub", "GitHub"]` in `.renamify/config.toml`
+- Config entries are case-insensitive matched (PascalCase in config matches all cases)
+- Config auto-applies when matching identifiers are used
+- CLI flags override config settings
+
+### 4. Variant Generation
+For atomic identifier "DocSpring":
+- Generate only: `DocSpring`, `docspring`, `DOCSPRING`
+- Do NOT generate: `doc_spring`, `DOC_SPRING`, `doc-spring`, `docSpring`
+
+### 5. Compound Identifier Handling
+When "FormAPI" is atomic:
+- `FormAPIController` → `DocSpringController`
+- `form_api_client` → `docspring_client`
+- `FORMAPI_TOKEN` → `DOCSPRING_TOKEN`
+- The atomic portion is preserved as a unit within larger identifiers
+
+### 6. VS Code Extension
+- Add "Atomic" checkbox under Search field with tooltip
+- Add "Atomic" checkbox under Replace field with tooltip
+- Tooltips explain: "Treat as indivisible (no word boundaries)"
+- Pre-check boxes if terms match config entries
+
+### 7. MCP Server
+- Add `atomicSearch: boolean` parameter
+- Add `atomicReplace: boolean` parameter
+- Read and respect `.renamify/config.toml` atomic entries
+
+## Technical Requirements
+
+### 1. Case Model Refactoring
+- Split `case_model.rs` into smaller modules (it's currently 1100 lines)
+- Create `atomic.rs` module for atomic-specific logic
+- Maintain backward compatibility
+
+### 2. Token Generation
+- Modify `parse_to_tokens` to accept atomic hints
+- When atomic, return single token regardless of internal capitals
+- Preserve existing behavior when not atomic
+
+### 3. Variant Map Generation
+- Update `generate_variant_map` to accept atomic flags
+- Generate limited variants for atomic identifiers
+- Handle mixed atomic/non-atomic scenarios
+
+### 4. Testing
+- Unit tests for atomic token parsing
+- Integration tests for compound identifiers
+- End-to-end tests with real examples (DocSpring, GitHub)
+- Performance tests to ensure no regression
+
+## Non-Functional Requirements
+
+### 1. Performance
+- Atomic detection should not significantly impact scan performance
+- Config file parsing should be cached
+
+### 2. Documentation
+- Create "Atomic Identifiers" page in Features section
+- Include examples of when to use atomic mode
+- Document config file format
+
+### 3. Error Handling
+- Clear error messages for conflicting flags
+- Warn if atomic identifier contains delimiters
+
+## Acceptance Criteria
+
+### Test Case 1: Basic Atomic Renaming
+```bash
+renamify rename GitLab GitHub --atomic
+```
+- `git_lab_api` → `GitHub_api`
+- `GIT_LAB_TOKEN` → `GitHub_TOKEN`
+- `GitLabController` → `GitHubController`
+
+### Test Case 2: Config File Auto-Application
+`.renamify/config.toml`:
+```toml
+atomic = ["DocSpring"]
+```
+```bash
+renamify rename DocSpring Helper
+```
+- `docspring_api` → `helper_api` (NOT `doc_spring_api` → `helper_api`)
+
+### Test Case 3: Partial Identifier Matching
+```bash
+renamify rename FormAPI DocSpring --atomic
+```
+- `FormAPIController` → `DocSpringController`
+- `useFormAPIHook` → `useDocSpringHook`
+
+### Test Case 4: Override Config
+`.renamify/config.toml`:
+```toml
+atomic = ["DocSpring"]
+```
+```bash
+renamify rename DocSpring doc_spring --no-atomic-search
+```
+- `DocSpring` → `doc_spring` (word boundary detected due to override)
+
+## Implementation Plan
+
+### Phase 1: Core Support (Week 1)
+1. Refactor case_model.rs into modules
+2. Implement atomic token parsing
+3. Update variant generation
+4. Add comprehensive tests
+
+### Phase 2: CLI Integration (Week 1)
+1. Add CLI flags
+2. Implement config file support
+3. Wire up to plan operation
+4. Add integration tests
+
+### Phase 3: UI Integration (Week 2)
+1. Update VS Code extension
+2. Update MCP server
+3. Add tooltips and help text
+4. End-to-end testing
+
+### Phase 4: Documentation (Week 2)
+1. Create atomic identifiers documentation
+2. Update existing docs with atomic examples
+3. Add to README and help text
+
+## Success Metrics
+- All test cases pass
+- No performance regression (scan time within 5% of baseline)
+- User feedback positive on solving word boundary issues
+- Documentation clear (no support questions about basic usage)
+
+## Risks and Mitigations
+
+### Risk 1: Breaking Changes
+**Mitigation**: Atomic mode is opt-in, existing behavior unchanged by default
+
+### Risk 2: Performance Impact
+**Mitigation**: Early detection during parsing, benchmark before/after
+
+### Risk 3: User Confusion
+**Mitigation**: Clear documentation, intuitive naming ("atomic"), helpful tooltips
+
+## Future Enhancements
+- Support for regex patterns in atomic config
+- Auto-detection of likely atomic identifiers based on casing patterns
+- Project-specific dictionaries of atomic terms
+- Integration with language-specific naming conventions
diff --git a/CLAUDE.md b/CLAUDE.md
index 06f0dd4..88a7714 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -136,6 +136,11 @@ Exit codes:
 
 - append only with checksums and revert info
 
+`.renamify/config.toml`
+
+- Project configuration including atomic identifiers
+- `atomic = ["DocSpring", "GitHub", "GitHub"]` - identifiers treated as indivisible units
+
 ## Search and plan algorithm
 
 1. Detect input case of `<old>` and `<new>`
diff --git a/docs/astro.config.mjs b/docs/astro.config.mjs
index 469e8f2..7ff5cf6 100644
--- a/docs/astro.config.mjs
+++ b/docs/astro.config.mjs
@@ -63,6 +63,10 @@ export default defineConfig({
               label: 'Resolving Case Ambiguity',
               slug: 'features/ambiguity-resolution',
             },
+            {
+              label: 'Atomic Identifiers',
+              slug: 'features/atomic-identifiers',
+            },
           ],
         },
         {
diff --git a/docs/src/content/docs/commands/plan.mdx b/docs/src/content/docs/commands/plan.mdx
index 4516fb4..d43e3d7 100644
--- a/docs/src/content/docs/commands/plan.mdx
+++ b/docs/src/content/docs/commands/plan.mdx
@@ -58,6 +58,18 @@ renamify plan <OLD> <NEW> [PATHS]... [OPTIONS]
 - `--exclude-acronyms <ACRONYMS>` - Exclude specific acronyms from detection
 - `--only-acronyms <ACRONYMS>` - Only use these acronyms, ignore defaults
 
+### Atomic Mode
+
+"Atomic" means treating a search or replace identifier as a single unit,
+not splitting it into separate components. E.g. GitHub → github, not git_hub
+
+- `--atomic` - Treat both search and replace terms as indivisible units
+- `--atomic-search` - Only treat search term as atomic
+- `--atomic-replace` - Only treat replace term as atomic
+- `--no-atomic` - Disable atomic mode (override config)
+- `--no-atomic-search` - Disable atomic for search term
+- `--no-atomic-replace` - Disable atomic for replace term
+
 ### Display Options
 
 - `--fixed-table-width` - Use fixed column widths in table output for consistent
@@ -171,6 +183,19 @@ renamify plan old_name new_name src/ tests/
 renamify plan old_name new_name --dry-run
 ```
 
+### Atomic Mode
+
+```bash
+# Treat compound words as single units
+renamify plan DocSpring FormAPI --atomic
+
+# Only search term is atomic
+renamify plan DocSpring form_api --atomic-search
+
+# Only replace term is atomic
+renamify plan doc_spring FormAPI --atomic-replace
+```
+
 ### Excluding Lines by Pattern
 
 ```bash
diff --git a/docs/src/content/docs/commands/rename.mdx b/docs/src/content/docs/commands/rename.mdx
index 03d3f55..78a5476 100644
--- a/docs/src/content/docs/commands/rename.mdx
+++ b/docs/src/content/docs/commands/rename.mdx
@@ -67,6 +67,18 @@ renamify rename <OLD> <NEW> [PATHS]... [OPTIONS]
 - `--exclude-acronyms <ACRONYMS>` - Exclude specific acronyms from detection
 - `--only-acronyms <ACRONYMS>` - Only use these acronyms, ignore defaults
 
+### Atomic Mode
+
+"Atomic" means treating a search or replace identifier as a single unit,
+not splitting it into separate components. E.g. GitHub → github, not git_hub
+
+- `--atomic` - Treat both search and replace terms as indivisible units
+- `--atomic-search` - Only treat search term as atomic
+- `--atomic-replace` - Only treat replace term as atomic
+- `--no-atomic` - Disable atomic mode (override config)
+- `--no-atomic-search` - Disable atomic for search term
+- `--no-atomic-replace` - Disable atomic for replace term
+
 ### Display Options
 
 - `--fixed-table-width` - Use fixed column widths in table output for consistent
@@ -114,6 +126,16 @@ renamify rename oldApi newApi \
   --exclude "**/*test*,node_modules/**"
 ```
 
+### Atomic Mode
+
+```bash
+# Treat compound words as single units
+renamify rename DocSpring FormAPI --atomic
+
+# Without --atomic, DocSpring would match doc_spring in snake_case
+# With --atomic, DocSpring only matches docspring (as single unit)
+```
+
 ### Case Style Control
 
 ```bash
diff --git a/docs/src/content/docs/commands/search.mdx b/docs/src/content/docs/commands/search.mdx
index 5cf80de..4258e40 100644
--- a/docs/src/content/docs/commands/search.mdx
+++ b/docs/src/content/docs/commands/search.mdx
@@ -54,6 +54,13 @@ Available styles: `snake`, `kebab`, `camel`, `pascal`, `screaming-snake`,
 - `--ignore-ambiguous` - Ignore mixed-case/ambiguous identifiers that don't
   match standard patterns
 
+### Atomic Mode
+
+- `--atomic` - Treat the search term as an indivisible unit (no word boundaries)
+- `--atomic-search` - Same as `--atomic` for search command
+- `--no-atomic` - Disable atomic mode (override config)
+- `--no-atomic-search` - Same as `--no-atomic` for search command
+
 ### Output Control
 
 - `--preview <format>` - Preview format: `table`, `diff`, `matches`, `summary`
@@ -132,6 +139,15 @@ renamify search myFunction --no-rename-paths
 renamify search cleanName --ignore-ambiguous
 ```
 
+### Atomic Search
+
+Search for compound words as single units:
+
+```bash
+# DocSpring will match as a whole word, not doc_spring
+renamify search DocSpring --atomic
+```
+
 ### JSON Output for Processing
 
 ```bash
diff --git a/docs/src/content/docs/features/atomic-identifiers.mdx b/docs/src/content/docs/features/atomic-identifiers.mdx
new file mode 100644
index 0000000..2be820e
--- /dev/null
+++ b/docs/src/content/docs/features/atomic-identifiers.mdx
@@ -0,0 +1,178 @@
+---
+title: Atomic Identifiers
+description: Treat compound brand names and identifiers as indivisible units during case transformations
+sidebar:
+  order: 7
+---
+
+import { Tabs, TabItem, Code } from '@astrojs/starlight/components';
+
+## Overview
+
+Atomic identifiers allow you to treat compound brand names and identifiers as indivisible units during case transformations. When an identifier is marked as atomic, Renamify preserves it as a single word without detecting internal word boundaries.
+
+This feature is essential for maintaining brand identity and preventing incorrect word splitting in compound names like "DocSpring" or "GitHub".
+
+## The Problem
+
+Without atomic mode, compound identifiers are split at word boundaries:
+
+```bash
+# Without atomic mode
+DocSpring → doc_spring (snake_case)
+DocSpring → doc-spring (kebab-case)
+DocSpring → DOC_SPRING (SCREAMING_SNAKE_CASE)
+```
+
+These transformations break the brand identity and can cause issues when the name should remain as a single unit.
+
+## The Solution
+
+With atomic mode, compound identifiers are preserved as single units:
+
+```bash
+# With atomic mode
+DocSpring → docspring (snake_case)
+DocSpring → docspring (kebab-case)
+DocSpring → DOCSPRING (SCREAMING_SNAKE_CASE)
+DocSpring → DocSpring (PascalCase - preserved)
+```
+
+## Using Atomic Mode
+
+### Command Line Flags
+
+You can specify atomic mode using CLI flags:
+
+<Tabs>
+<TabItem label="Both atomic">
+  ```bash # Both search and replace terms are atomic renamify rename FormAPI
+  DocSpring --atomic
+  ```
+</TabItem>
+<TabItem label="Search only">
+  ```bash # Only search term is atomic renamify rename FormAPI Helper
+  --atomic-search
+  ```
+</TabItem>
+<TabItem label="Replace only">
+
+```bash # Only replace term is atomic renamify rename OldName DocSpring
+--atomic-replace
+```
+
+</TabItem>
+</Tabs>
+
+### Configuration File
+
+You can configure commonly used atomic identifiers in `.renamify/config.toml`:
+
+```toml
+# List of identifiers that should always be treated as atomic
+atomic = ["DocSpring", "GitHub", "FormAPI"]
+```
+
+When configured identifiers are detected, they're automatically treated as atomic without needing CLI flags.
+
+### Overriding Configuration
+
+You can override the configuration file settings:
+
+```bash
+# Override config to allow word boundaries
+renamify rename DocSpring doc_spring --no-atomic-search
+
+# Override for search term only
+renamify rename DocSpring Helper --no-atomic-search
+
+# Override for replace term only
+renamify rename OldName DocSpring --no-atomic-replace
+```
+
+## Real-World Examples
+
+### Renaming a Brand Name
+
+When renaming "FormAPI" to "DocSpring" with atomic mode:
+
+```bash
+renamify rename FormAPI DocSpring --atomic
+```
+
+Results:
+
+- `FormAPIController` → `DocSpringController`
+- `formapi_client` → `docspring_client`
+- `FORMAPI_TOKEN` → `DOCSPRING_TOKEN`
+- `useFormAPIHook` → `useDocSpringHook`
+
+### Partial Matching
+
+Atomic identifiers are preserved even when they appear as part of larger identifiers:
+
+```bash
+# GitHub is atomic
+GitHubActions → GitHubActions (preserved in PascalCase)
+github_api → github_api (preserved as single unit)
+GITHUB_TOKEN → GITHUB_TOKEN (preserved as single unit)
+```
+
+## Case Transformation Behavior
+
+When an identifier is atomic, case transformations follow these rules:
+
+| Case Style           | Non-Atomic | Atomic    |
+| -------------------- | ---------- | --------- |
+| snake_case           | doc_spring | docspring |
+| kebab-case           | doc-spring | docspring |
+| camelCase            | docSpring  | docspring |
+| PascalCase           | DocSpring  | DocSpring |
+| SCREAMING_SNAKE_CASE | DOC_SPRING | DOCSPRING |
+| Train-Case           | Doc-Spring | Docspring |
+| lowercase            | docspring  | docspring |
+| UPPERCASE            | DOCSPRING  | DOCSPRING |
+
+## VS Code Extension
+
+The VS Code extension provides checkboxes for atomic mode:
+
+- **Atomic search**: Treat the search term as an indivisible unit
+- **Atomic replace**: Treat the replace term as an indivisible unit
+
+These checkboxes include tooltips explaining their behavior and are automatically checked when terms match configured atomic identifiers.
+
+## Best Practices
+
+1. **Configure Common Brand Names**: Add frequently used brand names to your `.renamify/config.toml`
+2. **Use for Compound Words**: Apply atomic mode to compound brand names and technical terms that should remain unified
+3. **Consider Context**: Use atomic mode when the identifier's meaning depends on being a single unit
+4. **Test First**: Use `--dry-run` to preview how atomic mode affects your renaming
+
+## Technical Details
+
+### How It Works
+
+1. **Token Parsing**: When atomic mode is enabled, the identifier bypasses normal word boundary detection
+2. **Variant Generation**: Only case variants are generated, not word-separated variants
+3. **Pattern Matching**: The atomic identifier is matched and replaced as a complete unit
+
+### Performance
+
+Atomic mode has minimal performance impact:
+
+- Detection happens during the parsing phase
+- No additional scanning or regex operations required
+- Config file is cached after first read
+
+## Limitations
+
+- Atomic mode applies to the entire identifier - you cannot make part of an identifier atomic
+- Case-insensitive matching is used for configured atomic identifiers
+- Atomic identifiers should not contain delimiters (underscores, hyphens, etc.)
+
+## See Also
+
+- [Case Transformations](/features/case-transformations) - Learn about supported case styles
+- [Configuration](/cli/configuration) - Set up persistent atomic identifiers
+- [CLI Reference](/cli/commands/rename) - Full command options
diff --git a/docs/src/content/docs/mcp/tools.mdx b/docs/src/content/docs/mcp/tools.mdx
index 50d5b00..810d11b 100644
--- a/docs/src/content/docs/mcp/tools.mdx
+++ b/docs/src/content/docs/mcp/tools.mdx
@@ -15,17 +15,18 @@ renaming.
 
 ### Parameters
 
-| Parameter     | Type     | Required | Default     | Description                            |
-| ------------- | -------- | -------- | ----------- | -------------------------------------- |
-| `search`      | string   | ✅ Yes   | -           | The identifier to search for           |
-| `paths`       | string[] | No       | Current dir | Paths to search (files or directories) |
-| `includes`    | string[] | No       | All files   | Glob patterns to include               |
-| `excludes`    | string[] | No       | None        | Glob patterns to exclude               |
-| `styles`      | string[] | No       | All styles  | Case styles to detect                  |
-| `preview`     | string   | No       | `summary`   | Output format                          |
-| `dryRun`      | boolean  | No       | `false`     | Preview without saving                 |
-| `renameFiles` | boolean  | No       | `true`      | Include file renames in search         |
-| `renameDirs`  | boolean  | No       | `true`      | Include directory renames in search    |
+| Parameter      | Type     | Required | Default     | Description                            |
+| -------------- | -------- | -------- | ----------- | -------------------------------------- |
+| `search`       | string   | ✅ Yes   | -           | The identifier to search for           |
+| `paths`        | string[] | No       | Current dir | Paths to search (files or directories) |
+| `includes`     | string[] | No       | All files   | Glob patterns to include               |
+| `excludes`     | string[] | No       | None        | Glob patterns to exclude               |
+| `styles`       | string[] | No       | All styles  | Case styles to detect                  |
+| `preview`      | string   | No       | `summary`   | Output format                          |
+| `dryRun`       | boolean  | No       | `false`     | Preview without saving                 |
+| `renameFiles`  | boolean  | No       | `true`      | Include file renames in search         |
+| `renameDirs`   | boolean  | No       | `true`      | Include directory renames in search    |
+| `atomicSearch` | boolean  | No       | `false`     | Treat search term as indivisible unit  |
 
 ### Example
 
@@ -56,18 +57,20 @@ your identifiers.
 
 ### Parameters
 
-| Parameter     | Type     | Required | Default     | Description                            |
-| ------------- | -------- | -------- | ----------- | -------------------------------------- |
-| `old`         | string   | ✅ Yes   | -           | The identifier to replace              |
-| `new`         | string   | ✅ Yes   | -           | The new identifier                     |
-| `paths`       | string[] | No       | Current dir | Paths to search (files or directories) |
-| `includes`    | string[] | No       | All files   | Glob patterns to include               |
-| `excludes`    | string[] | No       | None        | Glob patterns to exclude               |
-| `styles`      | string[] | No       | All styles  | Case styles to detect                  |
-| `preview`     | string   | No       | `summary`   | Output format                          |
-| `dryRun`      | boolean  | No       | `false`     | Preview without saving                 |
-| `renameFiles` | boolean  | No       | `true`      | Rename matching files                  |
-| `renameDirs`  | boolean  | No       | `true`      | Rename matching directories            |
+| Parameter       | Type     | Required | Default     | Description                            |
+| --------------- | -------- | -------- | ----------- | -------------------------------------- |
+| `old`           | string   | ✅ Yes   | -           | The identifier to replace              |
+| `new`           | string   | ✅ Yes   | -           | The new identifier                     |
+| `paths`         | string[] | No       | Current dir | Paths to search (files or directories) |
+| `includes`      | string[] | No       | All files   | Glob patterns to include               |
+| `excludes`      | string[] | No       | None        | Glob patterns to exclude               |
+| `styles`        | string[] | No       | All styles  | Case styles to detect                  |
+| `preview`       | string   | No       | `summary`   | Output format                          |
+| `dryRun`        | boolean  | No       | `false`     | Preview without saving                 |
+| `renameFiles`   | boolean  | No       | `true`      | Rename matching files                  |
+| `renameDirs`    | boolean  | No       | `true`      | Rename matching directories            |
+| `atomicSearch`  | boolean  | No       | `false`     | Treat search term as indivisible unit  |
+| `atomicReplace` | boolean  | No       | `false`     | Treat replace term as indivisible unit |
 
 ### Case Styles
 
@@ -104,6 +107,21 @@ Arguments: {
 }
 ```
 
+### Atomic Mode Example
+
+```
+Tool: renamify_plan
+Arguments: {
+  "old": "DocSpring",
+  "new": "FormAPI",
+  "atomicSearch": true,
+  "atomicReplace": true,
+  "preview": "summary"
+}
+```
+
+With atomic mode, compound words like "DocSpring" are treated as single units, preventing unwanted word boundary detection (e.g., `doc_spring`).
+
 ### Response Example
 
 ```
@@ -306,7 +324,7 @@ Last Applied:
 
 System:
   Renamify Version: 1.2.0
-  Config: .renamify/config.json found
+  Config: .renamify/config.toml found
   History Entries: 47
 ```
 
@@ -363,16 +381,18 @@ Perform case-aware renaming in a single step (combines plan + apply).
 
 ### Parameters
 
-| Parameter       | Type     | Required | Default     | Description               |
-| --------------- | -------- | -------- | ----------- | ------------------------- |
-| `old`           | string   | ✅ Yes   | -           | The identifier to replace |
-| `new`           | string   | ✅ Yes   | -           | The new identifier        |
-| `paths`         | string[] | No       | Current dir | Paths to search           |
-| `dryRun`        | boolean  | No       | `false`     | Preview without applying  |
-| `preview`       | string   | No       | `summary`   | Preview format            |
-| `excludeStyles` | string[] | No       | None        | Case styles to exclude    |
-| `includeStyles` | string[] | No       | None        | Additional case styles    |
-| `onlyStyles`    | string[] | No       | None        | Use only these styles     |
+| Parameter       | Type     | Required | Default     | Description                       |
+| --------------- | -------- | -------- | ----------- | --------------------------------- |
+| `old`           | string   | ✅ Yes   | -           | The identifier to replace         |
+| `new`           | string   | ✅ Yes   | -           | The new identifier                |
+| `paths`         | string[] | No       | Current dir | Paths to search                   |
+| `dryRun`        | boolean  | No       | `false`     | Preview without applying          |
+| `preview`       | string   | No       | `summary`   | Preview format                    |
+| `excludeStyles` | string[] | No       | None        | Case styles to exclude            |
+| `includeStyles` | string[] | No       | None        | Additional case styles            |
+| `onlyStyles`    | string[] | No       | None        | Use only these styles             |
+| `atomicSearch`  | boolean  | No       | `false`     | Treat search term as indivisible  |
+| `atomicReplace` | boolean  | No       | `false`     | Treat replace term as indivisible |
 
 ### Example Usage
 
diff --git a/renamify-cli/.gitignore b/renamify-cli/.gitignore
new file mode 100644
index 0000000..b25bec5
--- /dev/null
+++ b/renamify-cli/.gitignore
@@ -0,0 +1,2 @@
+# Renamify workspace
+.renamify/
diff --git a/renamify-cli/src/cli/args.rs b/renamify-cli/src/cli/args.rs
index 1f3a742..3382ef8 100644
--- a/renamify-cli/src/cli/args.rs
+++ b/renamify-cli/src/cli/args.rs
@@ -121,6 +121,34 @@ pub struct AcronymArgs {
     pub only_acronyms: Vec<String>,
 }
 
+/// Atomic identifier arguments
+#[derive(Args, Debug, Clone)]
+pub struct AtomicArgs {
+    /// Treat both terms as atomic (single words). E.g. DocSpring becomes docspring in snake_case, not doc_spring
+    #[arg(long, conflicts_with_all = ["atomic_search", "atomic_replace"])]
+    pub atomic: bool,
+
+    /// Treat search term as atomic (GitHub → github, not git_hub)
+    #[arg(long)]
+    pub atomic_search: bool,
+
+    /// Treat replace term as atomic (GitHub → github, not git_hub)
+    #[arg(long)]
+    pub atomic_replace: bool,
+
+    /// Override config: allow word boundary detection
+    #[arg(long, conflicts_with = "atomic")]
+    pub no_atomic: bool,
+
+    /// Override config for search: allow word boundaries
+    #[arg(long, conflicts_with = "atomic_search")]
+    pub no_atomic_search: bool,
+
+    /// Override config for replace: allow word boundaries
+    #[arg(long, conflicts_with = "atomic_replace")]
+    pub no_atomic_replace: bool,
+}
+
 #[derive(Subcommand, Debug)]
 pub enum Commands {
     /// Initialize renamify in the current repository
@@ -258,6 +286,9 @@ pub enum Commands {
         #[command(flatten)]
         acronyms: AcronymArgs,
 
+        #[command(flatten)]
+        atomic: AtomicArgs,
+
         /// Output format for machine consumption
         #[arg(long, value_enum, default_value = "summary")]
         output: OutputFormat,
@@ -374,6 +405,9 @@ pub enum Commands {
         #[command(flatten)]
         acronyms: AcronymArgs,
 
+        #[command(flatten)]
+        atomic: AtomicArgs,
+
         /// Output format for machine consumption
         #[arg(long, value_enum, default_value = "summary")]
         output: OutputFormat,
diff --git a/renamify-cli/src/main.rs b/renamify-cli/src/main.rs
index 966df36..0770e8f 100644
--- a/renamify-cli/src/main.rs
+++ b/renamify-cli/src/main.rs
@@ -75,6 +75,7 @@ fn main() {
             plan_out,
             dry_run,
             acronyms,
+            atomic,
             output,
             quiet,
         } => {
@@ -111,6 +112,7 @@ fn main() {
                 acronyms.include_acronyms,
                 acronyms.exclude_acronyms,
                 acronyms.only_acronyms,
+                atomic,
                 output,
                 quiet,
                 false, // regex flag - not used in Plan command
@@ -173,6 +175,14 @@ fn main() {
                 acronyms.include_acronyms,
                 acronyms.exclude_acronyms,
                 acronyms.only_acronyms,
+                cli::args::AtomicArgs {
+                    atomic: false,
+                    atomic_search: false,
+                    atomic_replace: false,
+                    no_atomic: false,
+                    no_atomic_search: false,
+                    no_atomic_replace: false,
+                },
                 output,
                 quiet,
                 false, // regex flag - not used in Search command
@@ -227,6 +237,7 @@ fn main() {
             no_rename_root,
             dry_run,
             acronyms,
+            atomic: _, // Not implemented in rename yet
             output,
             quiet,
         } => {
diff --git a/renamify-cli/src/plan.rs b/renamify-cli/src/plan.rs
index 36c5b45..89ede8f 100644
--- a/renamify-cli/src/plan.rs
+++ b/renamify-cli/src/plan.rs
@@ -2,7 +2,7 @@ use anyhow::Result;
 use renamify_core::{plan_operation, OutputFormatter, Style};
 use std::path::PathBuf;
 
-use crate::cli::{types::StyleArg, OutputFormat};
+use crate::cli::{args::AtomicArgs, types::StyleArg, OutputFormat};
 use renamify_core::Preview;
 
 #[allow(clippy::too_many_arguments)]
@@ -30,6 +30,7 @@ pub fn handle_plan(
     include_acronyms: Vec<String>,
     exclude_acronyms: Vec<String>,
     only_acronyms: Vec<String>,
+    atomic: AtomicArgs,
     output: OutputFormat,
     quiet: bool,
     _regex: bool, // TODO: Implement regex mode
@@ -52,6 +53,17 @@ pub fn handle_plan(
     let include_styles: Vec<Style> = include_styles.into_iter().map(Into::into).collect();
     let only_styles: Vec<Style> = only_styles.into_iter().map(Into::into).collect();
 
+    // Load config to get atomic identifiers
+    let config = renamify_core::Config::load().unwrap_or_default();
+
+    // Build atomic config from CLI args and config file
+    let atomic_config = renamify_core::atomic::AtomicConfig::from_flags_and_config(
+        atomic.atomic,
+        atomic.atomic_search || (atomic.atomic && !atomic.no_atomic_search),
+        atomic.atomic_replace || (atomic.atomic && !atomic.no_atomic_replace),
+        config.atomic,
+    );
+
     // Handle quiet mode - overrides preview to none unless output is json
     let effective_preview = if quiet && output != OutputFormat::Json {
         None
@@ -98,6 +110,7 @@ pub fn handle_plan(
         exclude_acronyms,
         only_acronyms,
         None, // working_dir
+        Some(&atomic_config),
     )?;
 
     // Handle output based on format
diff --git a/renamify-cli/src/replace.rs b/renamify-cli/src/replace.rs
index 160d0f3..caf6511 100644
--- a/renamify-cli/src/replace.rs
+++ b/renamify-cli/src/replace.rs
@@ -47,6 +47,7 @@ pub fn handle_replace(
         rename_root: false,
         plan_out: PathBuf::from(".renamify/plan.json"),
         coerce_separators: renamify_core::scanner::CoercionMode::Off,
+        atomic_config: None, // Replace doesn't use atomic mode
     };
 
     // Create the plan using simple regex/literal replacement
diff --git a/renamify-cli/tests/binary_name_preservation.rs b/renamify-cli/tests/binary_name_preservation.rs
new file mode 100644
index 0000000..0737cc3
--- /dev/null
+++ b/renamify-cli/tests/binary_name_preservation.rs
@@ -0,0 +1,152 @@
+use assert_cmd::Command;
+use std::fs;
+use tempfile::TempDir;
+
+/// Test that binary names in Cargo.toml are always kept in snake_case
+/// This is critical for build systems and scripts that depend on predictable binary names
+#[test]
+fn test_binary_name_stays_snake_case() {
+    let temp_dir = TempDir::new().unwrap();
+    let temp_path = temp_dir.path();
+
+    // Create a test Cargo.toml with enough context to show snake_case is predominant
+    let cargo_toml_content = r#"[package]
+name = "mytool"
+version.workspace = true
+edition.workspace = true
+authors.workspace = true
+license.workspace = true
+repository.workspace = true
+homepage.workspace = true
+description = "Smart search & replace for code and files"
+
+[[bin]]
+name = "mytool"
+path = "src/main.rs"
+
+[dependencies]
+mytool-core = { path = "../mytool-core" }
+anyhow = { workspace = true }
+clap = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
+ctrlc = "3.4"
+clap_complete = "4.5"
+dirs = "6.0"
+
+[dev-dependencies]
+assert_cmd = { workspace = true }
+predicates = { workspace = true }
+assert_fs = { workspace = true }
+tempfile = { workspace = true }
+"#;
+
+    let cargo_toml_path = temp_path.join("Cargo.toml");
+    fs::write(&cargo_toml_path, cargo_toml_content).unwrap();
+
+    // Test renaming from ambiguous single word to clearly snake_case multi-word name
+    let mut cmd = Command::cargo_bin("renamify").unwrap();
+    cmd.arg("rename")
+        .arg("mytool")
+        .arg("awesome_super_test_utility")
+        .arg("--dry-run")
+        .arg("--quiet")
+        .arg("--output")
+        .arg("json")
+        .current_dir(temp_path);
+
+    let output = cmd.output().unwrap();
+    let stdout = String::from_utf8_lossy(&output.stdout);
+
+    // Parse JSON output to check the replacements
+    let json: serde_json::Value = serde_json::from_str(&stdout).unwrap();
+    let matches = json["plan"]["matches"].as_array().unwrap();
+
+    // Debug: print all matches to find the right line
+    // eprintln!("All matches:");
+    // for m in matches {
+    //     eprintln!("  Line {}: {} -> {}",
+    //         m["line"].as_u64().unwrap(),
+    //         m["content"].as_str().unwrap(),
+    //         m["replace"].as_str().unwrap()
+    //     );
+    // }
+
+    // Find the binary name replacement (line 12 in the TOML, under [[bin]])
+    let binary_replacement = matches.iter().find(|m| m["line"].as_u64().unwrap() == 12);
+
+    // The binary name should be replaced with snake_case version
+    assert!(
+        binary_replacement.is_some(),
+        "Should find binary name replacement"
+    );
+    let replacement = binary_replacement.unwrap();
+    let replace_value = replacement["replace"].as_str().unwrap();
+    assert_eq!(
+        replace_value, "awesome_super_test_utility",
+        "Binary name should be snake_case 'awesome_super_test_utility', not '{}'",
+        replace_value
+    );
+    assert_ne!(
+        replace_value, "AwesomeSuperTestUtility",
+        "Binary name should not be PascalCase"
+    );
+}
+
+#[test]
+fn test_binary_name_with_camel_case_input() {
+    let temp_dir = TempDir::new().unwrap();
+    let temp_path = temp_dir.path();
+
+    // Create a test Cargo.toml
+    let cargo_toml_content = r#"
+[package]
+name = "old_service"
+version = "1.0.0"
+
+[[bin]]
+name = "old_service"
+path = "src/main.rs"
+"#;
+
+    let cargo_toml_path = temp_path.join("Cargo.toml");
+    fs::write(&cargo_toml_path, cargo_toml_content).unwrap();
+
+    // Test renaming to camelCase - binary name should become camelCase
+    let mut cmd = Command::cargo_bin("renamify").unwrap();
+    cmd.arg("rename")
+        .arg("old_service")
+        .arg("newServiceModule")
+        .arg("--dry-run")
+        .arg("--quiet")
+        .arg("--output")
+        .arg("json")
+        .current_dir(temp_path);
+
+    let output = cmd.output().unwrap();
+    let stdout = String::from_utf8_lossy(&output.stdout);
+
+    let json: serde_json::Value = serde_json::from_str(&stdout).unwrap();
+    let matches = json["plan"]["matches"].as_array().unwrap();
+
+    // Find the binary name replacement
+    let binary_replacement = matches.iter().find(|m| {
+        m["line"].as_u64().unwrap() == 3 // Line 3 is the binary name line
+    });
+
+    assert!(
+        binary_replacement.is_some(),
+        "Should find binary name replacement"
+    );
+    let replacement = binary_replacement.unwrap();
+    let replace_value = replacement["replace"].as_str().unwrap();
+
+    assert_eq!(
+        replace_value, "new_service_module",
+        "Binary name should be 'new_service_module' matching the predominantly style in the file"
+    );
+    assert_ne!(
+        replace_value, "newServiceModule",
+        "Binary name should not be newServiceModule"
+    );
+}
diff --git a/renamify-cli/tests/cli_tests.rs b/renamify-cli/tests/cli_tests.rs
index 9f33b32..295fd58 100644
--- a/renamify-cli/tests/cli_tests.rs
+++ b/renamify-cli/tests/cli_tests.rs
@@ -96,6 +96,7 @@ fn test_plan_command_basic() {
         vec![],                     // exclude_acronyms
         vec![],                     // only_acronyms
         Some(temp_dir.path()),      // working_dir
+        None,                       // atomic_config
     )
     .unwrap();
 
@@ -142,6 +143,7 @@ fn test_plan_command_with_styles() {
         vec![],                // exclude_acronyms
         vec![],                // only_acronyms
         Some(temp_dir.path()), // working_dir
+        None,                  // atomic_config
     )
     .unwrap();
 
@@ -184,6 +186,7 @@ fn test_plan_command_with_styles() {
         vec![],                        // exclude_acronyms
         vec![],                        // only_acronyms
         Some(temp_dir.path()),         // working_dir
+        None,                          // atomic_config
     )
     .unwrap();
 
diff --git a/renamify-core/src/ambiguity/language_heuristics.rs b/renamify-core/src/ambiguity/language_heuristics.rs
index c2cc342..c939816 100644
--- a/renamify-core/src/ambiguity/language_heuristics.rs
+++ b/renamify-core/src/ambiguity/language_heuristics.rs
@@ -13,13 +13,18 @@ impl LanguageHeuristics {
         preceding_context: &str,
         possible_styles: &[Style],
     ) -> Option<Style> {
+        let extension = file_path.extension()?.to_str()?;
+        let context = preceding_context.trim();
+
         if std::env::var("RENAMIFY_DEBUG_AMBIGUITY").is_ok() {
             eprintln!("DEBUG LanguageHeuristics: called suggest_style");
+            eprintln!("  file_path: {}", file_path.display());
+            eprintln!("  extension: {}", extension);
+            eprintln!("  preceding_context: {:?}", preceding_context);
+            eprintln!("  context (trimmed): {:?}", context);
+            eprintln!("  possible_styles: {:?}", possible_styles);
         }
 
-        let extension = file_path.extension()?.to_str()?;
-        let context = preceding_context.trim();
-
         match extension {
             // Programming languages
             "rb" | "rake" | "gemspec" => languages::ruby::suggest_style(context, possible_styles),
diff --git a/renamify-core/src/ambiguity/mod.rs b/renamify-core/src/ambiguity/mod.rs
index c287ddf..0413842 100644
--- a/renamify-core/src/ambiguity/mod.rs
+++ b/renamify-core/src/ambiguity/mod.rs
@@ -46,8 +46,8 @@ pub fn could_be_style(text: &str, style: Style) -> bool {
             first_char.is_lowercase() && !has_underscore && !has_hyphen && !has_dot
         },
         Style::Pascal => {
-            // PascalCase: starts uppercase
-            first_char.is_uppercase()
+            // PascalCase: starts uppercase, has mixed case, no separators
+            first_char.is_uppercase() && !has_underscore && !has_hyphen && !has_dot
         },
         Style::ScreamingSnake => {
             // SCREAMING_SNAKE: all uppercase, may have underscores
@@ -58,21 +58,38 @@ pub fn could_be_style(text: &str, style: Style) -> bool {
                         .all(|c| c.is_uppercase() || c.is_numeric() || c == '_'))
         },
         Style::Train => {
-            // Train-Case: starts uppercase, has hyphens
-            first_char.is_uppercase()
-                && (has_hyphen || text.chars().all(|c| c.is_alphanumeric() || c == '-'))
+            // Train-Case: Each segment is Title case (First-Second) or all caps acronym (API-Service)
+            // Must have hyphens for multi-segment, single segment must be Title or all caps
+            if has_hyphen {
+                // Check if all segments follow Train-Case pattern
+                text.split('-').all(|segment| {
+                    !segment.is_empty()
+                        && (
+                            // Title case: First letter upper, rest lower
+                            (segment.chars().next().unwrap().is_uppercase()
+                         && segment.chars().skip(1).all(|c| c.is_lowercase() || c.is_numeric()))
+                        // Or all uppercase (acronym)
+                        || segment.chars().all(|c| c.is_uppercase() || c.is_numeric())
+                        )
+                })
+            } else {
+                // Single segment: must be Title case or all uppercase
+                first_char.is_uppercase()
+                    && (
+                        // All uppercase (like API, SAML)
+                        text.chars().all(|c| c.is_uppercase() || c.is_numeric())
+                    // Or Title case (like Hello, World)
+                    || text.chars().skip(1).all(|c| c.is_lowercase() || c.is_numeric())
+                    )
+            }
         },
         Style::ScreamingTrain => {
-            // SCREAMING-TRAIN: all uppercase, has hyphens
-            !has_lowercase
-                && (has_hyphen
-                    || text
-                        .chars()
-                        .all(|c| c.is_uppercase() || c.is_numeric() || c == '-'))
+            // SCREAMING-TRAIN: all uppercase, MUST have hyphens
+            !has_lowercase && has_hyphen
         },
         Style::Title => {
-            // Title Case: has spaces and capital letters
-            text.contains(' ') || first_char.is_uppercase()
+            // Title Case: MUST have spaces and capital letters
+            text.contains(' ') && first_char.is_uppercase()
         },
         Style::Dot => {
             // dot.case: all lowercase with dots
@@ -107,8 +124,8 @@ pub fn get_possible_styles(text: &str) -> Vec<Style> {
         Style::ScreamingTrain,
         Style::Title,
         Style::Dot,
-        Style::Lower,
-        Style::Upper,
+        // NOTE: Lower and Upper are excluded as they destroy word boundaries
+        // and should never be used for identifier transformations
     ] {
         if could_be_style(text, *style) {
             styles.push(*style);
diff --git a/renamify-core/src/ambiguity/resolver.rs b/renamify-core/src/ambiguity/resolver.rs
index b435360..559425a 100644
--- a/renamify-core/src/ambiguity/resolver.rs
+++ b/renamify-core/src/ambiguity/resolver.rs
@@ -66,9 +66,32 @@ impl AmbiguityResolver {
         replacement_text: &str,
         context: &AmbiguityContext,
     ) -> ResolvedStyle {
+        self.resolve_with_styles(matched_text, replacement_text, context, None)
+    }
+
+    /// Resolution method with pre-calculated replacement styles for performance
+    pub fn resolve_with_styles(
+        &self,
+        matched_text: &str,
+        replacement_text: &str,
+        context: &AmbiguityContext,
+        replacement_possible_styles: Option<&[Style]>,
+    ) -> ResolvedStyle {
+        if std::env::var("RENAMIFY_DEBUG_AMBIGUITY").is_ok() {
+            eprintln!(
+                "=== Resolving ambiguity for '{}' -> '{}' ===",
+                matched_text, replacement_text
+            );
+            eprintln!("  File: {:?}", context.file_path);
+            eprintln!("  Content: {:?}", context.line_content);
+        }
+
         // First check if it's even ambiguous
         if !is_ambiguous(matched_text) {
             if let Some(style) = detect_style(matched_text) {
+                if std::env::var("RENAMIFY_DEBUG_AMBIGUITY").is_ok() {
+                    eprintln!("  -> Not ambiguous, detected style: {:?}", style);
+                }
                 return ResolvedStyle {
                     style,
                     confidence: ResolutionConfidence::High,
@@ -81,18 +104,32 @@ impl AmbiguityResolver {
         let possible_styles = get_possible_styles(matched_text);
         if possible_styles.is_empty() {
             // Shouldn't happen, but handle gracefully
-            return Self::default_fallback(&possible_styles, replacement_text);
+            return Self::default_fallback(
+                &possible_styles,
+                replacement_text,
+                replacement_possible_styles,
+            );
+        }
+
+        if std::env::var("RENAMIFY_DEBUG_AMBIGUITY").is_ok() {
+            eprintln!("  Possible styles: {:?}", possible_styles);
         }
 
         // Level 1: Language-specific heuristics
         if let Some(resolved) =
             Self::try_language_heuristics(matched_text, context, &possible_styles)
         {
+            if std::env::var("RENAMIFY_DEBUG_AMBIGUITY").is_ok() {
+                eprintln!("  -> Resolved by language heuristics: {:?}", resolved.style);
+            }
             return resolved;
         }
 
         // Level 2: File context analysis
         if let Some(resolved) = self.try_file_context(matched_text, context, &possible_styles) {
+            if std::env::var("RENAMIFY_DEBUG_AMBIGUITY").is_ok() {
+                eprintln!("  -> Resolved by file context: {:?}", resolved.style);
+            }
             return resolved;
         }
 
@@ -103,7 +140,11 @@ impl AmbiguityResolver {
         }
 
         // Level 4: Replacement string preference (ultimate fallback)
-        Self::try_replacement_preference(&possible_styles, replacement_text)
+        Self::try_replacement_preference(
+            &possible_styles,
+            replacement_text,
+            replacement_possible_styles,
+        )
     }
 
     /// Try language-specific heuristics
@@ -214,6 +255,7 @@ impl AmbiguityResolver {
     fn try_replacement_preference(
         possible_styles: &[Style],
         replacement_text: &str,
+        replacement_possible_styles: Option<&[Style]>,
     ) -> ResolvedStyle {
         // Determine the style of the replacement string
         if let Some(replacement_style) = detect_style(replacement_text) {
@@ -228,12 +270,20 @@ impl AmbiguityResolver {
         }
 
         // Otherwise use default fallback
-        Self::default_fallback(possible_styles, replacement_text)
+        Self::default_fallback(
+            possible_styles,
+            replacement_text,
+            replacement_possible_styles,
+        )
     }
 
     /// Default fallback when all else fails
-    fn default_fallback(possible_styles: &[Style], _replacement_text: &str) -> ResolvedStyle {
-        // Default precedence order
+    fn default_fallback(
+        possible_styles: &[Style],
+        replacement_text: &str,
+        replacement_possible_styles: Option<&[Style]>,
+    ) -> ResolvedStyle {
+        // Define default precedence order at the top
         const DEFAULT_PRECEDENCE: &[Style] = &[
             Style::Snake,
             Style::Camel,
@@ -244,10 +294,58 @@ impl AmbiguityResolver {
             Style::ScreamingTrain,
             Style::Title,
             Style::Dot,
-            Style::Lower,
-            Style::Upper,
         ];
 
+        // Use pre-calculated styles if provided, otherwise calculate them
+        let calculated_styles;
+        let replacement_styles = if let Some(styles) = replacement_possible_styles {
+            styles
+        } else {
+            calculated_styles = get_possible_styles(replacement_text);
+            &calculated_styles
+        };
+
+        // Find styles that are possible for both the matched text and replacement
+        let common_styles: Vec<Style> = possible_styles
+            .iter()
+            .filter(|s| replacement_styles.contains(s))
+            .copied()
+            .collect();
+
+        // If there's exactly one common style, that's our answer
+        if common_styles.len() == 1 {
+            return ResolvedStyle {
+                style: common_styles[0],
+                confidence: ResolutionConfidence::High,
+                method: ResolutionMethod::DefaultFallback,
+            };
+        }
+
+        // If there are multiple common styles, prefer the one from the replacement
+        // Check if replacement has a definitive (non-ambiguous) style
+        if !common_styles.is_empty() {
+            if let Some(replacement_style) = detect_style(replacement_text) {
+                if common_styles.contains(&replacement_style) {
+                    return ResolvedStyle {
+                        style: replacement_style,
+                        confidence: ResolutionConfidence::Medium,
+                        method: ResolutionMethod::DefaultFallback,
+                    };
+                }
+            }
+            // Otherwise use the first common style from precedence order
+            for &style in DEFAULT_PRECEDENCE {
+                if common_styles.contains(&style) {
+                    return ResolvedStyle {
+                        style,
+                        confidence: ResolutionConfidence::Medium,
+                        method: ResolutionMethod::DefaultFallback,
+                    };
+                }
+            }
+        }
+
+        // No common styles - fall back to precedence order from possible_styles
         // Find the first style in our precedence order that's possible
         for &style in DEFAULT_PRECEDENCE {
             if possible_styles.contains(&style) {
diff --git a/renamify-core/src/atomic.rs b/renamify-core/src/atomic.rs
new file mode 100644
index 0000000..9813e94
--- /dev/null
+++ b/renamify-core/src/atomic.rs
@@ -0,0 +1,231 @@
+use serde::{Deserialize, Serialize};
+use std::collections::HashSet;
+use ts_rs::TS;
+
+/// Configuration for atomic identifier handling
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[ts(export)]
+#[allow(clippy::struct_field_names)]
+pub struct AtomicConfig {
+    /// Set of identifiers that should be treated as atomic (indivisible)
+    pub atomic_identifiers: HashSet<String>,
+    /// Whether the search term should be treated as atomic
+    pub atomic_search: bool,
+    /// Whether the replace term should be treated as atomic
+    pub atomic_replace: bool,
+}
+
+impl AtomicConfig {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Check if an identifier should be treated as atomic
+    /// Performs case-insensitive matching against configured atomic identifiers
+    pub fn is_atomic(&self, identifier: &str) -> bool {
+        // Check if explicitly marked as atomic via flags
+        // This will be checked by the caller based on whether we're checking search or replace
+
+        // Check against configured atomic identifiers (case-insensitive)
+        self.atomic_identifiers
+            .iter()
+            .any(|atomic| atomic.eq_ignore_ascii_case(identifier))
+    }
+
+    /// Create config from CLI flags and config file
+    pub fn from_flags_and_config(
+        atomic_both: bool,
+        atomic_search: bool,
+        atomic_replace: bool,
+        config_atomics: Vec<String>,
+    ) -> Self {
+        let mut config = Self::new();
+
+        // Add configured atomic identifiers
+        for atomic in config_atomics {
+            config.atomic_identifiers.insert(atomic);
+        }
+
+        // Apply CLI flags
+        if atomic_both {
+            config.atomic_search = true;
+            config.atomic_replace = true;
+        } else {
+            config.atomic_search = atomic_search;
+            config.atomic_replace = atomic_replace;
+        }
+
+        config
+    }
+
+    /// Check if search term should be treated as atomic
+    pub fn should_treat_search_atomic(&self, search: &str) -> bool {
+        self.atomic_search || self.is_atomic(search)
+    }
+
+    /// Check if replace term should be treated as atomic
+    pub fn should_treat_replace_atomic(&self, replace: &str) -> bool {
+        self.atomic_replace || self.is_atomic(replace)
+    }
+}
+
+/// Parse an identifier as atomic (no word boundary detection)
+pub fn parse_atomic(s: &str) -> crate::case_model::TokenModel {
+    // Treat the entire string as a single token
+    crate::case_model::TokenModel::new(vec![crate::case_model::Token::new(s)])
+}
+
+/// Convert an atomic token to a specific style
+pub fn to_atomic_style(identifier: &str, style: crate::case_model::Style) -> String {
+    match style {
+        crate::case_model::Style::Snake
+        | crate::case_model::Style::Kebab
+        | crate::case_model::Style::Dot
+        | crate::case_model::Style::Lower => identifier.to_lowercase(),
+
+        crate::case_model::Style::ScreamingSnake
+        | crate::case_model::Style::ScreamingTrain
+        | crate::case_model::Style::Upper => identifier.to_uppercase(),
+
+        crate::case_model::Style::Pascal
+        | crate::case_model::Style::Train
+        | crate::case_model::Style::Title => {
+            // Preserve original casing for these styles when atomic
+            identifier.to_string()
+        },
+
+        crate::case_model::Style::Camel => {
+            // For camelCase, lowercase the first letter only
+            if identifier.is_empty() {
+                String::new()
+            } else {
+                let mut chars = identifier.chars();
+                match chars.next() {
+                    None => String::new(),
+                    Some(first) => first.to_lowercase().collect::<String>() + chars.as_str(),
+                }
+            }
+        },
+    }
+}
+
+/// Generate variants for an atomic identifier
+/// Only generates basic case variants without word boundaries
+pub fn generate_atomic_variants(
+    identifier: &str,
+    styles: &[crate::case_model::Style],
+) -> Vec<(String, crate::case_model::Style)> {
+    let mut variants = Vec::new();
+
+    for style in styles {
+        let variant = to_atomic_style(identifier, *style);
+        variants.push((variant, *style));
+    }
+
+    variants
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_atomic_config_basic() {
+        let config = AtomicConfig::from_flags_and_config(
+            true, // atomic_both
+            false,
+            false,
+            vec![],
+        );
+
+        assert!(config.atomic_search);
+        assert!(config.atomic_replace);
+    }
+
+    #[test]
+    fn test_atomic_config_separate_flags() {
+        let config = AtomicConfig::from_flags_and_config(
+            false,
+            true, // atomic_search
+            false,
+            vec![],
+        );
+
+        assert!(config.atomic_search);
+        assert!(!config.atomic_replace);
+    }
+
+    #[test]
+    fn test_atomic_config_with_identifiers() {
+        let config = AtomicConfig::from_flags_and_config(
+            false,
+            false,
+            false,
+            vec!["DocSpring".to_string(), "GitHub".to_string()],
+        );
+
+        assert!(config.is_atomic("DocSpring"));
+        assert!(config.is_atomic("docspring")); // Case insensitive
+        assert!(config.is_atomic("DOCSPRING"));
+        assert!(!config.is_atomic("RandomName"));
+    }
+
+    #[test]
+    fn test_should_treat_atomic() {
+        let config =
+            AtomicConfig::from_flags_and_config(false, false, false, vec!["DocSpring".to_string()]);
+
+        // DocSpring is in the atomic list
+        assert!(config.should_treat_search_atomic("DocSpring"));
+        assert!(config.should_treat_replace_atomic("docspring"));
+
+        // RandomName is not
+        assert!(!config.should_treat_search_atomic("RandomName"));
+        assert!(!config.should_treat_replace_atomic("RandomName"));
+    }
+
+    #[test]
+    fn test_parse_atomic() {
+        let tokens = parse_atomic("DocSpring");
+        assert_eq!(tokens.tokens.len(), 1);
+        assert_eq!(tokens.tokens[0].text, "DocSpring");
+
+        let tokens = parse_atomic("GitHub");
+        assert_eq!(tokens.tokens.len(), 1);
+        assert_eq!(tokens.tokens[0].text, "GitHub");
+    }
+
+    #[test]
+    fn test_generate_atomic_variants() {
+        use crate::case_model::Style;
+
+        let styles = vec![
+            Style::Snake,
+            Style::Kebab,
+            Style::Pascal,
+            Style::ScreamingSnake,
+        ];
+
+        let variants = generate_atomic_variants("DocSpring", &styles);
+
+        // Check we get the right variants
+        assert!(variants.contains(&("docspring".to_string(), Style::Snake)));
+        assert!(variants.contains(&("docspring".to_string(), Style::Kebab)));
+        assert!(variants.contains(&("DocSpring".to_string(), Style::Pascal)));
+        assert!(variants.contains(&("DOCSPRING".to_string(), Style::ScreamingSnake)));
+
+        // Should NOT contain word-separated variants
+        let variant_strings: Vec<String> = variants.iter().map(|(s, _)| s.clone()).collect();
+        assert!(!variant_strings.contains(&"doc_spring".to_string()));
+        assert!(!variant_strings.contains(&"doc-spring".to_string()));
+    }
+
+    #[test]
+    fn test_atomic_camel_case() {
+        use crate::case_model::Style;
+
+        let variants = generate_atomic_variants("DocSpring", &[Style::Camel]);
+        assert_eq!(variants.len(), 1);
+        assert_eq!(variants[0].0, "docSpring");
+    }
+}
diff --git a/renamify-core/src/case_model.rs b/renamify-core/src/case_model.rs
index 5027077..281acb3 100644
--- a/renamify-core/src/case_model.rs
+++ b/renamify-core/src/case_model.rs
@@ -228,48 +228,80 @@ pub fn parse_to_tokens_with_acronyms(
                 // Use trie to find longest matching acronym
                 // This handles both letter-starting acronyms (API, URL) and digit-starting ones (2FA, 3D)
                 if let Some(acronym) = acronym_set.find_longest_match(s, i) {
-                    let next_pos = i + acronym.len();
-                    let mut should_skip_acronym = false;
-
-                    // Check what comes after the potential acronym
-                    if next_pos < bytes.len() {
-                        let next_byte = bytes[next_pos];
-
-                        // Skip if followed by a digit (e.g., "ARM" in "ARM64")
-                        if next_byte.is_ascii_digit()
-                            && !acronym.bytes().any(|b| b.is_ascii_digit())
-                        {
-                            should_skip_acronym = true;
-                        }
-
-                        // Skip if the acronym match is part of a longer word
-                        // For example, "IDE" in "IDENTIFIERS" should not be matched
-                        // Check if we're in the same case style and continuing the word
-                        if bytes[i].is_ascii_uppercase() && next_byte.is_ascii_uppercase() {
-                            // Both uppercase - might be part of same word like "IDENTIFIERS"
-                            // Only accept the acronym if it's the complete uppercase sequence
-                            let mut j = next_pos;
-                            while j < bytes.len() && bytes[j].is_ascii_uppercase() {
-                                j += 1;
+                    // Verify the matched acronym has consistent casing
+                    // Don't match "Cli" as "CLI" - it's probably "Client"
+                    let has_consistent_case = acronym.chars().all(|c| c.is_ascii_uppercase())
+                        || acronym
+                            .chars()
+                            .all(|c| c.is_ascii_lowercase() || c.is_ascii_digit());
+
+                    if has_consistent_case {
+                        let next_pos = i + acronym.len();
+                        let mut should_skip_acronym = false;
+
+                        // Check what comes after the potential acronym
+                        if next_pos < bytes.len() {
+                            let next_byte = bytes[next_pos];
+
+                            // Skip if followed by a digit (e.g., "ARM" in "ARM64")
+                            if next_byte.is_ascii_digit()
+                                && !acronym.bytes().any(|b| b.is_ascii_digit())
+                            {
+                                should_skip_acronym = true;
                             }
-                            // If there are more uppercase letters, this might be a longer word
-                            // Only accept known acronyms if they're followed by a clear boundary
-                            if j > next_pos {
-                                // There are more uppercase letters - likely part of a longer word
+
+                            // Skip if the acronym match is part of a longer word
+                            // For example, "IDE" in "IDENTIFIERS" should not be matched
+                            // Check if we're in the same case style and continuing the word
+                            if bytes[i].is_ascii_uppercase() && next_byte.is_ascii_uppercase() {
+                                // Both uppercase - might be part of same word like "IDENTIFIERS"
+                                // OR might be consecutive acronyms like "HTTPSAPIClient"
+
+                                // Check if what follows is also a known acronym
+                                if let Some(_next_acronym) =
+                                    acronym_set.find_longest_match(s, next_pos)
+                                {
+                                    // The following text is also a known acronym!
+                                    // Accept the current acronym (e.g., "HTTPS" before "API")
+                                    should_skip_acronym = false;
+                                } else {
+                                    // Not a known acronym - check if it's just more uppercase letters
+                                    let mut j = next_pos;
+                                    while j < bytes.len() && bytes[j].is_ascii_uppercase() {
+                                        j += 1;
+                                    }
+                                    // If there are more uppercase letters, this might be a longer word
+                                    // Only accept known acronyms if they're followed by a clear boundary
+                                    if j > next_pos {
+                                        // There are more uppercase letters - likely part of a longer word
+                                        should_skip_acronym = true;
+                                    }
+                                }
+                            } else if bytes[i].is_ascii_lowercase()
+                                && next_byte.is_ascii_lowercase()
+                            {
+                                // Both lowercase - definitely part of same word
                                 should_skip_acronym = true;
                             }
-                        } else if bytes[i].is_ascii_lowercase() && next_byte.is_ascii_lowercase() {
-                            // Both lowercase - definitely part of same word
-                            should_skip_acronym = true;
                         }
-                    }
 
-                    if !should_skip_acronym {
-                        tokens.push(Token::new(acronym));
-                        i += acronym.len();
-                        continue;
+                        if !should_skip_acronym {
+                            if debug {
+                                eprintln!(
+                                    "    -> Found acronym '{}' at position {}, jumping to {}",
+                                    acronym,
+                                    i,
+                                    i + acronym.len()
+                                );
+                            }
+                            tokens.push(Token::new(acronym));
+                            i += acronym.len();
+                            continue;
+                        }
+                        // Otherwise, fall through to normal processing
                     }
-                    // Otherwise, fall through to normal processing
+                    // else: Mixed case like "Cli" - probably not an acronym in this context
+                    // Fall through to normal processing
                 }
 
                 // Handle uppercase sequences that might be acronyms
@@ -283,10 +315,27 @@ pub fn parse_to_tokens_with_acronyms(
                     // If we have multiple uppercase letters followed by lowercase,
                     // this might be an acronym followed by a word (e.g., "URLParser" -> "URL" + "Parser")
                     if j > i + 1 && j < bytes.len() && bytes[j].is_ascii_lowercase() {
-                        // Take all but the last uppercase letter as the acronym
-                        let acronym_part = std::str::from_utf8(&bytes[i..j - 1]).unwrap_or("");
-                        tokens.push(Token::new(acronym_part));
-                        i = j - 1; // Continue from the last uppercase letter
+                        // Check if any prefix of this uppercase sequence is a known acronym
+                        // Start from the longest possible and work down
+                        let mut found_acronym = false;
+                        for k in (i + 1..j).rev() {
+                            let potential_acronym = std::str::from_utf8(&bytes[i..k]).unwrap_or("");
+                            if acronym_set.is_acronym(potential_acronym) {
+                                // Found a known acronym! Split here
+                                tokens.push(Token::new(potential_acronym));
+                                i = k; // Continue from after the acronym
+                                found_acronym = true;
+                                break;
+                            }
+                        }
+
+                        if !found_acronym {
+                            // No known acronym found, use the heuristic:
+                            // Take all but the last uppercase letter as the acronym
+                            let acronym_part = std::str::from_utf8(&bytes[i..j - 1]).unwrap_or("");
+                            tokens.push(Token::new(acronym_part));
+                            i = j - 1; // Continue from the last uppercase letter
+                        }
                         continue;
                     }
                 }
@@ -299,8 +348,25 @@ pub fn parse_to_tokens_with_acronyms(
                 // Check for various split conditions
                 let mut should_split = false;
 
+                // Check if current buffer is a known acronym and we're about to add another uppercase letter
+                // This handles cases like "APIClient" where API is a known acronym
+                if b.is_ascii_uppercase() && prev.is_ascii_uppercase() {
+                    // Check if what we have so far is a known acronym
+                    if let Ok(current_str) = std::str::from_utf8(&current) {
+                        if current_str.chars().all(|c| c.is_ascii_uppercase())
+                            && acronym_set.is_acronym(current_str)
+                        {
+                            // Look ahead - if the next character is lowercase, this uppercase letter
+                            // starts a new word (e.g., "API" + "Client")
+                            if i + 1 < bytes.len() && bytes[i + 1].is_ascii_lowercase() {
+                                should_split = true;
+                            }
+                        }
+                    }
+                }
+
                 // 1. lowercase to uppercase (e.g., "camelCase" -> "camel", "Case")
-                if prev.is_ascii_lowercase() && b.is_ascii_uppercase() {
+                if !should_split && prev.is_ascii_lowercase() && b.is_ascii_uppercase() {
                     should_split = true;
                 }
                 // 2. letter to digit - DON'T split (e.g., "project1" -> "project1")
@@ -402,22 +468,42 @@ pub fn to_style(model: &TokenModel, style: Style) -> String {
             .join("-"),
 
         Style::Camel => {
+            let acronym_set = crate::acronym::get_default_acronym_set();
             let mut result = String::new();
             for (i, token) in model.tokens.iter().enumerate() {
                 if i == 0 {
                     result.push_str(&token.text.to_lowercase());
                 } else {
-                    result.push_str(&capitalize_first(&token.text));
+                    // If the token is an all-uppercase known acronym, preserve it
+                    if token.text.chars().all(|c| c.is_ascii_uppercase())
+                        && acronym_set.is_acronym(&token.text)
+                    {
+                        result.push_str(&token.text);
+                    } else {
+                        result.push_str(&capitalize_first(&token.text));
+                    }
                 }
             }
             result
         },
 
-        Style::Pascal => model
-            .tokens
-            .iter()
-            .map(|t| capitalize_first(&t.text))
-            .collect::<String>(),
+        Style::Pascal => {
+            let acronym_set = crate::acronym::get_default_acronym_set();
+            model
+                .tokens
+                .iter()
+                .map(|t| {
+                    // If the token is an all-uppercase known acronym, preserve it
+                    if t.text.chars().all(|c| c.is_ascii_uppercase())
+                        && acronym_set.is_acronym(&t.text)
+                    {
+                        t.text.clone()
+                    } else {
+                        capitalize_first(&t.text)
+                    }
+                })
+                .collect::<String>()
+        },
 
         Style::ScreamingSnake => model
             .tokens
@@ -501,6 +587,16 @@ pub fn generate_variant_map(
     replace: &str,
     styles: Option<&[Style]>,
 ) -> BTreeMap<String, String> {
+    generate_variant_map_with_atomic(search, replace, styles, None)
+}
+
+pub fn generate_variant_map_with_atomic(
+    search: &str,
+    replace: &str,
+    styles: Option<&[Style]>,
+    atomic_config: Option<&crate::atomic::AtomicConfig>,
+) -> BTreeMap<String, String> {
+    let using_default_styles = styles.is_none();
     let default_styles = [
         Style::Snake,
         Style::Kebab,
@@ -512,8 +608,21 @@ pub fn generate_variant_map(
     ];
     let styles = styles.unwrap_or(&default_styles);
 
-    let search_tokens = parse_to_tokens(search);
-    let replace_tokens = parse_to_tokens(replace);
+    // Check if we should treat search/replace as atomic
+    let search_is_atomic = atomic_config.is_some_and(|c| c.should_treat_search_atomic(search));
+    let replace_is_atomic = atomic_config.is_some_and(|c| c.should_treat_replace_atomic(replace));
+
+    let search_tokens = if search_is_atomic {
+        crate::atomic::parse_atomic(search)
+    } else {
+        parse_to_tokens(search)
+    };
+
+    let replace_tokens = if replace_is_atomic {
+        crate::atomic::parse_atomic(replace)
+    } else {
+        parse_to_tokens(replace)
+    };
 
     let mut map = BTreeMap::new();
 
@@ -527,8 +636,17 @@ pub fn generate_variant_map(
 
     // Generate variants for each requested style
     for style in styles {
-        let search_variant = to_style(&search_tokens, *style);
-        let replace_variant = to_style(&replace_tokens, *style);
+        let search_variant = if search_is_atomic {
+            crate::atomic::to_atomic_style(search, *style)
+        } else {
+            to_style(&search_tokens, *style)
+        };
+
+        let replace_variant = if replace_is_atomic {
+            crate::atomic::to_atomic_style(replace, *style)
+        } else {
+            to_style(&replace_tokens, *style)
+        };
 
         if std::env::var("RENAMIFY_DEBUG_VARIANTS").is_ok() {
             eprintln!(
@@ -541,6 +659,16 @@ pub fn generate_variant_map(
         map.insert(search_variant, replace_variant);
     }
 
+    // CRITICAL: Add an exact match entry to preserve user's exact casing
+    // This ensures that if the search term matches exactly as typed, the replacement
+    // will be exactly as the user typed it (e.g., FormAPI not FormApi)
+    // BUT: Only do this when using default styles AND the search term is NOT ambiguous
+    // This must come AFTER generating style variants to override any that match the exact input
+    if using_default_styles && !crate::ambiguity::is_ambiguous(search) {
+        // Using default styles and search is not ambiguous - add exact match preservation
+        map.insert(search.to_string(), replace.to_string());
+    }
+
     // Removed automatic case variants - they were causing incorrect matches
     // All variants should come from the explicit style system only
 
@@ -1096,4 +1224,102 @@ mod tests {
         assert!(!is_title_case(" "));
         assert!(!is_title_case("hello"));
     }
+
+    #[test]
+    fn test_generate_variant_map_with_atomic() {
+        // Test atomic search and replace
+        let atomic_config = crate::atomic::AtomicConfig::from_flags_and_config(
+            true, // atomic_both
+            false,
+            false,
+            vec![],
+        );
+
+        let map =
+            generate_variant_map_with_atomic("DocSpring", "GitHub", None, Some(&atomic_config));
+
+        // Should only have atomic variants (no word separation)
+        assert_eq!(map.get("docspring"), Some(&"github".to_string()));
+        assert_eq!(map.get("DOCSPRING"), Some(&"GITHUB".to_string()));
+        assert_eq!(map.get("DocSpring"), Some(&"GitHub".to_string()));
+
+        // Should NOT have word-separated variants
+        assert!(!map.contains_key("doc_spring"));
+        assert!(!map.contains_key("doc-spring"));
+        assert!(!map.contains_key("DOC_SPRING"));
+    }
+
+    #[test]
+    fn test_generate_variant_map_with_config_atomics() {
+        // Test with configured atomic identifiers
+        let atomic_config = crate::atomic::AtomicConfig::from_flags_and_config(
+            false,
+            false,
+            false,
+            vec!["FormAPI".to_string()],
+        );
+
+        let map =
+            generate_variant_map_with_atomic("FormAPI", "DocSpring", None, Some(&atomic_config));
+
+        // FormAPI should be atomic (in config), DocSpring should be normal
+        // When FormAPI is atomic, snake/kebab/dot all become "formapi" (lowercase)
+        // But DocSpring is normal, so it splits into doc_spring, doc-spring, etc.
+
+        // The atomic search "formapi" maps to different replace variants based on style
+        // But since snake/kebab/dot all produce the same search key "formapi",
+        // they overwrite each other. The last one wins.
+
+        // FormAPI variants should not have word separation
+        assert!(!map.contains_key("form_api"));
+        assert!(!map.contains_key("form-api"));
+
+        // Check uppercase variants work correctly
+        // FORMAPI could map to either DOC_SPRING or DOC-SPRING depending on order
+        assert!(map.contains_key("FORMAPI"));
+        let formapi_upper = map.get("FORMAPI").unwrap();
+        assert!(formapi_upper == "DOC_SPRING" || formapi_upper == "DOC-SPRING");
+
+        // FormAPI for Pascal/Train styles - could map to DocSpring or Doc-Spring
+        assert!(map.contains_key("FormAPI"));
+        let formapi_pascal = map.get("FormAPI").unwrap();
+        assert!(formapi_pascal == "DocSpring" || formapi_pascal == "Doc-Spring");
+
+        // The lowercase "formapi" key exists but maps to one of the normal variants
+        assert!(map.contains_key("formapi"));
+        // Its value should be one of the word-separated lowercase variants
+        let formapi_value = map.get("formapi").unwrap();
+        assert!(
+            formapi_value == "doc_spring"
+                || formapi_value == "doc-spring"
+                || formapi_value == "doc.spring"
+        );
+    }
+
+    #[test]
+    fn test_generate_variant_map_mixed_atomic() {
+        // Test with only search being atomic
+        let atomic_config = crate::atomic::AtomicConfig::from_flags_and_config(
+            false,
+            true, // atomic_search only
+            false,
+            vec![],
+        );
+
+        let map =
+            generate_variant_map_with_atomic("DocSpring", "NewName", None, Some(&atomic_config));
+
+        // DocSpring should be atomic, NewName should be normal
+        // The lowercase "docspring" key could map to "new_name" or "new-name" depending on order
+        assert!(map.contains_key("docspring"));
+        let docspring_value = map.get("docspring").unwrap();
+        assert!(docspring_value == "new_name" || docspring_value == "new-name");
+        // DOCSPRING could map to NEW_NAME or NEW-NAME
+        assert!(map.contains_key("DOCSPRING"));
+        let docspring_upper = map.get("DOCSPRING").unwrap();
+        assert!(docspring_upper == "NEW_NAME" || docspring_upper == "NEW-NAME");
+
+        // DocSpring should not have word-separated variants
+        assert!(!map.contains_key("doc_spring"));
+    }
 }
diff --git a/renamify-core/src/config.rs b/renamify-core/src/config.rs
index 0b239b3..e29a014 100644
--- a/renamify-core/src/config.rs
+++ b/renamify-core/src/config.rs
@@ -7,6 +7,10 @@ use std::path::Path;
 pub struct Config {
     #[serde(default)]
     pub defaults: DefaultsConfig,
+
+    /// List of atomic identifiers (treated as indivisible units)
+    #[serde(default)]
+    pub atomic: Vec<String>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -144,4 +148,21 @@ preview_format = "json"
         assert!(config.defaults.rename_dirs);
         assert_eq!(config.defaults.unrestricted_level, 0);
     }
+
+    #[test]
+    fn test_atomic_config() {
+        let toml_content = r#"
+atomic = ["DocSpring", "GitHub", "FormAPI"]
+
+[defaults]
+preview_format = "table"
+"#;
+
+        let config: Config = toml::from_str(toml_content).unwrap();
+        assert_eq!(config.atomic.len(), 3);
+        assert!(config.atomic.contains(&"DocSpring".to_string()));
+        assert!(config.atomic.contains(&"GitHub".to_string()));
+        assert!(config.atomic.contains(&"FormAPI".to_string()));
+        assert_eq!(config.defaults.preview_format, "table");
+    }
 }
diff --git a/renamify-core/src/lib.rs b/renamify-core/src/lib.rs
index 71f7f2c..f22992e 100644
--- a/renamify-core/src/lib.rs
+++ b/renamify-core/src/lib.rs
@@ -12,6 +12,7 @@
 pub mod acronym;
 pub mod ambiguity;
 pub mod apply;
+pub mod atomic;
 pub mod case_model;
 pub mod coercion;
 pub mod compound_matcher;
diff --git a/renamify-core/src/operations/plan.rs b/renamify-core/src/operations/plan.rs
index df8b0c5..fe7c78f 100644
--- a/renamify-core/src/operations/plan.rs
+++ b/renamify-core/src/operations/plan.rs
@@ -32,6 +32,7 @@ pub fn plan_operation(
     exclude_acronyms: Vec<String>,
     only_acronyms: Vec<String>,
     working_dir: Option<&std::path::Path>,
+    atomic_config: Option<&crate::atomic::AtomicConfig>,
 ) -> Result<(PlanResult, Option<String>)> {
     let current_dir = working_dir.map_or_else(
         || std::env::current_dir().expect("Failed to get current directory"),
@@ -77,6 +78,7 @@ pub fn plan_operation(
         exclude_acronyms,
         only_acronyms,
         ignore_ambiguous: false, // TODO: Get from args
+        atomic_config: atomic_config.cloned(),
     };
 
     // Resolve all search paths to absolute paths and canonicalize them
diff --git a/renamify-core/src/operations/rename.rs b/renamify-core/src/operations/rename.rs
index 19c1626..69561d9 100644
--- a/renamify-core/src/operations/rename.rs
+++ b/renamify-core/src/operations/rename.rs
@@ -73,7 +73,8 @@ pub fn rename_operation(
         include_acronyms: include_acronyms.to_owned(),
         exclude_acronyms: exclude_acronyms.to_owned(),
         only_acronyms: only_acronyms.to_owned(),
-        ignore_ambiguous: false, // TODO: Get from args
+        ignore_ambiguous: false,
+        atomic_config: None, // Rename doesn't need atomic config yet
     };
 
     // Resolve all search paths to absolute paths and canonicalize them
diff --git a/renamify-core/src/scanner.rs b/renamify-core/src/scanner.rs
index 68b03ac..a0803cf 100644
--- a/renamify-core/src/scanner.rs
+++ b/renamify-core/src/scanner.rs
@@ -1,5 +1,6 @@
 use crate::acronym::AcronymSet;
-use crate::case_model::Style;
+use crate::ambiguity::{get_possible_styles, is_ambiguous, AmbiguityContext, AmbiguityResolver};
+use crate::case_model::{parse_to_tokens, to_style, Style};
 use crate::pattern::{build_pattern, Match};
 use crate::rename::plan_renames;
 use anyhow::Result;
@@ -58,6 +59,8 @@ pub struct PlanOptions {
     pub exclude_acronyms: Vec<String>, // Default acronyms to exclude
     pub only_acronyms: Vec<String>, // Replace default list with these acronyms
     pub ignore_ambiguous: bool,     // Ignore mixed-case/ambiguous identifiers
+    #[ts(optional)]
+    pub atomic_config: Option<crate::atomic::AtomicConfig>, // Atomic identifier configuration
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, TS)]
@@ -95,6 +98,7 @@ impl Default for PlanOptions {
             exclude_acronyms: vec![],
             only_acronyms: vec![],
             ignore_ambiguous: false, // Default: process ambiguous identifiers
+            atomic_config: None,     // Default: no atomic configuration
         }
     }
 }
@@ -222,6 +226,7 @@ pub fn scan_repository_multi(
         replace,
         options.styles.as_deref(),
         &acronym_set,
+        options.atomic_config.as_ref(),
     );
     let variants: Vec<String> = variant_map.keys().cloned().collect();
     let _pattern = build_pattern(&variants)?;
@@ -319,7 +324,14 @@ pub fn scan_repository_multi(
                 // Sort by position to maintain order
                 file_matches.sort_by_key(|m| (m.line, m.column));
 
-                let hunks = generate_hunks(&file_matches, &content, &variant_map, path, options);
+                let hunks = generate_hunks(
+                    &file_matches,
+                    &content,
+                    &variant_map,
+                    path,
+                    options,
+                    replace,
+                );
 
                 stats.files_with_matches += 1;
                 stats.total_matches += hunks.len();
@@ -437,10 +449,17 @@ fn generate_hunks(
     variant_map: &VariantMap,
     path: &Path,
     options: &PlanOptions,
+    original_replacement: &str,
 ) -> Vec<MatchHunk> {
     let lines: Vec<&[u8]> = content.lines_with_terminator().collect();
     let mut hunks = Vec::new();
 
+    // Create ambiguity resolver for handling ambiguous identifiers
+    let ambiguity_resolver = AmbiguityResolver::new();
+
+    // Calculate possible styles for the replacement text ONCE for all matches in this file
+    let replacement_possible_styles = get_possible_styles(original_replacement);
+
     // Compile the exclude pattern if provided
     let exclude_line_regex = if let Some(ref pattern) = options.exclude_matching_lines {
         Regex::new(pattern).ok()
@@ -475,6 +494,33 @@ fn generate_hunks(
         let (content, mut replace) = if is_compound_match {
             // Compound match - text field has the replacement
             (m.variant.clone(), m.text.clone())
+        } else if is_ambiguous(&m.variant) {
+            // For ambiguous identifiers, use the ambiguity resolver to determine
+            // the appropriate style based on context
+            let file_content_str = String::from_utf8_lossy(content);
+            let ambiguity_context = AmbiguityContext {
+                file_path: Some(path.to_path_buf()),
+                file_content: Some(file_content_str.to_string()),
+                line_content: Some(line_string.clone()),
+                match_position: Some(m.column),
+                project_root: None, // Could be added if needed
+            };
+
+            // Resolve what style should be used based on context
+            // Pass the ORIGINAL replacement text, not the styled one from variant map
+            let resolved = ambiguity_resolver.resolve_with_styles(
+                &m.variant,
+                original_replacement,
+                &ambiguity_context,
+                Some(&replacement_possible_styles),
+            );
+
+            // Generate the replacement in the resolved style
+            // We need to tokenize the original replacement to apply the new style
+            let replacement_tokens = parse_to_tokens(original_replacement);
+            let styled_replacement = to_style(&replacement_tokens, resolved.style);
+
+            (m.variant.clone(), styled_replacement)
         } else {
             // Exact match - use variant map
             let new_variant = variant_map.get(&m.variant).unwrap();
@@ -796,8 +842,27 @@ fn generate_variant_map_with_acronyms(
     replace: &str,
     styles: Option<&[Style]>,
     acronym_set: &AcronymSet,
+    atomic_config: Option<&crate::atomic::AtomicConfig>,
 ) -> VariantMap {
-    // Use the acronym-aware tokenization
+    // If we have atomic config, use atomic-aware variant generation
+    if let Some(atomic_cfg) = atomic_config {
+        // Convert to BTreeMap first
+        let btree_map = crate::case_model::generate_variant_map_with_atomic(
+            search,
+            replace,
+            styles,
+            Some(atomic_cfg),
+        );
+
+        // Convert BTreeMap to VariantMap
+        let mut variant_map = VariantMap::new();
+        for (key, value) in btree_map {
+            variant_map.insert(key, None, value);
+        }
+        return variant_map;
+    }
+
+    // Otherwise use the acronym-aware tokenization (existing logic)
     let old_tokens = crate::case_model::parse_to_tokens_with_acronyms(search, acronym_set);
     let new_tokens = crate::case_model::parse_to_tokens_with_acronyms(replace, acronym_set);
 
@@ -1331,6 +1396,7 @@ mod tests {
             &variant_map,
             Path::new("test.txt"),
             &opts,
+            "new_name",
         );
 
         assert_eq!(hunks.len(), 2);
@@ -1409,7 +1475,14 @@ mod tests {
         ];
 
         let opts = PlanOptions::default();
-        let hunks = generate_hunks(&matches, content, &variant_map, Path::new("test.rs"), &opts);
+        let hunks = generate_hunks(
+            &matches,
+            content,
+            &variant_map,
+            Path::new("test.rs"),
+            &opts,
+            "new_name",
+        );
 
         assert_eq!(hunks.len(), 3);
 
diff --git a/renamify-core/tests/acronym_cli_test.rs b/renamify-core/tests/acronym_cli_test.rs
index 8fe2a4b..4377862 100644
--- a/renamify-core/tests/acronym_cli_test.rs
+++ b/renamify-core/tests/acronym_cli_test.rs
@@ -25,6 +25,7 @@ fn test_no_acronyms_flag() {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -81,6 +82,7 @@ fn test_include_acronyms_flag() {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -129,6 +131,7 @@ fn test_exclude_acronyms_flag() {
         exclude_acronyms: vec!["ID".to_string()], // Exclude ID from acronyms
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -177,6 +180,7 @@ fn test_only_acronyms_flag() {
         exclude_acronyms: vec![],
         only_acronyms: vec!["AWS".to_string()], // Only AWS is an acronym
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -232,6 +236,7 @@ fn test_acronym_case_insensitive() {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
diff --git a/renamify-core/tests/acronym_variant_test.rs b/renamify-core/tests/acronym_variant_test.rs
index 98092e0..b943d92 100644
--- a/renamify-core/tests/acronym_variant_test.rs
+++ b/renamify-core/tests/acronym_variant_test.rs
@@ -30,6 +30,7 @@ fn test_acronym_affects_case_variants() {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -67,6 +68,7 @@ fn test_acronym_affects_case_variants() {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -127,6 +129,7 @@ fn test_custom_acronym_generation() {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -192,6 +195,7 @@ fn test_excluded_acronym_variants() {
         exclude_acronyms: vec!["ID".to_string()], // Exclude ID
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -248,6 +252,7 @@ fn test_only_acronyms_list() {
         exclude_acronyms: vec![],
         only_acronyms: vec!["XML".to_string()], // Only XML
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
diff --git a/renamify-core/tests/ambiguity_integration_test.rs b/renamify-core/tests/ambiguity_integration_test.rs
new file mode 100644
index 0000000..1e8ae83
--- /dev/null
+++ b/renamify-core/tests/ambiguity_integration_test.rs
@@ -0,0 +1,289 @@
+use renamify_core::operations::plan::plan_operation;
+use std::fs;
+use tempfile::TempDir;
+
+#[test]
+fn test_ambiguous_identifier_resolution_in_python() {
+    // This test verifies that ambiguous identifiers get resolved based on context
+    // The identifier "api" is ambiguous - could be snake_case, camelCase, etc.
+    // We're renaming to a PascalCase replacement "ServiceHandler"
+    // The resolver should adapt the replacement based on Python context
+
+    let temp_dir = TempDir::new().unwrap();
+    let temp_path = temp_dir.path();
+
+    // Create a Python file with different contexts
+    // "api" is ambiguous - could be snake, camel, kebab, lower
+    // "API" is ambiguous - could be SCREAMING_SNAKE, Pascal, Upper
+    let py_file = temp_path.join("service.py");
+    fs::write(
+        &py_file,
+        r#"class API:
+    """API service class"""
+    pass
+
+def api():
+    """api function"""
+    return None
+
+api_key = "secret"
+API_URL = "https://example.com"
+
+# Using the API
+my_api = api()
+APIClass = API
+"#,
+    )
+    .unwrap();
+
+    // Plan to rename ambiguous "api" to PascalCase "ServiceHandler"
+    // This will match both "api" (lowercase) and "API" (uppercase)
+    let (plan_result, _) = plan_operation(
+        "api",
+        "ServiceHandler",
+        vec![],          // empty = current dir
+        vec![],          // includes
+        vec![],          // excludes
+        true,            // respect_gitignore
+        0,               // unrestricted_level
+        true,            // rename_files
+        true,            // rename_dirs
+        &[],             // exclude_styles
+        &[],             // include_styles
+        &[],             // only_styles
+        vec![],          // exclude_match
+        None,            // exclude_matching_lines
+        None,            // plan_out
+        None,            // preview_format
+        true,            // dry_run
+        false,           // fixed_table_width
+        false,           // use_color
+        false,           // no_acronyms
+        vec![],          // include_acronyms
+        vec![],          // exclude_acronyms
+        vec![],          // only_acronyms
+        Some(temp_path), // working_dir
+        None,            // atomic_config
+    )
+    .unwrap();
+
+    let matches = &plan_result.plan.unwrap().matches;
+
+    // Debug: print all matches to see what we're getting
+    eprintln!("Found {} matches", matches.len());
+    for m in matches {
+        eprintln!(
+            "  Line {}, Col {}: '{}' -> '{}'",
+            m.line, m.col, m.content, m.replace
+        );
+    }
+
+    // Find the class definition - should be PascalCase
+    let class_match = matches.iter()
+        .find(|m| m.line == 1 && m.col == 6)  // "class api" - col is 0-based
+        .expect("Should find class definition");
+
+    // This SHOULD be "ServiceHandler" (PascalCase) if ambiguity resolver works
+    // But will likely be "serviceHandler" (camelCase) with current broken implementation
+    assert_eq!(
+        class_match.replace, "ServiceHandler",
+        "Class name should be PascalCase in Python, got: {}",
+        class_match.replace
+    );
+
+    // Find the function definition - should be snake_case
+    let func_match = matches.iter()
+        .find(|m| m.line == 5 && m.col == 4)  // "def api" - col is 0-based
+        .expect("Should find function definition");
+
+    // This SHOULD be "service_handler" (snake_case) if ambiguity resolver works
+    assert_eq!(
+        func_match.replace, "service_handler",
+        "Function name should be snake_case in Python, got: {}",
+        func_match.replace
+    );
+
+    // Lowercase variable should be snake_case
+    let var_match = matches
+        .iter()
+        .find(|m| m.line == 9 && m.col == 0 && m.content == "api_key")
+        .expect("Should find variable assignment");
+
+    assert_eq!(
+        var_match.replace, "service_handler_key",
+        "Variable should be snake_case, got: {}",
+        var_match.replace
+    );
+
+    // Uppercase constant should be SCREAMING_SNAKE_CASE
+    let const_match = matches
+        .iter()
+        .find(|m| m.line == 10 && m.col == 0 && m.content == "API_URL")
+        .expect("Should find constant assignment");
+
+    assert_eq!(
+        const_match.replace, "SERVICE_HANDLER_URL",
+        "Constant should be SCREAMING_SNAKE_CASE, got: {}",
+        const_match.replace
+    );
+}
+
+#[test]
+fn test_ambiguous_identifier_resolution_in_javascript() {
+    // Test JavaScript-specific resolution
+    // "api" is ambiguous, renamed to "DataService"
+
+    let temp_dir = TempDir::new().unwrap();
+    let temp_path = temp_dir.path();
+
+    let js_file = temp_path.join("app.js");
+    fs::write(
+        &js_file,
+        r#"class Api {
+  constructor() {}
+}
+
+const api = new Api();
+let apiUrl = 'https://example.com';
+var api_key = process.env.API_KEY;
+
+function api() {
+  return fetch(apiUrl);
+}
+
+const API_TIMEOUT = 5000;
+"#,
+    )
+    .unwrap();
+
+    let (plan_result, _) = plan_operation(
+        "api",
+        "DataService",
+        vec![],
+        vec![],
+        vec![],
+        true,
+        0,
+        true,
+        true,
+        &[],
+        &[],
+        &[],
+        vec![],
+        None,
+        None,
+        None,
+        true,
+        false,
+        false,
+        false,
+        vec![],
+        vec![],
+        vec![],
+        Some(temp_path),
+        None,
+    )
+    .unwrap();
+
+    let matches = &plan_result.plan.unwrap().matches;
+
+    // Class should be PascalCase
+    let class_match = matches
+        .iter()
+        .find(|m| m.line == 1 && m.content == "Api")
+        .expect("Should find class");
+
+    assert_eq!(
+        class_match.replace, "DataService",
+        "JS class should be PascalCase, got: {}",
+        class_match.replace
+    );
+
+    // const variable should be camelCase
+    let const_match = matches
+        .iter()
+        .find(|m| m.line == 5 && m.col == 6)
+        .expect("Should find const variable");
+
+    assert_eq!(
+        const_match.replace, "dataService",
+        "JS const should be camelCase, got: {}",
+        const_match.replace
+    );
+}
+
+#[test]
+fn test_ambiguous_replacement_uses_context() {
+    // This tests when BOTH search and replace are ambiguous
+    // "api" -> "backend" (both are ambiguous single words)
+
+    let temp_dir = TempDir::new().unwrap();
+    let temp_path = temp_dir.path();
+
+    let py_file = temp_path.join("models.py");
+    fs::write(
+        &py_file,
+        r#"class Api:
+    pass
+
+def get_api():
+    return api()
+"#,
+    )
+    .unwrap();
+
+    let (plan_result, _) = plan_operation(
+        "api",
+        "backend",
+        vec![],
+        vec![],
+        vec![],
+        true,
+        0,
+        true,
+        true,
+        &[],
+        &[],
+        &[],
+        vec![],
+        None,
+        None,
+        None,
+        true,
+        false,
+        false,
+        false,
+        vec![],
+        vec![],
+        vec![],
+        Some(temp_path),
+        None,
+    )
+    .unwrap();
+
+    let matches = &plan_result.plan.unwrap().matches;
+
+    // Class should become "Backend" (PascalCase)
+    let class_match = matches
+        .iter()
+        .find(|m| m.line == 1)
+        .expect("Should find class");
+
+    assert_eq!(
+        class_match.replace, "Backend",
+        "Python class with ambiguous replacement should be PascalCase, got: {}",
+        class_match.replace
+    );
+
+    // Function reference should be "backend" (snake_case)
+    let func_ref = matches
+        .iter()
+        .find(|m| m.line == 5 && m.col > 10)
+        .expect("Should find function call");
+
+    assert_eq!(
+        func_ref.replace, "backend",
+        "Function reference should be snake_case, got: {}",
+        func_ref.replace
+    );
+}
diff --git a/renamify-core/tests/coercion_separator_test.rs b/renamify-core/tests/coercion_separator_test.rs
index 83af5c7..ab9e9ab 100644
--- a/renamify-core/tests/coercion_separator_test.rs
+++ b/renamify-core/tests/coercion_separator_test.rs
@@ -25,6 +25,7 @@ github.com/DocSpring/oldproject
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -74,6 +75,7 @@ MACRO(oldproject)
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -123,6 +125,7 @@ SETTINGS[oldproject]
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -172,6 +175,7 @@ Module:oldproject
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -223,6 +227,7 @@ fn test_coercion_preserves_case_after_at_sign() {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -272,6 +277,7 @@ System.oldproject.init();
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -321,6 +327,7 @@ project=oldproject
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -370,6 +377,7 @@ fn test_coercion_preserves_case_after_space() {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -422,6 +430,7 @@ fn test_coercion_preserves_case_with_quotes() {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -472,6 +481,7 @@ MyClass{oldproject}
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -521,6 +531,7 @@ const OLDPROJECT_VERSION = "1.0";
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
diff --git a/renamify-core/tests/coercion_tests.rs b/renamify-core/tests/coercion_tests.rs
index 22411b4..51670f8 100644
--- a/renamify-core/tests/coercion_tests.rs
+++ b/renamify-core/tests/coercion_tests.rs
@@ -116,6 +116,7 @@ fn test_end_to_end_coercion_with_files() {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -215,6 +216,7 @@ fn test_coercion_disabled() {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -280,6 +282,7 @@ let config = oldtool.config.load();
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -378,6 +381,7 @@ let regex_pattern = r"oldtool[_-](\w+)";
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -478,6 +482,7 @@ let nested = oldtool::core::pattern::Match;
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -538,6 +543,7 @@ let snake_case_var = oldtool_core; let camelVar = oldtoolService;
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -613,6 +619,7 @@ oldtool = { path = "../oldtool" }
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
diff --git a/renamify-core/tests/compound_position_test.rs b/renamify-core/tests/compound_position_test.rs
index 28d49e2..7ff4353 100644
--- a/renamify-core/tests/compound_position_test.rs
+++ b/renamify-core/tests/compound_position_test.rs
@@ -33,6 +33,7 @@ type FooBarOption = i32;",
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -122,6 +123,7 @@ type GetFooBarOption = i32;",
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -211,6 +213,7 @@ type LoadFooBar = i32;",
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -292,6 +295,7 @@ let fooBar = getFooBar();",
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
diff --git a/renamify-core/tests/compound_word_test.rs b/renamify-core/tests/compound_word_test.rs
index dd734a5..663f8a7 100644
--- a/renamify-core/tests/compound_word_test.rs
+++ b/renamify-core/tests/compound_word_test.rs
@@ -37,6 +37,7 @@ fn getFooBarOption() -> FooBarOption { }",
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -123,6 +124,7 @@ match foo_bar_type {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -205,6 +207,7 @@ function setFooBarType(fooBarType) {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -291,6 +294,7 @@ fn getFooBarOption() -> FooBarOption { }",
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -362,6 +366,7 @@ fn test_multiple_compounds_same_line() {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -421,6 +426,7 @@ fn test_compound_case_preservation_bug() {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -502,6 +508,7 @@ fn test_repeated_word_compound_bug() {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -679,6 +686,7 @@ class TestwordTestwordTestword {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -778,6 +786,7 @@ const TESTWORD_TESTWORD_CONFIG = {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -880,6 +889,7 @@ fn test_kebab_case_triple_repeated() {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -1004,6 +1014,7 @@ For advanced Testword-Testword-Advanced usage...
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -1127,6 +1138,7 @@ Mixed separators:
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -1253,6 +1265,7 @@ Cases where compound should take priority:
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
diff --git a/renamify-core/tests/diff_rendering_test.rs b/renamify-core/tests/diff_rendering_test.rs
index 1a88d01..4321bba 100644
--- a/renamify-core/tests/diff_rendering_test.rs
+++ b/renamify-core/tests/diff_rendering_test.rs
@@ -26,6 +26,7 @@ fn test_diff_merging_same_line() {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -94,6 +95,7 @@ fn test_diff_highlighting() {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
diff --git a/renamify-core/tests/dot_directory_test.rs b/renamify-core/tests/dot_directory_test.rs
index d653891..8c23636 100644
--- a/renamify-core/tests/dot_directory_test.rs
+++ b/renamify-core/tests/dot_directory_test.rs
@@ -31,6 +31,7 @@ temp_dir.child(".renamify").create_dir_all().unwrap();
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -127,6 +128,7 @@ coerce_separators: renamify_core::scanner::CoercionMode::Auto,
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -201,6 +203,7 @@ Commands:
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -253,6 +256,7 @@ impl From<PreviewFormatArg> for PreviewFormat {",
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
diff --git a/renamify-core/tests/exact_match_preserve_test.rs b/renamify-core/tests/exact_match_preserve_test.rs
new file mode 100644
index 0000000..e085427
--- /dev/null
+++ b/renamify-core/tests/exact_match_preserve_test.rs
@@ -0,0 +1,161 @@
+use renamify_core::case_model::generate_variant_map;
+
+#[test]
+fn test_exact_pascal_case_preserves_user_casing() {
+    // When user provides PascalCase input and it matches exactly,
+    // the replacement should be exactly what they typed
+    let map = generate_variant_map("DocSpring", "FormAPI", None);
+
+    // Exact match should preserve exact casing
+    assert_eq!(
+        map.get("DocSpring"),
+        Some(&"FormAPI".to_string()),
+        "PascalCase exact match should preserve user's exact casing (FormAPI, not FormApi)"
+    );
+
+    // Other variants should still work correctly
+    assert_eq!(map.get("doc_spring"), Some(&"form_api".to_string()));
+    assert_eq!(map.get("docSpring"), Some(&"formAPI".to_string()));
+    assert_eq!(map.get("DOC_SPRING"), Some(&"FORM_API".to_string()));
+}
+
+#[test]
+fn test_multiple_acronyms_in_replacement() {
+    let map = generate_variant_map("OldName", "HTTPSAPIClient", None);
+
+    // Exact PascalCase match should preserve all acronyms as typed
+    assert_eq!(
+        map.get("OldName"),
+        Some(&"HTTPSAPIClient".to_string()),
+        "Should preserve HTTPS and API as typed by user"
+    );
+
+    // snake_case should recognize acronyms
+    assert_eq!(map.get("old_name"), Some(&"https_api_client".to_string()));
+
+    // SCREAMING_SNAKE should preserve acronyms
+    assert_eq!(map.get("OLD_NAME"), Some(&"HTTPS_API_CLIENT".to_string()));
+}
+
+#[test]
+fn test_mixed_case_preservation() {
+    // Test various mixed case patterns that users might explicitly want
+    let test_cases = vec![
+        ("MyService", "IoTDevice", "IoTDevice"), // IoT is a specific casing
+        ("MyService", "macOSApp", "macOSApp"),   // macOS is a specific casing
+        ("MyService", "XMLParser", "XMLParser"), // All caps acronym
+        ("MyService", "Html5Video", "Html5Video"), // Mixed acronym/number
+        ("MyService", "PDFReader", "PDFReader"), // Common acronym
+    ];
+
+    for (search, replace, expected) in test_cases {
+        let map = generate_variant_map(search, replace, None);
+        assert_eq!(
+            map.get(search),
+            Some(&expected.to_string()),
+            "Failed for {} -> {}",
+            search,
+            replace
+        );
+    }
+}
+
+#[test]
+fn test_camel_case_preserves_acronyms() {
+    let map = generate_variant_map("oldName", "newAPIClient", None);
+
+    // camelCase exact match should preserve the acronym
+    assert_eq!(
+        map.get("oldName"),
+        Some(&"newAPIClient".to_string()),
+        "camelCase should preserve API acronym as typed"
+    );
+
+    // When converting from PascalCase to camelCase
+    let map2 = generate_variant_map("OldName", "NewAPIClient", None);
+    assert_eq!(
+        map2.get("oldName"),
+        Some(&"newAPIClient".to_string()),
+        "Should properly handle acronyms when converting to camelCase"
+    );
+}
+
+#[test]
+fn test_user_intent_overrides_conventions() {
+    // If user explicitly types something unconventional, respect it
+    let map = generate_variant_map("StandardName", "WeIrDCaSe", None);
+
+    // Exact match should preserve exactly what user typed
+    assert_eq!(
+        map.get("StandardName"),
+        Some(&"WeIrDCaSe".to_string()),
+        "Should preserve user's exact casing even if unconventional"
+    );
+}
+
+#[test]
+fn test_atomic_mode_with_acronyms() {
+    use renamify_core::atomic::AtomicConfig;
+    use renamify_core::case_model::generate_variant_map_with_atomic;
+
+    let atomic_config = AtomicConfig::from_flags_and_config(
+        true, // both atomic
+        false,
+        false,
+        vec![],
+    );
+
+    let map = generate_variant_map_with_atomic("DocSpring", "FormAPI", None, Some(&atomic_config));
+
+    // With atomic mode, should still preserve exact casing for PascalCase
+    assert_eq!(
+        map.get("DocSpring"),
+        Some(&"FormAPI".to_string()),
+        "Atomic mode should preserve FormAPI exactly as typed"
+    );
+
+    // snake_case becomes all lowercase (atomic)
+    assert_eq!(
+        map.get("docspring"),
+        Some(&"formapi".to_string()),
+        "Atomic snake_case should be all lowercase"
+    );
+
+    // SCREAMING becomes all uppercase (atomic)
+    assert_eq!(
+        map.get("DOCSPRING"),
+        Some(&"FORMAPI".to_string()),
+        "Atomic SCREAMING should be all uppercase"
+    );
+
+    // camelCase should preserve the acronym but with atomic behavior
+    assert_eq!(
+        map.get("docSpring"),
+        Some(&"formAPI".to_string()),
+        "Atomic camelCase should preserve acronym casing"
+    );
+}
+
+#[test]
+fn test_real_world_examples() {
+    // Real examples that users would expect to work
+    let test_cases = vec![
+        ("GitLab", "GitHub", "GitHub"),             // Both are well-known
+        ("MySQL", "PostgreSQL", "PostgreSQL"),      // Database names
+        ("OAuth", "SAML", "SAML"),                  // Auth protocols
+        ("iPhone", "iPad", "iPad"),                 // Apple products
+        ("JavaScript", "TypeScript", "TypeScript"), // Languages
+        ("DocuSign", "DocSpring", "DocSpring"),     // Services
+    ];
+
+    for (search, replace, expected) in test_cases {
+        let map = generate_variant_map(search, replace, None);
+        assert_eq!(
+            map.get(search),
+            Some(&expected.to_string()),
+            "Failed for {} -> {}",
+            search,
+            replace
+        );
+    }
+}
diff --git a/renamify-core/tests/format_string_test.rs b/renamify-core/tests/format_string_test.rs
new file mode 100644
index 0000000..c65af30
--- /dev/null
+++ b/renamify-core/tests/format_string_test.rs
@@ -0,0 +1,164 @@
+use renamify_core::operations::plan::plan_operation;
+use std::fs;
+use tempfile::TempDir;
+
+#[test]
+fn test_format_string_with_underscore_preserves_snake_case() {
+    // Test that format strings like 'greattool_{}.tmp' correctly become 'awesome_tool_name_{}.tmp'
+    // The underscore after greattool indicates snake_case context
+    let temp_dir = TempDir::new().unwrap();
+    let temp_path = temp_dir.path();
+
+    // Create a test file with format strings
+    let test_file = temp_path.join("test.rs");
+    fs::write(
+        &test_file,
+        r#"
+fn main() {
+    let file1 = "greattool_{{}}.tmp";
+    let file2 = "greattool_{{}}.log";
+    let file3 = format!("greattool_{{}}_backup.txt", id);
+    // Also test in string literals within assertions
+    assert!(true, "Format string 'greattool_{{}}.tmp' should be replaced");
+    // Also test without underscore for comparison
+    let file4 = "greattool.txt";
+}
+"#,
+    )
+    .unwrap();
+
+    // Scan and replace with all the required parameters
+    let (result, _preview) = plan_operation(
+        "greattool",
+        "awesome_tool_name",
+        vec![temp_path.to_path_buf()],
+        vec![], // include
+        vec![], // exclude
+        true,   // respect_gitignore
+        0,      // unrestricted_level
+        true,   // rename_files
+        true,   // rename_dirs
+        &[],    // exclude_styles
+        &[],    // include_styles
+        &[],    // only_styles
+        vec![], // exclude_match
+        None,   // exclude_matching_lines
+        None,   // plan_out
+        None,   // preview_format
+        true,   // dry_run
+        false,  // fixed_table_width
+        false,  // use_color
+        false,  // no_acronyms
+        vec![], // custom_acronyms
+        vec![], // atomic_search
+        vec![], // atomic_replace
+        None,   // cwd
+        None,   // atomic_config
+    )
+    .unwrap();
+
+    // Get the plan from the result
+    let plan = result.plan.expect("Should have a plan");
+
+    // Find the matches
+    let matches: Vec<_> = plan
+        .matches
+        .iter()
+        .filter(|m| m.file.ends_with("test.rs"))
+        .collect();
+
+    // Should find all instances
+    assert!(!matches.is_empty(), "Should find matches for 'greattool'");
+
+    // Check that format strings with underscore become snake_case
+    for m in &matches {
+        if m.content == "greattool" {
+            if let Some(ref line_before) = m.line_before {
+                if line_before.contains("greattool_") {
+                    assert_eq!(
+                        m.replace, "awesome_tool_name",
+                        "Format string with double curly brackets should preserve snake_case, got: {}",
+                        m.replace
+                    );
+                    // The full line should have the underscore preserved
+                    if let Some(ref line_after) = m.line_after {
+                        assert!(
+                            line_after.contains("awesome_tool_name_"),
+                            "Line should contain 'awesome_tool_name_', got: {}",
+                            line_after
+                        );
+                    }
+                    // Make sure it's NOT lowercase without underscores
+                    assert_ne!(
+                        m.replace, "awesometoolname",
+                        "Should NOT be all lowercase without underscores"
+                    );
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn test_ambiguous_with_following_underscore_is_snake_case() {
+    // Even more direct test - if we have 'tool_' it's obviously snake_case
+    let temp_dir = TempDir::new().unwrap();
+    let temp_path = temp_dir.path();
+
+    let test_file = temp_path.join("config.toml");
+    fs::write(
+        &test_file,
+        r#"
+cache_dir = "mytool_cache"
+log_file = "mytool_debug.log"
+template = "mytool_{}.tmp"
+"#,
+    )
+    .unwrap();
+
+    let (result, _preview) = plan_operation(
+        "mytool",
+        "super_awesome_tool",
+        vec![temp_path.to_path_buf()],
+        vec![],          // include
+        vec![],          // exclude
+        true,            // respect_gitignore
+        0,               // unrestricted_level
+        true,            // rename_files
+        true,            // rename_dirs
+        &[],             // exclude_styles
+        &[],             // include_styles
+        &[],             // only_styles
+        vec![],          // exclude_match
+        None,            // exclude_matching_lines
+        None,            // plan_out
+        None,            // preview_format
+        true,            // dry_run
+        false,           // fixed_table_width
+        false,           // use_color
+        false,           // no_acronyms
+        vec![],          // custom_acronyms
+        vec![],          // atomic_search
+        vec![],          // atomic_replace
+        Some(temp_path), // cwd - set to temp dir (expects &Path)
+        None,            // atomic_config
+    )
+    .unwrap();
+
+    let plan = result.plan.expect("Should have a plan");
+    for m in &plan.matches {
+        if m.content == "mytool" {
+            // All instances should be replaced with snake_case
+            assert_eq!(
+                m.replace, "super_awesome_tool",
+                "mytool in context '{:?}' should become super_awesome_tool, got: {}",
+                m.line_before, m.replace
+            );
+            // Absolutely should NOT be this
+            assert_ne!(
+                m.replace, "superawesometool",
+                "Should NEVER remove underscores to create 'superawesometool'"
+            );
+        }
+    }
+}
diff --git a/renamify-core/tests/hyphenated_capitalized_test.rs b/renamify-core/tests/hyphenated_capitalized_test.rs
index 157f1ea..14aaf11 100644
--- a/renamify-core/tests/hyphenated_capitalized_test.rs
+++ b/renamify-core/tests/hyphenated_capitalized_test.rs
@@ -33,6 +33,7 @@ fn test_hyphenated_capitalized_replacement() {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -141,6 +142,7 @@ fn test_train_case_replacement() {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -222,6 +224,7 @@ fn test_mixed_hyphenated_patterns() {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -297,6 +300,7 @@ use foo_bar_baz_qux_utils;
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -374,6 +378,7 @@ fn test_pascal_case_with_hyphen_suffix() {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
diff --git a/renamify-core/tests/mixed_style_test.rs b/renamify-core/tests/mixed_style_test.rs
index c57e8b0..443f979 100644
--- a/renamify-core/tests/mixed_style_test.rs
+++ b/renamify-core/tests/mixed_style_test.rs
@@ -31,6 +31,7 @@ let simple = renamify;
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -130,6 +131,7 @@ fn test_format_string_placeholders_are_replaced() {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -190,6 +192,7 @@ In format string: renamify_{}.tmp
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
diff --git a/renamify-core/tests/multiple_matches_per_line_test.rs b/renamify-core/tests/multiple_matches_per_line_test.rs
index f7c28bc..bdacd93 100644
--- a/renamify-core/tests/multiple_matches_per_line_test.rs
+++ b/renamify-core/tests/multiple_matches_per_line_test.rs
@@ -23,6 +23,7 @@ fn test_multiple_matches_per_line() {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -83,6 +84,7 @@ fn test_module_path_replacement() {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -119,10 +121,10 @@ fn test_dot_path_replacement() {
     let test_file = root.join("script.sh");
     std::fs::write(
         &test_file,
-        "mkdir .renamify\n\
-         cd .renamify\n\
-         echo 'renamify' > .renamify/config\n\
-         rm -rf .renamify\n",
+        "mkdir .awesometool\n\
+         cd .awesometool\n\
+         echo 'awesometool' > .awesometool/config\n\
+         rm -rf .awesometool\n",
     )
     .unwrap();
 
@@ -134,6 +136,7 @@ fn test_dot_path_replacement() {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -146,25 +149,28 @@ fn test_dot_path_replacement() {
         coerce_separators: renamify_core::scanner::CoercionMode::Auto,
     };
 
-    let plan = scan_repository(&root, "renamify", "smart_search", &options).unwrap();
+    let plan = scan_repository(&root, "awesometool", "smart_search", &options).unwrap();
 
     // Should find all occurrences including dot-prefixed
     assert!(
         plan.stats.total_matches >= 5,
-        "Should find renamify in regular text and .renamify paths"
+        "Should find awesometool in regular text and .awesometool paths"
     );
 
-    // Check that .renamify occurrences are found
+    // Check that .awesometool occurrences are found
     let dot_matches: Vec<_> = plan
         .matches
         .iter()
         .filter(|h| {
             h.line_before
                 .as_ref()
-                .is_some_and(|l| l.contains(".renamify"))
+                .is_some_and(|l| l.contains(".awesometool"))
         })
         .collect();
-    assert!(!dot_matches.is_empty(), "Should find .renamify occurrences");
+    assert!(
+        !dot_matches.is_empty(),
+        "Should find .awesometool occurrences"
+    );
 }
 
 #[test]
@@ -184,6 +190,7 @@ fn test_consecutive_occurrences() {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -237,6 +244,7 @@ fn test_camel_case_variant_multiple_per_line() {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -284,6 +292,7 @@ fn test_mixed_separators_on_same_line() {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -346,6 +355,7 @@ fn test_markdown_code_blocks() {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
diff --git a/renamify-core/tests/replace_column_position_test.rs b/renamify-core/tests/replace_column_position_test.rs
index b842e95..b29bb46 100644
--- a/renamify-core/tests/replace_column_position_test.rs
+++ b/renamify-core/tests/replace_column_position_test.rs
@@ -22,6 +22,7 @@ fn test_replace_command_column_positions() {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -88,6 +89,7 @@ fn test_replace_command_regex_column_positions() {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -153,6 +155,7 @@ fn test_replace_highlighting_compatibility() {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
diff --git a/renamify-core/tests/replace_include_flag_test.rs b/renamify-core/tests/replace_include_flag_test.rs
index c42dbc6..087b185 100644
--- a/renamify-core/tests/replace_include_flag_test.rs
+++ b/renamify-core/tests/replace_include_flag_test.rs
@@ -48,6 +48,7 @@ fn test_replace_include_flag_respects_pattern() {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec!["test/**/*".to_string()], // Only include test directory
         excludes: vec![],
         respect_gitignore: false,
@@ -171,6 +172,7 @@ fn test_replace_include_flag_with_specific_file() {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec!["file1.txt".to_string()], // Only include file1.txt
         excludes: vec![],
         respect_gitignore: false,
@@ -234,6 +236,7 @@ fn test_replace_include_with_directory_pattern() {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec!["test/".to_string()],
         excludes: vec![],
         respect_gitignore: false,
diff --git a/renamify-core/tests/tokenization_edge_cases_test.rs b/renamify-core/tests/tokenization_edge_cases_test.rs
index 00f6a0d..cab197a 100644
--- a/renamify-core/tests/tokenization_edge_cases_test.rs
+++ b/renamify-core/tests/tokenization_edge_cases_test.rs
@@ -29,6 +29,7 @@ URL="https://github.com/DocSpring/renamed_renaming_tool"
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -121,6 +122,7 @@ curl -L "https://raw.githubusercontent.com/DocSpring/oldproject/main/install.sh"
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -226,6 +228,7 @@ let oldtool_debug_identifiers = true;
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -283,6 +286,7 @@ let normal_backup = "oldtool_backup";
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -346,6 +350,7 @@ import: @mycompany/oldtool
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -408,6 +413,7 @@ let tool_ide_support = true;
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -482,6 +488,7 @@ fn test() {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -555,6 +562,7 @@ if std::env::var("TOOL_IDENTIFIER_DEBUG").is_ok() {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
diff --git a/renamify-core/tests/train_case_apply_test.rs b/renamify-core/tests/train_case_apply_test.rs
index faedecc..5864ea8 100644
--- a/renamify-core/tests/train_case_apply_test.rs
+++ b/renamify-core/tests/train_case_apply_test.rs
@@ -35,6 +35,7 @@ fn test_train_case_patterns_are_replaced_in_apply() {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
diff --git a/renamify-core/tests/train_case_literals_test.rs b/renamify-core/tests/train_case_literals_test.rs
index 86f904b..d9ee4c8 100644
--- a/renamify-core/tests/train_case_literals_test.rs
+++ b/renamify-core/tests/train_case_literals_test.rs
@@ -53,6 +53,7 @@ pub fn process() {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
@@ -171,6 +172,7 @@ fn test_train_case_exact_patterns() {
         exclude_acronyms: vec![],
         only_acronyms: vec![],
         ignore_ambiguous: false,
+        atomic_config: None,
         includes: vec![],
         excludes: vec![],
         respect_gitignore: false,
diff --git a/renamify-mcp/src/index.ts b/renamify-mcp/src/index.ts
index 309d1b6..292a419 100644
--- a/renamify-mcp/src/index.ts
+++ b/renamify-mcp/src/index.ts
@@ -75,6 +75,18 @@ export function createServer(
           .describe(
             "Ignore mixed-case/ambiguous identifiers that don't match standard patterns"
           ),
+        atomicSearch: z
+          .boolean()
+          .optional()
+          .describe(
+            'Treat search term as atomic (GitHub → github, not git_hub)'
+          ),
+        atomicReplace: z
+          .boolean()
+          .optional()
+          .describe(
+            'Treat replace term as atomic (GitHub → github, not git_hub)'
+          ),
       },
     },
     async (params) => {
@@ -138,6 +150,12 @@ export function createServer(
           .describe(
             "Ignore mixed-case/ambiguous identifiers that don't match standard patterns"
           ),
+        atomicSearch: z
+          .boolean()
+          .optional()
+          .describe(
+            'Treat search term as atomic (GitHub → github, not git_hub)'
+          ),
       },
     },
     async (params) => {
@@ -306,6 +324,18 @@ export function createServer(
           .array(z.string())
           .optional()
           .describe('Only use these specific case styles'),
+        atomicSearch: z
+          .boolean()
+          .optional()
+          .describe(
+            'Treat search term as atomic (GitHub → github, not git_hub)'
+          ),
+        atomicReplace: z
+          .boolean()
+          .optional()
+          .describe(
+            'Treat replace term as atomic (GitHub → github, not git_hub)'
+          ),
       },
     },
     async (params) => {
diff --git a/renamify-mcp/src/renamify-service.ts b/renamify-mcp/src/renamify-service.ts
index e8fab3e..d7257f7 100644
--- a/renamify-mcp/src/renamify-service.ts
+++ b/renamify-mcp/src/renamify-service.ts
@@ -26,6 +26,7 @@ export type SearchOptions = {
   renameFiles?: boolean;
   renameDirs?: boolean;
   ignoreAmbiguous?: boolean;
+  atomicSearch?: boolean;
 };
 
 export type PlanOptions = {
@@ -40,6 +41,8 @@ export type PlanOptions = {
   renameFiles?: boolean;
   renameDirs?: boolean;
   ignoreAmbiguous?: boolean;
+  atomicSearch?: boolean;
+  atomicReplace?: boolean;
 };
 
 export type ApplyOptions = {
@@ -166,6 +169,7 @@ export class RenamifyService {
     this.addDryRunArg(args, options.dryRun);
     this.addRenameArgs(args, options.renameFiles, options.renameDirs);
     this.addIgnoreAmbiguousArg(args, options.ignoreAmbiguous);
+    this.addAtomicSearchArg(args, options.atomicSearch);
 
     return args;
   }
@@ -185,6 +189,8 @@ export class RenamifyService {
     this.addDryRunArg(args, options.dryRun);
     this.addRenameArgs(args, options.renameFiles, options.renameDirs);
     this.addIgnoreAmbiguousArg(args, options.ignoreAmbiguous);
+    this.addAtomicSearchArg(args, options.atomicSearch);
+    this.addAtomicReplaceArg(args, options.atomicReplace);
 
     return args;
   }
@@ -245,6 +251,18 @@ export class RenamifyService {
     }
   }
 
+  private addAtomicSearchArg(args: string[], atomicSearch?: boolean): void {
+    if (atomicSearch) {
+      args.push('--atomic-search');
+    }
+  }
+
+  private addAtomicReplaceArg(args: string[], atomicReplace?: boolean): void {
+    if (atomicReplace) {
+      args.push('--atomic-replace');
+    }
+  }
+
   private async executeCommand(
     args: string[],
     operation: string
@@ -438,6 +456,8 @@ export class RenamifyService {
     excludeStyles?: string[];
     includeStyles?: string[];
     onlyStyles?: string[];
+    atomicSearch?: boolean;
+    atomicReplace?: boolean;
   }): Promise<string> {
     const args = ['rename', options.old, options.new];
 
@@ -462,6 +482,14 @@ export class RenamifyService {
       args.push('--only-styles', options.onlyStyles.join(','));
     }
 
+    // Add atomic flags
+    if (options.atomicSearch) {
+      args.push('--atomic-search');
+    }
+    if (options.atomicReplace) {
+      args.push('--atomic-replace');
+    }
+
     // Add dry-run flag
     if (options.dryRun) {
       args.push('--dry-run');
diff --git a/renamify-vscode/extension/src/cliService.ts b/renamify-vscode/extension/src/cliService.ts
index 4a7a82e..77bbc95 100644
--- a/renamify-vscode/extension/src/cliService.ts
+++ b/renamify-vscode/extension/src/cliService.ts
@@ -235,6 +235,10 @@ export class RenamifyCliService {
       args.push('--no-rename-paths');
     }
 
+    if (options.atomicSearch) {
+      args.push('--atomic-search');
+    }
+
     const config = vscode.workspace.getConfiguration('renamify');
     if (!config.get('respectGitignore')) {
       args.push('-u');
@@ -284,6 +288,14 @@ export class RenamifyCliService {
       args.push('--no-rename-paths');
     }
 
+    if (options.atomicSearch) {
+      args.push('--atomic-search');
+    }
+
+    if (options.atomicReplace) {
+      args.push('--atomic-replace');
+    }
+
     const config = vscode.workspace.getConfiguration('renamify');
     if (!config.get('respectGitignore')) {
       args.push('-u');
@@ -329,6 +341,14 @@ export class RenamifyCliService {
       args.push('--no-rename-paths');
     }
 
+    if (options.atomicSearch) {
+      args.push('--atomic-search');
+    }
+
+    if (options.atomicReplace) {
+      args.push('--atomic-replace');
+    }
+
     const config = vscode.workspace.getConfiguration('renamify');
     if (!config.get('respectGitignore')) {
       args.push('-u');
diff --git a/renamify-vscode/extension/src/types.ts b/renamify-vscode/extension/src/types.ts
index a9d4040..f37362d 100644
--- a/renamify-vscode/extension/src/types.ts
+++ b/renamify-vscode/extension/src/types.ts
@@ -7,6 +7,8 @@ export type SearchOptions = {
   caseStyles?: string[];
   renamePaths?: boolean;
   ignoreAmbiguous?: boolean;
+  atomicSearch?: boolean;
+  atomicReplace?: boolean;
 };
 
 // Match type is now imported from Rust bindings above
@@ -34,6 +36,8 @@ export type SearchMessage = {
   caseStyles?: string[];
   renamePaths?: boolean;
   ignoreAmbiguous?: boolean;
+  atomicSearch?: boolean;
+  atomicReplace?: boolean;
   searchId?: number;
 };
 
@@ -47,6 +51,8 @@ export type PlanMessage = {
   caseStyles?: string[];
   renamePaths?: boolean;
   ignoreAmbiguous?: boolean;
+  atomicSearch?: boolean;
+  atomicReplace?: boolean;
 };
 
 export type ApplyMessage = {
@@ -59,6 +65,8 @@ export type ApplyMessage = {
   caseStyles?: string[];
   renamePaths?: boolean;
   ignoreAmbiguous?: boolean;
+  atomicSearch?: boolean;
+  atomicReplace?: boolean;
   planId?: string;
 };
 
diff --git a/renamify-vscode/extension/templates/webview.hbs b/renamify-vscode/extension/templates/webview.hbs
index 5f7f6e2..5449485 100644
--- a/renamify-vscode/extension/templates/webview.hbs
+++ b/renamify-vscode/extension/templates/webview.hbs
@@ -83,7 +83,39 @@
         <label class="checkbox-label">
           <input type="checkbox" id="ignoreAmbiguousCheckbox" />
           Ignore ambiguous identifiers
+          <a
+            href="https://docspring.github.io/renamify/features/ambiguity-resolution/"
+            class="more-info-link"
+            target="_blank"
+            >more info</a
+          >
         </label>
+        <div class="atomic-checkboxes">
+          <label class="checkbox-label">
+            <input type="checkbox" id="atomicSearchCheckbox" />
+            Atomic search
+            <span class="tooltip-wrapper tooltip-left">
+              <span class="codicon codicon-info tooltip-icon"></span>
+              <span class="tooltip-text">
+                Treats compound words in PascalCase as single units in other cases.<br />
+                <strong>Example:</strong> GitHub → github<br />
+                <strong>Not:</strong> GitHub → git_hub
+              </span>
+            </span>
+          </label>
+          <label class="checkbox-label">
+            <input type="checkbox" id="atomicReplaceCheckbox" />
+            Atomic replace
+            <span class="tooltip-wrapper tooltip-right">
+              <span class="codicon codicon-info tooltip-icon"></span>
+              <span class="tooltip-text">
+                Treats compound words in PascalCase as single units in other cases.<br />
+                <strong>Example:</strong> GitHub → github<br />
+                <strong>Not:</strong> GitHub → git_hub
+              </span>
+            </span>
+          </label>
+        </div>
       </div>
 
       <div class="button-group">
diff --git a/renamify-vscode/media/style.css b/renamify-vscode/media/style.css
index a7f946d..f670c31 100644
--- a/renamify-vscode/media/style.css
+++ b/renamify-vscode/media/style.css
@@ -122,6 +122,112 @@ body {
   margin-right: 6px;
 }
 
+/* More info link */
+.more-info-link {
+  margin-left: 8px;
+  font-size: 11px;
+  color: var(--vscode-textLink-foreground);
+  text-decoration: none;
+  opacity: 0.8;
+}
+
+.more-info-link:hover {
+  text-decoration: underline;
+  opacity: 1;
+}
+
+/* Atomic checkboxes on same line */
+.atomic-checkboxes {
+  display: flex;
+  gap: 16px;
+  align-items: center;
+}
+
+/* Tooltip wrapper and icon */
+.tooltip-wrapper {
+  position: relative;
+  display: inline-flex;
+  align-items: center;
+  margin-left: 4px;
+}
+
+.tooltip-icon {
+  cursor: help;
+  opacity: 0.7;
+  font-size: 14px;
+  display: inline-block;
+  position: relative;
+  top: 4px;
+}
+
+.tooltip-wrapper:hover .tooltip-icon {
+  opacity: 1;
+}
+
+/* Tooltip text */
+.tooltip-text {
+  position: absolute;
+  bottom: 100%;
+  left: 50%;
+  transform: translateX(-50%);
+  margin-bottom: 5px;
+  padding: 8px 12px;
+  background-color: var(--vscode-editorWidget-background);
+  color: var(--vscode-editorWidget-foreground);
+  border: 1px solid var(--vscode-editorWidget-border);
+  border-radius: 3px;
+  font-size: 12px;
+  line-height: 1.4;
+  white-space: normal;
+  min-width: 200px;
+  max-width: 320px;
+  z-index: 1000;
+  opacity: 0;
+  visibility: hidden;
+  transition:
+    opacity 0.2s,
+    visibility 0.2s;
+  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.15);
+  pointer-events: none;
+}
+
+.tooltip-text strong {
+  color: var(--vscode-foreground);
+  font-weight: 600;
+}
+
+/* Shift left tooltip to the right to avoid left edge cutoff */
+.tooltip-left .tooltip-text {
+  left: -20px;
+  transform: translateX(0);
+}
+
+/* Shift right tooltip to the left to avoid right edge cutoff */
+.tooltip-right .tooltip-text {
+  right: -20px;
+  left: auto;
+  transform: translateX(0);
+}
+
+/* Show tooltip on hover */
+.tooltip-wrapper:hover .tooltip-text {
+  opacity: 1;
+  visibility: visible;
+}
+
+/* Tooltip arrow */
+.tooltip-text::after {
+  content: "";
+  position: absolute;
+  top: 100%;
+  left: 50%;
+  transform: translateX(-50%);
+  border-width: 5px;
+  border-style: solid;
+  border-color: var(--vscode-editorWidget-border) transparent transparent
+    transparent;
+}
+
 .button-group {
   display: flex;
   gap: 8px;
diff --git a/renamify-vscode/webview/src/webview.ts b/renamify-vscode/webview/src/webview.ts
index cbb7d33..c4a2a4c 100644
--- a/renamify-vscode/webview/src/webview.ts
+++ b/renamify-vscode/webview/src/webview.ts
@@ -33,6 +33,18 @@ type SearchResult = {
   const excludeLinesInput = document.getElementById(
     'excludeLines'
   ) as HTMLInputElement;
+  const renamePathsCheckbox = document.getElementById(
+    'renamePathsCheckbox'
+  ) as HTMLInputElement;
+  const ignoreAmbiguousCheckbox = document.getElementById(
+    'ignoreAmbiguousCheckbox'
+  ) as HTMLInputElement;
+  const atomicSearchCheckbox = document.getElementById(
+    'atomicSearchCheckbox'
+  ) as HTMLInputElement;
+  const atomicReplaceCheckbox = document.getElementById(
+    'atomicReplaceCheckbox'
+  ) as HTMLInputElement;
   const applyBtn = document.getElementById('applyBtn') as HTMLButtonElement;
   const expandAllBtn = document.getElementById(
     'expandAll'
@@ -167,6 +179,24 @@ type SearchResult = {
   excludeInput.addEventListener('input', debouncedSearch);
   excludeLinesInput.addEventListener('input', debouncedSearch);
 
+  // Re-run search when checkboxes change
+  renamePathsCheckbox.addEventListener('change', () => {
+    performSearch();
+    saveState();
+  });
+  ignoreAmbiguousCheckbox.addEventListener('change', () => {
+    performSearch();
+    saveState();
+  });
+  atomicSearchCheckbox.addEventListener('change', () => {
+    performSearch();
+    saveState();
+  });
+  atomicReplaceCheckbox.addEventListener('change', () => {
+    performSearch();
+    saveState();
+  });
+
   // Update checked count and trigger search when checkboxes change
   function updateCheckedCount() {
     const checked = document.querySelectorAll(
@@ -231,6 +261,10 @@ type SearchResult = {
       exclude: excludeInput.value,
       excludeMatchingLines: excludeLinesInput.value,
       caseStyles: selectedStyles,
+      renamePaths: renamePathsCheckbox.checked,
+      ignoreAmbiguous: ignoreAmbiguousCheckbox.checked,
+      atomicSearch: atomicSearchCheckbox.checked,
+      atomicReplace: atomicReplaceCheckbox.checked,
       searchId, // Include search ID to match responses
     });
   }
@@ -258,6 +292,10 @@ type SearchResult = {
       exclude: excludeInput.value,
       excludeMatchingLines: excludeLinesInput.value,
       caseStyles: selectedStyles,
+      renamePaths: renamePathsCheckbox.checked,
+      ignoreAmbiguous: ignoreAmbiguousCheckbox.checked,
+      atomicSearch: atomicSearchCheckbox.checked,
+      atomicReplace: atomicReplaceCheckbox.checked,
     });
   }
 
@@ -755,6 +793,10 @@ type SearchResult = {
     include?: string;
     exclude?: string;
     excludeLines?: string;
+    renamePaths?: boolean;
+    ignoreAmbiguous?: boolean;
+    atomicSearch?: boolean;
+    atomicReplace?: boolean;
     results?: SearchResult[];
   } | null;
   if (state) {
@@ -764,6 +806,20 @@ type SearchResult = {
     excludeInput.value = state.exclude || '';
     excludeLinesInput.value = state.excludeLines || '';
 
+    // Restore checkbox states (use defaults if not saved)
+    if (state.renamePaths !== undefined) {
+      renamePathsCheckbox.checked = state.renamePaths;
+    }
+    if (state.ignoreAmbiguous !== undefined) {
+      ignoreAmbiguousCheckbox.checked = state.ignoreAmbiguous;
+    }
+    if (state.atomicSearch !== undefined) {
+      atomicSearchCheckbox.checked = state.atomicSearch;
+    }
+    if (state.atomicReplace !== undefined) {
+      atomicReplaceCheckbox.checked = state.atomicReplace;
+    }
+
     if (state.results) {
       renderResults(state.results);
     } else if (state.search) {
@@ -780,6 +836,10 @@ type SearchResult = {
       include: includeInput.value,
       exclude: excludeInput.value,
       excludeLines: excludeLinesInput.value,
+      renamePaths: renamePathsCheckbox.checked,
+      ignoreAmbiguous: ignoreAmbiguousCheckbox.checked,
+      atomicSearch: atomicSearchCheckbox.checked,
+      atomicReplace: atomicReplaceCheckbox.checked,
       results: currentResults,
     });
   }