diff --git a/.changeset/fixable-gritql-plugins.md b/.changeset/fixable-gritql-plugins.md
new file mode 100644
index 000000000000..129d6c8a033e
--- /dev/null
+++ b/.changeset/fixable-gritql-plugins.md
@@ -0,0 +1,17 @@
+---
+"@biomejs/biome": minor
+---
+
+Added support for applying GritQL plugin rewrites as code actions. GritQL plugins that use the rewrite operator (`=>`) now produce fixable diagnostics for JavaScript, CSS, and JSON files. By default, plugin rewrites are treated as unsafe fixes and require `--write --unsafe` to apply. Plugin authors can pass `fix_kind = "safe"` to `register_diagnostic()` to mark a fix as safe, allowing it to be applied with just `--write`.
+
+**Example plugin** (`useConsoleInfo.grit`):
+```grit
+language js
+
+`console.log($msg)` as $call where {
+    register_diagnostic(span = $call, message = "Use console.info instead of console.log.", severity = "warn", fix_kind = "safe"),
+    $call => `console.info($msg)`
+}
+```
+
+Running `biome check --write` applies safe rewrites. Unsafe rewrites (the default, or `fix_kind = "unsafe"`) still require `--write --unsafe`.
diff --git a/Cargo.lock b/Cargo.lock
index 6e7d1a42f553..850ae373099e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -127,6 +127,7 @@ dependencies = [
  "biome_parser",
  "biome_rowan",
  "biome_suppression",
+ "biome_text_edit",
  "camino",
  "enumflags2",
  "indexmap",
diff --git a/crates/biome_analyze/Cargo.toml b/crates/biome_analyze/Cargo.toml
index bf09f589f532..82ab054d9089 100644
--- a/crates/biome_analyze/Cargo.toml
+++ b/crates/biome_analyze/Cargo.toml
@@ -21,6 +21,7 @@ biome_diagnostics        = { workspace = true }
 biome_parser             = { workspace = true }
 biome_rowan              = { workspace = true }
 biome_suppression        = { workspace = true }
+biome_text_edit          = { workspace = true }
 camino                   = { workspace = true }
 enumflags2               = { workspace = true }
 indexmap                 = { workspace = true }
diff --git a/crates/biome_analyze/src/analyzer_plugin.rs b/crates/biome_analyze/src/analyzer_plugin.rs
index 7028267172a6..33ef1852672c 100644
--- a/crates/biome_analyze/src/analyzer_plugin.rs
+++ b/crates/biome_analyze/src/analyzer_plugin.rs
@@ -1,10 +1,12 @@
+use biome_diagnostics::Applicability;
+use biome_rowan::{
+    AnySyntaxNode, Language, RawSyntaxKind, SyntaxKind, SyntaxNode, TextRange, WalkEvent,
+};
 use camino::Utf8PathBuf;
 use rustc_hash::FxHashSet;
 use std::hash::Hash;
 use std::{fmt::Debug, sync::Arc};
 
-use biome_rowan::{AnySyntaxNode, Language, RawSyntaxKind, SyntaxKind, SyntaxNode, WalkEvent};
-
 use crate::matcher::SignalRuleKey;
 use crate::{
     PluginSignal, RuleCategory, RuleDiagnostic, SignalEntry, Visitor, VisitorContext, profiling,
@@ -16,13 +18,41 @@ pub type AnalyzerPluginSlice<'a> = &'a [Arc<Box<dyn AnalyzerPlugin>>];
 /// Vector of analyzer plugins that can be cheaply cloned.
 pub type AnalyzerPluginVec = Vec<Arc<Box<dyn AnalyzerPlugin>>>;
 
+/// Data for a code action produced by a plugin.
+#[derive(Debug, Clone)]
+pub struct PluginActionData {
+    /// The source range this action applies to.
+    pub source_range: TextRange,
+    /// The original source text that was matched.
+    pub original_text: String,
+    /// The rewritten text to replace the original.
+    pub rewritten_text: String,
+    /// A message describing the action.
+    pub message: String,
+    /// Whether this fix is safe or unsafe.
+    pub applicability: Applicability,
+}
+
+/// A diagnostic paired with its optional code action.
+#[derive(Debug)]
+pub struct PluginDiagnosticEntry {
+    pub diagnostic: RuleDiagnostic,
+    pub action: Option<PluginActionData>,
+}
+
+/// Result of evaluating a plugin, containing diagnostics paired with their actions.
+#[derive(Debug, Default)]
+pub struct PluginEvalResult {
+    pub entries: Vec<PluginDiagnosticEntry>,
+}
+
 /// Definition of an analyzer plugin.
 pub trait AnalyzerPlugin: Debug + Send + Sync {
     fn language(&self) -> PluginTargetLanguage;
 
     fn query(&self) -> Vec<RawSyntaxKind>;
 
-    fn evaluate(&self, node: AnySyntaxNode, path: Arc<Utf8PathBuf>) -> Vec<RuleDiagnostic>;
+    fn evaluate(&self, node: AnySyntaxNode, path: Arc<Utf8PathBuf>) -> PluginEvalResult;
 }
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
@@ -103,20 +133,26 @@ where
         }
 
         let rule_timer = profiling::start_plugin_rule("plugin");
-        let diagnostics = self
+        let eval_result = self
             .plugin
             .evaluate(node.clone().into(), ctx.options.file_path.clone());
         rule_timer.stop();
 
-        let signals = diagnostics.into_iter().map(|diagnostic| {
-            let name = diagnostic
+        let signals = eval_result.entries.into_iter().map(|entry| {
+            let name = entry
+                .diagnostic
                 .subcategory
                 .clone()
                 .unwrap_or_else(|| "anonymous".into());
+            let text_range = entry.diagnostic.span().unwrap_or_default();
+
+            let signal = PluginSignal::<L>::new(entry.diagnostic)
+                .with_plugin_action(entry.action)
+                .with_root(node.clone());
 
             SignalEntry {
-                text_range: diagnostic.span().unwrap_or_default(),
-                signal: Box::new(PluginSignal::<L>::new(diagnostic)),
+                text_range,
+                signal: Box::new(signal),
                 rule: SignalRuleKey::Plugin(name.into()),
                 category: RuleCategory::Lint,
                 instances: Default::default(),
diff --git a/crates/biome_analyze/src/lib.rs b/crates/biome_analyze/src/lib.rs
index 5d08efefd195..8c0f9ceedfb7 100644
--- a/crates/biome_analyze/src/lib.rs
+++ b/crates/biome_analyze/src/lib.rs
@@ -30,7 +30,8 @@ mod visitor;
 pub use biome_diagnostics::category_concat;
 
 pub use crate::analyzer_plugin::{
-    AnalyzerPlugin, AnalyzerPluginSlice, AnalyzerPluginVec, PluginTargetLanguage, PluginVisitor,
+    AnalyzerPlugin, AnalyzerPluginSlice, AnalyzerPluginVec, PluginActionData,
+    PluginDiagnosticEntry, PluginEvalResult, PluginTargetLanguage, PluginVisitor,
 };
 pub use crate::categories::{
     ActionCategory, OtherActionCategory, RefactorKind, RuleCategories, RuleCategoriesBuilder,
diff --git a/crates/biome_analyze/src/signals.rs b/crates/biome_analyze/src/signals.rs
index 4ebd62ea216c..165d4b6c455b 100644
--- a/crates/biome_analyze/src/signals.rs
+++ b/crates/biome_analyze/src/signals.rs
@@ -2,8 +2,8 @@ use crate::categories::{
     SUPPRESSION_INLINE_ACTION_CATEGORY, SUPPRESSION_TOP_LEVEL_ACTION_CATEGORY,
 };
 use crate::{
-    AnalyzerDiagnostic, AnalyzerOptions, OtherActionCategory, Queryable, RuleDiagnostic, RuleGroup,
-    ServiceBag, SuppressionAction,
+    AnalyzerDiagnostic, AnalyzerOptions, OtherActionCategory, PluginActionData, Queryable,
+    RuleDiagnostic, RuleGroup, ServiceBag, SuppressionAction,
     categories::ActionCategory,
     context::RuleContext,
     registry::{RuleLanguage, RuleRoot},
@@ -11,7 +11,9 @@ use crate::{
 };
 use biome_console::{MarkupBuf, markup};
 use biome_diagnostics::{Applicability, CodeSuggestion, Error, advice::CodeSuggestionAdvice};
-use biome_rowan::{BatchMutation, Language};
+use biome_rowan::{BatchMutation, Language, SyntaxNode, TextRange};
+use biome_text_edit::TextEdit;
+use std::borrow::Cow;
 use std::iter::FusedIterator;
 use std::marker::PhantomData;
 use std::vec::IntoIter;
@@ -109,18 +111,30 @@ where
 /// Unlike [DiagnosticSignal] which converts through [Error] into
 /// [DiagnosticKind::Raw](crate::diagnostics::DiagnosticKind::Raw), this type
 /// directly converts via `AnalyzerDiagnostic::from(RuleDiagnostic)`.
-pub struct PluginSignal<L> {
+pub struct PluginSignal<L: Language> {
     diagnostic: RuleDiagnostic,
-    _phantom: PhantomData<L>,
+    plugin_action: Option<PluginActionData>,
+    root: Option<SyntaxNode<L>>,
 }
 
 impl<L: Language> PluginSignal<L> {
     pub fn new(diagnostic: RuleDiagnostic) -> Self {
         Self {
             diagnostic,
-            _phantom: PhantomData,
+            plugin_action: None,
+            root: None,
         }
     }
+
+    pub fn with_plugin_action(mut self, action: Option<PluginActionData>) -> Self {
+        self.plugin_action = action;
+        self
+    }
+
+    pub fn with_root(mut self, root: SyntaxNode<L>) -> Self {
+        self.root = Some(root);
+        self
+    }
 }
 
 impl<L: Language> AnalyzerSignal<L> for PluginSignal<L> {
@@ -129,7 +143,25 @@ impl<L: Language> AnalyzerSignal<L> for PluginSignal<L> {
     }
 
     fn actions(&self) -> AnalyzerActionIter<L> {
-        AnalyzerActionIter::new(vec![])
+        let Some(action_data) = &self.plugin_action else {
+            return AnalyzerActionIter::new(vec![]);
+        };
+
+        let Some(root) = &self.root else {
+            return AnalyzerActionIter::new(vec![]);
+        };
+
+        let text_edit =
+            TextEdit::from_unicode_words(&action_data.original_text, &action_data.rewritten_text);
+
+        AnalyzerActionIter::new(vec![AnalyzerAction {
+            rule_name: None,
+            category: ActionCategory::QuickFix(Cow::Borrowed("plugin")),
+            applicability: action_data.applicability,
+            message: markup!({ action_data.message }).to_owned(),
+            mutation: BatchMutation::new(root.clone()),
+            text_edit: Some((action_data.source_range, text_edit)),
+        }])
     }
 
     fn transformations(&self) -> AnalyzerTransformationIter<L> {
@@ -149,6 +181,8 @@ pub struct AnalyzerAction<L: Language> {
     pub applicability: Applicability,
     pub message: MarkupBuf,
     pub mutation: BatchMutation<L>,
+    /// Pre-computed text edit for plugin rewrites. Takes precedence over mutation.
+    pub text_edit: Option<(TextRange, TextEdit)>,
 }
 
 impl<L: Language> AnalyzerAction<L> {
@@ -179,7 +213,10 @@ impl<L: Language> Default for AnalyzerActionIter<L> {
 
 impl<L: Language> From<AnalyzerAction<L>> for CodeSuggestionAdvice<MarkupBuf> {
     fn from(action: AnalyzerAction<L>) -> Self {
-        let (_, suggestion) = action.mutation.to_text_range_and_edit().unwrap_or_default();
+        let (_, suggestion) = action
+            .text_edit
+            .or_else(|| action.mutation.to_text_range_and_edit())
+            .unwrap_or_default();
         Self {
             applicability: action.applicability,
             msg: action.message,
@@ -190,7 +227,10 @@ impl<L: Language> From<AnalyzerAction<L>> for CodeSuggestionAdvice<MarkupBuf> {
 
 impl<L: Language> From<AnalyzerAction<L>> for CodeSuggestionItem {
     fn from(action: AnalyzerAction<L>) -> Self {
-        let (range, suggestion) = action.mutation.to_text_range_and_edit().unwrap_or_default();
+        let (range, suggestion) = action
+            .text_edit
+            .or_else(|| action.mutation.to_text_range_and_edit())
+            .unwrap_or_default();
 
         Self {
             rule_name: action.rule_name,
@@ -469,6 +509,7 @@ where
                     category: action.category,
                     mutation: action.mutation,
                     message: action.message,
+                    text_edit: None,
                 });
             };
             if let Some(text_range) = R::text_range(&ctx, &self.state)
@@ -485,6 +526,7 @@ where
                     applicability: Applicability::Always,
                     mutation: suppression_action.mutation,
                     message: suppression_action.message,
+                    text_edit: None,
                 };
                 actions.push(action);
             }
@@ -498,6 +540,7 @@ where
                     applicability: Applicability::Always,
                     mutation: suppression_action.mutation,
                     message: suppression_action.message,
+                    text_edit: None,
                 };
                 actions.push(action);
             }
diff --git a/crates/biome_cli/tests/commands/check.rs b/crates/biome_cli/tests/commands/check.rs
index aa40310e6d9a..9747054c937c 100644
--- a/crates/biome_cli/tests/commands/check.rs
+++ b/crates/biome_cli/tests/commands/check.rs
@@ -3423,6 +3423,194 @@ const foo = 'bad'
     ));
 }
 
+#[test]
+fn check_plugin_apply_rewrite() {
+    let fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    fs.insert(
+        Utf8PathBuf::from("biome.json"),
+        br#"{
+    "plugins": ["useConsoleInfo.grit"],
+    "formatter": { "enabled": false }
+}
+"#,
+    );
+
+    fs.insert(
+        Utf8PathBuf::from("useConsoleInfo.grit"),
+        br#"language js
+
+`console.log($msg)` as $call where {
+    register_diagnostic(span = $call, message = "Use console.info instead of console.log.", severity = "warn"),
+    $call => `console.info($msg)`
+}
+"#,
+    );
+
+    let file_path = Utf8Path::new("input.js");
+    fs.insert(file_path.into(), b"console.log(\"hello\");\n");
+
+    let (fs, result) = run_cli_with_server_workspace(
+        fs,
+        &mut console,
+        Args::from(["check", "--write", "--unsafe", file_path.as_str()].as_slice()),
+    );
+
+    assert!(result.is_ok(), "run_cli returned {result:?}");
+    assert_file_contents(&fs, file_path, "console.info(\"hello\");\n");
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "check_plugin_apply_rewrite",
+        fs,
+        console,
+        result,
+    ));
+}
+
+#[test]
+fn check_plugin_rewrite_no_write() {
+    let fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    fs.insert(
+        Utf8PathBuf::from("biome.json"),
+        br#"{
+    "plugins": ["useConsoleInfo.grit"],
+    "formatter": { "enabled": false }
+}
+"#,
+    );
+
+    fs.insert(
+        Utf8PathBuf::from("useConsoleInfo.grit"),
+        br#"language js
+
+`console.log($msg)` as $call where {
+    register_diagnostic(span = $call, message = "Use console.info instead of console.log.", severity = "warn"),
+    $call => `console.info($msg)`
+}
+"#,
+    );
+
+    let file_path = Utf8Path::new("input.js");
+    fs.insert(file_path.into(), b"console.log(\"hello\");\n");
+
+    let (fs, result) = run_cli_with_server_workspace(
+        fs,
+        &mut console,
+        Args::from(["check", file_path.as_str()].as_slice()),
+    );
+
+    assert!(result.is_ok(), "run_cli returned {result:?}");
+    assert_file_contents(&fs, file_path, "console.log(\"hello\");\n");
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "check_plugin_rewrite_no_write",
+        fs,
+        console,
+        result,
+    ));
+}
+
+#[test]
+fn check_plugin_rewrite_write_without_unsafe() {
+    let fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    fs.insert(
+        Utf8PathBuf::from("biome.json"),
+        br#"{
+    "plugins": ["useConsoleInfo.grit"],
+    "formatter": { "enabled": false }
+}
+"#,
+    );
+
+    fs.insert(
+        Utf8PathBuf::from("useConsoleInfo.grit"),
+        br#"language js
+
+`console.log($msg)` as $call where {
+    register_diagnostic(span = $call, message = "Use console.info instead of console.log.", severity = "warn"),
+    $call => `console.info($msg)`
+}
+"#,
+    );
+
+    let file_path = Utf8Path::new("file.js");
+    fs.insert(file_path.into(), b"console.log(\"hello\");\n");
+
+    let (fs, result) = run_cli_with_server_workspace(
+        fs,
+        &mut console,
+        Args::from(["check", "--write", file_path.as_str()].as_slice()),
+    );
+
+    // --write without --unsafe should NOT apply unsafe fixes
+    assert!(result.is_ok(), "run_cli returned {result:?}");
+    assert_file_contents(&fs, file_path, "console.log(\"hello\");\n");
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "check_plugin_rewrite_write_without_unsafe",
+        fs,
+        console,
+        result,
+    ));
+}
+
+#[test]
+fn check_plugin_multiple_rewrites() {
+    let fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    fs.insert(
+        Utf8PathBuf::from("biome.json"),
+        br#"{
+    "plugins": ["useLoggerInfo.grit"],
+    "formatter": { "enabled": false }
+}
+"#,
+    );
+
+    fs.insert(
+        Utf8PathBuf::from("useLoggerInfo.grit"),
+        br#"language js
+
+`console.log($msg)` as $call where {
+    register_diagnostic(span = $call, message = "Use logger.info instead of console.log.", severity = "warn"),
+    $call => `logger.info($msg)`
+}
+"#,
+    );
+
+    let file_path = Utf8Path::new("input.js");
+    fs.insert(
+        file_path.into(),
+        b"console.log(\"hello\");\nconsole.log(\"world\");\nconsole.log(\"!\");\n",
+    );
+
+    let (fs, result) = run_cli_with_server_workspace(
+        fs,
+        &mut console,
+        Args::from(["check", "--write", "--unsafe", file_path.as_str()].as_slice()),
+    );
+
+    assert!(result.is_ok(), "run_cli returned {result:?}");
+    assert_file_contents(
+        &fs,
+        file_path,
+        "logger.info(\"hello\");\nlogger.info(\"world\");\nlogger.info(\"!\");\n",
+    );
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "check_plugin_multiple_rewrites",
+        fs,
+        console,
+        result,
+    ));
+}
+
 #[test]
 fn doesnt_check_file_when_assist_is_disabled() {
     let fs = MemoryFileSystem::default();
@@ -3579,3 +3767,286 @@ fn check_format_with_syntax_errors_when_flag_enabled() {
         result,
     ));
 }
