diff --git a/conductor/tracks.md b/conductor/tracks.md
index a1372ac..bae9481 100644
--- a/conductor/tracks.md
+++ b/conductor/tracks.md
@@ -4,8 +4,3 @@ This file tracks all major tracks for the project. Each track has its own detail
 
 ---
 
-- [ ] **Track: Implement Meyer's Square training workflow with visual-only interaction and 'Ghost of Meyer' guidance.**
-*Link: [./tracks/meyer_square_20260324/](./tracks/meyer_square_20260324/)*
-
----
-
diff --git a/conductor/tracks/meyer_square_20260324/index.md b/conductor/tracks/meyer_square_20260324/index.md
deleted file mode 100644
index 3352f77..0000000
--- a/conductor/tracks/meyer_square_20260324/index.md
+++ /dev/null
@@ -1,5 +0,0 @@
-# Track meyer_square_20260324 Context
-
-- [Specification](./spec.md)
-- [Implementation Plan](./plan.md)
-- [Metadata](./metadata.json)
diff --git a/conductor/tracks/meyer_square_20260324/metadata.json b/conductor/tracks/meyer_square_20260324/metadata.json
deleted file mode 100644
index 270d0b8..0000000
--- a/conductor/tracks/meyer_square_20260324/metadata.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-  "track_id": "meyer_square_20260324",
-  "type": "feature",
-  "status": "new",
-  "created_at": "2026-03-24T15:00:00Z",
-  "updated_at": "2026-03-24T15:00:00Z",
-  "description": "Implement Meyer's Square training workflow with visual-only interaction and 'Ghost of Meyer' guidance."
-}
\ No newline at end of file
diff --git a/conductor/tracks/meyer_square_20260324/plan.md b/conductor/tracks/meyer_square_20260324/plan.md
deleted file mode 100644
index b826b29..0000000
--- a/conductor/tracks/meyer_square_20260324/plan.md
+++ /dev/null
@@ -1,36 +0,0 @@
-# Implementation Plan: Meyer's Square Workflow
-
-## Phase 1: Data Structures & Core Logic
-### Task: Implement Meyer's Square Data Structures
-- [ ] Task: Define `MeyerSequence` and `MeyerNode` structs for 16-target geometry
-    - [ ] Create `MeyerNode` struct with (x, y) coordinates and technique type
-    - [ ] Define the 4 concentric 4-strike sequences using historical data
-- [ ] Task: Implement `MeyerTrainingResource` to manage visual-only flow
-    - [ ] Add state to track current sequence, node, and technique
-    - [ ] Implement logic to cycle through sequences without keyboard input
-- [ ] Task: Conductor - User Manual Verification 'Data Structures & Core Logic' (Protocol in workflow.md)
-
-## Phase 2: UI & Render Foundations
-### Task: Add Workflow Toggle in Settings
-- [ ] Task: Update `Settings` component to include a `TrainingWorkflow` enum (Circular, MeyerSquare)
-- [ ] Task: Implement UI button in the side panel to toggle between workflows
-- [ ] Task: Refactor `Target` rendering system to switch based on the active workflow
-- [ ] Task: Conductor - User Manual Verification 'UI & Render Foundations' (Protocol in workflow.md)
-
-## Phase 3: "Ghost of Meyer" Visual Signatures
-### Task: Implement Geometric Grid Rendering
-- [ ] Task: Render the bounding square and thick central cross in "GHOST_BORDER" style
-- [ ] Task: Render the 16 nodes as sharp, low-opacity markers in their concentric squares
-- [ ] Task: Implement "Glow Intensity" logic to highlight the active sequence
-### Task: Implement Technique Visual Signatures
-- [ ] Task: Implement "Slash (Cut)" shader/system with decaying trail
-- [ ] Task: Implement "Beam (Thrust)" telescoping line system
-- [ ] Task: Implement "Shield (Parry)" strobing/blinking visual marker
-- [ ] Task: Conductor - User Manual Verification 'Visual Signatures' (Protocol in workflow.md)
-
-## Phase 4: Integration & Training Flow
-### Task: Finalize Training Loop for Meyer's Square
-- [ ] Task: Connect the `MeyerTrainingResource` logic to the "Ghost" rendering systems
-- [ ] Task: Ensure smooth transitions between sequences and nodes
-- [ ] Task: Final polish of "Kinetic Brutalism" aesthetic for the Meyer workflow
-- [ ] Task: Conductor - User Manual Verification 'Integration & Training Flow' (Protocol in workflow.md)
diff --git a/conductor/tracks/meyer_square_20260324/spec.md b/conductor/tracks/meyer_square_20260324/spec.md
deleted file mode 100644
index 0fe4f3b..0000000
--- a/conductor/tracks/meyer_square_20260324/spec.md
+++ /dev/null
@@ -1,41 +0,0 @@
-# Track: Meyer's Square Workflow Implementation
-
-## Overview
-This track implements a second training workflow based on the 16th-century **Meyer's Square** (Carre Meyer) diagram. It replaces the circular 8-point system with a four-quadrant concentric grid. The interaction is **purely visual**, where a "Ghost of Meyer" guide indicates the path and technique (cut, thrust, parry) the user should execute.
-
-## Functional Requirements
-### 1. Geometric Grid (Meyer's Square)
-- Render a four-quadrant system with a stark bounding square and a thick central cross.
-- Implement 16 target nodes arranged in four concentric square sequences (Outer, Outer-Mid, Inner-Mid, Inner).
-- Each sequence consists of a 4-strike order crossing through the central intersection.
-
-### 2. "Ghost of Meyer" Visual Guidance
-- Implement a **Temporal Kinetic Guide** (the "Ghost") that provides visual-only cues:
-    - **Slash (Cut)**: A high-intensity "Kinetic Slash" traveling from start to end with a decaying "blade-width" trail.
-    - **Beam (Thrust)**: A sharp, narrow "Focus Beam" telescoping outward from the center/previous node to the next.
-    - **Shield (Parry)**: A "Static Shield" or "Block" that appears on a line, strobing/blinking to signal a defensive hold.
-- Distinguish the four sequences using **Glow Intensity** and pulse frequency rather than color.
-
-### 3. Training Logic (Technique Mode)
-- The system cycles through the 16 nodes in their defined sequences.
-- The "Ghost" changes shape (Slash, Beam, Shield) to signal the required technique for the next strike.
-- No keyboard interaction required; the session is a continuous visual drill.
-
-### 4. UI/UX Transitions
-- Add a "Workflow" toggle in the Settings panel to switch between `Circular` and `Meyer Square`.
-- The UI should adapt the "Active Canvas" to display either the circular targets or the geometric Meyer grid.
-
-## Non-Functional Requirements
-- **Performance**: Maintain smooth rendering of the "Ghost" paths and trails in Bevy.
-- **Aesthetic**: Adhere to the "Kinetic Brutalism" style (high contrast, emissive red glow, sharp lines).
-
-## Acceptance Criteria
-- [ ] User can switch between Circular and Meyer Square workflows in Settings.
-- [ ] Meyer Square grid renders correctly with 16 nodes and central cross.
-- [ ] "Ghost of Meyer" correctly visualizes Slash, Beam, and Shield techniques.
-- [ ] The sequences follow the historically accurate 4x4 strike patterns.
-- [ ] Training session progresses purely visually without keyboard input.
-
-## Out of Scope
-- Keyboard input for Meyer's Square (visual-only MVP).
-- Custom sequence creation (using historical sequences only).
diff --git a/src/components.rs b/src/components.rs
index bb05394..6a37e6d 100644
--- a/src/components.rs
+++ b/src/components.rs
@@ -68,3 +68,9 @@ pub struct CurriculumPageText;
 /// Marker for the curriculum document image display node.
 #[derive(Component)]
 pub struct CurriculumDocumentImage;
