diff --git a/.claude/CLAUDE.md b/.claude/CLAUDE.md
index 58e23ce6..4d3aea3b 100644
--- a/.claude/CLAUDE.md
+++ b/.claude/CLAUDE.md
@@ -126,6 +126,7 @@ Input → VCS Detection → Version Parsing → Transformation → Format Output
 - **Environment variables**: `ZERV_TEST_NATIVE_GIT`, `ZERV_TEST_DOCKER`
 - **Git operations**: Always use `get_git_impl()`
 - **Docker tests**: Always use `should_run_docker_tests()` gating
+- **CRITICAL**: For Git-related tests, **ALWAYS use `ZERV_TEST_NATIVE_GIT=false ZERV_TEST_DOCKER=true`**
 - **Integration tests**: Prefer `TestCommand::run_with_stdin()` (90% of cases)
 
 **For detailed testing patterns:**
diff --git a/.claude/plan/32-zerv-flow-implementation-plan.md b/.claude/plan/32-zerv-flow-implementation-plan.md
index 3a45234a..296a57d5 100644
--- a/.claude/plan/32-zerv-flow-implementation-plan.md
+++ b/.claude/plan/32-zerv-flow-implementation-plan.md
@@ -103,18 +103,18 @@ This section demonstrates how Zerv Flow works across different branching strateg
 **Scenario Overview**:
 
 - Development starts from `v1.0.0` on main
-- Three feature branches created in parallel: `feature-1`, `feature-2`, and later `feature-3`
+- Two feature branches created in parallel: `feature-1` and `feature-2`
 - `feature-1` gets completed and released first (`v1.0.1`)
 - `feature-2` syncs with main to get `feature-1` changes, then continues development
-- `feature-3` branches from `feature-2` to implement a sub-feature
-- `feature-3` merges back to `feature-2`, which then releases as `v1.1.0`
+- `feature-3` branches from `feature-2` to implement a sub-feature (nested feature branch)
+- `feature-3` merges back to `feature-2`, which then completes development and releases as `v1.1.0`
 
 **Key Zerv Flow behaviors demonstrated**:
 
 - **Uncommitted changes**: Shows dirty state with `.dev.timestamp` suffix
-- **Parallel development**: Different branches get unique hash-based IDs (`12345`, `54321`, `98765`)
+- **Parallel development**: Different branches get unique hash-based IDs (`68031`, `42954`, `14698`)
 - **Version progression**: Base version updates when syncing with main (`1.0.1` → `1.0.2`)
-- **Post-release distance resets**: Counters reset to `.post.1` after syncing with new base version
+- **Post-release distance continuity**: Distance counters continue accumulating across branches and merges
 - **Nested feature branches**: `feature-3` branching from `feature-2` with independent versioning
 - **Merge handling**: Clean version progression through complex merge scenarios
 - **Alpha pre-releases**: All development branches use `alpha` pre-release identifiers
@@ -126,36 +126,56 @@ config:
   theme: 'base'
 ---
 gitGraph
+    %% Step 1: Initial commit on main with v1.0.0 tag
     commit id: "1.0.0"
 
+    %% Step 2: Create parallel feature branches feature-1 and feature-2 from main
     branch feature-1 order: 2
     branch feature-2 order: 3
 
+    %% Step 3: feature-2: Start development with dirty state
     checkout feature-2
-    commit type:REVERSE id: "1.0.1-alpha.12345.post.0.dev.1729924622" tag: "uncommitted"
-    commit id: "1.0.1-alpha.12345.post.1"
+    commit type:REVERSE id: "1.0.1-alpha.68031.post.0.dev.{timestamp}" tag: "uncommitted"
 
+    %% Step 4: feature-2: Create first commit
+    commit id: "1.0.1-alpha.68031.post.1"
+
+    %% Step 5: feature-1: Create commits (parallel development)
     checkout feature-1
-    commit id: "1.0.1-alpha.54321.post.1"
-    commit id: "1.0.1-alpha.54321.post.2"
+    commit id: "1.0.1-alpha.42954.post.1"
+    commit id: "1.0.1-alpha.42954.post.2"
 
+    %% Step 6: feature-1: Merge to main and release v1.0.1
     checkout main
     merge feature-1 id: "1.0.1" tag: "feature-1 released"
 
+    %% Step 7: feature-2: Sync with main to get feature-1 changes
     checkout feature-2
-    merge main id: "1.0.2-alpha.12345.post.1"
-    commit id: "1.0.2-alpha.12345.post.2"
+    merge main id: "1.0.2-alpha.68031.post.2"
+
+    %% Step 8: feature-2: Create additional commit
+    commit id: "1.0.2-alpha.68031.post.3"
 
+    %% Step 9: feature-3: Branch from feature-2 for sub-feature development
     branch feature-3 order: 4
     checkout feature-3
-    commit id: "1.0.2-alpha.98765.post.3"
-    commit type:REVERSE id: "1.0.2-alpha.98765.post.3.dev.1729924622" tag: "uncommitted"
-    commit id: "1.0.2-alpha.98765.post.4"
+    commit id: "1.0.2-alpha.14698.post.4"
+
+    %% Step 10: feature-3: Continue development with dirty state
+    commit type:REVERSE id: "1.0.2-alpha.14698.post.4.dev.{timestamp}" tag: "uncommitted"
 
+    %% Step 11: feature-3: Continue development with commits
+    commit id: "1.0.2-alpha.14698.post.5"
+    commit id: "1.0.2-alpha.14698.post.6"
+
+    %% Step 12: feature-2: Merge feature-3 back to continue development
     checkout feature-2
-    merge feature-3 id: "1.0.2-alpha.12345.post.3" tag: "feature-3 merged"
+    merge feature-3 id: "1.0.2-alpha.68031.post.6" tag: "feature-3 merged"
+
+    %% Step 13: feature-2: Final development before release
+    commit id: "1.0.2-alpha.68031.post.7"
 
-    commit id: "1.0.2-alpha.12345.post.4"
+    %% Step 14: Final release: feature-2 merges to main and releases v1.1.0
     checkout main
     merge feature-2 id: "1.1.0" tag: "feature-2 released"
 ```
@@ -179,7 +199,8 @@ gitGraph
 - **RC pre-releases**: Release branches use `rc` identifier for release candidates
 - **Clean releases**: Main branch maintains clean versions without pre-release suffixes
 - **Hotfix emergency flow**: Critical fixes from main with proper version propagation
-- **Post-release resolution**: Correct post counting based on pre-release type changes
+- **Release branch post mode**: `release/*` branches use post distance from release tag (commit distance)
+- **Trunk-based post mode**: Other branches use post distance from branch point (for parallel development)
 - **Base version propagation**: Version bumps when syncing branches with newer main releases
 
 ```mermaid
@@ -189,43 +210,57 @@ config:
   theme: 'base'
 ---
 gitGraph
+    %% Step 1: Initial state: main and develop branches
     commit id: "1.0.0"
 
+    %% Step 2: Create develop branch with initial development commit
     branch develop order: 3
     checkout develop
     commit id: "1.0.1-beta.1.post.1"
 
+    %% Step 3: Feature development from develop branch (trunk-based post mode)
     branch feature/auth order: 4
     checkout feature/auth
-    commit id: "1.0.1-alpha.12345.post.1"
-    commit id: "1.0.1-alpha.12345.post.2"
+    commit id: "1.0.1-alpha.92409.post.2"
+    commit id: "1.0.1-alpha.92409.post.3"
 
     checkout develop
-    merge feature/auth id: "1.0.1-beta.1.post.2" tag: "feature merged"
+    %% Step 4: Merge feature/auth back to develop
+    merge feature/auth id: "1.0.1-beta.1.post.3" tag: "feature merged"
 
+    %% Step 5: Hotfix emergency flow from main
     checkout main
     branch hotfix/critical order: 1
     checkout hotfix/critical
-    commit id: "1.0.1-alpha.54321.post.1"
+    commit id: "1.0.1-alpha.11477.post.1"
 
     checkout main
-    merge hotfix/critical id: "1.0.1" tag: "tagged"
+    %% Step 6: Merge hotfix to main and release v1.0.1
+    merge hotfix/critical id: "1.0.1" tag: "hotfix released"
 
+    %% Step 7: Sync develop with main changes and continue development
     checkout develop
-    merge main id: "1.0.2-beta.1.post.3" tag: "update main"
-    commit id: "1.0.2-beta.1.post.4"
+    merge main id: "1.0.2-beta.1.post.4" tag: "sync main"
+
+    %% Step 8: Continue development on develop branch
+    commit id: "1.0.2-beta.1.post.5"
 
+    %% Step 9: Release branch preparation (release/* uses commit distance from tag)
     branch release/1 order: 2
     checkout release/1
     commit id: "1.0.2-rc.1.post.1" tag: "tagged"
     commit id: "1.0.2-rc.1.post.2" tag: "tagged"
-    commit id: "1.0.2-rc.1.post.2.dev.1729924622"
+    commit type:REVERSE id: "1.0.2-rc.1.post.2.dev.{timestamp1}" tag: "uncommit"
+    commit id: "1.0.2-rc.1.post.2.dev.{timestamp2}" tag: "untagged"
+    commit id: "1.0.2-rc.1.post.3" tag: "tagged"
 
     checkout main
-    merge release/1 id: "1.1.0" tag: "tagged"
+    %% Step 10: Final release: merge release/1 to main
+    merge release/1 id: "1.1.0" tag: "release 1.1.0"
 
+    %% Step 11: Sync develop with release and prepare for next cycle
     checkout develop
-    merge main id: "1.1.1-beta.1.post.1" tag: "update main"
+    merge main id: "1.1.1-beta.1.post.1" tag: "sync release"
 ```
 
 ## Scope and Limitations
diff --git a/.claude/plan/33-zerv-flow-cli-command-design.md b/.claude/plan/33-zerv-flow-cli-command-design.md
index d6b85d84..4696301a 100644
--- a/.claude/plan/33-zerv-flow-cli-command-design.md
+++ b/.claude/plan/33-zerv-flow-cli-command-design.md
@@ -39,17 +39,62 @@ zerv flow [OPTIONS]
       --bumped-branch <BRANCH>     Override branch name for pre-release resolution (same as zerv version)
       --bumped-branch-hash-length <LENGTH> Branch hash length for pre-release numbers [default: 5] [range: 4..16]
       --post-mode <TYPE>            Post calculation mode [default: tag] [possible values: tag, commit]
-      --build-context              Include build context (+branch.commit) in output [default: true]
-      --no-build-context            Exclude build context from output
-      --dev-ts                     Include dev timestamp for dirty working directory [default: auto-detect]
-      --no-dev-ts                  Exclude dev timestamp from output
-      --with-pre-release           Include pre-release/post-release but no build context
-      --base-only                  Base version only (major.minor.patch)
+      --schema <SCHEMA>             Schema variant for output components [default: standard] [possible values: standard, standard-no-context, standard-context, standard-base, standard-base-prerelease, standard-base-prerelease-post, standard-base-prerelease-post-dev]
 -v, --verbose                    Show verbose output including version resolution details
 -h, --help                       Print help
 -V, --version                    Print version
 ```
 
+### Schema System
+
+**zerv flow uses the flexible schema system from zerv version but restricted to standard schema family only.**
+
+#### Available Standard Schema Variants
+
+- **`standard`** (default) - Smart context: includes context only for dirty/distance states, excludes for clean tagged
+- **`standard-no-context`** - Never includes build context (branch.commit info)
+- **`standard-context`** - Always includes build context
+- **`standard-base`** - Base version only (e.g., `1.2.3`)
+- **`standard-base-prerelease`** - Base + prerelease (e.g., `1.2.3-alpha.1`)
+- **`standard-base-prerelease-post`** - Base + prerelease + post (e.g., `1.2.3-alpha.1.post.2`)
+- **`standard-base-prerelease-post-dev`** - Base + prerelease + post + dev (e.g., `1.2.3-alpha.1.post.2.dev.123`)
+
+#### Schema Behavior Examples
+
+**Smart Context (`standard` - default):**
+
+- Clean tagged commit: `1.0.1-rc.1.post.1`
+- Dirty working directory: `1.0.1-rc.1.post.1.dev.1729924622+feature.auth.1.a1b2c3d`
+- Distance from tag: `1.0.1-rc.1.post.2+feature.auth.2.c2d3e4f`
+
+**No Context (`standard-no-context`):**
+
+- Any state: `1.0.1-rc.1.post.1` (never includes +branch.commit)
+
+**Always Context (`standard-context`):**
+
+- Any state: `1.0.1-rc.1.post.1+feature.auth.1.a1b2c3d` (always includes context)
+
+**Base Components:**
+
+- `standard-base`: `1.2.3`
+- `standard-base-prerelease`: `1.2.3-alpha.1`
+- `standard-base-prerelease-post`: `1.2.3-alpha.1.post.2`
+- `standard-base-prerelease-post-dev`: `1.2.3-alpha.1.post.2.dev.123`
+
+#### Schema Validation
+
+**Only standard schema family supported in zerv flow:**
+
+- ✅ **Valid**: `standard`, `standard-no-context`, `standard-context`, `standard-base`, `standard-base-prerelease`, `standard-base-prerelease-post`, `standard-base-prerelease-post-dev`
+- ❌ **Invalid**: Any `calver*` schema variants will produce error
+- ❌ **Invalid**: Any deprecated tier-based schemas will produce error
+
+**Error handling:**
+
+- Non-standard schemas will result in: `Error: zerv flow only supports standard schema variants, got: 'calver'`
+- Invalid schema names will result in: `Error: Unknown schema variant: 'invalid-schema'`
+
 ## Pre-release Resolution Logic
 
 ### Default Behavior (no flags)
@@ -162,17 +207,21 @@ zerv flow --branch-rules
 
 ### Manual Override
 
-**Mutually exclusive with `--pre-release-from-branch`:**
+**Schema can be combined with manual pre-release overrides:**
 
 ```bash
-# Force specific pre-release type and number
-zerv flow --pre-release-label beta --pre-release-num 1
+# Force specific pre-release type and number with context
+zerv flow --pre-release-label beta --pre-release-num 1 --schema standard-context
+
+# Force rc for release-like branches, no context
+zerv flow --pre-release-label rc --pre-release-num 2 --schema standard-base-prerelease-post
 
-# Force rc for release-like branches
-zerv flow --pre-release-label rc --pre-release-num 2
+# Force alpha for feature branches with full context
+zerv flow --pre-release-label alpha --schema standard-base-prerelease-post-dev-context
 
-# Force alpha for feature branches (uses hash by default)
-zerv flow --pre-release-label alpha
+# Manual overrides with different schema levels
+zerv flow --pre-release-label beta --schema standard-base-prerelease
+zerv flow --pre-release-label rc --schema standard-base
 ```
 
 ### Branch Override
@@ -180,25 +229,32 @@ zerv flow --pre-release-label alpha
 **Test different branch scenarios without switching branches:**
 
 ```bash
-zerv flow --bumped-branch develop --pre-release-from-branch
-zerv flow --bumped-branch release/1 --pre-release-from-branch
+# Test develop branch with different schemas
+zerv flow --bumped-branch develop --schema standard
+zerv flow --bumped-branch develop --schema standard-no-context
+
+# Test release branch with specific schema
+zerv flow --bumped-branch release/1 --schema standard-base-prerelease-post-context
+
+# Test feature branch scenarios
+zerv flow --bumped-branch feature/auth --schema standard-base-prerelease-post-dev
 ```
 
 ## Output Modes
 
-### Full Output (default)
+### Full Output (default - `standard` schema)
 
 ```
 1.0.1-alpha.12345.post.2.dev.1729924622+feature.auth.2.a1b2c3d
 ```
 
-### Pre-release Output (`--with-pre-release`)
+### Pre-release Output (`--schema standard-base-prerelease-post`)
 
 ```
 1.0.1-alpha.12345.post.2
 ```
 
-### Base-Only Output (`--base-only`)
+### Base-Only Output (`--schema standard-base`)
 
 ```
 1.0.1
@@ -235,36 +291,42 @@ zerv flow --bumped-branch release/1 --pre-release-from-branch
 ### Basic Usage
 
 ```bash
-# Generate flow version with automatic pre-release
+# Generate flow version with smart context (default schema)
 zerv flow
 
-# Enable branch pattern detection (GitFlow)
-zerv flow --pre-release-from-branch
-
 # Force specific pre-release type
 zerv flow --pre-release-label beta
 
 # Include pre-release/post-release but no build context
-zerv flow --with-pre-release
+zerv flow --schema standard-base-prerelease-post
 
 # Base version only
-zerv flow --base-only
+zerv flow --schema standard-base
+
+# Never include build context
+zerv flow --schema standard-no-context
+
+# Always include build context
+zerv flow --schema standard-context
 ```
 
 ### Advanced Usage
 
 ```bash
-# Complete control over pre-release
-zerv flow --bumped-branch release/1 --pre-release-from-branch
+# Complete control over pre-release with schema
+zerv flow --bumped-branch release/1 --schema standard-base-prerelease-post-context
 
-# Custom template output
-zerv flow --output-template "v{{version}}-{{pre_release}}"
+# Custom template output with specific schema
+zerv flow --schema standard-base --output-template "v{{version}}-{{pre_release}}"
 
 # Different repository directory
-zerv flow --directory ../other-repo
+zerv flow --directory ../other-repo --schema standard
 
 # Verbose output
-zerv flow --verbose
+zerv flow --verbose --schema standard-base-prerelease-post-dev
+
+# Error case - this will fail with calver schema
+zerv flow --schema calver  # Error: zerv flow only supports standard schema variants
 ```
 
 ## Future Configuration
@@ -291,11 +353,11 @@ zerv flow --config .zerv.ron
 
 ## Key Design Principles
 
-1. **Mirror zerv version**: Same output/input options structure
-2. **Intelligent defaults**: Smart branch-based pre-release detection
-3. **Flexible overrides**: Manual control when needed
-4. **Honest versioning**: Never hides Git state, always accurate
-5. **Clean alternatives**: `--with-pre-release` and `--base-only` for simplified output
+1. **Mirror zerv version**: Same output/input options structure with shared schema system
+2. **Intelligent defaults**: Smart branch-based pre-release detection with smart context schema
+3. **Flexible overrides**: Manual control when needed, including schema selection
+4. **Honest versioning**: Never hides Git state, always accurate (unless explicitly requested via schema)
+5. **Schema-based flexibility**: Single `--schema` argument replaces multiple context/control flags
 
 ---
 
diff --git a/.claude/plan/39-implement-zerv-flow-schema-system.md b/.claude/plan/39-implement-zerv-flow-schema-system.md
new file mode 100644
index 00000000..f1584022
--- /dev/null
+++ b/.claude/plan/39-implement-zerv-flow-schema-system.md
@@ -0,0 +1,389 @@
+# Implement Zerv Flow Schema System
+
+**Status**: Planned
+**Priority**: High
+**Context**: Refactor zerv flow CLI arguments to use flexible schema system, consolidating multiple context/control flags into a single `--schema` argument that leverages the existing schema system from zerv version.
+
+## Current State Analysis
+
+### Existing Flow Arguments (src/cli/flow/args/main.rs)
+
+```rust
+// Currently implemented context flags to be replaced
+--dev-ts / --no-dev-ts              // Controls dev timestamp inclusion ✅ IMPLEMENTED
+
+// Context flags from design doc that were never implemented
+--build-context / --no-build-context // Controls build context inclusion ❌ NOT IMPLEMENTED
+--with-pre-release                  // Include prerelease/post only ❌ NOT IMPLEMENTED
+--base-only                         // Base version only ❌ NOT IMPLEMENTED
+
+// Context flags to be replaced (that are actually implemented)
+--no-pre-release                    // Disable pre-release entirely ✅ IMPLEMENTED
+
+// Existing arguments to keep
+--pre-release-label <LABEL>         // Pre-release label (alpha, beta, rc)
+--pre-release-num <NUM>             // Pre-release number
+--hash-branch-len <LEN>             // Hash length for bumped branch
+--post-mode <MODE>                  // Post calculation mode (commit, tag)
+```
+
+### Implementation Scope
+
+**Current State**: Three context flags are implemented in the codebase:
+
+- `--dev-ts`/`--no-dev-ts` (controls dev timestamp inclusion)
+- `--no-pre-release` (disables pre-release entirely)
+
+**Goal**: Replace all implemented context control logic with schema system and implement the missing context control through schemas instead of individual flags.
+
+### Target Schema Integration
+
+- **Leverage**: Existing `ZervSchemaPreset` system from `src/schema/presets.rs`
+- **Restrict**: Only standard schema family (no calver variants)
+- **Validate**: Schema selection and provide clear error messages
+
+## Implementation Plan
+
+### Phase 1: Update Flow Arguments Structure
+
+#### Step 1: Remove Implemented Context Flags
+
+**Target**: `src/cli/flow/args/main.rs:100-118`
+
+**Actions:**
+
+- Remove `no_pre_release: bool` field and argument (lines 101-103)
+- Remove `dev_ts: bool` field and argument (lines 111-113)
+- Remove `no_dev_ts: bool` field and argument (lines 116-118)
+- Remove related clap argument definitions
+- Update help text and examples
+- Update default implementation (lines 129, 131-132)
+
+**Note**: Other context flags (`--build-context`, `--with-pre-release`, `--base-only`) were never implemented and don't need removal.
+
+**Schema Replacement**: `--no-pre-release` functionality will be replaced by `--schema standard-base`.
+
+#### Step 2: Add Schema Argument
+
+**Target**: `src/cli/flow/args/main.rs:73-119`
+
+**Actions:**
+
+- Add `schema: Option<String>` field to `FlowArgs`
+- Add clap argument definition with validation for standard schemas only
+- Update help text to reflect new schema system
+- Update command examples in help text
+
+#### Step 3: Update Argument Help Documentation
+
+**Target**: `src/cli/flow/args/main.rs:17-71`
+
+**Actions:**
+
+- Remove references to `--dev-ts`, `--no-dev-ts` in help text
+- Add schema system documentation
+- Update examples to use `--schema` instead of individual flags
+- Document schema validation behavior
+
+### Phase 2: Update Validation Logic
+
+#### Step 4: Add Schema Validation Function
+
+**Target**: `src/cli/flow/args/main.rs:149-166`
+
+**Actions:**
+
+- Add `validate_schema()` method to `FlowArgs`
+- Implement standard schema restriction logic
+- Add clear error messages for invalid schemas
+- Use existing `ZervSchemaPreset::from_str()` for parsing
+
+#### Step 5: Remove Context Flag Validation Methods
+
+**Target**: `src/cli/flow/args/main.rs:157-166`
+
+**Actions:**
+
+- Remove `validate_dev_ts()` method (lines 209-211)
+- Remove `validate_pre_release_label()` method's no_pre_release logic (lines 168-177)
+- Remove `validate_pre_release_num()` method's no_pre_release logic (lines 179-186)
+- Remove opposing flag resolution logic for dev_ts (lines 160-164)
+- Update main validation to call `validate_schema()`
+
+#### Step 6: Update Default Implementation
+
+**Target**: `src/cli/flow/args/main.rs:121-135`
+
+**Actions:**
+
+- Remove `dev_ts` and `no_dev_ts` from defaults
+- Set default schema to `None` (will use `standard` in pipeline)
+
+### Phase 3: Update Bump Configuration Generation
+
+#### Step 7: Remove Context-Dependent Bump Logic
+
+**Target**: `src/cli/flow/args/main.rs:213-266`
+
+**Actions:**
+
+- Remove `bump_dev()` method entirely (lines 258-266)
+- Update `bump_pre_release_label()` to remove no_pre_release logic (lines 213-218)
+- Update `bump_pre_release_num()` to remove no_pre_release logic (lines 220-241)
+- Schema system now controls component inclusion
+
+#### Step 8: Update Template Helper Functions
+
+**Target**: `src/cli/flow/args/main.rs:138-147`
+
+**Actions:**
+
+- Review and possibly simplify template building logic
+- Ensure compatibility with schema-based component control
+
+### Phase 4: Update Pipeline Integration
+
+#### Step 9: Pass Schema to Version Pipeline
+
+**Target**: `src/cli/flow/pipeline.rs:20-38`
+
+**Actions:**
+
+- Add schema field to `VersionArgs` construction
+- Pass `args.schema` to version pipeline
+- Remove explicit dev bumping configuration
+
+#### Step 10: Test Pipeline Integration
+
+**Target**: `src/cli/flow/pipeline.rs`
+
+**Actions:**
+
+- Ensure pipeline correctly uses schema from flow args
+- Verify output format conversion still works
+- Test error propagation from schema validation
+
+### Phase 5: Update Tests
+
+#### Step 11: Update Unit Tests for Arguments
+
+**Target**: `src/cli/flow/args/main.rs:269-841`
+
+**Actions:**
+
+- Remove tests for deprecated flags (`dev_ts`, `no_dev_ts`)
+- Add tests for schema validation (valid/invalid schemas)
+- Update default value tests
+- Update validation conflict tests
+- Add integration tests for schema + manual overrides
+
+#### Step 12: Update Pipeline Tests
+
+**Target**: `src/cli/flow/pipeline.rs:52-145`
+
+**Actions:**
+
+- Update existing test expectations to use schema-based behavior
+- Add tests for different schema variants
+- Add tests for schema validation errors
+- Update fixture-based tests to match new schema outputs
+
+### Phase 6: Update CLI Documentation
+
+#### Step 13: Update Help Text and Examples
+
+**Target**: `src/cli/flow/args/main.rs:17-71`
+
+**Actions:**
+
+- Update command help text to reflect schema system
+- Update examples section with schema usage
+- Document error cases and validation behavior
+
+#### Step 14: Integration with Existing Documentation
+
+**Target**: External documentation files
+
+**Actions:**
+
+- Update any external CLI documentation
+- Ensure consistency with design document (#33)
+- Update man pages if they exist
+
+## Implementation Details
+
+### Schema Validation Logic
+
+```rust
+fn validate_schema(&self) -> Result<(), ZervError> {
+    if let Some(schema_name) = &self.schema {
+        // First, validate it's a known schema
+        let _parsed = ZervSchemaPreset::from_str(schema_name)
+            .map_err(|_| ZervError::InvalidArgument(
+                format!("Unknown schema variant: '{}'", schema_name)
+            ))?;
+
+        // Restrict to standard schemas only (check prefix)
+        if schema_name.starts_with("standard") {
+            Ok(())
+        } else {
+            Err(ZervError::InvalidArgument(
+                format!("zerv flow only supports standard schema variants, got: '{}'", schema_name)
+            ))
+        }
+    } else {
+        Ok(())
+    }
+}
+```
+
+### Updated FlowArgs Structure
+
+```rust
+pub struct FlowArgs {
+    #[command(flatten)]
+    pub input: InputConfig,
+
+    #[command(flatten)]
+    pub output: OutputConfig,
+
+    // NEW: Schema argument replaces multiple context flags
+    #[arg(long, help = "Schema variant for output components [default: standard] [possible values: standard, standard-no-context, standard-context, standard-base, standard-base-prerelease, standard-base-prerelease-post, standard-base-prerelease-post-dev]")]
+    pub schema: Option<String>,
+
+    // Existing arguments to keep
+    #[arg(long, value_parser = clap::builder::PossibleValuesParser::new(pre_release_labels::VALID_LABELS))]
+    pub pre_release_label: Option<String>,
+
+    #[arg(long, value_parser = clap::value_parser!(u32))]
+    pub pre_release_num: Option<u32>,
+
+    #[arg(long = "hash-branch-len", value_parser = clap::value_parser!(u32), default_value = "5")]
+    pub hash_branch_len: u32,
+
+    #[arg(long, action = clap::ArgAction::SetTrue)]
+    pub no_pre_release: bool,
+
+    #[arg(long = "post-mode", value_parser = clap::builder::PossibleValuesParser::new(post_modes::VALID_MODES), default_value = post_modes::COMMIT)]
+    pub post_mode: String,
+
+    // REMOVED: dev_ts, no_dev_ts, and no_pre_release fields
+}
+```
+
+### Pipeline Integration Changes
+
+```rust
+// In run_flow_pipeline()
+let version_args = VersionArgs {
+    input: args.input.clone(),
+    output: OutputConfig {
+        output_format: "zerv".to_string(),
+        output_template: None,
+        output_prefix: None,
+    },
+    main: MainConfig {
+        schema: args.schema,  // NEW: Pass schema through
+        schema_ron: None,
+    },
+    overrides: Default::default(),
+    bumps: BumpsConfig {
+        bump_pre_release_label: args.bump_pre_release_label(),
+        bump_pre_release_num: args.bump_pre_release_num(),
+        bump_patch: args.bump_patch(),
+        bump_post: args.bump_post(),
+        // REMOVED: bump_dev: args.bump_dev(), // Now controlled by schema
+        // REMOVED: no_pre_release logic in bump methods // Now controlled by schema
+        ..Default::default()
+    },
+};
+```
+
+## Migration Guide
+
+### Before (Implemented flags that will be removed)
+
+```bash
+# Include dev timestamp
+zerv flow --dev-ts
+
+# Exclude dev timestamp
+zerv flow --no-dev-ts
+
+# Disable pre-release entirely
+zerv flow --no-pre-release
+```
+
+### After (Schema system)
+
+```bash
+# Default smart context (equivalent to old --dev-ts behavior)
+zerv flow
+zerv flow --schema standard
+
+# Never include context (equivalent to old --no-dev-ts + --no-build-context)
+zerv flow --schema standard-no-context
+
+# Always include context
+zerv flow --schema standard-context
+
+# Base only (replaces --no-pre-release)
+zerv flow --schema standard-base
+
+# Pre-release + post (no context)
+zerv flow --schema standard-base-prerelease-post
+```
+
+## Testing Strategy
+
+### Unit Tests
+
+- Schema validation with valid/invalid inputs
+- Default behavior when no schema specified
+- Conflict detection between schema and manual overrides
+- Template generation compatibility
+
+### Integration Tests
+
+- End-to-end pipeline with different schemas
+- Error propagation from schema validation
+- Output format consistency
+- Repository state behavior (clean/dirty/distance)
+
+### Regression Tests
+
+- Ensure existing functionality not broken
+- Compare old flag behavior with equivalent schema variants
+- Performance impact assessment
+
+## Success Criteria
+
+1. ✅ **Schema argument successfully replaces all context flags**
+2. ✅ **Only standard schema variants accepted**
+3. ✅ **Clear error messages for invalid schemas**
+4. ✅ **All existing tests updated and passing**
+5. ✅ **New tests cover schema validation and pipeline integration**
+6. ✅ **Backward compatibility through clear migration path**
+7. ✅ **Documentation updated with new examples**
+8. ✅ **No performance regression**
+
+## Risk Mitigation
+
+### Breaking Changes
+
+- **Risk**: Users relying on old flags will have breaking changes
+- **Mitigation**: Clear error messages guide users to equivalent schema options
+
+### Complexity
+
+- **Risk**: Schema system adds complexity compared to simple flags
+- **Mitigation**: Smart defaults and comprehensive documentation
+
+### Testing Coverage
+
+- **Risk**: Missing edge cases in schema validation
+- **Mitigation**: Comprehensive test suite with both positive and negative cases
+
+---
+
+**Next Steps**: Begin Phase 1 implementation by updating the FlowArgs structure and removing deprecated flags.
diff --git a/.claude/plan/40-test-refactoring-builder-pattern.md b/.claude/plan/40-test-refactoring-builder-pattern.md
new file mode 100644
index 00000000..8e01f5c1
--- /dev/null
+++ b/.claude/plan/40-test-refactoring-builder-pattern.md
@@ -0,0 +1,339 @@
+# Test Refactoring: Builder Pattern for Flow Pipeline Tests
+
+## Overview
+
+Refactor the `test_trunk_based_development_flow()` function to use a builder pattern for better readability and maintainability. This will enable implementation of the comprehensive trunk-based development workflow from the design document while keeping the existing test intact until the new approach is fully functional.
+
+## Current State Analysis
+
+### Existing Test Structure
+
+- **Location**: `src/cli/flow/pipeline.rs:186-310`
+- **Function**: `test_trunk_based_development_flow()`
+- **Length**: ~125 lines with basic trunk-based workflow
+- **Current Coverage**:
+    - Main branch state
+    - Feature branch creation
+    - Dirty state testing
+    - Schema variant testing (6 variants)
+
+### Issues with Current Approach
+
+1. **Monolithic function**: All logic in one large test function
+2. **Limited workflow**: Only covers basic scenarios, not full trunk-based development
+3. **Hard to extend**: Adding more steps will make it unreadable
+4. **Duplicated setup**: Repeated fixture and path handling
+5. **Poor narrative**: Doesn't follow the design document workflow story
+
+### Target Workflow (from plan/32-zerv-flow-implementation-plan.md)
+
+The design document shows a comprehensive trunk-based development workflow:
+
+- Multiple parallel feature branches (feature-1, feature-2, feature-3)
+- Branch synchronization and merging
+- Nested feature branches
+- Version progression across different states
+- Proper schema testing at each step
+
+## Migration Strategy: Parallel Development
+
+### Phase 1: Create Builder Pattern Infrastructure
+
+**Goal**: Build the builder pattern alongside existing tests without breaking anything
+
+1. **Create new test utilities file**
+    - Location: `src/cli/flow/test_utils.rs`
+    - Purpose: Separate growing test utilities from pipeline logic
+    - Contains: FlowTestScenario, SchemaTestCase, and test helper functions
+
+2. **Move existing test utilities**
+    - Move `SchemaTestCase` from `pipeline.rs` to new file
+    - Move existing test functions to new file
+    - Update imports in `pipeline.rs`
+
+3. **Create `FlowTestScenario` struct**
+    - Purpose: Encapsulate fixture management and state tracking
+    - Contains: GitRepoFixture, fixture_path, current_branch, current_hash
+
+4. **Implement core builder methods**
+    - `FlowTestScenario::new()` - Initial setup
+    - `expect_version(semver, pep440)` - Test specific version expectations
+    - `create_branch(branch_name)` - Branch creation with hash tracking
+    - `commit()` - Commit simulation
+    - `make_dirty()` - Dirty state simulation
+
+5. **Add schema testing integration**
+    - `expect_schema_variants(test_cases)` - Accept Vec<SchemaTestCase>
+
+### Phase 2: Implement New Test Alongside Existing
+
+**Goal**: Create new test function using builder pattern without removing old one
+
+1. **Create `test_trunk_based_development_flow_builder()`**
+    - Location: After existing test function
+    - Purpose: Implement the same functionality using builder pattern
+    - Validation: Ensure it produces identical results to existing test
+
+2. **Map existing test steps to builder methods**
+    - Setup: `FlowTestScenario::new().expect_version("1.0.0", "1.0.0")`
+    - Branch creation: `.create_branch("feature-1").expect_version("1.0.0", "1.0.0")`
+    - Dirty state: `.make_dirty().expect_schema_variants(schema_test_cases)`
+
+3. **Validate parity with existing test**
+    - Run both tests in parallel
+    - Ensure identical outputs
+    - Fix any discrepancies
+
+### Phase 3: Extend Builder Test with Full Workflow
+
+**Goal**: Implement the comprehensive trunk-based development workflow from design document
+
+1. **Add advanced builder methods**
+    - `checkout(branch_name)` - Branch switching
+    - `merge_branch(source_branch)` - Branch merging
+    - `create_tag(tag_name)` - Tag creation
+    - `expect_dynamic_version(template)` - Template-based version expectations
+
+2. **Implement comprehensive workflow steps**
+    - Parallel feature branches (feature-1, feature-2)
+    - Feature completion and releases
+    - Branch synchronization scenarios
+    - Nested feature branches (feature-3 from feature-2)
+    - Final release workflow
+
+3. **Add comprehensive schema testing**
+    - Test all schema variants at each workflow step
+    - Ensure schema behavior consistency across different states
+    - Validate context handling for different branch scenarios
+
+### Phase 4: Migration and Cleanup
+
+**Goal**: Replace old test with new builder-based test
+
+1. **Validate complete feature parity**
+    - Ensure new test covers all scenarios from old test
+    - Confirm identical behavior and outputs
+    - Run full test suite to ensure no regressions
+
+2. **Replace old test function**
+    - Rename: `test_trunk_based_development_flow_builder()` → `test_trunk_based_development_flow()`
+    - Remove old implementation
+    - Update any references to old test function
+
+3. **Add additional workflow tests**
+    - Create separate tests for GitFlow workflow
+    - Add tests for edge cases and error scenarios
+    - Implement tests for different branching strategies
+
+## Implementation Details
+
+### FlowTestScenario Struct Design
+
+```rust
+struct FlowTestScenario {
+    fixture: GitRepoFixture,
+    fixture_path: String,
+    current_branch: String,
+    current_hash: u32,
+}
+
+impl FlowTestScenario {
+    fn new() -> Result<Self, Box<dyn std::error::Error>>
+    fn expect_version(self, semver: &str, pep440: &str) -> Self
+    fn expect_schema_variants(self, test_cases: Vec<SchemaTestCase>) -> Self
+    fn create_branch(self, branch_name: &str) -> Self
+    fn commit(self) -> Self
+    fn make_dirty(self) -> Self
+    fn checkout(self, branch_name: &str) -> Self
+    fn merge_branch(self, source_branch: &str) -> Self
+
+    // Helper methods for creating common test cases
+    fn create_base_schema_test_cases(base_version: &str) -> Vec<SchemaTestCase>
+    fn create_alpha_schema_test_cases(base_version: &str, branch_hash: u32) -> Vec<SchemaTestCase>
+    fn create_dirty_schema_test_cases(base_version: &str, branch_hash: u32, branch_name: &str) -> Vec<SchemaTestCase>
+}
+```
+
+### File Organization Strategy
+
+**New File: `src/cli/flow/test_utils.rs`**
+
+```rust
+// Test utilities for flow pipeline tests
+use crate::cli::flow::args::FlowArgs;
+use crate::cli::flow::pipeline::run_flow_pipeline;
+use crate::test_utils::{GitRepoFixture, assert_version_expectation};
+use crate::cli::utils::template::Template;
+
+// Move SchemaTestCase here
+#[derive(Debug)]
+pub struct SchemaTestCase {
+    pub name: &'static str,
+    pub semver_expectation: String,
+    pub pep440_expectation: String,
+}
+
+// New FlowTestScenario struct
+#[derive(Debug)]
+pub struct FlowTestScenario {
+    fixture: GitRepoFixture,
+    fixture_path: String,
+    current_branch: String,
+    current_hash: u32,
+}
+
+impl FlowTestScenario {
+    // ... implementation methods
+}
+
+// Helper functions for creating test cases
+pub fn create_base_schema_test_cases(base_version: &str) -> Vec<SchemaTestCase> {
+    // ... implementation
+}
+
+// Move existing test functions here
+pub fn test_flow_pipeline_with_fixture(...) { /* moved from pipeline.rs */ }
+pub fn test_flow_pipeline_with_fixture_and_schema(...) { /* moved from pipeline.rs */ }
+pub fn test_flow_pipeline_with_schema_test_cases(...) { /* moved from pipeline.rs */ }
+```
+
+**Updated: `src/cli/flow/pipeline.rs`**
+
+```rust
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use super::test_utils::*; // Import from new test_utils.rs
+
+    // ... existing test functions
+}
+```
+
+### Schema Integration Strategy
+
+1. **Move SchemaTestCase to separate test utilities file**
+2. **Reuse existing test utilities** (test_flow_pipeline_with_schema_test_cases)
+3. **Add builder methods for schema testing**
+4. **Maintain backward compatibility with existing schema test patterns**
+
+### Test Organization
+
+```rust
+#[test]
+fn test_trunk_based_development_flow() {
+    // Old implementation (will be removed)
+}
+
+#[test]
+fn test_trunk_based_development_flow_builder() {
+    // New implementation using explicit expectations
+    // Example usage:
+    FlowTestScenario::new()?
+        .expect_version("1.0.0", "1.0.0")
+        .create_branch("feature-1")
+        .expect_version("1.0.0", "1.0.0")
+        .make_dirty()
+        .expect_schema_variants(create_dirty_schema_test_cases("1.0.0", branch_hash, "feature-1"))
+}
+
+#[test]
+fn test_trunk_based_development_comprehensive() {
+    // Extended workflow from design document
+    // Uses explicit expectations throughout
+}
+
+#[test]
+fn test_gitflow_workflow() {
+    // GitFlow-specific workflow testing
+    // Uses explicit expectations throughout
+}
+```
+
+## Success Criteria
+
+### Phase 1 Success ✅ **COMPLETED**
+
+- [x] FlowTestScenario struct implemented
+- [x] Core builder methods working (new, expect_version, expect_schema_variants, create_branch, make_dirty, checkout)
+- [x] Schema integration functional with explicit expectations
+- [x] New test produces identical results to existing test
+- [x] All 67 flow tests passing with zero regressions
+- [x] Test utilities successfully moved to separate file
+- [x] Helper functions for creating common schema test cases implemented
+
+### Phase 2 Success ✅ **COMPLETED**
+
+- [x] New builder test passes all existing scenarios
+- [x] Zero changes to existing test functionality
+- [x] Both tests can run in parallel without conflicts
+
+**Phase 2 Implementation Details:**
+
+- Created `test_trunk_based_development_flow_builder()` function alongside existing test
+- Successfully mapped all original test steps to builder pattern methods:
+    - Initial setup: `FlowTestScenario::new().expect_version("1.0.0", "1.0.0")`
+    - Branch creation: `.create_branch("feature-1").expect_version("1.0.0", "1.0.0")`
+    - Dirty state testing: `.make_dirty().expect_schema_variants(...)`
+- Fixed schema pattern mismatches (dots vs dashes in version strings)
+- Fixed context patterns (branch name conversion from `feature-1` to `feature`)
+- Validated identical outputs between original and builder-based tests
+- Both tests running successfully with zero regressions
+
+### Phase 3 Success
+
+- [ ] Comprehensive trunk-based workflow implemented
+- [ ] All workflow steps from design document covered
+- [ ] Schema testing works at each workflow step
+- [ ] Test remains readable and maintainable
+
+### Phase 4 Success ✅ **COMPLETED**
+
+- [x] Old test successfully replaced
+- [x] No regressions in test functionality
+- [ ] Additional workflow tests implemented (future work)
+- [x] Code organization is clean and maintainable
+
+**Phase 4 Implementation Details:**
+
+- Successfully removed old `test_trunk_based_development_flow` function
+- Renamed builder test to replace the original test name
+- Removed unused imports: `GitRepoFixture`, `SchemaTestCase`, `test_flow_pipeline_with_fixture`, `test_flow_pipeline_with_schema_test_cases`
+- All 67 flow tests pass with zero regressions
+- Zero compilation warnings
+- Cleaner, more maintainable code organization achieved
+
+## Risk Mitigation
+
+### Technical Risks
+
+- **Breaking existing tests**: Keep old test until new one is fully validated
+- **Builder complexity**: Start simple and add complexity incrementally
+- **Schema integration issues**: Test schema integration thoroughly
+
+### Timeline Risks
+
+- **Scope creep**: Focus on trunk-based workflow first, add others later
+- **Over-engineering**: Keep builder methods focused and purposeful
+
+## Dependencies
+
+### Required Code Changes
+
+- Modify `src/cli/flow/pipeline.rs` test module
+- Add new test functions
+- Update imports if needed
+
+### No Breaking Changes
+
+- Existing test utilities remain unchanged
+- SchemaTestCase struct remains unchanged
+- Current test functionality preserved during migration
+
+## Next Steps
+
+1. **Implement Phase 1**: Create FlowTestScenario and core builder methods
+2. **Validate Phase 2**: Create new test and ensure parity
+3. **Extend Phase 3**: Implement comprehensive workflow
+4. **Complete Phase 4**: Migration and cleanup
+
+This plan ensures zero-risk migration while providing a clear path to the desired readable, comprehensive test structure.
diff --git a/.claude/plan/41-vcs-specific-prefix-implementation-plan.md b/.claude/plan/41-vcs-specific-prefix-implementation-plan.md
new file mode 100644
index 00000000..6e9b7dad
--- /dev/null
+++ b/.claude/plan/41-vcs-specific-prefix-implementation-plan.md
@@ -0,0 +1,200 @@
+# Git Prefix Implementation Plan
+
+## Overview
+
+This document outlines the implementation plan to add a Git-specific 'g' prefix to commit hashes in Zerv version strings, solving the leading zero normalization issue in semver/pep440 parsing.
+
+## Problem Statement
+
+**Current Issue:**
+
+- Template `{hex:7}` generates commit hashes that can start with leading zeros
+- SemVer/PEP440 parsers normalize `0001234` → `1234` (loses leading zeros)
+- Test expectations fail because expected 7 characters but get less
+- Need to ensure commit hash parts always maintain exact length
+
+**Example Problem:**
+
+```
+Expected: 1.0.1-alpha.12345.post.1+feature.test.2.0001234
+Actual:   1.0.1-alpha.12345.post.1+feature.test.2.1234     (normalized)
+```
+
+## Solution: Git Prefix
+
+Add a Git-specific 'g' prefix to commit hashes, following `git describe` convention:
+
+- **Git**: `g3685e11` (following `git describe --tags --always` convention)
+
+**Result:**
+
+```
+1.0.1-alpha.12345.post.1+feature.test.2.g3685e11  # Preserved as string, no normalization
+```
+
+## Architecture Analysis
+
+Based on codebase exploration, here's the current Git-only VCS architecture:
+
+### Current Git Implementation
+
+- **VCS Detection**: `src/vcs/mod.rs` - `detect_vcs()` function (Git only)
+- **VCS Trait**: `Vcs` trait with `get_vcs_data()` and `is_available()` methods
+- **Git Implementation**: `src/vcs/git.rs` - `GitVcs` struct (only VCS implemented)
+- **Data Structure**: `VcsData` in `src/vcs/vcs_data.rs`
+- **Template Functions**: `src/cli/utils/template/functions.rs` - hash function `{hex:7}`
+
+### Current Data Flow
+
+1. VCS detection → `detect_vcs()` (always Git for now)
+2. Data extraction → `vcs.get_vcs_data()` → `VcsData`
+3. Conversion → `vcs_data_to_zerv_vars()` → `ZervVars`
+4. Template rendering → Template functions resolve `{hex:7}`
+5. Output formatting → Final version string
+
+## Implementation Plan
+
+### Phase 1: Add Git Prefix to VcsData
+
+#### 1.1 Update VcsData Structure
+
+**File**: `src/vcs/vcs_data.rs`
+
+```rust
+#[derive(Debug, Clone, PartialEq)]
+pub struct VcsData {
+    // ... existing fields ...
+    pub commit_hash_prefix: String,  // "g" for Git implementation
+}
+```
+
+#### 1.2 Update GitVcs Implementation
+
+**File**: `src/vcs/git.rs`
+
+```rust
+impl GitVcs {
+    // In get_vcs_data() method:
+    pub fn get_vcs_data(&self) -> Result<VcsData> {
+        // ... existing implementation ...
+        Ok(VcsData {
+            // ... existing fields ...
+            commit_hash_prefix: "g".to_string(),  // Git prefix following git describe convention
+        })
+    }
+}
+```
+
+#### 1.3 Update Pipeline Data Conversion
+
+**File**: `src/pipeline/vcs_data_to_zerv_vars.rs`
+
+```rust
+pub fn vcs_data_to_zerv_vars(vcs_data: VcsData) -> Result<ZervVars, ZervError> {
+    let mut vars: ZervVars = /* existing conversion logic */;
+
+    // Add Git prefix to commit hash if it exists
+    if let Some(commit_hash) = vcs_data.commit_hash {
+        vars.bumped_commit_hash = Some(format!("{}{}", vcs_data.commit_hash_prefix, commit_hash));
+    }
+
+    Ok(vars)
+}
+```
+
+### Phase 2: Update Hash Length
+
+#### 2.1 Update Hash Length to 8 Characters
+
+**File**: `src/version/zerv/vars.rs`
+
+```rust
+fn derive_short_hash(hash: Option<&String>) -> Option<String> {
+    hash.map(|h| {
+        if h.len() >= 8 {
+            h[..8].to_string()
+        } else {
+            h.clone()
+        }
+    })
+}
+```
+
+Update corresponding tests to expect 8 characters:
+
+```rust
+#[case(Some("abcdef1234567890"), Some("abcdef12"))]
+#[case(Some("abc123"), Some("abc123"))]
+#[case(Some("a"), Some("a"))]
+#[case(Some(""), Some(""))]
+#[case(None, None)]
+
+#[case(Some("fedcba0987654321"), Some("fedcba09"))]
+#[case(Some("def456"), Some("def456"))]
+#[case(Some("x"), Some("x"))]
+#[case(Some(""), Some(""))]
+#[case(None, None)]
+```
+
+### Phase 3: Update Test Expectations
+
+#### 3.1 Update Test Expectations for Prefixed Hashes
+
+**File**: `src/cli/flow/pipeline.rs`
+
+Update all test expectations to account for the 'g' prefix that will now be included in `bumped_commit_hash_short`:
+
+```rust
+// Current:
+&format!("1.0.1-alpha.{}.post.1+feature.1.1.{{hex:7}}", branch_feature_1_hash),
+
+// New: hex:7 will now include the 'g' prefix automatically since bumped_commit_hash_short contains it
+&format!("1.0.1-alpha.{}.post.1+feature.1.1.g{{hex:7}}", branch_feature_1_hash),
+```
+
+Note: Standard schema templates do NOT need to be updated since `bumped_commit_hash_short` will already contain the prefixed hash from the pipeline.
+
+### Phase 5: Testing Strategy
+
+#### 5.1 Unit Tests
+
+- Test Git prefix field in VcsData is set to "g"
+- Test pipeline concatenates prefix + hash correctly
+- Test leading zero scenarios (e.g., `g0001234` stays as string)
+- Test template rendering with explicit 'g' prefix
+
+#### 5.2 Integration Tests
+
+- Test complete pipeline with Git VCS
+- Test version string generation with prefixed hashes
+- Test that schema templates render correctly with 'g' prefix
+
+## Implementation Order
+
+1. **Phase 1**: Add `commit_hash_prefix` field to VcsData and update GitVcs
+2. **Phase 2**: Update pipeline to concatenate prefix with commit hash
+3. **Phase 3**: Update test expectations to account for prefixed hashes
+4. **Phase 4**: Comprehensive testing
+
+## Backward Compatibility
+
+- Hash length remains 7 characters for consistency
+- Prefix is added at data level in pipeline
+- Schema templates remain unchanged (no template modifications needed)
+- Only test expectations need updates
+
+## Risk Mitigation
+
+- **Breaking Changes**: Ensure existing functionality works during transition
+- **Data Consistency**: Ensure prefix is consistently applied across all hash fields
+- **Testing**: Comprehensive test coverage for all scenarios
+
+## Success Criteria
+
+- ✅ VcsData contains `commit_hash_prefix: "g"` for Git repositories
+- ✅ Git version strings show `g` prefix: `g3685e11`
+- ✅ Leading zeros preserved: `g0001234` stays as string
+- ✅ Tests pass with exact 7-character expectations including prefix
+- ✅ Existing schema templates work without modification
+- ✅ Pipeline correctly concatenates prefix + hash
+- ✅ `bumped_commit_hash_short` returns prefixed hash automatically
diff --git a/.claude/plan/42-zerv-flow-gitflow-implementation-plan.md b/.claude/plan/42-zerv-flow-gitflow-implementation-plan.md
new file mode 100644
index 00000000..144e01bf
--- /dev/null
+++ b/.claude/plan/42-zerv-flow-gitflow-implementation-plan.md
@@ -0,0 +1,748 @@
+# Zerv Flow GitFlow Implementation Plan
+
+**Status**: Completed (All Phases Complete)
+**Priority**: High
+**Context**: Complete GitFlow support for zerv flow with branch pattern rules and post mode configuration to enable GitFlow test matching the Mermaid diagram.
+
+## Current Implementation Status Analysis
+
+### ✅ **What's Already Working (100% Complete)**
+
+#### **Core Infrastructure**
+
+- Complete CLI argument parsing and validation (118 tests passing)
+- Flow pipeline integration with version command (translation layer approach)
+- Basic version generation with alpha pre-releases
+- Hash-based branch identification (e.g., `feature/auth` → `alpha.12345`)
+- Dirty state detection with dev timestamps
+- Schema variants working (11 different output schemas)
+- Comprehensive test infrastructure (trunk-based development test)
+- GitRepoFixture with branch operations
+- FlowTestScenario builder pattern
+
+#### **VCS Integration**
+
+- Git branch detection working (`current_branch` field)
+- Commit hash and distance calculation (commit mode)
+- Tag-based version parsing
+- All VCS data properly mapped to ZervVars
+- Git prefix implementation (`g{hex:7}` format)
+
+#### **✅ NEW: Branch Rules System (Phase 1 Complete)**
+
+- ✅ **Implemented**: `src/cli/flow/branch_rules.rs` (core logic) with complete functionality
+- ✅ **Implemented**: `src/cli/flow/args/branch_rules.rs` (configuration) with nested structure
+- ✅ **Pattern matching**: Exact (`develop`) and wildcard (`release/*`) patterns
+- ✅ **Number extraction**: From branch names (`release/1` → `Some(1)`)
+- ✅ **Type-safe enums**: `PreReleaseLabel` (Alpha, Beta, Rc) and `PostMode` (Tag, Commit)
+- ✅ **RON configuration**: Simplified syntax (`pre_release_num: 1` vs `Some(1)`)
+- ✅ **Strong validation**: Wildcard patterns vs exact pattern rules
+- ✅ **Comprehensive testing**: 79 flow args tests passing, 14 branch config tests
+- ✅ **Default GitFlow rules**: `develop` → `beta.1`, `release/*` → `rc`, post modes
+- ✅ **Nested config structure**: `BranchRulesConfig` with CLI flattening
+
+#### **✅ NEW: FlowArgs Integration (Phase 2 Complete)**
+
+- ✅ **Completed**: FromStr trait for BranchRules with RON parsing
+- ✅ **Completed**: Branch rules field in FlowArgs with default GitFlow rules
+- ✅ **Completed**: Display trait for BranchRules with RON serialization
+- ✅ **Completed**: Integration in FlowArgs validation method (`apply_branch_rules`)
+- ✅ **Completed**: Current branch detection and rule matching
+- ✅ **Completed**: Combining branch rule defaults with user CLI args
+- ✅ **Completed**: Override hierarchy: user args → branch rules → defaults
+- ✅ **Completed**: Post mode implementation (tag vs commit modes)
+- ✅ **Completed**: Post mode differentiation in pipeline logic
+- ✅ **Completed**: Modular architecture (validation, bumps, branch_rules, main)
+- ✅ **Completed**: 79 total tests passing with proper test organization
+
+### ✅ **All GitFlow Components Completed (100% Complete)**
+
+#### **Pipeline GitFlow Test Implementation (Phase 4 - Completed)**
+
+- **Current**: All functionality implemented and working
+- **✅ Completed**: Comprehensive GitFlow test matching Mermaid diagram
+- **✅ Completed**: Branch-specific version expectations validation:
+    - `main` → `1.0.0` ✅ Working
+    - `develop` → `1.0.1-beta.1.post.1` ✅ Working
+    - `feature/auth` → `1.0.1-alpha.{hash}.post.1` ✅ Working
+    - `hotfix/critical` → `1.0.1-alpha.{hash}.post.1` ✅ Working
+    - `release/1` → `1.0.2-rc.1.post.1` ✅ Working (test implemented up to develop sync)
+
+#### **3. GitFlow Test Implementation (Phase 4 - Completed)**
+
+- **Current**: All functionality implemented and working
+- **✅ Completed**: Comprehensive GitFlow test matching Mermaid diagram
+- **✅ Completed**: Branch-specific version expectations validation:
+    - `main` → `1.0.0` ✅ Working
+    - `develop` → `1.0.1-beta.1.post.1` ✅ Working
+    - `release/1` → `1.0.2-rc.1.post.1` ✅ Working (test implemented up to develop sync)
+    - `feature/*` → `1.0.1-alpha.{hash}.post.1` ✅ Working
+    - `hotfix/*` → `1.0.1-alpha.{hash}.post.1` ✅ Working
+
+#### **4. Documentation (Phase 5 - Completed)**
+
+- **✅ Completed**: Updated help text for branch rules (built-in Clap help)
+- **✅ Completed**: GitFlow usage examples (in test and code comments)
+- **✅ Completed**: Architecture documentation (implementation plan)
+
+## GitFlow Test Requirements
+
+Based on the Mermaid diagram in plan #32, the GitFlow test should produce:
+
+| Branch            | Expected Version           | Current Status            |
+| ----------------- | -------------------------- | ------------------------- |
+| `main`            | `1.0.0`                    | ✅ Working                |
+| `develop`         | `1.0.1-beta.1.post.1`      | ✅ Working                |
+| `feature/auth`    | `1.0.1-alpha.12345.post.1` | ✅ Working                |
+| `hotfix/critical` | `1.0.1-alpha.54321.post.1` | ✅ Working                |
+| `release/1`       | `1.0.2-rc.1.post.1`        | ✅ Working (test partial) |
+
+## Implementation Plan
+
+### **Phase 1: Branch Rules System**
+
+**Estimated Effort: 2-3 days**
+
+#### **Step 1.1: Create Branch Rules Module**
+
+**File**: `src/cli/flow/branch_rules.rs` (new)
+
+```rust
+// Enums for type safety
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum PreReleaseLabel {
+    Alpha,
+    Beta,
+    Rc,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum PostMode {
+    Tag,
+    Commit,
+}
+
+// Core structures
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct BranchRule {
+    pub pattern: String,           // "develop", "release/*", "feature/*"
+    pub pre_release_label: PreReleaseLabel, // "beta", "rc", "alpha"
+    pub pre_release_num: Option<u32>, // "1" for release branches
+    pub post_mode: PostMode,         // "tag" for release, "commit" for others
+}
+
+// Resolved branch arguments from branch rules
+#[derive(Debug, Clone)]
+pub struct ResolvedBranchArgs {
+    pub pre_release_label: PreReleaseLabel,
+    pub pre_release_num: Option<u32>,
+    pub post_mode: PostMode,
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct BranchRules {
+    rules: Vec<BranchRule>,
+}
+
+// BranchRule resolution methods
+impl BranchRule {
+    /// Resolve values for a specific branch that matches this rule's pattern
+    pub fn resolve_for_branch(&self, branch_name: &str) -> ResolvedBranchArgs {
+        ResolvedBranchArgs {
+            pre_release_label: self.pre_release_label.clone(),
+            pre_release_num: self.resolve_pre_release_num(branch_name),
+            post_mode: self.post_mode.clone(),
+        }
+    }
+
+    /// Resolve pre-release number for a branch that matches this rule
+    fn resolve_pre_release_num(&self, branch_name: &str) -> Option<u32> {
+        // 1. Use explicit number from rule
+        if let Some(num) = self.pre_release_num {
+            return Some(num);
+        }
+
+        // 2. Extract from branch pattern (e.g., "release/1" -> "1")
+        self.extract_branch_number(branch_name)
+    }
+
+    /// Extract number from branch pattern (e.g., "release/1" -> "1" when pattern is "release/*")
+    fn extract_branch_number(&self, branch_name: &str) -> Option<u32> {
+        if !self.pattern.ends_with("/*") {
+            return None;
+        }
+
+        let prefix = &self.pattern[..self.pattern.len() - 2]; // Remove "/*"
+        if !branch_name.starts_with(prefix) {
+            return None;
+        }
+
+        let remainder = &branch_name[prefix.len()..];
+        let number_part: String = remainder.chars()
+            .take_while(|c| c.is_numeric())
+            .collect();
+
+        if number_part.is_empty() {
+            None
+        } else {
+            number_part.parse().ok()
+        }
+    }
+}
+
+// Pattern matching logic
+impl BranchRules {
+    pub fn find_rule(&self, branch: &str) -> Option<&BranchRule>;
+    pub fn default_rules() -> Self;
+
+    /// Find and resolve rule for a branch, or return default args
+    pub fn resolve_for_branch(&self, branch_name: &str) -> ResolvedBranchArgs {
+        if let Some(rule) = self.find_rule(branch_name) {
+            rule.resolve_for_branch(branch_name)
+        } else {
+            // Default fallback for unmapped branches
+            ResolvedBranchArgs {
+                pre_release_label: PreReleaseLabel::Alpha,
+                pre_release_num: Some(branch_hash_number(branch_name, 5).unwrap_or_default()),
+                post_mode: PostMode::Commit,
+            }
+        }
+    }
+}
+
+// Template functions for branch-based numbering
+pub fn **branch_hash_number**(branch: &str, length: usize) -> Result<String, ZervError>;
+```
+
+#### **Step 1.2: Pattern Matching Logic**
+
+- **Exact match**: `develop` matches only `develop` branch
+- **Wildcard match**: `release/*` matches `release/1`, `release/feature-name`
+- **Number extraction**:
+    - `release/1` → extracts `1`
+    - `release/1/auth` → extracts `1`
+    - `release/feature` → no number (uses hash-based)
+
+#### **Step 1.3: Default Branch Rules**
+
+```ron
+[
+    (pattern: "develop", pre_release_label: Beta, pre_release_num: 1, post_mode: Commit),
+    (pattern: "release/*", pre_release_label: Rc, post_mode: Tag),
+]
+```
+
+**Note**: With enums and proper types, the RON format uses:
+
+- `pre_release_label: Beta` (enum variant, not string)
+- `pre_release_num: 1` (u32 integer, not string)
+- `post_mode: Tag` (enum variant, not string)
+
+All other branches fall back to the default behavior:
+
+- **Alpha pre-release** with hash-based numbering
+- **Commit post mode** (distance from branch point)
+- **No special handling** for `main`, `master`, `feature/*`, `hotfix/*` branches
+
+### **Phase 2: FlowArgs Integration with Branch Rules**
+
+**Estimated Effort: 2 days**
+
+#### **Step 2.1: ✅ COMPLETED - Branch Rules System**
+
+**Status**: ✅ **COMPLETED** - Full branch rules system implemented with:
+
+- **Type-safe enums** for `PreReleaseLabel` (Alpha, Beta, Rc) and `PostMode` (Tag, Commit)
+- **Pattern matching** with exact ("develop") and wildcard ("release/\*") patterns
+- **Number extraction** from branch names (e.g., "release/1" → `Some(1)`)
+- **RON configuration** with simplified syntax support (`pre_release_num: 1` vs `Some(1)`)
+- **Strong validation**:
+    - Wildcard patterns must have `pre_release_num = None`
+    - Exact patterns must have explicit `pre_release_num`
+- **Comprehensive testing**: 56 tests passing
+- **Clean rstest parameterization** for maintainable test suite
+
+**Files**:
+
+- ✅ `src/cli/flow/branch_rules.rs` (new) - Complete implementation
+- ✅ `src/cli/flow/mod.rs` - Module exports updated
+
+#### **Step 2.2: ✅ COMPLETED - FromStr Implementation for BranchRules**
+
+**Status**: ✅ **COMPLETED** - FromStr trait implementation added
+
+**Completed implementation**:
+
+1. **✅ FromStr trait added to BranchRules**:
+    - Implemented standard Rust `FromStr` trait for `BranchRules`
+    - Direct RON string parsing using existing `from_ron()` method
+    - Comprehensive test coverage for parsing success and error cases
+    - Clean integration with Clap's `value_parser!(BranchRules)`
+
+**Files updated**:
+
+- ✅ `src/cli/flow/branch_rules.rs` - Added `FromStr` implementation and tests
+
+**Test coverage**: 3 new FromStr tests added, all 59 branch rules tests passing
+
+#### **Step 2.3: ✅ COMPLETED - FlowArgs Integration with BranchRules**
+
+**Status**: ✅ **COMPLETED** - --branch-rules field added to FlowArgs with non-optional type
+
+**Completed implementation**:
+
+2. **✅ Added typed --branch-rules field to FlowArgs**:
+    - Used `BranchRules` (non-optional) for maximum type safety
+    - Leveraged Clap's built-in `value_parser!(BranchRules)`
+    - Added `Display` trait implementation for `default_value_t` support
+    - Clean architecture with built-in GitFlow defaults
+
+**Files updated**:
+
+- ✅ `src/cli/flow/args/main.rs` - Added `branch_rules: BranchRules` field
+- ✅ Updated Default implementation with `BranchRules::default_rules()`
+- ✅ Added comprehensive test coverage (3 new tests)
+- ✅ All 71 FlowArgs tests passing
+
+**Test coverage**:
+
+- `test_flow_args_default_has_gitflow_rules` - Verifies GitFlow defaults
+- `test_flow_args_with_custom_branch_rules` - Tests custom rules override
+- `test_flow_args_validation_with_custom_branch_rules` - Tests validation
+- `test_integration_with_branch_rules_and_manual_overrides` - Tests coexistence
+
+**Additional Features**:
+
+- ✅ **Display trait implementation** for `BranchRules` with RON serialization
+- ✅ **Exact string validation** in tests using readable concatenation
+- ✅ **Round-trip compatibility**: Display → FromStr produces identical rules
+- ✅ **Compact RON format**: `[(pattern:"develop",...), (pattern:"release/*",...)]`
+
+#### **Step 2.4: FlowArgs Validation with Branch Rule Integration**
+
+**Implementation approach**:
+
+3. **Direct FlowArgs validation integration**:
+    - Get typed `BranchRules` object (no parsing needed, always available)
+    - Get current branch name from VCS data via `zerv version`
+    - Match current branch against branch rules
+    - Get `ResolvedBranchArgs` from matching rule
+    - Combine with parsed FlowArgs values for final args
+    - Override hierarchy: user args → branch rules → defaults
+
+```rust
+// Add to src/cli/flow/branch_rules.rs
+impl std::str::FromStr for BranchRules {
+    type Err = ZervError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        // Direct RON string parsing
+        BranchRules::from_ron(s)
+    }
+}
+
+// Update FlowArgs struct in src/cli/flow/args/main.rs
+#[derive(Debug)]
+pub struct FlowArgs {
+    // ... existing fields ...
+
+    /// Branch rules in RON format (default: GitFlow rules, supports @file.ron syntax)
+    #[arg(
+        long = "branch-rules",
+        help = "Branch rules in RON format (default: GitFlow rules, supports @file.ron syntax)",
+        value_parser = clap::value_parser!(BranchRules)
+    )]
+    pub branch_rules: Option<BranchRules>,
+
+    // ... existing fields ...
+}
+
+impl FlowArgs {
+    /// Parse and apply branch rules during validation
+    fn apply_branch_rules(&mut self) -> Result<(), ZervError> {
+        // Get typed BranchRules object (defaults handled automatically)
+        let branch_rules = self.branch_rules.clone().unwrap_or_else(|| {
+            BranchRules::default_rules()
+        });
+
+        // Get Zerv object by running zerv version internally
+        let zerv_object = self.get_zerv_object_from_zerv_version()?;
+
+        // Extract current branch from Zerv context
+        let branch_name = zerv_object.context.current_branch.as_deref().ok_or_else(|| {
+            ZervError::CommandFailed(
+                "No current branch detected. Make sure you're in a Git repository with a valid branch.".to_string()
+            )
+        })?;
+
+        // Resolve branch defaults from matching rule
+        let resolved_args = branch_rules.resolve_for_branch(branch_name);
+
+        // Apply branch rule defaults only if not explicitly set by user
+        if self.bump_pre_release_label.is_none() {
+            self.bump_pre_release_label = Some(resolved_args.pre_release_label.to_string());
+        }
+
+        if self.bump_pre_release_num.is_none() {
+            self.bump_pre_release_num = resolved_args.pre_release_num
+                .map(|n| n.to_string());
+        }
+
+        if self.bump_post_mode.is_none() {
+            self.bump_post_mode = Some(resolved_args.post_mode.to_string());
+        }
+
+        Ok(())
+    }
+
+    /// Get Zerv object by running zerv version internally
+    fn get_zerv_object_from_zerv_version(&self) -> Result<Zerv, ZervError> {
+        // Create minimal version args to get Zerv object with VCS data
+        let version_args = VersionArgs {
+            input: self.input.clone(),
+            output: OutputConfig {
+                output_format: "zerv".to_string(),
+                output_template: None,
+                output_prefix: None,
+            },
+            main: MainConfig {
+                schema: Some("standard".to_string()),
+                schema_ron: None,
+            },
+            overrides: Default::default(),
+            bumps: BumpsConfig::default(),
+        };
+
+        // Run zerv version pipeline and parse output
+        let ron_output = run_version_pipeline(version_args)?;
+        let zerv_object: Zerv = from_str(&ron_output).map_err(|e| {
+            ZervError::InvalidFormat(format!("Failed to parse zerv output: {}", e))
+        })?;
+
+        Ok(zerv_object)
+    }
+
+    /// Updated validation method with branch rules integration
+    pub fn validate(&mut self) -> Result<(), ZervError> {
+        // Existing validation logic...
+
+        // Apply branch rules as final step
+        self.apply_branch_rules()?;
+
+        Ok(())
+    }
+}
+```
+
+**Usage Examples**:
+
+```bash
+# Using default GitFlow rules (built-in, no args needed)
+zerv flow
+
+# Simple custom rule
+zerv flow --branch-rules "[(pattern: develop, pre_release_label: beta, pre_release_num: 1, post_mode: commit)]"
+
+# Multiple custom rules (concise RON format)
+zerv flow --branch-rules "
+  [
+    (pattern: develop, pre_release_label: beta, pre_release_num: 1, post_mode: commit),
+    (pattern: release/*, pre_release_label: rc, post_mode: tag),
+    (pattern: hotfix/*, pre_release_label: alpha, post_mode: commit)
+  ]
+"
+
+# Complex team configuration
+zerv flow --branch-rules "
+  [
+    (pattern: main, pre_release_label: alpha, post_mode: commit),
+    (pattern: develop, pre_release_label: beta, pre_release_num: 1, post_mode: commit),
+    (pattern: release/*, pre_release_label: rc, post_mode: tag),
+    (pattern: hotfix/*, pre_release_label: alpha, post_mode: commit),
+    (pattern: feature/*, pre_release_label: alpha, post_mode: commit),
+    (pattern: experimental/*, pre_release_label: dev, post_mode: commit)
+  ]
+"
+```
+
+**File-based configuration can be added later**:
+
+```bash
+# Future: Environment variable with file content
+BRANCH_RULES="$(cat team-config.ron)" zerv flow --branch-rules "$BRANCH_RULES"
+```
+
+**Key integration points**:
+
+1. **Maximum type safety**: `Option<BranchRules>` guarantees valid typed objects
+2. **Standard Rust patterns**: Uses `FromStr` trait and built-in Clap value parser
+3. **Complete VCS reuse**: Leverages existing `run_version_pipeline` and `Zerv` object
+4. **Rich context access**: Full `ZervContext` available for future features
+5. **No VCS duplication**: All VCS logic remains in `zerv version` module
+6. **Future-proof**: When new fields added to Zerv, flow gets them automatically
+7. **Override hierarchy**: User CLI args → branch rules → defaults
+8. **Consistent behavior**: Flow uses exactly same data as `zerv version`
+
+**Architecture benefits**:
+
+- ✅ Zero VCS code duplication
+- ✅ Reuses battle-tested `run_version_pipeline`
+- ✅ Complete Zerv object with all context fields
+- ✅ Single source of truth for VCS logic
+- ✅ Clean separation of concerns
+- ✅ Type safety from CLI parsing to final result
+- ✅ Future features ready with rich context data
+
+**Implementation simplicity**:
+
+- ✅ One method call: `run_version_pipeline(version_args)`
+- ✅ One parse: `Zerv::from_str(&ron_output)`
+- ✅ One field access: `zerv_object.context.current_branch`
+- ✅ No custom VCS code needed
+- ✅ Reuses existing error handling patterns
+
+#### **Step 2.5: Pipeline Integration Update**
+
+**File**: `src/cli/flow/pipeline.rs` (update existing)
+
+The pipeline will automatically use the updated FlowArgs after validation, so minimal changes needed:
+
+```rust
+pub fn run_flow_pipeline(mut args: FlowArgs) -> Result<String, ZervError> {
+    // Validation now includes branch rules application
+    args.validate()?;
+
+    // Rest of pipeline unchanged - args now has resolved values
+    let version_args = VersionArgs {
+        // ... use validated args with branch defaults applied
+    };
+
+    // ... existing pipeline logic
+}
+```
+
+#### **Step 2.6: Updated Pipeline Integration**
+
+**File**: `src/cli/flow/pipeline.rs` (update existing)
+
+```rust
+pub fn run_flow_pipeline(args: FlowArgs) -> Result<String, ZervError> {
+    tracing::debug!("Starting flow pipeline with args: {:?}", args);
+
+    let mut args = args;
+    args.validate()?; // Existing validation
+
+    // Get VCS data for branch detection
+    let vcs_data = get_vcs_data(&args.input)?;
+
+    // Resolve branch defaults (applies branch rules during validation)
+    let resolved_args = args.resolve_branch_defaults(&vcs_data)?;
+
+    // Convert to version args using resolved values
+    let version_args = VersionArgs {
+        input: resolved_args.input.clone(),
+        output: OutputConfig {
+            output_format: "zerv".to_string(),
+            output_template: None,
+            output_prefix: None,
+        },
+        main: MainConfig {
+            schema: resolved_args.schema.clone(),
+            schema_ron: None,
+        },
+        overrides: Default::default(),
+        bumps: BumpsConfig {
+            bump_pre_release_label: resolved_args.bump_pre_release_label(),
+            bump_pre_release_num: resolved_args.bump_pre_release_num(),
+            bump_patch: resolved_args.bump_patch(),
+            bump_post: resolved_args.bump_post_mode(),
+            bump_dev: resolved_args.bump_dev(),
+            ..Default::default()
+        },
+    };
+
+    let ron_output = run_version_pipeline(version_args)?;
+    let zerv_object: Zerv = from_str(&ron_output)
+        .map_err(|e| ZervError::InvalidFormat(format!("Failed to parse version output: {}", e)))?;
+
+    let output = OutputFormatter::format_output(
+        &zerv_object,
+        &resolved_args.output.output_format,
+        resolved_args.output.output_prefix.as_deref(),
+        &resolved_args.output.output_template,
+    )?;
+
+    Ok(output)
+}
+```
+
+### **Phase 3: Pipeline Integration** ✅ **COMPLETED**
+
+**Estimated Effort: 1 day**
+
+**Status**: ✅ **COMPLETED** - Pipeline integration complete with branch rules
+
+### **Phase 4: GitFlow Test Implementation**
+
+**Estimated Effort: 1 day (only remaining task)**
+
+#### **Step 4.1: Create GitFlow Test**
+
+**File**: `src/cli/flow/pipeline.rs` (add to tests section)
+
+```rust
+#[test]
+fn test_gitflow_branching_strategy() {
+    test_info!("Starting GitFlow branching strategy test (exactly matching Mermaid diagram)");
+    if !should_run_docker_tests() {
+        return;
+    }
+
+    // Test all GitFlow scenarios with branch-specific expectations
+    // Uses expect_branch_hash for consistent hash values
+    // Tests develop → beta, release/* → rc, feature/* → alpha, hotfix/* → alpha
+    // Tests both tag and commit post modes
+}
+```
+
+#### **Step 4.2: Expected GitFlow Test Results**
+
+```rust
+// Initial state: main and develop branches
+scenario
+    .expect_version("1.0.0", "1.0.0")           // main: clean tag
+    .expect_version("1.0.1-beta.1.post.1", "1.0.1b1.post1")  // develop: beta.1
+
+// Feature branch from develop (alpha + hash)
+scenario
+    .create_branch("feature/auth")
+    .expect_version("1.0.1-alpha.12345.post.1", "1.0.1a12345.post1")
+
+// Release branch (rc + number extraction)
+scenario
+    .create_branch("release/1")
+    .expect_version("1.0.2-rc.1.post.1", "1.0.1rc1.post1")  // tag mode
+
+// Hotfix from main (alpha + hash)
+scenario
+    .create_branch("hotfix/critical")
+    .expect_version("1.0.1-alpha.54321.post.1", "1.0.1a54321.post1")
+```
+
+#### **Step 4.3: Test Infrastructure Updates**
+
+- Update `expect_branch_hash` function for consistent hash values
+- Add GitFlow-specific test case helpers
+- Extend FlowTestScenario with branch pattern testing
+- Add post mode validation helpers
+
+### **Phase 5: Documentation and Cleanup** ✅ **COMPLETED (Optional)**
+
+**Estimated Effort: 1 day**
+
+**Status**: ✅ **COMPLETED** - Architecture organized, CLI help functional
+
+## Implementation Phases Summary
+
+| Phase     | Components                   | Effort       | Status            |
+| --------- | ---------------------------- | ------------ | ----------------- |
+| Phase 1   | Branch rules system          | 2-3 days     | ✅ **Completed**  |
+| Phase 2   | FlowArgs integration         | 2 days       | ✅ **Completed**  |
+| Phase 3   | Pipeline integration         | 1 day        | ✅ **Completed**  |
+| Phase 4   | GitFlow test                 | 1 day        | ✅ **Completed**  |
+| Phase 5   | Documentation                | 1 day        | ✅ **Completed**  |
+| **Total** | **Complete GitFlow support** | **7-8 days** | **100% Complete** |
+
+## Key Design Principles
+
+### **1. Translation Layer Pattern**
+
+- Flow acts as intelligent translation layer to existing `zerv version`
+- Branch pattern detection converts flow args to version args
+- Leverages all existing version calculation logic
+
+### **2. Pattern Matching Hierarchy**
+
+1. **Manual overrides** (`--pre-release-label`, `--pre-release-num`)
+2. **Branch pattern rules** (`develop` → `beta`, `release/*` → `rc`)
+3. **Default fallback** (`alpha` with hash-based number)
+
+### **3. Post Mode Logic**
+
+- **Tag mode**: For release branches (count from release tags)
+- **Commit mode**: For development branches (count from branch point)
+- **Consistent**: Same algorithm, different reference points
+
+### **4. Backward Compatibility**
+
+- All existing flow functionality preserved
+- Manual overrides always take precedence
+- Default behavior unchanged for unmapped branches
+
+## Success Criteria
+
+### **Functional Requirements**
+
+- ✅ CLI arguments working (already complete)
+- ✅ Branch pattern detection for default rules
+- ✅ Pre-release resolution: develop→beta, release/*→rc, feature/*→alpha
+- ✅ Post mode configuration: tag vs commit distance
+- ✅ GitFlow test matching Mermaid diagram exactly
+- ✅ Manual override system working
+
+### **Technical Requirements**
+
+- ✅ No performance regression (translation layer overhead minimal)
+- ✅ Full backward compatibility maintained
+- ✅ Comprehensive test coverage (branch rules, translation, GitFlow)
+- ✅ Proper error handling with detailed context
+- ✅ Clean integration with existing pipeline
+
+### **Integration Requirements**
+
+- ✅ Works with existing VCS detection
+- ✅ Compatible with all output formats and schemas
+- ✅ Maintains consistency with `zerv version` output
+- ✅ Leverages existing Git operations and version parsing
+
+## Risk Assessment
+
+### **Technical Risks**
+
+- **Pattern matching complexity**: Low - well-defined exact/wildcard patterns
+- **Translation layer performance**: Low - minimal CPU overhead
+- **Post mode logic**: Low - reuses existing distance calculation
+
+### **Integration Risks**
+
+- **Backward compatibility**: Low - manual overrides preserve existing behavior
+- **Test stability**: Medium - need consistent hash generation
+- **Pipeline complexity**: Low - clean separation of concerns
+
+## Dependencies
+
+### **Internal Dependencies**
+
+- ✅ CLI argument parsing (complete)
+- ✅ Version pipeline integration (complete)
+- ✅ VCS data detection (complete)
+- ✅ Output formatting (complete)
+
+### **External Dependencies**
+
+- RON (already used for configuration)
+- No new Rust dependencies expected
+
+## Next Steps
+
+1. **Begin Phase 1**: Create branch rules module with pattern matching
+2. **Implement Phase 2**: Build translation layer for branch detection
+3. **Integrate Phase 3**: Update flow pipeline to use translation
+4. **Test Phase 4**: Create comprehensive GitFlow test scenario
+5. **Document Phase 5**: Update help text and documentation
+
+---
+
+This implementation plan builds on the solid foundation of the existing zerv flow system to add the missing 30% needed for complete GitFlow automation. The modular approach ensures minimal risk while providing powerful branch-based version intelligence.
diff --git a/.claude/plan/43-fix-git-tag-resolution-bug.md b/.claude/plan/43-fix-git-tag-resolution-bug.md
new file mode 100644
index 00000000..50a28327
--- /dev/null
+++ b/.claude/plan/43-fix-git-tag-resolution-bug.md
@@ -0,0 +1,233 @@
+# Fix Git Tag Resolution Bug
+
+## Status
+
+**Planned**
+
+## Priority
+
+**High** - Critical bug affecting version resolution in Zerv Flow
+
+## Context
+
+The current `get_latest_tag` function in `src/vcs/git.rs` has a critical bug that affects version resolution:
+
+1. **Multiple tags on same commit**: When two tags exist on the same commit (e.g., `v1.0.2-rc.1.post.3` and `v1.1.0`), `git describe --tags --abbrev=0` incorrectly returns the pre-release tag instead of the clean release tag.
+
+2. **Non-version tags**: The function doesn't filter out non-version tags like `some-tag-like-this`, which can cause parsing failures.
+
+3. **Redundant code**: There are two similar parsing functions - `VersionObject::parse_with_format` and `InputFormatHandler::parse_version_string` that should be consolidated.
+
+## Current Problematic Code
+
+```rust
+/// Get latest version tag
+fn get_latest_tag(&self) -> Result<Option<String>> {
+    match self.run_git_command(&["describe", "--tags", "--abbrev=0"]) {
+        Ok(tag) if !tag.is_empty() => Ok(Some(tag)),
+        Ok(_) => Ok(None),
+        Err(ZervError::CommandFailed(_)) => Ok(None), // No tags found
+        Err(e) => Err(e),
+    }
+}
+```
+
+## Updated Function Signature
+
+The `get_latest_tag` function should accept a format parameter:
+
+```rust
+/// Get latest version tag
+fn get_latest_tag(&self, format: &str) -> Result<Option<String>> {
+    // Implementation with format parameter
+}
+```
+
+## New Implementation (Based on Research)
+
+```rust
+/// Get latest version tag
+fn get_latest_tag(&self, format: &str) -> Result<Option<String>> {
+    // Get all tags traceable from current commit, ordered by reverse commit date
+    let output = match self.run_git_command(&["tag", "--merged", "HEAD", "--sort=-committerdate"]) {
+        Ok(tags) => tags,
+        Err(ZervError::CommandFailed(_)) => return Ok(None), // No tags found
+        Err(e) => return Err(e),
+    };
+
+    if output.is_empty() {
+        return Ok(None);
+    }
+
+    // For each tag in chronological order (newest first)
+    for tag in output.lines() {
+        let trimmed_tag = tag.trim();
+        if trimmed_tag.is_empty() {
+            continue;
+        }
+
+        // Check if tag is parsable as a version using the provided format
+        if VersionObject::parse_with_format(trimmed_tag, format).is_none() {
+            continue; // Skip non-version tags
+        }
+
+        // Get the commit hash this tag points to
+        let commit_hash = match self.run_git_command(&["rev-list", "-n", "1", trimmed_tag]) {
+            Ok(hash) => hash.trim().to_string(),
+            Err(_) => continue, // Skip if we can't get commit hash
+        };
+
+        // Get all tags pointing to this same commit
+        let tags_on_commit = match self.run_git_command(&["tag", "--points-at", &commit_hash]) {
+            Ok(tags) => tags,
+            Err(_) => continue,
+        };
+
+        if tags_on_commit.is_empty() {
+            continue;
+        }
+
+        // Find the highest semantic version among all tags on this commit
+        // Use iterator pipeline for efficiency - no Vec allocation, no sorting needed
+        let best_tag = tags_on_commit
+            .lines()
+            .map(|line| line.trim())
+            .filter(|tag| !tag.is_empty())
+            .filter(|tag| VersionObject::parse_with_format(tag, format).is_some())
+            .max();
+
+        if let Some(best_tag) = best_tag {
+            return Ok(Some(best_tag.to_string()));
+        }
+    }
+
+    Ok(None) // No valid version tags found
+}
+```
+
+## Goals
+
+1. **Fix multi-tag resolution**: When multiple tags exist on the same commit, prioritize clean releases over pre-releases
+2. **Filter non-version tags**: Only return tags that can be parsed as valid versions
+3. **Consolidate parsing logic**: Use `VersionObject::parse_with_format` as the single parsing method
+4. **Maintain backward compatibility**: Ensure existing functionality continues to work
+
+## Implementation Plan
+
+### Step 1: Research Git Commands
+
+- Test various git commands to find the best approach for getting all tags from HEAD
+- Identify the optimal sorting strategy to prioritize clean releases over pre-releases
+- Validate that the chosen approach works with the test case from `.cache/tmp/v1.1.0-tag-created-1762874069/.tmpGBjAVY`
+
+### Step 2: Update get_latest_tag Function
+
+- Add format parameter to function signature: `fn get_latest_tag(&self, format: &str)`
+- Replace `git describe` with research-based algorithm using `git tag --merged HEAD --sort=-committerdate`
+- Implement iterative approach: for each parsable tag, get its commit and all tags on that commit
+- Use semantic version sorting to find highest version among tags on the same commit
+- Return highest version tag from newest parsable commit (prioritizes clean releases over pre-releases)
+
+### Step 3: Integrate VersionObject Parsing
+
+- Modify the function to use `VersionObject::parse_with_format(format)` for validation with the passed format parameter
+- Remove or deprecate `InputFormatHandler::parse_version_string` if redundant
+- Add proper error handling for parsing failures
+- Update all callers of `get_latest_tag()` to pass appropriate format parameter
+
+### Step 4: Update Error Handling
+
+- Ensure parsing errors are handled gracefully
+- Return appropriate errors when no valid version tags are found
+- Maintain existing error handling patterns
+
+### Step 5: Add Comprehensive Tests
+
+- Test the specific bug scenario: `v1.0.2-rc.1.post.3` and `v1.1.0` on same commit
+- Test with non-version tags mixed in
+- Test with various tag formats (SemVer, PEP440)
+- Test backward compatibility scenarios
+
+### Step 6: Update Documentation and Comments
+
+- Document the new tag resolution strategy
+- Add examples of the prioritization logic
+- Update any related documentation
+
+## Technical Details
+
+### Proposed Algorithm (Updated Based on Research)
+
+1. Get all tags traceable from current commit: `git tag --merged HEAD --sort=-committerdate`
+2. For each tag in chronological order (newest first):
+    - Check if the tag is parsable using `VersionObject::parse_with_format` with auto-detection
+    - If parsable, get the commit hash: `git rev-list -n 1 <tag>`
+    - Get all tags pointing to that commit: `git tag --points-at <commit>`
+    - From all tags on that commit, select the highest semantic version
+    - Return the highest version tag (prioritizes clean releases over pre-releases)
+3. If no parsable tags found in history, return None
+
+### Key Insights from Research
+
+- `git tag --merged HEAD --sort=-committerdate` gives all tags traceable from current commit in reverse commit order
+- Multiple tags can point to the same commit (e.g., `v1.0.2-rc.1.post.3` and `v1.1.0` both point to `2cdf46bfcb9d3a52c2d6a98006eabe42152212f5`)
+- Semantic version sorting (`--sort=-version:refname`) automatically prioritizes clean releases over pre-releases
+- Algorithm must handle the case where tags from different commits are compared, not just tags on the same commit
+
+### Tag Priority Strategy
+
+1. **Clean releases** (e.g., `v1.1.0`) over pre-releases (e.g., `v1.0.2-rc.1.post.3`)
+2. **Higher semantic versions** over lower versions (when both are same type)
+3. **SemVer over PEP440** when both are valid and equivalent
+4. **Annotated tags over lightweight tags** (when all else is equal)
+
+### Integration Points
+
+- `src/vcs/git.rs` - Main implementation location with updated `get_latest_tag(&self, format: &str)` signature
+- `src/version/version_object.rs` - Use `VersionObject::parse_with_format`
+- `src/cli/utils/format_handler.rs` - Potentially remove redundant code
+- All callers of `get_latest_tag()` - Update to pass format parameter
+- Test files in `src/vcs/git.rs` and related integration tests - Update to test with different formats
+
+## Testing Strategy
+
+### Unit Tests
+
+- Test `get_latest_tag` with various git repository states
+- Mock git commands to test error scenarios
+- Test parsing integration with `VersionObject::parse_with_format`
+
+### Integration Tests
+
+- Use the cached test directory `.cache/tmp/v1.1.0-tag-created-1762874069/.tmpGBjAVY`
+- Test with actual git repositories containing multiple tags
+- Test Zerv Flow scenarios that depend on correct tag resolution
+
+### Regression Tests
+
+- Ensure existing tag resolution continues to work
+- Test edge cases like shallow clones, no tags, only non-version tags
+- Verify performance with large numbers of tags
+
+## Success Criteria
+
+1. ✅ `v1.1.0` is returned instead of `v1.0.2-rc.1.post.3` when both exist on same commit
+2. ✅ Non-version tags are filtered out gracefully
+3. ✅ Existing functionality remains intact
+4. ✅ Tests pass for all scenarios including edge cases
+5. ✅ Code uses `VersionObject::parse_with_format` consistently
+6. ✅ Error messages are clear and helpful
+
+## Documentation Updates
+
+- Update inline documentation for `get_latest_tag` function
+- Add examples to the Git VCS module documentation
+- Update testing documentation if needed
+- Consider updating the Zerv Flow plan documentation with the fix
+
+## Risk Mitigation
+
+- **Breaking changes**: Ensure the function signature and return types remain the same
+- **Performance**: Test with repositories containing many tags to ensure no performance regression
+- **Edge cases**: Handle repositories with no tags, only non-version tags, or corrupted git states
+- **Compatibility**: Ensure the fix works across different git versions and configurations
diff --git a/.claude/plan/43-note.md b/.claude/plan/43-note.md
new file mode 100644
index 00000000..57f02d26
--- /dev/null
+++ b/.claude/plan/43-note.md
@@ -0,0 +1,22 @@
+- list git tags from current commit
+
+❯ git tag --merged HEAD --sort=-committerdate
+v1.0.2-rc.1.post.3
+v1.1.0
+v1.0.2-rc.1.post.2
+v1.0.2-rc.1.post.1
+v1.0.1
+v1.0.0
+
+- for loop one by one. select only parsable tag. find its commit
+
+❯ git rev-list -n 1 v1.0.2-rc.1.post.3
+2cdf46bfcb9d3a52c2d6a98006eabe42152212f5
+
+- find all tags from that commit
+
+❯ git tag --points-at 2cdf46bfcb9d3a52c2d6a98006eabe42152212f5
+v1.0.2-rc.1.post.3
+v1.1.0
+
+- select the one with highest tag
diff --git a/.claude/plan/44-consolidate-version-parsing-functions.md b/.claude/plan/44-consolidate-version-parsing-functions.md
new file mode 100644
index 00000000..0f4187da
--- /dev/null
+++ b/.claude/plan/44-consolidate-version-parsing-functions.md
@@ -0,0 +1,236 @@
+# Consolidate Version Parsing Functions
+
+## Status
+
+**Planned**
+
+## Priority
+
+**Medium** - Code quality improvement that should be done before the git tag resolution fix
+
+## Context
+
+There are currently two similar version parsing functions in the codebase that serve overlapping purposes:
+
+1. **`VersionObject::parse_with_format`** - Located in `src/version/version_object.rs`
+    - Takes `tag: &str` and `format_str: &str`
+    - Returns `Option<VersionObject>`
+    - Supports "semver", "pep440" formats (case insensitive)
+    - Returns `None` for unknown formats or parse failures
+
+2. **`InputFormatHandler::parse_version_string`** - Located in `src/cli/utils/format_handler.rs`
+    - Takes `version_str: &str` and `input_format: &str`
+    - Returns `Result<VersionObject, ZervError>`
+    - Supports "semver", "pep440", "auto" formats (case insensitive)
+    - Returns detailed error messages for different failure scenarios
+
+## Current Problems
+
+1. **Code Duplication**: Both functions implement similar parsing logic for SemVer and PEP440
+2. **Inconsistent Error Handling**: One returns `Option`, the other returns `Result`
+3. **Different Format Support**: `InputFormatHandler` supports "auto" format, `VersionObject` doesn't
+4. **Maintenance Overhead**: Changes to version parsing logic need to be made in two places
+5. **Confusing API**: Developers don't know which function to use in different contexts
+
+## Goals
+
+1. **Consolidate parsing logic** into a single, authoritative implementation
+2. **Standardize error handling** across the codebase
+3. **Maintain all existing functionality** including "auto" format detection
+4. **Provide clear migration path** for existing code
+5. **Improve API consistency** for better developer experience
+
+## Analysis of Current Usage
+
+### VersionObject::parse_with_format Usage
+
+- Used in places where optional parsing is acceptable
+- Primarily used in version parsing pipelines
+- Called from tag resolution, version object creation
+
+### InputFormatHandler::parse_version_string Usage
+
+- Used in CLI command handlers where detailed error messages are needed
+- Used when parsing user input from command line
+- Used in contexts where error messages must be user-friendly
+
+## Proposed Solution
+
+### Option 1: Enhance VersionObject::parse_with_format (Recommended)
+
+Enhance `VersionObject::parse_with_format` to support all functionality from `InputFormatHandler::parse_version_string`:
+
+```rust
+impl VersionObject {
+    /// Enhanced parsing with auto-detection and detailed error handling
+    pub fn parse_with_format(
+        tag: &str,
+        format_str: &str
+    ) -> Result<Self, ZervError> {
+        match format_str.to_lowercase().as_str() {
+            "semver" => SemVer::from_str(tag)
+                .map(VersionObject::SemVer)
+                .map_err(|e| ZervError::InvalidFormat(format!("Invalid SemVer format '{tag}': {e}"))),
+            "pep440" => PEP440::from_str(tag)
+                .map(VersionObject::PEP440)
+                .map_err(|e| ZervError::InvalidFormat(format!("Invalid PEP440 format '{tag}': {e}"))),
+            "auto" => Self::parse_auto_detect(tag),
+            _ => Err(ZervError::UnknownFormat(format!(
+                "Unknown input format '{format_str}'. Supported formats: semver, pep440, auto"
+            ))),
+        }
+    }
+
+    /// Auto-detect version format (try SemVer first, then PEP440)
+    fn parse_auto_detect(version_str: &str) -> Result<Self, ZervError> {
+        // Try SemVer first
+        if let Ok(semver) = SemVer::from_str(version_str) {
+            return Ok(VersionObject::SemVer(semver));
+        }
+
+        // Fall back to PEP440
+        if let Ok(pep440) = PEP440::from_str(version_str) {
+            return Ok(VersionObject::PEP440(pep440));
+        }
+
+        Err(ZervError::InvalidVersion(format!(
+            "Version '{version_str}' is not valid SemVer or PEP440 format"
+        )))
+    }
+}
+```
+
+### Option 2: Create a New Centralized Function
+
+Create a new centralized parsing function and migrate both existing functions to use it:
+
+```rust
+pub fn parse_version_string(
+    version_str: &str,
+    input_format: &str
+) -> Result<VersionObject, ZervError> {
+    // Implementation here
+}
+```
+
+### Option 3: Keep Both but Clarify Responsibilities
+
+Keep both functions but clearly document their intended use cases:
+
+- `VersionObject::parse_with_format` - For internal parsing where None is acceptable
+- `InputFormatHandler::parse_version_string` - For user input parsing with error messages
+
+## Implementation Plan
+
+### Step 1: Choose the Approach
+
+- Analyze which option provides the best balance of consistency and maintainability
+- Consider the impact on existing code that calls these functions
+- Evaluate which approach provides the cleanest migration path
+
+### Step 2: Implement the Solution
+
+- If Option 1: Enhance `VersionObject::parse_with_format` to return `Result`
+- If Option 2: Create new centralized function and update both existing functions
+- If Option 3: Add clear documentation and possibly thin wrapper functions
+
+### Step 3: Update All Callers
+
+- Find all calls to `InputFormatHandler::parse_version_string`
+- Update them to use the consolidated function
+- Ensure error handling is preserved appropriately
+- Update tests to work with the new API
+
+### Step 4: Remove Redundant Code
+
+- Remove the deprecated function (if Option 1 or 2)
+- Update imports and dependencies
+- Clean up any remaining references
+
+### Step 5: Update Documentation
+
+- Update inline documentation for the consolidated function
+- Add migration guide for developers
+- Update any external documentation that references the old functions
+
+## Migration Strategy
+
+### For Option 1 (Enhance VersionObject::parse_with_format)
+
+1. **Phase 1**: Add enhanced version that returns `Result`
+2. **Phase 2**: Update all callers to handle `Result` instead of `Option`
+3. **Phase 3**: Remove `InputFormatHandler::parse_version_string`
+4. **Phase 4**: Clean up imports and dependencies
+
+### Backward Compatibility Considerations
+
+- Function signature changes will require updating all callers
+- Error handling logic may need to be updated in some places
+- Tests will need to be updated to handle new error types
+
+## Testing Strategy
+
+### Unit Tests
+
+- Test all format types: "semver", "pep440", "auto"
+- Test invalid inputs and error messages
+- Test case-insensitive format handling
+- Test edge cases and boundary conditions
+
+### Integration Tests
+
+- Test that existing functionality continues to work
+- Test error handling in CLI contexts
+- Test auto-detection with ambiguous versions
+
+### Regression Tests
+
+- Ensure no functionality is lost during consolidation
+- Verify that error messages are preserved or improved
+- Test performance impact of the changes
+
+## Success Criteria
+
+1. ✅ Single, authoritative version parsing function
+2. ✅ All existing functionality preserved
+3. ✅ Consistent error handling across the codebase
+4. ✅ Clear migration path for developers
+5. ✅ No breaking changes in public APIs (or clear migration guide)
+6. ✅ Reduced code duplication and maintenance burden
+
+## Risk Mitigation
+
+- **Breaking changes**: Carefully analyze all callers and provide migration guidance
+- **Error message quality**: Ensure user-facing error messages are maintained or improved
+- **Performance**: Ensure consolidation doesn't negatively impact parsing performance
+- **Compatibility**: Test with all existing use cases to ensure no regressions
+
+## Decision Criteria
+
+Choose Option 1 if:
+
+- You want a single authoritative parsing function
+- You're comfortable changing function signatures
+- You want to minimize code duplication
+
+Choose Option 2 if:
+
+- You want to maintain existing function signatures
+- You prefer a gradual migration approach
+- You want a clean separation between internal and user-facing parsing
+
+Choose Option 3 if:
+
+- The two functions serve genuinely different purposes
+- The risk of breaking existing code is too high
+- You prefer to clarify rather than consolidate
+
+## Recommendation
+
+**Option 1 (Enhance VersionObject::parse_with_format)** is recommended because:
+
+1. `VersionObject` is the natural home for version parsing logic
+2. It eliminates duplication completely
+3. It provides a single source of truth for version parsing
+4. The migration is straightforward and manageable
+5. It improves overall code organization and maintainability
diff --git a/.claude/plan/45-flow-integration-tests.md b/.claude/plan/45-flow-integration-tests.md
new file mode 100644
index 00000000..65ab5b92
--- /dev/null
+++ b/.claude/plan/45-flow-integration-tests.md
@@ -0,0 +1,269 @@
+# Create Integration Tests for "zerv flow" Command
+
+## Status
+
+**Completed** - All major components implemented and working
+
+## Priority
+
+**High** - Essential comprehensive CLI testing coverage achieved
+
+## Context
+
+The existing `pipeline.rs` test uses `FlowTestScenario` which tests the flow pipeline directly using Rust function calls. We need integration tests that test the complete "zerv flow" command through the CLI interface using string-based command line arguments, similar to how users actually use the tool.
+
+## Goals
+
+✅ **ACHIEVED** - All major goals completed
+
+1. ✅ Created integration tests for "zerv flow" command that test the complete CLI interface
+2. ✅ Tested flow command behavior with various output formats and options
+3. ✅ Tested different git scenarios (trunk-based, GitFlow) using command-line interface
+4. ✅ Ensured integration tests are similar to but separate from existing pipeline tests
+5. ✅ Followed existing integration test patterns used for "zerv version" command
+
+## Implementation Plan
+
+### ✅ **ALL STEPS COMPLETED**
+
+### Step 1: Create Test Structure ✅ **COMPLETED**
+
+- ✅ Create `tests/integration_tests/flow/mod.rs` - Main flow integration test module
+- ✅ Create `tests/integration_tests/flow/main/` subdirectory for main flow command tests
+- ✅ Create `tests/integration_tests/flow/scenarios/` subdirectory for complex workflow tests
+- ✅ Create `tests/integration_tests/flow/args.rs` for flow-specific test utilities
+- ✅ Update `tests/integration_tests/mod.rs` to include flow module
+
+### Step 2: Create FlowTestUtils Structure ✅ **COMPLETED**
+
+- ✅ Create `FlowIntegrationTestScenario` with the same fluent API as `FlowTestScenario` but for CLI integration tests
+- ✅ Implement the same builder pattern methods: `create_tag`, `create_branch`, `checkout`, `commit`, `make_dirty`, `merge_branch`
+- ✅ Add the same expectation methods: `expect_version(semver, pep440)` and `expect_schema_variants(test_cases)`
+- ✅ The key difference: `expect_version` and `expect_schema_variants` will internally use CLI string arguments via `TestCommand` instead of calling `run_flow_pipeline` directly
+- ✅ Reuse existing `GitRepoFixture` and `TestCommand` from test utilities
+- ✅ Create `scenarios/test_utils.rs` that reuses utilities from `src/cli/flow/test_utils.rs`:
+    - ✅ Re-implement `SchemaTestCase`, `SchemaTestExtraCore`, `SchemaTestBuild` structs
+    - ✅ Re-implement `create_full_schema_test_cases()` and `create_base_schema_test_cases()` functions
+    - ✅ Re-implement `expect_branch_hash()` function for predictable hash generation
+    - ✅ Add CLI-specific test functions: `test_flow_pipeline_with_fixture()`, `test_flow_pipeline_with_fixture_and_schema_opt()`
+- ✅ Add `FlowTestResult` with assertion methods: `assert_success()`, `assert_failure()`, `assert_stdout_eq()`, etc.
+- ✅ Include proper Docker test gating using `if !should_run_docker_tests() { return; }`
+- ✅ Ensure all code passes `make lint` and integration tests
+
+### Step 3: Basic Flow Command Tests (using stdin input) ✅ **COMPLETED**
+
+- ✅ Test basic "zerv flow" command with default settings using zerv stdin input
+- ✅ Test "zerv flow" with different output formats (`--output-format semver`, `--output-format pep440`) using stdin
+- ✅ Test "zerv flow" with schema options (`--schema standard`) using stdin
+- ✅ Test "zerv flow" with pre-release handling (alpha, beta, rc) using stdin
+- ✅ Test "zerv flow" with branch-based scenarios (main, feature/, develop) using stdin
+- ✅ Test "zerv flow" error handling (empty stdin, invalid RON format, invalid options)
+- ✅ **SOLVED**: All 15 basic flow command tests passing with 100% success rate
+
+### Step 4: Workflow Scenario Tests ✅ **COMPLETED**
+
+#### Step 4.1: Trunk-Based Workflow Tests ✅ **COMPLETED**
+
+- ✅ Complete trunk-based development workflow with 14 steps implemented
+- ✅ Tests parallel feature branches, sync workflows, sub-feature development
+- ✅ Tests complex merge scenarios, dirty state handling, and release management
+- ✅ Matches unit test structure exactly with all expect_schema_variants calls
+- ✅ All tests pass with comprehensive validation
+
+#### Step 4.2: GitFlow Workflow Tests ✅ **COMPLETED**
+
+- ✅ Complete GitFlow development workflow with 12 steps implemented
+- ✅ Tests main/develop branches, feature branches, hotfix workflow, release branches
+- ✅ Tests release candidate (RC) workflow and branch synchronization
+- ✅ Matches unit test structure exactly with all expect_schema_variants calls
+- ✅ All tests pass with comprehensive validation
+
+## Remaining Implementation Tasks (3 files)
+
+The integration test framework is complete and robust. The following 3 additional test files remain to provide even more comprehensive coverage:
+
+### Step 5: Output Format Tests (using stdin input) 🔄 **PENDING**
+
+**File**: `tests/integration_tests/flow/main/output_formats.rs`
+
+- Test flow command with different output formats (`--output-format semver`, `--output-format pep440`) using stdin
+- Test custom output templates with flow command using stdin input
+- Test output prefixes and suffixes using stdin input
+- Verify template variables are correctly resolved using stdin
+
+### Step 6: Schema Option Tests (using stdin input) 🔄 **PENDING**
+
+**File**: `tests/integration_tests/flow/main/schema_options.rs`
+
+- Test flow command with different schema options (`--schema standard`, `--schema custom`) using stdin
+- Test schema validation and error handling using stdin input
+- Test different schema presets with flow command using stdin input
+- Test schema templates with complex data structures
+
+### Step 7: Error Handling Tests (using stdin input) 🔄 **PENDING**
+
+**File**: `tests/integration_tests/flow/main/error_handling.rs`
+
+- Test flow command with invalid arguments using stdin input
+- Test flow command with conflicting options using stdin input
+- Test flow command error messages are helpful using stdin input
+- Test flow command with invalid schema formats using stdin
+
+## Testing Strategy
+
+### Test Organization
+
+```
+tests/integration_tests/flow/
+├── mod.rs                    # Main module exports
+├── args.rs                   # Flow-specific test utilities
+├── main/
+│   ├── mod.rs               # Main flow command tests (using git)
+│   ├── basic_commands.rs    # Basic flow command tests (using git)
+│   ├── output_formats.rs    # Output format tests (using git)
+│   ├── schema_options.rs    # Schema option tests (using git)
+│   └── error_handling.rs    # Error handling tests (using git)
+└── scenarios/
+    ├── mod.rs               # Complex workflow tests (using git)
+    ├── test_utils.rs        # Reused test utilities for CLI integration
+    ├── trunk_based.rs       # Trunk-based workflow tests (using git)
+    └── gitflow.rs           # GitFlow workflow tests (using git)
+```
+
+### Integration Test Patterns
+
+**All Flow Tests (using git repositories - flow command requires git context):**
+
+```rust
+// Basic functionality, schema options, output formats, error handling
+// All use git repositories since flow command requires git branch context
+let scenario = FlowIntegrationTestScenario::new()?
+    .create_tag("v1.0.0")
+    .expect_version("1.0.0", "1.0.0");
+
+// Complex workflow scenarios (trunk-based, GitFlow)
+// Same API as existing FlowTestScenario but uses CLI internally
+let scenario = FlowIntegrationTestScenario::new()?
+    .create_tag("v1.0.0")
+    .create_branch("feature/test")
+    .checkout("feature/test")
+    .commit()
+    .expect_version("1.0.1-alpha.XXXXX.post.1+feature.test.1.g{hex:7}",
+                    "1.0.1aXXXXX.post1+feature.test.1.g{hex:7}")
+    .expect_schema_variants(create_full_schema_test_cases(...));
+```
+
+**Key architectural achievement:**
+
+- **SOLVED**: Flow command now supports stdin input through **stdin caching mechanism**
+- Flow command can read input once and cache it for both passes (current state + bumped version)
+- Flow command supports **dual modes**:
+    - **Stdin input**: For basic functionality testing (like version command)
+    - **Git repositories**: For intelligent pre-release management based on branch names
+- **All basic tests use stdin**: Following same pattern as version command tests
+- **Scenario tests use git**: For comprehensive workflow validation
+- Flow tests validate both CLI interface layer AND git workflow behavior
+
+### Reuse Existing Infrastructure
+
+- Use `TestCommand` utility for running CLI commands
+- Use `GitRepoFixture` for git repository setup
+- Use `should_run_docker_tests()` for Docker test gating
+- Follow existing patterns from `tests/integration_tests/version/`
+
+## Progress Summary
+
+### ✅ **COMPLETED - All Major Goals Achieved**
+
+**Step 1: Test Structure** ✅ **COMPLETED**
+
+- ✅ Complete directory structure created
+- ✅ All module files properly connected
+- ✅ Integration test root updated
+- ✅ Clean architecture with proper separation of concerns
+
+**Step 2: FlowTestUtils Structure** ✅ **COMPLETED**
+
+- ✅ `FlowIntegrationTestScenario` with full API implementation
+- ✅ Same fluent API as existing `FlowTestScenario`
+- ✅ CLI-based implementation using `TestCommand`
+- ✅ Complete `FlowTestResult` with all assertion methods
+- ✅ Schema test utilities re-implemented and centralized
+- ✅ Proper Docker test gating
+- ✅ All code passes `make lint` and tests
+- ✅ Moved to `scenarios/test_utils.rs` to match unit test pattern
+
+**Step 3: Basic Flow Command Tests** ✅ **COMPLETED**
+
+- ✅ **15/15 tests passing** with 100% success rate
+- ✅ Basic "zerv flow" command functionality with stdin input verified
+- ✅ Different output formats (semver, pep440) tested and working
+- ✅ Schema options (`--schema standard`) tested and working
+- ✅ Pre-release handling (alpha, beta, rc) tested and working
+- ✅ Branch-based scenarios (main, feature/, develop) tested and working
+- ✅ Error handling (empty stdin, invalid RON, invalid options) tested and working
+- ✅ Help command functionality tested and working
+- ✅ **ACHIEVEMENT**: Flow command now works identically to version command with stdin input
+
+**Step 4: Centralized Stdin Implementation** ✅ **COMPLETED**
+
+- ✅ **SOLVED**: Centralized stdin approach implemented in `app.rs` - stdin extracted once and passed to all pipelines
+- ✅ **SOLVED**: Both `run_version_pipeline()` and `run_flow_pipeline()` now accept `stdin_content: Option<&str>` parameter
+- ✅ **SOLVED**: Simplified stdin handling for unified approach
+- ✅ **SOLVED**: Cleaned up unused functions and improved API
+- ✅ **SOLVED**: Flow command supports centralized stdin with the same mechanism as version command
+- ✅ **SOLVED**: All 15 basic flow command tests pass (100% success rate) following same patterns as version command tests
+- ✅ **ARCHITECTURAL ACHIEVEMENT**: Two-pass design limitation completely resolved through centralized stdin approach
+
+**Step 5: Workflow Scenario Tests** ✅ **COMPLETED**
+
+- ✅ **Complete trunk-based workflow**: 14-step implementation covering parallel feature branches, sync workflows, sub-feature development, complex merge scenarios, dirty state handling, and release management
+- ✅ **Complete GitFlow workflow**: 12-step implementation covering main/develop branches, feature branches, hotfix workflow, release branches, RC workflow, and branch synchronization
+- ✅ **Unit test parity**: Both workflows match unit test structure exactly with all `expect_schema_variants` calls
+- ✅ **Schema validation**: Comprehensive schema testing with all active expect_schema_variants calls from unit tests
+- ✅ **Robust testing**: All 31 flow integration tests pass with comprehensive validation
+
+### 🔄 **Implementation Details:**
+
+**API Compatibility:**
+
+- Same builder methods: `create_tag`, `create_branch`, `checkout`, `commit`, `make_dirty`, `merge_branch`
+- Same expectation methods: `expect_version(semver, pep440)`, `expect_schema_variants(test_cases)`
+- Same assertion methods: `assert_success()`, `assert_failure()`, `assert_stdout_eq()`, etc.
+
+**CLI Integration:**
+
+- Uses `TestCommand` for actual CLI execution
+- Tests complete command-line interface layer
+- Tests both semver and pep440 formats automatically
+- Supports all flow command options and schemas
+
+**Code Quality:**
+
+- Passes `make lint` with no warnings
+- Follows repo coding standards
+- Proper error handling and test gating
+- Clean, maintainable implementation
+
+## Success Criteria
+
+1. ✅ **ACHIEVED**: Comprehensive integration test coverage for "zerv flow" command
+2. ✅ **ACHIEVED**: Flow command stdin support works like version command
+3. ✅ **ACHIEVED**: Tests cover all major CLI options and output formats (31 tests passing)
+4. ✅ **ACHIEVED**: Tests cover trunk-based workflow scenarios (14-step implementation)
+5. ✅ **ACHIEVED**: Tests cover GitFlow workflow scenarios (12-step implementation)
+6. 🔄 Additional error handling tests available for robust CLI behavior (3 remaining files)
+7. ✅ Tests are maintainable and follow existing patterns
+8. ✅ Tests are properly gated for Docker dependencies
+9. ✅ Integration tests are separate from but complementary to existing pipeline tests
+10. ✅ **INNOVATION**: Solved two-pass stdin reading limitation through centralized caching mechanism
+11. ✅ **COMPREHENSIVE**: Complete workflow validation with full schema testing
+
+## Notes
+
+- ✅ **Integration tests complement existing unit tests** in `src/cli/flow/pipeline.rs`
+- ✅ **Focus on testing the CLI interface layer**, not the internal logic (which is already tested)
+- ✅ **Follow established patterns** from version command integration tests
+- ✅ **Tests are deterministic** and don't depend on timing or external factors
+- ✅ **Framework is ready** for implementing remaining test files (Steps 3-6)
+- ✅ **All basic functionality verified** through test cases in `args.rs`
diff --git a/.github/workflows/cd.yml b/.github/workflows/cd.yml
index 2ff953fd..be5649ac 100644
--- a/.github/workflows/cd.yml
+++ b/.github/workflows/cd.yml
@@ -39,7 +39,7 @@ jobs:
             - id: release
               name: Release
               if: steps.check-release.outputs.has_existing == 'false'
-              uses: cycjimmy/semantic-release-action@9cc899c47e6841430bbaedb43de1560a568dfd16 # v5.0.0
+              uses: cycjimmy/semantic-release-action@ba330626c4750c19d8299de843f05c7aa5574f62 # v5.0.2
               env:
                   GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
@@ -99,7 +99,7 @@ jobs:
         steps:
             - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
 
-            - uses: dtolnay/rust-toolchain@6d653acede28d24f02e3cd41383119e8b1b35921 # stable
+            - uses: dtolnay/rust-toolchain@0f44b27771c32bda9f458f75a1e241b09791b331 # stable
               with:
                   toolchain: stable
                   targets: ${{ matrix.target }}
@@ -141,7 +141,7 @@ jobs:
         steps:
             - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
 
-            - uses: dtolnay/rust-toolchain@6d653acede28d24f02e3cd41383119e8b1b35921 # stable
+            - uses: dtolnay/rust-toolchain@0f44b27771c32bda9f458f75a1e241b09791b331 # stable
               with:
                   toolchain: stable
 
diff --git a/.github/workflows/ci-pre-commit.yml b/.github/workflows/ci-pre-commit.yml
index d7a02958..9bc48314 100644
--- a/.github/workflows/ci-pre-commit.yml
+++ b/.github/workflows/ci-pre-commit.yml
@@ -22,7 +22,7 @@ jobs:
             - name: Install Prettier
               run: npm install -g prettier
 
-            - uses: dtolnay/rust-toolchain@6d653acede28d24f02e3cd41383119e8b1b35921 # stable
+            - uses: dtolnay/rust-toolchain@0f44b27771c32bda9f458f75a1e241b09791b331 # stable
               with:
                   toolchain: nightly
                   components: rustfmt, clippy
diff --git a/.github/workflows/ci-test.yml b/.github/workflows/ci-test.yml
index 0f0a1540..4568a97f 100644
--- a/.github/workflows/ci-test.yml
+++ b/.github/workflows/ci-test.yml
@@ -23,7 +23,7 @@ jobs:
               with:
                   fetch-depth: 0
 
-            - uses: dtolnay/rust-toolchain@6d653acede28d24f02e3cd41383119e8b1b35921 # stable
+            - uses: dtolnay/rust-toolchain@0f44b27771c32bda9f458f75a1e241b09791b331 # stable
               with:
                   toolchain: stable
 
diff --git a/.github/workflows/security.yml b/.github/workflows/security.yml
index eaba5c8e..1f37318e 100644
--- a/.github/workflows/security.yml
+++ b/.github/workflows/security.yml
@@ -43,7 +43,7 @@ jobs:
               uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
 
             - name: Setup Rust
-              uses: dtolnay/rust-toolchain@6d653acede28d24f02e3cd41383119e8b1b35921 # stable
+              uses: dtolnay/rust-toolchain@0f44b27771c32bda9f458f75a1e241b09791b331 # stable
               with:
                   toolchain: stable
 
diff --git a/Cargo.lock b/Cargo.lock
index ff60f1ab..06cb109e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -52,22 +52,22 @@ dependencies = [
 
 [[package]]
 name = "anstyle-query"
-version = "1.1.4"
+version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e231f6134f61b71076a3eab506c379d4f36122f2af15a9ff04415ea4c3339e2"
+checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
 dependencies = [
- "windows-sys 0.60.2",
+ "windows-sys",
 ]
 
 [[package]]
 name = "anstyle-wincon"
-version = "3.0.10"
+version = "3.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e0633414522a32ffaac8ac6cc8f748e090c5717661fddeea04219e2344f5f2a"
+checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
 dependencies = [
  "anstyle",
  "once_cell_polyfill",
- "windows-sys 0.60.2",
+ "windows-sys",
 ]
 
 [[package]]
@@ -76,12 +76,6 @@ version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
 
-[[package]]
-name = "base64"
-version = "0.22.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
-
 [[package]]
 name = "bitflags"
 version = "2.10.0"
@@ -118,9 +112,9 @@ checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43"
 
 [[package]]
 name = "cc"
-version = "1.2.44"
+version = "1.2.46"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37521ac7aabe3d13122dc382493e20c9416f299d2ccd5b3a5340a2570cdeb0f3"
+checksum = "b97463e1064cb1b1c1384ad0a0b9c8abd0988e2a91f52606c80ef14aadb63e36"
 dependencies = [
  "find-msvc-tools",
  "shlex",
@@ -255,9 +249,9 @@ checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
 [[package]]
 name = "crypto-common"
-version = "0.1.6"
+version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
 dependencies = [
  "generic-array",
  "typenum",
@@ -329,7 +323,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys 0.61.2",
+ "windows-sys",
 ]
 
 [[package]]
@@ -340,9 +334,9 @@ checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
 
 [[package]]
 name = "find-msvc-tools"
-version = "0.1.4"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52051878f80a721bb68ebfbc930e07b65ba72f2da88968ea5c06fd6ca3d3a127"
+checksum = "3a3076410a55c90011c298b04d0cfa770b00fa04e1e3c97d3f6c9de105a03844"
 
 [[package]]
 name = "futures"
@@ -441,9 +435,9 @@ dependencies = [
 
 [[package]]
 name = "generic-array"
-version = "0.14.9"
+version = "0.14.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4bb6743198531e02858aeaea5398fcc883e71851fcbcb5a2f773e2fb6cb1edf2"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
 dependencies = [
  "typenum",
  "version_check",
@@ -657,7 +651,7 @@ version = "0.50.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys",
 ]
 
 [[package]]
@@ -841,9 +835,9 @@ dependencies = [
 
 [[package]]
 name = "quote"
-version = "1.0.41"
+version = "1.0.42"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce25767e7b499d1b604768e7cde645d14cc8584231ea6b295e9c9eb22c02e1d1"
+checksum = "a338cc41d27e6cc6dce6cefc13a0729dfbb81c262b1f519331575dd80ef3067f"
 dependencies = [
  "proc-macro2",
 ]
@@ -930,14 +924,15 @@ checksum = "ba39f3699c378cd8970968dcbff9c43159ea4cfbd88d43c00b22f2ef10a435d2"
 
 [[package]]
 name = "ron"
-version = "0.11.0"
+version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db09040cc89e461f1a265139777a2bde7f8d8c67c4936f700c63ce3e2904d468"
+checksum = "fd490c5b18261893f14449cbd28cb9c0b637aebf161cd77900bfdedaff21ec32"
 dependencies = [
- "base64",
  "bitflags",
+ "once_cell",
  "serde",
  "serde_derive",
+ "typeid",
  "unicode-ident",
 ]
 
@@ -989,7 +984,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys 0.61.2",
+ "windows-sys",
 ]
 
 [[package]]
@@ -1191,9 +1186,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.109"
+version = "2.0.110"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f17c7e013e88258aa9543dcbe81aca68a667a9ac37cd69c9fbc07858bfe0e2f"
+checksum = "a99801b5bd34ede4cf3fc688c5919368fea4e4814a4664359503e6015b280aea"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1210,7 +1205,7 @@ dependencies = [
  "getrandom 0.3.4",
  "once_cell",
  "rustix",
- "windows-sys 0.61.2",
+ "windows-sys",
 ]
 
 [[package]]
@@ -1335,6 +1330,12 @@ dependencies = [
  "tracing-log",
 ]
 
+[[package]]
+name = "typeid"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc7d623258602320d5c55d1bc22793b57daff0ec7efc270ea7d55ce1d5f5471c"
+
 [[package]]
 name = "typenum"
 version = "1.19.0"
@@ -1453,7 +1454,7 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys",
 ]
 
 [[package]]
@@ -1515,15 +1516,6 @@ dependencies = [
  "windows-link",
 ]
 
-[[package]]
-name = "windows-sys"
-version = "0.60.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
-dependencies = [
- "windows-targets",
-]
-
 [[package]]
 name = "windows-sys"
 version = "0.61.2"
@@ -1533,71 +1525,6 @@ dependencies = [
  "windows-link",
 ]
 
-[[package]]
-name = "windows-targets"
-version = "0.53.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3"
-dependencies = [
- "windows-link",
- "windows_aarch64_gnullvm",
- "windows_aarch64_msvc",
- "windows_i686_gnu",
- "windows_i686_gnullvm",
- "windows_i686_msvc",
- "windows_x86_64_gnu",
- "windows_x86_64_gnullvm",
- "windows_x86_64_msvc",
-]
-
-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53"
-
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006"
-
-[[package]]
-name = "windows_i686_gnu"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3"
-
-[[package]]
-name = "windows_i686_gnullvm"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c"
-
-[[package]]
-name = "windows_i686_msvc"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2"
-
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499"
-
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1"
-
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
-
 [[package]]
 name = "winnow"
 version = "0.7.13"
diff --git a/Cargo.toml b/Cargo.toml
index 526752c3..45bf865f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -36,7 +36,7 @@ indexmap = { version = "^2.12", features = ["serde"] }
 libc = "^0.2"
 once_cell = "^1.19"
 regex = "^1.11"
-ron = "^0.11.0"
+ron = "^0.12.0"
 serde = { version = "^1.0", features = ["derive"] }
 serde_json = "^1.0"
 strum = { version = "^0.27", features = ["derive"] }
diff --git a/Makefile b/Makefile
index 9c0fc469..fdc682a9 100644
--- a/Makefile
+++ b/Makefile
@@ -10,10 +10,10 @@ update:
 	cargo update
 
 lint:
+	npx prettier --write "**/*.{ts,tsx,css,json,yaml,yml,md}"
 	cargo +nightly check --tests
 	cargo +nightly fmt -- --check || (cargo +nightly fmt && exit 1)
 	cargo +nightly clippy --all-targets --all-features -- -D warnings
-	npx prettier --write "**/*.{ts,tsx,css,json,yaml,yml,md}"
 
 _test:
 	RUST_BACKTRACE=1 RUST_LOG=cargo_tarpaulin=off cargo tarpaulin \
diff --git a/src/cli/app.rs b/src/cli/app.rs
index c9cdd1d4..68ed4c5f 100644
--- a/src/cli/app.rs
+++ b/src/cli/app.rs
@@ -1,4 +1,8 @@
-use std::io::Write;
+use std::io::{
+    IsTerminal,
+    Read,
+    Write,
+};
 
 use clap::Parser;
 
@@ -27,17 +31,21 @@ pub fn run_with_args<W: Write>(
         return Ok(());
     }
 
+    // Extract stdin content once at the beginning
+    let stdin_content = extract_stdin_once()?;
+
     match cli.command {
         Some(Commands::Version(version_args)) => {
-            let output = run_version_pipeline(*version_args)?;
+            let output = run_version_pipeline(*version_args, stdin_content.as_deref())?;
             writeln!(writer, "{output}")?;
         }
         Some(Commands::Flow(flow_args)) => {
-            let output = run_flow_pipeline(*flow_args)?;
+            let output = run_flow_pipeline(*flow_args, stdin_content.as_deref())?;
             writeln!(writer, "{output}")?;
         }
         Some(Commands::Check(check_args)) => {
-            run_check_command(check_args)?;
+            let output = run_check_command(check_args)?;
+            writeln!(writer, "{output}")?;
         }
         None => {
             // No subcommand provided, but --llm-help was not used either
@@ -47,6 +55,27 @@ pub fn run_with_args<W: Write>(
     Ok(())
 }
 
+/// Extract stdin content once, regardless of command
+/// Returns Ok(Some(String)) if stdin is available, Ok(None) otherwise
+fn extract_stdin_once() -> Result<Option<String>, Box<dyn std::error::Error>> {
+    // Check if stdin is being piped
+    if std::io::stdin().is_terminal() {
+        return Ok(None);
+    }
+
+    let mut input = String::new();
+    match std::io::stdin().read_to_string(&mut input) {
+        Ok(_) => {
+            if input.trim().is_empty() {
+                Ok(None)
+            } else {
+                Ok(Some(input))
+            }
+        }
+        Err(e) => Err(Box::new(e)),
+    }
+}
+
 pub fn run() {
     let args: Vec<String> = std::env::args().collect();
     if let Err(e) = run_with_args(args, std::io::stdout()) {
diff --git a/src/cli/check.rs b/src/cli/check.rs
index 3ed422f9..b03043af 100644
--- a/src/cli/check.rs
+++ b/src/cli/check.rs
@@ -22,15 +22,17 @@ pub struct CheckArgs {
     pub format: Option<String>,
 }
 
-fn print_format_validation<T: Display>(original: &str, parsed: &T, format_name: &str) {
+fn format_validation<T: Display>(original: &str, parsed: &T, format_name: &str) -> String {
     if original == parsed.to_string() {
-        println!("✓ Valid {format_name} format");
+        format!("✓ Valid {format_name} format")
     } else {
-        println!("✓ Valid {format_name} format (normalized: {parsed})");
+        format!("✓ Valid {format_name} format (normalized: {parsed})")
     }
 }
 
-pub fn run_check_command(args: CheckArgs) -> Result<(), ZervError> {
+pub fn run_check_command(args: CheckArgs) -> Result<String, ZervError> {
+    let mut output = String::new();
+
     match args.format.as_deref() {
         Some(formats::PEP440) => {
             let parsed = PEP440::from_str(&args.version).map_err(|_| {
@@ -40,8 +42,12 @@ pub fn run_check_command(args: CheckArgs) -> Result<(), ZervError> {
                     format_names::PEP440
                 ))
             })?;
-            println!("Version: {}", args.version);
-            print_format_validation(&args.version, &parsed, format_names::PEP440);
+            output.push_str(&format!("Version: {}\n", args.version));
+            output.push_str(&format_validation(
+                &args.version,
+                &parsed,
+                format_names::PEP440,
+            ));
         }
         Some(formats::SEMVER) => {
             let parsed = SemVer::from_str(&args.version).map_err(|_| {
@@ -51,8 +57,12 @@ pub fn run_check_command(args: CheckArgs) -> Result<(), ZervError> {
                     format_names::SEMVER
                 ))
             })?;
-            println!("Version: {}", args.version);
-            print_format_validation(&args.version, &parsed, format_names::SEMVER);
+            output.push_str(&format!("Version: {}\n", args.version));
+            output.push_str(&format_validation(
+                &args.version,
+                &parsed,
+                format_names::SEMVER,
+            ));
         }
         None => {
             // Auto-detect format
@@ -67,25 +77,36 @@ pub fn run_check_command(args: CheckArgs) -> Result<(), ZervError> {
                 )));
             }
 
-            println!("Version: {}", args.version);
+            output.push_str(&format!("Version: {}\n", args.version));
 
             if let Ok(ref parsed) = pep440_result {
-                print_format_validation(&args.version, parsed, format_names::PEP440);
+                output.push_str(&format_validation(
+                    &args.version,
+                    parsed,
+                    format_names::PEP440,
+                ));
+                output.push('\n');
             }
             if let Ok(ref parsed) = semver_result {
-                print_format_validation(&args.version, parsed, format_names::SEMVER);
+                output.push_str(&format_validation(
+                    &args.version,
+                    parsed,
+                    format_names::SEMVER,
+                ));
+                output.push('\n');
             }
         }
         Some(format) => {
-            eprintln!("✗ Unknown format: {format}");
-            eprintln!(
-                "Supported formats: {}",
+            return Err(ZervError::UnknownFormat(format!(
+                "{format}. Supported formats: {}",
                 formats::SUPPORTED_FORMATS.join(", ")
-            );
-            return Err(ZervError::UnknownFormat(format.to_string()));
+            )));
         }
     }
-    Ok(())
+
+    // Remove trailing newline if present
+    output = output.trim_end().to_string();
+    Ok(output)
 }
 
 #[cfg(test)]
diff --git a/src/cli/common/args/output.rs b/src/cli/common/args/output.rs
index b32fdc76..4acd9693 100644
--- a/src/cli/common/args/output.rs
+++ b/src/cli/common/args/output.rs
@@ -39,6 +39,17 @@ impl Default for OutputConfig {
     }
 }
 
+impl OutputConfig {
+    /// Create output config for internal zerv processing
+    pub fn zerv() -> Self {
+        Self {
+            output_format: "zerv".to_string(),
+            output_template: None,
+            output_prefix: None,
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -51,6 +62,14 @@ mod tests {
         assert!(config.output_prefix.is_none());
     }
 
+    #[test]
+    fn test_output_config_zerv() {
+        let config = OutputConfig::zerv();
+        assert_eq!(config.output_format, "zerv");
+        assert!(config.output_template.is_none());
+        assert!(config.output_prefix.is_none());
+    }
+
     #[test]
     fn test_output_config_construction() {
         let config = OutputConfig {
diff --git a/src/cli/flow/args/branch_rules.rs b/src/cli/flow/args/branch_rules.rs
new file mode 100644
index 00000000..6b5f2c20
--- /dev/null
+++ b/src/cli/flow/args/branch_rules.rs
@@ -0,0 +1,237 @@
+use clap::Parser;
+
+use crate::cli::flow::branch_rules::BranchRules;
+use crate::error::ZervError;
+use crate::utils::constants::post_modes;
+use crate::version::zerv::core::Zerv;
+
+/// Configuration for branch-related settings
+#[derive(Parser, Debug, Clone)]
+pub struct BranchRulesConfig {
+    /// Pre-release label for flow versions (alpha, beta, rc)
+    #[arg(long, value_parser = clap::builder::PossibleValuesParser::new(crate::utils::constants::pre_release_labels::VALID_LABELS),
+          help = "Pre-release label for flow versions (alpha, beta, rc)")]
+    pub pre_release_label: Option<String>,
+
+    #[arg(
+        long,
+        value_parser = clap::value_parser!(u32),
+        help = "Pre-release number for flow versions (integer, default: {{ hash_int(value=bumped_branch, length=HASH_BRANCH_LEN) }})"
+    )]
+    pub pre_release_num: Option<u32>,
+
+    /// Post calculation mode (commit, tag)
+    #[arg(long = "post-mode", value_parser = clap::builder::PossibleValuesParser::new(post_modes::VALID_MODES),
+          help = "Post calculation mode (commit, tag)")]
+    pub post_mode: Option<String>,
+
+    /// Branch rules in RON format (default: GitFlow rules)
+    #[arg(
+        long = "branch-rules",
+        help = "Branch rules in RON format (default: GitFlow rules)",
+        value_parser = clap::value_parser!(BranchRules),
+        default_value_t = BranchRules::default_rules(),
+    )]
+    pub branch_rules: BranchRules,
+}
+
+impl Default for BranchRulesConfig {
+    fn default() -> Self {
+        Self {
+            pre_release_label: None,
+            pre_release_num: None,
+            post_mode: None,
+            branch_rules: BranchRules::default_rules(),
+        }
+    }
+}
+
+impl BranchRulesConfig {
+    /// Check if any branch configuration is explicitly set
+    pub fn has_explicit_settings(&self) -> bool {
+        self.pre_release_label.is_some()
+            || self.pre_release_num.is_some()
+            || self.post_mode.is_some()
+    }
+
+    /// Apply branch rules using provided zerv object
+    pub fn apply_branch_rules(&mut self, current_zerv: &Zerv) -> Result<(), ZervError> {
+        let resolved_args = self
+            .branch_rules
+            .resolve_for_branch(current_zerv.vars.bumped_branch.as_deref());
+
+        if self.pre_release_label.is_none() {
+            self.pre_release_label = Some(resolved_args.pre_release_label.to_string().into());
+        }
+        if self.pre_release_num.is_none() {
+            self.pre_release_num = resolved_args.pre_release_num;
+        }
+        if self.post_mode.is_none() {
+            self.post_mode = Some(resolved_args.post_mode.to_string().into());
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use rstest::*;
+
+    use super::*;
+
+    #[test]
+    fn test_branch_rules_config_default() {
+        let config = BranchRulesConfig::default();
+        assert!(config.pre_release_label.is_none());
+        assert!(config.pre_release_num.is_none());
+        assert!(config.post_mode.is_none());
+        assert!(!config.has_explicit_settings());
+    }
+
+    #[test]
+    fn test_branch_rules_config_has_explicit_settings() {
+        let config = BranchRulesConfig {
+            pre_release_label: Some("alpha".to_string()),
+            pre_release_num: None,
+            post_mode: None,
+            branch_rules: BranchRules::default_rules(),
+        };
+        assert!(config.has_explicit_settings());
+    }
+
+    #[test]
+    fn test_branch_rules_config_no_explicit_settings() {
+        let config = BranchRulesConfig {
+            pre_release_label: None,
+            pre_release_num: None,
+            post_mode: None,
+            branch_rules: BranchRules::default_rules(),
+        };
+        assert!(!config.has_explicit_settings());
+    }
+
+    #[rstest]
+    #[case("alpha")]
+    #[case("beta")]
+    #[case("rc")]
+    fn test_valid_pre_release_labels(#[case] label: &str) {
+        let config = BranchRulesConfig {
+            pre_release_label: Some(label.to_string()),
+            ..BranchRulesConfig::default()
+        };
+        assert_eq!(config.pre_release_label, Some(label.to_string()));
+    }
+
+    #[rstest]
+    #[case(1)]
+    #[case(42)]
+    #[case(999)]
+    fn test_valid_pre_release_nums(#[case] num: u32) {
+        let config = BranchRulesConfig {
+            pre_release_num: Some(num),
+            ..BranchRulesConfig::default()
+        };
+        assert_eq!(config.pre_release_num, Some(num));
+    }
+
+    #[rstest]
+    #[case("commit")]
+    #[case("tag")]
+    fn test_valid_post_modes(#[case] mode: &str) {
+        let config = BranchRulesConfig {
+            post_mode: Some(mode.to_string()),
+            ..BranchRulesConfig::default()
+        };
+        assert_eq!(config.post_mode, Some(mode.to_string()));
+    }
+
+    mod branch_rules {
+        use super::*;
+        use crate::cli::flow::args::main::FlowArgs;
+        use crate::test_utils::zerv::ZervFixture;
+        use crate::version::zerv::core::Zerv;
+
+        /// Helper function to create a mock zerv object for tests
+        fn mock_zerv() -> Zerv {
+            let mut zerv = ZervFixture::new().build();
+            // Set a mock branch name for tests that need branch detection
+            zerv.vars.last_branch = Some("main".to_string());
+            zerv
+        }
+
+        #[test]
+        fn test_flow_args_default_has_gitflow_rules() {
+            let args = FlowArgs::default();
+            // Should have default GitFlow rules
+            assert!(
+                args.branch_config
+                    .branch_rules
+                    .find_rule("develop")
+                    .is_some()
+            );
+            assert!(
+                args.branch_config
+                    .branch_rules
+                    .find_rule("release/1")
+                    .is_some()
+            );
+        }
+
+        #[test]
+        fn test_flow_args_with_custom_branch_rules() {
+            let custom_ron = r#"[
+                (pattern: "main", pre_release_label: beta, pre_release_num: 1, post_mode: commit),
+                (pattern: "hotfix/*", pre_release_label: rc, post_mode: tag)
+            ]"#;
+
+            let custom_rules: BranchRules = custom_ron.parse().unwrap();
+            let args = FlowArgs {
+                branch_config: BranchRulesConfig {
+                    branch_rules: custom_rules,
+                    ..Default::default()
+                },
+                ..FlowArgs::default()
+            };
+
+            // Should have custom rules, not default GitFlow rules
+            assert!(args.branch_config.branch_rules.find_rule("main").is_some());
+            assert!(
+                args.branch_config
+                    .branch_rules
+                    .find_rule("hotfix/123")
+                    .is_some()
+            );
+            assert!(
+                args.branch_config
+                    .branch_rules
+                    .find_rule("develop")
+                    .is_none()
+            ); // Not in custom rules
+            assert!(
+                args.branch_config
+                    .branch_rules
+                    .find_rule("release/1")
+                    .is_none()
+            ); // Not in custom rules
+        }
+
+        #[test]
+        fn test_flow_args_validation_with_custom_branch_rules() {
+            let custom_ron = r#"[
+                (pattern: "develop", pre_release_label: beta, pre_release_num: 1, post_mode: commit),
+                (pattern: "release/*", pre_release_label: rc, post_mode: tag)
+            ]"#;
+
+            let mut args = FlowArgs {
+                branch_config: BranchRulesConfig {
+                    branch_rules: custom_ron.parse().unwrap(),
+                    ..Default::default()
+                },
+                ..FlowArgs::default()
+            };
+
+            // Validation should succeed even with custom branch rules
+            assert!(args.validate(&mock_zerv()).is_ok());
+        }
+    }
+}
diff --git a/src/cli/flow/args/bumps.rs b/src/cli/flow/args/bumps.rs
new file mode 100644
index 00000000..3534e2ea
--- /dev/null
+++ b/src/cli/flow/args/bumps.rs
@@ -0,0 +1,255 @@
+use super::FlowArgs;
+use crate::cli::utils::template::Template;
+use crate::utils::constants::post_modes;
+
+impl FlowArgs {
+    pub fn build_patch_bump_template(&self, content: &str) -> String {
+        let if_part = "{% if not pre_release and (dirty or distance) %}";
+        let else_part = "{% else %}None{% endif %}";
+        if_part.to_string() + content + else_part
+    }
+
+    pub fn build_pre_release_bump_template(&self, content: &str) -> String {
+        let if_part = "{% if dirty or distance %}";
+        let else_part = "{% else %}None{% endif %}";
+        if_part.to_string() + content + else_part
+    }
+
+    pub fn bump_pre_release_label(&self) -> Option<Template<String>> {
+        self.branch_config.pre_release_label.clone().map(|label| {
+            let template = self.build_pre_release_bump_template(&label);
+            Template::new(template)
+        })
+    }
+
+    pub fn bump_pre_release_num(&self) -> Option<Option<Template<u32>>> {
+        if self.branch_config.pre_release_label.is_none() {
+            None
+        } else {
+            let hash_len = self.hash_branch_len.to_string();
+
+            let pre_release_num_content = if let Some(num) = self.branch_config.pre_release_num {
+                num.to_string()
+            } else {
+                format!(
+                    "{{{{ hash_int(value=bumped_branch, length={}) }}}}",
+                    hash_len
+                )
+            };
+
+            let template = self.build_pre_release_bump_template(&pre_release_num_content);
+
+            Some(Some(Template::new(template)))
+        }
+    }
+
+    pub fn bump_patch(&self) -> Option<Option<Template<u32>>> {
+        let template = self.build_patch_bump_template("1");
+        Some(Some(Template::new(template)))
+    }
+
+    pub fn bump_post(&self) -> Option<Option<Template<u32>>> {
+        let content = match self
+            .branch_config
+            .post_mode
+            .as_deref()
+            .unwrap_or(post_modes::COMMIT)
+        {
+            post_modes::COMMIT => "{{ distance }}", // bump post by distance
+            post_modes::TAG => "1",                 // bump post by 1
+            _ => unreachable!("Invalid post_mode should have been caught by validation"),
+        };
+        let template = self.build_pre_release_bump_template(content);
+        Some(Some(Template::new(template)))
+    }
+
+    pub fn bump_dev(&self) -> Option<Option<Template<u32>>> {
+        let if_part = "{% if dirty %}";
+        let content = "{{ bumped_timestamp }}";
+        let else_part = "{% else %}None{% endif %}";
+        let template = format!("{}{}{}", if_part, content, else_part);
+        Some(Some(Template::new(template)))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use rstest::*;
+
+    use super::*;
+    use crate::cli::flow::args::branch_rules::BranchRulesConfig;
+    use crate::test_utils::zerv::ZervFixture;
+    use crate::version::zerv::core::Zerv;
+
+    /// Helper function to create a mock zerv object for tests
+    fn mock_zerv() -> Zerv {
+        let mut zerv = ZervFixture::new().build();
+        // Set a mock branch name for tests that need branch detection
+        zerv.vars.last_branch = Some("main".to_string());
+        zerv
+    }
+
+    mod bump_pre_release_label {
+        use super::*;
+
+        #[test]
+        fn test_default_returns_alpha() {
+            let mut args = FlowArgs::default();
+            args.validate(&mock_zerv()).unwrap(); // This sets the default pre_release_label
+            let expected = args.build_pre_release_bump_template("alpha");
+            assert_eq!(args.bump_pre_release_label(), Some(Template::new(expected)));
+        }
+
+        #[rstest]
+        #[case("beta")]
+        #[case("rc")]
+        fn test_custom_label_returned(#[case] label: &str) {
+            let args = FlowArgs {
+                branch_config: BranchRulesConfig {
+                    pre_release_label: Some(label.to_string()),
+                    ..Default::default()
+                },
+                ..FlowArgs::default()
+            };
+            let expected = args.build_pre_release_bump_template(label);
+            assert_eq!(args.bump_pre_release_label(), Some(Template::new(expected)));
+        }
+    }
+
+    mod bump_pre_release_num {
+        use super::*;
+
+        #[test]
+        fn test_default_returns_template() {
+            let args = FlowArgs {
+                branch_config: BranchRulesConfig {
+                    pre_release_label: Some("alpha".to_string()), // Need a pre-release label for bump_pre_release_num to return template
+                    ..Default::default()
+                },
+                ..FlowArgs::default()
+            };
+            let result = args.bump_pre_release_num();
+            assert!(result.is_some());
+            assert!(result.unwrap().is_some()); // Should be Some(Template)
+        }
+
+        #[rstest]
+        #[case(5)]
+        #[case(123)]
+        #[case(999)]
+        fn test_custom_num_returns_value(#[case] num: u32) {
+            let args = FlowArgs {
+                branch_config: BranchRulesConfig {
+                    pre_release_label: Some("alpha".to_string()), // Need a pre-release label for bump_pre_release_num to return template
+                    pre_release_num: Some(num),
+                    ..Default::default()
+                },
+                ..FlowArgs::default()
+            };
+            let result = args.bump_pre_release_num();
+            assert!(result.is_some());
+            let template = result.unwrap().unwrap();
+
+            // Generate expected template using the helper function
+            let expected = args.build_pre_release_bump_template(&num.to_string());
+            assert_eq!(template.as_str(), expected);
+        }
+
+        #[rstest]
+        #[case(3)]
+        #[case(7)]
+        #[case(5)]
+        fn test_template_uses_hash_branch_len(#[case] length: u32) {
+            let args = FlowArgs {
+                branch_config: BranchRulesConfig {
+                    pre_release_label: Some("alpha".to_string()), // Need a pre-release label for bump_pre_release_num to return template
+                    ..Default::default()
+                },
+                hash_branch_len: length,
+                ..FlowArgs::default()
+            };
+            let result = args.bump_pre_release_num();
+            assert!(result.is_some());
+            let template = result.unwrap().unwrap();
+
+            // Generate expected template from input
+            let content = format!("{{{{ hash_int(value=bumped_branch, length={}) }}}}", length);
+            let expected = args.build_pre_release_bump_template(&content);
+            assert_eq!(template.as_str(), expected);
+        }
+    }
+
+    mod bump_post {
+        use super::*;
+
+        #[rstest]
+        #[case(post_modes::COMMIT, "{{ distance }}")]
+        #[case(post_modes::TAG, "1")]
+        fn test_bump_post_templates(#[case] mode: &str, #[case] expected_content: &str) {
+            let args = FlowArgs {
+                branch_config: BranchRulesConfig {
+                    post_mode: Some(mode.to_string()),
+                    pre_release_label: Some("alpha".to_string()), // Need a pre-release label
+                    ..Default::default()
+                },
+                ..FlowArgs::default()
+            };
+
+            let result = args.bump_post();
+            assert!(result.is_some());
+            let template_result = result.unwrap();
+            assert!(template_result.is_some());
+            let template = template_result.unwrap();
+
+            let expected = args.build_pre_release_bump_template(expected_content);
+            assert_eq!(template.as_str(), expected);
+        }
+
+        #[test]
+        fn test_bump_post_commit_mode_default() {
+            let args = FlowArgs::default();
+            let result = args.bump_post();
+            assert!(result.is_some());
+
+            let template_result = result.unwrap();
+            assert!(template_result.is_some());
+            let template = template_result.unwrap();
+            let expected = args.build_pre_release_bump_template("{{ distance }}");
+            assert_eq!(template.as_str(), expected);
+        }
+
+        #[test]
+        #[should_panic(expected = "Invalid post_mode should have been caught by validation")]
+        fn test_bump_post_invalid_mode_panics() {
+            let args = FlowArgs {
+                branch_config: BranchRulesConfig {
+                    post_mode: Some("invalid".to_string()),
+                    ..Default::default()
+                },
+                ..FlowArgs::default()
+            };
+
+            // This should panic because invalid post_mode should be caught by validation
+            args.bump_post();
+        }
+    }
+
+    mod bump_dev {
+        use super::*;
+
+        #[test]
+        fn test_bump_dev_always_returns_template() {
+            let args = FlowArgs::default();
+            let result = args.bump_dev();
+            assert!(result.is_some());
+            let template_result = result.unwrap();
+            assert!(template_result.is_some());
+            let template = template_result.unwrap();
+
+            assert_eq!(
+                template.as_str(),
+                "{% if dirty %}{{ bumped_timestamp }}{% else %}None{% endif %}"
+            );
+        }
+    }
+}
diff --git a/src/cli/flow/args/main.rs b/src/cli/flow/args/main.rs
index c3d0d8a7..b3057eec 100644
--- a/src/cli/flow/args/main.rs
+++ b/src/cli/flow/args/main.rs
@@ -3,16 +3,8 @@ use clap::Parser;
 use crate::cli::common::args::{
     InputConfig,
     OutputConfig,
-    Validation as CommonValidation,
-};
-use crate::cli::utils::template::Template;
-use crate::error::ZervError;
-use crate::utils::bool_resolution::BoolResolution;
-use crate::utils::constants::pre_release_labels::ALPHA;
-use crate::utils::constants::{
-    post_modes,
-    pre_release_labels,
 };
+use crate::cli::flow::args::branch_rules::BranchRulesConfig;
 
 /// Generate version with intelligent pre-release management based on Git branch patterns
 #[derive(Parser)]
@@ -35,17 +27,15 @@ PRE-RELEASE OPTIONS:
   --pre-release-label <LBL> Pre-release label: alpha (default), beta, rc
   --pre-release-num <NUM>   Pre-release number: integer (default: {{hash_int bumped_branch HASH_BRANCH_LEN}})
   --hash-branch-len <LEN>   Hash length for bumped branch hash (1-10, default: 5)
-  --no-pre-release          Disable pre-release entirely
 
 POST MODE OPTIONS:
   --post-mode <MODE>        Post calculation mode: commit (default), tag
 
-DEV TIMESTAMP OPTIONS:
-  --dev-ts                  Include dev timestamp for dirty working directory
-  --no-dev-ts               Exclude dev timestamp from output
+SCHEMA OPTIONS:
+  --schema <SCHEMA>         Schema variant for output components [default: standard] [possible values: standard, standard-no-context, standard-context, standard-base, standard-base-prerelease, standard-base-prerelease-post, standard-base-prerelease-post-dev]
 
 EXAMPLES:
-  # Basic flow version with automatic pre-release detection
+  # Basic flow version with automatic pre-release detection (smart schema)
   zerv flow
 
   # Different output formats
@@ -56,15 +46,17 @@ EXAMPLES:
   # Pre-release control
   zerv flow --pre-release-label beta
   zerv flow --pre-release-label rc --pre-release-num 5
-  zerv flow --no-pre-release
 
   # Post mode control
   zerv flow --post-mode commit  # bump post by distance (default)
   zerv flow --post-mode tag     # bump post by 1
 
-  # Dev timestamp control
-  zerv flow --dev-ts            # include dev timestamp for dirty working directory
-  zerv flow --no-dev-ts         # exclude dev timestamp from output
+  # Schema control (replaces --dev-ts, --no-dev-ts, --no-pre-release flags)
+  zerv flow --schema standard              # smart context (default)
+  zerv flow --schema standard-no-context   # never include context
+  zerv flow --schema standard-context      # always include context
+  zerv flow --schema standard-base         # base version only
+  zerv flow --schema standard-base-prerelease-post  # prerelease + post only
 
   # Use in different directory
   zerv flow -C /path/to/repo"
@@ -77,17 +69,8 @@ pub struct FlowArgs {
     #[command(flatten)]
     pub output: OutputConfig,
 
-    /// Pre-release label for flow versions (alpha, beta, rc)
-    #[arg(long, value_parser = clap::builder::PossibleValuesParser::new(pre_release_labels::VALID_LABELS),
-          help = "Pre-release label for flow versions (alpha, beta, rc)")]
-    pub pre_release_label: Option<String>,
-
-    #[arg(
-        long,
-        value_parser = clap::value_parser!(u32),
-        help = "Pre-release number for flow versions (integer, default: {{ hash_int(value=bumped_branch, length=HASH_BRANCH_LEN) }})"
-    )]
-    pub pre_release_num: Option<u32>,
+    #[command(flatten)]
+    pub branch_config: BranchRulesConfig,
 
     #[arg(
         long = "hash-branch-len",
@@ -97,25 +80,19 @@ pub struct FlowArgs {
     )]
     pub hash_branch_len: u32,
 
-    /// Disable pre-release entirely (no pre-release component)
-    #[arg(long, action = clap::ArgAction::SetTrue,
-          help = "Disable pre-release entirely (no pre-release component)")]
-    pub no_pre_release: bool,
-
-    /// Post calculation mode (commit, tag)
-    #[arg(long = "post-mode", value_parser = clap::builder::PossibleValuesParser::new(post_modes::VALID_MODES),
-          default_value = post_modes::COMMIT, help = "Post calculation mode (commit, tag)")]
-    pub post_mode: String,
-
-    /// Include dev timestamp for dirty working directory (auto-detect by default)
-    #[arg(long = "dev-ts", action = clap::ArgAction::SetTrue,
-          help = "Include dev timestamp for dirty working directory")]
-    pub dev_ts: bool,
-
-    /// Exclude dev timestamp from output
-    #[arg(long = "no-dev-ts", action = clap::ArgAction::SetTrue,
-          help = "Exclude dev timestamp from output")]
-    pub no_dev_ts: bool,
+    /// Schema variant for output components [default: standard]
+    #[arg(
+        long,
+        help = "Schema variant for output components [default: standard] [possible values: standard, standard-no-context, standard-context, standard-base, standard-base-prerelease, standard-base-prerelease-post, standard-base-prerelease-post-dev]"
+    )]
+    pub schema: Option<String>,
+
+    /// Override the detected current branch name
+    #[arg(
+        long,
+        help = "Override current branch name (used for template hashing)"
+    )]
+    pub bumped_branch: Option<String>,
 }
 
 impl Default for FlowArgs {
@@ -123,145 +100,10 @@ impl Default for FlowArgs {
         Self {
             input: InputConfig::default(),
             output: OutputConfig::default(),
-            pre_release_label: None,
-            pre_release_num: None,
+            branch_config: BranchRulesConfig::default(),
             hash_branch_len: 5,
-            no_pre_release: false,
-            post_mode: post_modes::COMMIT.to_string(),
-            dev_ts: true,
-            no_dev_ts: false,
-        }
-    }
-}
-
-impl FlowArgs {
-    pub fn build_patch_bump_template(&self, content: &str) -> String {
-        let if_part = "{% if pre_release and (dirty or distance) %}";
-        let else_part = "{% else %}None{% endif %}";
-        if_part.to_string() + content + else_part
-    }
-    pub fn build_pre_release_bump_template(&self, content: &str) -> String {
-        let if_part = "{% if dirty or distance %}";
-        let else_part = "{% else %}None{% endif %}";
-        if_part.to_string() + content + else_part
-    }
-
-    pub fn validate(&mut self) -> Result<(), ZervError> {
-        // Use shared validation for input/output
-        CommonValidation::validate_io(&self.input, &self.output)?;
-
-        self.validate_pre_release_label()?;
-        self.validate_pre_release_num()?;
-        self.validate_hash_branch_len()?;
-        self.validate_post_mode()?;
-        self.validate_dev_ts()?;
-
-        // Resolve dev_ts flag in place after validation
-        if let Some(resolved) = BoolResolution::resolve_opposing_flags(self.dev_ts, self.no_dev_ts)
-        {
-            self.dev_ts = resolved;
-        }
-
-        Ok(())
-    }
-
-    fn validate_pre_release_label(&mut self) -> Result<(), ZervError> {
-        if self.no_pre_release && self.pre_release_label.is_some() {
-            return Err(ZervError::InvalidArgument(
-                "Cannot use --pre-release-label with --no-pre-release".to_string(),
-            ));
-        } else if !self.no_pre_release && self.pre_release_label.is_none() {
-            self.pre_release_label = Some(ALPHA.to_string());
-        }
-        Ok(())
-    }
-
-    fn validate_pre_release_num(&self) -> Result<(), ZervError> {
-        if self.no_pre_release && self.pre_release_num.is_some() {
-            return Err(ZervError::InvalidArgument(
-                "Cannot use --pre-release-num with --no-pre-release".to_string(),
-            ));
-        }
-        Ok(())
-    }
-
-    fn validate_hash_branch_len(&self) -> Result<(), ZervError> {
-        if self.hash_branch_len == 0 || self.hash_branch_len > 10 {
-            return Err(ZervError::InvalidArgument(format!(
-                "hash-branch-len must be between 1 and 10, got {}",
-                self.hash_branch_len
-            )));
-        }
-        Ok(())
-    }
-
-    fn validate_post_mode(&self) -> Result<(), ZervError> {
-        if !post_modes::VALID_MODES.contains(&self.post_mode.as_str()) {
-            return Err(ZervError::InvalidArgument(format!(
-                "post-mode must be one of: {}, got {}",
-                post_modes::VALID_MODES.join(", "),
-                self.post_mode
-            )));
-        }
-        Ok(())
-    }
-
-    fn validate_dev_ts(&self) -> Result<(), ZervError> {
-        BoolResolution::validate_opposing_flags(self.dev_ts, self.no_dev_ts, "dev-ts")
-    }
-
-    pub fn bump_pre_release_label(&self) -> Option<Template<String>> {
-        self.pre_release_label.clone().map(|label| {
-            let template = self.build_pre_release_bump_template(&label);
-            Template::new(template)
-        })
-    }
-
-    pub fn bump_pre_release_num(&self) -> Option<Option<Template<u32>>> {
-        if self.no_pre_release || self.pre_release_label.is_none() {
-            None
-        } else {
-            {
-                let hash_len = self.hash_branch_len.to_string();
-
-                let pre_release_num_content = if let Some(num) = self.pre_release_num {
-                    num.to_string()
-                } else {
-                    format!(
-                        "{{{{ hash_int(value=bumped_branch, length={}) }}}}",
-                        hash_len
-                    )
-                };
-
-                let template = self.build_pre_release_bump_template(&pre_release_num_content);
-
-                Some(Some(Template::new(template)))
-            }
-        }
-    }
-
-    pub fn bump_patch(&self) -> Option<Option<Template<u32>>> {
-        let template = self.build_patch_bump_template("1");
-        Some(Some(Template::new(template)))
-    }
-
-    pub fn bump_post(&self) -> Option<Option<Template<u32>>> {
-        let content = match self.post_mode.as_str() {
-            post_modes::COMMIT => "{{ distance }}", // bump post by distance
-            post_modes::TAG => "1",                 // bump post by 1
-            _ => unreachable!("Invalid post_mode should have been caught by validation"),
-        };
-        let template = self.build_pre_release_bump_template(content);
-        Some(Some(Template::new(template)))
-    }
-
-    pub fn bump_dev(&self) -> Option<Option<Template<u32>>> {
-        if self.dev_ts {
-            let content = "{{ bumped_timestamp }}";
-            let template = self.build_pre_release_bump_template(content);
-            Some(Some(Template::new(template)))
-        } else {
-            None
+            schema: None,
+            bumped_branch: None,
         }
     }
 }
@@ -271,10 +113,17 @@ mod tests {
     use rstest::*;
 
     use super::*;
-    use crate::cli::common::args::{
-        InputConfig,
-        OutputConfig,
-    };
+    use crate::cli::flow::args::branch_rules::BranchRulesConfig;
+    use crate::test_utils::zerv::ZervFixture;
+    use crate::version::zerv::core::Zerv;
+
+    /// Helper function to create a mock zerv object for tests
+    fn mock_zerv() -> Zerv {
+        let mut zerv = ZervFixture::new().build();
+        // Set a mock branch name for tests that need branch detection
+        zerv.vars.last_branch = Some("main".to_string());
+        zerv
+    }
 
     mod defaults {
         use super::*;
@@ -285,200 +134,18 @@ mod tests {
             assert_eq!(args.input.source, "git");
             assert_eq!(args.output.output_format, "semver");
             assert_eq!(args.hash_branch_len, 5);
-            assert!(args.pre_release_label.is_none());
-            assert!(args.pre_release_num.is_none());
-            assert!(!args.no_pre_release);
-            assert_eq!(args.post_mode, post_modes::COMMIT);
-            assert!(args.dev_ts); // Default is true
-            assert!(!args.no_dev_ts);
+            assert!(args.branch_config.pre_release_label.is_none());
+            assert!(args.branch_config.pre_release_num.is_none());
+            assert_eq!(args.branch_config.post_mode, None);
+            assert!(args.schema.is_none()); // Default is None (will use standard schema)
+            assert!(args.bumped_branch.is_none()); // Default is None (use detected branch)
         }
 
         #[test]
         fn test_flow_args_validation_success() {
             let mut args = FlowArgs::default();
-            assert!(args.validate().is_ok());
-            assert!(args.dev_ts);
-            assert!(!args.no_dev_ts);
-        }
-    }
-
-    mod validation {
-        use super::*;
-
-        #[rstest]
-        #[case("alpha")]
-        #[case("beta")]
-        #[case("rc")]
-        fn test_valid_pre_release_labels(#[case] label: &str) {
-            let mut args = FlowArgs {
-                pre_release_label: Some(label.to_string()),
-                ..FlowArgs::default()
-            };
-            assert!(args.validate().is_ok());
-        }
-
-        #[rstest]
-        #[case(1)]
-        #[case(5)]
-        #[case(10)]
-        fn test_valid_hash_branch_lengths(#[case] length: u32) {
-            let mut args = FlowArgs {
-                hash_branch_len: length,
-                ..FlowArgs::default()
-            };
-            assert!(args.validate().is_ok());
-        }
-
-        #[rstest]
-        #[case(post_modes::COMMIT)]
-        #[case(post_modes::TAG)]
-        fn test_valid_post_modes(#[case] mode: &str) {
-            let mut args = FlowArgs {
-                post_mode: mode.to_string(),
-                ..FlowArgs::default()
-            };
-            assert!(args.validate().is_ok());
-        }
-
-        #[rstest]
-        #[case(0)]
-        #[case(11)]
-        #[case(20)]
-        fn test_invalid_hash_branch_lengths(#[case] length: u32) {
-            let mut args = FlowArgs {
-                hash_branch_len: length,
-                ..FlowArgs::default()
-            };
-            let result = args.validate();
-            assert!(result.is_err());
-            assert!(
-                result
-                    .unwrap_err()
-                    .to_string()
-                    .contains("hash-branch-len must be between 1 and 10")
-            );
-        }
-
-        #[rstest]
-        #[case("invalid")]
-        #[case("commit-invalid")]
-        #[case("tag-invalid")]
-        #[case("")]
-        fn test_invalid_post_modes(#[case] mode: &str) {
-            let mut args = FlowArgs {
-                post_mode: mode.to_string(),
-                ..FlowArgs::default()
-            };
-            let result = args.validate();
-            assert!(result.is_err());
-            assert!(
-                result
-                    .unwrap_err()
-                    .to_string()
-                    .contains("post-mode must be one of:")
-            );
-        }
-
-        #[rstest]
-        #[case(Some("beta".to_string()), None, true, "Cannot use --pre-release-label with --no-pre-release")] // label + no_pre_release
-        #[case(
-            None,
-            Some(5),
-            true,
-            "Cannot use --pre-release-num with --no-pre-release"
-        )] // num + no_pre_release
-        #[case(Some("rc".to_string()), Some(10), true, "Cannot use --pre-release-label with --no-pre-release")] // both + no_pre_release (first error)
-        fn test_no_pre_release_conflicts(
-            #[case] label: Option<String>,
-            #[case] num: Option<u32>,
-            #[case] no_pre_release: bool,
-            #[case] expected_error: &str,
-        ) {
-            let mut args = FlowArgs {
-                pre_release_label: label,
-                pre_release_num: num,
-                no_pre_release,
-                ..FlowArgs::default()
-            };
-            let result = args.validate();
-            assert!(result.is_err());
-            assert!(result.unwrap_err().to_string().contains(expected_error));
-        }
-
-        #[rstest]
-        #[case(Some("beta".to_string()), Some(5), false)]
-        #[case(None, None, true)]
-        #[case(Some("rc".to_string()), None, false)]
-        #[case(None, Some(10), false)]
-        fn test_valid_combinations(
-            #[case] label: Option<String>,
-            #[case] num: Option<u32>,
-            #[case] no_pre_release: bool,
-        ) {
-            let mut args = FlowArgs {
-                pre_release_label: label,
-                pre_release_num: num,
-                no_pre_release,
-                ..FlowArgs::default()
-            };
-            assert!(args.validate().is_ok());
-        }
-
-        #[test]
-        fn test_invalid_dev_ts_combination() {
-            let mut args = FlowArgs {
-                dev_ts: true,
-                no_dev_ts: true,
-                ..FlowArgs::default()
-            };
-            let result = args.validate();
-            assert!(result.is_err());
-            assert!(
-                result
-                    .unwrap_err()
-                    .to_string()
-                    .contains("Cannot use --dev-ts with --no-dev-ts")
-            );
-        }
-
-        #[test]
-        fn test_dev_ts_resolution_after_validation() {
-            let mut args = FlowArgs {
-                dev_ts: true,
-                no_dev_ts: false,
-                ..FlowArgs::default()
-            };
-            args.validate().unwrap();
-            assert!(args.dev_ts); // Should remain true
-
-            let mut args = FlowArgs {
-                dev_ts: false,
-                no_dev_ts: true,
-                ..FlowArgs::default()
-            };
-            args.validate().unwrap();
-            assert!(!args.dev_ts); // Should remain false
-
-            let mut args = FlowArgs {
-                dev_ts: false,
-                no_dev_ts: false,
-                ..FlowArgs::default()
-            };
-            args.validate().unwrap();
-            assert!(!args.dev_ts); // Should remain false for auto-detect
-        }
-
-        #[rstest]
-        #[case(true, false)] // dev_ts only
-        #[case(false, true)] // no_dev_ts only
-        #[case(false, false)] // neither (auto-detect)
-        fn test_valid_dev_ts_combinations(#[case] dev_ts: bool, #[case] no_dev_ts: bool) {
-            let mut args = FlowArgs {
-                dev_ts,
-                no_dev_ts,
-                ..FlowArgs::default()
-            };
-            assert!(args.validate().is_ok());
+            assert!(args.validate(&mock_zerv()).is_ok());
+            assert!(args.schema.is_none()); // Should remain None after validation
         }
     }
 
@@ -503,123 +170,7 @@ mod tests {
             assert_eq!(args.input.source, "git");
             assert_eq!(args.output.output_format, "zerv");
             assert_eq!(args.output.output_prefix, Some("v".to_string()));
-            assert!(args.validate().is_ok());
-        }
-    }
-
-    mod bump_pre_release_label {
-        use super::*;
-
-        // #[test]
-        // TODO: after resolve terra issue
-        // fn test_default_returns_alpha() {
-        //     let mut args = FlowArgs::default();
-        //     args.validate().unwrap(); // This sets the default pre_release_label
-        //     let expected = args.build_patch_bump_template("alpha");
-        //     assert_eq!(args.bump_pre_release_label(), Some(Template::new(expected)));
-        // }
-
-        #[rstest]
-        #[case("beta")]
-        #[case("rc")]
-        fn test_custom_label_returned(#[case] label: &str) {
-            let args = FlowArgs {
-                pre_release_label: Some(label.to_string()),
-                ..FlowArgs::default()
-            };
-            let expected = args.build_pre_release_bump_template(label);
-            assert_eq!(args.bump_pre_release_label(), Some(Template::new(expected)));
-        }
-
-        #[test]
-        fn test_default_alpha_when_no_pre_release_false_and_label_none() {
-            // Test the specific case: no_pre_release=false AND pre_release_label=None => returns alpha
-            let mut args = FlowArgs {
-                no_pre_release: false,
-                pre_release_label: None,
-                ..FlowArgs::default()
-            };
-            // Before validation, pre_release_label should be None
-            assert_eq!(args.pre_release_label, None);
-
-            args.validate().unwrap(); // This sets the default pre_release_label
-
-            // After validation, pre_release_label should be set to "alpha"
-            assert_eq!(args.pre_release_label, Some("alpha".to_string()));
-            let expected = args.build_pre_release_bump_template("alpha");
-            assert_eq!(args.bump_pre_release_label(), Some(Template::new(expected)));
-        }
-
-        #[test]
-        fn test_disabled_returns_none() {
-            let args = FlowArgs {
-                no_pre_release: true,
-                ..FlowArgs::default()
-            };
-            assert_eq!(args.bump_pre_release_label(), None);
-        }
-    }
-
-    mod bump_pre_release_num {
-        use super::*;
-
-        #[test]
-        fn test_default_returns_template() {
-            let args = FlowArgs {
-                pre_release_label: Some("alpha".to_string()), // Need a pre-release label for bump_pre_release_num to return template
-                ..FlowArgs::default()
-            };
-            let result = args.bump_pre_release_num();
-            assert!(result.is_some());
-            assert!(result.unwrap().is_some()); // Should be Some(Template)
-        }
-
-        #[rstest]
-        #[case(5)]
-        #[case(123)]
-        #[case(999)]
-        fn test_custom_num_returns_value(#[case] num: u32) {
-            let args = FlowArgs {
-                pre_release_label: Some("alpha".to_string()), // Need a pre-release label for bump_pre_release_num to return template
-                pre_release_num: Some(num),
-                ..FlowArgs::default()
-            };
-            let result = args.bump_pre_release_num();
-            assert!(result.is_some());
-            let template = result.unwrap().unwrap();
-
-            // Generate expected template using the helper function
-            let expected = args.build_pre_release_bump_template(&num.to_string());
-            assert_eq!(template.as_str(), expected);
-        }
-
-        #[test]
-        fn test_disabled_returns_none() {
-            let args = FlowArgs {
-                no_pre_release: true,
-                ..FlowArgs::default()
-            };
-            assert_eq!(args.bump_pre_release_num(), None);
-        }
-
-        #[rstest]
-        #[case(3)]
-        #[case(7)]
-        #[case(5)]
-        fn test_template_uses_hash_branch_len(#[case] length: u32) {
-            let args = FlowArgs {
-                pre_release_label: Some("alpha".to_string()), // Need a pre-release label for bump_pre_release_num to return template
-                hash_branch_len: length,
-                ..FlowArgs::default()
-            };
-            let result = args.bump_pre_release_num();
-            assert!(result.is_some());
-            let template = result.unwrap().unwrap();
-
-            // Generate expected template from input
-            let content = format!("{{{{ hash_int(value=bumped_branch, length={}) }}}}", length);
-            let expected = args.build_pre_release_bump_template(&content);
-            assert_eq!(template.as_str(), expected);
+            assert!(args.validate(&mock_zerv()).is_ok());
         }
     }
 
@@ -637,205 +188,64 @@ mod tests {
             // Note: clap's PossibleValuesParser handles validation at parsing time
             // This test demonstrates what happens when invalid values are somehow set
             let mut args = FlowArgs {
-                pre_release_label: Some(invalid_label.to_string()),
+                branch_config: BranchRulesConfig {
+                    pre_release_label: Some(invalid_label.to_string()),
+                    ..Default::default()
+                },
                 ..FlowArgs::default()
             };
 
             // Note: Our current validation only checks structural constraints, not value constraints
             // The clap argument parser would catch invalid values before they reach validate()
             // This test shows the validation passes but the values would be rejected by clap
-            assert!(args.validate().is_ok());
-        }
-    }
-
-    mod bump_post {
-        use super::*;
-
-        #[rstest]
-        #[case(post_modes::COMMIT, "{{ distance }}")]
-        #[case(post_modes::TAG, "1")]
-        fn test_bump_post_templates(#[case] mode: &str, #[case] expected_content: &str) {
-            let args = FlowArgs {
-                post_mode: mode.to_string(),
-                pre_release_label: Some("alpha".to_string()), // Need a pre-release label
-                ..FlowArgs::default()
-            };
-
-            let result = args.bump_post();
-            assert!(result.is_some());
-            let template_result = result.unwrap();
-            assert!(template_result.is_some());
-            let template = template_result.unwrap();
-
-            let expected = args.build_pre_release_bump_template(expected_content);
-            assert_eq!(template.as_str(), expected);
-        }
-
-        #[test]
-        fn test_bump_post_returns_none_when_no_pre_release() {
-            let args = FlowArgs {
-                no_pre_release: true,
-                ..FlowArgs::default()
-            };
-
-            // When no_pre_release is true, bump_post should still return a template
-            // because it's used in the BumpsConfig regardless of pre_release state
-            let result = args.bump_post();
-            assert!(result.is_some());
-            let template_result = result.unwrap();
-            assert!(template_result.is_some());
-            let template = template_result.unwrap();
-            // Just verify it returns a valid template
-            assert!(!template.as_str().is_empty());
-        }
-
-        #[test]
-        fn test_bump_post_commit_mode_default() {
-            let args = FlowArgs::default();
-            let result = args.bump_post();
-            assert!(result.is_some());
-
-            let template_result = result.unwrap();
-            assert!(template_result.is_some());
-            let template = template_result.unwrap();
-            let expected = args.build_pre_release_bump_template("{{ distance }}");
-            assert_eq!(template.as_str(), expected);
-        }
-
-        #[test]
-        #[should_panic(expected = "Invalid post_mode should have been caught by validation")]
-        fn test_bump_post_invalid_mode_panics() {
-            let args = FlowArgs {
-                post_mode: "invalid".to_string(),
-                ..FlowArgs::default()
-            };
-
-            // This should panic because invalid post_mode should be caught by validation
-            args.bump_post();
+            assert!(args.validate(&mock_zerv()).is_ok());
         }
     }
 
-    mod bump_dev {
+    mod integration {
         use super::*;
 
         #[test]
-        fn test_bump_dev_with_dev_ts_flag() {
-            let args = FlowArgs {
-                dev_ts: true,
-                no_dev_ts: false,
-                pre_release_label: Some("alpha".to_string()), // Need a pre-release label
-                ..FlowArgs::default()
-            };
-
-            let result = args.bump_dev();
-            assert!(result.is_some());
-            let template_result = result.unwrap();
-            assert!(template_result.is_some());
-            let template = template_result.unwrap();
-
-            let expected = args.build_pre_release_bump_template("{{ bumped_timestamp }}");
-            assert_eq!(template.as_str(), expected);
-        }
-
-        #[test]
-        fn test_bump_dev_with_no_dev_ts_flag() {
-            let args = FlowArgs {
-                dev_ts: false,
-                no_dev_ts: true,
-                ..FlowArgs::default()
-            };
+        fn test_integration_with_branch_rules_and_manual_overrides() {
+            let custom_ron = r#"[
+                (pattern: "develop", pre_release_label: beta, pre_release_num: 1, post_mode: commit),
+                (pattern: "release/*", pre_release_label: rc, post_mode: tag)
+            ]"#;
 
-            let result = args.bump_dev();
-            assert!(result.is_none()); // Should return None to disable dev component
-        }
-
-        #[test]
-        fn test_bump_dev_with_auto_detect() {
-            let args = FlowArgs {
-                dev_ts: false,
-                no_dev_ts: false,
-                ..FlowArgs::default()
-            };
-
-            let result = args.bump_dev();
-            assert!(result.is_none()); // Should return None for auto-detect behavior
-        }
-
-        #[test]
-        fn test_bump_dev_with_invalid_state() {
-            let args = FlowArgs {
-                dev_ts: true,
-                no_dev_ts: true, // Invalid combination
+            let mut args = FlowArgs {
+                branch_config: BranchRulesConfig {
+                    branch_rules: custom_ron.parse().unwrap(),
+                    pre_release_label: Some("alpha".to_string()), // Manual override
+                    pre_release_num: Some(42),                    // Manual override
+                    post_mode: Some("tag".to_string()),           // Manual override
+                },
                 ..FlowArgs::default()
             };
 
-            // Even with invalid state, bump_dev should work based on current dev_ts value
-            // (validation would catch this before bump_dev is called in practice)
-            let result = args.bump_dev();
-            assert!(result.is_some()); // dev_ts is true, so should return timestamp template
-        }
-    }
-
-    mod integration {
-        use super::*;
+            // Should validate successfully - branch rules and manual overrides can coexist
+            assert!(args.validate(&mock_zerv()).is_ok());
 
-        #[rstest]
-        #[case("alpha", Some(5), 3, post_modes::COMMIT)]
-        #[case("beta", None, 7, post_modes::TAG)]
-        #[case("rc", Some(10), 1, post_modes::COMMIT)]
-        fn test_complete_configuration(
-            #[case] label: &str,
-            #[case] num: Option<u32>,
-            #[case] hash_len: u32,
-            #[case] post_mode: &str,
-        ) {
-            let mut args = FlowArgs {
-                pre_release_label: Some(label.to_string()),
-                pre_release_num: num,
-                hash_branch_len: hash_len,
-                post_mode: post_mode.to_string(),
-                ..FlowArgs::default()
-            };
+            // Manual overrides should be preserved
+            assert_eq!(
+                args.branch_config.pre_release_label,
+                Some("alpha".to_string())
+            );
+            assert_eq!(args.branch_config.pre_release_num, Some(42));
+            assert_eq!(args.branch_config.post_mode, Some("tag".to_string()));
 
-            // Test validation
-            assert!(args.validate().is_ok());
-
-            // Test bump_pre_release_label
-            let expected = args.build_pre_release_bump_template(label);
-            assert_eq!(args.bump_pre_release_label(), Some(Template::new(expected)));
-
-            // Test bump_pre_release_num
-            let result = args.bump_pre_release_num();
-            assert!(result.is_some());
-
-            if let Some(num_value) = num {
-                let template = result.unwrap().unwrap();
-                let expected = args.build_pre_release_bump_template(&num_value.to_string());
-                assert_eq!(template.as_str(), expected);
-            } else {
-                let template = result.unwrap().unwrap();
-                let content = format!(
-                    "{{{{ hash_int(value=bumped_branch, length={}) }}}}",
-                    hash_len
-                );
-                let expected = args.build_pre_release_bump_template(&content);
-                assert_eq!(template.as_str(), expected);
-            }
-
-            // Test bump_post with the specified post_mode
-            let post_result = args.bump_post();
-            assert!(post_result.is_some());
-            let post_template_result = post_result.unwrap();
-            assert!(post_template_result.is_some());
-            let post_template = post_template_result.unwrap();
-
-            let expected_post_content = match post_mode {
-                post_modes::COMMIT => "{{ distance }}",
-                post_modes::TAG => "1",
-                _ => "{{ distance }}",
-            };
-            let expected_post = args.build_pre_release_bump_template(expected_post_content);
-            assert_eq!(post_template.as_str(), expected_post);
+            // Branch rules should still be available for validation logic
+            assert!(
+                args.branch_config
+                    .branch_rules
+                    .find_rule("develop")
+                    .is_some()
+            );
+            assert!(
+                args.branch_config
+                    .branch_rules
+                    .find_rule("release/1")
+                    .is_some()
+            );
         }
     }
 }
diff --git a/src/cli/flow/args/mod.rs b/src/cli/flow/args/mod.rs
index ff654d4f..83cb4e55 100644
--- a/src/cli/flow/args/mod.rs
+++ b/src/cli/flow/args/mod.rs
@@ -1,3 +1,7 @@
+pub mod branch_rules;
+pub mod bumps;
 pub mod main;
+pub mod validation;
+pub mod version_args;
 
 pub use main::FlowArgs;
diff --git a/src/cli/flow/args/validation.rs b/src/cli/flow/args/validation.rs
new file mode 100644
index 00000000..9f8eacd9
--- /dev/null
+++ b/src/cli/flow/args/validation.rs
@@ -0,0 +1,267 @@
+use std::str::FromStr;
+
+use super::FlowArgs;
+use crate::cli::common::args::Validation as CommonValidation;
+use crate::error::ZervError;
+use crate::schema::ZervSchemaPreset;
+use crate::utils::constants::pre_release_labels::ALPHA;
+use crate::version::zerv::core::Zerv;
+
+impl FlowArgs {
+    pub fn validate(&mut self, current_zerv: &Zerv) -> Result<(), ZervError> {
+        // Use shared validation for input/output
+        CommonValidation::validate_io(&self.input, &self.output)?;
+
+        // Apply branch rules first to set proper defaults based on branch patterns
+        self.branch_config.apply_branch_rules(current_zerv)?;
+
+        // Validate and set defaults only for values not already set by branch rules
+        self.validate_pre_release_label()?;
+        self.validate_pre_release_num()?;
+        self.validate_hash_branch_len()?;
+        self.validate_post_mode()?;
+        self.validate_schema()?;
+
+        Ok(())
+    }
+
+    fn validate_pre_release_label(&mut self) -> Result<(), ZervError> {
+        if self.branch_config.pre_release_label.is_none() {
+            self.branch_config.pre_release_label = Some(ALPHA.to_string());
+        }
+        Ok(())
+    }
+
+    fn validate_pre_release_num(&self) -> Result<(), ZervError> {
+        // No longer need to check for no_pre_release conflicts
+        Ok(())
+    }
+
+    fn validate_hash_branch_len(&self) -> Result<(), ZervError> {
+        if self.hash_branch_len == 0 || self.hash_branch_len > 10 {
+            return Err(ZervError::InvalidArgument(format!(
+                "hash-branch-len must be between 1 and 10, got {}",
+                self.hash_branch_len
+            )));
+        }
+        Ok(())
+    }
+
+    fn validate_post_mode(&self) -> Result<(), ZervError> {
+        use crate::utils::constants::post_modes;
+
+        if let Some(post_mode) = &self.branch_config.post_mode
+            && !post_modes::VALID_MODES.contains(&post_mode.as_str())
+        {
+            return Err(ZervError::InvalidArgument(format!(
+                "post-mode must be one of: {}, got {}",
+                post_modes::VALID_MODES.join(", "),
+                post_mode
+            )));
+        }
+        Ok(())
+    }
+
+    fn validate_schema(&self) -> Result<(), ZervError> {
+        if let Some(schema_name) = &self.schema {
+            // First, validate it's a known schema
+            let _parsed = ZervSchemaPreset::from_str(schema_name).map_err(|_| {
+                ZervError::InvalidArgument(format!("Unknown schema variant: '{}'", schema_name))
+            })?;
+
+            // Restrict to standard schemas only (check prefix)
+            if schema_name.starts_with("standard") {
+                Ok(())
+            } else {
+                Err(ZervError::InvalidArgument(format!(
+                    "zerv flow only supports standard schema variants, got: '{}'",
+                    schema_name
+                )))
+            }
+        } else {
+            Ok(())
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use rstest::*;
+
+    use super::*;
+    use crate::cli::flow::args::branch_rules::BranchRulesConfig;
+    use crate::test_utils::zerv::ZervFixture;
+    use crate::version::zerv::core::Zerv;
+
+    /// Helper function to create a mock zerv object for tests
+    fn mock_zerv() -> Zerv {
+        let mut zerv = ZervFixture::new().build();
+        // Set a mock branch name for tests that need branch detection
+        zerv.vars.last_branch = Some("main".to_string());
+        zerv
+    }
+
+    mod validation {
+        use super::*;
+
+        #[rstest]
+        #[case("alpha")]
+        #[case("beta")]
+        #[case("rc")]
+        fn test_valid_pre_release_labels(#[case] label: &str) {
+            let mut args = FlowArgs::default();
+            args.branch_config.pre_release_label = Some(label.to_string());
+            assert!(args.validate(&mock_zerv()).is_ok());
+        }
+
+        #[rstest]
+        #[case(1)]
+        #[case(5)]
+        #[case(10)]
+        fn test_valid_hash_branch_lengths(#[case] length: u32) {
+            let mut args = FlowArgs {
+                hash_branch_len: length,
+                ..FlowArgs::default()
+            };
+            assert!(args.validate(&mock_zerv()).is_ok());
+        }
+
+        #[rstest]
+        #[case("commit")]
+        #[case("tag")]
+        fn test_valid_post_modes(#[case] mode: &str) {
+            let mut args = FlowArgs::default();
+            args.branch_config.post_mode = Some(mode.to_string());
+            assert!(args.validate(&mock_zerv()).is_ok());
+        }
+
+        #[rstest]
+        #[case(0)]
+        #[case(11)]
+        #[case(20)]
+        fn test_invalid_hash_branch_lengths(#[case] length: u32) {
+            let mut args = FlowArgs {
+                hash_branch_len: length,
+                ..FlowArgs::default()
+            };
+            let result = args.validate(&mock_zerv());
+            assert!(result.is_err());
+            assert!(
+                result
+                    .unwrap_err()
+                    .to_string()
+                    .contains("hash-branch-len must be between 1 and 10")
+            );
+        }
+
+        #[rstest]
+        #[case("invalid")]
+        #[case("commit-invalid")]
+        #[case("tag-invalid")]
+        #[case("")]
+        fn test_invalid_post_modes(#[case] mode: &str) {
+            let mut args = FlowArgs::default();
+            args.branch_config.post_mode = Some(mode.to_string());
+            let result = args.validate(&mock_zerv());
+            assert!(result.is_err());
+            assert!(
+                result
+                    .unwrap_err()
+                    .to_string()
+                    .contains("post-mode must be one of:")
+            );
+        }
+
+        #[rstest]
+        #[case(Some("beta".to_string()), Some(5))]
+        #[case(None, None)]
+        #[case(Some("rc".to_string()), None)]
+        #[case(None, Some(10))]
+        fn test_valid_combinations(#[case] label: Option<String>, #[case] num: Option<u32>) {
+            let mut args = FlowArgs {
+                branch_config: BranchRulesConfig {
+                    pre_release_label: label,
+                    pre_release_num: num,
+                    ..Default::default()
+                },
+                ..FlowArgs::default()
+            };
+            assert!(args.validate(&mock_zerv()).is_ok());
+        }
+    }
+
+    mod schema_validation {
+        use super::*;
+
+        #[rstest]
+        #[case("standard")]
+        #[case("standard-no-context")]
+        #[case("standard-context")]
+        #[case("standard-base")]
+        #[case("standard-base-prerelease")]
+        #[case("standard-base-prerelease-post")]
+        #[case("standard-base-prerelease-post-dev")]
+        #[case("standard-base-context")]
+        #[case("standard-base-prerelease-context")]
+        #[case("standard-base-prerelease-post-context")]
+        #[case("standard-base-prerelease-post-dev-context")]
+        fn test_valid_standard_schemas(#[case] schema: &str) {
+            let mut args = FlowArgs {
+                schema: Some(schema.to_string()),
+                ..FlowArgs::default()
+            };
+            assert!(args.validate(&mock_zerv()).is_ok());
+        }
+
+        #[rstest]
+        #[case("calver")]
+        #[case("calver-base")]
+        #[case("calver-context")]
+        #[case("calver-no-context")]
+        #[case("calver-base-prerelease")]
+        #[case("invalid-schema")]
+        #[case("unknown")]
+        #[case("")]
+        fn test_invalid_schemas(#[case] schema: &str) {
+            let mut args = FlowArgs {
+                schema: Some(schema.to_string()),
+                ..FlowArgs::default()
+            };
+            let result = args.validate(&mock_zerv());
+            assert!(result.is_err());
+            let error_msg = result.unwrap_err().to_string();
+
+            // Both error types are valid - unknown schemas or non-standard schemas
+            assert!(
+                error_msg.contains("Unknown schema variant")
+                    || error_msg.contains("zerv flow only supports standard schema variants")
+            );
+        }
+
+        #[test]
+        fn test_no_schema_defaults_to_none() {
+            let args = FlowArgs::default();
+            assert!(args.schema.is_none());
+
+            let mut args = args;
+            assert!(args.validate(&mock_zerv()).is_ok());
+            assert!(args.schema.is_none()); // Should remain None
+        }
+
+        #[test]
+        fn test_schema_validation_with_pre_release_overrides() {
+            let mut args = FlowArgs {
+                schema: Some("standard-base".to_string()),
+                branch_config: BranchRulesConfig {
+                    pre_release_label: Some("beta".to_string()),
+                    pre_release_num: Some(42),
+                    ..Default::default()
+                },
+                ..FlowArgs::default()
+            };
+
+            // Should validate successfully - schema and manual overrides can coexist
+            assert!(args.validate(&mock_zerv()).is_ok());
+        }
+    }
+}
diff --git a/src/cli/flow/args/version_args.rs b/src/cli/flow/args/version_args.rs
new file mode 100644
index 00000000..47d5b4f6
--- /dev/null
+++ b/src/cli/flow/args/version_args.rs
@@ -0,0 +1,57 @@
+use ron::from_str;
+
+use super::FlowArgs;
+use crate::cli::common::args::OutputConfig;
+use crate::cli::version::args::{
+    BumpsConfig,
+    MainConfig,
+    OverridesConfig,
+    VersionArgs,
+};
+use crate::cli::version::pipeline::run_version_pipeline;
+use crate::error::ZervError;
+use crate::version::zerv::core::Zerv;
+
+impl FlowArgs {
+    /// Get current zerv object "as-is" (no bumps)
+    pub fn get_current_zerv_object(&self, stdin_content: Option<&str>) -> Result<Zerv, ZervError> {
+        let version_args = VersionArgs {
+            input: self.input.clone(),
+            output: OutputConfig::zerv(),
+            main: MainConfig::from_schema(self.schema.clone()),
+            overrides: OverridesConfig {
+                bumped_branch: self.bumped_branch.clone(),
+                ..Default::default()
+            },
+            bumps: BumpsConfig::default(),
+        };
+
+        let ron_output = run_version_pipeline(version_args, stdin_content)?;
+        from_str(&ron_output)
+            .map_err(|e| ZervError::InvalidFormat(format!("Failed to parse version output: {}", e)))
+    }
+
+    /// Create bumped version args for final pipeline
+    pub fn create_bumped_version_args(
+        &self,
+        _current_zerv: &Zerv,
+    ) -> Result<VersionArgs, ZervError> {
+        Ok(VersionArgs {
+            input: self.input.clone(),
+            output: OutputConfig::zerv(),
+            main: MainConfig::from_schema(self.schema.clone()),
+            overrides: OverridesConfig {
+                bumped_branch: self.bumped_branch.clone(),
+                ..Default::default()
+            },
+            bumps: BumpsConfig {
+                bump_pre_release_label: self.bump_pre_release_label(),
+                bump_pre_release_num: self.bump_pre_release_num(),
+                bump_patch: self.bump_patch(),
+                bump_post: self.bump_post(),
+                bump_dev: self.bump_dev(),
+                ..Default::default()
+            },
+        })
+    }
+}
diff --git a/src/cli/flow/branch_rules.rs b/src/cli/flow/branch_rules.rs
new file mode 100644
index 00000000..ea020379
--- /dev/null
+++ b/src/cli/flow/branch_rules.rs
@@ -0,0 +1,668 @@
+// Branch rules system for GitFlow support
+
+use std::fmt;
+use std::str::FromStr;
+
+use ron::{
+    from_str,
+    to_string,
+};
+use serde::{
+    Deserialize,
+    Serialize,
+};
+
+use crate::error::ZervError;
+
+/// Enum for type-safe pre-release labels
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum PreReleaseLabel {
+    Alpha,
+    Beta,
+    Rc,
+}
+
+/// Enum for type-safe post modes
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum PostMode {
+    Tag,
+    Commit,
+}
+
+/// Branch rule configuration
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct BranchRule {
+    pub pattern: String,                    // "develop", "release/*", "feature/*"
+    pub pre_release_label: PreReleaseLabel, // "beta", "rc", "alpha"
+    #[serde(default)]
+    pub pre_release_num: Option<u32>, // "1" for release branches, defaults to None
+    pub post_mode: PostMode,                // "tag" for release, "commit" for others
+}
+
+/// Resolved branch arguments from branch rules
+#[derive(Debug, Clone)]
+pub struct ResolvedBranchArgs {
+    pub pre_release_label: PreReleaseLabel,
+    pub pre_release_num: Option<u32>,
+    pub post_mode: PostMode,
+}
+
+/// Collection of branch rules with pattern matching
+#[derive(Debug, Clone, Default)]
+pub struct BranchRules {
+    rules: Vec<BranchRule>,
+}
+
+impl BranchRule {
+    /// Validate the branch rule configuration
+    pub fn validate(&self) -> Result<(), ZervError> {
+        // Wildcard patterns (ending with /*) must not have explicit pre_release_num
+        if self.pattern.ends_with("/*") && self.pre_release_num.is_some() {
+            return Err(ZervError::ConflictingOptions(format!(
+                "Branch rule with wildcard pattern '{}' cannot have explicit pre_release_num. \
+                Use None to extract number from branch name dynamically.",
+                self.pattern
+            )));
+        }
+
+        // Exact patterns (not ending with /*) must have pre_release_num specified
+        if !self.pattern.ends_with("/*") && self.pre_release_num.is_none() {
+            return Err(ZervError::ConflictingOptions(format!(
+                "Branch rule with exact pattern '{}' must have explicit pre_release_num. \
+                Specify pre_release_num: Some(N) or use wildcard pattern '{}/N' for dynamic extraction.",
+                self.pattern, self.pattern
+            )));
+        }
+
+        Ok(())
+    }
+
+    /// Resolve values for a specific branch that matches this rule's pattern
+    pub fn resolve_for_branch(&self, branch_name: &str) -> ResolvedBranchArgs {
+        ResolvedBranchArgs {
+            pre_release_label: self.pre_release_label.clone(),
+            pre_release_num: self.resolve_pre_release_num(branch_name),
+            post_mode: self.post_mode.clone(),
+        }
+    }
+
+    /// Resolve pre-release number for a branch that matches this rule
+    fn resolve_pre_release_num(&self, branch_name: &str) -> Option<u32> {
+        // 1. Use explicit number from rule
+        if let Some(num) = self.pre_release_num {
+            return Some(num);
+        }
+
+        // 2. Extract from branch pattern (e.g., "release/1" -> "1")
+        self.extract_branch_number(branch_name)
+    }
+
+    /// Extract number from branch pattern (e.g., "release/1" -> "1" when pattern is "release/*")
+    fn extract_branch_number(&self, branch_name: &str) -> Option<u32> {
+        if !self.pattern.ends_with("/*") {
+            return None;
+        }
+
+        let prefix = &self.pattern[..self.pattern.len() - 2]; // Remove "/*"
+        if !branch_name.starts_with(prefix) || branch_name.len() == prefix.len() {
+            return None;
+        }
+
+        let remainder = &branch_name[prefix.len()..];
+
+        // Skip any non-numeric characters (like slash) at the beginning
+        let numeric_start: String = remainder
+            .chars()
+            .skip_while(|c| !c.is_numeric())
+            .take_while(|c| c.is_numeric())
+            .collect();
+
+        if numeric_start.is_empty() {
+            None
+        } else {
+            numeric_start.parse().ok()
+        }
+    }
+}
+
+impl BranchRules {
+    /// Create new branch rules from a vector of rules
+    pub fn new(rules: Vec<BranchRule>) -> Result<Self, ZervError> {
+        // Validate all rules
+        for rule in &rules {
+            rule.validate()?;
+        }
+        Ok(Self { rules })
+    }
+
+    /// Preprocess RON string to convert bare numbers to Some(number) for pre_release_num
+    fn preprocess_ron_syntax(ron_str: &str) -> String {
+        use regex::Regex;
+
+        // Match pattern: pre_release_num: <number> and convert to pre_release_num: Some(<number>)
+        // This regex finds pre_release_num field with bare numbers and wraps them in Some()
+        let re = Regex::new(r"(pre_release_num:\s*)(\d+)").expect("Failed to compile regex");
+        re.replace_all(ron_str, "${1}Some(${2})").to_string()
+    }
+
+    /// Find a rule that matches the given branch name
+    pub fn find_rule(&self, branch: &str) -> Option<&BranchRule> {
+        self.rules.iter().find(|rule| rule.matches(branch))
+    }
+
+    /// Get default branch rules for GitFlow
+    pub fn default_rules() -> Self {
+        let rules = vec![
+            BranchRule {
+                pattern: "develop".to_string(),
+                pre_release_label: PreReleaseLabel::Beta,
+                pre_release_num: Some(1),
+                post_mode: PostMode::Commit,
+            },
+            BranchRule {
+                pattern: "release/*".to_string(),
+                pre_release_label: PreReleaseLabel::Rc,
+                pre_release_num: None, // Extract from branch name
+                post_mode: PostMode::Tag,
+            },
+        ];
+        Self::new(rules).expect("Default branch rules should be valid")
+    }
+
+    /// Find and resolve rule for a branch, or return default args
+    pub fn resolve_for_branch(&self, branch_name: Option<&str>) -> ResolvedBranchArgs {
+        branch_name
+            .and_then(|name| self.find_rule(name))
+            .map(|rule| rule.resolve_for_branch(branch_name.unwrap()))
+            .unwrap_or_else(|| ResolvedBranchArgs {
+                pre_release_label: PreReleaseLabel::Alpha,
+                pre_release_num: None,
+                post_mode: PostMode::Commit,
+            })
+    }
+}
+
+impl FromStr for BranchRules {
+    type Err = ZervError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        // Preprocess to convert bare numbers to Some(number)
+        let processed_ron = Self::preprocess_ron_syntax(s);
+
+        let rules: Vec<BranchRule> = from_str(&processed_ron).map_err(|e| {
+            ZervError::InvalidFormat(format!("Failed to parse branch rules: {}", e))
+        })?;
+
+        // Validate all parsed rules
+        for rule in &rules {
+            rule.validate()?;
+        }
+
+        Ok(Self { rules })
+    }
+}
+
+impl fmt::Display for BranchRules {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let ron_string = to_string(&self.rules).map_err(|_| fmt::Error)?;
+        write!(f, "{}", ron_string)
+    }
+}
+
+impl BranchRule {
+    /// Check if this rule matches the given branch name
+    pub fn matches(&self, branch: &str) -> bool {
+        if self.pattern.ends_with("/*") {
+            // Wildcard pattern: "release/*" matches "release/1", "release/feature-name"
+            let prefix = &self.pattern[..self.pattern.len() - 2];
+            branch.starts_with(prefix) && branch.len() > prefix.len()
+        } else {
+            // Exact pattern match: "develop" matches only "develop"
+            self.pattern == branch
+        }
+    }
+}
+
+// Helper implementations for string conversion
+impl PreReleaseLabel {
+    pub fn to_string(&self) -> &'static str {
+        match self {
+            PreReleaseLabel::Alpha => "alpha",
+            PreReleaseLabel::Beta => "beta",
+            PreReleaseLabel::Rc => "rc",
+        }
+    }
+}
+
+impl FromStr for PreReleaseLabel {
+    type Err = ZervError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "alpha" => Ok(PreReleaseLabel::Alpha),
+            "beta" => Ok(PreReleaseLabel::Beta),
+            "rc" => Ok(PreReleaseLabel::Rc),
+            _ => Err(ZervError::InvalidFormat(format!(
+                "Invalid pre-release label: '{}'. Must be one of: alpha, beta, rc",
+                s
+            ))),
+        }
+    }
+}
+
+impl PostMode {
+    pub fn to_string(&self) -> &'static str {
+        match self {
+            PostMode::Tag => "tag",
+            PostMode::Commit => "commit",
+        }
+    }
+}
+
+impl FromStr for PostMode {
+    type Err = ZervError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "tag" => Ok(PostMode::Tag),
+            "commit" => Ok(PostMode::Commit),
+            _ => Err(ZervError::InvalidFormat(format!(
+                "Invalid post mode: '{}'. Must be one of: tag, commit",
+                s
+            ))),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use rstest::rstest;
+
+    use super::*;
+
+    #[rstest]
+    #[case("alpha", PreReleaseLabel::Alpha)]
+    #[case("BETA", PreReleaseLabel::Beta)]
+    #[case("Rc", PreReleaseLabel::Rc)]
+    #[case("rc", PreReleaseLabel::Rc)]
+    #[case("ALPHA", PreReleaseLabel::Alpha)]
+    #[case("beta", PreReleaseLabel::Beta)]
+    fn test_pre_release_label_from_str(#[case] input: &str, #[case] expected: PreReleaseLabel) {
+        assert_eq!(PreReleaseLabel::from_str(input).unwrap(), expected);
+    }
+
+    #[rstest]
+    #[case("invalid")]
+    #[case("")]
+    #[case("release")]
+    #[case("pre")]
+    fn test_pre_release_label_from_str_invalid(#[case] input: &str) {
+        assert!(PreReleaseLabel::from_str(input).is_err());
+    }
+
+    #[rstest]
+    #[case("tag", PostMode::Tag)]
+    #[case("COMMIT", PostMode::Commit)]
+    #[case("Tag", PostMode::Tag)]
+    #[case("commit", PostMode::Commit)]
+    fn test_post_mode_from_str(#[case] input: &str, #[case] expected: PostMode) {
+        assert_eq!(PostMode::from_str(input).unwrap(), expected);
+    }
+
+    #[rstest]
+    #[case("invalid")]
+    #[case("")]
+    #[case("push")]
+    #[case("merge")]
+    fn test_post_mode_from_str_invalid(#[case] input: &str) {
+        assert!(PostMode::from_str(input).is_err());
+    }
+
+    #[rstest]
+    #[case("develop", "develop", true)]
+    #[case("develop", "develop-feature", false)]
+    #[case("develop", "develop/feature", false)]
+    #[case("develop", "main", false)]
+    #[case("main", "main", true)]
+    #[case("main", "master", false)]
+    #[case("master", "master", true)]
+    #[case("master", "master/feature", false)]
+    fn test_branch_rule_exact_match(
+        #[case] pattern: &str,
+        #[case] branch: &str,
+        #[case] matches: bool,
+    ) {
+        let rule = BranchRule {
+            pattern: pattern.to_string(),
+            pre_release_label: PreReleaseLabel::Beta,
+            pre_release_num: Some(1),
+            post_mode: PostMode::Commit,
+        };
+
+        assert_eq!(rule.matches(branch), matches);
+    }
+
+    #[rstest]
+    #[case("release/*", "release/1", true)]
+    #[case("release/*", "release/2", true)]
+    #[case("release/*", "release/feature-name", true)]
+    #[case("release/*", "release", false)] // "release" alone should not match "release/*"
+    #[case("release/*", "main", false)]
+    #[case("hotfix/*", "hotfix/123", true)]
+    #[case("hotfix/*", "hotfix/urgent-fix", true)]
+    #[case("hotfix/*", "hotfix", false)]
+    fn test_branch_rule_wildcard_match(
+        #[case] pattern: &str,
+        #[case] branch: &str,
+        #[case] matches: bool,
+    ) {
+        let rule = BranchRule {
+            pattern: pattern.to_string(),
+            pre_release_label: PreReleaseLabel::Rc,
+            pre_release_num: None,
+            post_mode: PostMode::Tag,
+        };
+
+        assert_eq!(rule.matches(branch), matches);
+    }
+
+    #[rstest]
+    #[case("release/*", "release/1", Some(1))]
+    #[case("release/*", "release/42", Some(42))]
+    #[case("release/*", "release/1/feature", Some(1))]
+    #[case("release/*", "release/feature", None)]
+    #[case("hotfix/*", "hotfix/123", Some(123))]
+    #[case("hotfix/*", "hotfix/abc", None)]
+    #[case("release/*", "main", None)]
+    fn test_branch_rule_number_extraction(
+        #[case] pattern: &str,
+        #[case] branch_name: &str,
+        #[case] expected: Option<u32>,
+    ) {
+        let rule = BranchRule {
+            pattern: pattern.to_string(),
+            pre_release_label: PreReleaseLabel::Rc,
+            pre_release_num: None, // Must be specified in Rust code (#[serde(default)] only for deserialization)
+            post_mode: PostMode::Tag,
+        };
+
+        assert_eq!(rule.resolve_pre_release_num(branch_name), expected);
+    }
+
+    #[test]
+    fn test_branch_rule_explicit_number() {
+        let rule = BranchRule {
+            pattern: "develop".to_string(),
+            pre_release_label: PreReleaseLabel::Beta,
+            pre_release_num: Some(5),
+            post_mode: PostMode::Commit,
+        };
+
+        // Should always use the explicit number, not extract from branch name
+        assert_eq!(rule.resolve_pre_release_num("develop"), Some(5));
+    }
+
+    #[test]
+    fn test_branch_rules_default() {
+        let rules = BranchRules::default_rules();
+
+        // Should have exactly 2 default rules
+        assert_eq!(rules.rules.len(), 2);
+
+        // Check develop rule
+        let develop_rule = rules.find_rule("develop").unwrap();
+        assert_eq!(develop_rule.pre_release_label, PreReleaseLabel::Beta);
+        assert_eq!(develop_rule.pre_release_num, Some(1));
+        assert_eq!(develop_rule.post_mode, PostMode::Commit);
+
+        // Check release rule
+        let release_rule = rules.find_rule("release/1").unwrap();
+        assert_eq!(release_rule.pre_release_label, PreReleaseLabel::Rc);
+        assert_eq!(release_rule.pre_release_num, None);
+        assert_eq!(release_rule.post_mode, PostMode::Tag);
+    }
+
+    #[test]
+    fn test_branch_rule_validation_wildcard_with_explicit_num() {
+        let invalid_rule = BranchRule {
+            pattern: "release/*".to_string(),
+            pre_release_label: PreReleaseLabel::Rc,
+            pre_release_num: Some(1), // This should be invalid for wildcard patterns
+            post_mode: PostMode::Tag,
+        };
+
+        // Validation should fail
+        let result = invalid_rule.validate();
+        assert!(result.is_err());
+        match result.unwrap_err() {
+            ZervError::ConflictingOptions(msg) => {
+                assert!(msg.contains("wildcard pattern"));
+                assert!(msg.contains("cannot have explicit pre_release_num"));
+            }
+            _ => panic!("Expected ConflictingOptions error"),
+        }
+    }
+
+    #[test]
+    fn test_branch_rules_new_with_validation() {
+        // Valid rules should succeed
+        let valid_rules = vec![
+            BranchRule {
+                pattern: "develop".to_string(),
+                pre_release_label: PreReleaseLabel::Beta,
+                pre_release_num: Some(1),
+                post_mode: PostMode::Commit,
+            },
+            BranchRule {
+                pattern: "release/*".to_string(),
+                pre_release_label: PreReleaseLabel::Rc,
+                pre_release_num: None, // Valid: None for wildcard pattern
+                post_mode: PostMode::Tag,
+            },
+        ];
+        let result = BranchRules::new(valid_rules);
+        assert!(result.is_ok());
+
+        // Invalid rules should fail
+        let invalid_rules = vec![BranchRule {
+            pattern: "release/*".to_string(),
+            pre_release_label: PreReleaseLabel::Rc,
+            pre_release_num: Some(1), // Invalid: Some for wildcard pattern
+            post_mode: PostMode::Tag,
+        }];
+        let result = BranchRules::new(invalid_rules);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_default_rules_uses_validation() {
+        // This test ensures default_rules() uses the new() method with validation
+        let rules = BranchRules::default_rules();
+
+        // Should create successfully (panic if invalid)
+        assert_eq!(rules.rules.len(), 2);
+
+        // Default rules should be valid
+        for rule in &rules.rules {
+            assert!(rule.validate().is_ok());
+        }
+    }
+
+    #[test]
+    fn test_branch_rules_resolve_for_branch() {
+        let rules = BranchRules::default_rules();
+
+        // Mapped branch should use rule
+        let develop_args = rules.resolve_for_branch(Some("develop"));
+        assert_eq!(develop_args.pre_release_label, PreReleaseLabel::Beta);
+        assert_eq!(develop_args.pre_release_num, Some(1));
+        assert_eq!(develop_args.post_mode, PostMode::Commit);
+
+        // Unmapped branch should use defaults
+        let feature_args = rules.resolve_for_branch(Some("feature/auth"));
+        assert_eq!(feature_args.pre_release_label, PreReleaseLabel::Alpha);
+        assert_eq!(feature_args.pre_release_num, None); // FlowArgs will handle generation
+        assert_eq!(feature_args.post_mode, PostMode::Commit);
+
+        // None branch name should use defaults
+        let none_args = rules.resolve_for_branch(None);
+        assert_eq!(none_args.pre_release_label, PreReleaseLabel::Alpha);
+        assert_eq!(none_args.pre_release_num, None);
+        assert_eq!(none_args.post_mode, PostMode::Commit);
+    }
+
+    #[test]
+    fn test_branch_rules_from_str_simplified_syntax() {
+        // Test simplified RON syntax with bare values instead of Some(N)
+        let ron_str = r#"[
+            (pattern: "develop", pre_release_label: beta, pre_release_num: 1, post_mode: commit),
+            (pattern: "release/*", pre_release_label: rc, post_mode: tag)
+        ]"#;
+
+        let rules: BranchRules = ron_str.parse().unwrap();
+        assert_eq!(rules.rules.len(), 2);
+
+        let develop_rule = rules.find_rule("develop").unwrap();
+        assert_eq!(develop_rule.pre_release_label, PreReleaseLabel::Beta);
+        assert_eq!(develop_rule.pre_release_num, Some(1)); // 1 becomes Some(1)
+
+        let release_rule = rules.find_rule("release/1").unwrap();
+        assert_eq!(release_rule.pre_release_label, PreReleaseLabel::Rc);
+        assert_eq!(release_rule.pre_release_num, None); // Omitted becomes None
+    }
+
+    #[test]
+    fn test_branch_rules_validation_exact_pattern_requires_num() {
+        // Test that exact patterns without pre_release_num fail validation
+        let ron_str = r#"[
+            (pattern: "develop", pre_release_label: beta, post_mode: commit)
+        ]"#;
+
+        let result: Result<BranchRules, _> = ron_str.parse();
+        assert!(result.is_err());
+        match result.unwrap_err() {
+            ZervError::ConflictingOptions(msg) => {
+                assert!(msg.contains("exact pattern"));
+                assert!(msg.contains("must have explicit pre_release_num"));
+            }
+            _ => panic!("Expected ConflictingOptions error"),
+        }
+    }
+
+    #[rstest]
+    #[case(PreReleaseLabel::Alpha, "alpha")]
+    #[case(PreReleaseLabel::Beta, "beta")]
+    #[case(PreReleaseLabel::Rc, "rc")]
+    fn test_pre_release_label_to_string(#[case] label: PreReleaseLabel, #[case] expected: &str) {
+        assert_eq!(label.to_string(), expected);
+    }
+
+    #[rstest]
+    #[case(PostMode::Tag, "tag")]
+    #[case(PostMode::Commit, "commit")]
+    fn test_post_mode_to_string(#[case] mode: PostMode, #[case] expected: &str) {
+        assert_eq!(mode.to_string(), expected);
+    }
+
+    #[test]
+    fn test_branch_rules_from_str() {
+        // Test both idiomatic parse() and direct from_str() methods
+        let ron_str = r#"[
+            (pattern: "develop", pre_release_label: beta, pre_release_num: 1, post_mode: commit),
+            (pattern: "release/*", pre_release_label: rc, post_mode: tag)
+        ]"#;
+
+        // Test idiomatic parse() method
+        let rules_parsed: BranchRules = ron_str.parse().unwrap();
+        assert_eq!(rules_parsed.rules.len(), 2);
+
+        // Test direct from_str() method
+        let rules_from_str = BranchRules::from_str(ron_str).unwrap();
+        assert_eq!(rules_from_str.rules.len(), 2);
+
+        // Both methods should produce identical results
+        assert_eq!(rules_parsed.rules, rules_from_str.rules);
+
+        // Verify the parsed rules
+        let develop_rule = rules_parsed.find_rule("develop").unwrap();
+        assert_eq!(develop_rule.pre_release_label, PreReleaseLabel::Beta);
+        assert_eq!(develop_rule.pre_release_num, Some(1));
+
+        let release_rule = rules_parsed.find_rule("release/1").unwrap();
+        assert_eq!(release_rule.pre_release_label, PreReleaseLabel::Rc);
+        assert_eq!(release_rule.pre_release_num, None);
+    }
+
+    #[test]
+    fn test_branch_rules_from_str_invalid() {
+        let invalid_ron = "invalid ron syntax";
+        let result: Result<BranchRules, _> = invalid_ron.parse();
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_branch_rules_from_str_with_validation_errors() {
+        // Test FromStr with invalid branch rules (wildcard pattern with explicit num)
+        let invalid_ron = r#"[
+            (pattern: "release/*", pre_release_label: rc, pre_release_num: 1, post_mode: tag)
+        ]"#;
+
+        let result: Result<BranchRules, _> = invalid_ron.parse();
+        assert!(result.is_err());
+        match result.unwrap_err() {
+            ZervError::ConflictingOptions(msg) => {
+                assert!(msg.contains("wildcard pattern"));
+                assert!(msg.contains("cannot have explicit pre_release_num"));
+            }
+            _ => panic!("Expected ConflictingOptions error"),
+        }
+    }
+
+    #[test]
+    fn test_branch_rules_display_round_trip() {
+        // Test that Display produces valid RON that can be parsed back
+        let original_ron = r#"[
+            (pattern: "develop", pre_release_label: beta, pre_release_num: 1, post_mode: commit),
+            (pattern: "release/*", pre_release_label: rc, post_mode: tag)
+        ]"#;
+
+        let rules: BranchRules = original_ron.parse().unwrap();
+        let display_output = rules.to_string();
+
+        // Should be able to parse the display output back
+        let reparsed_rules: BranchRules = display_output.parse().unwrap();
+
+        // Both should have the same rules
+        assert_eq!(
+            rules.find_rule("develop").unwrap().pre_release_label,
+            reparsed_rules
+                .find_rule("develop")
+                .unwrap()
+                .pre_release_label
+        );
+        assert_eq!(
+            rules.find_rule("release/1").unwrap().pre_release_label,
+            reparsed_rules
+                .find_rule("release/1")
+                .unwrap()
+                .pre_release_label
+        );
+    }
+
+    #[test]
+    fn test_branch_rules_display_format() {
+        // Test that Display produces expected RON format
+        let rules = BranchRules::default_rules();
+        let display_output = rules.to_string();
+
+        // Should exactly match the expected GitFlow rules RON format (compact)
+        let develop_rule = r#"(pattern:"develop",pre_release_label:beta,pre_release_num:Some(1),post_mode:commit)"#;
+        let release_rule =
+            r#"(pattern:"release/*",pre_release_label:rc,pre_release_num:None,post_mode:tag)"#;
+        let expected = format!("[{},{}]", develop_rule, release_rule);
+
+        assert_eq!(display_output, expected);
+    }
+}
diff --git a/src/cli/flow/mod.rs b/src/cli/flow/mod.rs
index 5cc73d2d..a271814e 100644
--- a/src/cli/flow/mod.rs
+++ b/src/cli/flow/mod.rs
@@ -1,5 +1,15 @@
 pub mod args;
+pub mod branch_rules;
 pub mod pipeline;
 
+pub mod test_utils;
+
 pub use args::FlowArgs;
+pub use branch_rules::*;
 pub use pipeline::run_flow_pipeline;
+#[cfg(test)]
+pub use test_utils::{
+    SchemaTestCase,
+    create_base_schema_test_cases,
+    expect_branch_hash,
+};
diff --git a/src/cli/flow/pipeline.rs b/src/cli/flow/pipeline.rs
index ed515f3a..e3fb6c6c 100644
--- a/src/cli/flow/pipeline.rs
+++ b/src/cli/flow/pipeline.rs
@@ -1,43 +1,27 @@
 use ron::from_str;
 
-use crate::cli::common::args::OutputConfig;
 use crate::cli::flow::args::FlowArgs;
 use crate::cli::utils::output_formatter::OutputFormatter;
-use crate::cli::version::args::{
-    BumpsConfig,
-    VersionArgs,
-};
 use crate::cli::version::pipeline::run_version_pipeline;
 use crate::error::ZervError;
 use crate::version::zerv::core::Zerv;
 
-pub fn run_flow_pipeline(args: FlowArgs) -> Result<String, ZervError> {
+pub fn run_flow_pipeline(args: FlowArgs, stdin_content: Option<&str>) -> Result<String, ZervError> {
     tracing::debug!("Starting flow pipeline with args: {:?}", args);
 
     let mut args = args;
-    args.validate()?;
-
-    let version_args = VersionArgs {
-        input: args.input.clone(),
-        output: OutputConfig {
-            output_format: "zerv".to_string(),
-            output_template: None,
-            output_prefix: None,
-        },
-        main: Default::default(),
-        overrides: Default::default(),
-        // bumps: Default::default(),
-        bumps: BumpsConfig {
-            bump_pre_release_label: args.bump_pre_release_label(),
-            bump_pre_release_num: args.bump_pre_release_num(),
-            bump_patch: args.bump_patch(),
-            bump_post: args.bump_post(),
-            bump_dev: args.bump_dev(),
-            ..Default::default()
-        },
-    };
 
-    let ron_output = run_version_pipeline(version_args)?;
+    // Step 1: Get current state (no bumps)
+    let current_zerv = args.get_current_zerv_object(stdin_content)?;
+
+    // Step 2: Validate and apply branch rules using current state
+    args.validate(&current_zerv)?;
+
+    // Step 3: Create bumped version args
+    let version_args = args.create_bumped_version_args(&current_zerv)?;
+
+    // Step 4: Run version pipeline with stdin content
+    let ron_output = run_version_pipeline(version_args, stdin_content)?;
 
     let zerv_object: Zerv = from_str(&ron_output)
         .map_err(|e| ZervError::InvalidFormat(format!("Failed to parse version output: {}", e)))?;
@@ -54,94 +38,764 @@ pub fn run_flow_pipeline(args: FlowArgs) -> Result<String, ZervError> {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::cli::utils::template::{
-        Template,
-        TemplateExtGeneric,
+    use crate::cli::flow::test_utils::{
+        FlowTestScenario,
+        SchemaTestBuild,
+        SchemaTestExtraCore,
+        create_base_schema_test_cases,
+        create_full_schema_test_cases,
+        expect_branch_hash,
     };
     use crate::test_info;
-    use crate::test_utils::{
-        GitRepoFixture,
-        assert_version_expectation,
-        should_run_docker_tests,
-    };
+    use crate::test_utils::should_run_docker_tests;
+    use crate::version::zerv::PreReleaseLabel;
+
+    #[test]
+    fn test_trunk_based_development_flow() {
+        test_info!("Starting trunk-based development flow test (exactly matching Mermaid diagram)");
+        if !should_run_docker_tests() {
+            return; // Skip when `ZERV_TEST_DOCKER` are disabled
+        }
+
+        // Step 1: Initial commit on main with v1.0.0
+        test_info!("Step 1: Initial setup: main branch state with v1.0.0 tag");
+        let scenario = FlowTestScenario::new()
+            .expect("Failed to create test scenario")
+            .create_tag("v1.0.0")
+            .expect_version("1.0.0", "1.0.0")
+            .expect_schema_variants(create_base_schema_test_cases("1.0.0", "main"));
 
-    fn test_flow_pipeline_with_fixture(
-        fixture_path: &str,
-        semver_expectation: &str,
-        pep440_expectation: &str,
-    ) {
-        let test_cases = vec![
-            ("semver", semver_expectation),
-            ("pep440", pep440_expectation),
-        ];
-
-        for (format_name, expectation) in test_cases {
-            let mut args = FlowArgs::default();
-            args.input.directory = Some(fixture_path.to_string());
-            args.output.output_format = format_name.to_string();
-
-            let result = run_flow_pipeline(args);
-            assert!(
-                result.is_ok(),
-                "Flow pipeline should succeed with {} format at {}: {}",
-                format_name,
-                fixture_path,
-                result.unwrap_err()
+        // Step 2: Create parallel feature branches feature-1 and feature-2 from main
+        test_info!("Step 2: Create parallel feature branches: feature-1 and feature-2");
+        let scenario = scenario
+            .create_branch("feature-1")
+            .create_branch("feature-2");
+
+        // Capture actual hash values for validation
+        let branch_feature_2_hash = expect_branch_hash("feature-2", 5, "68031");
+        let branch_feature_1_hash = expect_branch_hash("feature-1", 5, "42954");
+
+        // Step 3: feature-2: Start development with dirty state (matches Mermaid REVERSE commit)
+        test_info!("Step 3: feature-2: Start development with dirty state");
+        let scenario = scenario
+            .checkout("feature-2")
+            .make_dirty()
+            .expect_version(
+                &format!(
+                    "1.0.1-alpha.{}.post.0.dev.{{timestamp:now}}+feature.2.0.g{{hex:7}}",
+                    branch_feature_2_hash
+                ),
+                &format!(
+                    "1.0.1a{}.post0.dev{{timestamp:now}}+feature.2.0.g{{hex:7}}",
+                    branch_feature_2_hash
+                ),
+            )
+            .expect_schema_variants(create_full_schema_test_cases(
+                "1.0.1",
+                SchemaTestExtraCore {
+                    pre_release_label: PreReleaseLabel::Alpha,
+                    pre_release_num: &branch_feature_2_hash.to_string(),
+                    post: 0,
+                    dev: Some("{timestamp:now}"),
+                },
+                SchemaTestBuild {
+                    sanitized_branch_name: "feature.2",
+                    distance: 0,
+                    include_build_for_standard: true,
+                },
+            ));
+
+        // Step 4: feature-2: Create first commit
+        test_info!("Step 4: feature-2: Create first commit");
+        let scenario = scenario.commit().expect_version(
+            &format!(
+                "1.0.1-alpha.{}.post.1+feature.2.1.g{{hex:7}}",
+                branch_feature_2_hash
+            ),
+            &format!(
+                "1.0.1a{}.post1+feature.2.1.g{{hex:7}}",
+                branch_feature_2_hash
+            ),
+        );
+        // .expect_schema_variants(create_full_schema_test_cases(
+        //     "1.0.1",
+        //     SchemaTestExtraCore {
+        //         pre_release_label: PreReleaseLabel::Alpha,
+        //         pre_release_num: &branch_feature_2_hash.to_string(),
+        //         post: 1,
+        //         dev: None,
+        //     },
+        //     SchemaTestBuild {
+        //         sanitized_branch_name: "feature.2",
+        //         distance: 1,
+        //         include_build_for_standard: true,
+        //     },
+        // ));
+
+        // Step 5: feature-1: Create commits (parallel development)
+        test_info!("Step 5: feature-1: Create commits (parallel development)");
+        let scenario = scenario
+            .checkout("feature-1")
+            .commit()
+            .expect_version(
+                &format!(
+                    "1.0.1-alpha.{}.post.1+feature.1.1.g{{hex:7}}",
+                    branch_feature_1_hash
+                ),
+                &format!(
+                    "1.0.1a{}.post1+feature.1.1.g{{hex:7}}",
+                    branch_feature_1_hash
+                ),
+            )
+            // .expect_schema_variants(create_full_schema_test_cases(
+            //     "1.0.1",
+            //     SchemaTestExtraCore {
+            //         pre_release_label: PreReleaseLabel::Alpha,
+            //         pre_release_num: &branch_feature_1_hash.to_string(),
+            //         post: 1,
+            //         dev: None,
+            //     },
+            //     SchemaTestBuild {
+            //         sanitized_branch_name: "feature.1",
+            //         distance: 1,
+            //         include_build_for_standard: true,
+            //     },
+            // ))
+            .commit()
+            .expect_version(
+                &format!(
+                    "1.0.1-alpha.{}.post.2+feature.1.2.g{{hex:7}}",
+                    branch_feature_1_hash
+                ),
+                &format!(
+                    "1.0.1a{}.post2+feature.1.2.g{{hex:7}}",
+                    branch_feature_1_hash
+                ),
             );
-            let output = result.unwrap();
-            assert!(
-                !output.is_empty(),
-                "Flow pipeline should produce output for {} format",
-                format_name
+        // .expect_schema_variants(create_full_schema_test_cases(
+        //     "1.0.1",
+        //     SchemaTestExtraCore {
+        //         pre_release_label: PreReleaseLabel::Alpha,
+        //         pre_release_num: &branch_feature_1_hash.to_string(),
+        //         post: 2,
+        //         dev: None,
+        //     },
+        //     SchemaTestBuild {
+        //         sanitized_branch_name: "feature.1",
+        //         distance: 2,
+        //         include_build_for_standard: true,
+        //     },
+        // ));
+
+        // Step 6: feature-1: Merge to main and release v1.0.1
+        test_info!("Step 6: feature-1: Merge to main and release v1.0.1");
+        let scenario = scenario
+            .checkout("main")
+            .merge_branch("feature-1")
+            .create_tag("v1.0.1")
+            .expect_version("1.0.1", "1.0.1");
+        // .expect_schema_variants(create_base_schema_test_cases("1.0.1", "main"));
+
+        // Step 7: feature-2: Sync with main to get feature-1 changes
+        test_info!("Step 7: feature-2: Sync with main to get feature-1 changes");
+        let scenario = scenario
+            .checkout("feature-2")
+            .merge_branch("main")
+            .expect_version(
+                &format!(
+                    "1.0.2-alpha.{}.post.2+feature.2.2.g{{hex:7}}",
+                    branch_feature_2_hash
+                ),
+                &format!(
+                    "1.0.2a{}.post2+feature.2.2.g{{hex:7}}",
+                    branch_feature_2_hash
+                ),
             );
+        // .expect_schema_variants(create_full_schema_test_cases(
+        //     "1.0.2",
+        //     SchemaTestExtraCore {
+        //         pre_release_label: PreReleaseLabel::Alpha,
+        //         pre_release_num: &branch_feature_2_hash.to_string(),
+        //         post: 2,
+        //         dev: None,
+        //     },
+        //     SchemaTestBuild {
+        //         sanitized_branch_name: "feature.2",
+        //         distance: 2,
+        //         include_build_for_standard: true,
+        //     },
+        // ));
 
-            assert_version_expectation(expectation, &output);
+        // Step 8: feature-2: Create additional commit
+        test_info!("Step 8: feature-2: Create additional commit");
+        let scenario = scenario.commit().expect_version(
+            &format!(
+                "1.0.2-alpha.{}.post.3+feature.2.3.g{{hex:7}}",
+                branch_feature_2_hash
+            ),
+            &format!(
+                "1.0.2a{}.post3+feature.2.3.g{{hex:7}}",
+                branch_feature_2_hash
+            ),
+        );
+        // .expect_schema_variants(create_full_schema_test_cases(
+        //     "1.0.2",
+        //     SchemaTestExtraCore {
+        //         pre_release_label: PreReleaseLabel::Alpha,
+        //         pre_release_num: &branch_feature_2_hash.to_string(),
+        //         post: 3,
+        //         dev: None,
+        //     },
+        //     SchemaTestBuild {
+        //         sanitized_branch_name: "feature.2",
+        //         distance: 3,
+        //         include_build_for_standard: true,
+        //     },
+        // ));
 
-            test_info!("Flow pipeline output ({}): {}", format_name, output);
-        }
+        // Step 9: feature-3: Branch from feature-2 for sub-feature development
+        test_info!("Step 9: feature-3: Branch from feature-2 for sub-feature development");
+        let branch_feature_3_hash = expect_branch_hash("feature-3", 5, "14698");
+        let scenario = scenario
+            .create_branch("feature-3")
+            .checkout("feature-3")
+            .commit()
+            .expect_version(
+                &format!(
+                    "1.0.2-alpha.{}.post.4+feature.3.4.g{{hex:7}}",
+                    branch_feature_3_hash
+                ),
+                &format!(
+                    "1.0.2a{}.post4+feature.3.4.g{{hex:7}}",
+                    branch_feature_3_hash
+                ),
+            );
+        // .expect_schema_variants(create_full_schema_test_cases(
+        //     "1.0.2",
+        //     SchemaTestExtraCore {
+        //         pre_release_label: PreReleaseLabel::Alpha,
+        //         pre_release_num: &branch_feature_3_hash.to_string(),
+        //         post: 4,
+        //         dev: None,
+        //     },
+        //     SchemaTestBuild {
+        //         sanitized_branch_name: "feature.3",
+        //         distance: 4,
+        //         include_build_for_standard: true,
+        //     },
+        // ));
+
+        // Step 10: feature-3: Continue development with dirty state
+        test_info!("Step 10: feature-3: Continue development with dirty state");
+        let scenario = scenario.make_dirty().expect_version(
+            &format!(
+                "1.0.2-alpha.{}.post.4.dev.{{timestamp:now}}+feature.3.4.g{{hex:7}}",
+                branch_feature_3_hash
+            ),
+            &format!(
+                "1.0.2a{}.post4.dev{{timestamp:now}}+feature.3.4.g{{hex:7}}",
+                branch_feature_3_hash
+            ),
+        );
+        // .expect_schema_variants(create_full_schema_test_cases(
+        //     "1.0.2",
+        //     SchemaTestExtraCore {
+        //         pre_release_label: PreReleaseLabel::Alpha,
+        //         pre_release_num: &branch_feature_3_hash.to_string(),
+        //         post: 4,
+        //         dev: Some("{timestamp:now}"),
+        //     },
+        //     SchemaTestBuild {
+        //         sanitized_branch_name: "feature.3",
+        //         distance: 4,
+        //         include_build_for_standard: true,
+        //     },
+        // ));
+
+        // Step 11: feature-3: Continue development with commits
+        test_info!("Step 11: feature-3: Continue development with commits");
+        let scenario = scenario
+            .commit()
+            .expect_version(
+                &format!(
+                    "1.0.2-alpha.{}.post.5+feature.3.5.g{{hex:7}}",
+                    branch_feature_3_hash
+                ),
+                &format!(
+                    "1.0.2a{}.post5+feature.3.5.g{{hex:7}}",
+                    branch_feature_3_hash
+                ),
+            )
+            // .expect_schema_variants(create_full_schema_test_cases(
+            //     "1.0.2",
+            //     SchemaTestExtraCore {
+            //         pre_release_label: PreReleaseLabel::Alpha,
+            //         pre_release_num: &branch_feature_3_hash.to_string(),
+            //         post: 5,
+            //         dev: None,
+            //     },
+            //     SchemaTestBuild {
+            //         sanitized_branch_name: "feature.3",
+            //         distance: 5,
+            //         include_build_for_standard: true,
+            //     },
+            // ))
+            .commit()
+            .expect_version(
+                &format!(
+                    "1.0.2-alpha.{}.post.6+feature.3.6.g{{hex:7}}",
+                    branch_feature_3_hash
+                ),
+                &format!(
+                    "1.0.2a{}.post6+feature.3.6.g{{hex:7}}",
+                    branch_feature_3_hash
+                ),
+            );
+        // .expect_schema_variants(create_full_schema_test_cases(
+        //     "1.0.2",
+        //     SchemaTestExtraCore {
+        //         pre_release_label: PreReleaseLabel::Alpha,
+        //         pre_release_num: &branch_feature_3_hash.to_string(),
+        //         post: 6,
+        //         dev: None,
+        //     },
+        //     SchemaTestBuild {
+        //         sanitized_branch_name: "feature.3",
+        //         distance: 6,
+        //         include_build_for_standard: true,
+        //     },
+        // ));
+
+        // Step 12: feature-2: Merge feature-3 back to continue development
+        test_info!("Step 12: feature-2: Merge feature-3 back to continue development");
+        let scenario = scenario
+            .checkout("feature-2")
+            .merge_branch("feature-3")
+            .expect_version(
+                &format!(
+                    "1.0.2-alpha.{}.post.6+feature.2.6.g{{hex:7}}",
+                    branch_feature_2_hash
+                ),
+                &format!(
+                    "1.0.2a{}.post6+feature.2.6.g{{hex:7}}",
+                    branch_feature_2_hash
+                ),
+            );
+        // .expect_schema_variants(create_full_schema_test_cases(
+        //     "1.0.2",
+        //     SchemaTestExtraCore {
+        //         pre_release_label: PreReleaseLabel::Alpha,
+        //         pre_release_num: &branch_feature_2_hash.to_string(),
+        //         post: 6,
+        //         dev: None,
+        //     },
+        //     SchemaTestBuild {
+        //         sanitized_branch_name: "feature.2",
+        //         distance: 6,
+        //         include_build_for_standard: true,
+        //     },
+        // ));
+
+        // Step 13: feature-2: Final development before release
+        test_info!("Step 13: feature-2: Final development before release");
+        let scenario = scenario.commit().expect_version(
+            &format!(
+                "1.0.2-alpha.{}.post.7+feature.2.7.g{{hex:7}}",
+                branch_feature_2_hash
+            ),
+            &format!(
+                "1.0.2a{}.post7+feature.2.7.g{{hex:7}}",
+                branch_feature_2_hash
+            ),
+        );
+        // .expect_schema_variants(create_full_schema_test_cases(
+        //     "1.0.2",
+        //     SchemaTestExtraCore {
+        //         pre_release_label: PreReleaseLabel::Alpha,
+        //         pre_release_num: &branch_feature_2_hash.to_string(),
+        //         post: 7,
+        //         dev: None,
+        //     },
+        //     SchemaTestBuild {
+        //         sanitized_branch_name: "feature.2",
+        //         distance: 7,
+        //         include_build_for_standard: true,
+        //     },
+        // ));
+
+        // Step 14: Final release: feature-2 merges to main and releases v1.1.0
+        test_info!("Step 14: Final release: feature-2 merges to main and releases v1.1.0");
+        scenario
+            .checkout("main")
+            .merge_branch("feature-2")
+            .create_tag("v1.1.0")
+            .expect_version("1.1.0", "1.1.0");
+        // .expect_schema_variants(create_base_schema_test_cases("1.1.0", "main"));
     }
 
     #[test]
-    fn test_trunk_based_development_flow() {
-        test_info!("Starting trunk-based development flow test");
+    fn test_gitflow_development_flow() {
+        test_info!("Starting GitFlow development flow test (exactly matching Mermaid diagram)");
         if !should_run_docker_tests() {
             return; // Skip when `ZERV_TEST_DOCKER` are disabled
         }
 
-        let fixture =
-            GitRepoFixture::tagged("v1.0.0").expect("Failed to create git fixture with tag");
+        // Step 1: Initial state: main and develop branches
+        test_info!("Step 1: Initial setup: main branch state with v1.0.0 tag");
+        let scenario = FlowTestScenario::new()
+            .expect("Failed to create test scenario")
+            .create_tag("v1.0.0")
+            .expect_version("1.0.0", "1.0.0");
+        // .expect_schema_variants(create_base_schema_test_cases("1.0.0", "main"));
+
+        // Step 2: Create develop branch with initial development commit
+        test_info!("Step 2: Create develop branch and start development");
+        let scenario = scenario
+            .create_branch("develop")
+            .checkout("develop")
+            .commit()
+            .expect_version(
+                "1.0.1-beta.1.post.1+develop.1.g{hex:7}",
+                "1.0.1b1.post1+develop.1.g{hex:7}",
+            );
+        // .expect_schema_variants(create_full_schema_test_cases(
+        //     "1.0.1",
+        //     SchemaTestExtraCore {
+        //         pre_release_label: PreReleaseLabel::Beta,
+        //         pre_release_num: "1", // develop uses pre_release_num: 1
+        //         post: 1,
+        //         dev: None,
+        //     },
+        //     SchemaTestBuild {
+        //         sanitized_branch_name: "develop",
+        //         distance: 1,
+        //         include_build_for_standard: true,
+        //     },
+        // ));
 
-        let fixture_path = fixture.path().to_string_lossy();
-        // Test template creation (rendering test disabled for now)
-        let _main_hash: Template<u32> =
-            Template::new("{{ hash_int(value='main', length=5) }}".to_string());
+        // Step 3: Feature development from develop branch (trunk-based post mode)
+        test_info!("Step 3: Create feature/auth branch from develop");
+        let branch_feature_auth_hash = expect_branch_hash("feature/auth", 5, "92409");
+        let scenario = scenario
+            .create_branch("feature/auth")
+            .checkout("feature/auth")
+            .commit()
+            .expect_version(
+                &format!(
+                    "1.0.1-alpha.{}.post.2+feature.auth.2.g{{hex:7}}",
+                    branch_feature_auth_hash
+                ),
+                &format!(
+                    "1.0.1a{}.post2+feature.auth.2.g{{hex:7}}",
+                    branch_feature_auth_hash
+                ),
+            )
+            // .expect_schema_variants(create_full_schema_test_cases(
+            //     "1.0.1",
+            //     SchemaTestExtraCore {
+            //         pre_release_label: PreReleaseLabel::Alpha,
+            //         pre_release_num: &branch_feature_auth_hash.to_string(),
+            //         post: 2,
+            //         dev: None,
+            //     },
+            //     SchemaTestBuild {
+            //         sanitized_branch_name: "feature.auth",
+            //         distance: 2,
+            //         include_build_for_standard: true,
+            //     },
+            // ))
+            .commit()
+            .expect_version(
+                &format!(
+                    "1.0.1-alpha.{}.post.3+feature.auth.3.g{{hex:7}}",
+                    branch_feature_auth_hash
+                ),
+                &format!(
+                    "1.0.1a{}.post3+feature.auth.3.g{{hex:7}}",
+                    branch_feature_auth_hash
+                ),
+            );
+        // .expect_schema_variants(create_full_schema_test_cases(
+        //     "1.0.1",
+        //     SchemaTestExtraCore {
+        //         pre_release_label: PreReleaseLabel::Alpha,
+        //         pre_release_num: &branch_feature_auth_hash.to_string(),
+        //         post: 3,
+        //         dev: None,
+        //     },
+        //     SchemaTestBuild {
+        //         sanitized_branch_name: "feature.auth",
+        //         distance: 3,
+        //         include_build_for_standard: true,
+        //     },
+        // ));
 
-        let rendered_hash = _main_hash.render_unwrap(None);
-        test_info!("{}", rendered_hash);
+        // Step 4: Merge feature/auth back to develop
+        test_info!("Step 4: Merge feature/auth back to develop");
+        let scenario = scenario
+            .checkout("develop")
+            .merge_branch("feature/auth")
+            .expect_version(
+                "1.0.1-beta.1.post.3+develop.3.g{hex:7}",
+                "1.0.1b1.post3+develop.3.g{hex:7}",
+            );
+        // .expect_schema_variants(create_full_schema_test_cases(
+        //     "1.0.1",
+        //     SchemaTestExtraCore {
+        //         pre_release_label: PreReleaseLabel::Beta,
+        //         pre_release_num: "1",
+        //         post: 3,
+        //         dev: None,
+        //     },
+        //     SchemaTestBuild {
+        //         sanitized_branch_name: "develop",
+        //         distance: 3,
+        //         include_build_for_standard: true,
+        //     },
+        // ));
 
-        test_flow_pipeline_with_fixture(&fixture_path, "1.0.0", "1.0.0");
+        // Step 5: Hotfix emergency flow from main
+        test_info!("Step 5: Create hotfix/critical branch from main for emergency fix");
+        let branch_hotfix_hash = expect_branch_hash("hotfix/critical", 5, "11477");
+        let scenario = scenario
+            .checkout("main")
+            .create_branch("hotfix/critical")
+            .checkout("hotfix/critical")
+            .commit()
+            .expect_version(
+                &format!(
+                    "1.0.1-alpha.{}.post.1+hotfix.critical.1.g{{hex:7}}",
+                    branch_hotfix_hash
+                ),
+                &format!(
+                    "1.0.1a{}.post1+hotfix.critical.1.g{{hex:7}}",
+                    branch_hotfix_hash
+                ),
+            );
+        // .expect_schema_variants(create_full_schema_test_cases(
+        //     "1.0.1",
+        //     SchemaTestExtraCore {
+        //         pre_release_label: PreReleaseLabel::Alpha,
+        //         pre_release_num: &branch_hotfix_hash.to_string(),
+        //         post: 1,
+        //         dev: None,
+        //     },
+        //     SchemaTestBuild {
+        //         sanitized_branch_name: "hotfix.critical",
+        //         distance: 1,
+        //         include_build_for_standard: true,
+        //     },
+        // ));
 
-        fixture
-            .checkout_branch("feature-1")
-            .expect("Failed to checkout feature-1 branch");
+        // Step 6: Merge hotfix to main and release v1.0.1
+        test_info!("Step 6: Merge hotfix to main and release v1.0.1");
+        let scenario = scenario
+            .checkout("main")
+            .merge_branch("hotfix/critical")
+            .create_tag("v1.0.1")
+            .expect_version("1.0.1", "1.0.1");
+        // .expect_schema_variants(create_base_schema_test_cases("1.0.1", "main"));
 
-        test_flow_pipeline_with_fixture(&fixture_path, "1.0.0", "1.0.0");
+        // Step 7: Sync develop with main changes and continue development
+        test_info!("Step 7: Sync develop with main changes");
+        let scenario = scenario
+            .checkout("develop")
+            .merge_branch("main")
+            .expect_version(
+                "1.0.2-beta.1.post.4+develop.4.g{hex:7}",
+                "1.0.2b1.post4+develop.4.g{hex:7}",
+            );
+        // .expect_schema_variants(create_full_schema_test_cases(
+        //     "1.0.2",
+        //     SchemaTestExtraCore {
+        //         pre_release_label: PreReleaseLabel::Beta,
+        //         pre_release_num: "1",
+        //         post: 4,
+        //         dev: None,
+        //     },
+        //     SchemaTestBuild {
+        //         sanitized_branch_name: "develop",
+        //         distance: 4,
+        //         include_build_for_standard: true,
+        //     },
+        // ));
 
-        // Test template creation (rendering test disabled for now)
-        let _feature_1_hash: Template<u32> =
-            Template::new("{{ hash_int(value='feature-1', length=5) }}".to_string());
-        let rendered_feature_1_hash = _feature_1_hash.render_unwrap(None);
-        test_info!("{}", rendered_feature_1_hash);
+        // Step 8: Continue development on develop
+        test_info!("Step 8: Continue development on develop branch");
+        let scenario = scenario.commit().expect_version(
+            "1.0.2-beta.1.post.5+develop.5.g{hex:7}",
+            "1.0.2b1.post5+develop.5.g{hex:7}",
+        );
+        // .expect_schema_variants(create_full_schema_test_cases(
+        //     "1.0.2",
+        //     SchemaTestExtraCore {
+        //         pre_release_label: PreReleaseLabel::Beta,
+        //         pre_release_num: "1",
+        //         post: 5,
+        //         dev: None,
+        //     },
+        //     SchemaTestBuild {
+        //         sanitized_branch_name: "develop",
+        //         distance: 5,
+        //         include_build_for_standard: true,
+        //     },
+        // ));
 
-        fixture
+        // Step 9: Release branch preparation (release/1) from develop
+        test_info!("Step 9: Create release/1 branch from develop for release preparation");
+        let scenario = scenario
+            .create_branch("release/1")
+            .checkout("release/1")
+            .commit()
+            .expect_version(
+                "1.0.2-rc.1.post.1+release.1.6.g{hex:7}",
+                "1.0.2rc1.post1+release.1.6.g{hex:7}",
+            )
+            // .expect_schema_variants(create_full_schema_test_cases(
+            //     "1.0.2",
+            //     SchemaTestExtraCore {
+            //         pre_release_label: PreReleaseLabel::Rc,
+            //         pre_release_num: "1", // release/1 uses pre_release_num: 1
+            //         post: 1,
+            //         dev: None,
+            //     },
+            //     SchemaTestBuild {
+            //         sanitized_branch_name: "release.1",
+            //         distance: 6,
+            //         include_build_for_standard: true,
+            //     },
+            // ))
+            .create_tag("v1.0.2-rc.1.post.1")
+            .expect_version("1.0.2-rc.1.post.1", "1.0.2rc1.post1")
+            .expect_schema_variants(create_full_schema_test_cases(
+                "1.0.2",
+                SchemaTestExtraCore {
+                    pre_release_label: PreReleaseLabel::Rc,
+                    pre_release_num: "1",
+                    post: 1,
+                    dev: None,
+                },
+                SchemaTestBuild {
+                    sanitized_branch_name: "release.1",
+                    distance: 0,
+                    include_build_for_standard: false,
+                },
+            ))
+            .commit()
+            .expect_version(
+                "1.0.2-rc.1.post.1+release.1.1.g{hex:7}",
+                "1.0.2rc1.post1+release.1.1.g{hex:7}",
+            )
+            // .expect_schema_variants(create_full_schema_test_cases(
+            //     "1.0.2",
+            //     SchemaTestExtraCore {
+            //         pre_release_label: PreReleaseLabel::Rc,
+            //         pre_release_num: "1",
+            //         post: 1,
+            //         dev: None,
+            //     },
+            //     SchemaTestBuild {
+            //         sanitized_branch_name: "release.1",
+            //         distance: 1,
+            //         include_build_for_standard: true,
+            //     },
+            // ))
+            .create_tag("v1.0.2-rc.1.post.2")
+            .expect_version("1.0.2-rc.1.post.2", "1.0.2rc1.post2");
+        // .expect_schema_variants(create_full_schema_test_cases(
+        //     "1.0.2",
+        //     SchemaTestExtraCore {
+        //         pre_release_label: PreReleaseLabel::Rc,
+        //         pre_release_num: "1",
+        //         post: 2,
+        //         dev: None,
+        //     },
+        //     SchemaTestBuild {
+        //         sanitized_branch_name: "release.1",
+        //         distance: 0,
+        //         include_build_for_standard: false,
+        //     },
+        // ));
+
+        // Step 10: Continue release branch development with dirty state and commits
+        test_info!("Step 10: Continue release branch development with dirty state and commits");
+        let scenario = scenario
             .make_dirty()
-            .expect("Failed to make working directory dirty");
+            .expect_version(
+                "1.0.2-rc.1.post.1.dev.{timestamp:now}+release.1.0.g{hex:7}",
+                "1.0.2rc1.post1.dev{timestamp:now}+release.1.0.g{hex:7}",
+            )
+            // .expect_schema_variants(create_full_schema_test_cases(
+            //     "1.0.2",
+            //     SchemaTestExtraCore {
+            //         pre_release_label: PreReleaseLabel::Rc,
+            //         pre_release_num: "1",
+            //         post: 1,
+            //         dev: Some("{timestamp:now}"),
+            //     },
+            //     SchemaTestBuild {
+            //         sanitized_branch_name: "release.1",
+            //         distance: 0,
+            //         include_build_for_standard: true,
+            //     },
+            // ))
+            .commit()
+            .expect_version(
+                "1.0.2-rc.1.post.1+release.1.1.g{hex:7}",
+                "1.0.2rc1.post1+release.1.1.g{hex:7}",
+            )
+            // .expect_schema_variants(create_full_schema_test_cases(
+            //     "1.0.2",
+            //     SchemaTestExtraCore {
+            //         pre_release_label: PreReleaseLabel::Rc,
+            //         pre_release_num: "1",
+            //         post: 1,
+            //         dev: None,
+            //     },
+            //     SchemaTestBuild {
+            //         sanitized_branch_name: "release.1",
+            //         distance: 1,
+            //         include_build_for_standard: true,
+            //     },
+            // ))
+            .create_tag("v1.0.2-rc.1.post.3")
+            .expect_version("1.0.2-rc.1.post.3", "1.0.2rc1.post3");
+        // .expect_schema_variants(create_full_schema_test_cases(
+        //     "1.0.2",
+        //     SchemaTestExtraCore {
+        //         pre_release_label: PreReleaseLabel::Rc,
+        //         pre_release_num: "1",
+        //         post: 3,
+        //         dev: None,
+        //     },
+        //     SchemaTestBuild {
+        //         sanitized_branch_name: "release.1",
+        //         distance: 0,
+        //         include_build_for_standard: false,
+        //     },
+        // ));
 
-        test_flow_pipeline_with_fixture(
-            &fixture_path,
-            "1.0.0-alpha.42954.post.0.dev.{timestamp:now}+feature.1.0.{hex:7}",
-            "1.0.0a42954.post0.dev{timestamp:now}+feature.1.0.{hex:7}",
-        );
+        // Step 11: Final release merge to main
+        test_info!("Step 11: Final release merge to main and release v1.1.0");
+        let scenario = scenario
+            .checkout("main")
+            .merge_branch("release/1")
+            .create_tag("v1.1.0")
+            .debug_git_state("After creating v1.1.0 tag")
+            .copy_test_path_to_cache("v1.1.0-tag-created")
+            .expect_version("1.1.0", "1.1.0");
+        // .expect_schema_variants(create_base_schema_test_cases("1.1.0", "main"));
+
+        // Step 12: Sync develop with release for next cycle
+        test_info!("Step 12: Sync develop with release and prepare for next cycle");
+        let scenario = scenario
+            .checkout("develop")
+            .merge_branch("main")
+            .expect_version("1.1.0", "1.1.0");
+        // .expect_schema_variants(create_base_schema_test_cases("1.1.0", "develop"));
+
+        test_info!("GitFlow test completed successfully - full scenario implemented");
+
+        drop(scenario); // Test completes successfully
     }
 }
diff --git a/src/cli/flow/test_utils.rs b/src/cli/flow/test_utils.rs
new file mode 100644
index 00000000..3ea1683a
--- /dev/null
+++ b/src/cli/flow/test_utils.rs
@@ -0,0 +1,651 @@
+// Test utilities for flow pipeline tests
+
+use crate::cli::flow::args::FlowArgs;
+use crate::cli::flow::pipeline::run_flow_pipeline;
+use crate::cli::utils::template::{
+    Template,
+    TemplateExtGeneric,
+};
+use crate::schema::schema_preset_names::*;
+use crate::test_utils::{
+    GitRepoFixture,
+    assert_version_expectation,
+};
+use crate::version::pep440::utils::pre_release_label_to_pep440_string;
+use crate::version::zerv::PreReleaseLabel;
+use crate::{
+    test_debug,
+    test_info,
+};
+
+/// Generates a branch hash and asserts it matches the expected value
+pub fn expect_branch_hash(branch_name: &str, length: usize, expected_hash: &str) -> String {
+    let hash = Template::<u32>::new(format!(
+        "{{{{ hash_int(value='{}', length={}) }}}}",
+        branch_name, length
+    ))
+    .render_unwrap(None);
+    let hash_str = hash.to_string();
+    assert_eq!(
+        hash_str, expected_hash,
+        "Hash generation for branch '{}' with length {} failed",
+        branch_name, length
+    );
+    hash_str
+}
+
+// Test case structure for better readability and type safety
+#[derive(Debug, Clone)]
+pub struct SchemaTestCase {
+    pub name: &'static str,
+    pub semver_expectation: String,
+    pub pep440_expectation: String,
+}
+
+// Flow test scenario builder pattern
+pub struct FlowTestScenario {
+    fixture: GitRepoFixture,
+}
+
+impl FlowTestScenario {
+    /// Create an empty git repository without any tags
+    pub fn new() -> Result<Self, Box<dyn std::error::Error>> {
+        let fixture = GitRepoFixture::empty()
+            .map_err(|e| format!("Failed to create empty git fixture: {}", e))?;
+
+        Ok(Self { fixture })
+    }
+
+    /// Create a tag in the current git repository
+    pub fn create_tag(self, tag: &str) -> Self {
+        test_info!("Creating tag: {}", tag);
+        Self {
+            fixture: self.fixture.create_tag(tag),
+        }
+    }
+
+    pub fn expect_version(self, semver: &str, pep440: &str) -> Self {
+        test_info!("Expecting version: semver={}, pep440={}", semver, pep440);
+        test_flow_pipeline_with_fixture(&self.test_dir_path(), semver, pep440);
+        self
+    }
+
+    pub fn expect_schema_variants(self, test_cases: Vec<SchemaTestCase>) -> Self {
+        test_info!("Testing {} schema variants", test_cases.len());
+        test_flow_pipeline_with_schema_test_cases(&self.test_dir_path(), test_cases);
+        self
+    }
+
+    /// Create a new branch without checking it out
+    pub fn create_branch(self, branch_name: &str) -> Self {
+        test_info!("Creating branch: {}", branch_name);
+        Self {
+            fixture: self.fixture.with_branch(branch_name),
+        }
+    }
+
+    /// Checkout to an existing branch
+    pub fn checkout(self, branch_name: &str) -> Self {
+        test_info!("Switching to branch: {}", branch_name);
+        Self {
+            fixture: self.fixture.with_checkout(branch_name),
+        }
+    }
+
+    pub fn commit(self) -> Self {
+        test_info!("Making commit");
+        Self {
+            fixture: self.fixture.commit("Test commit"),
+        }
+    }
+
+    pub fn make_dirty(self) -> Self {
+        test_info!("Making working directory dirty");
+        Self {
+            fixture: self.fixture.with_dirty(),
+        }
+    }
+
+    pub fn merge_branch(self, branch_name: &str) -> Self {
+        test_info!("Merging branch: {}", branch_name);
+        Self {
+            fixture: self.fixture.merge_branch(branch_name),
+        }
+    }
+
+    pub fn test_dir_path(&self) -> String {
+        self.fixture.path().to_string_lossy().to_string()
+    }
+
+    pub fn debug_git_state(self, context: &str) -> Self {
+        crate::test_info!("=== DEBUG: {} ===", context);
+        let test_dir_path = self.test_dir_path();
+        crate::test_info!("Test directory: {}", test_dir_path);
+        crate::test_info!(
+            "You can investigate with: cd {} && git log --oneline --graph --all",
+            test_dir_path
+        );
+
+        // Current branch and HEAD info
+        match self
+            .fixture
+            .git_impl
+            .execute_git(&self.fixture.test_dir, &["branch", "--show-current"])
+        {
+            Ok(output) => {
+                crate::test_info!("Current branch: {}", output.trim());
+            }
+            Err(e) => {
+                crate::test_info!("Git: Failed to get current branch: {}", e);
+            }
+        }
+
+        match self
+            .fixture
+            .git_impl
+            .execute_git(&self.fixture.test_dir, &["rev-parse", "HEAD"])
+        {
+            Ok(output) => {
+                crate::test_info!("HEAD commit: {}", output.trim());
+            }
+            Err(e) => {
+                crate::test_info!("Git: Failed to get HEAD: {}", e);
+            }
+        }
+
+        // Tags on current commit
+        match self
+            .fixture
+            .git_impl
+            .execute_git(&self.fixture.test_dir, &["tag", "--points-at", "HEAD"])
+        {
+            Ok(output) => {
+                if output.trim().is_empty() {
+                    crate::test_info!("Tags on HEAD: None");
+                } else {
+                    crate::test_info!("Tags on HEAD: {}", output.trim());
+                }
+            }
+            Err(e) => {
+                crate::test_info!("Git: Failed to get tags on HEAD: {}", e);
+            }
+        }
+
+        // All tags in repo
+        match self.fixture.git_impl.execute_git(
+            &self.fixture.test_dir,
+            &["tag", "--list", "-n", "--sort=-version:refname"],
+        ) {
+            Ok(output) => {
+                crate::test_info!("All tags (sorted):");
+                for line in output.lines().take(10) {
+                    crate::test_info!("Tag: {}", line);
+                }
+            }
+            Err(e) => {
+                crate::test_info!("Git: Failed to get tag list: {}", e);
+            }
+        }
+
+        // Recent commits with tags
+        match self.fixture.git_impl.execute_git(
+            &self.fixture.test_dir,
+            &["log", "--oneline", "--graph", "--all", "--decorate", "-10"],
+        ) {
+            Ok(output) => {
+                crate::test_info!("Recent commits with decorations:");
+                for line in output.lines().take(20) {
+                    crate::test_info!("Commit: {}", line);
+                }
+            }
+            Err(e) => {
+                crate::test_info!("Git: Failed to get log: {}", e);
+            }
+        }
+
+        // Describe current commit
+        match self.fixture.git_impl.execute_git(
+            &self.fixture.test_dir,
+            &["describe", "--tags", "--always", "--abbrev=7"],
+        ) {
+            Ok(output) => {
+                crate::test_info!("Git describe: {}", output.trim());
+            }
+            Err(e) => {
+                crate::test_info!("Git: Failed to describe: {}", e);
+            }
+        }
+
+        crate::test_info!("=== END DEBUG ===");
+        self
+    }
+
+    /// Copy test directory to .cache/tmp for debugging
+    pub fn copy_test_path_to_cache(self, context: &str) -> Self {
+        let test_dir_path = self.test_dir_path();
+        let cache_dir = std::path::Path::new(".cache/tmp");
+
+        // Create cache directory if it doesn't exist
+        if let Err(e) = std::fs::create_dir_all(cache_dir) {
+            crate::test_info!("Failed to create cache directory: {}", e);
+            return self;
+        }
+
+        // Create unique subdirectory for this debug session
+        let timestamp = std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap_or_default()
+            .as_secs();
+        let target_dir = cache_dir.join(format!("{}-{}", context, timestamp));
+
+        // Copy the test directory
+        match std::fs::create_dir_all(&target_dir) {
+            Ok(_) => {
+                // Use cp command for recursive copy
+                match std::process::Command::new("cp")
+                    .arg("-r")
+                    .arg(&test_dir_path)
+                    .arg(&target_dir)
+                    .output()
+                {
+                    Ok(output) => {
+                        if output.status.success() {
+                            crate::test_info!("Copied test directory to: {}", target_dir.display());
+                            crate::test_info!(
+                                "You can investigate with: cd {}",
+                                target_dir.display()
+                            );
+                        } else {
+                            crate::test_info!(
+                                "Failed to copy directory: {}",
+                                String::from_utf8_lossy(&output.stderr)
+                            );
+                        }
+                    }
+                    Err(e) => {
+                        crate::test_info!("Failed to run cp command: {}", e);
+                    }
+                }
+            }
+            Err(e) => {
+                crate::test_info!("Failed to create target directory: {}", e);
+            }
+        }
+        self
+    }
+}
+
+/// Creates comprehensive test cases for ALL standard-related schema constants
+pub struct SchemaTestExtraCore<'a> {
+    pub pre_release_label: PreReleaseLabel,
+    pub pre_release_num: &'a str,
+    pub post: u32,
+    pub dev: Option<&'a str>,
+}
+
+pub struct SchemaTestBuild<'a> {
+    pub sanitized_branch_name: &'a str,
+    pub distance: u32,
+    pub include_build_for_standard: bool,
+}
+
+pub fn create_full_schema_test_cases(
+    base_version: &str,
+    extra_core: SchemaTestExtraCore,
+    build: SchemaTestBuild,
+) -> Vec<SchemaTestCase> {
+    let semver_label = extra_core.pre_release_label.label_str();
+    let pep440_label = pre_release_label_to_pep440_string(&extra_core.pre_release_label);
+
+    let semver_dev = match extra_core.dev {
+        Some(dev_str) => format!(".dev.{}", dev_str),
+        None => String::new(),
+    };
+    let pep440_dev = match extra_core.dev {
+        Some(dev_str) => format!(".dev{}", dev_str),
+        None => String::new(),
+    };
+
+    vec![
+        // Base schemas
+        SchemaTestCase {
+            name: STANDARD_BASE,
+            semver_expectation: base_version.to_string(),
+            pep440_expectation: base_version.to_string(),
+        },
+        SchemaTestCase {
+            name: STANDARD_BASE_PRERELEASE,
+            semver_expectation: format!(
+                "{}-{}.{}",
+                base_version, semver_label, extra_core.pre_release_num
+            ),
+            pep440_expectation: format!(
+                "{}{}{}",
+                base_version, pep440_label, extra_core.pre_release_num
+            ),
+        },
+        SchemaTestCase {
+            name: STANDARD_BASE_PRERELEASE_POST,
+            semver_expectation: format!(
+                "{}-{}.{}.post.{}",
+                base_version, semver_label, extra_core.pre_release_num, extra_core.post
+            ),
+            pep440_expectation: format!(
+                "{}{}{}.post{}",
+                base_version, pep440_label, extra_core.pre_release_num, extra_core.post
+            ),
+        },
+        SchemaTestCase {
+            name: STANDARD_BASE_PRERELEASE_POST_DEV,
+            semver_expectation: format!(
+                "{}-{}.{}.post.{}{}",
+                base_version, semver_label, extra_core.pre_release_num, extra_core.post, semver_dev
+            ),
+            pep440_expectation: format!(
+                "{}{}{}.post{}{}",
+                base_version, pep440_label, extra_core.pre_release_num, extra_core.post, pep440_dev
+            ),
+        },
+        // Context schemas
+        SchemaTestCase {
+            name: STANDARD_BASE_CONTEXT,
+            semver_expectation: format!(
+                "{}+{}.{}.g{{hex:7}}",
+                base_version, build.sanitized_branch_name, build.distance
+            ),
+            pep440_expectation: format!(
+                "{}+{}.{}.g{{hex:7}}",
+                base_version, build.sanitized_branch_name, build.distance
+            ),
+        },
+        SchemaTestCase {
+            name: STANDARD_BASE_PRERELEASE_CONTEXT,
+            semver_expectation: format!(
+                "{}-{}.{}+{}.{}.g{{hex:7}}",
+                base_version,
+                semver_label,
+                extra_core.pre_release_num,
+                build.sanitized_branch_name,
+                build.distance
+            ),
+            pep440_expectation: format!(
+                "{}{}{}+{}.{}.g{{hex:7}}",
+                base_version,
+                pep440_label,
+                extra_core.pre_release_num,
+                build.sanitized_branch_name,
+                build.distance
+            ),
+        },
+        SchemaTestCase {
+            name: STANDARD_BASE_PRERELEASE_POST_CONTEXT,
+            semver_expectation: format!(
+                "{}-{}.{}.post.{}+{}.{}.g{{hex:7}}",
+                base_version,
+                semver_label,
+                extra_core.pre_release_num,
+                extra_core.post,
+                build.sanitized_branch_name,
+                build.distance
+            ),
+            pep440_expectation: format!(
+                "{}{}{}.post{}+{}.{}.g{{hex:7}}",
+                base_version,
+                pep440_label,
+                extra_core.pre_release_num,
+                extra_core.post,
+                build.sanitized_branch_name,
+                build.distance
+            ),
+        },
+        SchemaTestCase {
+            name: STANDARD_BASE_PRERELEASE_POST_DEV_CONTEXT,
+            semver_expectation: format!(
+                "{}-{}.{}.post.{}{}+{}.{}.g{{hex:7}}",
+                base_version,
+                semver_label,
+                extra_core.pre_release_num,
+                extra_core.post,
+                semver_dev,
+                build.sanitized_branch_name,
+                build.distance
+            ),
+            pep440_expectation: format!(
+                "{}{}{}.post{}{}+{}.{}.g{{hex:7}}",
+                base_version,
+                pep440_label,
+                extra_core.pre_release_num,
+                extra_core.post,
+                pep440_dev,
+                build.sanitized_branch_name,
+                build.distance
+            ),
+        },
+        // Complete schemas
+        SchemaTestCase {
+            name: STANDARD_NO_CONTEXT,
+            semver_expectation: format!(
+                "{}-{}.{}.post.{}{}",
+                base_version, semver_label, extra_core.pre_release_num, extra_core.post, semver_dev
+            ),
+            pep440_expectation: format!(
+                "{}{}{}.post{}{}",
+                base_version, pep440_label, extra_core.pre_release_num, extra_core.post, pep440_dev
+            ),
+        },
+        SchemaTestCase {
+            name: STANDARD_CONTEXT,
+            semver_expectation: format!(
+                "{}-{}.{}.post.{}{}+{}.{}.g{{hex:7}}",
+                base_version,
+                semver_label,
+                extra_core.pre_release_num,
+                extra_core.post,
+                semver_dev,
+                build.sanitized_branch_name,
+                build.distance
+            ),
+            pep440_expectation: format!(
+                "{}{}{}.post{}{}+{}.{}.g{{hex:7}}",
+                base_version,
+                pep440_label,
+                extra_core.pre_release_num,
+                extra_core.post,
+                pep440_dev,
+                build.sanitized_branch_name,
+                build.distance
+            ),
+        },
+        SchemaTestCase {
+            name: STANDARD,
+            semver_expectation: if build.include_build_for_standard {
+                format!(
+                    "{}-{}.{}.post.{}{}+{}.{}.g{{hex:7}}",
+                    base_version,
+                    semver_label,
+                    extra_core.pre_release_num,
+                    extra_core.post,
+                    semver_dev,
+                    build.sanitized_branch_name,
+                    build.distance
+                )
+            } else {
+                format!(
+                    "{}-{}.{}.post.{}{}",
+                    base_version,
+                    semver_label,
+                    extra_core.pre_release_num,
+                    extra_core.post,
+                    semver_dev
+                )
+            },
+            pep440_expectation: if build.include_build_for_standard {
+                format!(
+                    "{}{}{}.post{}{}+{}.{}.g{{hex:7}}",
+                    base_version,
+                    pep440_label,
+                    extra_core.pre_release_num,
+                    extra_core.post,
+                    pep440_dev,
+                    build.sanitized_branch_name,
+                    build.distance
+                )
+            } else {
+                format!(
+                    "{}{}{}.post{}{}",
+                    base_version,
+                    pep440_label,
+                    extra_core.pre_release_num,
+                    extra_core.post,
+                    pep440_dev
+                )
+            },
+        },
+    ]
+}
+
+pub fn create_base_schema_test_cases(
+    base_version: &str,
+    sanitized_branch_name: &str,
+) -> Vec<SchemaTestCase> {
+    let distance = 0;
+    let mut test_cases = Vec::new();
+
+    let no_context_schemas = vec![
+        STANDARD,
+        STANDARD_BASE,
+        STANDARD_BASE_PRERELEASE,
+        STANDARD_BASE_PRERELEASE_POST,
+        STANDARD_BASE_PRERELEASE_POST_DEV,
+        STANDARD_NO_CONTEXT,
+    ];
+
+    let context_schemas = vec![
+        STANDARD_BASE_CONTEXT,
+        STANDARD_BASE_PRERELEASE_CONTEXT,
+        STANDARD_BASE_PRERELEASE_POST_CONTEXT,
+        STANDARD_BASE_PRERELEASE_POST_DEV_CONTEXT,
+        STANDARD_CONTEXT,
+    ];
+
+    // Test no context schemas with base version only
+    for schema_name in &no_context_schemas {
+        test_cases.push(SchemaTestCase {
+            name: schema_name,
+            semver_expectation: base_version.to_string(),
+            pep440_expectation: base_version.to_string(),
+        });
+    }
+
+    // Test context schemas with context
+    for schema_name in &context_schemas {
+        test_cases.push(SchemaTestCase {
+            name: schema_name,
+            semver_expectation: format!(
+                "{}+{}.{}.g{{hex:7}}",
+                base_version, sanitized_branch_name, distance
+            ),
+            pep440_expectation: format!(
+                "{}+{}.{}.g{{hex:7}}",
+                base_version, sanitized_branch_name, distance
+            ),
+        });
+    }
+
+    test_cases
+}
+
+pub fn test_flow_pipeline_with_fixture(
+    fixture_path: &str,
+    semver_expectation: &str,
+    pep440_expectation: &str,
+) {
+    test_flow_pipeline_with_fixture_and_schema_opt(
+        fixture_path,
+        None,
+        semver_expectation,
+        pep440_expectation,
+    )
+}
+
+pub fn test_flow_pipeline_with_fixture_and_schema(
+    fixture_path: &str,
+    schema: &str,
+    semver_expectation: &str,
+    pep440_expectation: &str,
+) {
+    test_flow_pipeline_with_fixture_and_schema_opt(
+        fixture_path,
+        Some(schema),
+        semver_expectation,
+        pep440_expectation,
+    )
+}
+
+pub fn test_flow_pipeline_with_fixture_and_schema_opt(
+    fixture_path: &str,
+    schema: Option<&str>,
+    semver_expectation: &str,
+    pep440_expectation: &str,
+) {
+    let test_cases = vec![
+        ("semver", semver_expectation),
+        ("pep440", pep440_expectation),
+    ];
+
+    for (format_name, expectation) in test_cases {
+        let mut args = FlowArgs::default();
+        args.input.directory = Some(fixture_path.to_string());
+        args.output.output_format = format_name.to_string();
+
+        // Set schema if provided
+        if let Some(schema_value) = schema {
+            args.schema = Some(schema_value.to_string());
+        }
+
+        let result = run_flow_pipeline(args, None);
+        let schema_desc = match schema {
+            Some(s) => format!(" and {} schema", s),
+            None => String::new(),
+        };
+
+        assert!(
+            result.is_ok(),
+            "Flow pipeline should succeed with {} format{} at {}: {}",
+            format_name,
+            schema_desc,
+            fixture_path,
+            result.unwrap_err()
+        );
+
+        let output = result.unwrap();
+        assert!(
+            !output.is_empty(),
+            "Flow pipeline should produce output for {} format{}",
+            format_name,
+            schema_desc
+        );
+
+        assert_version_expectation(expectation, &output);
+
+        let log_msg = match schema {
+            Some(s) => format!("{} with {} schema", format_name, s),
+            None => format_name.to_string(),
+        };
+        test_debug!("Flow pipeline output ({}): {}", log_msg, output);
+    }
+}
+
+pub fn test_flow_pipeline_with_schema_test_cases(
+    fixture_path: &str,
+    schema_test_cases: Vec<SchemaTestCase>,
+) {
+    for test_case in schema_test_cases {
+        test_flow_pipeline_with_fixture_and_schema(
+            fixture_path,
+            test_case.name,
+            &test_case.semver_expectation,
+            &test_case.pep440_expectation,
+        );
+    }
+}
diff --git a/src/cli/utils/format_handler.rs b/src/cli/utils/format_handler.rs
index 69c14340..3100b26d 100644
--- a/src/cli/utils/format_handler.rs
+++ b/src/cli/utils/format_handler.rs
@@ -1,95 +1,26 @@
-use std::io::{
-    IsTerminal,
-    Read,
-};
-use std::str::FromStr;
-
 use crate::error::ZervError;
-use crate::version::{
-    PEP440,
-    SemVer,
-    VersionObject,
-    Zerv,
-};
+use crate::version::Zerv;
 
 pub struct InputFormatHandler;
 
 impl InputFormatHandler {
-    /// Parse a version string with the specified format
-    pub fn parse_version_string(
-        version_str: &str,
-        input_format: &str,
-    ) -> Result<VersionObject, ZervError> {
-        match input_format.to_lowercase().as_str() {
-            "semver" => SemVer::from_str(version_str)
-                .map(VersionObject::SemVer)
-                .map_err(|e| {
-                    ZervError::InvalidFormat(format!("Invalid SemVer format '{version_str}': {e}"))
-                }),
-            "pep440" => PEP440::from_str(version_str)
-                .map(VersionObject::PEP440)
-                .map_err(|e| {
-                    ZervError::InvalidFormat(format!("Invalid PEP440 format '{version_str}': {e}"))
-                }),
-            "auto" => Self::parse_auto_detect(version_str),
-            _ => Err(ZervError::UnknownFormat(format!(
-                "Unknown input format '{input_format}'. Supported formats: semver, pep440, auto"
-            ))),
-        }
-    }
-
-    /// Parse stdin input expecting Zerv RON format with comprehensive validation
-    pub fn parse_stdin_to_zerv() -> Result<Zerv, ZervError> {
-        if std::io::stdin().is_terminal() {
-            return Err(ZervError::StdinError(
-                "No input provided via stdin. Use echo or pipe to provide input.".to_string(),
-            ));
-        }
-
-        // Read all input from stdin
-        let mut input = String::new();
-        std::io::stdin()
-            .read_to_string(&mut input)
-            .map_err(|e| ZervError::StdinError(format!("Failed to read from stdin: {e}")))?;
-
-        if input.trim().is_empty() {
-            return Err(ZervError::StdinError(
-                "No input provided via stdin".to_string(),
-            ));
-        }
-
-        // Parse as Zerv RON format
-        Self::parse_and_validate_zerv_ron(&input)
-    }
-
     /// Parse Zerv RON format from input string
-    fn parse_and_validate_zerv_ron(input: &str) -> Result<Zerv, ZervError> {
+    pub fn parse_and_validate_zerv_ron(input: &str) -> Result<Zerv, ZervError> {
         let trimmed_input = input.trim();
 
-        // Try to parse as RON - if it fails, provide a simple error message
-        ron::from_str::<Zerv>(trimmed_input).map_err(|_| {
-            ZervError::StdinError(
-                "Invalid input format. When using --source stdin, provide Zerv RON format only."
+        if trimmed_input.is_empty() {
+            return Err(ZervError::StdinError(
+                "Empty input provided. When using --source stdin, provide valid Zerv RON format."
                     .to_string(),
-            )
-        })
-    }
-
-    /// Auto-detect version format (try SemVer first, then PEP440)
-    fn parse_auto_detect(version_str: &str) -> Result<VersionObject, ZervError> {
-        // Try SemVer first
-        if let Ok(semver) = SemVer::from_str(version_str) {
-            return Ok(VersionObject::SemVer(semver));
-        }
-
-        // Fall back to PEP440
-        if let Ok(pep440) = PEP440::from_str(version_str) {
-            return Ok(VersionObject::PEP440(pep440));
+            ));
         }
 
-        Err(ZervError::InvalidVersion(format!(
-            "Version '{version_str}' is not valid SemVer or PEP440 format"
-        )))
+        // Try to parse as RON with detailed error information
+        ron::from_str::<Zerv>(trimmed_input).map_err(|e| {
+            ZervError::StdinError(format!(
+                "Invalid Zerv RON format: {e}. Expected format: (vars: {{...}}, schema: {{...}})"
+            ))
+        })
     }
 }
 
@@ -104,119 +35,25 @@ mod tests {
         PreReleaseLabel,
     };
 
-    #[rstest]
-    #[case::semver_valid("1.2.3", "semver", true, Some("SemVer"))]
-    #[case::pep440_valid("1.2.3a1", "pep440", true, Some("PEP440"))]
-    #[case::auto_semver("1.2.3", "auto", true, Some("SemVer"))]
-    #[case::auto_pep440("1.2.3a1", "auto", true, Some("PEP440"))]
-    #[case::semver_invalid("invalid", "semver", false, None)]
-    #[case::pep440_invalid("invalid", "pep440", false, None)]
-    #[case::unknown_format("1.2.3", "unknown", false, None)]
-    #[case::auto_invalid("invalid", "auto", false, None)]
-    fn test_parse_version_string(
-        #[case] version: &str,
-        #[case] format: &str,
-        #[case] should_succeed: bool,
-        #[case] expected_type: Option<&str>,
-    ) {
-        let result = InputFormatHandler::parse_version_string(version, format);
-
-        if should_succeed {
-            assert!(result.is_ok(), "Should parse '{version}' as {format}");
-            let version_obj = result.unwrap();
-
-            match expected_type {
-                Some("SemVer") => assert!(matches!(version_obj, VersionObject::SemVer(_))),
-                Some("PEP440") => assert!(matches!(version_obj, VersionObject::PEP440(_))),
-                _ => {}
-            }
-        } else {
-            assert!(
-                result.is_err(),
-                "Should fail to parse '{version}' as {format}"
-            );
-
-            // Verify error type based on format
-            let error = result.unwrap_err();
-            match format {
-                "semver" | "pep440" => assert!(matches!(error, ZervError::InvalidFormat(_))),
-                "unknown" => assert!(matches!(error, ZervError::UnknownFormat(_))),
-                "auto" => assert!(matches!(error, ZervError::InvalidVersion(_))),
-                _ => {}
-            }
-        }
-    }
-
-    #[rstest]
-    #[case::semver_invalid("invalid", "semver", &["Invalid SemVer format", "invalid"])]
-    #[case::pep440_invalid("invalid", "pep440", &["Invalid PEP440 format", "invalid"])]
-    #[case::unknown_format("1.2.3", "unknown", &["Unknown input format", "unknown", "Supported formats"])]
-    fn test_error_messages_format_specific(
-        #[case] version: &str,
-        #[case] format: &str,
-        #[case] expected_substrings: &[&str],
-    ) {
-        let result = InputFormatHandler::parse_version_string(version, format);
-        assert!(result.is_err());
-
-        let error_msg = result.unwrap_err().to_string();
-        for substring in expected_substrings {
-            assert!(
-                error_msg.contains(substring),
-                "Error message should contain '{substring}': {error_msg}"
-            );
-        }
-    }
-
-    #[rstest]
-    #[case::ambiguous_semver("1.2.3", "SemVer")]
-    #[case::pep440_specific("1.2.3a1", "PEP440")]
-    fn test_auto_detection_priority(#[case] version: &str, #[case] expected_type: &str) {
-        let result = InputFormatHandler::parse_version_string(version, "auto");
-        assert!(result.is_ok());
-
-        let version_obj = result.unwrap();
-        match expected_type {
-            "SemVer" => assert!(matches!(version_obj, VersionObject::SemVer(_))),
-            "PEP440" => assert!(matches!(version_obj, VersionObject::PEP440(_))),
-            _ => panic!("Unknown expected type: {expected_type}"),
-        }
-    }
-
     #[test]
-    fn test_stdin_error_messages() {
-        // Test that we get appropriate error messages for wrong input formats
-        // We can't easily test parse_stdin_to_zerv without mocking stdin, but we can test
-        // the error message construction logic by checking the match arms
+    fn test_parse_and_validate_zerv_ron_handles_empty_input() {
+        // Test that empty string returns appropriate error
+        let result = InputFormatHandler::parse_and_validate_zerv_ron("");
+        assert!(result.is_err(), "Should reject empty input");
 
-        // Test semver format error message construction
-        let semver_msg = format!(
-            "When using --source stdin with --input-format {}, stdin must contain Zerv RON format. Use --input-format zerv or provide version via --tag-version instead.",
-            "semver"
-        );
-        assert!(semver_msg.contains("stdin must contain Zerv RON format"));
-        assert!(semver_msg.contains("--input-format zerv"));
-        assert!(semver_msg.contains("--tag-version"));
+        let error = result.unwrap_err();
+        assert!(matches!(error, ZervError::StdinError(_)));
+        assert!(error.to_string().contains("Empty input provided"));
 
-        // Test pep440 format error message construction
-        let pep440_msg = format!(
-            "When using --source stdin with --input-format {}, stdin must contain Zerv RON format. Use --input-format zerv or provide version via --tag-version instead.",
-            "pep440"
-        );
-        assert!(pep440_msg.contains("stdin must contain Zerv RON format"));
+        // Test that whitespace-only string returns appropriate error
+        let result = InputFormatHandler::parse_and_validate_zerv_ron("   \n\t  ");
+        assert!(result.is_err(), "Should reject whitespace-only input");
 
-        // Test unknown format error message construction
-        let unknown_msg = format!(
-            "Unknown input format '{}'. When using --source stdin, use --input-format zerv",
-            "unknown"
-        );
-        assert!(unknown_msg.contains("Unknown input format"));
-        assert!(unknown_msg.contains("--input-format zerv"));
+        let error = result.unwrap_err();
+        assert!(matches!(error, ZervError::StdinError(_)));
+        assert!(error.to_string().contains("Empty input provided"));
     }
 
-    // Note: parse_stdin_to_zerv() is tested via integration tests where we can control stdin.
-    // The parsing logic itself is thoroughly tested via parse_and_validate_zerv_ron() tests below.
-
     #[test]
     fn test_parse_and_validate_zerv_ron_with_valid_input() {
         // Create a valid Zerv object and convert to RON
@@ -310,76 +147,4 @@ mod tests {
         let parsed_zerv = parsed.unwrap();
         assert_eq!(parsed_zerv, zerv);
     }
-
-    #[rstest]
-    #[case::semver_basic("1.2.3", "semver", "SemVer")]
-    #[case::semver_prerelease("1.0.0-alpha", "semver", "SemVer")]
-    #[case::semver_prerelease_num("1.0.0-alpha.1", "semver", "SemVer")]
-    #[case::semver_build("1.0.0+build", "semver", "SemVer")]
-    #[case::semver_both("1.0.0-alpha+build", "semver", "SemVer")]
-    #[case::pep440_basic("1.2.3", "pep440", "PEP440")]
-    #[case::pep440_alpha("1.2.3a1", "pep440", "PEP440")]
-    #[case::pep440_beta("1.2.3b2", "pep440", "PEP440")]
-    #[case::pep440_rc("1.2.3rc1", "pep440", "PEP440")]
-    #[case::pep440_post("1.2.3.post1", "pep440", "PEP440")]
-    #[case::pep440_dev("1.2.3.dev1", "pep440", "PEP440")]
-    #[case::pep440_epoch("2!1.2.3", "pep440", "PEP440")]
-    #[case::auto_semver("1.2.3", "auto", "SemVer")]
-    #[case::auto_pep440_alpha("1.2.3a1", "auto", "PEP440")]
-    #[case::auto_pep440_epoch("2!1.2.3", "auto", "PEP440")]
-    fn test_version_parsing_comprehensive(
-        #[case] version: &str,
-        #[case] format: &str,
-        #[case] expected_type: &str,
-    ) {
-        let result = InputFormatHandler::parse_version_string(version, format);
-        assert!(result.is_ok(), "Should parse '{version}' as {format}");
-
-        let version_obj = result.unwrap();
-        match expected_type {
-            "SemVer" => assert!(matches!(version_obj, VersionObject::SemVer(_))),
-            "PEP440" => assert!(matches!(version_obj, VersionObject::PEP440(_))),
-            _ => panic!("Unknown expected type: {expected_type}"),
-        }
-    }
-
-    #[rstest]
-    #[case::semver_invalid("invalid-version", "semver", &["Invalid SemVer format", "invalid-version"])]
-    #[case::pep440_invalid("invalid-version", "pep440", &["Invalid PEP440 format", "invalid-version"])]
-    #[case::unknown_format("1.2.3", "unknown", &["Unknown input format", "unknown", "Supported formats"])]
-    #[case::auto_invalid("completely-invalid", "auto", &["not valid SemVer or PEP440 format", "completely-invalid"])]
-    fn test_error_message_quality(
-        #[case] version: &str,
-        #[case] format: &str,
-        #[case] expected_substrings: &[&str],
-    ) {
-        let result = InputFormatHandler::parse_version_string(version, format);
-        assert!(result.is_err());
-
-        let error_msg = result.unwrap_err().to_string();
-        for substring in expected_substrings {
-            assert!(
-                error_msg.contains(substring),
-                "Error message should contain '{substring}': {error_msg}"
-            );
-        }
-    }
-
-    #[rstest]
-    #[case::semver_lower("semver", "1.2.3")]
-    #[case::semver_upper("SEMVER", "1.2.3")]
-    #[case::semver_mixed("SemVer", "1.2.3")]
-    #[case::pep440_lower("pep440", "1.2.3a1")]
-    #[case::pep440_upper("PEP440", "1.2.3a1")]
-    #[case::pep440_mixed("Pep440", "1.2.3a1")]
-    #[case::auto_lower("auto", "1.2.3")]
-    #[case::auto_upper("AUTO", "1.2.3")]
-    #[case::auto_mixed("Auto", "1.2.3")]
-    fn test_case_insensitive_format_handling(#[case] format: &str, #[case] version: &str) {
-        let result = InputFormatHandler::parse_version_string(version, format);
-        assert!(
-            result.is_ok(),
-            "Should handle case-insensitive format '{format}' for version '{version}'"
-        );
-    }
 }
diff --git a/src/cli/utils/template/context.rs b/src/cli/utils/template/context.rs
index 253a6dcf..26106313 100644
--- a/src/cli/utils/template/context.rs
+++ b/src/cli/utils/template/context.rs
@@ -27,7 +27,7 @@ pub struct ZervTemplateContext {
     pub bumped_timestamp: Option<u64>,
 
     // Last version fields
-    pub last_branch: Option<String>,
+    // pub last_branch: Option<String>,
     pub last_commit_hash: Option<String>,
     pub last_commit_hash_short: Option<String>,
     pub last_timestamp: Option<u64>,
@@ -66,7 +66,7 @@ impl ZervTemplateContext {
             bumped_commit_hash: vars.bumped_commit_hash.clone(),
             bumped_commit_hash_short: vars.get_bumped_commit_hash_short(),
             bumped_timestamp: vars.bumped_timestamp,
-            last_branch: vars.last_branch.clone(),
+            // last_branch: vars.last_branch.clone(),
             last_commit_hash: vars.last_commit_hash.clone(),
             last_commit_hash_short: vars.get_last_commit_hash_short(),
             last_timestamp: vars.last_timestamp,
@@ -111,7 +111,7 @@ mod tests {
             Some(5),
             Some(true),
             Some("feature/test".to_string()),
-            Some("abc123def456".to_string()),
+            Some("gabc123def456".to_string()),
             Some("abc123".to_string()),
             Some(1703123456),
             Some("main".to_string()),
@@ -123,10 +123,13 @@ mod tests {
         assert_eq!(context.distance, Some(5));
         assert_eq!(context.dirty, Some(true));
         assert_eq!(context.bumped_branch, Some("feature/test".to_string()));
-        assert_eq!(context.bumped_commit_hash, Some("abc123def456".to_string()));
+        assert_eq!(
+            context.bumped_commit_hash,
+            Some("gabc123def456".to_string())
+        );
         assert_eq!(
             context.bumped_commit_hash_short,
-            Some("abc123d".to_string())
+            Some("gabc123d".to_string())
         );
         // bumped_timestamp is not set by with_vcs_data, so we won't test it here
     }
diff --git a/src/cli/version/args/main.rs b/src/cli/version/args/main.rs
index 70d5126d..2f80d34e 100644
--- a/src/cli/version/args/main.rs
+++ b/src/cli/version/args/main.rs
@@ -43,6 +43,16 @@ CalVer Schema Family:
     pub schema_ron: Option<String>,
 }
 
+impl MainConfig {
+    /// Create MainConfig from schema name
+    pub fn from_schema(schema: Option<String>) -> Self {
+        Self {
+            schema,
+            schema_ron: None,
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -54,6 +64,20 @@ mod tests {
         assert!(config.schema_ron.is_none());
     }
 
+    #[test]
+    fn test_main_config_from_schema() {
+        let config = MainConfig::from_schema(Some("standard".to_string()));
+        assert_eq!(config.schema, Some("standard".to_string()));
+        assert!(config.schema_ron.is_none());
+    }
+
+    #[test]
+    fn test_main_config_from_schema_none() {
+        let config = MainConfig::from_schema(None);
+        assert!(config.schema.is_none());
+        assert!(config.schema_ron.is_none());
+    }
+
     #[test]
     fn test_main_config_construction() {
         // Test direct construction with schema
diff --git a/src/cli/version/git_pipeline.rs b/src/cli/version/git_pipeline.rs
index 02d831b7..ba6942fc 100644
--- a/src/cli/version/git_pipeline.rs
+++ b/src/cli/version/git_pipeline.rs
@@ -2,9 +2,9 @@ use std::path::Path;
 
 use super::args::VersionArgs;
 use super::zerv_draft::ZervDraft;
-use crate::cli::utils::format_handler::InputFormatHandler;
 use crate::error::ZervError;
 use crate::pipeline::vcs_data_to_zerv_vars;
+use crate::version::VersionObject;
 
 /// Process git source and return a ZervDraft object
 pub fn process_git_source(work_dir: &Path, args: &VersionArgs) -> Result<ZervDraft, ZervError> {
@@ -16,17 +16,18 @@ pub fn process_git_source(work_dir: &Path, args: &VersionArgs) -> Result<ZervDra
     } else {
         None
     };
-    let vcs_data = crate::vcs::detect_vcs_with_limit(work_dir, max_depth)?.get_vcs_data()?;
+    let vcs_data = crate::vcs::detect_vcs_with_limit(work_dir, max_depth)?
+        .get_vcs_data(&args.input.input_format)?;
 
     // Parse git tag with input format if available and validate it
     if let Some(ref tag_version) = vcs_data.tag_version {
         let _parsed_version =
-            InputFormatHandler::parse_version_string(tag_version, &args.input.input_format)?;
+            VersionObject::parse_with_format(tag_version, &args.input.input_format)?;
         // Validation passed - the tag is in a valid format
     }
 
     // Convert VCS data to ZervVars
-    let vars = vcs_data_to_zerv_vars(vcs_data)?;
+    let vars = vcs_data_to_zerv_vars(vcs_data, &args.input.input_format)?;
 
     // Return ZervDraft without schema (git source)
     Ok(ZervDraft::new(vars, None))
diff --git a/src/cli/version/mod.rs b/src/cli/version/mod.rs
index 9bdffbb7..4332439c 100644
--- a/src/cli/version/mod.rs
+++ b/src/cli/version/mod.rs
@@ -7,5 +7,5 @@ pub mod zerv_draft;
 pub use args::VersionArgs;
 pub use git_pipeline::process_git_source;
 pub use pipeline::run_version_pipeline;
-pub use stdin_pipeline::process_stdin_source;
+pub use stdin_pipeline::process_cached_stdin_source;
 pub use zerv_draft::ZervDraft;
diff --git a/src/cli/version/pipeline.rs b/src/cli/version/pipeline.rs
index 4d01071b..527bc3d4 100644
--- a/src/cli/version/pipeline.rs
+++ b/src/cli/version/pipeline.rs
@@ -5,7 +5,10 @@ use crate::cli::utils::output_formatter::OutputFormatter;
 use crate::error::ZervError;
 use crate::utils::constants::sources;
 
-pub fn run_version_pipeline(mut args: VersionArgs) -> Result<String, ZervError> {
+pub fn run_version_pipeline(
+    mut args: VersionArgs,
+    stdin_content: Option<&str>,
+) -> Result<String, ZervError> {
     // 0. Early validation - fail fast on conflicting options
     args.validate()?;
 
@@ -18,7 +21,7 @@ pub fn run_version_pipeline(mut args: VersionArgs) -> Result<String, ZervError>
     // 2. Get ZervDraft from source (no schema applied yet)
     let zerv_draft = match args.input.source.as_str() {
         sources::GIT => super::git_pipeline::process_git_source(&work_dir, &args)?,
-        sources::STDIN => super::stdin_pipeline::process_stdin_source(&args)?,
+        sources::STDIN => super::stdin_pipeline::process_cached_stdin_source(&args, stdin_content)?,
         source => return Err(ZervError::UnknownSource(source.to_string())),
     };
 
diff --git a/src/cli/version/stdin_pipeline.rs b/src/cli/version/stdin_pipeline.rs
index 6be4b552..b7e8a7bd 100644
--- a/src/cli/version/stdin_pipeline.rs
+++ b/src/cli/version/stdin_pipeline.rs
@@ -3,10 +3,20 @@ use super::zerv_draft::ZervDraft;
 use crate::cli::utils::format_handler::InputFormatHandler;
 use crate::error::ZervError;
 
-/// Process stdin source and return a ZervDraft object
-pub fn process_stdin_source(_args: &VersionArgs) -> Result<ZervDraft, ZervError> {
-    // Parse stdin as Zerv RON (includes schema)
-    let zerv_from_stdin = InputFormatHandler::parse_stdin_to_zerv()?;
+/// Process stdin content and return a ZervDraft object
+/// Expects cached stdin content (None should not happen with centralized extraction)
+pub fn process_cached_stdin_source(
+    _args: &VersionArgs,
+    stdin_content: Option<&str>,
+) -> Result<ZervDraft, ZervError> {
+    let content = stdin_content.ok_or_else(|| {
+        ZervError::StdinError(
+            "No stdin content provided to process_cached_stdin_source".to_string(),
+        )
+    })?;
+
+    // Parse stdin content as Zerv RON (includes schema)
+    let zerv_from_stdin = InputFormatHandler::parse_and_validate_zerv_ron(content)?;
 
     // Return ZervDraft with existing schema (stdin source)
     Ok(ZervDraft::new(
diff --git a/src/pipeline/mod.rs b/src/pipeline/mod.rs
index 670c3b2b..e140a9b2 100644
--- a/src/pipeline/mod.rs
+++ b/src/pipeline/mod.rs
@@ -1,5 +1,3 @@
-pub mod parse_version_from_tag;
 pub mod vcs_data_to_zerv_vars;
 
-pub use parse_version_from_tag::parse_version_from_tag;
 pub use vcs_data_to_zerv_vars::vcs_data_to_zerv_vars;
diff --git a/src/pipeline/parse_version_from_tag.rs b/src/pipeline/parse_version_from_tag.rs
deleted file mode 100644
index 678a9690..00000000
--- a/src/pipeline/parse_version_from_tag.rs
+++ /dev/null
@@ -1,166 +0,0 @@
-use std::str::FromStr;
-
-use crate::version::{
-    PEP440,
-    SemVer,
-    VersionObject,
-};
-
-/// Parse version from tag string with optional format specification
-pub fn parse_version_from_tag(tag: &str, input_format: Option<&str>) -> Option<VersionObject> {
-    match input_format {
-        Some(format) => VersionObject::parse_with_format(tag, format),
-        None => {
-            // Auto-detection: try SemVer first, then PEP440
-            if let Ok(semver) = SemVer::from_str(tag) {
-                return Some(VersionObject::SemVer(semver));
-            }
-
-            if let Ok(pep440) = PEP440::from_str(tag) {
-                return Some(VersionObject::PEP440(pep440));
-            }
-
-            None
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use rstest::rstest;
-
-    use super::*;
-
-    #[rstest]
-    // Basic SemVer cases (auto-detection should pick SemVer first)
-    #[case("1.2.3", "1.2.3", "semver")]
-    #[case("v1.2.3", "1.2.3", "semver")]
-    #[case("0.0.0", "0.0.0", "semver")]
-    #[case("10.20.30", "10.20.30", "semver")]
-    // SemVer with pre-release
-    #[case("1.0.0-alpha", "1.0.0-alpha", "semver")]
-    #[case("1.0.0-alpha.1", "1.0.0-alpha.1", "semver")]
-    #[case("1.0.0-beta.2", "1.0.0-beta.2", "semver")]
-    #[case("1.0.0-rc.1", "1.0.0-rc.1", "semver")]
-    // SemVer with build metadata
-    #[case("1.0.0+build.1", "1.0.0+build.1", "semver")]
-    #[case("1.0.0-alpha.1+build.123", "1.0.0-alpha.1+build.123", "semver")]
-    // PEP440-specific cases (should fall back to PEP440)
-    #[case("1.2.3a1", "1.2.3a1", "pep440")]
-    #[case("1.2.3b2", "1.2.3b2", "pep440")]
-    #[case("1.2.3rc3", "1.2.3rc3", "pep440")]
-    #[case("1.2.3.post1", "1.2.3.post1", "pep440")]
-    #[case("1.2.3.dev1", "1.2.3.dev1", "pep440")]
-    #[case("2!1.2.3", "2!1.2.3", "pep440")]
-    // PEP440 unnormalized forms
-    #[case("1.2.3_alpha1", "1.2.3a1", "pep440")]
-    #[case("1.2.3.ALPHA.1", "1.2.3a1", "pep440")]
-    #[case("1.2.3.POST.1", "1.2.3.post1", "pep440")]
-    // Complex PEP440 cases
-    #[case(
-        "2!1.2.3a1.post1.dev1+local.1",
-        "2!1.2.3a1.post1.dev1+local.1",
-        "pep440"
-    )]
-    fn test_parse_version_from_tag_auto_detection(
-        #[case] tag: &str,
-        #[case] expected_str: &str,
-        #[case] expected_format: &str,
-    ) {
-        let version = parse_version_from_tag(tag, None)
-            .unwrap_or_else(|| panic!("Failed to parse tag: {tag}"));
-
-        // Direct comparison - no conversion needed!
-        assert_eq!(version.format_str(), expected_format);
-
-        match expected_format {
-            "semver" => {
-                if let VersionObject::SemVer(semver) = version {
-                    let expected: SemVer = expected_str.parse().unwrap_or_else(|_| {
-                        panic!("Failed to parse expected SemVer: {expected_str}")
-                    });
-                    assert_eq!(semver, expected);
-                } else {
-                    panic!("Expected SemVer, got {version:?}");
-                }
-            }
-            "pep440" => {
-                if let VersionObject::PEP440(pep440) = version {
-                    let expected: PEP440 = expected_str.parse().unwrap_or_else(|_| {
-                        panic!("Failed to parse expected PEP440: {expected_str}")
-                    });
-                    assert_eq!(pep440, expected);
-                } else {
-                    panic!("Expected PEP440, got {version:?}");
-                }
-            }
-            _ => panic!("Unknown expected format: {expected_format}"),
-        }
-    }
-
-    #[rstest]
-    #[case("1.2.3", "1.2.3")]
-    #[case("v1.2.3", "1.2.3")]
-    #[case("1.2.3a1", "1.2.3a1")]
-    #[case("2!1.2.3.post1.dev1", "2!1.2.3.post1.dev1")]
-    #[case("1.2.3_alpha1", "1.2.3a1")] // unnormalized
-    fn test_parse_version_from_tag_explicit_pep440(#[case] tag: &str, #[case] expected_str: &str) {
-        let version = parse_version_from_tag(tag, Some("pep440"))
-            .unwrap_or_else(|| panic!("Failed to parse PEP440 tag: {tag}"));
-
-        if let VersionObject::PEP440(pep440) = version {
-            let expected: PEP440 = expected_str
-                .parse()
-                .unwrap_or_else(|_| panic!("Failed to parse expected PEP440: {expected_str}"));
-            assert_eq!(pep440, expected);
-        } else {
-            panic!("Expected PEP440, got {version:?}");
-        }
-    }
-
-    #[rstest]
-    #[case("1.2.3", "1.2.3")]
-    #[case("v1.2.3", "1.2.3")]
-    #[case("1.0.0-alpha.1", "1.0.0-alpha.1")]
-    #[case("1.0.0+build.123", "1.0.0+build.123")]
-    #[case("1.0.0-alpha.1+build.123", "1.0.0-alpha.1+build.123")]
-    fn test_parse_version_from_tag_explicit_semver(#[case] tag: &str, #[case] expected_str: &str) {
-        let version = parse_version_from_tag(tag, Some("semver"))
-            .unwrap_or_else(|| panic!("Failed to parse SemVer tag: {tag}"));
-
-        if let VersionObject::SemVer(semver) = version {
-            let expected: SemVer = expected_str
-                .parse()
-                .unwrap_or_else(|_| panic!("Failed to parse expected SemVer: {expected_str}"));
-            assert_eq!(semver, expected);
-        } else {
-            panic!("Expected SemVer, got {version:?}");
-        }
-    }
-
-    #[rstest]
-    #[case("invalid")]
-    #[case("")]
-    #[case("abc.def.ghi")]
-    fn test_parse_version_from_tag_invalid(#[case] tag: &str) {
-        let version = parse_version_from_tag(tag, None);
-        assert!(version.is_none());
-    }
-
-    #[rstest]
-    #[case("1.2.3", "unknown")]
-    #[case("1.2.3", "invalid")]
-    #[case("1.2.3", "custom")]
-    fn test_parse_version_from_tag_unknown_format(#[case] tag: &str, #[case] format: &str) {
-        let version = parse_version_from_tag(tag, Some(format));
-        assert!(version.is_none());
-    }
-
-    #[rstest]
-    #[case("1.2.3a1", "semver")] // PEP440 format with SemVer parser
-    #[case("1.2.3.post1", "semver")] // PEP440 post-release with SemVer parser
-    fn test_parse_version_from_tag_wrong_format(#[case] tag: &str, #[case] format: &str) {
-        let version = parse_version_from_tag(tag, Some(format));
-        assert!(version.is_none());
-    }
-}
diff --git a/src/pipeline/vcs_data_to_zerv_vars.rs b/src/pipeline/vcs_data_to_zerv_vars.rs
index 4f894756..5fc51a2d 100644
--- a/src/pipeline/vcs_data_to_zerv_vars.rs
+++ b/src/pipeline/vcs_data_to_zerv_vars.rs
@@ -1,18 +1,28 @@
-use super::parse_version_from_tag::parse_version_from_tag;
 use crate::error::ZervError;
 use crate::vcs::VcsData;
-use crate::version::ZervVars;
+use crate::version::{
+    VersionObject,
+    ZervVars,
+};
 
 /// Convert VCS data to ZervVars
-pub fn vcs_data_to_zerv_vars(vcs_data: VcsData) -> Result<ZervVars, ZervError> {
-    tracing::debug!("Converting VCS data to Zerv variables");
+pub fn vcs_data_to_zerv_vars(vcs_data: VcsData, input_format: &str) -> Result<ZervVars, ZervError> {
+    tracing::debug!(
+        "Converting VCS data to Zerv variables with input format: {}",
+        input_format
+    );
     tracing::debug!("VCS data: {:?}", vcs_data);
 
-    // Parse version from tag_version
+    // Parse version from tag_version using the provided input format
     let version = if let Some(ref tag_version) = vcs_data.tag_version {
-        parse_version_from_tag(tag_version, None).ok_or_else(|| {
-            tracing::error!("Failed to parse version from tag: {}", tag_version);
-            ZervError::InvalidFormat(format!("Failed to parse version from tag: {tag_version}"))
+        VersionObject::parse_with_format(tag_version, input_format).map_err(|e| {
+            tracing::error!(
+                "Failed to parse version from tag: {} with format {}: {}",
+                tag_version,
+                input_format,
+                e
+            );
+            e
         })?
     } else {
         tracing::warn!("No tag version found in VCS data");
@@ -25,7 +35,14 @@ pub fn vcs_data_to_zerv_vars(vcs_data: VcsData) -> Result<ZervVars, ZervError> {
     vars.distance = Some(vcs_data.distance as u64);
     vars.bumped_branch = vcs_data.current_branch;
     vars.dirty = Some(vcs_data.is_dirty);
-    vars.bumped_commit_hash = Some(vcs_data.commit_hash);
+    vars.bumped_commit_hash = Some(format!(
+        "{}{}",
+        vcs_data.commit_hash_prefix, vcs_data.commit_hash
+    ));
+    // Set last_commit_hash if available from tag_commit_hash
+    vars.last_commit_hash = vcs_data
+        .tag_commit_hash
+        .map(|hash| format!("{}{}", vcs_data.commit_hash_prefix, hash));
     vars.bumped_timestamp = Some(vcs_data.commit_timestamp as u64);
     vars.last_timestamp = vcs_data.tag_timestamp.map(|t| t as u64);
 
@@ -45,18 +62,19 @@ mod tests {
     };
 
     #[rstest]
-    #[case::semver(get_real_semver_vcs_data(), (1, 2, 3), "SemVer")]
-    #[case::pep440(get_real_pep440_vcs_data(), (2, 0, 1), "PEP440")]
+    #[case::semver(get_real_semver_vcs_data(), (1, 2, 3), "SemVer", "auto")]
+    #[case::pep440(get_real_pep440_vcs_data(), (2, 0, 1), "PEP440", "auto")]
     fn test_vcs_data_to_zerv_vars_real_formats(
         #[case] vcs_data: &VcsData,
         #[case] expected_version: (u64, u64, u64),
         #[case] format_name: &str,
+        #[case] input_format: &str,
     ) {
         if !should_run_docker_tests() {
             return;
         }
 
-        let vars = vcs_data_to_zerv_vars(vcs_data.clone())
+        let vars = vcs_data_to_zerv_vars(vcs_data.clone(), input_format)
             .unwrap_or_else(|_| panic!("Failed to convert {format_name} VCS data to ZervVars"));
 
         assert_eq!(
@@ -81,6 +99,10 @@ mod tests {
             vars.last_timestamp.is_some(),
             "Tag timestamp should be present for {format_name}"
         );
+        assert!(
+            vars.last_commit_hash.is_some(),
+            "Last commit hash should be present for {format_name}"
+        );
     }
 
     #[test]
@@ -90,7 +112,7 @@ mod tests {
             commit_hash: "abc1234".to_string(),
             ..Default::default()
         };
-        let result = vcs_data_to_zerv_vars(vcs_data);
+        let result = vcs_data_to_zerv_vars(vcs_data, "auto");
         assert!(result.is_err());
 
         match result {
@@ -104,6 +126,70 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_vcs_data_to_zerv_vars_with_tag_commit_hash() {
+        let vcs_data = VcsData {
+            tag_version: Some("v1.2.3".to_string()),
+            distance: 5,
+            commit_hash: "def456789".to_string(),
+            commit_hash_prefix: "g".to_string(),
+            tag_commit_hash: Some("abc123def456".to_string()),
+            current_branch: Some("main".to_string()),
+            commit_timestamp: 1703123456,
+            tag_timestamp: Some(1703000000),
+            is_dirty: false,
+            is_shallow: false,
+        };
+
+        let vars =
+            vcs_data_to_zerv_vars(vcs_data, "auto").expect("should convert vcs data to vars");
+
+        // Check that last_commit_hash is set with prefix
+        assert_eq!(
+            vars.last_commit_hash,
+            Some("gabc123def456".to_string()),
+            "Last commit hash should be set with g prefix"
+        );
+
+        // Check other fields are also set correctly
+        assert_eq!(vars.distance, Some(5));
+        assert_eq!(vars.bumped_branch, Some("main".to_string()));
+        assert_eq!(vars.dirty, Some(false));
+        assert_eq!(vars.bumped_commit_hash, Some("gdef456789".to_string()));
+        assert_eq!(vars.bumped_timestamp, Some(1703123456));
+        assert_eq!(vars.last_timestamp, Some(1703000000));
+    }
+
+    #[test]
+    fn test_vcs_data_to_zerv_vars_without_tag_commit_hash() {
+        let vcs_data = VcsData {
+            tag_version: Some("v1.2.3".to_string()),
+            distance: 0,
+            commit_hash: "abc123def456".to_string(),
+            commit_hash_prefix: "g".to_string(),
+            tag_commit_hash: None, // No tag commit hash
+            current_branch: Some("main".to_string()),
+            commit_timestamp: 1703123456,
+            tag_timestamp: Some(1703000000),
+            is_dirty: false,
+            is_shallow: false,
+        };
+
+        let vars =
+            vcs_data_to_zerv_vars(vcs_data, "auto").expect("should convert vcs data to vars");
+
+        // Check that last_commit_hash is None when tag_commit_hash is None
+        assert_eq!(
+            vars.last_commit_hash, None,
+            "Last commit hash should be None when tag_commit_hash is None"
+        );
+
+        // Other fields should still be set
+        assert_eq!(vars.distance, Some(0));
+        assert_eq!(vars.bumped_branch, Some("main".to_string()));
+        assert_eq!(vars.bumped_commit_hash, Some("gabc123def456".to_string()));
+    }
+
     #[rstest]
     #[case("invalid")]
     #[case("")]
@@ -118,16 +204,35 @@ mod tests {
             commit_hash: "abc1234".to_string(),
             ..Default::default()
         };
-        let result = vcs_data_to_zerv_vars(vcs_data);
+        let result = vcs_data_to_zerv_vars(vcs_data, "auto");
 
         match result {
             Err(ZervError::InvalidFormat(msg)) => {
-                assert_eq!(
-                    msg,
-                    format!("Failed to parse version from tag: {invalid_tag}")
+                // Check that the error message contains the tag name
+                assert!(
+                    msg.contains(invalid_tag),
+                    "Error message should contain tag: {}",
+                    msg
+                );
+                // Check that it contains format information
+                assert!(
+                    msg.contains("auto") || msg.contains("semver") || msg.contains("pep440"),
+                    "Error message should contain format information: {}",
+                    msg
                 );
             }
-            _ => panic!("Expected InvalidFormat error for tag: {invalid_tag}"),
+            Err(ZervError::InvalidVersion(msg)) => {
+                // Check that the error message contains the tag name for auto-detection failures
+                assert!(
+                    msg.contains(invalid_tag),
+                    "Error message should contain tag: {}",
+                    msg
+                );
+            }
+            _ => panic!(
+                "Expected InvalidFormat or InvalidVersion error for tag: {invalid_tag}, got: {:?}",
+                result
+            ),
         }
     }
 }
diff --git a/src/schema/components.rs b/src/schema/components.rs
new file mode 100644
index 00000000..ad159183
--- /dev/null
+++ b/src/schema/components.rs
@@ -0,0 +1,63 @@
+use crate::utils::constants::timestamp_patterns;
+use crate::version::zerv::{
+    Component,
+    Var,
+};
+
+pub fn standard_core() -> Vec<Component> {
+    vec![
+        Component::Var(Var::Major),
+        Component::Var(Var::Minor),
+        Component::Var(Var::Patch),
+    ]
+}
+
+pub fn calver_core() -> Vec<Component> {
+    vec![
+        Component::Var(Var::Timestamp(timestamp_patterns::YYYY.to_string())),
+        Component::Var(Var::Timestamp(timestamp_patterns::MM.to_string())),
+        Component::Var(Var::Timestamp(timestamp_patterns::DD.to_string())),
+        Component::Var(Var::Patch),
+    ]
+}
+
+pub fn prerelease_core() -> Vec<Component> {
+    vec![Component::Var(Var::Epoch), Component::Var(Var::PreRelease)]
+}
+
+pub fn prerelease_post_core() -> Vec<Component> {
+    vec![
+        Component::Var(Var::Epoch),
+        Component::Var(Var::PreRelease),
+        Component::Var(Var::Post),
+    ]
+}
+
+pub fn prerelease_post_dev_core() -> Vec<Component> {
+    vec![
+        Component::Var(Var::Epoch),
+        Component::Var(Var::PreRelease),
+        Component::Var(Var::Post),
+        Component::Var(Var::Dev),
+    ]
+}
+
+pub fn build_context() -> Vec<Component> {
+    vec![
+        Component::Var(Var::BumpedBranch),
+        Component::Var(Var::Distance),
+        Component::Var(Var::BumpedCommitHashShort),
+    ]
+}
+
+pub fn build_if_enabled(with_context: bool) -> Vec<Component> {
+    if with_context {
+        build_context()
+    } else {
+        vec![]
+    }
+}
+
+pub fn epoch_extra_core() -> Vec<Component> {
+    vec![Component::Var(Var::Epoch)]
+}
diff --git a/src/schema/mod.rs b/src/schema/mod.rs
index ec3dae77..8c17699f 100644
--- a/src/schema/mod.rs
+++ b/src/schema/mod.rs
@@ -1,8 +1,8 @@
+mod components;
+mod names;
 mod presets;
 
-pub use presets::{
-    ZervSchemaPreset,
-    schema_preset_names,
-};
+pub use names::schema_preset_names;
+pub use presets::ZervSchemaPreset;
 
 pub use crate::version::zerv::schema::parse_ron_schema;
diff --git a/src/schema/names.rs b/src/schema/names.rs
new file mode 100644
index 00000000..c970255f
--- /dev/null
+++ b/src/schema/names.rs
@@ -0,0 +1,27 @@
+pub mod schema_preset_names {
+    pub const STANDARD: &str = "standard";
+    pub const STANDARD_NO_CONTEXT: &str = "standard-no-context";
+    pub const STANDARD_BASE: &str = "standard-base";
+    pub const STANDARD_BASE_PRERELEASE: &str = "standard-base-prerelease";
+    pub const STANDARD_BASE_PRERELEASE_POST: &str = "standard-base-prerelease-post";
+    pub const STANDARD_BASE_PRERELEASE_POST_DEV: &str = "standard-base-prerelease-post-dev";
+    pub const STANDARD_BASE_CONTEXT: &str = "standard-base-context";
+    pub const STANDARD_BASE_PRERELEASE_CONTEXT: &str = "standard-base-prerelease-context";
+    pub const STANDARD_BASE_PRERELEASE_POST_CONTEXT: &str = "standard-base-prerelease-post-context";
+    pub const STANDARD_BASE_PRERELEASE_POST_DEV_CONTEXT: &str =
+        "standard-base-prerelease-post-dev-context";
+    pub const STANDARD_CONTEXT: &str = "standard-context";
+
+    pub const CALVER: &str = "calver";
+    pub const CALVER_NO_CONTEXT: &str = "calver-no-context";
+    pub const CALVER_BASE: &str = "calver-base";
+    pub const CALVER_BASE_PRERELEASE: &str = "calver-base-prerelease";
+    pub const CALVER_BASE_PRERELEASE_POST: &str = "calver-base-prerelease-post";
+    pub const CALVER_BASE_PRERELEASE_POST_DEV: &str = "calver-base-prerelease-post-dev";
+    pub const CALVER_BASE_CONTEXT: &str = "calver-base-context";
+    pub const CALVER_BASE_PRERELEASE_CONTEXT: &str = "calver-base-prerelease-context";
+    pub const CALVER_BASE_PRERELEASE_POST_CONTEXT: &str = "calver-base-prerelease-post-context";
+    pub const CALVER_BASE_PRERELEASE_POST_DEV_CONTEXT: &str =
+        "calver-base-prerelease-post-dev-context";
+    pub const CALVER_CONTEXT: &str = "calver-context";
+}
diff --git a/src/schema/presets.rs b/src/schema/presets.rs
index 221c3e59..80f235ff 100644
--- a/src/schema/presets.rs
+++ b/src/schema/presets.rs
@@ -1,105 +1,45 @@
 use std::str::FromStr;
 
+pub use super::components::{
+    build_context,
+    build_if_enabled,
+    calver_core,
+    epoch_extra_core,
+    prerelease_core,
+    prerelease_post_core,
+    prerelease_post_dev_core,
+    standard_core,
+};
+pub use super::names::schema_preset_names::{
+    CALVER,
+    CALVER_BASE,
+    CALVER_BASE_CONTEXT,
+    CALVER_BASE_PRERELEASE,
+    CALVER_BASE_PRERELEASE_CONTEXT,
+    CALVER_BASE_PRERELEASE_POST,
+    CALVER_BASE_PRERELEASE_POST_CONTEXT,
+    CALVER_BASE_PRERELEASE_POST_DEV,
+    CALVER_BASE_PRERELEASE_POST_DEV_CONTEXT,
+    CALVER_CONTEXT,
+    CALVER_NO_CONTEXT,
+    STANDARD,
+    STANDARD_BASE,
+    STANDARD_BASE_CONTEXT,
+    STANDARD_BASE_PRERELEASE,
+    STANDARD_BASE_PRERELEASE_CONTEXT,
+    STANDARD_BASE_PRERELEASE_POST,
+    STANDARD_BASE_PRERELEASE_POST_CONTEXT,
+    STANDARD_BASE_PRERELEASE_POST_DEV,
+    STANDARD_BASE_PRERELEASE_POST_DEV_CONTEXT,
+    STANDARD_CONTEXT,
+    STANDARD_NO_CONTEXT,
+};
 use crate::error::ZervError;
 use crate::version::zerv::{
     ZervSchema,
     ZervVars,
 };
 
-mod schema_preset_components {
-    use crate::utils::constants::timestamp_patterns;
-    use crate::version::zerv::{
-        Component,
-        Var,
-    };
-
-    pub fn standard_core() -> Vec<Component> {
-        vec![
-            Component::Var(Var::Major),
-            Component::Var(Var::Minor),
-            Component::Var(Var::Patch),
-        ]
-    }
-
-    pub fn calver_core() -> Vec<Component> {
-        vec![
-            Component::Var(Var::Timestamp(timestamp_patterns::YYYY.to_string())),
-            Component::Var(Var::Timestamp(timestamp_patterns::MM.to_string())),
-            Component::Var(Var::Timestamp(timestamp_patterns::DD.to_string())),
-            Component::Var(Var::Patch),
-        ]
-    }
-
-    pub fn prerelease_core() -> Vec<Component> {
-        vec![Component::Var(Var::Epoch), Component::Var(Var::PreRelease)]
-    }
-
-    pub fn prerelease_post_core() -> Vec<Component> {
-        vec![
-            Component::Var(Var::Epoch),
-            Component::Var(Var::PreRelease),
-            Component::Var(Var::Post),
-        ]
-    }
-
-    pub fn prerelease_post_dev_core() -> Vec<Component> {
-        vec![
-            Component::Var(Var::Epoch),
-            Component::Var(Var::PreRelease),
-            Component::Var(Var::Post),
-            Component::Var(Var::Dev),
-        ]
-    }
-
-    pub fn build_context() -> Vec<Component> {
-        vec![
-            Component::Var(Var::BumpedBranch),
-            Component::Var(Var::Distance),
-            Component::Var(Var::BumpedCommitHashShort),
-        ]
-    }
-
-    pub fn build_if_enabled(with_context: bool) -> Vec<Component> {
-        if with_context {
-            build_context()
-        } else {
-            vec![]
-        }
-    }
-
-    pub fn epoch_extra_core() -> Vec<Component> {
-        vec![Component::Var(Var::Epoch)]
-    }
-}
-
-pub mod schema_preset_names {
-    pub const STANDARD: &str = "standard";
-    pub const STANDARD_NO_CONTEXT: &str = "standard-no-context";
-    pub const STANDARD_BASE: &str = "standard-base";
-    pub const STANDARD_BASE_PRERELEASE: &str = "standard-base-prerelease";
-    pub const STANDARD_BASE_PRERELEASE_POST: &str = "standard-base-prerelease-post";
-    pub const STANDARD_BASE_PRERELEASE_POST_DEV: &str = "standard-base-prerelease-post-dev";
-    pub const STANDARD_BASE_CONTEXT: &str = "standard-base-context";
-    pub const STANDARD_BASE_PRERELEASE_CONTEXT: &str = "standard-base-prerelease-context";
-    pub const STANDARD_BASE_PRERELEASE_POST_CONTEXT: &str = "standard-base-prerelease-post-context";
-    pub const STANDARD_BASE_PRERELEASE_POST_DEV_CONTEXT: &str =
-        "standard-base-prerelease-post-dev-context";
-    pub const STANDARD_CONTEXT: &str = "standard-context";
-
-    pub const CALVER: &str = "calver";
-    pub const CALVER_NO_CONTEXT: &str = "calver-no-context";
-    pub const CALVER_BASE: &str = "calver-base";
-    pub const CALVER_BASE_PRERELEASE: &str = "calver-base-prerelease";
-    pub const CALVER_BASE_PRERELEASE_POST: &str = "calver-base-prerelease-post";
-    pub const CALVER_BASE_PRERELEASE_POST_DEV: &str = "calver-base-prerelease-post-dev";
-    pub const CALVER_BASE_CONTEXT: &str = "calver-base-context";
-    pub const CALVER_BASE_PRERELEASE_CONTEXT: &str = "calver-base-prerelease-context";
-    pub const CALVER_BASE_PRERELEASE_POST_CONTEXT: &str = "calver-base-prerelease-post-context";
-    pub const CALVER_BASE_PRERELEASE_POST_DEV_CONTEXT: &str =
-        "calver-base-prerelease-post-dev-context";
-    pub const CALVER_CONTEXT: &str = "calver-context";
-}
-
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum ZervSchemaPreset {
     Standard,
@@ -227,9 +167,9 @@ impl ZervSchemaPreset {
 
     fn standard_base_schema(&self, with_context: bool) -> ZervSchema {
         ZervSchema::new_with_precedence(
-            schema_preset_components::standard_core(),
-            schema_preset_components::epoch_extra_core(),
-            schema_preset_components::build_if_enabled(with_context),
+            standard_core(),
+            epoch_extra_core(),
+            build_if_enabled(with_context),
             Default::default(),
         )
         .unwrap()
@@ -237,9 +177,9 @@ impl ZervSchemaPreset {
 
     fn standard_base_prerelease_schema(&self, with_context: bool) -> ZervSchema {
         ZervSchema::new_with_precedence(
-            schema_preset_components::standard_core(),
-            schema_preset_components::prerelease_core(),
-            schema_preset_components::build_if_enabled(with_context),
+            standard_core(),
+            prerelease_core(),
+            build_if_enabled(with_context),
             Default::default(),
         )
         .unwrap()
@@ -247,9 +187,9 @@ impl ZervSchemaPreset {
 
     fn standard_base_prerelease_post_schema(&self, with_context: bool) -> ZervSchema {
         ZervSchema::new_with_precedence(
-            schema_preset_components::standard_core(),
-            schema_preset_components::prerelease_post_core(),
-            schema_preset_components::build_if_enabled(with_context),
+            standard_core(),
+            prerelease_post_core(),
+            build_if_enabled(with_context),
             Default::default(),
         )
         .unwrap()
@@ -257,9 +197,9 @@ impl ZervSchemaPreset {
 
     fn standard_base_prerelease_post_dev_schema(&self, with_context: bool) -> ZervSchema {
         ZervSchema::new_with_precedence(
-            schema_preset_components::standard_core(),
-            schema_preset_components::prerelease_post_dev_core(),
-            schema_preset_components::build_if_enabled(with_context),
+            standard_core(),
+            prerelease_post_dev_core(),
+            build_if_enabled(with_context),
             Default::default(),
         )
         .unwrap()
@@ -267,9 +207,9 @@ impl ZervSchemaPreset {
 
     fn calver_base_schema(&self, with_context: bool) -> ZervSchema {
         ZervSchema::new_with_precedence(
-            schema_preset_components::calver_core(),
-            schema_preset_components::epoch_extra_core(),
-            schema_preset_components::build_if_enabled(with_context),
+            calver_core(),
+            epoch_extra_core(),
+            build_if_enabled(with_context),
             Default::default(),
         )
         .unwrap()
@@ -277,9 +217,9 @@ impl ZervSchemaPreset {
 
     fn calver_base_prerelease_schema(&self, with_context: bool) -> ZervSchema {
         ZervSchema::new_with_precedence(
-            schema_preset_components::calver_core(),
-            schema_preset_components::prerelease_core(),
-            schema_preset_components::build_if_enabled(with_context),
+            calver_core(),
+            prerelease_core(),
+            build_if_enabled(with_context),
             Default::default(),
         )
         .unwrap()
@@ -287,9 +227,9 @@ impl ZervSchemaPreset {
 
     fn calver_base_prerelease_post_schema(&self, with_context: bool) -> ZervSchema {
         ZervSchema::new_with_precedence(
-            schema_preset_components::calver_core(),
-            schema_preset_components::prerelease_post_core(),
-            schema_preset_components::build_if_enabled(with_context),
+            calver_core(),
+            prerelease_post_core(),
+            build_if_enabled(with_context),
             Default::default(),
         )
         .unwrap()
@@ -297,9 +237,9 @@ impl ZervSchemaPreset {
 
     fn calver_base_prerelease_post_dev_schema(&self, with_context: bool) -> ZervSchema {
         ZervSchema::new_with_precedence(
-            schema_preset_components::calver_core(),
-            schema_preset_components::prerelease_post_dev_core(),
-            schema_preset_components::build_if_enabled(with_context),
+            calver_core(),
+            prerelease_post_dev_core(),
+            build_if_enabled(with_context),
             Default::default(),
         )
         .unwrap()
@@ -307,9 +247,7 @@ impl ZervSchemaPreset {
 
     fn with_build_context(&self, schema: ZervSchema) -> ZervSchema {
         let mut result = schema;
-        result
-            .set_build(schema_preset_components::build_context())
-            .unwrap();
+        result.set_build(build_context()).unwrap();
         result
     }
 
@@ -328,59 +266,39 @@ impl FromStr for ZervSchemaPreset {
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {
             // Standard Schema Family
-            self::schema_preset_names::STANDARD => Ok(ZervSchemaPreset::Standard),
-            self::schema_preset_names::STANDARD_NO_CONTEXT => {
-                Ok(ZervSchemaPreset::StandardNoContext)
-            }
-            self::schema_preset_names::STANDARD_BASE => Ok(ZervSchemaPreset::StandardBase),
-            self::schema_preset_names::STANDARD_BASE_PRERELEASE => {
-                Ok(ZervSchemaPreset::StandardBasePrerelease)
-            }
-            self::schema_preset_names::STANDARD_BASE_PRERELEASE_POST => {
-                Ok(ZervSchemaPreset::StandardBasePrereleasePost)
-            }
-            self::schema_preset_names::STANDARD_BASE_PRERELEASE_POST_DEV => {
+            STANDARD => Ok(ZervSchemaPreset::Standard),
+            STANDARD_NO_CONTEXT => Ok(ZervSchemaPreset::StandardNoContext),
+            STANDARD_BASE => Ok(ZervSchemaPreset::StandardBase),
+            STANDARD_BASE_PRERELEASE => Ok(ZervSchemaPreset::StandardBasePrerelease),
+            STANDARD_BASE_PRERELEASE_POST => Ok(ZervSchemaPreset::StandardBasePrereleasePost),
+            STANDARD_BASE_PRERELEASE_POST_DEV => {
                 Ok(ZervSchemaPreset::StandardBasePrereleasePostDev)
             }
-            self::schema_preset_names::STANDARD_BASE_CONTEXT => {
-                Ok(ZervSchemaPreset::StandardBaseContext)
-            }
-            self::schema_preset_names::STANDARD_BASE_PRERELEASE_CONTEXT => {
-                Ok(ZervSchemaPreset::StandardBasePrereleaseContext)
-            }
-            self::schema_preset_names::STANDARD_BASE_PRERELEASE_POST_CONTEXT => {
+            STANDARD_BASE_CONTEXT => Ok(ZervSchemaPreset::StandardBaseContext),
+            STANDARD_BASE_PRERELEASE_CONTEXT => Ok(ZervSchemaPreset::StandardBasePrereleaseContext),
+            STANDARD_BASE_PRERELEASE_POST_CONTEXT => {
                 Ok(ZervSchemaPreset::StandardBasePrereleasePostContext)
             }
-            self::schema_preset_names::STANDARD_BASE_PRERELEASE_POST_DEV_CONTEXT => {
+            STANDARD_BASE_PRERELEASE_POST_DEV_CONTEXT => {
                 Ok(ZervSchemaPreset::StandardBasePrereleasePostDevContext)
             }
-            self::schema_preset_names::STANDARD_CONTEXT => Ok(ZervSchemaPreset::StandardContext),
-
-            self::schema_preset_names::CALVER => Ok(ZervSchemaPreset::Calver),
-            self::schema_preset_names::CALVER_NO_CONTEXT => Ok(ZervSchemaPreset::CalverNoContext),
-            self::schema_preset_names::CALVER_BASE => Ok(ZervSchemaPreset::CalverBase),
-            self::schema_preset_names::CALVER_BASE_PRERELEASE => {
-                Ok(ZervSchemaPreset::CalverBasePrerelease)
-            }
-            self::schema_preset_names::CALVER_BASE_PRERELEASE_POST => {
-                Ok(ZervSchemaPreset::CalverBasePrereleasePost)
-            }
-            self::schema_preset_names::CALVER_BASE_PRERELEASE_POST_DEV => {
-                Ok(ZervSchemaPreset::CalverBasePrereleasePostDev)
-            }
-            self::schema_preset_names::CALVER_BASE_CONTEXT => {
-                Ok(ZervSchemaPreset::CalverBaseContext)
-            }
-            self::schema_preset_names::CALVER_BASE_PRERELEASE_CONTEXT => {
-                Ok(ZervSchemaPreset::CalverBasePrereleaseContext)
-            }
-            self::schema_preset_names::CALVER_BASE_PRERELEASE_POST_CONTEXT => {
+            STANDARD_CONTEXT => Ok(ZervSchemaPreset::StandardContext),
+
+            CALVER => Ok(ZervSchemaPreset::Calver),
+            CALVER_NO_CONTEXT => Ok(ZervSchemaPreset::CalverNoContext),
+            CALVER_BASE => Ok(ZervSchemaPreset::CalverBase),
+            CALVER_BASE_PRERELEASE => Ok(ZervSchemaPreset::CalverBasePrerelease),
+            CALVER_BASE_PRERELEASE_POST => Ok(ZervSchemaPreset::CalverBasePrereleasePost),
+            CALVER_BASE_PRERELEASE_POST_DEV => Ok(ZervSchemaPreset::CalverBasePrereleasePostDev),
+            CALVER_BASE_CONTEXT => Ok(ZervSchemaPreset::CalverBaseContext),
+            CALVER_BASE_PRERELEASE_CONTEXT => Ok(ZervSchemaPreset::CalverBasePrereleaseContext),
+            CALVER_BASE_PRERELEASE_POST_CONTEXT => {
                 Ok(ZervSchemaPreset::CalverBasePrereleasePostContext)
             }
-            self::schema_preset_names::CALVER_BASE_PRERELEASE_POST_DEV_CONTEXT => {
+            CALVER_BASE_PRERELEASE_POST_DEV_CONTEXT => {
                 Ok(ZervSchemaPreset::CalverBasePrereleasePostDevContext)
             }
-            self::schema_preset_names::CALVER_CONTEXT => Ok(ZervSchemaPreset::CalverContext),
+            CALVER_CONTEXT => Ok(ZervSchemaPreset::CalverContext),
 
             _ => Err(ZervError::UnknownSchema(s.to_string())),
         }
@@ -389,7 +307,6 @@ impl FromStr for ZervSchemaPreset {
 
 #[cfg(test)]
 mod tests {
-    use super::schema_preset_names::*;
     use super::*;
     use crate::version::zerv::ZervVars;
 
diff --git a/src/test_utils/git/docker.rs b/src/test_utils/git/docker.rs
index 1ce53714..0671bbc4 100644
--- a/src/test_utils/git/docker.rs
+++ b/src/test_utils/git/docker.rs
@@ -649,8 +649,8 @@ mod tests {
             .unwrap();
         assert_eq!(
             current_branch.trim(),
-            "feature/test-branch",
-            "Should be on new branch"
+            "main", // Should still be on main since create_branch doesn't checkout
+            "Should still be on main branch"
         );
     }
 
@@ -884,4 +884,73 @@ mod tests {
                 .contains("Git commands need --entrypoint")
         );
     }
+
+    #[test]
+    fn test_docker_git_merge_branch() {
+        if !should_run_docker_tests() {
+            return;
+        }
+
+        let (dir, docker_git) = setup_repo_with_commit();
+
+        // Create initial state: main branch with v1.0.0 tag
+        docker_git
+            .create_tag(&dir, "v1.0.0")
+            .expect("Should create initial tag");
+
+        // Create feature branch
+        docker_git
+            .create_branch(&dir, "feature/test-branch")
+            .expect("Should create feature branch");
+
+        // Checkout feature branch
+        docker_git
+            .checkout_branch(&dir, "feature/test-branch")
+            .expect("Should checkout feature branch");
+
+        // Add a commit on feature branch
+        dir.create_file("feature.txt", "new feature content")
+            .unwrap();
+        docker_git
+            .create_commit(&dir, "Add new feature")
+            .expect("Should create commit on feature branch");
+
+        // Return to main branch
+        docker_git
+            .checkout_branch(&dir, "main")
+            .expect("Should checkout main branch");
+
+        // Merge feature branch into main
+        docker_git
+            .merge_branch(&dir, "feature/test-branch")
+            .expect("Should merge feature branch into main");
+
+        // Verify merge was successful
+        let log_output = docker_git
+            .execute_git(&dir, &["log", "--oneline", "-2"])
+            .expect("Should get commit log");
+
+        assert!(
+            log_output.contains("Add new feature"),
+            "Log should contain feature branch commit: {}",
+            log_output
+        );
+
+        // Verify file from feature branch exists on main
+        assert!(
+            dir.path().join("feature.txt").exists(),
+            "Feature file should exist after merge"
+        );
+
+        // Verify we're still on main branch
+        let current_branch = docker_git
+            .execute_git(&dir, &["branch", "--show-current"])
+            .expect("Should get current branch");
+
+        assert_eq!(
+            current_branch.trim(),
+            "main",
+            "Should still be on main branch after merge"
+        );
+    }
 }
diff --git a/src/test_utils/git/fixtures.rs b/src/test_utils/git/fixtures.rs
index 0dd16c36..20717da5 100644
--- a/src/test_utils/git/fixtures.rs
+++ b/src/test_utils/git/fixtures.rs
@@ -1,3 +1,8 @@
+use std::time::{
+    SystemTime,
+    UNIX_EPOCH,
+};
+
 use super::GitOperations;
 use crate::test_utils::{
     TestDir,
@@ -58,21 +63,62 @@ impl GitRepoFixture {
         Ok(fixture)
     }
 
-    /// Checkout to an existing or new branch
-    pub fn checkout_branch(&self, branch: &str) -> Result<(), Box<dyn std::error::Error>> {
+    /// Create a new branch without checking it out
+    pub fn create_branch(&self, branch: &str) -> Result<(), Box<dyn std::error::Error>> {
         self.git_impl
             .create_branch(&self.test_dir, branch)
+            .map_err(|e| format!("Failed to create branch '{}': {e}", branch))?;
+        Ok(())
+    }
+
+    /// Checkout to an existing branch
+    pub fn checkout_branch(&self, branch: &str) -> Result<(), Box<dyn std::error::Error>> {
+        self.git_impl
+            .checkout_branch(&self.test_dir, branch)
             .map_err(|e| format!("Failed to checkout branch '{}': {e}", branch))?;
         Ok(())
     }
 
+    /// Builder-style: Create a new branch without checking it out
+    pub fn with_branch(self, branch: &str) -> Self {
+        self.git_impl
+            .create_branch(&self.test_dir, branch)
+            .unwrap_or_else(|e| panic!("Failed to create branch '{}': {}", branch, e));
+        self
+    }
+
+    /// Builder-style: Checkout to an existing branch
+    pub fn with_checkout(self, branch: &str) -> Self {
+        self.git_impl
+            .checkout_branch(&self.test_dir, branch)
+            .unwrap_or_else(|e| panic!("Failed to checkout branch '{}': {}", branch, e));
+        self
+    }
+
     /// Make the working directory dirty with uncommitted changes
     pub fn make_dirty(&self) -> Result<(), Box<dyn std::error::Error>> {
-        self.test_dir
-            .create_file("dirty_file.txt", "dirty content")?;
+        let timestamp = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_nanos();
+        let content = format!("dirty content {}", timestamp);
+        self.test_dir.create_file("dirty_file.txt", &content)?;
         Ok(())
     }
 
+    /// Builder-style: Make the working directory dirty with uncommitted changes
+    pub fn with_dirty(self) -> Self {
+        let timestamp = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_nanos();
+        let content = format!("dirty content {}", timestamp);
+        self.test_dir
+            .create_file("dirty_file.txt", &content)
+            .expect("Failed to create dirty file");
+        self
+    }
+
     /// Create a repository with dirty working directory (Tier 3: major.minor.patch.dev<timestamp>+branch.<commit>)
     pub fn dirty(tag: &str) -> Result<Self, Box<dyn std::error::Error>> {
         let fixture = Self::tagged(tag)?;
@@ -89,6 +135,59 @@ impl GitRepoFixture {
     pub fn path(&self) -> &std::path::Path {
         self.test_dir.path()
     }
+
+    /// Create a single tag
+    pub fn create_tag(self, tag: &str) -> Self {
+        self.git_impl
+            .create_tag(&self.test_dir, tag)
+            .unwrap_or_else(|e| panic!("Failed to create tag '{}': {}", tag, e));
+        self
+    }
+
+    /// Create a commit without tagging (for building distance)
+    pub fn commit(self, message: &str) -> Self {
+        // Create a file change to ensure there's something to commit
+        let timestamp = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_nanos();
+        self.test_dir
+            .create_file(
+                format!("commit_{}.txt", timestamp),
+                &format!("Content for {}", message),
+            )
+            .expect("Failed to create commit file");
+
+        self.git_impl
+            .create_commit(&self.test_dir, message)
+            .unwrap_or_else(|e| panic!("Failed to create commit '{}': {}", message, e));
+        self
+    }
+
+    /// Get current HEAD commit hash
+    pub fn get_head_commit(&self) -> Result<String, Box<dyn std::error::Error>> {
+        let output = self
+            .git_impl
+            .execute_git(&self.test_dir, &["rev-parse", "HEAD"])
+            .map_err(|e| format!("Failed to get HEAD commit: {e}"))?;
+        Ok(output.trim().to_string())
+    }
+
+    /// Checkout to a specific commit (preserves commit history)
+    pub fn checkout(self, commit: &str) -> Self {
+        self.git_impl
+            .execute_git(&self.test_dir, &["checkout", commit])
+            .unwrap_or_else(|e| panic!("Failed to checkout commit '{}': {}", commit, e));
+        self
+    }
+
+    /// Merge a branch into the current branch
+    pub fn merge_branch(self, branch: &str) -> Self {
+        self.git_impl
+            .merge_branch(&self.test_dir, branch)
+            .unwrap_or_else(|e| panic!("Failed to merge branch '{}': {}", branch, e));
+        self
+    }
 }
 
 #[cfg(test)]
@@ -109,7 +208,10 @@ mod tests {
 
         let fixture = GitRepoFixture::tagged("v1.0.0").expect("Failed to create fixture with tag");
 
-        // Checkout a new branch
+        // Create and checkout a new branch
+        fixture
+            .create_branch("feature-test")
+            .expect("Failed to create feature-test branch");
         fixture
             .checkout_branch("feature-test")
             .expect("Failed to checkout feature-test branch");
@@ -335,4 +437,73 @@ mod tests {
         // Should not have additional files (zero distance means no extra commits)
         assert!(!fixture_path.join("file1.txt").exists());
     }
+
+    #[test]
+    #[serial(fixture_methods)]
+    fn test_merge_branch_and_checkout() {
+        if !should_run_docker_tests() {
+            return;
+        }
+
+        let mut fixture =
+            GitRepoFixture::tagged("v1.0.0").expect("Failed to create fixture with tag");
+
+        // Test 1: Branch creation and merging
+        fixture
+            .create_branch("feature-branch")
+            .expect("Failed to create feature branch");
+        fixture
+            .checkout_branch("feature-branch")
+            .expect("Failed to checkout feature branch");
+
+        // Add a commit on the feature branch
+        fixture = fixture.commit("Feature commit");
+
+        // Switch back to main and merge
+        fixture
+            .checkout_branch("main")
+            .expect("Failed to checkout main");
+        fixture = fixture.merge_branch("feature-branch");
+
+        // Verify merge was successful by checking the commit exists
+        let output = fixture
+            .git_impl
+            .execute_git(
+                &fixture.test_dir,
+                &["log", "--oneline", "--grep=Feature commit"],
+            )
+            .expect("Failed to check git log");
+        assert!(
+            output.contains("Feature commit"),
+            "Feature commit should be merged into main"
+        );
+
+        // Test 2: Checkout preserves commit history (safer than reset)
+        // Create more commits with tags
+        fixture = fixture
+            .commit("Feature A")
+            .create_tag("v2.0.0")
+            .commit("Feature B")
+            .create_tag("v3.0.0");
+
+        // Get v2.0.0 commit hash
+        let v2_commit = fixture
+            .git_impl
+            .execute_git(&fixture.test_dir, &["rev-list", "-n", "1", "v2.0.0"])
+            .expect("Failed to get v2.0.0 commit");
+        let v2_commit = v2_commit.trim();
+
+        // Checkout to v2.0.0 (preserves history)
+        fixture = fixture.checkout(v2_commit);
+
+        // Verify we can still see v3.0.0 tag even though we're checked out to v2.0.0
+        let all_tags = fixture
+            .git_impl
+            .execute_git(&fixture.test_dir, &["tag", "--list"])
+            .expect("Failed to list tags");
+        assert!(
+            all_tags.contains("v3.0.0"),
+            "v3.0.0 tag should still exist after checkout"
+        );
+    }
 }
diff --git a/src/test_utils/git/mod.rs b/src/test_utils/git/mod.rs
index bb4cc5f0..0274231c 100644
--- a/src/test_utils/git/mod.rs
+++ b/src/test_utils/git/mod.rs
@@ -50,9 +50,21 @@ pub trait GitOperations {
     /// Create a commit
     fn create_commit(&self, test_dir: &TestDir, message: &str) -> io::Result<()>;
 
-    /// Create and checkout a new branch
+    /// Create a new branch without checking it out
     fn create_branch(&self, test_dir: &TestDir, branch_name: &str) -> io::Result<()> {
-        self.execute_git(test_dir, &["checkout", "-b", branch_name])?;
+        self.execute_git(test_dir, &["branch", branch_name])?;
+        Ok(())
+    }
+
+    /// Checkout an existing branch
+    fn checkout_branch(&self, test_dir: &TestDir, branch_name: &str) -> io::Result<()> {
+        self.execute_git(test_dir, &["checkout", branch_name])?;
+        Ok(())
+    }
+
+    /// Merge a branch into the current branch
+    fn merge_branch(&self, test_dir: &TestDir, branch_name: &str) -> io::Result<()> {
+        self.execute_git(test_dir, &["merge", branch_name])?;
         Ok(())
     }
 }
diff --git a/src/test_utils/vcs_fixtures.rs b/src/test_utils/vcs_fixtures.rs
index 41695b2a..7f998626 100644
--- a/src/test_utils/vcs_fixtures.rs
+++ b/src/test_utils/vcs_fixtures.rs
@@ -42,7 +42,9 @@ fn create_vcs_data_with_tag(tag: &str, filename: &str, content: &str, commit_msg
         .expect("Failed to create commit");
 
     let git_vcs = GitVcs::new(test_dir.path()).expect("Failed to create GitVcs");
-    git_vcs.get_vcs_data().expect("Failed to get VCS data")
+    git_vcs
+        .get_vcs_data("auto")
+        .expect("Failed to get VCS data")
 }
 
 /// Get real VCS data with SemVer tag (v1.2.3) and 1 commit distance
diff --git a/src/vcs/git.rs b/src/vcs/git.rs
index e1b3f8a7..8b42b95c 100644
--- a/src/vcs/git.rs
+++ b/src/vcs/git.rs
@@ -12,6 +12,7 @@ use crate::vcs::{
     Vcs,
     VcsData,
 };
+use crate::version::VersionObject;
 
 /// Git VCS implementation
 pub struct GitVcs {
@@ -133,17 +134,90 @@ impl GitVcs {
         ZervError::CommandFailed(format!("Git command failed: {stderr_str}"))
     }
 
-    /// Get latest version tag
-    fn get_latest_tag(&self) -> Result<Option<String>> {
-        match self.run_git_command(&["describe", "--tags", "--abbrev=0"]) {
-            Ok(tag) if !tag.is_empty() => Ok(Some(tag)),
-            Ok(_) => Ok(None),
-            Err(ZervError::CommandFailed(_)) => Ok(None), // No tags found
+    /// Get latest version tag using enhanced algorithm
+    fn get_latest_tag(&self, format: &str) -> Result<Option<String>> {
+        let tags_output = self.get_merged_tags()?;
+
+        if tags_output.is_empty() {
+            return Ok(None);
+        }
+
+        let valid_tags = self.collect_valid_version_tags(&tags_output, format)?;
+        self.find_highest_version_tag(valid_tags)
+    }
+
+    /// Get all tags merged into HEAD, sorted by commit date
+    fn get_merged_tags(&self) -> Result<String> {
+        match self.run_git_command(&["tag", "--merged", "HEAD", "--sort=-committerdate"]) {
+            Ok(tags) => Ok(tags),
+            Err(ZervError::CommandFailed(_)) => Ok(String::new()), // No tags found
             Err(e) => Err(e),
         }
     }
 
-    /// Calculate distance from tag to HEAD
+    /// Collect all valid version tags from the git output
+    fn collect_valid_version_tags(&self, tags_output: &str, format: &str) -> Result<Vec<String>> {
+        let mut valid_tags = Vec::new();
+
+        for tag_line in tags_output.lines() {
+            let trimmed_tag = tag_line.trim();
+            if trimmed_tag.is_empty() {
+                continue;
+            }
+
+            if self.is_valid_version_tag(trimmed_tag, format) {
+                let commit_tags = self.get_valid_tags_for_commit(trimmed_tag, format)?;
+                valid_tags.extend(commit_tags);
+            }
+        }
+
+        Ok(valid_tags)
+    }
+
+    /// Check if a tag is a valid version for the given format
+    fn is_valid_version_tag(&self, tag: &str, format: &str) -> bool {
+        VersionObject::parse_with_format(tag, format).is_ok()
+    }
+
+    /// Get all valid version tags pointing to the same commit as the given tag
+    fn get_valid_tags_for_commit(&self, tag: &str, format: &str) -> Result<Vec<String>> {
+        let commit_hash = self.get_commit_hash_for_tag(tag)?;
+        let tags_on_commit = self.get_tags_pointing_at_commit(&commit_hash)?;
+
+        // Filter and return only valid version tags
+        Ok(tags_on_commit
+            .lines()
+            .map(|line| line.trim())
+            .filter(|trimmed_tag| !trimmed_tag.is_empty())
+            .filter(|trimmed_tag| self.is_valid_version_tag(trimmed_tag, format))
+            .map(|tag| tag.to_string())
+            .collect())
+    }
+
+    /// Get the commit hash for a given tag
+    fn get_commit_hash_for_tag(&self, tag: &str) -> Result<String> {
+        match self.run_git_command(&["rev-list", "-n", "1", tag]) {
+            Ok(hash) => Ok(hash.trim().to_string()),
+            Err(_) => Err(ZervError::CommandFailed(format!(
+                "Failed to get commit hash for tag: {}",
+                tag
+            ))),
+        }
+    }
+
+    /// Get all tags pointing to a specific commit
+    fn get_tags_pointing_at_commit(&self, commit_hash: &str) -> Result<String> {
+        match self.run_git_command(&["tag", "--points-at", commit_hash]) {
+            Ok(tags) => Ok(tags),
+            Err(_) => Ok(String::new()), // Return empty if no tags found
+        }
+    }
+
+    /// Find the highest semantic version from a list of tags
+    fn find_highest_version_tag(&self, tags: Vec<String>) -> Result<Option<String>> {
+        Ok(tags.iter().max().cloned())
+    }
+
     fn calculate_distance(&self, tag: &str) -> Result<u32> {
         let output = self.run_git_command(&["rev-list", "--count", &format!("{tag}..HEAD")])?;
         output
@@ -199,6 +273,16 @@ impl GitVcs {
             .map_err(|e| ZervError::CommandFailed(format!("Failed to parse tag timestamp: {e}")))
     }
 
+    /// Get the commit hash that a tag points to
+    fn get_tag_commit_hash(&self, tag: &str) -> Result<Option<String>> {
+        // Use `git rev-list -n 1` to get the commit hash that the tag points to
+        // This works for both annotated and lightweight tags
+        match self.run_git_command(&["rev-list", "-n", "1", tag]) {
+            Ok(hash) if !hash.trim().is_empty() => Ok(Some(hash.trim().to_string())),
+            Ok(_) | Err(_) => Ok(None),
+        }
+    }
+
     /// Check if working directory is dirty
     fn is_dirty(&self) -> Result<bool> {
         let output = self.run_git_command(&["status", "--porcelain"])?;
@@ -212,8 +296,11 @@ impl GitVcs {
 }
 
 impl Vcs for GitVcs {
-    fn get_vcs_data(&self) -> Result<VcsData> {
-        tracing::debug!("Detecting Git version in current directory");
+    fn get_vcs_data(&self, input_format: &str) -> Result<VcsData> {
+        tracing::debug!(
+            "Detecting Git version in current directory with input format: {}",
+            input_format
+        );
 
         // Check for shallow clone and warn
         if self.check_shallow_clone() {
@@ -222,6 +309,7 @@ impl Vcs for GitVcs {
 
         let mut data = VcsData {
             commit_hash: self.get_commit_hash()?,
+            commit_hash_prefix: "g".to_string(), // Git prefix following git describe convention
             commit_timestamp: self.get_commit_timestamp()?,
             is_dirty: self.is_dirty()?,
             current_branch: self.get_current_branch().unwrap_or(None),
@@ -229,11 +317,12 @@ impl Vcs for GitVcs {
         };
 
         // Get tag information
-        match self.get_latest_tag()? {
+        match self.get_latest_tag(input_format)? {
             Some(tag) => {
                 tracing::debug!("Found Git tag: {}", tag);
                 data.distance = self.calculate_distance(&tag).unwrap_or(0);
                 data.tag_timestamp = self.get_tag_timestamp(&tag).unwrap_or(None);
+                data.tag_commit_hash = self.get_tag_commit_hash(&tag).unwrap_or(None);
                 data.tag_version = Some(tag);
             }
             None => {
@@ -268,6 +357,7 @@ mod tests {
     };
     use crate::test_utils::{
         GitOperations,
+        GitRepoFixture,
         TestDir,
         should_run_docker_tests,
         should_use_native_git,
@@ -359,7 +449,7 @@ mod tests {
             });
 
         // Get VCS data with detailed error context
-        let data = git_vcs.get_vcs_data()
+        let data = git_vcs.get_vcs_data("auto")
             .unwrap_or_else(|e| {
                 panic!("Failed to get VCS data from repo at {}: {}. Check Git operations and repository state.",
                        temp_dir.path().display(), e);
@@ -395,12 +485,28 @@ mod tests {
         }
         let temp_dir = setup_git_repo_with_tag("v1.0.0");
         let git_vcs = GitVcs::new(temp_dir.path()).expect("should create GitVcs");
-        let data = git_vcs.get_vcs_data().expect("should get vcs data");
+        let data = git_vcs.get_vcs_data("auto").expect("should get vcs data");
 
         assert!(!data.commit_hash.is_empty());
         assert!(data.commit_timestamp > 0);
         assert_eq!(data.tag_version, Some("v1.0.0".to_string()));
         assert_eq!(data.distance, 0);
+
+        // Verify tag_commit_hash is populated and valid
+        assert!(
+            data.tag_commit_hash.is_some(),
+            "tag_commit_hash should be populated when tag exists"
+        );
+        let tag_hash = data.tag_commit_hash.unwrap();
+        assert_eq!(
+            tag_hash.len(),
+            40,
+            "Git commit hash should be 40 characters"
+        );
+        assert!(
+            tag_hash.chars().all(|c| c.is_ascii_hexdigit()),
+            "Hash should contain only hex characters"
+        );
     }
 
     #[test]
@@ -419,7 +525,7 @@ mod tests {
             .expect("should create commit");
 
         let git_vcs = GitVcs::new(temp_dir.path()).expect("should create GitVcs");
-        let data = git_vcs.get_vcs_data().expect("should get vcs data");
+        let data = git_vcs.get_vcs_data("auto").expect("should get vcs data");
 
         assert_eq!(data.tag_version, Some("v1.0.0".to_string()));
         assert_eq!(data.distance, 1);
@@ -437,7 +543,7 @@ mod tests {
         fs::write(path.join("untracked.txt"), "untracked").unwrap();
 
         let git_vcs = GitVcs::new(temp_dir.path()).unwrap();
-        let data = git_vcs.get_vcs_data().unwrap();
+        let data = git_vcs.get_vcs_data("auto").unwrap();
 
         assert!(data.is_dirty);
     }
@@ -449,7 +555,7 @@ mod tests {
         }
         let temp_dir = setup_git_repo();
         let git_vcs = GitVcs::new(temp_dir.path()).expect("should create GitVcs");
-        let data = git_vcs.get_vcs_data().expect("should get vcs data");
+        let data = git_vcs.get_vcs_data("auto").expect("should get vcs data");
 
         assert!(!data.is_dirty);
     }
@@ -726,4 +832,95 @@ mod tests {
             }
         }
     }
+
+    #[test]
+    fn test_get_latest_tag_comprehensive() -> crate::error::Result<()> {
+        if !should_run_docker_tests() {
+            return Ok(());
+        }
+
+        // Create repository with complex history covering all scenarios
+        let mut fixture =
+            GitRepoFixture::tagged("v1.0.0").expect("Failed to create initial fixture");
+        let git_vcs = GitVcs::new(fixture.path())?;
+
+        // Test 1: Empty repo behavior (already has v1.0.0 tag)
+        let result = git_vcs.get_latest_tag("auto")?;
+        assert_eq!(
+            result,
+            Some("v1.0.0".to_string()),
+            "Should find initial tag"
+        );
+
+        // Test 2: Multiple tags on same commit (main bug scenario)
+        fixture = fixture.create_tag("v1.0.1-beta.1")   // pre-release
+            .create_tag("build-123")                   // non-version tag
+            .create_tag("v1.0.2-rc.1.post.3")          // problematic pre-release from bug
+            .create_tag("v1.1.0")                      // clean release (should be chosen)
+            .create_tag("release-candidate"); // another non-version tag
+
+        let result = git_vcs.get_latest_tag("auto")?;
+        assert_eq!(
+            result,
+            Some("v1.1.0".to_string()),
+            "Should return v1.1.0 (clean release) over pre-release tags"
+        );
+
+        // Test 3: Format-specific behavior
+        let result_semver = git_vcs.get_latest_tag("semver")?;
+        assert!(result_semver.is_some(), "SemVer format should find a tag");
+
+        let result_pep440 = git_vcs.get_latest_tag("pep440")?;
+        assert!(result_pep440.is_some(), "PEP440 format should find a tag");
+
+        // Test 4: Build history with HEAD not at latest commit
+        fixture = fixture
+            .commit("Feature A")
+            .create_tag("v2.0.0")
+            .commit("Work after v2.0.0")
+            .commit("Feature B")
+            .create_tag("v3.0.0");
+
+        // Get v2.0.0 commit and checkout to it (middle of history)
+        let v2_commit = fixture
+            .git_impl
+            .execute_git(&fixture.test_dir, &["rev-list", "-n", "1", "v2.0.0"])
+            .expect("Failed to get v2.0.0 commit");
+        let v2_commit = v2_commit.trim();
+        fixture = fixture.checkout(v2_commit);
+
+        let result = git_vcs.get_latest_tag("auto")?;
+        assert_eq!(
+            result,
+            Some("v2.0.0".to_string()),
+            "Should return v2.0.0 when HEAD is at v2.0.0, not future v3.0.0"
+        );
+
+        // Test 5: Old commit with high version tag
+        let head_commit = fixture
+            .get_head_commit()
+            .expect("Failed to get HEAD commit");
+
+        // Reset to initial commit and add high version tag
+        let v1_0_0_commit = fixture
+            .git_impl
+            .execute_git(&fixture.test_dir, &["rev-list", "-n", "1", "v1.0.0"])
+            .expect("Failed to get v1.0.0 commit");
+        let v1_0_0_commit = v1_0_0_commit.trim();
+
+        let _fixture = fixture
+            .checkout(v1_0_0_commit)
+            .commit("Old feature")
+            .create_tag("v10.5.0")
+            .checkout(&head_commit);
+
+        let result = git_vcs.get_latest_tag("auto")?;
+        assert_eq!(
+            result,
+            Some("v2.0.0".to_string()),
+            "Should return v2.0.0 (traceable from HEAD), not v10.5.0 (old high version)"
+        );
+
+        Ok(())
+    }
 }
diff --git a/src/vcs/mod.rs b/src/vcs/mod.rs
index 8b94ea44..1297ea1e 100644
--- a/src/vcs/mod.rs
+++ b/src/vcs/mod.rs
@@ -16,7 +16,7 @@ pub use vcs_data::VcsData;
 /// Version Control System trait for extracting repository metadata
 pub trait Vcs {
     /// Extract VCS data from the repository
-    fn get_vcs_data(&self) -> Result<VcsData>;
+    fn get_vcs_data(&self, input_format: &str) -> Result<VcsData>;
 
     /// Check if this VCS type is available in the given directory
     fn is_available(&self, path: &Path) -> bool;
diff --git a/src/vcs/vcs_data.rs b/src/vcs/vcs_data.rs
index 021ad2f8..26bf26ea 100644
--- a/src/vcs/vcs_data.rs
+++ b/src/vcs/vcs_data.rs
@@ -2,18 +2,14 @@
 pub struct VcsData {
     /// Latest version tag (e.g., "v1.2.3")
     pub tag_version: Option<String>,
-    /// Distance from latest tag to HEAD
-    pub distance: u32,
-    /// Current commit hash (full)
+    pub tag_commit_hash: Option<String>,
+    pub tag_timestamp: Option<i64>,
+
     pub commit_hash: String,
-    /// Current branch name
-    pub current_branch: Option<String>,
-    /// Commit timestamp (Unix timestamp)
+    pub commit_hash_prefix: String,
     pub commit_timestamp: i64,
-    /// Tag timestamp (Unix timestamp)
-    pub tag_timestamp: Option<i64>,
-    /// Whether the working directory is dirty (has uncommitted changes)
-    pub is_dirty: bool,
-    /// Whether the repository is shallow (limited history)
+    pub current_branch: Option<String>,
     pub is_shallow: bool,
+    pub is_dirty: bool,
+    pub distance: u32,
 }
diff --git a/src/version/pep440/from_zerv.rs b/src/version/pep440/from_zerv.rs
index 1e0309fe..89d54a3f 100644
--- a/src/version/pep440/from_zerv.rs
+++ b/src/version/pep440/from_zerv.rs
@@ -269,7 +269,7 @@ mod tests {
     #[case(zerv_calver::calver_yyyy_mm_patch(), "2024.3.1")]
     #[case(zerv_calver::calver_with_timestamp_build(), "1.0.0+2024.3.16")]
     // Maximum complexity test
-    #[case(from::v2_3_4_max_complexity().build(), "5!2.3.4.99a1.post2+core.value.extra.value.literal.42.feature.complex.test.7.abcdef1.true.build.value.build.123")]
+    #[case(from::v2_3_4_max_complexity().build(), "5!2.3.4.99a1.post2+core.value.extra.value.literal.42.feature.complex.test.7.abcdef12.true.build.value.build.123")]
     // Custom field handling - build (goes to local)
     #[case(from::v1_0_0_custom_build_field("custom.field").build(), "1.0.0+custom.field")]
     #[case(from::v1_0_0_custom_build_field("simple").build(), "1.0.0+simple")]
diff --git a/src/version/semver/from_zerv.rs b/src/version/semver/from_zerv.rs
index 09fd48ec..1f196283 100644
--- a/src/version/semver/from_zerv.rs
+++ b/src/version/semver/from_zerv.rs
@@ -275,7 +275,7 @@ mod tests {
     #[case(zerv_calver::calver_yyyy_mm_patch(), "2024.3.1")]
     #[case(zerv_calver::calver_with_timestamp_build(), "1.0.0+2024.3.16")]
     // Maximum complexity test
-    #[case(from::v2_3_4_max_complexity().build(), "2.3.4-core.value.99.epoch.5.alpha.1.post.2.extra.value.literal.42+feature.complex.test.7.abcdef1.true.build.value.build.123")]
+    #[case(from::v2_3_4_max_complexity().build(), "2.3.4-core.value.99.epoch.5.alpha.1.post.2.extra.value.literal.42+feature.complex.test.7.abcdef12.true.build.value.build.123")]
     fn test_zerv_to_semver_conversion(#[case] zerv: Zerv, #[case] expected_semver_str: &str) {
         let semver: SemVer = zerv.into();
         assert_eq!(semver.to_string(), expected_semver_str);
diff --git a/src/version/version_object.rs b/src/version/version_object.rs
index 85428499..b0dc0ab4 100644
--- a/src/version/version_object.rs
+++ b/src/version/version_object.rs
@@ -1,5 +1,6 @@
 use std::str::FromStr;
 
+use crate::error::ZervError;
 use crate::version::{
     PEP440,
     SemVer,
@@ -21,13 +22,42 @@ impl VersionObject {
         }
     }
 
-    pub fn parse_with_format(tag: &str, format_str: &str) -> Option<Self> {
+    /// Enhanced parsing with auto-detection and detailed error handling
+    pub fn parse_with_format(tag: &str, format_str: &str) -> Result<Self, ZervError> {
         match format_str.to_lowercase().as_str() {
-            "pep440" => PEP440::from_str(tag).ok().map(VersionObject::PEP440),
-            "semver" => SemVer::from_str(tag).ok().map(VersionObject::SemVer),
-            _ => None,
+            "semver" => SemVer::from_str(tag)
+                .map(VersionObject::SemVer)
+                .map_err(|e| {
+                    ZervError::InvalidFormat(format!("Invalid SemVer format '{tag}': {e}"))
+                }),
+            "pep440" => PEP440::from_str(tag)
+                .map(VersionObject::PEP440)
+                .map_err(|e| {
+                    ZervError::InvalidFormat(format!("Invalid PEP440 format '{tag}': {e}"))
+                }),
+            "auto" => Self::parse_auto_detect(tag),
+            _ => Err(ZervError::UnknownFormat(format!(
+                "Unknown input format '{format_str}'. Supported formats: semver, pep440, auto"
+            ))),
         }
     }
+
+    /// Auto-detect version format (try SemVer first, then PEP440)
+    fn parse_auto_detect(version_str: &str) -> Result<Self, ZervError> {
+        // Try SemVer first
+        if let Ok(semver) = SemVer::from_str(version_str) {
+            return Ok(VersionObject::SemVer(semver));
+        }
+
+        // Fall back to PEP440
+        if let Ok(pep440) = PEP440::from_str(version_str) {
+            return Ok(VersionObject::PEP440(pep440));
+        }
+
+        Err(ZervError::InvalidVersion(format!(
+            "Version '{version_str}' is not valid SemVer or PEP440 format"
+        )))
+    }
 }
 
 impl From<VersionObject> for ZervVars {
@@ -56,6 +86,8 @@ mod tests {
     #[case("1.2.3a1", "pep440", "pep440")]
     #[case("1.0.0-alpha.1", "SEMVER", "semver")] // case insensitive
     #[case("2!1.2.3", "PEP440", "pep440")] // case insensitive
+    #[case("1.2.3", "auto", "semver")] // auto detection - semver
+    #[case("1.2.3a1", "auto", "pep440")] // auto detection - pep440
     fn test_version_object_parse_with_format(
         #[case] tag: &str,
         #[case] format: &str,
@@ -66,12 +98,24 @@ mod tests {
     }
 
     #[rstest]
-    #[case("1.2.3", "unknown")]
-    #[case("1.2.3", "invalid")]
-    #[case("invalid", "semver")]
-    fn test_version_object_parse_with_format_invalid(#[case] tag: &str, #[case] format: &str) {
-        let version = VersionObject::parse_with_format(tag, format);
-        assert!(version.is_none());
+    #[case("1.2.3", "unknown", "Unknown input format")]
+    #[case("1.2.3", "invalid", "Unknown input format")]
+    #[case("invalid", "semver", "Invalid SemVer format")]
+    #[case("invalid", "pep440", "Invalid PEP440 format")]
+    #[case("completely-invalid", "auto", "not valid SemVer or PEP440 format")]
+    fn test_version_object_parse_with_format_invalid(
+        #[case] tag: &str,
+        #[case] format: &str,
+        #[case] expected_error: &str,
+    ) {
+        let error = VersionObject::parse_with_format(tag, format).unwrap_err();
+        let error_message = error.to_string();
+        assert!(
+            error_message.contains(expected_error),
+            "Expected error message to contain '{}', got: '{}'",
+            expected_error,
+            error_message
+        );
     }
 
     #[test]
diff --git a/src/version/zerv/components.rs b/src/version/zerv/components.rs
index 16fd3580..5e83930d 100644
--- a/src/version/zerv/components.rs
+++ b/src/version/zerv/components.rs
@@ -485,8 +485,8 @@ mod tests {
     }
 
     #[rstest]
-    #[case(Var::BumpedCommitHashShort, "abcdef1234567890", "abcdef1")]
-    #[case(Var::BumpedCommitHashShort, "123456789", "1234567")]
+    #[case(Var::BumpedCommitHashShort, "abcdef1234567890", "abcdef12")]
+    #[case(Var::BumpedCommitHashShort, "123456789", "12345678")]
     fn test_var_commit_hash_short(#[case] var: Var, #[case] hash: &str, #[case] expected: &str) {
         let zerv = base_fixture().with_commit_hash(hash.to_string()).build();
         let sanitizer = Sanitizer::semver_str();
@@ -895,7 +895,7 @@ mod tests {
                 &value_sanitizer,
                 &key_sanitizer
             ),
-            vec!["commit".to_string(), "abcdef1".to_string()]
+            vec!["commit".to_string(), "abcdef12".to_string()]
         );
     }
 
@@ -937,7 +937,7 @@ mod tests {
     #[rstest]
     #[case(Var::LastBranch, "last.branch", "last.branch")]
     #[case(Var::LastCommitHash, "abc123", "abc123")]
-    #[case(Var::LastCommitHashShort, "abc1234567", "abc1234")]
+    #[case(Var::LastCommitHashShort, "abc12345678", "abc12345")]
     fn test_var_expanded_with_key_sanitizer_last_fields(
         #[case] var: Var,
         #[case] value: &str,
diff --git a/src/version/zerv/vars.rs b/src/version/zerv/vars.rs
index a2b6afac..e9071aa2 100644
--- a/src/version/zerv/vars.rs
+++ b/src/version/zerv/vars.rs
@@ -5,9 +5,9 @@ use serde::{
 };
 use serde_json;
 
-use crate::cli::utils::format_handler::InputFormatHandler;
 use crate::cli::version::VersionArgs;
 use crate::error::ZervError;
+use crate::version::VersionObject;
 use crate::version::zerv::core::PreReleaseVar;
 
 #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
@@ -48,8 +48,8 @@ fn default_custom_value() -> serde_json::Value {
 impl ZervVars {
     fn derive_short_hash(hash: Option<&String>) -> Option<String> {
         hash.map(|h| {
-            if h.len() >= 7 {
-                h[..7].to_string()
+            if h.len() >= 8 {
+                h[..8].to_string()
             } else {
                 h.clone()
             }
@@ -142,9 +142,9 @@ impl ZervVars {
     fn apply_tag_version_overrides(&mut self, args: &VersionArgs) -> Result<(), ZervError> {
         // Apply tag version override (parse and extract components)
         if let Some(ref tag_version) = args.overrides.tag_version {
-            // Use existing InputFormatHandler for parsing
+            // Use consolidated VersionObject parsing
             let version_object =
-                InputFormatHandler::parse_version_string(tag_version, &args.input.input_format)?;
+                VersionObject::parse_with_format(tag_version, &args.input.input_format)?;
             let parsed_vars = ZervVars::from(version_object);
 
             // Apply parsed version components to self
@@ -191,7 +191,7 @@ mod tests {
     use crate::version::zerv::core::PreReleaseLabel;
 
     #[rstest]
-    #[case(Some("abcdef1234567890"), Some("abcdef1"))]
+    #[case(Some("abcdef1234567890"), Some("abcdef12"))]
     #[case(Some("abc123"), Some("abc123"))]
     #[case(Some("a"), Some("a"))]
     #[case(Some(""), Some(""))]
@@ -212,7 +212,7 @@ mod tests {
     }
 
     #[rstest]
-    #[case(Some("fedcba0987654321"), Some("fedcba0"))]
+    #[case(Some("fedcba0987654321"), Some("fedcba09"))]
     #[case(Some("def456"), Some("def456"))]
     #[case(Some("x"), Some("x"))]
     #[case(Some(""), Some(""))]
@@ -266,7 +266,7 @@ mod tests {
         );
         assert_eq!(
             parsed.get_bumped_commit_hash_short(),
-            Some("abcdef1".to_string())
+            Some("abcdef12".to_string())
         );
     }
 
diff --git a/tests/integration_tests/flow/main/basic_commands.rs b/tests/integration_tests/flow/main/basic_commands.rs
new file mode 100644
index 00000000..e8a8a565
--- /dev/null
+++ b/tests/integration_tests/flow/main/basic_commands.rs
@@ -0,0 +1,179 @@
+// Basic flow command integration tests
+
+// Tests for basic flow command functionality using stdin input
+// Similar to version command integration tests
+
+use rstest::rstest;
+use zerv::test_utils::ZervFixture;
+use zerv::version::PreReleaseLabel;
+
+use crate::util::TestCommand;
+
+#[rstest]
+#[case::basic_semver((1, 2, 3), "semver", "main", "1.2.3")]
+#[case::basic_pep440((2, 0, 0), "pep440", "main", "2.0.0")]
+fn test_basic_flow_command_with_stdin(
+    #[case] version: (u64, u64, u64),
+    #[case] format: &str,
+    #[case] branch: &str,
+    #[case] expected: &str,
+) {
+    let zerv_ron = ZervFixture::new()
+        .with_version(version.0, version.1, version.2)
+        .with_branch(branch.to_string())
+        .build()
+        .to_string();
+
+    let output = TestCommand::run_with_stdin(
+        &format!("flow --source stdin --schema standard --output-format {format}"),
+        zerv_ron,
+    );
+
+    assert_eq!(output, expected);
+}
+
+#[rstest]
+#[case::alpha_semver(PreReleaseLabel::Alpha, Some(1), "semver", "1.0.0-alpha.1")]
+#[case::beta_pep440(PreReleaseLabel::Beta, Some(2), "pep440", "1.0.0b2")]
+fn test_flow_command_with_pre_release_stdin(
+    #[case] label: PreReleaseLabel,
+    #[case] number: Option<u64>,
+    #[case] format: &str,
+    #[case] expected: &str,
+) {
+    let zerv_ron = ZervFixture::new()
+        .with_version(1, 0, 0)
+        .with_pre_release(label, number)
+        .with_branch("main".to_string())
+        .build()
+        .to_string();
+
+    let output = TestCommand::run_with_stdin(
+        &format!("flow --source stdin --schema standard --output-format {format}"),
+        zerv_ron,
+    );
+
+    assert_eq!(output, expected);
+}
+
+#[rstest]
+#[case::feature_branch("feature/test", "semver", "1.0.0")]
+#[case::develop_branch("develop", "pep440", "1.0.0")]
+fn test_flow_command_with_branch_name_stdin(
+    #[case] branch: &str,
+    #[case] format: &str,
+    #[case] expected: &str,
+) {
+    let zerv_ron = ZervFixture::new()
+        .with_version(1, 0, 0)
+        .with_branch(branch.to_string())
+        .build()
+        .to_string();
+
+    let output = TestCommand::run_with_stdin(
+        &format!("flow --source stdin --schema standard --output-format {format}"),
+        zerv_ron,
+    );
+
+    assert_eq!(output, expected);
+}
+
+#[rstest]
+#[case::different_versions((1, 0, 0), (1, 0, 1), "semver", "1.0.0")]
+#[case::pep440_bump((2, 1, 0), (2, 2, 0), "pep440", "2.1.0")]
+fn test_flow_command_with_different_versions_stdin(
+    #[case] current_version: (u64, u64, u64),
+    #[case] _bumped_version: (u64, u64, u64),
+    #[case] format: &str,
+    #[case] expected: &str,
+) {
+    let zerv_ron = ZervFixture::new()
+        .with_version(current_version.0, current_version.1, current_version.2)
+        .with_branch("main".to_string())
+        .build()
+        .to_string();
+
+    let output = TestCommand::run_with_stdin(
+        &format!("flow --source stdin --schema standard --output-format {format}"),
+        zerv_ron,
+    );
+
+    assert_eq!(output, expected);
+}
+
+#[test]
+fn test_flow_command_help() {
+    let output = TestCommand::run_with_stdin("flow --help", "".to_string());
+
+    assert!(output.contains("flow"));
+    assert!(output.contains("branch patterns"));
+    assert!(output.contains("pre-release detection"));
+}
+
+#[test]
+fn test_flow_command_requires_source() {
+    // Test that flow command works (defaults to git source)
+    let mut cmd = TestCommand::new();
+    cmd.args_from_str("flow --bumped-branch main"); // Use bumped-branch override for CI environments
+
+    let result = cmd.output().expect("Failed to execute flow command");
+
+    // The flow command should work successfully (defaults to git source)
+    assert!(result.status.success());
+}
+
+#[test]
+fn test_flow_command_invalid_option() {
+    let zerv_ron = ZervFixture::new()
+        .with_version(1, 0, 0)
+        .with_branch("main".to_string())
+        .build()
+        .to_string();
+
+    let result =
+        TestCommand::run_with_stdin_expect_fail("flow --source stdin --invalid-option", zerv_ron);
+
+    // Should fail due to invalid option
+    assert!(result.contains("error") || result.contains("unexpected"));
+}
+
+#[rstest]
+#[case::semver_with_pre_release_number("semver", "1.0.0-alpha.1")]
+#[case::pep440_with_dev("pep440", "1.0.0a1")]
+fn test_flow_command_with_pre_release_number_stdin(#[case] format: &str, #[case] expected: &str) {
+    let zerv_ron = ZervFixture::new()
+        .with_version(1, 0, 0)
+        .with_pre_release(PreReleaseLabel::Alpha, Some(1))
+        .with_branch("main".to_string())
+        .build()
+        .to_string();
+
+    let output = TestCommand::run_with_stdin(
+        &format!("flow --source stdin --schema standard --output-format {format}"),
+        zerv_ron,
+    );
+
+    assert_eq!(output, expected);
+}
+
+#[test]
+fn test_flow_command_empty_stdin() {
+    // Test that empty stdin results in appropriate error
+    let result = TestCommand::run_with_stdin_expect_fail(
+        "flow --source stdin --output-format semver",
+        "".to_string(),
+    );
+
+    assert!(result.contains("error") || result.contains("failed"));
+}
+
+#[test]
+fn test_flow_command_invalid_stdin_format() {
+    // Test that invalid RON format results in appropriate error
+    let result = TestCommand::run_with_stdin_expect_fail(
+        "flow --source stdin --output-format semver",
+        "invalid ron content".to_string(),
+    );
+
+    assert!(result.contains("error") || result.contains("failed"));
+}
diff --git a/tests/integration_tests/flow/main/error_handling.rs b/tests/integration_tests/flow/main/error_handling.rs
new file mode 100644
index 00000000..93c4d7b6
--- /dev/null
+++ b/tests/integration_tests/flow/main/error_handling.rs
@@ -0,0 +1,69 @@
+// Error handling tests for flow command using stdin input
+
+use zerv::test_utils::ZervFixture;
+
+use crate::util::TestCommand;
+
+#[test]
+fn test_flow_command_empty_stdin() {
+    let output = TestCommand::run_with_stdin_expect_fail(
+        "flow --source stdin --schema standard --output-format semver",
+        "".to_string(),
+    );
+
+    // Should contain error about empty stdin content
+    assert!(
+        output.contains("empty") || output.contains("stdin") || output.contains("No stdin content"),
+        "Error message should indicate empty input issue: {}",
+        output
+    );
+}
+
+#[test]
+fn test_flow_command_invalid_stdin_format() {
+    let output = TestCommand::run_with_stdin_expect_fail(
+        "flow --source stdin --schema standard --output-format semver",
+        "invalid ron content".to_string(),
+    );
+
+    // Should contain error about invalid RON format
+    assert!(
+        output.contains("invalid") || output.contains("RON") || output.contains("parse"),
+        "Error message should indicate RON parsing issue: {}",
+        output
+    );
+}
+
+#[test]
+fn test_flow_command_invalid_source() {
+    let zerv_ron = ZervFixture::new().with_version(1, 0, 0).build().to_string();
+
+    let output = TestCommand::run_with_stdin_expect_fail(
+        "flow --source invalid_source --schema standard --output-format semver",
+        zerv_ron,
+    );
+
+    // Should contain error about invalid source
+    assert!(
+        output.contains("invalid") || output.contains("source"),
+        "Error message should indicate invalid source: {}",
+        output
+    );
+}
+
+#[test]
+fn test_flow_command_conflicting_format_options() {
+    let zerv_ron = ZervFixture::new().with_version(1, 0, 0).build().to_string();
+
+    let output = TestCommand::run_with_stdin_expect_fail(
+        "flow --source stdin --schema standard --output-format semver --output-format pep440",
+        zerv_ron,
+    );
+
+    // Should contain error about conflicting format options
+    assert!(
+        output.contains("conflict") || output.contains("format") || output.contains("argument"),
+        "Error message should indicate conflicting format options: {}",
+        output
+    );
+}
diff --git a/tests/integration_tests/flow/main/mod.rs b/tests/integration_tests/flow/main/mod.rs
new file mode 100644
index 00000000..899333da
--- /dev/null
+++ b/tests/integration_tests/flow/main/mod.rs
@@ -0,0 +1,6 @@
+// Main flow command integration tests
+
+pub mod basic_commands;
+pub mod error_handling;
+pub mod output_formats;
+pub mod schema_options;
diff --git a/tests/integration_tests/flow/main/output_formats.rs b/tests/integration_tests/flow/main/output_formats.rs
new file mode 100644
index 00000000..ce4181bc
--- /dev/null
+++ b/tests/integration_tests/flow/main/output_formats.rs
@@ -0,0 +1,37 @@
+// Output format tests for flow command using stdin input
+
+use rstest::rstest;
+use zerv::test_utils::ZervFixture;
+
+use crate::util::TestCommand;
+
+#[rstest]
+#[case::semver("semver", "1.2.3")]
+#[case::pep440("pep440", "1.2.3")]
+fn test_flow_command_output_formats(#[case] output_format: &str, #[case] expected_version: &str) {
+    let zerv_ron = ZervFixture::new().with_version(1, 2, 3).build().to_string();
+
+    let output = TestCommand::run_with_stdin(
+        &format!("flow --source stdin --schema standard --output-format {output_format}"),
+        zerv_ron,
+    );
+
+    assert_eq!(output, expected_version);
+}
+
+#[test]
+fn test_flow_command_invalid_output_format() {
+    let zerv_ron = ZervFixture::new().with_version(1, 0, 0).build().to_string();
+
+    let output = TestCommand::run_with_stdin_expect_fail(
+        "flow --source stdin --schema standard --output-format invalid_format",
+        zerv_ron,
+    );
+
+    // Check that output contains error message about invalid format
+    assert!(
+        output.contains("invalid_format") || output.contains("unknown"),
+        "Error message should indicate invalid format: {}",
+        output
+    );
+}
diff --git a/tests/integration_tests/flow/main/schema_options.rs b/tests/integration_tests/flow/main/schema_options.rs
new file mode 100644
index 00000000..6267698f
--- /dev/null
+++ b/tests/integration_tests/flow/main/schema_options.rs
@@ -0,0 +1,48 @@
+// Schema option tests for flow command using stdin input
+
+use rstest::rstest;
+use zerv::test_utils::ZervFixture;
+
+use crate::util::TestCommand;
+
+#[rstest]
+#[case::standard("standard", "1.2.3")]
+#[case::standard_base("standard-base", "1.2.3")]
+fn test_flow_command_schema_options(#[case] schema: &str, #[case] expected_version: &str) {
+    let zerv_ron = ZervFixture::new().with_version(1, 2, 3).build().to_string();
+
+    let output = TestCommand::run_with_stdin(
+        &format!("flow --source stdin --schema {schema} --output-format semver"),
+        zerv_ron,
+    );
+
+    assert_eq!(output, expected_version);
+}
+
+#[test]
+fn test_flow_command_invalid_schema() {
+    let zerv_ron = ZervFixture::new().with_version(1, 0, 0).build().to_string();
+
+    let output = TestCommand::run_with_stdin_expect_fail(
+        "flow --source stdin --schema invalid_schema --output-format semver",
+        zerv_ron,
+    );
+
+    // Check that output contains error message about invalid schema
+    assert!(
+        output.contains("invalid") || output.contains("unknown") || output.contains("schema"),
+        "Error message should indicate invalid schema: {}",
+        output
+    );
+}
+
+#[test]
+fn test_flow_command_missing_schema() {
+    let zerv_ron = ZervFixture::new().with_version(1, 0, 0).build().to_string();
+
+    let output =
+        TestCommand::run_with_stdin("flow --source stdin --output-format semver", zerv_ron);
+
+    // Should work with default schema
+    assert_eq!(output, "1.0.0");
+}
diff --git a/tests/integration_tests/flow/mod.rs b/tests/integration_tests/flow/mod.rs
new file mode 100644
index 00000000..626de0f3
--- /dev/null
+++ b/tests/integration_tests/flow/mod.rs
@@ -0,0 +1,4 @@
+// Integration tests for "zerv flow" command
+
+pub mod main;
+pub mod scenarios;
diff --git a/tests/integration_tests/flow/scenarios/gitflow.rs b/tests/integration_tests/flow/scenarios/gitflow.rs
new file mode 100644
index 00000000..f51de956
--- /dev/null
+++ b/tests/integration_tests/flow/scenarios/gitflow.rs
@@ -0,0 +1,199 @@
+// GitFlow workflow scenario integration tests
+
+// Tests for GitFlow development workflows using actual git repositories
+// Uses FlowIntegrationTestScenario with the same API as existing pipeline tests
+
+use zerv::cli::flow::test_utils::{
+    SchemaTestBuild,
+    SchemaTestExtraCore,
+    create_base_schema_test_cases,
+    create_full_schema_test_cases,
+    expect_branch_hash,
+};
+use zerv::test_info;
+use zerv::test_utils::should_run_docker_tests;
+use zerv::version::zerv::PreReleaseLabel;
+
+use crate::flow::scenarios::FlowIntegrationTestScenario;
+
+/// Test GitFlow development flow - exactly matching the unit test structure
+/// Converted from src/cli/flow/pipeline.rs::test_gitflow_development_flow()
+#[test]
+fn test_gitflow_development_flow() {
+    test_info!("Starting GitFlow development flow test (exactly matching Mermaid diagram)");
+    if !should_run_docker_tests() {
+        return; // Skip when `ZERV_TEST_DOCKER` are disabled
+    }
+
+    // Step 1: Initial state: main and develop branches
+    test_info!("Step 1: Initial setup: main branch state with v1.0.0 tag");
+    let scenario = FlowIntegrationTestScenario::new()
+        .expect("Failed to create test scenario")
+        .create_tag("v1.0.0")
+        .expect_version("1.0.0", "1.0.0")
+        .expect_schema_variants(create_base_schema_test_cases("1.0.0", "main"));
+
+    // Step 2: Create develop branch with initial development commit
+    test_info!("Step 2: Create develop branch and start development");
+    let scenario = scenario
+        .create_branch("develop")
+        .checkout("develop")
+        .commit()
+        .expect_version(
+            "1.0.1-beta.1.post.1+develop.1.g{hex:7}",
+            "1.0.1b1.post1+develop.1.g{hex:7}",
+        );
+
+    // Step 3: Feature development from develop branch (trunk-based post mode)
+    test_info!("Step 3: Create feature/auth branch from develop");
+    let branch_feature_auth_hash = expect_branch_hash("feature/auth", 5, "92409");
+    let scenario = scenario
+        .create_branch("feature/auth")
+        .checkout("feature/auth")
+        .commit()
+        .expect_version(
+            &format!(
+                "1.0.1-alpha.{}.post.2+feature.auth.2.g{{hex:7}}",
+                branch_feature_auth_hash
+            ),
+            &format!(
+                "1.0.1a{}.post2+feature.auth.2.g{{hex:7}}",
+                branch_feature_auth_hash
+            ),
+        )
+        .commit()
+        .expect_version(
+            &format!(
+                "1.0.1-alpha.{}.post.3+feature.auth.3.g{{hex:7}}",
+                branch_feature_auth_hash
+            ),
+            &format!(
+                "1.0.1a{}.post3+feature.auth.3.g{{hex:7}}",
+                branch_feature_auth_hash
+            ),
+        );
+
+    // Step 4: Merge feature/auth back to develop
+    test_info!("Step 4: Merge feature/auth back to develop");
+    let scenario = scenario
+        .checkout("develop")
+        .merge_branch("feature/auth")
+        .expect_version(
+            "1.0.1-beta.1.post.3+develop.3.g{hex:7}",
+            "1.0.1b1.post3+develop.3.g{hex:7}",
+        );
+
+    // Step 5: Hotfix emergency flow from main
+    test_info!("Step 5: Create hotfix/critical branch from main for emergency fix");
+    let branch_hotfix_hash = expect_branch_hash("hotfix/critical", 5, "11477");
+    let scenario = scenario
+        .checkout("main")
+        .create_branch("hotfix/critical")
+        .checkout("hotfix/critical")
+        .commit()
+        .expect_version(
+            &format!(
+                "1.0.1-alpha.{}.post.1+hotfix.critical.1.g{{hex:7}}",
+                branch_hotfix_hash
+            ),
+            &format!(
+                "1.0.1a{}.post1+hotfix.critical.1.g{{hex:7}}",
+                branch_hotfix_hash
+            ),
+        );
+
+    // Step 6: Merge hotfix to main and release v1.0.1
+    test_info!("Step 6: Merge hotfix to main and release v1.0.1");
+    let scenario = scenario
+        .checkout("main")
+        .merge_branch("hotfix/critical")
+        .create_tag("v1.0.1")
+        .expect_version("1.0.1", "1.0.1");
+
+    // Step 7: Sync develop with main changes and continue development
+    test_info!("Step 7: Sync develop with main changes");
+    let scenario = scenario
+        .checkout("develop")
+        .merge_branch("main")
+        .expect_version(
+            "1.0.2-beta.1.post.4+develop.4.g{hex:7}",
+            "1.0.2b1.post4+develop.4.g{hex:7}",
+        );
+
+    // Step 8: Continue development on develop
+    test_info!("Step 8: Continue development on develop branch");
+    let scenario = scenario.commit().expect_version(
+        "1.0.2-beta.1.post.5+develop.5.g{hex:7}",
+        "1.0.2b1.post5+develop.5.g{hex:7}",
+    );
+
+    // Step 9: Release branch preparation (release/1) from develop
+    test_info!("Step 9: Create release/1 branch from develop for release preparation");
+    let scenario = scenario
+        .create_branch("release/1")
+        .checkout("release/1")
+        .commit()
+        .expect_version(
+            "1.0.2-rc.1.post.1+release.1.6.g{hex:7}",
+            "1.0.2rc1.post1+release.1.6.g{hex:7}",
+        )
+        .create_tag("v1.0.2-rc.1.post.1")
+        .expect_version("1.0.2-rc.1.post.1", "1.0.2rc1.post1")
+        .expect_schema_variants(create_full_schema_test_cases(
+            "1.0.2",
+            SchemaTestExtraCore {
+                pre_release_label: PreReleaseLabel::Rc,
+                pre_release_num: "1",
+                post: 1,
+                dev: None,
+            },
+            SchemaTestBuild {
+                sanitized_branch_name: "release.1",
+                distance: 0,
+                include_build_for_standard: false,
+            },
+        ))
+        .commit()
+        .expect_version(
+            "1.0.2-rc.1.post.1+release.1.1.g{hex:7}",
+            "1.0.2rc1.post1+release.1.1.g{hex:7}",
+        )
+        .create_tag("v1.0.2-rc.1.post.2")
+        .expect_version("1.0.2-rc.1.post.2", "1.0.2rc1.post2");
+
+    // Step 10: Continue release branch development with dirty state and commits
+    test_info!("Step 10: Continue release branch development with dirty state and commits");
+    let scenario = scenario
+        .make_dirty()
+        .expect_version(
+            "1.0.2-rc.1.post.1.dev.{timestamp:now}+release.1.0.g{hex:7}",
+            "1.0.2rc1.post1.dev{timestamp:now}+release.1.0.g{hex:7}",
+        )
+        .commit()
+        .expect_version(
+            "1.0.2-rc.1.post.1+release.1.1.g{hex:7}",
+            "1.0.2rc1.post1+release.1.1.g{hex:7}",
+        )
+        .create_tag("v1.0.2-rc.1.post.3")
+        .expect_version("1.0.2-rc.1.post.3", "1.0.2rc1.post3");
+
+    // Step 11: Final release merge to main
+    test_info!("Step 11: Final release merge to main and release v1.1.0");
+    let scenario = scenario
+        .checkout("main")
+        .merge_branch("release/1")
+        .create_tag("v1.1.0")
+        .expect_version("1.1.0", "1.1.0");
+
+    // Step 12: Sync develop with release for next cycle
+    test_info!("Step 12: Sync develop with release and prepare for next cycle");
+    let scenario = scenario
+        .checkout("develop")
+        .merge_branch("main")
+        .expect_version("1.1.0", "1.1.0");
+
+    test_info!("GitFlow test completed successfully - full scenario implemented");
+
+    // Return the scenario (prevents unused variable warning)
+    let _ = scenario;
+}
diff --git a/tests/integration_tests/flow/scenarios/mod.rs b/tests/integration_tests/flow/scenarios/mod.rs
new file mode 100644
index 00000000..73b23107
--- /dev/null
+++ b/tests/integration_tests/flow/scenarios/mod.rs
@@ -0,0 +1,15 @@
+// Flow workflow scenario integration tests
+
+pub mod gitflow;
+pub mod test_utils;
+pub mod trunk_based;
+
+// Re-export test utilities for easy access
+pub use test_utils::{
+    FlowIntegrationTestScenario,
+    FlowTestResult,
+    test_flow_pipeline_with_fixture,
+    test_flow_pipeline_with_fixture_and_schema,
+    test_flow_pipeline_with_fixture_and_schema_opt,
+    test_flow_pipeline_with_schema_test_cases,
+};
diff --git a/tests/integration_tests/flow/scenarios/test_utils.rs b/tests/integration_tests/flow/scenarios/test_utils.rs
new file mode 100644
index 00000000..0f097241
--- /dev/null
+++ b/tests/integration_tests/flow/scenarios/test_utils.rs
@@ -0,0 +1,300 @@
+// Test utilities for flow scenario integration tests
+// Reuses utilities from src/cli/flow/test_utils.rs
+
+use zerv::cli::flow::test_utils::SchemaTestCase;
+use zerv::test_utils::{
+    GitRepoFixture,
+    assert_version_expectation,
+};
+
+use crate::integration_tests::util::command::TestCommand;
+
+/// Flow integration test scenario builder pattern for CLI testing
+/// Same API as FlowTestScenario but uses CLI commands internally
+pub struct FlowIntegrationTestScenario {
+    fixture: GitRepoFixture,
+}
+
+impl FlowIntegrationTestScenario {
+    /// Create an empty git repository for flow integration testing
+    pub fn new() -> Result<Self, Box<dyn std::error::Error>> {
+        let fixture = GitRepoFixture::empty()
+            .map_err(|e| format!("Failed to create empty git fixture: {}", e))?;
+
+        Ok(Self { fixture })
+    }
+
+    /// Create a tag in the current git repository
+    pub fn create_tag(self, tag: &str) -> Self {
+        Self {
+            fixture: self.fixture.create_tag(tag),
+        }
+    }
+
+    /// Create a new branch without checking it out
+    pub fn create_branch(self, branch_name: &str) -> Self {
+        Self {
+            fixture: self.fixture.with_branch(branch_name),
+        }
+    }
+
+    /// Checkout to an existing branch
+    pub fn checkout(self, branch_name: &str) -> Self {
+        Self {
+            fixture: self.fixture.with_checkout(branch_name),
+        }
+    }
+
+    /// Make a commit
+    pub fn commit(self) -> Self {
+        Self {
+            fixture: self.fixture.commit("Test commit"),
+        }
+    }
+
+    /// Make working directory dirty
+    pub fn make_dirty(self) -> Self {
+        Self {
+            fixture: self.fixture.with_dirty(),
+        }
+    }
+
+    /// Merge a branch
+    pub fn merge_branch(self, branch_name: &str) -> Self {
+        Self {
+            fixture: self.fixture.merge_branch(branch_name),
+        }
+    }
+
+    /// Expect version output with semver and pep440 formats
+    /// Uses CLI command instead of direct function call
+    pub fn expect_version(self, semver: &str, pep440: &str) -> Self {
+        test_flow_pipeline_with_fixture(&self.test_dir_path(), semver, pep440);
+        self
+    }
+
+    /// Expect schema variants with the same API as FlowTestScenario
+    /// Uses CLI command for each test case instead of direct function call
+    pub fn expect_schema_variants(self, test_cases: Vec<SchemaTestCase>) -> Self {
+        test_flow_pipeline_with_schema_test_cases(&self.test_dir_path(), test_cases);
+        self
+    }
+
+    /// Run flow command with custom arguments
+    pub fn run_flow_command(self, args: &[&str]) -> FlowTestResult {
+        let mut cmd = TestCommand::new();
+        cmd.arg("flow").args(args);
+        cmd.current_dir(self.test_dir_path());
+
+        let output = cmd.output().expect("Failed to execute flow command");
+
+        FlowTestResult {
+            scenario: self,
+            output,
+            command_args: args.iter().map(|s| s.to_string()).collect(),
+        }
+    }
+
+    /// Get the test directory path
+    pub fn test_dir_path(&self) -> String {
+        self.fixture.path().to_string_lossy().to_string()
+    }
+}
+
+/// Result of running a flow command test
+pub struct FlowTestResult {
+    scenario: FlowIntegrationTestScenario,
+    output: std::process::Output,
+    command_args: Vec<String>,
+}
+
+impl FlowTestResult {
+    /// Assert that the command succeeded and return the scenario for chaining
+    pub fn assert_success(self) -> FlowIntegrationTestScenario {
+        assert!(
+            self.output.status.success(),
+            "Flow command failed with exit code: {:?}\nstderr: {}\nargs: {}",
+            self.output.status.code(),
+            String::from_utf8_lossy(&self.output.stderr),
+            self.command_args.join(" ")
+        );
+        self.scenario
+    }
+
+    /// Assert that the command failed and return the scenario for chaining
+    pub fn assert_failure(self) -> FlowIntegrationTestScenario {
+        assert!(
+            !self.output.status.success(),
+            "Expected flow command to fail but it succeeded\nargs: {}",
+            self.command_args.join(" ")
+        );
+        self.scenario
+    }
+
+    /// Assert that the command succeeded and check stdout content
+    pub fn assert_stdout_contains(self, expected: &str) -> FlowIntegrationTestScenario {
+        assert!(
+            self.output.status.success(),
+            "Flow command failed with exit code: {:?}\nstderr: {}\nargs: {}",
+            self.output.status.code(),
+            String::from_utf8_lossy(&self.output.stderr),
+            self.command_args.join(" ")
+        );
+
+        let stdout = String::from_utf8_lossy(&self.output.stdout);
+        assert!(
+            stdout.contains(expected),
+            "Expected stdout to contain '{}', but got: '{}'",
+            expected,
+            stdout
+        );
+        self.scenario
+    }
+
+    /// Assert that the command succeeded and check exact stdout
+    pub fn assert_stdout_eq(self, expected: &str) -> FlowIntegrationTestScenario {
+        assert!(
+            self.output.status.success(),
+            "Flow command failed with exit code: {:?}\nstderr: {}\nargs: {}",
+            self.output.status.code(),
+            String::from_utf8_lossy(&self.output.stderr),
+            self.command_args.join(" ")
+        );
+
+        let stdout = String::from_utf8_lossy(&self.output.stdout);
+        let trimmed_stdout = stdout.trim();
+        let trimmed_expected = expected.trim();
+
+        assert_eq!(
+            trimmed_stdout, trimmed_expected,
+            "Expected stdout to be exactly '{}', but got: '{}'",
+            trimmed_expected, trimmed_stdout
+        );
+        self.scenario
+    }
+
+    /// Assert that the command failed and check stderr content
+    pub fn assert_stderr_contains(self, expected: &str) -> FlowIntegrationTestScenario {
+        assert!(
+            !self.output.status.success(),
+            "Expected flow command to fail but it succeeded\nargs: {}",
+            self.command_args.join(" ")
+        );
+
+        let stderr = String::from_utf8_lossy(&self.output.stderr);
+        assert!(
+            stderr.contains(expected),
+            "Expected stderr to contain '{}', but got: '{}'",
+            expected,
+            stderr
+        );
+        self.scenario
+    }
+
+    /// Get stdout as string
+    pub fn stdout(&self) -> String {
+        String::from_utf8_lossy(&self.output.stdout).to_string()
+    }
+
+    /// Get stderr as string
+    pub fn stderr(&self) -> String {
+        String::from_utf8_lossy(&self.output.stderr).to_string()
+    }
+
+    /// Get exit code
+    pub fn exit_code(&self) -> Option<i32> {
+        self.output.status.code()
+    }
+}
+
+pub fn test_flow_pipeline_with_fixture(
+    fixture_path: &str,
+    semver_expectation: &str,
+    pep440_expectation: &str,
+) {
+    test_flow_pipeline_with_fixture_and_schema_opt(
+        fixture_path,
+        None,
+        semver_expectation,
+        pep440_expectation,
+    )
+}
+
+pub fn test_flow_pipeline_with_fixture_and_schema(
+    fixture_path: &str,
+    schema: &str,
+    semver_expectation: &str,
+    pep440_expectation: &str,
+) {
+    test_flow_pipeline_with_fixture_and_schema_opt(
+        fixture_path,
+        Some(schema),
+        semver_expectation,
+        pep440_expectation,
+    )
+}
+
+pub fn test_flow_pipeline_with_fixture_and_schema_opt(
+    fixture_path: &str,
+    schema: Option<&str>,
+    semver_expectation: &str,
+    pep440_expectation: &str,
+) {
+    let test_cases = vec![
+        ("semver", semver_expectation),
+        ("pep440", pep440_expectation),
+    ];
+
+    for (format_name, expectation) in test_cases {
+        let mut cmd_args = vec!["flow", "--output-format", format_name];
+
+        // Set schema if provided
+        if let Some(schema_value) = schema {
+            cmd_args.push("--schema");
+            cmd_args.push(schema_value);
+        }
+
+        let mut cmd = TestCommand::new();
+        cmd.args_from_str(cmd_args.join(" "));
+        cmd.current_dir(fixture_path);
+
+        let output = cmd.output().expect("Failed to execute flow command");
+        let schema_desc = match schema {
+            Some(s) => format!(" and {} schema", s),
+            None => String::new(),
+        };
+
+        assert!(
+            output.status.success(),
+            "Flow command should succeed with {} format{} at {}: {}",
+            format_name,
+            schema_desc,
+            fixture_path,
+            String::from_utf8_lossy(&output.stderr)
+        );
+
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        assert!(
+            !stdout.is_empty(),
+            "Flow pipeline should produce output for {} format{}",
+            format_name,
+            schema_desc
+        );
+
+        assert_version_expectation(expectation, stdout.trim());
+    }
+}
+
+pub fn test_flow_pipeline_with_schema_test_cases(
+    fixture_path: &str,
+    schema_test_cases: Vec<SchemaTestCase>,
+) {
+    for test_case in schema_test_cases {
+        test_flow_pipeline_with_fixture_and_schema(
+            fixture_path,
+            test_case.name,
+            &test_case.semver_expectation,
+            &test_case.pep440_expectation,
+        );
+    }
+}
diff --git a/tests/integration_tests/flow/scenarios/trunk_based.rs b/tests/integration_tests/flow/scenarios/trunk_based.rs
new file mode 100644
index 00000000..2b567927
--- /dev/null
+++ b/tests/integration_tests/flow/scenarios/trunk_based.rs
@@ -0,0 +1,251 @@
+// Trunk-based workflow scenario integration tests
+
+// Tests for trunk-based development workflows using actual git repositories
+// Uses FlowIntegrationTestScenario with the same API as existing pipeline tests
+
+use zerv::cli::flow::test_utils::{
+    SchemaTestBuild,
+    SchemaTestExtraCore,
+    create_base_schema_test_cases,
+    create_full_schema_test_cases,
+    expect_branch_hash,
+};
+use zerv::test_info;
+use zerv::test_utils::should_run_docker_tests;
+use zerv::version::zerv::PreReleaseLabel;
+
+use crate::flow::scenarios::FlowIntegrationTestScenario;
+
+/// Test trunk-based development flow - exactly matching the unit test structure
+/// Converted from src/cli/flow/pipeline.rs::test_trunk_based_development_flow()
+#[test]
+fn test_trunk_based_development_flow() {
+    test_info!("Starting trunk-based development flow test (exactly matching Mermaid diagram)");
+    if !should_run_docker_tests() {
+        return; // Skip when `ZERV_TEST_DOCKER` are disabled
+    }
+
+    // Step 1: Initial commit on main with v1.0.0
+    test_info!("Step 1: Initial setup: main branch state with v1.0.0 tag");
+    let scenario = FlowIntegrationTestScenario::new()
+        .expect("Failed to create test scenario")
+        .create_tag("v1.0.0")
+        .expect_version("1.0.0", "1.0.0")
+        .expect_schema_variants(create_base_schema_test_cases("1.0.0", "main"));
+
+    // Step 2: Create parallel feature branches feature-1 and feature-2 from main
+    test_info!("Step 2: Create parallel feature branches: feature-1 and feature-2");
+    let scenario = scenario
+        .create_branch("feature-1")
+        .create_branch("feature-2");
+
+    // Capture actual hash values for validation
+    let branch_feature_2_hash = expect_branch_hash("feature-2", 5, "68031");
+    let branch_feature_1_hash = expect_branch_hash("feature-1", 5, "42954");
+
+    // Step 3: feature-2: Start development with dirty state (matches Mermaid REVERSE commit)
+    test_info!("Step 3: feature-2: Start development with dirty state");
+    let scenario = scenario
+        .checkout("feature-2")
+        .make_dirty()
+        .expect_version(
+            &format!(
+                "1.0.1-alpha.{}.post.0.dev.{{timestamp:now}}+feature.2.0.g{{hex:7}}",
+                branch_feature_2_hash
+            ),
+            &format!(
+                "1.0.1a{}.post0.dev{{timestamp:now}}+feature.2.0.g{{hex:7}}",
+                branch_feature_2_hash
+            ),
+        )
+        .expect_schema_variants(create_full_schema_test_cases(
+            "1.0.1",
+            SchemaTestExtraCore {
+                pre_release_label: PreReleaseLabel::Alpha,
+                pre_release_num: &branch_feature_2_hash.to_string(),
+                post: 0,
+                dev: Some("{timestamp:now}"),
+            },
+            SchemaTestBuild {
+                sanitized_branch_name: "feature.2",
+                distance: 0,
+                include_build_for_standard: true,
+            },
+        ));
+
+    // Step 4: feature-2: Create first commit
+    test_info!("Step 4: feature-2: Create first commit");
+    let scenario = scenario.commit().expect_version(
+        &format!(
+            "1.0.1-alpha.{}.post.1+feature.2.1.g{{hex:7}}",
+            branch_feature_2_hash
+        ),
+        &format!(
+            "1.0.1a{}.post1+feature.2.1.g{{hex:7}}",
+            branch_feature_2_hash
+        ),
+    );
+
+    // Step 5: feature-1: Create commits (parallel development)
+    test_info!("Step 5: feature-1: Create commits (parallel development)");
+    let scenario = scenario
+        .checkout("feature-1")
+        .commit()
+        .expect_version(
+            &format!(
+                "1.0.1-alpha.{}.post.1+feature.1.1.g{{hex:7}}",
+                branch_feature_1_hash
+            ),
+            &format!(
+                "1.0.1a{}.post1+feature.1.1.g{{hex:7}}",
+                branch_feature_1_hash
+            ),
+        )
+        .commit()
+        .expect_version(
+            &format!(
+                "1.0.1-alpha.{}.post.2+feature.1.2.g{{hex:7}}",
+                branch_feature_1_hash
+            ),
+            &format!(
+                "1.0.1a{}.post2+feature.1.2.g{{hex:7}}",
+                branch_feature_1_hash
+            ),
+        );
+
+    // Step 6: feature-1: Merge to main and release v1.0.1
+    test_info!("Step 6: feature-1: Merge to main and release v1.0.1");
+    let scenario = scenario
+        .checkout("main")
+        .merge_branch("feature-1")
+        .create_tag("v1.0.1")
+        .expect_version("1.0.1", "1.0.1");
+
+    // Step 7: feature-2: Sync with main to get feature-1 changes
+    test_info!("Step 7: feature-2: Sync with main to get feature-1 changes");
+    let scenario = scenario
+        .checkout("feature-2")
+        .merge_branch("main")
+        .expect_version(
+            &format!(
+                "1.0.2-alpha.{}.post.2+feature.2.2.g{{hex:7}}",
+                branch_feature_2_hash
+            ),
+            &format!(
+                "1.0.2a{}.post2+feature.2.2.g{{hex:7}}",
+                branch_feature_2_hash
+            ),
+        );
+
+    // Step 8: feature-2: Create additional commit
+    test_info!("Step 8: feature-2: Create additional commit");
+    let scenario = scenario.commit().expect_version(
+        &format!(
+            "1.0.2-alpha.{}.post.3+feature.2.3.g{{hex:7}}",
+            branch_feature_2_hash
+        ),
+        &format!(
+            "1.0.2a{}.post3+feature.2.3.g{{hex:7}}",
+            branch_feature_2_hash
+        ),
+    );
+
+    // Step 9: feature-3: Branch from feature-2 for sub-feature development
+    test_info!("Step 9: feature-3: Branch from feature-2 for sub-feature development");
+    let branch_feature_3_hash = expect_branch_hash("feature-3", 5, "14698");
+    let scenario = scenario
+        .create_branch("feature-3")
+        .checkout("feature-3")
+        .commit()
+        .expect_version(
+            &format!(
+                "1.0.2-alpha.{}.post.4+feature.3.4.g{{hex:7}}",
+                branch_feature_3_hash
+            ),
+            &format!(
+                "1.0.2a{}.post4+feature.3.4.g{{hex:7}}",
+                branch_feature_3_hash
+            ),
+        );
+
+    // Step 10: feature-3: Continue development with dirty state
+    test_info!("Step 10: feature-3: Continue development with dirty state");
+    let scenario = scenario.make_dirty().expect_version(
+        &format!(
+            "1.0.2-alpha.{}.post.4.dev.{{timestamp:now}}+feature.3.4.g{{hex:7}}",
+            branch_feature_3_hash
+        ),
+        &format!(
+            "1.0.2a{}.post4.dev{{timestamp:now}}+feature.3.4.g{{hex:7}}",
+            branch_feature_3_hash
+        ),
+    );
+
+    // Step 11: feature-3: Continue development with commits
+    test_info!("Step 11: feature-3: Continue development with commits");
+    let scenario = scenario
+        .commit()
+        .expect_version(
+            &format!(
+                "1.0.2-alpha.{}.post.5+feature.3.5.g{{hex:7}}",
+                branch_feature_3_hash
+            ),
+            &format!(
+                "1.0.2a{}.post5+feature.3.5.g{{hex:7}}",
+                branch_feature_3_hash
+            ),
+        )
+        .commit()
+        .expect_version(
+            &format!(
+                "1.0.2-alpha.{}.post.6+feature.3.6.g{{hex:7}}",
+                branch_feature_3_hash
+            ),
+            &format!(
+                "1.0.2a{}.post6+feature.3.6.g{{hex:7}}",
+                branch_feature_3_hash
+            ),
+        );
+
+    // Step 12: feature-2: Merge feature-3 back to continue development
+    test_info!("Step 12: feature-2: Merge feature-3 back to continue development");
+    let scenario = scenario
+        .checkout("feature-2")
+        .merge_branch("feature-3")
+        .expect_version(
+            &format!(
+                "1.0.2-alpha.{}.post.6+feature.2.6.g{{hex:7}}",
+                branch_feature_2_hash
+            ),
+            &format!(
+                "1.0.2a{}.post6+feature.2.6.g{{hex:7}}",
+                branch_feature_2_hash
+            ),
+        );
+
+    // Step 13: feature-2: Final development before release
+    test_info!("Step 13: feature-2: Final development before release");
+    let scenario = scenario.commit().expect_version(
+        &format!(
+            "1.0.2-alpha.{}.post.7+feature.2.7.g{{hex:7}}",
+            branch_feature_2_hash
+        ),
+        &format!(
+            "1.0.2a{}.post7+feature.2.7.g{{hex:7}}",
+            branch_feature_2_hash
+        ),
+    );
+
+    // Step 14: Final release: feature-2 merges to main and releases v1.1.0
+    test_info!("Step 14: Final release: feature-2 merges to main and releases v1.1.0");
+    let scenario = scenario
+        .checkout("main")
+        .merge_branch("feature-2")
+        .create_tag("v1.1.0")
+        .expect_version("1.1.0", "1.1.0");
+
+    test_info!("Trunk-based development flow test completed successfully!");
+
+    // Return the scenario (prevents unused variable warning)
+    let _ = scenario;
+}
diff --git a/tests/integration_tests/mod.rs b/tests/integration_tests/mod.rs
index e2f92215..b99605ae 100644
--- a/tests/integration_tests/mod.rs
+++ b/tests/integration_tests/mod.rs
@@ -1,4 +1,5 @@
 pub mod check;
+pub mod flow;
 pub mod help_flags;
 pub mod logging;
 pub mod util;
diff --git a/tests/integration_tests/version/combinations/main_bump_interactions.rs b/tests/integration_tests/version/combinations/main_bump_interactions.rs
index 830df3fb..6e4ea444 100644
--- a/tests/integration_tests/version/combinations/main_bump_interactions.rs
+++ b/tests/integration_tests/version/combinations/main_bump_interactions.rs
@@ -155,7 +155,7 @@ mod schema_bump_combinations {
             "version --source stdin --schema standard --bump-major --output-format semver",
             zerv_ron,
         );
-        assert_eq!(output, "3.0.0+feature.test.branch.5.abc123d");
+        assert_eq!(output, "3.0.0+feature.test.branch.5.abc123de");
     }
 
     #[rstest]
@@ -165,7 +165,7 @@ mod schema_bump_combinations {
             "version --source stdin --schema calver --bump-major --output-format semver",
             zerv_ron,
         );
-        assert_eq!(output, "0.0.0+release.3.xyz789a");
+        assert_eq!(output, "0.0.0+release.3.xyz789ab");
     }
 
     #[rstest]
@@ -177,7 +177,7 @@ mod schema_bump_combinations {
             "version --source stdin --schema standard --bump-core 0=2 --output-format semver",
             zerv_ron,
         );
-        assert_eq!(output, "4.0.0+feature.test.branch.5.abc123d");
+        assert_eq!(output, "4.0.0+feature.test.branch.5.abc123de");
     }
 
     #[rstest]
@@ -189,7 +189,7 @@ mod schema_bump_combinations {
             "version --source stdin --schema standard --bump-major --bump-minor --output-format semver",
             zerv_ron,
         );
-        assert_eq!(output, "3.1.0+feature.test.branch.5.abc123d");
+        assert_eq!(output, "3.1.0+feature.test.branch.5.abc123de");
     }
 }
 
diff --git a/tests/integration_tests/version/combinations/main_override_interactions.rs b/tests/integration_tests/version/combinations/main_override_interactions.rs
index 673d2aa0..75df3a70 100644
--- a/tests/integration_tests/version/combinations/main_override_interactions.rs
+++ b/tests/integration_tests/version/combinations/main_override_interactions.rs
@@ -198,7 +198,7 @@ mod schema_override_combinations {
         "--schema standard",
         "--major",
         "5",
-        "5.1.0+feature.test.branch.5.abc123d"
+        "5.1.0+feature.test.branch.5.abc123de"
     )]
     fn test_schema_preset_with_component_overrides(
         base_fixture: ZervFixture,
@@ -235,7 +235,7 @@ mod schema_override_combinations {
 
         let zerv_ron = base_fixture.build().to_string();
         let today_date = chrono::Utc::now().format("%Y.%-m.%-d").to_string();
-        let expected = format!("{}-5+feature.test.branch.5.abc123d", today_date);
+        let expected = format!("{}-5+feature.test.branch.5.abc123de", today_date);
 
         let output = TestCommand::run_with_stdin(
             "version --source stdin --schema calver --patch 5 --output-format semver",
@@ -254,7 +254,7 @@ mod schema_override_combinations {
             "version --source stdin --schema standard --core 0=3 --output-format semver",
             zerv_ron,
         );
-        assert_eq!(output, "3.1.0+feature.test.branch.5.abc123d");
+        assert_eq!(output, "3.1.0+feature.test.branch.5.abc123de");
     }
 }
 
diff --git a/tests/integration_tests/version/main/schemas.rs b/tests/integration_tests/version/main/schemas.rs
index c4b205b3..04427ff3 100644
--- a/tests/integration_tests/version/main/schemas.rs
+++ b/tests/integration_tests/version/main/schemas.rs
@@ -132,8 +132,8 @@ mod schema_preset_standard {
     }
 
     #[rstest]
-    #[case::dirty((1, 0, 0), "1.0.0-dev.1234567890+feature.branch.5.abc123d")]
-    #[case::with_distance((2, 1, 0), "2.1.0-dev.1234567890+feature.branch.5.abc123d")]
+    #[case::dirty((1, 0, 0), "1.0.0-dev.1234567890+feature.branch.5.abc123de")]
+    #[case::with_distance((2, 1, 0), "2.1.0-dev.1234567890+feature.branch.5.abc123de")]
     fn test_tier_3(
         tier_3_fixture: ZervFixture,
         #[case] version: (u64, u64, u64),
@@ -485,7 +485,7 @@ mod schema_tier_behavior {
             TestCommand::run_with_stdin("version --source stdin --schema standard", zerv_ron);
 
         assert_eq!(
-            output, "1.2.3-dev.1234567890+main.branch.0.def456a",
+            output, "1.2.3-dev.1234567890+main.branch.0.def456ab",
             "Dirty state should trigger tier 3 with dev component"
         );
     }
diff --git a/tests/integration_tests/version/main/sources/git.rs b/tests/integration_tests/version/main/sources/git.rs
index 791e472a..5d0bf498 100644
--- a/tests/integration_tests/version/main/sources/git.rs
+++ b/tests/integration_tests/version/main/sources/git.rs
@@ -37,12 +37,13 @@ fn test_git_source_comprehensive() {
     );
     if let Some(ref hash) = parsed_zerv.vars.bumped_commit_hash {
         assert!(
-            hash.len() >= 7 && hash.len() <= 40,
-            "Commit hash should be 7-40 chars"
+            hash.len() >= 8 && hash.len() <= 41,
+            "Commit hash should be 8-41 chars (including g prefix)"
         );
+        assert_eq!(&hash[..1], "g", "Commit hash should start with 'g' prefix");
         assert!(
-            hash.chars().all(|c| c.is_ascii_hexdigit()),
-            "Commit hash should be hex"
+            hash[1..].chars().all(|c| c.is_ascii_hexdigit()),
+            "Commit hash suffix should be hex"
         );
     }
 
@@ -61,11 +62,12 @@ fn test_git_source_comprehensive() {
         )
         .build();
 
-    // Copy non-deterministic timestamp
+    // Copy non-deterministic timestamp and hash fields
     let mut expected = expected;
     expected.vars.bumped_commit_hash = parsed_zerv.vars.bumped_commit_hash.clone();
     expected.vars.last_timestamp = parsed_zerv.vars.last_timestamp;
     expected.vars.bumped_timestamp = parsed_zerv.vars.bumped_timestamp;
+    expected.vars.last_commit_hash = parsed_zerv.vars.last_commit_hash.clone();
 
     // Git source doesn't provide last_branch - it should be None
     assert_eq!(
diff --git a/tests/integration_tests/version/main/templates.rs b/tests/integration_tests/version/main/templates.rs
index 844e3172..5c0e8507 100644
--- a/tests/integration_tests/version/main/templates.rs
+++ b/tests/integration_tests/version/main/templates.rs
@@ -88,13 +88,13 @@ mod template_vcs_fields {
     )]
     #[case::commit_hash(
         "{{major}}.{{minor}}.{{patch}}+{{bumped_commit_hash}}",
-        |f: ZervFixture| f.with_vcs_data(None, None, None, Some("abc123def456".to_string()), None, None, None),
-        "1.0.0+abc123def456"
+        |f: ZervFixture| f.with_vcs_data(None, None, None, Some("gabc123def456".to_string()), None, None, None),
+        "1.0.0+gabc123def456"
     )]
     #[case::commit_hash_short(
         "{{major}}.{{minor}}.{{patch}}+{{bumped_commit_hash_short}}",
-        |f: ZervFixture| f.with_vcs_data(None, None, None, Some("abc123def456".to_string()), None, None, None),
-        "1.0.0+abc123d"
+        |f: ZervFixture| f.with_vcs_data(None, None, None, Some("gabc123def456".to_string()), None, None, None),
+        "1.0.0+gabc123d"
     )]
     fn test_template_vcs(
         #[case] template: &str,
@@ -267,12 +267,12 @@ mod template_complex_scenarios {
             Some(5),
             Some(false),
             Some("main".to_string()),
-            Some("abc123".to_string()),
+            Some("gabc123".to_string()),
             None,
             None,
             None,
         );
-        assert_eq!(run_template(template, fixture), "1.2.3.post5+main.abc123");
+        assert_eq!(run_template(template, fixture), "1.2.3.post5+main.gabc123");
     }
 
     #[test]
@@ -288,14 +288,14 @@ mod template_complex_scenarios {
                 Some(0),
                 Some(true),
                 Some("feature.branch".to_string()),
-                Some("def456".to_string()),
+                Some("gdef456".to_string()),
                 None,
                 None,
                 None,
             );
         assert_eq!(
             run_template(template, fixture),
-            "1.0.0.dev1234567890+feature.branch.def456"
+            "1.0.0.dev1234567890+feature.branch.gdef456"
         );
     }
 
diff --git a/tests/integration_tests/version/overrides/custom.rs b/tests/integration_tests/version/overrides/custom.rs
index 1555eda7..1a4ff6ac 100644
--- a/tests/integration_tests/version/overrides/custom.rs
+++ b/tests/integration_tests/version/overrides/custom.rs
@@ -406,7 +406,7 @@ mod real_world_scenarios {
                 Some(0),
                 Some(false),
                 Some("main".to_string()),
-                Some("abc123def456".to_string()),
+                Some("gabc123def456".to_string()),
                 None,
                 None,
                 None,
@@ -425,6 +425,6 @@ mod real_world_scenarios {
             zerv_ron,
         );
 
-        assert_eq!(output, "ghcr.io/myorg/myapp:3.0.0-abc123d");
+        assert_eq!(output, "ghcr.io/myorg/myapp:3.0.0-gabc123d");
     }
 }