+
+#[test]
+fn check_plugin_apply_rewrite_css() {
+    let fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    fs.insert(
+        Utf8PathBuf::from("biome.json"),
+        br#"{
+    "plugins": ["banRed.grit"],
+    "css": { "linter": { "enabled": true } },
+    "linter": {
+        "rules": { "recommended": false }
+    },
+    "formatter": { "enabled": false }
+}
+"#,
+    );
+
+    fs.insert(
+        Utf8PathBuf::from("banRed.grit"),
+        br#"language css
+
+`red` as $color where {
+    register_diagnostic(
+        span = $color,
+        message = "Avoid using red.",
+        severity = "warn"
+    ),
+    $color => `blue`
+}
+"#,
+    );
+
+    let file_path = Utf8Path::new("file.css");
+    fs.insert(file_path.into(), b"a { color: red; }\n");
+
+    let (fs, result) = run_cli_with_server_workspace(
+        fs,
+        &mut console,
+        Args::from(["check", "--write", "--unsafe", file_path.as_str()].as_slice()),
+    );
+
+    assert!(result.is_ok(), "run_cli returned {result:?}");
+    assert_file_contents(&fs, file_path, "a { color: blue; }\n");
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "check_plugin_apply_rewrite_css",
+        fs,
+        console,
+        result,
+    ));
+}
+
+#[test]
+fn check_plugin_safe_fix_write() {
+    let fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    fs.insert(
+        Utf8PathBuf::from("biome.json"),
+        br#"{
+    "plugins": ["useConsoleInfo.grit"],
+    "formatter": { "enabled": false }
+}
+"#,
+    );
+
+    fs.insert(
+        Utf8PathBuf::from("useConsoleInfo.grit"),
+        br#"language js
+
+`console.log($msg)` as $call where {
+    register_diagnostic(span = $call, message = "Use console.info instead of console.log.", severity = "warn", fix_kind = "safe"),
+    $call => `console.info($msg)`
+}
+"#,
+    );
+
+    let file_path = Utf8Path::new("input.js");
+    fs.insert(file_path.into(), b"console.log(\"hello\");\n");
+
+    let (fs, result) = run_cli_with_server_workspace(
+        fs,
+        &mut console,
+        Args::from(["check", "--write", file_path.as_str()].as_slice()),
+    );
+
+    // --write without --unsafe should apply safe fixes
+    assert!(result.is_ok(), "run_cli returned {result:?}");
+    assert_file_contents(&fs, file_path, "console.info(\"hello\");\n");
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "check_plugin_safe_fix_write",
+        fs,
+        console,
+        result,
+    ));
+}
+
+#[test]
+fn check_plugin_safe_fix_no_write() {
+    let fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    fs.insert(
+        Utf8PathBuf::from("biome.json"),
+        br#"{
+    "plugins": ["useConsoleInfo.grit"],
+    "formatter": { "enabled": false }
+}
+"#,
+    );
+
+    fs.insert(
+        Utf8PathBuf::from("useConsoleInfo.grit"),
+        br#"language js
+
+`console.log($msg)` as $call where {
+    register_diagnostic(span = $call, message = "Use console.info instead of console.log.", severity = "warn", fix_kind = "safe"),
+    $call => `console.info($msg)`
+}
+"#,
+    );
+
+    let file_path = Utf8Path::new("input.js");
+    fs.insert(file_path.into(), b"console.log(\"hello\");\n");
+
+    let (fs, result) = run_cli_with_server_workspace(
+        fs,
+        &mut console,
+        Args::from(["check", file_path.as_str()].as_slice()),
+    );
+
+    // Without --write, safe fixes should not be applied but shown as "Safe fix"
+    assert!(result.is_ok(), "run_cli returned {result:?}");
+    assert_file_contents(&fs, file_path, "console.log(\"hello\");\n");
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "check_plugin_safe_fix_no_write",
+        fs,
+        console,
+        result,
+    ));
+}
+
+#[test]
+fn check_plugin_invalid_fix_kind() {
+    let fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    fs.insert(
+        Utf8PathBuf::from("biome.json"),
+        br#"{
+    "plugins": ["badFixKind.grit"],
+    "formatter": { "enabled": false }
+}
+"#,
+    );
+
+    fs.insert(
+        Utf8PathBuf::from("badFixKind.grit"),
+        br#"language js
+
+`console.log($msg)` as $call where {
+    register_diagnostic(span = $call, message = "Use console.info instead.", fix_kind = "invalid"),
+    $call => `console.info($msg)`
+}
+"#,
+    );
+
+    let file_path = Utf8Path::new("input.js");
+    fs.insert(file_path.into(), b"console.log(\"hello\");\n");
+
+    let (fs, result) = run_cli_with_server_workspace(
+        fs,
+        &mut console,
+        Args::from(["check", file_path.as_str()].as_slice()),
+    );
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "check_plugin_invalid_fix_kind",
+        fs,
+        console,
+        result,
+    ));
+}
+
+#[test]
+fn check_plugin_invalid_severity() {
+    let fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    fs.insert(
+        Utf8PathBuf::from("biome.json"),
+        br#"{
+    "plugins": ["badSeverity.grit"],
+    "formatter": { "enabled": false }
+}
+"#,
+    );
+
+    fs.insert(
+        Utf8PathBuf::from("badSeverity.grit"),
+        br#"language js
+
+`console.log($msg)` as $call where {
+    register_diagnostic(span = $call, message = "Use console.info instead.", severity = "invalid")
+}
+"#,
+    );
+
+    let file_path = Utf8Path::new("input.js");
+    fs.insert(file_path.into(), b"console.log(\"hello\");\n");
+
+    let (fs, result) = run_cli_with_server_workspace(
+        fs,
+        &mut console,
+        Args::from(["check", file_path.as_str()].as_slice()),
+    );
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "check_plugin_invalid_severity",
+        fs,
+        console,
+        result,
+    ));
+}
+
+#[test]
+fn check_plugin_apply_rewrite_json() {
+    let fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    fs.insert(
+        Utf8PathBuf::from("biome.json"),
+        br#"{
+    "plugins": ["fixVersion.grit"],
+    "json": { "linter": { "enabled": true } },
+    "linter": {
+        "rules": { "recommended": false }
+    },
+    "formatter": { "enabled": false }
+}
+"#,
+    );
+
+    fs.insert(
+        Utf8PathBuf::from("fixVersion.grit"),
+        br#"language json
+
+`"1.0.0"` as $version where {
+    register_diagnostic(
+        span = $version,
+        message = "Update version.",
+        severity = "warn"
+    ),
+    $version => `"2.0.0"`
+}
+"#,
+    );
+
+    let file_path = Utf8Path::new("package.json");
+    fs.insert(file_path.into(), b"{\"version\": \"1.0.0\"}\n");
+
+    let (fs, result) = run_cli_with_server_workspace(
+        fs,
+        &mut console,
+        Args::from(["check", "--write", "--unsafe", file_path.as_str()].as_slice()),
+    );
+
+    assert!(result.is_ok(), "run_cli returned {result:?}");
+    assert_file_contents(&fs, file_path, "{\"version\": \"2.0.0\"}\n");
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "check_plugin_apply_rewrite_json",
+        fs,
+        console,
+        result,
+    ));
+}
diff --git a/crates/biome_cli/tests/snapshots/main_commands_check/check_plugin_apply_rewrite.snap b/crates/biome_cli/tests/snapshots/main_commands_check/check_plugin_apply_rewrite.snap
new file mode 100644
index 000000000000..0da9f16a0423
--- /dev/null
+++ b/crates/biome_cli/tests/snapshots/main_commands_check/check_plugin_apply_rewrite.snap
@@ -0,0 +1,37 @@
+---
+source: crates/biome_cli/tests/snap_test.rs
+expression: redactor(content)
+---
+## `biome.json`
+
+```json
+{
+  "plugins": ["useConsoleInfo.grit"],
+  "formatter": { "enabled": false }
+}
+```
+
+## `input.js`
+
+```js
+console.info("hello");
+
+```
+
+## `useConsoleInfo.grit`
+
+```grit
+language js
+
+`console.log($msg)` as $call where {
+    register_diagnostic(span = $call, message = "Use console.info instead of console.log.", severity = "warn"),
+    $call => `console.info($msg)`
+}
+
+```
+
+# Emitted Messages
+
+```block
+Checked 1 file in <TIME>. Fixed 1 file.
+```
diff --git a/crates/biome_cli/tests/snapshots/main_commands_check/check_plugin_apply_rewrite_css.snap b/crates/biome_cli/tests/snapshots/main_commands_check/check_plugin_apply_rewrite_css.snap
new file mode 100644
index 000000000000..16dfe95d8a40
--- /dev/null
+++ b/crates/biome_cli/tests/snapshots/main_commands_check/check_plugin_apply_rewrite_css.snap
@@ -0,0 +1,45 @@
+---
+source: crates/biome_cli/tests/snap_test.rs
+expression: redactor(content)
+---
+## `biome.json`
+
+```json
+{
+  "plugins": ["banRed.grit"],
+  "css": { "linter": { "enabled": true } },
+  "linter": {
+    "rules": { "recommended": false }
+  },
+  "formatter": { "enabled": false }
+}
+```
+
+## `banRed.grit`
+
+```grit
+language css
+
+`red` as $color where {
+    register_diagnostic(
+        span = $color,
+        message = "Avoid using red.",
+        severity = "warn"
+    ),
+    $color => `blue`
+}
+
+```
+
+## `file.css`
+
+```css
+a { color: blue; }
+
+```
+
+# Emitted Messages
+
+```block
+Checked 1 file in <TIME>. Fixed 1 file.
+```
diff --git a/crates/biome_cli/tests/snapshots/main_commands_check/check_plugin_apply_rewrite_json.snap b/crates/biome_cli/tests/snapshots/main_commands_check/check_plugin_apply_rewrite_json.snap
new file mode 100644
index 000000000000..53914e8d1e0a
--- /dev/null
+++ b/crates/biome_cli/tests/snapshots/main_commands_check/check_plugin_apply_rewrite_json.snap
@@ -0,0 +1,45 @@
+---
+source: crates/biome_cli/tests/snap_test.rs
+expression: redactor(content)
+---
+## `biome.json`
+
+```json
+{
+  "plugins": ["fixVersion.grit"],
+  "json": { "linter": { "enabled": true } },
+  "linter": {
+    "rules": { "recommended": false }
+  },
+  "formatter": { "enabled": false }
+}
+```
+
+## `fixVersion.grit`
+
+```grit
+language json
+
+`"1.0.0"` as $version where {
+    register_diagnostic(
+        span = $version,
+        message = "Update version.",
+        severity = "warn"
+    ),
+    $version => `"2.0.0"`
+}
+
+```
+
+## `package.json`
+
+```json
+{"version": "2.0.0"}
+
+```
+
+# Emitted Messages
+
+```block
+Checked 1 file in <TIME>. Fixed 1 file.
+```
diff --git a/crates/biome_cli/tests/snapshots/main_commands_check/check_plugin_invalid_fix_kind.snap b/crates/biome_cli/tests/snapshots/main_commands_check/check_plugin_invalid_fix_kind.snap
new file mode 100644
index 000000000000..2af26e1d982a
--- /dev/null
+++ b/crates/biome_cli/tests/snapshots/main_commands_check/check_plugin_invalid_fix_kind.snap
@@ -0,0 +1,46 @@
+---
+source: crates/biome_cli/tests/snap_test.rs
+expression: redactor(content)
+---
+## `biome.json`
+
+```json
+{
+  "plugins": ["badFixKind.grit"],
+  "formatter": { "enabled": false }
+}
+```
+
+## `badFixKind.grit`
+
+```grit
+language js
+
+`console.log($msg)` as $call where {
+    register_diagnostic(span = $call, message = "Use console.info instead.", fix_kind = "invalid"),
+    $call => `console.info($msg)`
+}
+
+```
+
+## `input.js`
+
+```js
+console.log("hello");
+
+```
+
+# Emitted Messages
+
+```block
+input.js plugin ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  i badFixKind errored: invalid fix_kind "invalid", expected "safe" or "unsafe"
+  
+
+```
+
+```block
+Checked 1 file in <TIME>. No fixes applied.
+Found 1 info.
+```
diff --git a/crates/biome_cli/tests/snapshots/main_commands_check/check_plugin_invalid_severity.snap b/crates/biome_cli/tests/snapshots/main_commands_check/check_plugin_invalid_severity.snap
new file mode 100644
index 000000000000..b98073772df6
--- /dev/null
+++ b/crates/biome_cli/tests/snapshots/main_commands_check/check_plugin_invalid_severity.snap
@@ -0,0 +1,45 @@
+---
+source: crates/biome_cli/tests/snap_test.rs
+expression: redactor(content)
+---
+## `biome.json`
+
+```json
+{
+  "plugins": ["badSeverity.grit"],
+  "formatter": { "enabled": false }
+}
+```
+
+## `badSeverity.grit`
+
+```grit
+language js
+
+`console.log($msg)` as $call where {
+    register_diagnostic(span = $call, message = "Use console.info instead.", severity = "invalid")
+}
+
+```
+
+## `input.js`
+
+```js
+console.log("hello");
+
+```
+
+# Emitted Messages
+
+```block
+input.js plugin ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  i badSeverity errored: invalid severity "invalid", expected "hint", "info", "warn", or "error"
+  
+
+```
+
+```block
+Checked 1 file in <TIME>. No fixes applied.
+Found 1 info.
+```
diff --git a/crates/biome_cli/tests/snapshots/main_commands_check/check_plugin_multiple_rewrites.snap b/crates/biome_cli/tests/snapshots/main_commands_check/check_plugin_multiple_rewrites.snap
new file mode 100644
index 000000000000..96401b263161
--- /dev/null
+++ b/crates/biome_cli/tests/snapshots/main_commands_check/check_plugin_multiple_rewrites.snap
@@ -0,0 +1,39 @@
+---
+source: crates/biome_cli/tests/snap_test.rs
+expression: redactor(content)
+---
+## `biome.json`
+
+```json
+{
+  "plugins": ["useLoggerInfo.grit"],
+  "formatter": { "enabled": false }
+}
+```
+
+## `input.js`
+
+```js
+logger.info("hello");
+logger.info("world");
+logger.info("!");
+
+```
+
+## `useLoggerInfo.grit`
+
+```grit
+language js
+
+`console.log($msg)` as $call where {
+    register_diagnostic(span = $call, message = "Use logger.info instead of console.log.", severity = "warn"),
+    $call => `logger.info($msg)`
+}
+
+```
+
+# Emitted Messages
+
+```block
+Checked 1 file in <TIME>. Fixed 1 file.
+```
diff --git a/crates/biome_cli/tests/snapshots/main_commands_check/check_plugin_rewrite_no_write.snap b/crates/biome_cli/tests/snapshots/main_commands_check/check_plugin_rewrite_no_write.snap
new file mode 100644
index 000000000000..1eff4119bd68
--- /dev/null
+++ b/crates/biome_cli/tests/snapshots/main_commands_check/check_plugin_rewrite_no_write.snap
@@ -0,0 +1,56 @@
+---
+source: crates/biome_cli/tests/snap_test.rs
+expression: redactor(content)
+---
+## `biome.json`
+
+```json
+{
+  "plugins": ["useConsoleInfo.grit"],
+  "formatter": { "enabled": false }
+}
+```
+
+## `input.js`
+
+```js
+console.log("hello");
+
+```
+
+## `useConsoleInfo.grit`
+
+```grit
+language js
+
+`console.log($msg)` as $call where {
+    register_diagnostic(span = $call, message = "Use console.info instead of console.log.", severity = "warn"),
+    $call => `console.info($msg)`
+}
+
+```
+
+# Emitted Messages
+
+```block
+input.js:1:1 plugin  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! Use console.info instead of console.log.
+  
+  > 1 │ console.log("hello");
+      │ ^^^^^^^^^^^^^^^^^^^^
+    2 │ 
+  
+  i Unsafe fix: Rewrite suggested by plugin `useConsoleInfo`
+  
+    1   │ - console.log("hello");
+      1 │ + console.info("hello");
+    2 2 │   
+  
+
+```
+
+```block
+Checked 1 file in <TIME>. No fixes applied.
+Found 1 warning.
+```
diff --git a/crates/biome_cli/tests/snapshots/main_commands_check/check_plugin_rewrite_write_without_unsafe.snap b/crates/biome_cli/tests/snapshots/main_commands_check/check_plugin_rewrite_write_without_unsafe.snap
new file mode 100644
index 000000000000..a980eb98f395
--- /dev/null
+++ b/crates/biome_cli/tests/snapshots/main_commands_check/check_plugin_rewrite_write_without_unsafe.snap
@@ -0,0 +1,62 @@
+---
+source: crates/biome_cli/tests/snap_test.rs
+expression: redactor(content)
+---
+## `biome.json`
+
+```json
+{
+  "plugins": ["useConsoleInfo.grit"],
+  "formatter": { "enabled": false }
+}
+```
+
+## `file.js`
+
+```js
+console.log("hello");
+
+```
+
+## `useConsoleInfo.grit`
+
+```grit
+language js
+
+`console.log($msg)` as $call where {
+    register_diagnostic(span = $call, message = "Use console.info instead of console.log.", severity = "warn"),
+    $call => `console.info($msg)`
+}
+
+```
+
+# Emitted Messages
+
+```block
+file.js:1:1 plugin  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! Use console.info instead of console.log.
+  
+  > 1 │ console.log("hello");
+      │ ^^^^^^^^^^^^^^^^^^^^
+    2 │ 
+  
+  i Unsafe fix: Rewrite suggested by plugin `useConsoleInfo`
+  
+    1   │ - console.log("hello");
+      1 │ + console.info("hello");
+    2 2 │   
+  
+
+```
+
+```block
+Skipped 1 suggested fixes.
+If you wish to apply the suggested (unsafe) fixes, use the command biome check --write --unsafe
+
+```
+
+```block
+Checked 1 file in <TIME>. No fixes applied.
+Found 1 warning.
+```
diff --git a/crates/biome_cli/tests/snapshots/main_commands_check/check_plugin_safe_fix_no_write.snap b/crates/biome_cli/tests/snapshots/main_commands_check/check_plugin_safe_fix_no_write.snap
new file mode 100644
index 000000000000..c82efb7706ef
--- /dev/null
+++ b/crates/biome_cli/tests/snapshots/main_commands_check/check_plugin_safe_fix_no_write.snap
@@ -0,0 +1,56 @@
+---
+source: crates/biome_cli/tests/snap_test.rs
+expression: redactor(content)
+---
+## `biome.json`
+
+```json
+{
+  "plugins": ["useConsoleInfo.grit"],
+  "formatter": { "enabled": false }
+}
+```
+
+## `input.js`
+
+```js
+console.log("hello");
+
+```
+
+## `useConsoleInfo.grit`
+
+```grit
+language js
+
+`console.log($msg)` as $call where {
+    register_diagnostic(span = $call, message = "Use console.info instead of console.log.", severity = "warn", fix_kind = "safe"),
+    $call => `console.info($msg)`
+}
+
+```
+
+# Emitted Messages
+
+```block
+input.js:1:1 plugin  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! Use console.info instead of console.log.
+  
+  > 1 │ console.log("hello");
+      │ ^^^^^^^^^^^^^^^^^^^^
+    2 │ 
+  
+  i Safe fix: Rewrite suggested by plugin `useConsoleInfo`
+  
+    1   │ - console.log("hello");
+      1 │ + console.info("hello");
+    2 2 │   
+  
+
+```
+
+```block
+Checked 1 file in <TIME>. No fixes applied.
+Found 1 warning.
+```
diff --git a/crates/biome_cli/tests/snapshots/main_commands_check/check_plugin_safe_fix_write.snap b/crates/biome_cli/tests/snapshots/main_commands_check/check_plugin_safe_fix_write.snap
new file mode 100644
index 000000000000..584510737729
--- /dev/null
+++ b/crates/biome_cli/tests/snapshots/main_commands_check/check_plugin_safe_fix_write.snap
@@ -0,0 +1,37 @@
+---
+source: crates/biome_cli/tests/snap_test.rs
+expression: redactor(content)
+---
+## `biome.json`
+
+```json
+{
+  "plugins": ["useConsoleInfo.grit"],
+  "formatter": { "enabled": false }
+}
+```
+
+## `input.js`
+
+```js
+console.info("hello");
+
+```
+
+## `useConsoleInfo.grit`
+
+```grit
+language js
+
+`console.log($msg)` as $call where {
+    register_diagnostic(span = $call, message = "Use console.info instead of console.log.", severity = "warn", fix_kind = "safe"),
+    $call => `console.info($msg)`
+}
+
+```
+
+# Emitted Messages
+
+```block
+Checked 1 file in <TIME>. Fixed 1 file.
+```
diff --git a/crates/biome_grit_patterns/src/grit_binding.rs b/crates/biome_grit_patterns/src/grit_binding.rs
index f6ff28be6f95..dcc2527523e9 100644
--- a/crates/biome_grit_patterns/src/grit_binding.rs
+++ b/crates/biome_grit_patterns/src/grit_binding.rs
@@ -1,6 +1,7 @@
 use crate::{
     grit_context::GritQueryContext, grit_target_language::GritTargetLanguage,
-    grit_target_node::GritTargetNode, source_location_ext::SourceFileExt, util::TextRangeGritExt,
+    grit_target_node::GritTargetNode, linearization::linearize_binding,
+    source_location_ext::SourceFileExt, util::TextRangeGritExt,
 };
 use biome_diagnostics::{SourceCode, display::SourceFile};
 use biome_rowan::TextRange;