+
+/// Marker for the UI button that switches the training workflow.
+///
+/// Used to identify the button that toggles between Circular and Meyer's Square workflows.
+#[derive(Component)]
+pub struct WorkflowModeButton;
diff --git a/src/constants.rs b/src/constants.rs
index 059a806..1205504 100644
--- a/src/constants.rs
+++ b/src/constants.rs
@@ -24,6 +24,49 @@ pub const CIRCLE_RADIUS: f32 = 300.0;
 /// standard HEMA target diagrams (e.g., Meyer's Square).
 pub const LABELS: [u8; 8] = [7, 1, 5, 3, 8, 4, 6, 2];
 
+/// The four concentric sequences of Meyer's Square.
+///
+/// Organized from outer to inner, with each sequence containing a 4-strike order.
+/// Coordinates are normalized from -1.0 to 1.0, with (0,0) at the center.
+pub const MEYER_SEQUENCES: [crate::resources::MeyerSequence; 4] = [
+    // Outer Sequence
+    crate::resources::MeyerSequence {
+        nodes: [
+            crate::resources::MeyerNode { x: -1.0, y: 1.0, technique: crate::resources::TechniqueType::Cut },
+            crate::resources::MeyerNode { x: 1.0, y: -1.0, technique: crate::resources::TechniqueType::Cut },
+            crate::resources::MeyerNode { x: -1.0, y: -1.0, technique: crate::resources::TechniqueType::Cut },
+            crate::resources::MeyerNode { x: 1.0, y: 1.0, technique: crate::resources::TechniqueType::Cut },
+        ],
+    },
+    // Outer-Mid Sequence
+    crate::resources::MeyerSequence {
+        nodes: [
+            crate::resources::MeyerNode { x: -0.66, y: 0.66, technique: crate::resources::TechniqueType::Thrust },
+            crate::resources::MeyerNode { x: 0.66, y: -0.66, technique: crate::resources::TechniqueType::Thrust },
+            crate::resources::MeyerNode { x: -0.66, y: -0.66, technique: crate::resources::TechniqueType::Thrust },
+            crate::resources::MeyerNode { x: 0.66, y: 0.66, technique: crate::resources::TechniqueType::Thrust },
+        ],
+    },
+    // Inner-Mid Sequence
+    crate::resources::MeyerSequence {
+        nodes: [
+            crate::resources::MeyerNode { x: -0.33, y: 0.33, technique: crate::resources::TechniqueType::Parry },
+            crate::resources::MeyerNode { x: 0.33, y: -0.33, technique: crate::resources::TechniqueType::Parry },
+            crate::resources::MeyerNode { x: -0.33, y: -0.33, technique: crate::resources::TechniqueType::Parry },
+            crate::resources::MeyerNode { x: 0.33, y: 0.33, technique: crate::resources::TechniqueType::Parry },
+        ],
+    },
+    // Inner Sequence
+    crate::resources::MeyerSequence {
+        nodes: [
+            crate::resources::MeyerNode { x: -0.1, y: 0.1, technique: crate::resources::TechniqueType::Cut },
+            crate::resources::MeyerNode { x: 0.1, y: -0.1, technique: crate::resources::TechniqueType::Cut },
+            crate::resources::MeyerNode { x: -0.1, y: -0.1, technique: crate::resources::TechniqueType::Cut },
+            crate::resources::MeyerNode { x: 0.1, y: 0.1, technique: crate::resources::TechniqueType::Cut },
+        ],
+    },
+];
+
 // --- Kinetic Brutalism Color Palette ---
 
 /// Background: The primary void.
