diff --git a/CHANGELOG.md b/CHANGELOG.md
index caee3bc9..fdbcbc9f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,16 @@ All notable changes to rtk (Rust Token Killer) will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+### Features
+
+* **init:** add Cursor support (`rtk init --cursor`) ([#213](https://github.com/rtk-ai/rtk/issues/213))
+  * Hook script supports both Claude Code and Cursor preToolUse (auto-detect payload)
+  * Installs hook + rules (rtk.mdc) + hooks.json for global (~/.cursor) or project (.cursor)
+  * `rtk init --cursor --show` and `rtk init --cursor -g --uninstall`
+* **init:** refactor for multi-agent: `InitTarget` enum, shared `patch_json_registry`, `ensure_agent_hook_installed` (enables adding Codex, OpenCode, etc.)
+
 ## [0.22.2](https://github.com/rtk-ai/rtk/compare/v0.22.1...v0.22.2) (2026-02-20)
 
 
diff --git a/CLAUDE.md b/CLAUDE.md
index b8cf94f0..760143ab 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -128,9 +128,10 @@ main.rs (CLI entry)
   - Priority: env var > config file > default location
 
 **4. Configuration System** (src/config.rs, src/init.rs)
-- Manages CLAUDE.md initialization (global vs local)
+- Manages CLAUDE.md initialization (global vs local) and Cursor (hooks + rules)
 - Reads ~/.config/rtk/config.toml for user preferences
-- `rtk init` command bootstraps LLM integration
+- `rtk init` bootstraps Claude Code; `rtk init --cursor` bootstraps Cursor (hooks.json + rtk.mdc)
+- **Adding a new agent (Codex, OpenCode, etc.)**: Add an `InitTarget` variant in init.rs, implement `run_<agent>_mode` (reuse `ensure_agent_hook_installed`, `patch_json_registry` with agent-specific is_present/insert), and branch in `show_config`/`uninstall`. See doc comment on `InitTarget` in src/init.rs.
 - **New**: `tracking.database_path` field for custom DB location
 
 **5. Tee Output Recovery** (src/tee.rs)
diff --git a/README.md b/README.md
index b6537eab..2b3f6f9a 100644
--- a/README.md
+++ b/README.md
@@ -373,6 +373,8 @@ Four strategies applied per command type:
 | `rtk init -g --claude-md` | Global | ❌ | ❌ | Full (137 lines) | ~2000 | Legacy compatibility |
 | `rtk init -g --hook-only` | Global | ✅ | ❌ | Nothing | 0 | Minimal setup, hook-only |
 | `rtk init` | Local | ❌ | ❌ | Full (137 lines) | ~2000 | Single project, no hook |
+| `rtk init --cursor` | Project | Cursor hook | rtk.mdc | .cursor/hooks.json | 0 | Cursor Agent (preToolUse) |
+| `rtk init --cursor -g` | Global | Cursor hook | rtk.mdc | ~/.cursor/hooks.json | 0 | Cursor Agent, all projects |
 
 ```bash
 rtk init --show         # Show current configuration
@@ -401,6 +403,15 @@ rtk init -g --hook-only     # Hook only, no RTK.md
 rtk init -g --uninstall     # Remove all RTK artifacts
 ```
 
+**Cursor** (Agent / Cmd+K):
+```bash
+rtk init --cursor           # Project: .cursor/hooks + .cursor/rules/rtk.mdc + .cursor/hooks.json
+rtk init --cursor -g        # Global: ~/.cursor/ (same layout)
+rtk init --cursor --show    # Show Cursor RTK status (global + project)
+rtk init --cursor -g --uninstall   # Remove global Cursor RTK
+```
+Uses the same rewrite hook (preToolUse for Shell); Cursor runs it via `hooks.json` and gets rules from `rtk.mdc`. Restart Cursor after init.
+
 **What is settings.json?**
 Claude Code configuration file that registers the RTK hook. The hook transparently rewrites commands (e.g., `git status` → `rtk git status`) before execution. Without this registration, Claude won't use the hook.
 
diff --git a/hooks/rtk-cursor-rules.mdc b/hooks/rtk-cursor-rules.mdc
new file mode 100644
index 00000000..9f4b6711
--- /dev/null
+++ b/hooks/rtk-cursor-rules.mdc
@@ -0,0 +1,39 @@
+---
+description: Use rtk (Rust Token Killer) to wrap CLI commands for token-optimized output (60-90% savings)
+globs: ["**/*"]
+alwaysApply: true
+---
+
+# RTK Command Proxy
+
+When running shell commands, prefer `rtk <cmd>` over raw commands for token-optimized output. rtk is a CLI proxy that reduces LLM token consumption by 60-90% through smart filtering.
+
+Leading env var assignments should be preserved (e.g., `FOO=bar cargo test` → `FOO=bar rtk cargo test`).
+
+## Custom Rules (rtk err — errors-only wrapper)
+
+These commands have no native rtk filter. Wrap with `rtk err` to show only stderr/errors:
+
+- `pre-commit ...` → `rtk err pre-commit ...`
+- `make ...` → `rtk err make ...`
+- `go generate ...` → `rtk err go generate ...`
+- `pnpm run <script>` → `rtk err pnpm run <script>`
+
+## Native RTK Rewrites
+
+- **Git**: `git <subcmd>` → `rtk git <subcmd>` (all subcommands)
+- **GitHub CLI**: `gh pr|issue|run|api|release ...` → `rtk gh ...`
+- **Cargo**: `cargo test|build|clippy|check|install|fmt` → `rtk cargo ...`
+- **File ops**: `cat` → `rtk read`, `rg|grep` → `rtk grep`, `ls` → `rtk ls`, `tree` → `rtk tree`, `find|diff` → `rtk find|diff`
+- **JS/TS**: `vitest|tsc|eslint|prettier|playwright|prisma|pnpm list|outdated` → `rtk vitest|tsc|lint|prettier|playwright|prisma|pnpm ...`
+- **Python**: `pytest|ruff check|format|pip|uv pip` → `rtk pytest|ruff|pip ...`
+- **Go**: `go test|build|vet` → `rtk go ...`, `golangci-lint` → `rtk golangci-lint`
+- **Containers**: `docker compose|docker ps|images|logs|...` → `rtk docker ...`, `kubectl get|logs|...` → `rtk kubectl ...`
+- **Network**: `curl|wget` → `rtk curl|wget`
+
+## Exceptions — Do NOT wrap with rtk
+
+- Commands already prefixed with `rtk`
+- Commands with heredocs (`<<`)
+- Interactive commands (e.g., `git rebase -i`)
+- Commands that must produce exact raw output for parsing by other tools
diff --git a/hooks/rtk-rewrite.sh b/hooks/rtk-rewrite.sh
index 59e02caa..5e145846 100644
--- a/hooks/rtk-rewrite.sh
+++ b/hooks/rtk-rewrite.sh
@@ -1,7 +1,7 @@
 #!/bin/bash
-# RTK auto-rewrite hook for Claude Code PreToolUse:Bash
+# RTK auto-rewrite hook for Claude Code PreToolUse:Bash and Cursor preToolUse (Shell).
 # Transparently rewrites raw commands to their rtk equivalents.
-# Outputs JSON with updatedInput to modify the command before execution.
+# Outputs JSON: Claude = hookSpecificOutput.updatedInput; Cursor = decision + updated_input.
 
 # Guards: skip silently if dependencies missing
 if ! command -v rtk &>/dev/null || ! command -v jq &>/dev/null; then
@@ -11,6 +11,19 @@ fi
 set -euo pipefail
 
 INPUT=$(cat)
+# Detect Cursor vs Claude Code from payload shape.
+# Cursor payloads include "hook_event_name" or "cursor_version" as top-level strings.
+# Claude Code payloads have none of these; they nest event info inside hookSpecificOutput.
+# If both agents add overlapping fields in the future, set RTK_HOOK_MODE=cursor|claude to override.
+CURSOR_MODE=
+if [ "${RTK_HOOK_MODE:-}" = "cursor" ]; then
+  CURSOR_MODE=1
+elif [ "${RTK_HOOK_MODE:-}" = "claude" ]; then
+  CURSOR_MODE=
+elif echo "$INPUT" | jq -e '.hook_event_name // .cursor_version | type == "string"' &>/dev/null; then
+  CURSOR_MODE=1
+fi
+
 CMD=$(echo "$INPUT" | jq -r '.tool_input.command // empty')
 
 if [ -z "$CMD" ]; then
@@ -196,14 +209,22 @@ fi
 ORIGINAL_INPUT=$(echo "$INPUT" | jq -c '.tool_input')
 UPDATED_INPUT=$(echo "$ORIGINAL_INPUT" | jq --arg cmd "$REWRITTEN" '.command = $cmd')
 
-# Output the rewrite instruction
-jq -n \
-  --argjson updated "$UPDATED_INPUT" \
-  '{
-    "hookSpecificOutput": {
-      "hookEventName": "PreToolUse",
-      "permissionDecision": "allow",
-      "permissionDecisionReason": "RTK auto-rewrite",
-      "updatedInput": $updated
-    }
-  }'
+# Output the rewrite instruction (format depends on host)
+if [ -n "$CURSOR_MODE" ]; then
+  # Cursor preToolUse: https://cursor.com/docs/agent/hooks
+  jq -n \
+    --argjson updated "$UPDATED_INPUT" \
+    '{ "decision": "allow", "updated_input": $updated }'
+else
+  # Claude Code PreToolUse
+  jq -n \
+    --argjson updated "$UPDATED_INPUT" \
+    '{
+      "hookSpecificOutput": {
+        "hookEventName": "PreToolUse",
+        "permissionDecision": "allow",
+        "permissionDecisionReason": "RTK auto-rewrite",
+        "updatedInput": $updated
+      }
+    }'
+fi
diff --git a/src/init.rs b/src/init.rs
index 961e4ac3..87f9f057 100644
--- a/src/init.rs
+++ b/src/init.rs
@@ -10,6 +10,9 @@ const REWRITE_HOOK: &str = include_str!("../hooks/rtk-rewrite.sh");
 // Embedded slim RTK awareness instructions
 const RTK_SLIM: &str = include_str!("../hooks/rtk-awareness.md");
 