@@ -157,14 +158,45 @@ impl<'a> Binding<'a, GritQueryContext> for GritBinding<'a> {
 
     fn linearized_text(
         &self,
-        _language: &GritTargetLanguage,
-        _effects: &[Effect<'a, GritQueryContext>],
-        _files: &FileRegistry<'a, GritQueryContext>,
-        _memo: &mut HashMap<grit_util::CodeRange, Option<String>>,
-        _distributed_indent: Option<usize>,
-        _logs: &mut AnalysisLogs,
+        language: &GritTargetLanguage,
+        effects: &[Effect<'a, GritQueryContext>],
+        files: &FileRegistry<'a, GritQueryContext>,
+        memo: &mut HashMap<grit_util::CodeRange, Option<String>>,
+        distributed_indent: Option<usize>,
+        logs: &mut AnalysisLogs,
     ) -> GritResult<Cow<'a, str>> {
-        Err(GritPatternError::new("Not implemented")) // TODO: Implement rewriting
+        match self {
+            Self::Node(node) => {
+                let source = node.source();
+                let range = node.code_range();
+                linearize_binding(
+                    language,
+                    effects,
+                    files,
+                    memo,
+                    source,
+                    range,
+                    distributed_indent,
+                    logs,
+                )
+            }
+            Self::Range(text_range, source) => {
+                let range = text_range.to_code_range(source);
+                linearize_binding(
+                    language,
+                    effects,
+                    files,
+                    memo,
+                    source,
+                    range,
+                    distributed_indent,
+                    logs,
+                )
+            }
+            Self::Empty(..) => Ok(Cow::Borrowed("")),
+            Self::File(path) => Ok(path.to_string_lossy()),
+            Self::Constant(constant) => Ok(constant.to_string().into()),
+        }
     }
 
     fn text(&self, _language: &GritTargetLanguage) -> GritResult<Cow<'a, str>> {
diff --git a/crates/biome_grit_patterns/src/grit_context.rs b/crates/biome_grit_patterns/src/grit_context.rs
index a2c04b4ef58a..920af975eafa 100644
--- a/crates/biome_grit_patterns/src/grit_context.rs
+++ b/crates/biome_grit_patterns/src/grit_context.rs
@@ -7,7 +7,9 @@ use crate::grit_resolved_pattern::GritResolvedPattern;
 use crate::grit_target_language::GritTargetLanguage;
 use crate::grit_target_node::GritTargetNode;
 use crate::grit_tree::GritTargetTree;
+use crate::linearization::apply_effects;
 use biome_analyze::RuleDiagnostic;
+use biome_diagnostics::Applicability;
 use biome_parser::AnyParse;
 use camino::Utf8PathBuf;
 use grit_pattern_matcher::constants::{GLOBAL_VARS_SCOPE_INDEX, NEW_FILES_INDEX};
@@ -54,11 +56,11 @@ pub struct GritExecContext<'a> {
     pub patterns: &'a [PatternDefinition<GritQueryContext>],
     pub predicates: &'a [PredicateDefinition<GritQueryContext>],
 
-    pub diagnostics: Mutex<Vec<RuleDiagnostic>>,
+    pub diagnostics: Mutex<Vec<(RuleDiagnostic, Applicability)>>,
 }
 
 impl GritExecContext<'_> {