diff --git a/src/logic.rs b/src/logic.rs
index 6bc519f..fc9fe94 100644
--- a/src/logic.rs
+++ b/src/logic.rs
@@ -20,6 +20,7 @@ impl Plugin for TrainingPlugin {
     fn build(&self, app: &mut App) {
         app.add_systems(Update, (
             update_sequence_logic,
+            update_meyer_sequence_logic,
             handle_session_controls,
             sync_rhythm_timer,
             sync_arrow_target,
@@ -56,8 +57,9 @@ fn update_sequence_logic(
     mut current_number: ResMut<CurrentNumber>,
     mut sequence_state: ResMut<SequenceState>,
     mut rhythm_state: ResMut<RhythmState>,
+    active_workflow: Res<ActiveWorkflow>,
 ) {
-    if !sequence_state.running {
+    if !sequence_state.running || active_workflow.0 != TrainingWorkflow::Circular {
         return;
     }
 
@@ -109,6 +111,48 @@ fn update_sequence_logic(
     }
 }
 
+/// System to update the Meyer's Square training sequence logic.
+///
+/// Cycles through the 16 nodes in their defined sequences.
+fn update_meyer_sequence_logic(
+    time: Res<Time>,
+    sequence_state: Res<SequenceState>,
+    active_workflow: Res<ActiveWorkflow>,
+    mut meyer_state: ResMut<MeyerTrainingResource>,
+    rhythm_state: Res<RhythmState>,
+) {
+    if !sequence_state.running || active_workflow.0 != TrainingWorkflow::MeyerSquare {
+        return;
+    }
+
+    // Use rhythm_state.duration for the transition speed.
+    // The transition_timer goes from 0.0 to 1.0 over the duration.
+    // time.delta() can be 0 or small in minimal tests without explicit time stepping.
+    // Instead we use `delta_secs()` or `delta().as_secs_f32()` which gets updated by `time.advance_by`.
+    let delta = time.delta_secs();
+
+    // Safety check against zero duration to avoid division by zero or infinite loop
+    let dur = rhythm_state.duration.max(0.1);
+
+    meyer_state.transition_timer += delta / dur;
+
+    // Loop until we consume the timer, since a large delta might skip nodes.
+    // In normal execution delta is small, but tests could jump large amounts.
+    while meyer_state.transition_timer >= 1.0 {
+        // Adjust timer for remaining overflow before advancing so while condition re-checks properly
+        meyer_state.transition_timer -= 1.0;
+
+        // Advance node
+        meyer_state.current_node += 1;
+
+        // If we hit the end of a 4-strike sequence, advance to next sequence
+        if meyer_state.current_node >= 4 {
+            meyer_state.current_node = 0;
+            meyer_state.current_sequence = (meyer_state.current_sequence + 1) % 4;
+        }
+    }
+}
+
 /// Keeps UI elements synchronized with the internal [`RhythmState`].
 ///
 /// Updates the numeric display and the slider widget whenever the rhythm
diff --git a/src/logic_test.rs b/src/logic_test.rs
index c5cc380..c2a0ea5 100644
--- a/src/logic_test.rs
+++ b/src/logic_test.rs
@@ -19,6 +19,8 @@ mod tests {
            .insert_resource(HighlightTimer(Timer::from_seconds(1.0, TimerMode::Repeating)))
            .insert_resource(CurrentNumber(0))
            .insert_resource(SequenceState { running: true, ..default() })
+           .insert_resource(ActiveWorkflow::default())
+           .insert_resource(MeyerTrainingResource::default())
            .insert_resource(RhythmState { duration: 1.0, mode: RhythmMode::Constant, accelerate_counter: 0 })
            .insert_resource(ArrowTarget::default())
            .insert_resource(ArrowAnimationState::default());
@@ -280,4 +282,53 @@ mod tests {
             assert!(animation_state.progress > 0.0);
         }
     }
+
+    /// Verifies that the Meyer sequence logic correctly advances nodes and sequences.
+    #[test]
+    fn test_meyer_sequence_advances_nodes_and_sequences() {
+        let mut app = setup_app();
+
+        // Setup Meyer's Square workflow and unpause
+        {
+            let mut active_workflow = app.world_mut().get_resource_mut::<ActiveWorkflow>().unwrap();
+            active_workflow.0 = TrainingWorkflow::MeyerSquare;
+            let mut seq_state = app.world_mut().get_resource_mut::<SequenceState>().unwrap();
+            seq_state.running = true;
+        }
+
+        app.update(); // Initialize
+
+        // Setup initial delta
+        {
+            // Instead of dealing with Bevy's time complexities in tests,
+            // directly manipulate the internal transition timer.
+            let mut meyer_state = app.world_mut().get_resource_mut::<MeyerTrainingResource>().unwrap();
+            meyer_state.transition_timer = 1.0;
+        }
+
+        app.update();
+
+        // Node should have advanced from 0 to 1
+        {
+            let meyer_state = app.world().get_resource::<MeyerTrainingResource>().unwrap();
+            assert_eq!(meyer_state.current_node, 1);
+            assert_eq!(meyer_state.current_sequence, 0);
+        }
+
+        // Advance time by 3 more full durations to complete the sequence
+        for _ in 0..3 {
+            {
+                let mut meyer_state = app.world_mut().get_resource_mut::<MeyerTrainingResource>().unwrap();
+                meyer_state.transition_timer = 1.0;
+            }
+            app.update();
+        }
+
+        // Should now be on node 0 of sequence 1
+        {
+            let meyer_state = app.world().get_resource::<MeyerTrainingResource>().unwrap();
+            assert_eq!(meyer_state.current_node, 0);
+            assert_eq!(meyer_state.current_sequence, 1);
+        }
+    }
 }
diff --git a/src/main.rs b/src/main.rs
index ca2c496..6fb9e2e 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -52,6 +52,8 @@ fn initialize_app(app: &mut App) {
             mode: SequenceMode::Random,
             current_ordered_value: 0,
         })
+        .insert_resource(ActiveWorkflow::default())
+        .insert_resource(MeyerTrainingResource::default())
         .insert_resource(RhythmState {
             duration: 1.0,
             mode: RhythmMode::Constant,
diff --git a/src/resources.rs b/src/resources.rs
index 7b68e29..06f9db6 100644
--- a/src/resources.rs
+++ b/src/resources.rs
@@ -20,6 +20,60 @@ pub struct HighlightTimer(pub Timer);
 #[derive(Resource)]
 pub struct CurrentNumber(pub u8);
 
+/// Technique required for a strike in Meyer's Square.
+#[derive(Debug, Default, PartialEq, Clone, Copy)]
+pub enum TechniqueType {
+    /// A flowing cut or slash.
+    #[default]
+    Cut,
+    /// A direct thrust.
+    Thrust,
+    /// A defensive parry or shield.
+    Parry,
+}
+
+/// Represents a single target node in the Meyer's Square grid.
+#[derive(Debug, Clone, Copy)]
+pub struct MeyerNode {
+    /// Normalized X coordinate (-1.0 to 1.0).
+    pub x: f32,
+    /// Normalized Y coordinate (-1.0 to 1.0).
+    pub y: f32,
+    /// The technique to execute at this node.
+    pub technique: TechniqueType,
+}
+
+/// Represents a 4-strike sequence in the Meyer's Square.
+#[derive(Debug, Clone)]
+pub struct MeyerSequence {
+    pub nodes: [MeyerNode; 4],
+}
+
+/// Resource to manage the state of the Meyer's Square training flow.
+#[derive(Resource, Default, Debug)]
+pub struct MeyerTrainingResource {
+    /// The index of the current sequence (0 to 3).
+    pub current_sequence: usize,
+    /// The index of the current node within the sequence (0 to 3).
+    pub current_node: usize,
+    /// Progress of the transition to the next node (0.0 to 1.0).
+    pub transition_timer: f32,
+}
+
+/// Workflow mode for the training session.
+#[derive(Debug, Default, PartialEq, Clone, Copy)]
+pub enum TrainingWorkflow {
+    /// The original circular target training.
+    #[default]
+    Circular,
+    /// The Meyer's Square grid training.
+    MeyerSquare,
+}
+
+/// Stores the current active workflow mode.
+#[derive(Resource, Default, Debug)]
+pub struct ActiveWorkflow(pub TrainingWorkflow);
+
 /// Strategy for generating the sequence of target numbers.
 #[derive(Debug, Default, PartialEq, Clone, Copy)]
 pub enum SequenceMode {
diff --git a/src/ui/mod.rs b/src/ui/mod.rs
index f77092d..e5bd9bd 100644
--- a/src/ui/mod.rs
+++ b/src/ui/mod.rs
@@ -44,11 +44,13 @@ impl Plugin for UiPlugin {
                     curriculum_page_button_system,
                     sync_curriculum_ui_labels,
                     mode_toggle_system,
+                    workflow_toggle_system,
                     rhythm_mode_toggle_system,
                     style_slider_system,
                     update_rhythm_from_slider,
                     update_circle_layout,
                     render_glowing_arrow,
+                    render_meyer_square,
                     sync_target_visuals,
                     toggle_curriculum_visibility,
                     curriculum_keyboard_navigation,
diff --git a/src/ui/settings.rs b/src/ui/settings.rs
index 3c211ff..0149ae8 100644
--- a/src/ui/settings.rs
+++ b/src/ui/settings.rs
@@ -46,6 +46,7 @@ pub fn spawn_settings_panel(parent: &mut ChildSpawnerCommands, typography: &Typo
                 },
             ));
 
+            spawn_workflow_toggle_button(parent, typography);
             spawn_mode_toggle_button(parent, typography);
             spawn_sequence_control_button(parent, typography);
             spawn_rhythm_section(parent, typography);
@@ -53,6 +54,37 @@ pub fn spawn_settings_panel(parent: &mut ChildSpawnerCommands, typography: &Typo
         });
 }
 
+/// Spawns the button for toggling the training workflow (Circular vs Meyer's Square).
+fn spawn_workflow_toggle_button(parent: &mut ChildSpawnerCommands, typography: &Typography) {
+    parent
+        .spawn((
+            Button,
+            Node {
+                width: Val::Percent(100.0),
+                height: Val::Px(65.0),
+                border: UiRect::all(Val::Px(1.0)),
+                justify_content: JustifyContent::Center,
+                align_items: AlignItems::Center,
+                margin: UiRect::bottom(Val::Px(15.0)),
+                ..default()
+            },
+            BorderColor::all(GHOST_BORDER),
+            BackgroundColor(Color::NONE),
+            WorkflowModeButton,
+        ))
+        .with_children(|parent| {
+            parent.spawn((
+                Text::new("Workflow: Circular"),
+                TextFont {
+                    font: typography.work_sans.clone(),
+                    font_size: 20.0,
+                    ..default()
+                },
+                TextColor(NEUTRAL_TEXT),
+            ));
+        });
+}
+
 /// Spawns the curriculum integration controls, including the visibility toggle
 /// and selectors for grades/documents.
 fn spawn_curriculum_section(parent: &mut ChildSpawnerCommands, typography: &Typography) {
diff --git a/src/ui/setup_test.rs b/src/ui/setup_test.rs
index b85362a..a45bf27 100644
--- a/src/ui/setup_test.rs
+++ b/src/ui/setup_test.rs
@@ -35,13 +35,21 @@ mod tests {
         assert!(!seq_state.running, "Sequence should be paused when curriculum is opened.");
     }
 
-    /// Verifies that the camera is spawned with the Hdr and Bloom components.
-    #[test]
-    fn test_camera_has_hdr_and_bloom() {
+    fn setup_test_app() -> App {
         let mut app = App::new();
+        // Use TaskPoolPlugin to avoid "IoTaskPool has not been initialized yet"
+        app.add_plugins(TaskPoolPlugin::default());
+        app.add_plugins(AssetPlugin::default());
+        app.add_plugins(bevy::text::TextPlugin::default());
         app.insert_resource(Typography::default());
-        app.add_plugins((AssetPlugin::default(), bevy::text::TextPlugin::default()));
         app.add_systems(Startup, setup);
+        app
+    }
+
+    /// Verifies that the camera is spawned with the Hdr and Bloom components.
+    #[test]
+    fn test_camera_has_hdr_and_bloom() {
+        let mut app = setup_test_app();
         app.update();
 
         // Check for camera with Hdr and Bloom
@@ -52,10 +60,7 @@ mod tests {
     /// Verifies that the target numbers are spawned with the correct Z-coordinate and ZIndex.
     #[test]
     fn test_target_numbers_layering() {
-        let mut app = App::new();
-        app.insert_resource(Typography::default());
-        app.add_plugins((AssetPlugin::default(), bevy::text::TextPlugin::default()));
-        app.add_systems(Startup, setup);
+        let mut app = setup_test_app();
         app.update();
 
         use crate::components::NumberIndex;
diff --git a/src/ui/systems.rs b/src/ui/systems.rs
index 88e2ffb..2028df4 100644
--- a/src/ui/systems.rs
+++ b/src/ui/systems.rs
@@ -9,7 +9,7 @@ use bevy_ui_widgets::{Slider, SliderRange, SliderThumb, SliderValue};
 use std::f32::consts::PI;
 
 use crate::components::*;
-use crate::constants::{PRIMARY_EMISSIVE, NEUTRAL_TEXT, PANEL_WIDTH};
+use crate::constants::{PRIMARY_EMISSIVE, NEUTRAL_TEXT, PANEL_WIDTH, GHOST_BORDER, MEYER_SEQUENCES};
 use crate::resources::*;
 
 /// Handles interactions with the sequence control button (Play/Pause).
@@ -88,6 +88,113 @@ pub fn curriculum_toggle_system(
     }
 }
 
+/// Renders the Meyer's Square grid and the "Ghost of Meyer" visual cues.
+pub fn render_meyer_square(
+    window: Single<&bevy::window::Window, With<bevy::window::PrimaryWindow>>,
+    active_workflow: Res<ActiveWorkflow>,
+    meyer_state: Res<MeyerTrainingResource>,
+    sequence_state: Res<SequenceState>,
+    mut gizmos: Gizmos,
+) {
+    if active_workflow.0 != TrainingWorkflow::MeyerSquare {
+        return;
+    }
+
+    let available_width = window.resolution.width() - PANEL_WIDTH;
+    let available_height = window.resolution.height();
+    // Leave some padding around the square.
+    let half_size = available_width.min(available_height) / 2.0 * 0.8;
+    let offset_x = -PANEL_WIDTH / 2.0;
+    let center = Vec2::new(offset_x, 0.0);
+
+    // Render Geometric Grid
+    // Bounding Square
+    gizmos.rect_2d(
+        center,
+        Vec2::splat(half_size * 2.0),
+        GHOST_BORDER,
+    );
+
+    // Thick central cross
+    gizmos.line_2d(
+        center + Vec2::new(-half_size, 0.0),
+        center + Vec2::new(half_size, 0.0),
+        GHOST_BORDER,
+    );
+    gizmos.line_2d(
+        center + Vec2::new(0.0, -half_size),
+        center + Vec2::new(0.0, half_size),
+        GHOST_BORDER,
+    );
+
+    // Draw all 16 nodes as markers
+    for sequence in MEYER_SEQUENCES.iter() {
+        for node in &sequence.nodes {
+            let pos = center + Vec2::new(node.x, node.y) * half_size;
+            gizmos.circle_2d(pos, 5.0, GHOST_BORDER);
+        }
+    }
+
+    // Ghost of Meyer visual signatures
+    if sequence_state.running {
+        let current_sequence = &MEYER_SEQUENCES[meyer_state.current_sequence];
+        let current_node = &current_sequence.nodes[meyer_state.current_node];
+
+        // Calculate end node
+        let next_node_idx = (meyer_state.current_node + 1) % 4;
+        // If transitioning sequence, it's more complex, but for MVP keep it within sequence
+        let end_node = &current_sequence.nodes[next_node_idx];
+
+        // For cuts and thrusts, the visual element should span the full extent
+        // of the outermost square, regardless of which concentric square the node is on.
+        // We can find the outer positions using signum() (since the outer square has nodes at x,y = +/- 1.0)
+        let outer_start_pos = center + Vec2::new(current_node.x.signum(), current_node.y.signum()) * half_size;
+        let outer_end_pos = center + Vec2::new(end_node.x.signum(), end_node.y.signum()) * half_size;
+
+        // Interpolate position based on transition timer using the outer bounding box
+        let current_pos = outer_start_pos.lerp(outer_end_pos, meyer_state.transition_timer);
+
+        match current_node.technique {
+            TechniqueType::Cut => {
+                // Slash (Cut): Decaying trail. Line from outer start to current interpolated pos.
+                gizmos.line_2d(outer_start_pos, current_pos, PRIMARY_EMISSIVE);
+                // Make it thicker
+                let offset = (outer_end_pos - outer_start_pos).normalize_or_zero().perp() * 2.0;
+                gizmos.line_2d(outer_start_pos + offset, current_pos + offset, PRIMARY_EMISSIVE);
+                gizmos.line_2d(outer_start_pos - offset, current_pos - offset, PRIMARY_EMISSIVE);
+            }
+            TechniqueType::Thrust => {
+                // Beam (Thrust): Telescoping line from center to the outer position.
+                // Note: Thrust usually goes from center outwards.
+                let thrust_current_pos = center.lerp(outer_start_pos, meyer_state.transition_timer);
+                gizmos.line_2d(center, thrust_current_pos, PRIMARY_EMISSIVE);
+                let offset = (thrust_current_pos - center).normalize_or_zero().perp() * 1.5;
+                gizmos.line_2d(center + offset, thrust_current_pos + offset, PRIMARY_EMISSIVE);
+                gizmos.line_2d(center - offset, thrust_current_pos - offset, PRIMARY_EMISSIVE);
+            }
+            TechniqueType::Parry => {
+                // Shield (Parry): Strobing block spanning the full quadrant.
+                // We find the center of the quadrant using half_size / 2.0.
+                let quadrant_center = center + Vec2::new(current_node.x.signum(), current_node.y.signum()) * (half_size / 2.0);
+                let strobe = (meyer_state.transition_timer * 20.0).sin() > 0.0;
+                if strobe {
+                    gizmos.rect_2d(
+                        quadrant_center,
+                        Vec2::splat(half_size),
+                        PRIMARY_EMISSIVE,
+                    );
+                } else {
+                    gizmos.rect_2d(
+                        quadrant_center,
+                        Vec2::splat(half_size),
+                        GHOST_BORDER,
+                    );
+                }
+            }
+        }
+    }
+}
+
 /// Handles interactions with the sequence mode toggle button.
 ///
 /// Switches the [`SequenceMode`] between Random and Ordered. It also resets
@@ -131,6 +238,50 @@ pub fn mode_toggle_system(
     }
 }
 
+/// Handles interactions with the workflow toggle button.
+///
+/// Switches the [`TrainingWorkflow`] between Circular and MeyerSquare.
+#[allow(clippy::type_complexity)]
+pub fn workflow_toggle_system(
+    mut interaction_query: Query<
+        (&Interaction, &mut BackgroundColor, &Children),
+        (Changed<Interaction>, With<WorkflowModeButton>),
+    >,
+    mut text_query: Query<&mut Text>,
+    mut workflow_state: ResMut<ActiveWorkflow>,
+    mut sequence_state: ResMut<SequenceState>,
+) {
+    for (interaction, mut background_color, children) in &mut interaction_query {
+        let mut text = text_query.get_mut(children[0]).unwrap();
+        match *interaction {
+            Interaction::Pressed => {
+                workflow_state.0 = match workflow_state.0 {
+                    TrainingWorkflow::Circular => TrainingWorkflow::MeyerSquare,
+                    TrainingWorkflow::MeyerSquare => TrainingWorkflow::Circular,
+                };
+
+                // Pause training when switching workflows.
+                sequence_state.running = false;
+
+                match workflow_state.0 {
+                    TrainingWorkflow::Circular => {
+                        text.0 = "Workflow: Circular".to_string();
+                    }
+                    TrainingWorkflow::MeyerSquare => {
+                        text.0 = "Workflow: Meyer's Square".to_string();
+                    }
+                }
+            }
+            Interaction::Hovered => {
+                background_color.0 = Color::srgba(0.886, 0.886, 0.886, 0.1);
+            }
+            Interaction::None => {
+                background_color.0 = Color::NONE;
+            }
+        }
+    }
+}
+
 /// Handles interactions with the rhythm mode toggle button.
 ///
 /// Switches the [`RhythmMode`] between Constant and Accelerate. When switching,
@@ -291,10 +442,11 @@ pub fn render_glowing_arrow(
     arrow_target: Res<ArrowTarget>,
     animation_state: Res<ArrowAnimationState>,
     sequence_state: Res<SequenceState>,
+    active_workflow: Res<ActiveWorkflow>,
     mut gizmos: Gizmos,
 ) {
-    // Don't show the arrow if the sequence is stopped.
-    if !sequence_state.running {
+    // Don't show the arrow if the sequence is stopped or if we are not in Circular mode.
+    if !sequence_state.running || active_workflow.0 != TrainingWorkflow::Circular {
         return;
     }
 
@@ -349,9 +501,13 @@ pub fn render_glowing_arrow(
 pub fn sync_target_visuals(
     current_number: Res<CurrentNumber>,
     sequence_state: Res<SequenceState>,
-    mut query: Query<(&NumberIndex, &mut TextColor)>,
+    active_workflow: Res<ActiveWorkflow>,
+    mut query: Query<(&NumberIndex, &mut TextColor, &mut Visibility)>,
 ) {
-    for (index, mut color) in &mut query {
+    let show_circular = active_workflow.0 == TrainingWorkflow::Circular;
+    for (index, mut color, mut visibility) in &mut query {
+        *visibility = if show_circular { Visibility::Inherited } else { Visibility::Hidden };
+
         if sequence_state.running && index.0 == current_number.0 {
             color.0 = PRIMARY_EMISSIVE;
         } else {