+// Cursor rules file content (.mdc with frontmatter)
+const CURSOR_RTK_RULES: &str = include_str!("../hooks/rtk-cursor-rules.mdc");
+
 /// Control flow for settings.json patching
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum PatchMode {
@@ -27,6 +30,30 @@ pub enum PatchResult {
     Skipped,        // --no-patch flag used
 }
 
+/// Agent/editor target for init.
+///
+/// To add a new target (e.g. Codex, OpenCode):
+/// 1. Add a variant here and extend `from_cursor_flag` or add a new CLI flag and map it in main.rs.
+/// 2. In `run()`, add a branch that calls a new `run_<agent>_mode()`.
+/// 3. Implement: resolve config dir (global vs project), `ensure_agent_hook_installed` + optional rules file,
+///    then `patch_json_registry` with agent-specific is_present/insert/on_skip (reuse same REWRITE_HOOK if hook contract is compatible).
+/// 4. In `show_config()` and `uninstall()`, add a branch for the new target.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum InitTarget {
+    Claude,
+    Cursor,
+}
+
+impl InitTarget {
+    pub fn from_cursor_flag(cursor: bool) -> Self {
+        if cursor {
+            InitTarget::Cursor
+        } else {
+            InitTarget::Claude
+        }
+    }
+}
+
 // Legacy full instructions for backward compatibility (--claude-md mode)
 const RTK_INSTRUCTIONS: &str = r##"<!-- rtk-instructions v2 -->
 # RTK (Rust Token Killer) - Token-Optimized Commands