-    pub fn add_diagnostic(&self, diagnostic: RuleDiagnostic) {
+    pub fn add_diagnostic(&self, diagnostic: RuleDiagnostic, applicability: Applicability) {
         let mut diagnostics = self.diagnostics.lock().unwrap();
         // Make sure we don't add multiple messages for the same span.
         // I think this happens when a node and its child(ren) both match the
@@ -67,13 +69,13 @@ impl GritExecContext<'_> {
         // Grit pattern matcher.
         if diagnostics
             .last()
-            .is_none_or(|last| last.span() != diagnostic.span())
+            .is_none_or(|(last, _)| last.span() != diagnostic.span())
         {
-            diagnostics.push(diagnostic);
+            diagnostics.push((diagnostic, applicability));
         }
     }
 
-    pub fn into_diagnostics(self) -> Vec<RuleDiagnostic> {
+    pub fn into_diagnostics(self) -> Vec<(RuleDiagnostic, Applicability)> {
         self.diagnostics.into_inner().unwrap()
     }
 }
@@ -176,15 +178,36 @@ impl<'a> ExecContext<'a, GritQueryContext> for GritExecContext<'a> {
             variables,
             suppressed,
         };
-        for file_ptr in files {
-            let file = state.files.get_file_owner(file_ptr);
+        for file_ptr in &files {
+            let file = state.files.get_file_owner(*file_ptr);
             let mut match_log = file.matches.borrow_mut();
 
             if match_log.input_matches.is_none() {
                 match_log.input_matches = Some(input_ranges.clone());
             }
+        }
 
-            // TODO: Implement effect application
+        // Apply effects: if there are accumulated effects, linearize
+        // them to produce rewritten source and push a new file version.
+        if !state.effects.is_empty() {
+            for file_ptr in &files {
+                let file_owner = state.files.get_file_owner(*file_ptr);
+                let source = file_owner.tree.text();
+
+                let new_src =
+                    apply_effects(source, &state.effects, &state.files, &self.lang, logs)?;
+
+                if new_src != source {
+                    let file_name = file_owner.name.clone();
+                    if let Some(new_owner) = new_file_owner(file_name, &new_src, &self.lang, logs)?
+                    {
+                        self.files().push(new_owner);
+                        state
+                            .files
+                            .push_revision(file_ptr, self.files().last().unwrap());
+                    }
+                }
+            }
         }
 
         let new_files_binding = &mut state.bindings[GLOBAL_VARS_SCOPE_INDEX as usize]
diff --git a/crates/biome_grit_patterns/src/grit_query.rs b/crates/biome_grit_patterns/src/grit_query.rs
index 2553b0c56e1c..bf74a458d322 100644
--- a/crates/biome_grit_patterns/src/grit_query.rs
+++ b/crates/biome_grit_patterns/src/grit_query.rs
@@ -14,6 +14,7 @@ use crate::pattern_compiler::{
 use crate::variables::{VarRegistry, VariableLocations};
 use crate::{BuiltInFunction, CompileError};
 use biome_analyze::RuleDiagnostic;
+use biome_diagnostics::Applicability;
 use biome_grit_syntax::{GritRoot, GritRootExt};
 use camino::Utf8Path;
 use grit_pattern_matcher::constants::{
@@ -199,7 +200,7 @@ impl GritQuery {
 #[derive(Debug)]
 pub struct GritQueryResult {
     pub effects: Vec<GritQueryEffect>,
-    pub diagnostics: Vec<RuleDiagnostic>,
+    pub diagnostics: Vec<(RuleDiagnostic, Applicability)>,
     pub logs: AnalysisLogs,
 }
 
diff --git a/crates/biome_grit_patterns/src/grit_resolved_pattern.rs b/crates/biome_grit_patterns/src/grit_resolved_pattern.rs
index 99658e9a2b84..ee665e1908b3 100644
--- a/crates/biome_grit_patterns/src/grit_resolved_pattern.rs
+++ b/crates/biome_grit_patterns/src/grit_resolved_pattern.rs
@@ -345,11 +345,75 @@ impl<'a> ResolvedPattern<'a, GritQueryContext> for GritResolvedPattern<'a> {
 
     fn extend(
         &mut self,
-        _with: Self,
-        _effects: &mut Vec<Effect<'a, GritQueryContext>>,
-        _language: &<GritQueryContext as QueryContext>::Language<'a>,
+        mut with: Self,
+        effects: &mut Vec<Effect<'a, GritQueryContext>>,
+        language: &<GritQueryContext as QueryContext>::Language<'a>,
     ) -> GritResult<()> {
-        Err(GritPatternError::new("Not implemented")) // TODO: Implement rewriting
+        match self {
+            Self::Binding(bindings) => {
+                let new_effects: GritResult<Vec<Effect<GritQueryContext>>> = bindings
+                    .iter()
+                    .map(|b| {
+                        let is_first = !effects.iter().any(|e| e.binding == *b);
+                        with.normalize_insert(b, is_first, language)?;
+                        Ok(Effect {
+                            binding: b.clone(),
+                            pattern: with.clone(),
+                            kind: grit_util::EffectKind::Insert,
+                        })
+                    })
+                    .collect();
+                effects.extend(new_effects?);
+                Ok(())
+            }
+            Self::Snippets(snippets) => {
+                match with {
+                    Self::Snippets(with_snippets) => snippets.extend(with_snippets),
+                    Self::Binding(binding) => {
+                        let binding = binding.last().ok_or_else(|| {
+                            GritPatternError::new("cannot extend with empty binding")
+                        })?;
+                        snippets.push(ResolvedSnippet::Binding(binding.clone()));
+                    }
+                    Self::Constant(c) => {
+                        snippets.push(ResolvedSnippet::Text(c.to_string().into()));
+                    }
+                    Self::List(_) | Self::File(_) | Self::Files(_) | Self::Map(_) => {
+                        return Err(GritPatternError::new(
+                            "cannot extend ResolvedPattern::Snippet with this type",
+                        ));
+                    }
+                }
+                Ok(())
+            }
+            Self::List(lst) => {
+                lst.push(with);
+                Ok(())
+            }
+            Self::Constant(Constant::Integer(i)) => {
+                if let Self::Constant(Constant::Integer(j)) = with {
+                    *i += j;
+                    Ok(())
+                } else {
+                    Err(GritPatternError::new(
+                        "can only extend Constant::Integer with another Constant::Integer",
+                    ))
+                }
+            }
+            Self::Constant(Constant::Float(x)) => {
+                if let Self::Constant(Constant::Float(y)) = with {
+                    *x += y;
+                    Ok(())
+                } else {
+                    Err(GritPatternError::new(
+                        "can only extend Constant::Float with another Constant::Float",
+                    ))
+                }
+            }
+            Self::File(_) | Self::Files(_) | Self::Map(_) | Self::Constant(_) => {
+                Err(GritPatternError::new("cannot extend this resolved pattern"))
+            }
+        }
     }
 
     fn float(
@@ -528,14 +592,83 @@ impl<'a> ResolvedPattern<'a, GritQueryContext> for GritResolvedPattern<'a> {
 
     fn linearized_text(
         &self,
-        _language: &GritTargetLanguage,
-        _effects: &[Effect<'a, GritQueryContext>],
-        _files: &FileRegistry<'a, GritQueryContext>,
-        _memo: &mut HashMap<CodeRange, Option<String>>,
-        _should_pad_snippet: bool,
-        _logs: &mut AnalysisLogs,
+        language: &GritTargetLanguage,
+        effects: &[Effect<'a, GritQueryContext>],
+        files: &FileRegistry<'a, GritQueryContext>,
+        memo: &mut HashMap<CodeRange, Option<String>>,
+        should_pad_snippet: bool,
+        logs: &mut AnalysisLogs,
     ) -> GritResult<Cow<'a, str>> {
-        Err(GritPatternError::new("Not implemented")) // TODO: Implement rewriting
+        match self {
+            Self::Snippets(snippets) => Ok(snippets
+                .iter()
+                .map(|snippet| snippet.linearized_text(language, effects, files, memo, None, logs))
+                .collect::<GritResult<Vec<_>>>()?
+                .join("")
+                .into()),
+            Self::Binding(bindings) => Ok(bindings
+                .last()
+                .ok_or_else(|| {
+                    GritPatternError::new("cannot grab text of resolved_pattern with no binding")
+                })?
+                .linearized_text(
+                    language,
+                    effects,
+                    files,
+                    memo,
+                    should_pad_snippet.then_some(0),
+                    logs,
+                )?),
+            Self::Constant(c) => Ok(c.to_string().into()),
+            Self::List(list) => Ok(list
+                .iter()
+                .map(|pattern| {
+                    pattern.linearized_text(
+                        language,
+                        effects,
+                        files,
+                        memo,
+                        should_pad_snippet,
+                        logs,
+                    )
+                })
+                .collect::<GritResult<Vec<_>>>()?
+                .join(",")
+                .into()),
+            Self::Map(map) => Ok(("{".to_string()
+                + &map
+                    .iter()
+                    .map(|(key, value)| {
+                        let linearized = value.linearized_text(
+                            language,
+                            effects,
+                            files,
+                            memo,
+                            should_pad_snippet,
+                            logs,
+                        )?;
+                        Ok(format!("\"{key}\": {linearized}"))
+                    })
+                    .collect::<GritResult<Vec<_>>>()?
+                    .join(", ")
+                + "}")
+                .into()),
+            Self::File(file) => Ok(format!(
+                "{}:\n{}",
+                file.name(files)
+                    .linearized_text(language, effects, files, memo, false, logs)?,
+                file.body(files).linearized_text(
+                    language,
+                    effects,
+                    files,
+                    memo,
+                    should_pad_snippet,
+                    logs,
+                )?
+            )
+            .into()),
+            Self::Files(_) => self.text(files, language),
+        }
     }
 
     fn matches_undefined(&self) -> bool {
@@ -561,11 +694,22 @@ impl<'a> ResolvedPattern<'a, GritQueryContext> for GritResolvedPattern<'a> {
 
     fn normalize_insert(
         &mut self,
-        _binding: &GritBinding,
-        _is_first: bool,
-        _language: &GritTargetLanguage,
+        binding: &GritBinding,
+        is_first: bool,
+        language: &GritTargetLanguage,
     ) -> GritResult<()> {
-        Err(GritPatternError::new("Not implemented")) // TODO: Implement insertion padding
+        let Self::Snippets(snippets) = self else {
+            return Ok(());
+        };
+        let Some(ResolvedSnippet::Text(text)) = snippets.first() else {
+            return Ok(());
+        };
+        if let Some(padding) = binding.get_insertion_padding(text, is_first, language)
+            && padding.chars().next() != binding.text(language)?.chars().last()
+        {
+            snippets.insert(0, ResolvedSnippet::Text(padding.into()));
+        }
+        Ok(())
     }
 
     fn position(&self, language: &GritTargetLanguage) -> Option<Range> {
diff --git a/crates/biome_grit_patterns/src/lib.rs b/crates/biome_grit_patterns/src/lib.rs
index 689d2fed9b5c..d7a972f29f59 100644
--- a/crates/biome_grit_patterns/src/lib.rs
+++ b/crates/biome_grit_patterns/src/lib.rs
@@ -19,6 +19,7 @@ mod grit_resolved_pattern;
 mod grit_target_language;
 mod grit_target_node;
 mod grit_tree;
+mod linearization;
 mod pattern_compiler;
 mod source_location_ext;
 mod util;
diff --git a/crates/biome_grit_patterns/src/linearization.rs b/crates/biome_grit_patterns/src/linearization.rs
new file mode 100644
index 000000000000..8626dc2c003d
--- /dev/null
+++ b/crates/biome_grit_patterns/src/linearization.rs
@@ -0,0 +1,133 @@
+use crate::grit_context::GritQueryContext;
+use crate::grit_target_language::GritTargetLanguage;
+use grit_pattern_matcher::binding::Binding;
+use grit_pattern_matcher::effects::Effect;
+use grit_pattern_matcher::pattern::{FileRegistry, ResolvedPattern, get_top_level_effects};
+use grit_util::error::{GritPatternError, GritResult};
+use grit_util::{AnalysisLogs, CodeRange, EffectKind};
+use std::borrow::Cow;
+use std::collections::HashMap;
+
+/// Simplified linearization function that applies effects to produce rewritten
+/// source text.
+///
+/// This is a simplified version of the upstream `linearize_binding` that skips
+/// padding/indent alignment (not yet implemented for Biome's target languages).
+#[expect(clippy::too_many_arguments)]
+pub(crate) fn linearize_binding<'a>(
+    language: &GritTargetLanguage,
+    effects: &[Effect<'a, GritQueryContext>],
+    files: &FileRegistry<'a, GritQueryContext>,
+    memo: &mut HashMap<CodeRange, Option<String>>,
+    source: &'a str,
+    range: CodeRange,
+    _distributed_indent: Option<usize>,
+    logs: &mut AnalysisLogs,
+) -> GritResult<Cow<'a, str>> {
+    // Get only top-level effects within this range.
+    let top_level_effects = get_top_level_effects(effects, memo, &range, language, logs)?;
+
+    if top_level_effects.is_empty() {
+        return Ok(Cow::Borrowed(
+            &source[range.start as usize..range.end as usize],
+        ));
+    }
+
+    // For each effect, compute the linearized replacement text.
+    let mut replacements: Vec<(usize, usize, String)> = Vec::new();
+    for effect in &top_level_effects {
+        let binding = &effect.binding;
+        let binding_range = binding.code_range(language);
+
+        if let Some(ref br) = binding_range {
+            // Check memo cache for rewrites.
+            if matches!(effect.kind, EffectKind::Rewrite) {
+                match memo.get(br) {
+                    Some(Some(cached_text)) => {
+                        let byte_range = binding.range(language).ok_or_else(|| {
+                            GritPatternError::new(
+                                "failed to apply rewrite: binding has no byte range",
+                            )
+                        })?;
+                        replacements.push((byte_range.start, byte_range.end, cached_text.clone()));
+                        continue;
+                    }
+                    // `None` marks an in-progress rewrite; skip to avoid recursive re-entry.
+                    Some(None) => continue,
+                    None => {
+                        // Mark as "in progress" to prevent infinite recursion.
+                        memo.insert(br.clone(), None);
+                    }
+                }
+            }
+        }
+
+        // Recursively linearize the replacement pattern.
+        let res = effect
+            .pattern
+            .linearized_text(language, effects, files, memo, false, logs)?;
+
+        if let Some(ref br) = binding_range
+            && matches!(effect.kind, EffectKind::Rewrite)
+        {
+            memo.insert(br.clone(), Some(res.to_string()));
+        }
+
+        let byte_range = binding.range(language).ok_or_else(|| {
+            GritPatternError::new("failed to apply rewrite: binding has no byte range")
+        })?;
+        replacements.push((byte_range.start, byte_range.end, res.into_owned()));
+    }
+
+    // Sort replacements by start offset.
+    replacements.sort_by_key(|(start, _, _)| *start);
+
+    // Walk source, copying gaps and inserting replacements.
+    let mut result = String::with_capacity(range.end as usize - range.start as usize);
+    let mut cursor = range.start as usize;
+
+    for (start, end, replacement) in &replacements {
+        if *start < cursor {
+            return Err(GritPatternError::new(format!(
+                "overlapping replacements detected: start={start}, cursor={cursor}"
+            )));
+        }
+        if *start > cursor {
+            result.push_str(&source[cursor..*start]);
+        }
+        result.push_str(replacement);
+        cursor = *end;
+    }
+
+    // Copy any remaining source after the last replacement.
+    if cursor < range.end as usize {
+        result.push_str(&source[cursor..range.end as usize]);
+    }
+
+    memo.insert(range, Some(result.clone()));
+    Ok(Cow::Owned(result))
+}
+
+/// Simplified apply_effects: applies accumulated effects to produce rewritten
+/// source for a file. Returns the rewritten source as an owned String.
+pub(crate) fn apply_effects<'a>(
+    source: &'a str,
+    effects: &[Effect<'a, GritQueryContext>],
+    files: &FileRegistry<'a, GritQueryContext>,
+    language: &GritTargetLanguage,
+    logs: &mut AnalysisLogs,
+) -> GritResult<String> {
+    if effects.is_empty() {
+        return Ok(source.to_string());
+    }
+
+    let mut memo: HashMap<CodeRange, Option<String>> = HashMap::new();
+    let len = u32::try_from(source.len())
+        .map_err(|_| GritPatternError::new("source file too large for GritQL linearization"))?;
+    let range = CodeRange::new(0, len, source);
+
+    let result = linearize_binding(
+        language, effects, files, &mut memo, source, range, None, logs,
+    )?;
+    Ok(result.into_owned())
+}
diff --git a/crates/biome_grit_patterns/tests/specs/ts/duplicateVariable.snap b/crates/biome_grit_patterns/tests/specs/ts/duplicateVariable.snap
index f630bc8da8d6..0128d3a16144 100644
--- a/crates/biome_grit_patterns/tests/specs/ts/duplicateVariable.snap
+++ b/crates/biome_grit_patterns/tests/specs/ts/duplicateVariable.snap
@@ -1,5 +1,6 @@
 ---
 source: crates/biome_grit_patterns/tests/spec_tests.rs
+assertion_line: 94
 expression: duplicateVariable
 ---
 SnapshotResult {
@@ -8,6 +9,14 @@ SnapshotResult {
         "2:1-2:13",
         "6:1-6:21",
     ],
-    rewritten_files: [],
+    rewritten_files: [
+        OutputFile {
+            messages: [],
+            variables: [],
+            source_file: "tests/specs/ts/duplicateVariable.ts",
+            content: "\nfoo?.();\nfoo && bar();\nfoo && foo.bar();\nbar || bar();\nfoo.bar?.();\n",
+            byte_ranges: None,
+        },
+    ],
     created_files: [],
 }
diff --git a/crates/biome_grit_patterns/tests/specs/ts/functionToArrow.snap b/crates/biome_grit_patterns/tests/specs/ts/functionToArrow.snap
index 0ed5c4abee45..28fb568a5e43 100644
--- a/crates/biome_grit_patterns/tests/specs/ts/functionToArrow.snap
+++ b/crates/biome_grit_patterns/tests/specs/ts/functionToArrow.snap
@@ -1,5 +1,6 @@
 ---
 source: crates/biome_grit_patterns/tests/spec_tests.rs
+assertion_line: 94
 expression: functionToArrow
 ---
 SnapshotResult {
@@ -8,6 +9,14 @@ SnapshotResult {
         "1:1-2:2",
         "4:1-6:2",
     ],
-    rewritten_files: [],
+    rewritten_files: [
+        OutputFile {
+            messages: [],
+            variables: [],
+            source_file: "tests/specs/ts/functionToArrow.ts",
+            content: "const foo = (apple) => {  }\n\nconst bar = (apple, pear) => { console.log(\"fruits\"); }\n\nfunction baz(pear) {\n}\n",
+            byte_ranges: None,
+        },
+    ],
     created_files: [],
 }
diff --git a/crates/biome_grit_patterns/tests/specs/ts/log.snap b/crates/biome_grit_patterns/tests/specs/ts/log.snap
index 438da694bf63..867d8d9ea17d 100644
--- a/crates/biome_grit_patterns/tests/specs/ts/log.snap
+++ b/crates/biome_grit_patterns/tests/specs/ts/log.snap
@@ -1,5 +1,6 @@
 ---
 source: crates/biome_grit_patterns/tests/spec_tests.rs
+assertion_line: 94
 expression: log
 ---
 SnapshotResult {
@@ -7,7 +8,15 @@ SnapshotResult {
     matched_ranges: [
         "1:1-1:21",
     ],
-    rewritten_files: [],
+    rewritten_files: [
+        OutputFile {
+            messages: [],
+            variables: [],
+            source_file: "tests/specs/ts/log.ts",
+            content: ";\n",
+            byte_ranges: None,
+        },
+    ],
     created_files: [],
 }
 
diff --git a/crates/biome_grit_patterns/tests/specs/ts/patternDefinition.snap b/crates/biome_grit_patterns/tests/specs/ts/patternDefinition.snap
index 36ecd4420476..71f9521fe2e6 100644
--- a/crates/biome_grit_patterns/tests/specs/ts/patternDefinition.snap
+++ b/crates/biome_grit_patterns/tests/specs/ts/patternDefinition.snap
@@ -1,5 +1,6 @@
 ---
 source: crates/biome_grit_patterns/tests/spec_tests.rs
+assertion_line: 94
 expression: patternDefinition
 ---
 SnapshotResult {
@@ -7,6 +8,14 @@ SnapshotResult {
     matched_ranges: [
         "1:1-1:29",
     ],
-    rewritten_files: [],
+    rewritten_files: [
+        OutputFile {
+            messages: [],
+            variables: [],
+            source_file: "tests/specs/ts/patternDefinition.ts",
+            content: "console.info('Hello, world!');\nconsole.warn('Can you hear me?');\n",
+            byte_ranges: None,
+        },
+    ],
     created_files: [],
 }
diff --git a/crates/biome_grit_patterns/tests/specs/ts/rawSnippet.snap b/crates/biome_grit_patterns/tests/specs/ts/rawSnippet.snap
index 159eab2ef19e..dc9236956f54 100644
--- a/crates/biome_grit_patterns/tests/specs/ts/rawSnippet.snap
+++ b/crates/biome_grit_patterns/tests/specs/ts/rawSnippet.snap
@@ -1,5 +1,6 @@
 ---
 source: crates/biome_grit_patterns/tests/spec_tests.rs
+assertion_line: 94
 expression: rawSnippet
 ---
 SnapshotResult {
@@ -7,6 +8,19 @@ SnapshotResult {
     matched_ranges: [
         "1:1-1:29",
     ],
-    rewritten_files: [],
+    rewritten_files: [
+        OutputFile {
+            messages: [],
+            variables: [],
+            source_file: "tests/specs/ts/rawSnippet.ts",
+            content: "if(' // I like broken code\";\n",
+            byte_ranges: None,
+        },
+    ],
     created_files: [],
 }
+
+## Logs
+
+Message: unterminated string literalSyntax: 
+Message: expected `)` but instead the file endsSyntax:
diff --git a/crates/biome_grit_patterns/tests/specs/ts/regex.snap b/crates/biome_grit_patterns/tests/specs/ts/regex.snap
index ca2afac0acce..6e1a576daf94 100644
--- a/crates/biome_grit_patterns/tests/specs/ts/regex.snap
+++ b/crates/biome_grit_patterns/tests/specs/ts/regex.snap
@@ -1,5 +1,6 @@
 ---
 source: crates/biome_grit_patterns/tests/spec_tests.rs
+assertion_line: 94
 expression: regex
 ---
 SnapshotResult {
@@ -7,6 +8,14 @@ SnapshotResult {
     matched_ranges: [
         "2:1-2:27",
     ],
-    rewritten_files: [],
+    rewritten_files: [
+        OutputFile {
+            messages: [],
+            variables: [],
+            source_file: "tests/specs/ts/regex.ts",
+            content: "console.log(\"Hello, Bert\");\nconsole.log(Lucy, Hello);\n",
+            byte_ranges: None,
+        },
+    ],
     created_files: [],
 }
diff --git a/crates/biome_grit_patterns/tests/specs/ts/whereClause.snap b/crates/biome_grit_patterns/tests/specs/ts/whereClause.snap
index f37d4b1f7b77..708ff8dc8df9 100644
--- a/crates/biome_grit_patterns/tests/specs/ts/whereClause.snap
+++ b/crates/biome_grit_patterns/tests/specs/ts/whereClause.snap
@@ -1,5 +1,6 @@
 ---
 source: crates/biome_grit_patterns/tests/spec_tests.rs
+assertion_line: 94
 expression: whereClause
 ---
 SnapshotResult {
@@ -7,6 +8,14 @@ SnapshotResult {
     matched_ranges: [
         "2:1-2:29",
     ],
-    rewritten_files: [],
+    rewritten_files: [
+        OutputFile {
+            messages: [],
+            variables: [],
+            source_file: "tests/specs/ts/whereClause.ts",
+            content: "console.log('Hi');\n;\n",
+            byte_ranges: None,
+        },
+    ],
     created_files: [],
 }
diff --git a/crates/biome_lsp/src/server.tests.rs b/crates/biome_lsp/src/server.tests.rs
index fe27f249102c..f76fd15c7173 100644
--- a/crates/biome_lsp/src/server.tests.rs
+++ b/crates/biome_lsp/src/server.tests.rs
@@ -1841,6 +1841,79 @@ async fn plugin_load_error_show_message() -> Result<()> {
     Ok(())
 }
 
+#[tokio::test]
+async fn plugin_rewrite_pull_diagnostics() -> Result<()> {
+    let fs = MemoryFileSystem::default();
+
+    let config = r#"{
+        "plugins": ["useConsoleInfo.grit"],
+        "linter": {
+            "rules": { "recommended": false }
+        }
+    }"#;
+
+    let plugin = br#"language js
+
+`console.log($msg)` as $call where {
+    register_diagnostic(
+        span = $call,
+        message = "Use console.info instead of console.log.",
+        severity = "warn"
+    ),
+    $call => `console.info($msg)`
+}"#;
+
+    fs.insert(to_utf8_file_path_buf(uri!("biome.json")), config);
+    fs.insert(to_utf8_file_path_buf(uri!("useConsoleInfo.grit")), plugin);
+
+    let factory = ServerFactory::new_with_fs(Arc::new(fs));
+    let (service, client) = factory.create().into_inner();
+
+    let (stream, sink) = client.split();
+    let mut server = Server::new(service);
+
+    let (sender, mut receiver) = channel(CHANNEL_BUFFER_SIZE);
+    let reader = tokio::spawn(client_handler(stream, sink, sender));
+
+    server.initialize().await?;
+    server.initialized().await?;
+
+    server.load_configuration().await?;
+
+    server
+        .open_named_document("console.log(\"hello\");", uri!("document.js"), "javascript")
+        .await?;
+
+    let notification = wait_for_notification(&mut receiver, |n| n.is_publish_diagnostics()).await;
+
+    // Verify that the plugin diagnostic is emitted
+    if let Some(ServerNotification::PublishDiagnostics(params)) = &notification {
+        assert!(
+            !params.diagnostics.is_empty(),
+            "Expected at least one diagnostic"
+        );
+        let diag = &params.diagnostics[0];
+        assert_eq!(diag.severity, Some(lsp::DiagnosticSeverity::WARNING));
+        assert_eq!(
+            diag.code,
+            Some(lsp::NumberOrString::String(String::from("plugin")))
+        );
+        assert!(
+            diag.message.contains("console.info"),
+            "Diagnostic message should mention console.info, got: {}",
+            diag.message
+        );
+    } else {
+        panic!("Expected PublishDiagnostics, got {notification:?}");
+    }
+
+    server.close_document().await?;
+    server.shutdown().await?;
+    reader.abort();
+
+    Ok(())
+}
+
 #[tokio::test]
 async fn pull_diagnostics_for_css_files() -> Result<()> {
     let fs = MemoryFileSystem::default();
diff --git a/crates/biome_plugin_loader/src/analyzer_grit_plugin.rs b/crates/biome_plugin_loader/src/analyzer_grit_plugin.rs
index ee2b0ad8b179..50ef127db8a1 100644
--- a/crates/biome_plugin_loader/src/analyzer_grit_plugin.rs
+++ b/crates/biome_plugin_loader/src/analyzer_grit_plugin.rs
@@ -1,13 +1,15 @@
 use crate::{AnalyzerPlugin, PluginDiagnostic};
-use biome_analyze::{PluginTargetLanguage, RuleDiagnostic};
+use biome_analyze::{
+    PluginActionData, PluginDiagnosticEntry, PluginEvalResult, PluginTargetLanguage, RuleDiagnostic,
+};
 use biome_console::markup;
 use biome_css_syntax::{CssRoot, CssSyntaxNode};
-use biome_diagnostics::{Severity, category};
+use biome_diagnostics::{Applicability, Severity, category};
 use biome_fs::FileSystem;
 use biome_grit_patterns::{
     BuiltInFunction, CompilePatternOptions, GritBinding, GritExecContext, GritPattern, GritQuery,
-    GritQueryContext, GritQueryState, GritResolvedPattern, GritTargetFile, GritTargetLanguage,
-    compile_pattern_with_options,
+    GritQueryContext, GritQueryEffect, GritQueryState, GritResolvedPattern, GritTargetFile,
+    GritTargetLanguage, compile_pattern_with_options,
 };
 use biome_js_syntax::{AnyJsRoot, JsSyntaxNode};
 use biome_json_syntax::{JsonRoot, JsonSyntaxNode};
@@ -31,7 +33,7 @@ impl AnalyzerGritPlugin {
             .with_extra_built_ins(vec![
                 BuiltInFunction::new(
                     "register_diagnostic",
-                    &["span", "message", "severity"],
+                    &["span", "message", "severity", "fix_kind"],
                     Box::new(register_diagnostic),
                 )
                 .as_predicate(),
@@ -68,19 +70,34 @@ impl AnalyzerPlugin for AnalyzerGritPlugin {
         }
     }
 
-    fn evaluate(&self, node: AnySyntaxNode, path: Arc<Utf8PathBuf>) -> Vec<RuleDiagnostic> {
+    fn evaluate(&self, node: AnySyntaxNode, path: Arc<Utf8PathBuf>) -> PluginEvalResult {
         let name: &str = self.grit_query.name.as_deref().unwrap_or("anonymous");
 
-        let root = match self.language() {
+        let (root, source_range, original_text) = match self.language() {
             PluginTargetLanguage::JavaScript => node
                 .downcast_ref::<JsSyntaxNode>()
-                .and_then(|node| node.as_send()),
+                .map(|node| {
+                    let range = node.text_range_with_trivia();
+                    let text = node.text_with_trivia().to_string();
+                    (node.as_send(), range, text)
+                })
+                .unwrap(),
             PluginTargetLanguage::Css => node
                 .downcast_ref::<CssSyntaxNode>()
-                .and_then(|node| node.as_send()),
+                .map(|node| {
+                    let range = node.text_range_with_trivia();
+                    let text = node.text_with_trivia().to_string();
+                    (node.as_send(), range, text)
+                })
+                .unwrap(),
             PluginTargetLanguage::Json => node
                 .downcast_ref::<JsonSyntaxNode>()
-                .and_then(|node| node.as_send()),
+                .map(|node| {
+                    let range = node.text_range_with_trivia();
+                    let text = node.text_with_trivia().to_string();
+                    (node.as_send(), range, text)
+                })
+                .unwrap(),
         };
 
         let parse = AnyParse::Node(NodeParse::new(root.unwrap(), vec![]));
@@ -88,43 +105,82 @@ impl AnalyzerPlugin for AnalyzerGritPlugin {
 
         match self.grit_query.execute(file) {
             Ok(result) => {
-                let mut diagnostics: Vec<_> = result
-                    .logs
-                    .iter()
-                    .map(|log| {
-                        RuleDiagnostic::new(
+                // Log entries never consume actions.
+                let log_entries = result.logs.iter().map(|log| PluginDiagnosticEntry {
+                    diagnostic: RuleDiagnostic::new(
                         category!("plugin"),
                         log.range.map(from_grit_range),
                         markup!(<Emphasis>{name}</Emphasis>" logged: "<Info>{log.message}</Info>),
                     )
                     .verbose()
+                    .subcategory(name.to_string()),
+                    action: None,
+                });
+
+                // Convert rewrite effects to plugin actions.
+                let mut actions: Vec<_> = result
+                    .effects
+                    .iter()
+                    .filter_map(|effect| match effect {
+                        GritQueryEffect::Rewrite(rewrite) => Some(PluginActionData {
+                            source_range,
+                            original_text: original_text.clone(),
+                            rewritten_text: rewrite.rewritten.content.clone(),
+                            message: format!("Rewrite suggested by plugin `{name}`"),
+                            applicability: Applicability::MaybeIncorrect,
+                        }),
+                        _ => None,
                     })
-                    .chain(result.diagnostics)
-                    .map(|diagnostics| diagnostics.subcategory(name.to_string()))
                     .collect();
 
-                if diagnostics
-                    .iter()
-                    .any(|diagnostic| diagnostic.span().is_none())
-                {
-                    diagnostics.push(RuleDiagnostic::new(
-                        category!("plugin"),
-                        None::<TextRange>,
-                        markup!(
-                            "Plugin "<Emphasis>{name}</Emphasis>" reported one or more diagnostics, "
-                            "but it didn't specify a valid "<Emphasis>"span"</Emphasis>". "
-                            "Diagnostics have been shown without context."
+                // Pair each real diagnostic with its action by position.
+                let mut action_iter = actions.drain(..);
+                let diag_entries: Vec<_> = result
+                    .diagnostics
+                    .into_iter()
+                    .map(|(diagnostic, applicability)| {
+                        let mut action = action_iter.next();
+                        if let Some(ref mut action) = action {
+                            action.applicability = applicability;
+                        }
+                        PluginDiagnosticEntry {
+                            diagnostic: diagnostic.subcategory(name.to_string()),
+                            action,
+                        }
+                    })
+                    .collect();
+
+                let has_missing_span = diag_entries.iter().any(|e| e.diagnostic.span().is_none());
+
+                let mut entries: Vec<_> = log_entries.chain(diag_entries).collect();
+
+                if has_missing_span {
+                    entries.push(PluginDiagnosticEntry {
+                        diagnostic: RuleDiagnostic::new(
+                            category!("plugin"),
+                            None::<TextRange>,
+                            markup!(
+                                "Plugin "<Emphasis>{name}</Emphasis>" reported one or more diagnostics, "
+                                "but it didn't specify a valid "<Emphasis>"span"</Emphasis>". "
+                                "Diagnostics have been shown without context."
+                            ),
                         ),
-                    ));
+                        action: None,
+                    });
                 }
 
-                diagnostics
+                PluginEvalResult { entries }
             }
-            Err(error) => vec![RuleDiagnostic::new(
-                category!("plugin"),
-                None::<TextRange>,
-                markup!(<Emphasis>{name}</Emphasis>" errored: "<Error>{error.to_string()}</Error>),
-            )],
+            Err(error) => PluginEvalResult {
+                entries: vec![PluginDiagnosticEntry {
+                    diagnostic: RuleDiagnostic::new(
+                        category!("plugin"),
+                        None::<TextRange>,
+                        markup!(<Emphasis>{name}</Emphasis>" errored: "<Error>{error.to_string()}</Error>),
+                    ),
+                    action: None,
+                }],
+            },
         }
     }
 }
@@ -141,11 +197,11 @@ fn register_diagnostic<'a>(
 ) -> Result<GritResolvedPattern<'a>, GritPatternError> {
     let args = GritResolvedPattern::from_patterns(args, state, context, logs)?;
 
-    let (span_node, message, severity) = match args.as_slice() {
-        [Some(span), Some(message), severity] => (span, message, severity),
+    let (span_node, message, severity, fix_kind) = match args.as_slice() {
+        [Some(span), Some(message), severity, fix_kind] => (span, message, severity, fix_kind),
         _ => {
             return Err(GritPatternError::new(
-                "register_diagnostic() takes 2 required arguments: span and message, and an optional severity",
+                "register_diagnostic() takes 2 required arguments: span and message, and optional severity and fix_kind",
             ));
         }
     };
@@ -174,14 +230,41 @@ fn register_diagnostic<'a>(
     };
     let message = message.as_deref().unwrap_or("(no message)");
 
-    let severity = severity
-        .as_ref()
-        .and_then(|severity| severity.text(&state.files, &context.lang).ok())
-        .and_then(|severity| Severity::from_str(severity.as_ref()).ok())
-        .unwrap_or(Severity::Error);
+    let severity = match severity.as_ref() {
+        None => Severity::Error,
+        Some(severity) => {
+            let text = severity
+                .text(&state.files, &context.lang)
+                .map_err(|e| GritPatternError::new(format!("failed to read severity: {e}")))?;
+            Severity::from_str(text.as_ref()).map_err(|_| {
+                GritPatternError::new(format!(
+                    "invalid severity \"{text}\", expected \"hint\", \"info\", \"warn\", or \"error\""
+                ))
+            })?
+        }
+    };
+
+    let applicability = match fix_kind.as_ref() {
+        None => Applicability::MaybeIncorrect,
+        Some(fix_kind) => {
+            let text = fix_kind
+                .text(&state.files, &context.lang)
+                .map_err(|e| GritPatternError::new(format!("failed to read fix_kind: {e}")))?;
+            match text.as_ref() {
+                "safe" => Applicability::Always,
+                "unsafe" => Applicability::MaybeIncorrect,
+                other => {
+                    return Err(GritPatternError::new(format!(
+                        "invalid fix_kind \"{other}\", expected \"safe\" or \"unsafe\""
+                    )));
+                }
+            }
+        }
+    };
 
     context.add_diagnostic(
         RuleDiagnostic::new(category!("plugin"), span, message).with_severity(severity),
+        applicability,
     );
 
     Ok(span_node.clone())
diff --git a/crates/biome_plugin_loader/src/analyzer_js_plugin.rs b/crates/biome_plugin_loader/src/analyzer_js_plugin.rs
index 4013f672f8b6..0499d83fd5d8 100644
--- a/crates/biome_plugin_loader/src/analyzer_js_plugin.rs
+++ b/crates/biome_plugin_loader/src/analyzer_js_plugin.rs
@@ -6,7 +6,9 @@ use boa_engine::object::builtins::JsFunction;
 use boa_engine::{JsNativeError, JsResult, JsString, JsValue};
 use camino::{Utf8Path, Utf8PathBuf};
 
-use biome_analyze::{AnalyzerPlugin, PluginTargetLanguage, RuleDiagnostic};
+use biome_analyze::{
+    AnalyzerPlugin, PluginDiagnosticEntry, PluginEvalResult, PluginTargetLanguage, RuleDiagnostic,
+};
 use biome_console::markup;
 use biome_diagnostics::category;
 use biome_js_runtime::JsExecContext;
@@ -85,25 +87,30 @@ impl AnalyzerPlugin for AnalyzerJsPlugin {
             .collect()
     }
 
-    fn evaluate(&self, _node: AnySyntaxNode, path: Arc<Utf8PathBuf>) -> Vec<RuleDiagnostic> {
+    fn evaluate(&self, _node: AnySyntaxNode, path: Arc<Utf8PathBuf>) -> PluginEvalResult {
         let mut plugin = match self
             .loaded
             .get_mut_or_try_init(|| load_plugin(self.fs.clone(), &self.path))
         {
             Ok(plugin) => plugin,
             Err(err) => {
-                return vec![RuleDiagnostic::new(
-                    category!("plugin"),
-                    None::<TextRange>,
-                    markup!("Could not load the plugin: "<Error>{err.to_string()}</Error>),
-                )];
+                return PluginEvalResult {
+                    entries: vec![PluginDiagnosticEntry {
+                        diagnostic: RuleDiagnostic::new(
+                            category!("plugin"),
+                            None::<TextRange>,
+                            markup!("Could not load the plugin: "<Error>{err.to_string()}</Error>),
+                        ),
+                        action: None,
+                    }],
+                };
             }
         };
 
         let plugin = plugin.deref_mut();
 
         // TODO: pass the AST to the plugin
-        plugin
+        let diagnostics = plugin
             .ctx
             .call_function(
                 &plugin.entrypoint,
@@ -119,7 +126,17 @@ impl AnalyzerPlugin for AnalyzerJsPlugin {
                     )]
                 },
                 |_| plugin.ctx.pull_diagnostics(),
-            )
+            );
+
+        let entries = diagnostics
+            .into_iter()
+            .map(|diagnostic| PluginDiagnosticEntry {
+                diagnostic,
+                action: None,
+            })
+            .collect();
+
+        PluginEvalResult { entries }
     }
 }
 
@@ -190,8 +207,10 @@ mod tests {
             })
         };
 
-        let mut diagnostics = worker1.join().unwrap();
-        diagnostics.extend(worker2.join().unwrap());
+        let result1 = worker1.join().unwrap();
+        let result2 = worker2.join().unwrap();
+        let mut diagnostics: Vec<_> = result1.entries.into_iter().map(|e| e.diagnostic).collect();
+        diagnostics.extend(result2.entries.into_iter().map(|e| e.diagnostic));
 
         assert_eq!(diagnostics.len(), 2);
         snap_diagnostics(
diff --git a/crates/biome_service/src/file_handlers/css.rs b/crates/biome_service/src/file_handlers/css.rs
index e8fd579c3bb8..3f50be34a8ee 100644
--- a/crates/biome_service/src/file_handlers/css.rs
+++ b/crates/biome_service/src/file_handlers/css.rs
@@ -725,6 +725,8 @@ pub(crate) fn fix_all(params: FixAllParams) -> Result<FixFileResult, WorkspaceEr
             |signal| process_fix_all.process_signal(signal),
         );
 
+        let plugin_text_edit = action.as_ref().and_then(|a| a.text_edit.clone());
+
         let result = process_fix_all.process_action(action, |root| {
             tree = match AnyCssRoot::cast(root) {
                 Some(tree) => tree,
@@ -734,6 +736,17 @@ pub(crate) fn fix_all(params: FixAllParams) -> Result<FixFileResult, WorkspaceEr
         })?;
 
         if result.is_none() {
+            if let Some(new_text) = process_fix_all
+                .apply_plugin_text_edit(plugin_text_edit, &tree.syntax().to_string())?
+            {
+                let options = params
+                    .settings
+                    .parse_options::<CssLanguage>(params.biome_path, &params.document_file_source);
+                let parse = biome_css_parser::parse_css(&new_text, file_source, options);
+                tree = parse.tree();
+                continue;
+            }
+
             return process_fix_all.finish(|| {
                 Ok(if params.should_format {
                     Either::Left(format_node(
diff --git a/crates/biome_service/src/file_handlers/javascript.rs b/crates/biome_service/src/file_handlers/javascript.rs
index b9cff37bdd31..3fee1c1f8572 100644
--- a/crates/biome_service/src/file_handlers/javascript.rs
+++ b/crates/biome_service/src/file_handlers/javascript.rs
@@ -1094,6 +1094,10 @@ pub(crate) fn fix_all(params: FixAllParams) -> Result<FixFileResult, WorkspaceEr
             |signal| process_fix_all.process_signal(signal),
         );
 
+        // Extract plugin text_edit before the action is consumed by process_action,
+        // since plugin rewrites use text_edit instead of tree mutations.
+        let plugin_text_edit = action.as_ref().and_then(|a| a.text_edit.clone());
+
         let result = process_fix_all.process_action(action, |root| {
             tree = match AnyJsRoot::cast(root) {
                 Some(tree) => tree,
@@ -1103,6 +1107,19 @@ pub(crate) fn fix_all(params: FixAllParams) -> Result<FixFileResult, WorkspaceEr
         })?;
 
         if result.is_none() {
+            // No tree mutation was applied. Check if there's a plugin text edit
+            // to apply (plugin rewrites produce text edits, not tree mutations).
+            if let Some(new_text) = process_fix_all
+                .apply_plugin_text_edit(plugin_text_edit, &tree.syntax().to_string())?
+            {
+                let options = params
+                    .settings
+                    .parse_options::<JsLanguage>(params.biome_path, &params.document_file_source);
+                let parse = biome_js_parser::parse(&new_text, file_source, options);
+                tree = parse.tree();
+                continue;
+            }
+
             return process_fix_all.finish(|| {
                 Ok(if params.should_format {
                     Either::Left(format_node(
diff --git a/crates/biome_service/src/file_handlers/json.rs b/crates/biome_service/src/file_handlers/json.rs
index 1846c20263ed..a0772d94a848 100644
--- a/crates/biome_service/src/file_handlers/json.rs
+++ b/crates/biome_service/src/file_handlers/json.rs
@@ -715,6 +715,8 @@ fn fix_all(params: FixAllParams) -> Result<FixFileResult, WorkspaceError> {
             |signal| process_fix_all.process_signal(signal),
         );
 
+        let plugin_text_edit = action.as_ref().and_then(|a| a.text_edit.clone());
+
         let result = process_fix_all.process_action(action, |root| {
             tree = match JsonRoot::cast(root) {
                 Some(tree) => tree,
@@ -724,6 +726,17 @@ fn fix_all(params: FixAllParams) -> Result<FixFileResult, WorkspaceError> {
         })?;
 
         if result.is_none() {
+            if let Some(new_text) = process_fix_all
+                .apply_plugin_text_edit(plugin_text_edit, &tree.syntax().to_string())?
+            {
+                let options = params
+                    .settings
+                    .parse_options::<JsonLanguage>(params.biome_path, &params.document_file_source);
+                let parse = biome_json_parser::parse_json(&new_text, options);
+                tree = parse.tree();
+                continue;
+            }
+
             return process_fix_all.finish(|| {
                 Ok(if params.should_format {
                     Either::Left(format_node(
diff --git a/crates/biome_service/src/file_handlers/mod.rs b/crates/biome_service/src/file_handlers/mod.rs
index a6e0048f810b..050a42b7c8f6 100644
--- a/crates/biome_service/src/file_handlers/mod.rs
+++ b/crates/biome_service/src/file_handlers/mod.rs
@@ -49,6 +49,7 @@ use biome_parser::AnyParse;
 use biome_project_layout::ProjectLayout;
 use biome_rowan::{FileSourceError, NodeCache, SendNode, SyntaxNode, TokenText};
 use biome_string_case::StrLikeExtension;
+use biome_text_edit::TextEdit;
 use camino::Utf8Path;
 use either::Either;
 use grit::GritFileHandler;
@@ -831,14 +832,65 @@ impl<'a> ProcessFixAll<'a> {
                             },
                         ));
                     };
-                };
 
-                Ok(Some(()))
+                    Ok(Some(()))
+                } else {
+                    // Mutation was empty (no tree changes), signal no fix applied
+                    Ok(None)
+                }
             }
             None => Ok(None),
         }
     }
 
+    /// Record a text-edit-based fix (e.g. from a plugin rewrite) that was
+    /// applied outside of the normal mutation path.
+    pub(crate) fn record_text_edit_fix(
+        &mut self,
+        range: TextRange,
+        new_text_len: u32,
+        rule_name: Option<(&'static str, &'static str)>,
+    ) -> Result<(), WorkspaceError> {
+        self.actions.push(FixAction {
+            rule_name: rule_name.map(|(g, r)| (Cow::Borrowed(g), Cow::Borrowed(r))),
+            range,
+        });
+        if !self.growth_guard.check(new_text_len) {
+            return Err(WorkspaceError::RuleError(
+                RuleError::ConflictingRuleFixesError {
+                    rules: self
+                        .actions
+                        .iter()
+                        .rev()
+                        .take(10)
+                        .filter_map(|action| action.rule_name.clone())
+                        .collect::<HashSet<_>>()
+                        .into_iter()
+                        .collect(),
+                },
+            ));
+        }
+        Ok(())
+    }
+
+    /// Apply a plugin text edit if present and the text actually changed.
+    /// Returns `Some(new_text)` if the edit was applied, `None` otherwise.
+    pub(crate) fn apply_plugin_text_edit(
+        &mut self,
+        text_edit: Option<(TextRange, TextEdit)>,
+        current_text: &str,
+    ) -> Result<Option<String>, WorkspaceError> {
+        let Some((range, edit)) = text_edit else {
+            return Ok(None);
+        };
+        let new_text = edit.new_string(current_text);
+        if new_text == current_text {
+            return Ok(None);
+        }
+        self.record_text_edit_fix(range, new_text.len() as u32, Some(("plugin", "gritql")))?;
+        Ok(Some(new_text))
+    }
+
     /// Finish processing the fix all actions. Returns the result of the fix-all actions. The `format_tree`
     /// is a closure that must return the new code (formatted, if needed).
     pub(crate) fn finish<F, C>(self, format_tree: F) -> Result<FixFileResult, WorkspaceError>