@@ -170,8 +197,13 @@ pub fn run(
     hook_only: bool,
     patch_mode: PatchMode,
     verbose: u8,
+    target: InitTarget,
 ) -> Result<()> {
-    // Mode selection
+    match target {
+        InitTarget::Cursor => return run_cursor_mode(global, patch_mode, verbose),
+        InitTarget::Claude => {}
+    }
+    // Claude mode selection
     match (claude_md, hook_only) {
         (true, _) => run_claude_md_mode(global, verbose),
         (false, true) => run_hook_only_mode(global, patch_mode, verbose),
@@ -189,43 +221,6 @@ fn prepare_hook_paths() -> Result<(PathBuf, PathBuf)> {
     Ok((hook_dir, hook_path))
 }
 
-/// Write hook file if missing or outdated, return true if changed
-#[cfg(unix)]
-fn ensure_hook_installed(hook_path: &Path, verbose: u8) -> Result<bool> {
-    let changed = if hook_path.exists() {
-        let existing = fs::read_to_string(hook_path)
-            .with_context(|| format!("Failed to read existing hook: {}", hook_path.display()))?;
-
-        if existing == REWRITE_HOOK {
-            if verbose > 0 {
-                eprintln!("Hook already up to date: {}", hook_path.display());
-            }
-            false
-        } else {
-            fs::write(hook_path, REWRITE_HOOK)
-                .with_context(|| format!("Failed to write hook to {}", hook_path.display()))?;
-            if verbose > 0 {
-                eprintln!("Updated hook: {}", hook_path.display());
-            }
-            true
-        }
-    } else {
-        fs::write(hook_path, REWRITE_HOOK)
-            .with_context(|| format!("Failed to write hook to {}", hook_path.display()))?;
-        if verbose > 0 {
-            eprintln!("Created hook: {}", hook_path.display());
-        }
-        true
-    };
-
-    // Set executable permissions
-    use std::os::unix::fs::PermissionsExt;
-    fs::set_permissions(hook_path, fs::Permissions::from_mode(0o755))
-        .with_context(|| format!("Failed to set hook permissions: {}", hook_path.display()))?;
-
-    Ok(changed)
-}
-
 /// Idempotent file write: create or update if content differs
 fn write_if_changed(path: &Path, content: &str, name: &str, verbose: u8) -> Result<bool> {
     if path.exists() {
@@ -399,8 +394,11 @@ fn remove_hook_from_settings(verbose: u8) -> Result<bool> {
     Ok(removed)
 }
 
-/// Full uninstall: remove hook, RTK.md, @RTK.md reference, settings.json entry
-pub fn uninstall(global: bool, verbose: u8) -> Result<()> {
+/// Full uninstall: remove Claude or Cursor RTK artifacts
+pub fn uninstall(global: bool, verbose: u8, target: InitTarget) -> Result<()> {
+    if target == InitTarget::Cursor {
+        return uninstall_cursor(global, verbose);
+    }
     if !global {
         anyhow::bail!("Uninstall only works with --global flag. For local projects, manually remove RTK from CLAUDE.md");
     }
@@ -466,83 +464,184 @@ pub fn uninstall(global: bool, verbose: u8) -> Result<()> {
     Ok(())
 }
 
-/// Orchestrator: patch settings.json with RTK hook
-/// Handles reading, checking, prompting, merging, backing up, and atomic writing
-fn patch_settings_json(hook_path: &Path, mode: PatchMode, verbose: u8) -> Result<PatchResult> {
-    let claude_dir = resolve_claude_dir()?;
-    let settings_path = claude_dir.join("settings.json");
-    let hook_command = hook_path
-        .to_str()
-        .context("Hook path contains invalid UTF-8")?;
+/// Remove Cursor RTK: hook script, rules file, hooks.json entry (and any RTK block in other cursor config)
+fn uninstall_cursor(global: bool, verbose: u8) -> Result<()> {
+    let cursor_dir = resolve_cursor_dir(global)?;
+    let mut removed = Vec::new();
+
+    let hook_path = cursor_dir.join("hooks").join("rtk-rewrite.sh");
+    if hook_path.exists() {
+        fs::remove_file(&hook_path)
+            .with_context(|| format!("Failed to remove hook: {}", hook_path.display()))?;
+        removed.push(format!("Hook: {}", hook_path.display()));
+    }
 
-    // Read or create settings.json
-    let mut root = if settings_path.exists() {
-        let content = fs::read_to_string(&settings_path)
-            .with_context(|| format!("Failed to read {}", settings_path.display()))?;
+    let rules_path = cursor_dir.join("rules").join("rtk.mdc");
+    if rules_path.exists() {
+        fs::remove_file(&rules_path)
+            .with_context(|| format!("Failed to remove rules: {}", rules_path.display()))?;
+        removed.push(format!("Rules: {}", rules_path.display()));
+    }
+
+    let hooks_json_path = cursor_dir.join("hooks.json");
+    if remove_cursor_hook_from_json(&hooks_json_path, verbose)? {
+        removed.push("hooks.json: removed RTK preToolUse entry".to_string());
+    }
 
+    if removed.is_empty() {
+        println!("RTK was not installed for Cursor (nothing to remove)");
+    } else {
+        println!("RTK Cursor uninstalled:");
+        for item in &removed {
+            println!("  - {}", item);
+        }
+        println!("\nRestart Cursor to apply changes.");
+    }
+    Ok(())
+}
+
+/// Remove RTK preToolUse entry from Cursor hooks.json; backup and rewrite file. Returns true if entry was removed.
+fn remove_cursor_hook_from_json(hooks_json_path: &Path, verbose: u8) -> Result<bool> {
+    if !hooks_json_path.exists() {
+        return Ok(false);
+    }
+    let content = fs::read_to_string(hooks_json_path)
+        .with_context(|| format!("Failed to read {}", hooks_json_path.display()))?;
+    if content.trim().is_empty() {
+        return Ok(false);
+    }
+    let mut root: serde_json::Value = serde_json::from_str(&content)
+        .with_context(|| format!("Failed to parse {}", hooks_json_path.display()))?;
+    let removed = remove_cursor_hook_from_json_value(&mut root);
+    if removed {
+        let backup = hooks_json_path.with_extension("json.bak");
+        fs::copy(hooks_json_path, &backup)
+            .with_context(|| format!("Failed to backup {}", hooks_json_path.display()))?;
+        if verbose > 0 {
+            eprintln!("Backup: {}", backup.display());
+        }
+        let out = serde_json::to_string_pretty(&root).context("Failed to serialize hooks.json")?;
+        atomic_write(hooks_json_path, &out)?;
+        if verbose > 0 {
+            eprintln!("Removed RTK hook from hooks.json");
+        }
+    }
+    Ok(removed)
+}
+
+/// Remove RTK preToolUse entry from parsed JSON; return true if any entry was removed
+fn remove_cursor_hook_from_json_value(root: &mut serde_json::Value) -> bool {
+    let pre = match root
+        .get_mut("hooks")
+        .and_then(|h| h.get_mut("preToolUse"))
+        .and_then(|p| p.as_array_mut())
+    {
+        Some(arr) => arr,
+        None => return false,
+    };
+    let before = pre.len();
+    pre.retain(|entry| {
+        let cmd = entry.get("command").and_then(|c| c.as_str()).unwrap_or("");
+        !(cmd.contains("rtk-rewrite.sh"))
+    });
+    before != pre.len()
+}
+
+/// Generic JSON registry patcher: read, check, prompt, merge, backup, write.
+/// Shared by Claude (settings.json) and Cursor (hooks.json); add new agents by passing their is_present/insert/on_skip.
+fn patch_json_registry<F1, F2, F3>(
+    path: &Path,
+    hook_command: &str,
+    is_present: F1,
+    insert: F2,
+    on_skip_or_decline: F3,
+    mode: PatchMode,
+    verbose: u8,
+    already_present_msg: &str,
+    success_msg: &str,
+) -> Result<PatchResult>
+where
+    F1: Fn(&serde_json::Value, &str) -> bool,
+    F2: Fn(&mut serde_json::Value, &str),
+    F3: Fn(),
+{
+    let mut root = if path.exists() {
+        let content = fs::read_to_string(path)
+            .with_context(|| format!("Failed to read {}", path.display()))?;
         if content.trim().is_empty() {
             serde_json::json!({})
         } else {
             serde_json::from_str(&content)
-                .with_context(|| format!("Failed to parse {} as JSON", settings_path.display()))?
+                .with_context(|| format!("Failed to parse {} as JSON", path.display()))?
         }
     } else {
         serde_json::json!({})
     };
 
-    // Check idempotency
-    if hook_already_present(&root, &hook_command) {
+    if is_present(&root, hook_command) {
         if verbose > 0 {
-            eprintln!("settings.json: hook already present");
+            eprintln!("{}", already_present_msg);
         }
         return Ok(PatchResult::AlreadyPresent);
     }
 
-    // Handle mode
     match mode {
         PatchMode::Skip => {
-            print_manual_instructions(hook_path);
+            on_skip_or_decline();
             return Ok(PatchResult::Skipped);
         }
         PatchMode::Ask => {
-            if !prompt_user_consent(&settings_path)? {
-                print_manual_instructions(hook_path);
+            if !prompt_user_consent(path)? {
+                on_skip_or_decline();
                 return Ok(PatchResult::Declined);
             }
         }
-        PatchMode::Auto => {
-            // Proceed without prompting
-        }
+        PatchMode::Auto => {}
     }
 
-    // Deep-merge hook
-    insert_hook_entry(&mut root, &hook_command);
-
-    // Backup original
-    if settings_path.exists() {
-        let backup_path = settings_path.with_extension("json.bak");
-        fs::copy(&settings_path, &backup_path)
-            .with_context(|| format!("Failed to backup to {}", backup_path.display()))?;
+    insert(&mut root, hook_command);
+    if path.exists() {
+        let backup = path.with_extension("json.bak");
+        fs::copy(path, &backup).with_context(|| format!("Failed to backup {}", path.display()))?;
         if verbose > 0 {
-            eprintln!("Backup: {}", backup_path.display());
+            eprintln!("Backup: {}", backup.display());
         }
     }
+    let serialized = serde_json::to_string_pretty(&root).context("Failed to serialize JSON")?;
+    atomic_write(path, &serialized)?;
+    println!("\n  {}", success_msg);
+    Ok(PatchResult::Patched)
+}
 
-    // Atomic write
-    let serialized =
-        serde_json::to_string_pretty(&root).context("Failed to serialize settings.json")?;
-    atomic_write(&settings_path, &serialized)?;
+/// Patch Claude Code settings.json with RTK hook
+fn patch_settings_json(hook_path: &Path, mode: PatchMode, verbose: u8) -> Result<PatchResult> {
+    let claude_dir = resolve_claude_dir()?;
+    let settings_path = claude_dir.join("settings.json");
+    let hook_command = hook_path
+        .to_str()
+        .context("Hook path contains invalid UTF-8")?;
 
-    println!("\n  settings.json: hook added");
-    if settings_path.with_extension("json.bak").exists() {
-        println!(
-            "  Backup: {}",
-            settings_path.with_extension("json.bak").display()
-        );
+    let result = patch_json_registry(
+        &settings_path,
+        hook_command,
+        hook_already_present,
+        insert_hook_entry,
+        || print_manual_instructions(hook_path),
+        mode,
+        verbose,
+        "settings.json: hook already present",
+        "settings.json: hook added",
+    )?;
+    if result == PatchResult::Patched {
+        if settings_path.with_extension("json.bak").exists() {
+            println!(
+                "  Backup: {}",
+                settings_path.with_extension("json.bak").display()
+            );
+        }
+        println!("  Restart Claude Code. Test with: git status");
     }
-    println!("  Restart Claude Code. Test with: git status");
-
-    Ok(PatchResult::Patched)
+    Ok(result)
 }
 
 /// Clean up consecutive blank lines (collapse 3+ to 2)
@@ -660,7 +759,7 @@ fn run_default_mode(global: bool, patch_mode: PatchMode, verbose: u8) -> Result<
 
     // 1. Prepare hook directory and install hook
     let (_hook_dir, hook_path) = prepare_hook_paths()?;
-    ensure_hook_installed(&hook_path, verbose)?;
+    ensure_agent_hook_installed(&hook_path, verbose)?;
 
     // 2. Write RTK.md
     write_if_changed(&rtk_md_path, RTK_SLIM, "RTK.md", verbose)?;
@@ -717,7 +816,7 @@ fn run_hook_only_mode(global: bool, patch_mode: PatchMode, verbose: u8) -> Resul
 
     // Prepare and install hook
     let (_hook_dir, hook_path) = prepare_hook_paths()?;
-    ensure_hook_installed(&hook_path, verbose)?;
+    ensure_agent_hook_installed(&hook_path, verbose)?;
 
     println!("\nRTK hook installed (hook-only mode).\n");
     println!("  Hook: {}", hook_path.display());
@@ -980,8 +1079,241 @@ fn resolve_claude_dir() -> Result<PathBuf> {
         .context("Cannot determine home directory. Is $HOME set?")
 }
 
+/// Resolve Cursor config directory: ~/.cursor (global) or .cursor in current dir (project)
+fn resolve_cursor_dir(global: bool) -> Result<PathBuf> {
+    if global {
+        dirs::home_dir()
+            .map(|h| h.join(".cursor"))
+            .context("Cannot determine home directory. Is $HOME set?")
+    } else {
+        Ok(std::env::current_dir()
+            .context("Cannot determine current directory")?
+            .join(".cursor"))
+    }
+}
+
+/// Prepare Cursor hook and rules paths; create directories
+fn prepare_cursor_paths(global: bool) -> Result<(PathBuf, PathBuf)> {
+    let cursor_dir = resolve_cursor_dir(global)?;
+    let hooks_dir = cursor_dir.join("hooks");
+    let rules_dir = cursor_dir.join("rules");
+    fs::create_dir_all(&hooks_dir).with_context(|| {
+        format!(
+            "Failed to create Cursor hooks directory: {}",
+            hooks_dir.display()
+        )
+    })?;
+    fs::create_dir_all(&rules_dir).with_context(|| {
+        format!(
+            "Failed to create Cursor rules directory: {}",
+            rules_dir.display()
+        )
+    })?;
+    Ok((hooks_dir.join("rtk-rewrite.sh"), rules_dir.join("rtk.mdc")))
+}
+
+/// Install the shared rtk-rewrite hook script at the given path. Used by Cursor and any future agent (Codex, OpenCode, etc.).
+fn ensure_agent_hook_installed(hook_path: &Path, verbose: u8) -> Result<()> {
+    write_if_changed(hook_path, REWRITE_HOOK, "hook", verbose)?;
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::PermissionsExt;
+        fs::set_permissions(hook_path, fs::Permissions::from_mode(0o755))
+            .with_context(|| format!("Failed to set hook permissions: {}", hook_path.display()))?;
+    }
+    if verbose > 0 {
+        eprintln!("Hook: {}", hook_path.display());
+    }
+    Ok(())
+}
+
+/// Run init for Cursor: hook script + rules file + hooks.json
+///
+/// Hook contract (Cursor preToolUse):
+///   Input:  `{ "hook_event_name": "preToolUse", "tool_input": { "command": "..." }, ... }`
+///   Output: `{ "decision": "allow", "updated_input": { "command": "rtk ..." } }`
+/// See <https://docs.cursor.com/context/hooks> for the full specification.
+#[cfg(not(unix))]
+fn run_cursor_mode(_global: bool, _patch_mode: PatchMode, _verbose: u8) -> Result<()> {
+    anyhow::bail!(
+        "Cursor hook init requires Unix (macOS/Linux). \
+         The RTK rewrite hook is a bash script and cannot run on Windows natively. \
+         Use WSL on Windows."
+    )
+}
+
+#[cfg(unix)]
+fn run_cursor_mode(global: bool, patch_mode: PatchMode, verbose: u8) -> Result<()> {
+    let (hook_path, rules_path) = prepare_cursor_paths(global)?;
+
+    // 1. Install shared hook script (auto-detects Cursor vs Claude from payload)
+    ensure_agent_hook_installed(&hook_path, verbose)?;
+
+    // 2. Write rules file
+    write_if_changed(&rules_path, CURSOR_RTK_RULES, "rtk.mdc", verbose)?;
+
+    // 3. Patch hooks.json
+    let patch_result = patch_cursor_hooks_json(global, patch_mode, verbose)?;
+    match patch_result {
+        PatchResult::Patched => {}
+        PatchResult::AlreadyPresent => println!("\n  hooks.json: RTK hook already present"),
+        PatchResult::Declined | PatchResult::Skipped => {
+            // Manual instructions already printed by patch_cursor_hooks_json
+        }
+    }
+
+    let scope = if global {
+        "global (~/.cursor)"
+    } else {
+        "project (.cursor)"
+    };
+    println!("\nRTK Cursor init complete ({}).", scope);
+    println!("  Hook:   {}", hook_path.display());
+    println!("  Rules:  {}", rules_path.display());
+    println!("  Restart Cursor. Test with: git status");
+
+    Ok(())
+}
+
+/// Print manual instructions for adding RTK to Cursor hooks.json
+fn print_cursor_manual_instructions(hooks_json_path: &Path, hook_command: &str) {
+    println!("\n  MANUAL: Add to {}:", hooks_json_path.display());
+    println!("  {{ \"version\": 1, \"hooks\": {{ \"preToolUse\": [ {{ \"command\": \"{}\", \"matcher\": \"Shell\" }} ] }} }}", hook_command);
+}
+
+/// Patch Cursor hooks.json to register preToolUse (Shell) hook
+fn patch_cursor_hooks_json(global: bool, mode: PatchMode, verbose: u8) -> Result<PatchResult> {
+    let cursor_dir = resolve_cursor_dir(global)?;
+    let hooks_json_path = cursor_dir.join("hooks.json");
+    let hook_command = if global {
+        "./hooks/rtk-rewrite.sh"
+    } else {
+        ".cursor/hooks/rtk-rewrite.sh"
+    };
+
+    patch_json_registry(
+        &hooks_json_path,
+        hook_command,
+        cursor_hook_already_present,
+        insert_cursor_hook_entry,
+        || print_cursor_manual_instructions(&hooks_json_path, hook_command),
+        mode,
+        verbose,
+        "hooks.json: RTK hook already present",
+        "hooks.json: RTK preToolUse (Shell) hook added",
+    )
+}
+
+fn insert_cursor_hook_entry(root: &mut serde_json::Value, hook_command: &str) {
+    let root_obj = match root.as_object_mut() {
+        Some(obj) => obj,
+        None => {
+            *root = serde_json::json!({});
+            root.as_object_mut()
+                .expect("Just created object, must succeed")
+        }
+    };
+
+    root_obj
+        .entry("version")
+        .or_insert_with(|| serde_json::json!(1));
+
+    let hooks = root_obj
+        .entry("hooks")
+        .or_insert_with(|| serde_json::json!({}));
+    if !hooks.is_object() {
+        *hooks = serde_json::json!({});
+    }
+    let hooks_obj = hooks.as_object_mut().expect("Just ensured hooks is object");
+
+    let pre_tool_use = hooks_obj
+        .entry("preToolUse")
+        .or_insert_with(|| serde_json::json!([]));
+    if !pre_tool_use.is_array() {
+        *pre_tool_use = serde_json::json!([]);
+    }
+    let arr = pre_tool_use
+        .as_array_mut()
+        .expect("Just ensured preToolUse is array");
+
+    arr.push(serde_json::json!({
+        "command": hook_command,
+        "matcher": "Shell"
+    }));
+}
+
+fn cursor_hook_already_present(root: &serde_json::Value, hook_command: &str) -> bool {
+    let arr = match root
+        .get("hooks")
+        .and_then(|h| h.get("preToolUse"))
+        .and_then(|p| p.as_array())
+    {
+        Some(a) => a,
+        None => return false,
+    };
+    for entry in arr {
+        let cmd = entry.get("command").and_then(|c| c.as_str()).unwrap_or("");
+        if cmd == hook_command || cmd.contains("rtk-rewrite.sh") {
+            return true;
+        }
+    }
+    false
+}
+
+/// Show Cursor rtk configuration (global and project)
+fn show_cursor_config() -> Result<()> {
+    println!("📋 rtk Cursor Configuration:\n");
+
+    for (label, global) in [("Global (~/.cursor)", true), ("Project (.cursor)", false)] {
+        if let Ok(cursor_dir) = resolve_cursor_dir(global) {
+            let hook_path = cursor_dir.join("hooks").join("rtk-rewrite.sh");
+            let rules_path = cursor_dir.join("rules").join("rtk.mdc");
+            let hooks_json_path = cursor_dir.join("hooks.json");
+
+            println!("  {}:", label);
+            if hook_path.exists() {
+                println!("    ✅ Hook: {}", hook_path.display());
+            } else {
+                println!("    ⚪ Hook: not found");
+            }
+            if rules_path.exists() {
+                println!("    ✅ Rules: {}", rules_path.display());
+            } else {
+                println!("    ⚪ Rules: not found");
+            }
+            if hooks_json_path.exists() {
+                let content = fs::read_to_string(&hooks_json_path)?;
+                if let Ok(root) = serde_json::from_str::<serde_json::Value>(&content) {
+                    let cmd = if global {
+                        "./hooks/rtk-rewrite.sh"
+                    } else {
+                        ".cursor/hooks/rtk-rewrite.sh"
+                    };
+                    if cursor_hook_already_present(&root, cmd) {
+                        println!("    ✅ hooks.json: RTK preToolUse configured");
+                    } else {
+                        println!("    ⚪ hooks.json: RTK hook not configured");
+                    }
+                } else {
+                    println!("    ⚠️  hooks.json: invalid JSON");
+                }
+            } else {
+                println!("    ⚪ hooks.json: not found");
+            }
+            println!();
+        }
+    }
+    println!("  rtk init --cursor         # Project .cursor");
+    println!("  rtk init --cursor -g       # Global ~/.cursor");
+    println!("  rtk init --cursor -g --uninstall  # Remove global Cursor RTK");
+    Ok(())
+}
+
 /// Show current rtk configuration
-pub fn show_config() -> Result<()> {
+pub fn show_config(target: InitTarget) -> Result<()> {
+    if target == InitTarget::Cursor {
+        return show_cursor_config();
+    }
     let claude_dir = resolve_claude_dir()?;
     let hook_path = claude_dir.join("hooks").join("rtk-rewrite.sh");
     let rtk_md_path = claude_dir.join("RTK.md");
@@ -1335,6 +1667,56 @@ More notes
         assert!(!hook_already_present(&json_content, hook_command));
     }
 
+    // Tests for cursor_hook_already_present()
+    #[test]
+    fn test_cursor_hook_already_present_exact_match() {
+        let json_content = serde_json::json!({
+            "version": 1,
+            "hooks": {
+                "preToolUse": [{ "command": ".cursor/hooks/rtk-rewrite.sh", "matcher": "Shell" }]
+            }
+        });
+        assert!(cursor_hook_already_present(
+            &json_content,
+            ".cursor/hooks/rtk-rewrite.sh"
+        ));
+    }
+
+    #[test]
+    fn test_cursor_hook_already_present_rtk_substring() {
+        let json_content = serde_json::json!({
+            "hooks": { "preToolUse": [{ "command": "./hooks/rtk-rewrite.sh", "matcher": "Shell" }] }
+        });
+        assert!(cursor_hook_already_present(
+            &json_content,
+            "./hooks/rtk-rewrite.sh"
+        ));
+    }
+
+    #[test]
+    fn test_cursor_hook_not_present() {
+        let json_content = serde_json::json!({ "version": 1, "hooks": { "preToolUse": [] } });
+        assert!(!cursor_hook_already_present(
+            &json_content,
+            ".cursor/hooks/rtk-rewrite.sh"
+        ));
+    }
+
+    #[test]
+    fn test_remove_cursor_hook_from_json() {
+        let temp = TempDir::new().unwrap();
+        let hooks_json = temp.path().join("hooks.json");
+        let content = r#"{"version":1,"hooks":{"preToolUse":[{"command":".cursor/hooks/rtk-rewrite.sh","matcher":"Shell"},{"command":"./other.sh","matcher":"Shell"}]}}"#;
+        fs::write(&hooks_json, content).unwrap();
+        let removed = remove_cursor_hook_from_json(&hooks_json, 0).unwrap();
+        assert!(removed);
+        let out = fs::read_to_string(&hooks_json).unwrap();
+        let root: serde_json::Value = serde_json::from_str(&out).unwrap();
+        let pre = root["hooks"]["preToolUse"].as_array().unwrap();
+        assert_eq!(pre.len(), 1);
+        assert_eq!(pre[0]["command"], "./other.sh");
+    }
+
     // Tests for insert_hook_entry()
     #[test]
     fn test_insert_hook_entry_empty_root() {
diff --git a/src/main.rs b/src/main.rs
index fcb39303..a4f7f7e3 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -266,6 +266,10 @@ enum Commands {
         #[arg(long)]
         show: bool,
 
+        /// Initialize for Cursor (hooks + rules in ~/.cursor or .cursor)
+        #[arg(long, conflicts_with_all = ["claude_md", "hook_only"])]
+        cursor: bool,
+
         /// Inject full instructions into CLAUDE.md (legacy mode)
         #[arg(long = "claude-md", group = "mode")]
         claude_md: bool,
@@ -1110,16 +1114,18 @@ fn main() -> Result<()> {
         Commands::Init {
             global,
             show,
+            cursor,
             claude_md,
             hook_only,
             auto_patch,
             no_patch,
             uninstall,
         } => {
+            let target = init::InitTarget::from_cursor_flag(cursor);
             if show {
-                init::show_config()?;
+                init::show_config(target)?;
             } else if uninstall {
-                init::uninstall(global, cli.verbose)?;
+                init::uninstall(global, cli.verbose, target)?;
             } else {
                 let patch_mode = if auto_patch {
                     init::PatchMode::Auto
@@ -1128,7 +1134,14 @@ fn main() -> Result<()> {
                 } else {
                     init::PatchMode::Ask
                 };
-                init::run(global, claude_md, hook_only, patch_mode, cli.verbose)?;
+                init::run(
+                    global,
+                    claude_md,
+                    hook_only,
+                    patch_mode,
+                    cli.verbose,
+                    target,
+                )?;
             }
         }