diff --git a/Cargo.lock b/Cargo.lock
index b7796e6d8..79fa30e31 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -892,7 +892,7 @@ dependencies = [
 
 [[package]]
 name = "rtk"
-version = "0.36.0"
+version = "0.34.3"
 dependencies = [
  "anyhow",
  "automod",
diff --git a/README.md b/README.md
index 1452b1ca8..8be45ee27 100644
--- a/README.md
+++ b/README.md
@@ -173,6 +173,7 @@ rtk gh run list                 # Workflow run status
 ```bash
 rtk jest                        # Jest compact (failures only)
 rtk vitest                      # Vitest compact (failures only)
+rtk bun test                    # Bun tests (failures + error context, -85%)
 rtk playwright test             # E2E results (failures only)
 rtk pytest                      # Python tests (-90%)
 rtk go test                     # Go tests (NDJSON, -90%)
@@ -189,6 +190,8 @@ rtk lint                        # ESLint grouped by rule/file
 rtk lint biome                  # Supports other linters
 rtk tsc                         # TypeScript errors grouped by file
 rtk next build                  # Next.js build compact
+rtk bun build                   # Bun build compact
+rtk bunx <cmd>                  # Routes bunx tsc/eslint/prisma to RTK filters
 rtk prettier --check .          # Files needing formatting
 rtk cargo build                 # Cargo build (-80%)
 rtk cargo clippy                # Cargo clippy (-80%)
@@ -200,6 +203,8 @@ rtk rubocop                     # Ruby linting (JSON, -60%+)
 ### Package Managers
 ```bash
 rtk pnpm list                   # Compact dependency tree
+rtk bun install                 # Bun install (strip progress bars)
+rtk bun run <script>            # Bun script runner (filtered output)
 rtk pip list                    # Python packages (auto-detect uv)
 rtk pip outdated                # Outdated packages
 rtk bundle install              # Ruby gems (strip Using lines)
diff --git a/docs/guide/resources/what-rtk-covers.md b/docs/guide/resources/what-rtk-covers.md
index dd5c39e89..221c9a2d3 100644
--- a/docs/guide/resources/what-rtk-covers.md
+++ b/docs/guide/resources/what-rtk-covers.md
@@ -53,6 +53,11 @@ Typical savings: 60-99%.
 |---------|---------|--------------|
 | `jest` | 94-99% | Failures only |
 | `vitest` | 94-99% | Failures only |
+| `bun test` | 85-90% | Failures + error context, passes suppressed |
+| `bun install` | 80% | Progress bars stripped, summary kept |
+| `bun build` | 80% | Compact build output |
+| `bun run <script>` | varies | Script output with error focus |
+| `bunx <cmd>` | varies | Routed to specialized filters (tsc, eslint, prisma) |
 | `tsc` | 75% | Type errors grouped by file |
 | `eslint` | 84% | Violations grouped by rule |
 | `pnpm list` | 70-90% | Compact dependency tree |
diff --git a/src/cmds/js/bun_cmd.rs b/src/cmds/js/bun_cmd.rs
new file mode 100644
index 000000000..40ce861bd
--- /dev/null
+++ b/src/cmds/js/bun_cmd.rs
@@ -0,0 +1,538 @@
+//! Filters Bun output — test results, install logs, build summaries, script output.
+
+use crate::core::runner;
+use crate::core::utils::{resolved_command, strip_ansi};
+use anyhow::Result;
+use lazy_static::lazy_static;
+use regex::Regex;
+use std::ffi::OsString;
+
+lazy_static! {
+    /// Matches bun test summary line: "X pass, Y fail, Z skip" (with optional ANSI)
+    static ref BUN_TEST_SUMMARY_RE: Regex =
+        Regex::new(r"^\s*\d+\s+pass").unwrap();
+    static ref BUN_TEST_FAIL_COUNT_RE: Regex =
+        Regex::new(r"^\s*\d+\s+fail$").unwrap();
+    static ref BUN_TEST_SKIP_RE: Regex =
+        Regex::new(r"^\s*\d+\s+skip").unwrap();
+    static ref BUN_TEST_EXPECT_RE: Regex =
+        Regex::new(r"^\s*\d+\s+expect").unwrap();
+    /// Matches "X tests failed:" trailing summary section
+    static ref BUN_TESTS_FAILED_RE: Regex =
+        Regex::new(r"^\d+\s+tests?\s+failed:").unwrap();
+
+    /// Matches bun install summary: "bun install v1.x (Xms)" or "X packages installed"
+    static ref BUN_INSTALL_DONE_RE: Regex =
+        Regex::new(r"(?i)(\d+)\s+packages?\s+installed").unwrap();
+    static ref BUN_INSTALL_SPEED_RE: Regex =
+        Regex::new(r"\[\d+(\.\d+)?(ms|s)\]").unwrap();
+
+    /// Matches bun build output size lines
+    static ref BUN_BUILD_ENTRY_RE: Regex =
+        Regex::new(r"^\s*\S+\s+[\d.]+(KB|MB|B|GB)\s*$").unwrap();
+
+    /// Matches lines that are just whitespace or ANSI reset codes
+    static ref NOISE_LINE_RE: Regex =
+        Regex::new(r"^\s*(\x1b\[[0-9;]*m)*\s*$").unwrap();
+}
+
+pub fn test(args: &[String], verbose: u8) -> Result<i32> {
+    let mut cmd = resolved_command("bun");
+    cmd.arg("test");
+    cmd.env("LC_ALL", "C");
+    for arg in args {
+        cmd.arg(arg);
+    }
+
+    if verbose > 0 {
+        eprintln!("Running: bun test {}", args.join(" "));
+    }
+
+    runner::run_filtered(
+        cmd,
+        "bun",
+        &format!("test {}", args.join(" ")),
+        filter_bun_test,
+        runner::RunOptions::default(),
+    )
+}
+
+pub fn install(args: &[String], verbose: u8, skip_env: bool) -> Result<i32> {
+    let mut cmd = resolved_command("bun");
+    cmd.arg("install");
+    cmd.env("LC_ALL", "C");
+    for arg in args {
+        cmd.arg(arg);
+    }
+    if skip_env {
+        cmd.env("SKIP_ENV_VALIDATION", "1");
+    }
+
+    if verbose > 0 {
+        eprintln!("Running: bun install {}", args.join(" "));
+    }
+
+    runner::run_filtered(
+        cmd,
+        "bun",
+        &format!("install {}", args.join(" ")),
+        filter_bun_install,
+        runner::RunOptions::default(),
+    )
+}
+
+pub fn build(args: &[String], verbose: u8) -> Result<i32> {
+    let mut cmd = resolved_command("bun");
+    cmd.arg("build");
+    cmd.env("LC_ALL", "C");
+    for arg in args {
+        cmd.arg(arg);
+    }
+
+    if verbose > 0 {
+        eprintln!("Running: bun build {}", args.join(" "));
+    }
+
+    runner::run_filtered(
+        cmd,
+        "bun",
+        &format!("build {}", args.join(" ")),
+        filter_bun_build,
+        runner::RunOptions::default(),
+    )
+}
+
+pub fn run(script: &str, args: &[String], verbose: u8, skip_env: bool) -> Result<i32> {
+    let mut cmd = resolved_command("bun");
+    cmd.arg("run").arg(script);
+    cmd.env("LC_ALL", "C");
+    for arg in args {
+        cmd.arg(arg);
+    }
+    if skip_env {
+        cmd.env("SKIP_ENV_VALIDATION", "1");
+    }
+
+    if verbose > 0 {
+        eprintln!("Running: bun run {} {}", script, args.join(" "));
+    }
+
+    runner::run_filtered(
+        cmd,
+        "bun",
+        &format!("run {} {}", script, args.join(" ")),
+        filter_bun_run,
+        runner::RunOptions::default(),
+    )
+}
+
+pub fn run_passthrough(args: &[OsString], verbose: u8) -> Result<i32> {
+    runner::run_passthrough("bun", args, verbose)
+}
+
+pub fn run_tool(args: &[String], verbose: u8) -> Result<i32> {
+    let os_args: Vec<OsString> = args.iter().map(Into::into).collect();
+    runner::run_passthrough("bunx", &os_args, verbose)
+}
+
+/// Filter bun test output: strip passing tests, keep failures and summary.
+///
+/// Handles both TTY format (✓/✗) and piped format ((pass)/(fail)).
+/// Bun outputs error context BEFORE the failure marker, so we buffer
+/// potential error lines and flush them when a (fail)/✗ marker appears.
+fn filter_bun_test(output: &str) -> String {
+    let clean = strip_ansi(output);
+    let lines: Vec<&str> = clean.lines().collect();
+
+    if lines.is_empty() {
+        return String::new();
+    }
+
+    let mut failures: Vec<String> = Vec::new();
+    let mut summary_lines: Vec<&str> = Vec::new();
+    let mut error_buffer: Vec<&str> = Vec::new();
+    let mut has_failures = false;
+    let mut in_failed_summary = false;
+
+    for line in &lines {
+        let trimmed = line.trim();
+
+        // Skip empty lines upfront — never buffer or match against them
+        if trimmed.is_empty() {
+            continue;
+        }
+
+        // "X tests failed:" trailing section — skip (duplicates already captured)
+        if BUN_TESTS_FAILED_RE.is_match(trimmed) {
+            in_failed_summary = true;
+            error_buffer.clear();
+            continue;
+        }
+        if in_failed_summary {
+            if is_fail_marker(trimmed) {
+                continue;
+            }
+            in_failed_summary = false;
+            // Fall through to summary detection
+        }
+
+        // Failure marker — flush error buffer as context
+        if is_fail_marker(trimmed) {
+            has_failures = true;
+            for buf_line in &error_buffer {
+                failures.push(buf_line.to_string());
+            }
+            error_buffer.clear();
+            failures.push(trimmed.to_string());
+            continue;
+        }
+
+        // Pass marker or file header — discard buffered lines (not error context)
+        if is_pass_marker(trimmed) || is_test_file_header(trimmed) || trimmed.starts_with("bun test") {
+            error_buffer.clear();
+            continue;
+        }
+
+        // Summary lines
+        if BUN_TEST_SUMMARY_RE.is_match(trimmed)
+            || BUN_TEST_FAIL_COUNT_RE.is_match(trimmed)
+            || BUN_TEST_SKIP_RE.is_match(trimmed)
+            || BUN_TEST_EXPECT_RE.is_match(trimmed)
+            || trimmed.starts_with("Ran ")
+        {
+            error_buffer.clear();
+            summary_lines.push(trimmed);
+            continue;
+        }
+
+        // Buffer as potential error context (will be flushed if followed by a fail marker)
+        error_buffer.push(trimmed);
+    }
+
+    let mut result = Vec::new();
+
+    if has_failures {
+        result.push("FAILURES:".to_string());
+        for line in &failures {
+            result.push(line.to_string());
+        }
+        result.push(String::new());
+    }
+
+    if !summary_lines.is_empty() {
+        for line in &summary_lines {
+            result.push(line.to_string());
+        }
+    } else {
+        result.push("ok".to_string());
+    }
+
+    let joined = result.join("\n");
+    let output = joined.trim();
+    if output.is_empty() {
+        "ok".to_string()
+    } else {
+        output.to_string()
+    }
+}
+
+fn is_fail_marker(line: &str) -> bool {
+    line.starts_with('✗') || line.starts_with('✘') || line.starts_with("(fail)") || line.starts_with("FAIL")
+}
+
+fn is_pass_marker(line: &str) -> bool {
+    line.starts_with('✓') || line.starts_with('✔') || line.starts_with("(pass)")
+}
+
+fn is_test_file_header(line: &str) -> bool {
+    line.ends_with(':') && (line.contains(".test.") || line.contains(".spec."))
+}
+
+/// Filter bun install output: strip progress bars, keep summary.
+fn filter_bun_install(output: &str) -> String {
+    let clean = strip_ansi(output);
+    let mut result = Vec::new();
+
+    for line in clean.lines() {
+        let trimmed = line.trim();
+
+        // Skip empty lines
+        if trimmed.is_empty() {
+            continue;
+        }
+        // Skip progress indicators
+        if trimmed.contains("⸩") || trimmed.contains("⸨") {
+            continue;
+        }
+        // Skip resolution/download progress
+        if trimmed.starts_with("Resolving")
+            || trimmed.starts_with("Downloading")
+            || trimmed.starts_with("Extracting")
+        {
+            continue;
+        }
+        // Skip bun install header noise
+        if trimmed.starts_with("bun install v") {
+            continue;
+        }
+
+        // Keep: package count, warnings, errors, lockfile info
+        result.push(trimmed.to_string());
+    }
+
+    let joined = result.join("\n");
+    let output = joined.trim();
+    if output.is_empty() {
+        "ok".to_string()
+    } else {
+        output.to_string()
+    }
+}
+
+/// Filter bun build output: keep errors, warnings, and final summary.
+fn filter_bun_build(output: &str) -> String {
+    let clean = strip_ansi(output);
+    let mut result = Vec::new();
+
+    for line in clean.lines() {
+        let trimmed = line.trim();
+
+        if trimmed.is_empty() {
+            continue;
+        }
+        // Skip bun build header
+        if trimmed.starts_with("bun build v") {
+            continue;
+        }
+        // Keep errors and warnings
+        if trimmed.contains("error") || trimmed.contains("warn") || trimmed.contains("Error") {
+            result.push(trimmed.to_string());
+            continue;
+        }
+        // Keep build output entries (file sizes)
+        if BUN_BUILD_ENTRY_RE.is_match(trimmed) {
+            result.push(trimmed.to_string());
+            continue;
+        }
+        // Keep summary lines
+        if trimmed.contains("built") || trimmed.contains("Bundle") || trimmed.starts_with("Done") {
+            result.push(trimmed.to_string());
+        }
+    }
+
+    let joined = result.join("\n");
+    let output = joined.trim();
+    if output.is_empty() {
+        "ok".to_string()
+    } else {
+        output.to_string()
+    }
+}
+
+/// Filter bun run output: strip boilerplate, keep script output.
+fn filter_bun_run(output: &str) -> String {
+    let clean = strip_ansi(output);
+    let mut result = Vec::new();
+
+    for line in clean.lines() {
+        let trimmed = line.trim();
+
+        // Skip empty lines
+        if trimmed.is_empty() {
+            continue;
+        }
+        // Skip bun run boilerplate ($ command echo)
+        if trimmed.starts_with("$") && trimmed.len() < 200 {
+            continue;
+        }
+        // Skip bun version header
+        if trimmed.starts_with("bun run v") {
+            continue;
+        }
+
+        result.push(line.to_string());
+    }
+
+    let joined = result.join("\n");
+    let output = joined.trim();
+    if output.is_empty() {
+        "ok".to_string()
+    } else {
+        output.to_string()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn count_tokens(text: &str) -> usize {
+        text.split_whitespace().count()
+    }
+
+    #[test]
+    fn test_filter_bun_test_all_pass() {
+        let input = include_str!("../../../tests/fixtures/bun_test_pass.txt");
+        let output = filter_bun_test(input);
+
+        // Should NOT contain individual test lines
+        assert!(!output.contains("(pass)"), "Filtered output still contains passing tests");
+        // Should contain summary
+        assert!(output.contains("pass"));
+        // Should NOT contain failure header
+        assert!(!output.contains("FAILURES:"));
+
+        // Token savings
+        let savings =
+            100.0 - (count_tokens(&output) as f64 / count_tokens(input) as f64 * 100.0);
+        assert!(
+            savings >= 60.0,
+            "bun test (pass): expected >=60% savings, got {:.1}%",
+            savings
+        );
+    }
+
+    #[test]
+    fn test_filter_bun_test_with_failures() {
+        let input = include_str!("../../../tests/fixtures/bun_test_fail.txt");
+        let output = filter_bun_test(input);
+
+        // Should contain failure header and error details
+        assert!(output.contains("FAILURES:"), "Missing FAILURES header:\n{}", output);
+        assert!(
+            output.contains("(fail)") || output.contains("fail"),
+            "Missing failure markers:\n{}", output
+        );
+        // Should contain error context (captured from lines before the marker)
+        assert!(
+            output.contains("Expected:") && output.contains("Received:"),
+            "Missing error details:\n{}", output
+        );
+        // Should NOT contain passing tests
+        assert!(!output.contains("(pass)"), "Contains passing tests:\n{}", output);
+    }
+
+    #[test]
+    fn test_filter_bun_test_empty() {
+        let output = filter_bun_test("");
+        assert!(output.is_empty() || output == "ok");
+    }
+
+    #[test]
+    fn test_filter_bun_install() {
+        let input = include_str!("../../../tests/fixtures/bun_install.txt");
+        let output = filter_bun_install(input);
+
+        // Should not contain progress noise
+        assert!(!output.contains("Resolving"));
+        assert!(!output.contains("Downloading"));
+
+        // Token savings
+        let savings =
+            100.0 - (count_tokens(&output) as f64 / count_tokens(input) as f64 * 100.0);
+        assert!(
+            savings >= 60.0,
+            "bun install: expected >=60% savings, got {:.1}%",
+            savings
+        );
+    }
+
+    #[test]
+    fn test_filter_bun_build() {
+        let input = include_str!("../../../tests/fixtures/bun_build.txt");
+        let output = filter_bun_build(input);
+
+        // Should keep error/summary info
+        assert!(
+            output.contains("built") || output.contains("ok") || output.contains("Done"),
+            "Expected build summary in output: {}",
+            output
+        );
+    }
+
+    #[test]
+    fn test_filter_bun_run_strips_boilerplate() {
+        let input = "$ next build\n\nCreating optimized build...\n✓ Build completed in 4.2s\n";
+        let output = filter_bun_run(input);
+
+        assert!(!output.contains("$ next"));
+        assert!(output.contains("Build completed"));
+    }
+
+    #[test]
+    fn test_filter_bun_run_empty() {
+        let output = filter_bun_run("\n\n\n");
+        assert_eq!(output, "ok");
+    }
+
+    #[test]
+    fn test_filter_bun_install_empty() {
+        let output = filter_bun_install("\n\n");
+        assert_eq!(output, "ok");
+    }
+
+    #[test]
+    fn test_filter_bun_build_empty() {
+        let output = filter_bun_build("");
+        assert_eq!(output, "ok");
+    }
+
+    #[test]
+    fn test_filter_bun_test_real_output() {
+        let input = include_str!("../../../tests/fixtures/bun_test_real.txt");
+        let output = filter_bun_test(input);
+
+        // Must NOT contain passing test lines
+        assert!(
+            !output.contains("(pass)"),
+            "Filtered output still contains passing tests:\n{}",
+            output
+        );
+        // Must contain failure details with error context
+        assert!(
+            output.contains("FAILURES:"),
+            "Filtered output missing FAILURES header:\n{}",
+            output
+        );
+        assert!(
+            output.contains("Expected:") && output.contains("Received:"),
+            "Filtered output missing error details:\n{}",
+            output
+        );
+        // Must contain summary
+        assert!(
+            output.contains("79 pass"),
+            "Filtered output missing summary:\n{}",
+            output
+        );
+        assert!(
+            output.contains("Ran 81 tests"),
+            "Filtered output missing run count:\n{}",
+            output
+        );
+
+        // Token savings must be >= 60%
+        let input_tokens = count_tokens(input);
+        let output_tokens = count_tokens(&output);
+        let savings = 100.0 - (output_tokens as f64 / input_tokens as f64 * 100.0);
+        assert!(
+            savings >= 60.0,
+            "bun test (real): expected >=60% savings, got {:.1}% ({} -> {} tokens)\nOutput:\n{}",
+            savings,
+            input_tokens,
+            output_tokens,
+            output
+        );
+    }
+
+    #[test]
+    fn test_filter_bun_test_tty_format() {
+        // TTY format uses ✓/✗ instead of (pass)/(fail)
+        let input = "bun test v1.1.0 (abc)\n\ntest.ts:\n✓ passes [1ms]\n  Expected: 1\n  Received: 2\n✗ fails [1ms]\n\n 1 pass\n 1 fail\n 2 expect() calls\nRan 2 tests across 1 files. [10.00ms]\n";
+        let output = filter_bun_test(input);
+
+        assert!(output.contains("FAILURES:"), "Missing FAILURES for TTY format:\n{}", output);
+        assert!(output.contains("Expected:"), "Missing error context for TTY format:\n{}", output);
+        assert!(output.contains("1 pass"), "Missing summary for TTY format:\n{}", output);
+    }
+}
diff --git a/src/cmds/js/vitest_cmd.rs b/src/cmds/js/vitest_cmd.rs
index fc80bff69..7726bff10 100644
--- a/src/cmds/js/vitest_cmd.rs
+++ b/src/cmds/js/vitest_cmd.rs
@@ -11,7 +11,21 @@ use crate::parser::{
     emit_degradation_warning, emit_passthrough_warning, extract_json_object, truncate_passthrough,
     FormatMode, OutputParser, ParseResult, TestFailure, TestResult, TokenFormatter,
 };
-use crate::Commands;
+
+#[derive(Debug, Clone, Copy)]
+pub enum TestFramework {
+    Jest,
+    Vitest,
+}
+
+impl TestFramework {
+    fn name(&self) -> &'static str {
+        match self {
+            TestFramework::Jest => "jest",
+            TestFramework::Vitest => "vitest",
+        }
+    }
+}
 
 /// Vitest JSON output structures (tool-specific format)
 #[derive(Debug, Deserialize)]
@@ -204,32 +218,19 @@ fn extract_failures_regex(output: &str) -> Vec<TestFailure> {
     failures
 }
 
-pub fn run_test(command: &Commands, args: &[String], verbose: u8) -> Result<i32> {
+pub fn run_test(framework: TestFramework, args: &[String], verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
+    let framework_name = framework.name();
+    let mut cmd = package_manager_exec(framework_name);
 
-    let (framework, mut cmd) = match command {
-        Commands::Vitest { .. } => {
-            let framework = "vitest";
-            let mut cmd = package_manager_exec(framework);
-            cmd
-                // Force non-watch mode
-                .arg("run")
-                // Enable JSON structured output
-                .arg("--reporter=json");
-            (framework, cmd)
+    match framework {
+        TestFramework::Vitest => {
+            cmd.arg("run").arg("--reporter=json");
         }
-        Commands::Jest { .. } => {
-            let framework = "jest";
-            let mut cmd = package_manager_exec(framework);
-            cmd
-                // Force non-watch mode
-                .arg("--no-watch")
-                // Enable JSON structured output
-                .arg("--json");
-            (framework, cmd)
+        TestFramework::Jest => {
+            cmd.arg("--no-watch").arg("--json");
         }
-        _ => unreachable!(),
-    };
+    }
 
     for arg in args {
         if arg == "run"
@@ -242,7 +243,7 @@ pub fn run_test(command: &Commands, args: &[String], verbose: u8) -> Result<i32>
         cmd.arg(arg);
     }
 
-    let result = exec_capture(&mut cmd).context(format!("Failed to run {}", framework))?;
+    let result = exec_capture(&mut cmd).context(format!("Failed to run {}", framework_name))?;
     let combined = result.combined();
 
     // Parse output using VitestParser
@@ -252,24 +253,24 @@ pub fn run_test(command: &Commands, args: &[String], verbose: u8) -> Result<i32>
     let filtered = match parse_result {
         ParseResult::Full(data) => {
             if verbose > 0 {
-                eprintln!("{} run (Tier 1: Full JSON parse)", framework);
+                eprintln!("{} run (Tier 1: Full JSON parse)", framework_name);
             }
             data.format(mode)
         }
         ParseResult::Degraded(data, warnings) => {
             if verbose > 0 {
-                emit_degradation_warning(framework, &warnings.join(", "));
+                emit_degradation_warning(framework_name, &warnings.join(", "));
             }
             data.format(mode)
         }
         ParseResult::Passthrough(raw) => {
-            emit_passthrough_warning(framework, "All parsing tiers failed");
+            emit_passthrough_warning(framework_name, "All parsing tiers failed");
             raw
         }
     };
 
     if let Some(hint) =
-        crate::core::tee::tee_and_hint(&combined, format!("{}_run", framework).as_str(), result.exit_code)
+        crate::core::tee::tee_and_hint(&combined, format!("{}_run", framework_name).as_str(), result.exit_code)
     {
         println!("{}\n{}", filtered, hint);
     } else {
@@ -277,8 +278,8 @@ pub fn run_test(command: &Commands, args: &[String], verbose: u8) -> Result<i32>
     }
 
     timer.track(
-        format!("{} run", framework).as_str(),
-        format!("rtk {} run", framework).as_str(),
+        format!("{} run", framework_name).as_str(),
+        format!("rtk {} run", framework_name).as_str(),
         &combined,
         &filtered,
     );
diff --git a/src/core/utils.rs b/src/core/utils.rs
index feae1fb6d..e0043bc6d 100644
--- a/src/core/utils.rs
+++ b/src/core/utils.rs
@@ -270,7 +270,9 @@ pub fn count_tokens(text: &str) -> usize {
 /// ```
 #[allow(dead_code)]
 pub fn detect_package_manager() -> &'static str {
-    if std::path::Path::new("pnpm-lock.yaml").exists() {
+    if std::path::Path::new("bun.lockb").exists() || std::path::Path::new("bun.lock").exists() {
+        "bun"
+    } else if std::path::Path::new("pnpm-lock.yaml").exists() {
         "pnpm"
     } else if std::path::Path::new("yarn.lock").exists() {
         "yarn"
@@ -287,6 +289,11 @@ pub fn package_manager_exec(tool: &str) -> Command {
     } else {
         let pm = detect_package_manager();
         match pm {
+            "bun" => {
+                let mut c = resolved_command("bunx");
+                c.arg("--").arg(tool);
+                c
+            }
             "pnpm" => {
                 let mut c = resolved_command("pnpm");
                 c.arg("exec").arg("--").arg(tool);
diff --git a/src/discover/rules.rs b/src/discover/rules.rs
index 74c876a1e..4d290a066 100644
--- a/src/discover/rules.rs
+++ b/src/discover/rules.rs
@@ -79,6 +79,24 @@ pub const RULES: &[RtkRule] = &[
         subcmd_savings: &[],
         subcmd_status: &[],
     },
+    RtkRule {
+        pattern: r"^bun\s+(test|run|install|build|add|remove)",
+        rtk_cmd: "rtk bun",
+        rewrite_prefixes: &["bun"],
+        category: "PackageManager",
+        savings_pct: 80.0,
+        subcmd_savings: &[("test", 88.0), ("install", 85.0), ("build", 80.0)],
+        subcmd_status: &[],
+    },
+    RtkRule {
+        pattern: r"^(bun\s+x|bunx)(\s|$)",
+        rtk_cmd: "rtk bunx",
+        rewrite_prefixes: &["bun x", "bunx"],
+        category: "PackageManager",
+        savings_pct: 70.0,
+        subcmd_savings: &[],
+        subcmd_status: &[],
+    },
     RtkRule {
         pattern: r"^(cat|head|tail)\s+",
         rtk_cmd: "rtk read",
@@ -116,9 +134,13 @@ pub const RULES: &[RtkRule] = &[
         subcmd_status: &[],
     },
     RtkRule {
-        pattern: r"^((p?np(m|x)|p?npm\s+(exec|run|run-script)|npm\s+(rum|urn|x)|pnpm\s+dlx)\s+)?tsc(\s|$)",
+        pattern: r"^((p?np(m|x)|p?npm\s+(exec|run|run-script)|npm\s+(rum|urn|x)|pnpm\s+dlx|bunx|bun\s+x|bun(\s+run)?)\s+)?tsc(\s|$)",
         rtk_cmd: "rtk tsc",
         rewrite_prefixes: &[
+            "bun run tsc",
+            "bun tsc",
+            "bun x tsc",
+            "bunx tsc",
             "npm exec tsc",
             "npm rum tsc",
             "npm run tsc",
@@ -141,10 +163,22 @@ pub const RULES: &[RtkRule] = &[
         subcmd_status: &[],
     },
     RtkRule {
-        pattern: r"^((p?np(m|x)|p?npm\s+(exec|run|run-script)|npm\s+(rum|urn|x)|pnpm\s+dlx)\s+)?(biome|eslint|lint)(\s|$)",
+        pattern: r"^((p?np(m|x)|p?npm\s+(exec|run|run-script)|npm\s+(rum|urn|x)|pnpm\s+dlx|bunx|bun\s+x|bun(\s+run)?)\s+)?(biome|eslint|lint)(\s|$)",
         rtk_cmd: "rtk lint",
         rewrite_prefixes: &[
             "biome",
+            "bun biome",
+            "bun eslint",
+            "bun lint",
+            "bun run biome",
+            "bun run eslint",
+            "bun run lint",
+            "bun x biome",
+            "bun x eslint",
+            "bun x lint",
+            "bunx biome",
+            "bunx eslint",
+            "bunx lint",
             "eslint",
             "lint",
             "npm biome",
@@ -192,9 +226,13 @@ pub const RULES: &[RtkRule] = &[
         subcmd_status: &[],
     },
     RtkRule {
-        pattern: r"^((p?np(m|x)|p?npm\s+(exec|run|run-script)|npm\s+(rum|urn|x)|pnpm\s+dlx)\s+)?prettier",
+        pattern: r"^((p?np(m|x)|p?npm\s+(exec|run|run-script)|npm\s+(rum|urn|x)|pnpm\s+dlx|bunx|bun\s+x|bun(\s+run)?)\s+)?prettier",
         rtk_cmd: "rtk prettier",
         rewrite_prefixes: &[
+            "bun prettier",
+            "bun run prettier",
+            "bun x prettier",
+            "bunx prettier",
             "npm exec prettier",
             "npm prettier",
             "npm rum prettier",
@@ -217,9 +255,13 @@ pub const RULES: &[RtkRule] = &[
         subcmd_status: &[],
     },
     RtkRule {
-        pattern: r"^((p?np(m|x)|p?npm\s+(exec|run|run-script)|npm\s+(rum|urn|x)|pnpm\s+dlx)\s+)?next\s+build",
+        pattern: r"^((p?np(m|x)|p?npm\s+(exec|run|run-script)|npm\s+(rum|urn|x)|pnpm\s+dlx|bunx|bun\s+x|bun(\s+run)?)\s+)?next\s+build",
         rtk_cmd: "rtk next",
         rewrite_prefixes: &[
+            "bun next build",
+            "bun run next build",
+            "bun x next build",
+            "bunx next build",
             "next build",
             "npm exec next build",
             "npm next build",
@@ -242,9 +284,15 @@ pub const RULES: &[RtkRule] = &[
         subcmd_status: &[],
     },
     RtkRule {
-        pattern: r"^((p?np(m|x)|p?npm\s+(exec|run|run-script)|npm\s+(rum|urn|x)|pnpm\s+dlx)\s+)?jest(\s+run)?(\s|$)",
+        pattern: r"^((p?np(m|x)|p?npm\s+(exec|run|run-script)|npm\s+(rum|urn|x)|pnpm\s+dlx|bunx|bun\s+x|bun)\s+)?jest(\s+run)?(\s|$)",
         rtk_cmd: "rtk jest",
         rewrite_prefixes: &[
+            "bun jest run",
+            "bun jest",
+            "bun x jest run",
+            "bun x jest",
+            "bunx jest run",
+            "bunx jest",
             "jest run",
             "jest",
             "npm exec jest run",
@@ -282,9 +330,15 @@ pub const RULES: &[RtkRule] = &[
         subcmd_status: &[],
     },
     RtkRule {
-        pattern: r"^((p?np(m|x)|p?npm\s+(exec|run|run-script)|npm\s+(rum|urn|x)|pnpm\s+dlx)\s+)?vitest(\s+run)?(\s|$)",
+        pattern: r"^((p?np(m|x)|p?npm\s+(exec|run|run-script)|npm\s+(rum|urn|x)|pnpm\s+dlx|bunx|bun\s+x|bun)\s+)?vitest(\s+run)?(\s|$)",
         rtk_cmd: "rtk vitest",
         rewrite_prefixes: &[
+            "bun vitest run",
+            "bun vitest",
+            "bun x vitest run",
+            "bun x vitest",
+            "bunx vitest run",
+            "bunx vitest",
             "npm exec vitest run",
             "npm exec vitest",
             "npm rum vitest run",
@@ -322,9 +376,13 @@ pub const RULES: &[RtkRule] = &[
         subcmd_status: &[],
     },
     RtkRule {
-        pattern: r"^((p?np(m|x)|p?npm\s+(exec|run|run-script)|npm\s+(rum|urn|x)|pnpm\s+dlx)\s+)?playwright",
+        pattern: r"^((p?np(m|x)|p?npm\s+(exec|run|run-script)|npm\s+(rum|urn|x)|pnpm\s+dlx|bunx|bun\s+x|bun(\s+run)?)\s+)?playwright",
         rtk_cmd: "rtk playwright",
         rewrite_prefixes: &[
+            "bun playwright",
+            "bun run playwright",
+            "bun x playwright",
+            "bunx playwright",
             "npm exec playwright",
             "npm playwright",
             "npm rum playwright",
@@ -347,9 +405,11 @@ pub const RULES: &[RtkRule] = &[
         subcmd_status: &[],
     },
     RtkRule {
-        pattern: r"^((p?np(m|x)|p?npm\s+(exec|run|run-script)|npm\s+(rum|urn|x)|pnpm\s+dlx)\s+)?prisma",
+        pattern: r"^((p?np(m|x)|p?npm\s+(exec|run|run-script)|npm\s+(rum|urn|x)|pnpm\s+dlx|bunx|bun\s+x)\s+)?prisma",
         rtk_cmd: "rtk prisma",
         rewrite_prefixes: &[
+            "bun x prisma",
+            "bunx prisma",
             "npm exec prisma",
             "npm prisma",
             "npm rum prisma",
diff --git a/src/main.rs b/src/main.rs
index ccb096ef0..c85410e05 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -12,8 +12,8 @@ use cmds::dotnet::{binlog, dotnet_cmd, dotnet_format_report, dotnet_trx};
 use cmds::git::{diff_cmd, gh_cmd, git, glab_cmd, gt_cmd};
 use cmds::go::{go_cmd, golangci_cmd};
 use cmds::js::{
-    lint_cmd, next_cmd, npm_cmd, playwright_cmd, pnpm_cmd, prettier_cmd, prisma_cmd, tsc_cmd,
-    vitest_cmd,
+    bun_cmd, lint_cmd, next_cmd, npm_cmd, playwright_cmd, pnpm_cmd, prettier_cmd, prisma_cmd,
+    tsc_cmd, vitest_cmd,
 };
 use cmds::python::{mypy_cmd, pip_cmd, pytest_cmd, ruff_cmd};
 use cmds::ruby::{rake_cmd, rspec_cmd, rubocop_cmd};
@@ -543,6 +543,19 @@ enum Commands {
         args: Vec<String>,
     },
 
+    /// Bun commands with compact output
+    Bun {
+        #[command(subcommand)]
+        command: BunCommands,
+    },
+
+    /// bunx with intelligent routing (tsc, eslint, prisma -> specialized filters)
+    Bunx {
+        /// bunx arguments (command + options)
+        #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
+        args: Vec<String>,
+    },
+
     /// Curl with auto-JSON detection and schema output
     Curl {
         /// Curl arguments (URL + options)
@@ -951,6 +964,37 @@ enum KubectlCommands {
     Other(Vec<OsString>),
 }
 
+#[derive(Debug, Subcommand)]
+enum BunCommands {
+    /// Run tests with filtered output (85-90% token reduction)
+    Test {
+        /// Additional bun test arguments
+        #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
+        args: Vec<String>,
+    },
+    /// Install packages (filter progress bars)
+    Install {
+        /// Additional bun install arguments
+        #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
+        args: Vec<String>,
+    },
+    /// Build with compact output
+    Build {
+        /// Additional bun build arguments
+        #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
+        args: Vec<String>,
+    },
+    /// Run script with filtered output
+    Run {
+        /// Script name and arguments
+        #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
+        args: Vec<String>,
+    },
+    /// Passthrough: runs any unsupported bun subcommand directly
+    #[command(external_subcommand)]
+    Other(Vec<OsString>),
+}
+
 #[derive(Debug, Subcommand)]
 enum PrismaCommands {
     /// Generate Prisma Client (strip ASCII art)
@@ -1335,6 +1379,38 @@ fn main() {
     std::process::exit(code);
 }
 
+fn route_bunx(args: &[String], verbose: u8) -> Result<i32> {
+    if args.is_empty() {
+        anyhow::bail!("bunx requires a command argument");
+    }
+    match args[0].as_str() {
+        "tsc" | "typescript" => tsc_cmd::run(&args[1..], verbose),
+        "eslint" | "biome" => lint_cmd::run(&args[1..], verbose),
+        "jest" => vitest_cmd::run_test(vitest_cmd::TestFramework::Jest, &args[1..], verbose),
+        "vitest" => vitest_cmd::run_test(vitest_cmd::TestFramework::Vitest, &args[1..], verbose),
+        "prisma" => {
+            if args.len() > 1 {
+                let prisma_args: Vec<String> = args[2..].to_vec();
+                match args[1].as_str() {
+                    "generate" => {
+                        prisma_cmd::run(prisma_cmd::PrismaCommand::Generate, &prisma_args, verbose)
+                    }
+                    "db" if args.len() > 2 && args[2] == "push" => {
+                        prisma_cmd::run(prisma_cmd::PrismaCommand::DbPush, &args[3..], verbose)
+                    }
+                    _ => bun_cmd::run_tool(args, verbose),
+                }
+            } else {
+                bun_cmd::run_tool(args, verbose)
+            }
+        }
+        "next" => next_cmd::run(&args[1..], verbose),
+        "prettier" => prettier_cmd::run(&args[1..], verbose),
+        "playwright" => playwright_cmd::run(&args[1..], verbose),
+        _ => bun_cmd::run_tool(args, verbose),
+    }
+}
+
 fn run_cli() -> Result<i32> {
     // Fire-and-forget telemetry ping (1/day, non-blocking)
     core::telemetry::maybe_ping();
@@ -1886,8 +1962,11 @@ fn run_cli() -> Result<i32> {
             0
         }
 
-        Commands::Jest { ref args } | Commands::Vitest { ref args } => {
-            vitest_cmd::run_test(&cli.command, args, cli.verbose)?
+        Commands::Jest { ref args } => {
+            vitest_cmd::run_test(vitest_cmd::TestFramework::Jest, args, cli.verbose)?
+        }
+        Commands::Vitest { ref args } => {
+            vitest_cmd::run_test(vitest_cmd::TestFramework::Vitest, args, cli.verbose)?
         }
 
         Commands::Prisma { command } => match command {
@@ -1958,6 +2037,35 @@ fn run_cli() -> Result<i32> {
 
         Commands::Npm { args } => npm_cmd::run(&args, cli.verbose, cli.skip_env)?,
 
+        Commands::Bun { command } => match command {
+            BunCommands::Test { args } => bun_cmd::test(&args, cli.verbose)?,
+            BunCommands::Install { args } => bun_cmd::install(&args, cli.verbose, cli.skip_env)?,
+            BunCommands::Build { args } => bun_cmd::build(&args, cli.verbose)?,
+            BunCommands::Run { args } => {
+                if args.is_empty() {
+                    anyhow::bail!("bun run requires a script name");
+                }
+                bun_cmd::run(&args[0], &args[1..], cli.verbose, cli.skip_env)?
+            }
+            BunCommands::Other(args) => {
+                if args
+                    .first()
+                    .map(|a| a.to_string_lossy() == "x")
+                    .unwrap_or(false)
+                {
+                    let rest: Vec<String> = args[1..]
+                        .iter()
+                        .map(|a| a.to_string_lossy().into_owned())
+                        .collect();
+                    route_bunx(&rest, cli.verbose)?
+                } else {
+                    bun_cmd::run_passthrough(&args, cli.verbose)?
+                }
+            }
+        },
+
+        Commands::Bunx { args } => route_bunx(&args, cli.verbose)?,
+
         Commands::Curl { args } => curl_cmd::run(&args, cli.verbose)?,
 
         Commands::Discover {
@@ -2422,6 +2530,8 @@ fn is_operational_command(cmd: &Commands) -> bool {
             | Commands::Cargo { .. }
             | Commands::Npm { .. }
             | Commands::Npx { .. }
+            | Commands::Bun { .. }
+            | Commands::Bunx { .. }
             | Commands::Curl { .. }
             | Commands::Ruff { .. }
             | Commands::Pytest { .. }
@@ -3005,4 +3115,43 @@ mod tests {
             _ => panic!("Expected Commands::Npx for unknown tool"),
         }
     }
+
+    #[test]
+    fn test_bun_test_with_cwd() {
+        let cli = Cli::try_parse_from(["rtk", "bun", "test", "--cwd", "packages/api"]).unwrap();
+        match cli.command {
+            Commands::Bun { command } => match command {
+                BunCommands::Test { args } => {
+                    assert_eq!(args, vec!["--cwd", "packages/api"]);
+                }
+                _ => panic!("Expected BunCommands::Test"),
+            },
+            _ => panic!("Expected Commands::Bun"),
+        }
+    }
+
+    #[test]
+    fn test_bun_run_script() {
+        let cli = Cli::try_parse_from(["rtk", "bun", "run", "dev"]).unwrap();
+        match cli.command {
+            Commands::Bun { command } => match command {
+                BunCommands::Run { args } => {
+                    assert_eq!(args, vec!["dev"]);
+                }
+                _ => panic!("Expected BunCommands::Run"),
+            },
+            _ => panic!("Expected Commands::Bun"),
+        }
+    }
+
+    #[test]
+    fn test_bunx_routing() {
+        let cli = Cli::try_parse_from(["rtk", "bunx", "eslint", "."]).unwrap();
+        match cli.command {
+            Commands::Bunx { args } => {
+                assert_eq!(args, vec!["eslint", "."]);
+            }
+            _ => panic!("Expected Commands::Bunx"),
+        }
+    }
 }
diff --git a/tests/fixtures/bun_build.txt b/tests/fixtures/bun_build.txt
new file mode 100644
index 000000000..ef959bf3b
--- /dev/null
+++ b/tests/fixtures/bun_build.txt
@@ -0,0 +1,11 @@
+bun build v1.1.38 (a3e18c1b)
+
+  src/index.ts → dist/index.js
+  src/utils/helpers.ts → dist/utils/helpers.js
+  src/components/App.tsx → dist/components/App.js
+
+  dist/index.js        45.2KB
+  dist/utils/helpers.js   12.8KB
+  dist/components/App.js  89.4KB
+
+Done in 156ms. Built 3 modules, total 147.4KB
diff --git a/tests/fixtures/bun_install.txt b/tests/fixtures/bun_install.txt
new file mode 100644
index 000000000..3f1f06882
--- /dev/null
+++ b/tests/fixtures/bun_install.txt
@@ -0,0 +1,25 @@
+bun install v1.1.38 (a3e18c1b)
+
+Resolving dependencies...
+Downloading @types/react@18.2.48
+Downloading @types/node@20.11.5
+Downloading typescript@5.3.3
+Downloading react@18.2.0
+Downloading react-dom@18.2.0
+Downloading next@14.1.0
+Downloading eslint@8.56.0
+Downloading prettier@3.2.4
+Downloading tailwindcss@3.4.1
+Downloading postcss@8.4.33
+Downloading autoprefixer@10.4.17
+Downloading @prisma/client@5.8.1
+Downloading prisma@5.8.1
+Extracting packages...
+
+ 148 packages installed [2.45s]
+
+ Removed: 3 packages
+ Changed: 12 packages
+ Added: 5 packages
+
+ Lockfile saved.
diff --git a/tests/fixtures/bun_test_fail.txt b/tests/fixtures/bun_test_fail.txt
new file mode 100644
index 000000000..3ddd699ae
--- /dev/null
+++ b/tests/fixtures/bun_test_fail.txt
@@ -0,0 +1,39 @@
+bun test v1.1.38 (a3e18c1b)
+
+src/utils/math.test.ts:
+(pass) adds two numbers [0.12ms]
+(pass) subtracts two numbers [0.05ms]
+  Expected: -6
+  Received: 6
+
+    at src/utils/math.test.ts:15:3
+(fail) multiplies negative numbers [0.08ms]
+
+src/utils/string.test.ts:
+(pass) capitalizes first letter [0.15ms]
+(pass) trims whitespace [0.02ms]
+  Expected: "HÉLLO"
+  Received: "HéLLO"
+
+    at src/utils/string.test.ts:28:3
+(fail) handles unicode characters [0.06ms]
+
+src/api/client.test.ts:
+(pass) fetches data successfully [3.12ms]
+  Timeout: test exceeded 5000ms
+  Expected fetch to be called 3 times, but was called 1 time
+
+    at src/api/client.test.ts:42:3
+(fail) retries on network failure [5001.00ms]
+(pass) sends auth headers [0.78ms]
+
+3 tests failed:
+(fail) multiplies negative numbers [0.08ms]
+(fail) handles unicode characters [0.06ms]
+(fail) retries on network failure [5001.00ms]
+
+ 7 pass
+ 3 fail
+ 1 skip
+ 15 expect() calls
+Ran 11 tests across 3 files. [5320.00ms]
diff --git a/tests/fixtures/bun_test_pass.txt b/tests/fixtures/bun_test_pass.txt
new file mode 100644
index 000000000..da95b1ace
--- /dev/null
+++ b/tests/fixtures/bun_test_pass.txt
@@ -0,0 +1,34 @@
+bun test v1.1.38 (a3e18c1b)
+
+src/utils/math.test.ts:
+(pass) adds two numbers [0.12ms]
+(pass) subtracts two numbers [0.05ms]
+(pass) multiplies two numbers [0.03ms]
+(pass) divides two numbers [0.04ms]
+(pass) handles division by zero [0.08ms]
+
+src/utils/string.test.ts:
+(pass) capitalizes first letter [0.15ms]
+(pass) trims whitespace [0.02ms]
+(pass) converts to camelCase [0.06ms]
+(pass) converts to snake_case [0.04ms]
+(pass) handles empty string [0.02ms]
+
+src/components/Button.test.tsx:
+(pass) renders correctly [2.45ms]
+(pass) handles click event [1.20ms]
+(pass) disables when loading [0.89ms]
+(pass) shows spinner when loading [1.05ms]
+(pass) applies custom className [0.34ms]
+
+src/api/client.test.ts:
+(pass) fetches data successfully [3.12ms]
+(pass) handles 404 error [1.56ms]
+(pass) retries on network failure [2.34ms]
+(pass) sends auth headers [0.78ms]
+(pass) handles timeout [1.92ms]
+
+ 20 pass
+ 0 fail
+ 20 expect() calls
+Ran 20 tests across 4 files. [245.00ms]
diff --git a/tests/fixtures/bun_test_real.txt b/tests/fixtures/bun_test_real.txt
new file mode 100644
index 000000000..c85da680b
--- /dev/null
+++ b/tests/fixtures/bun_test_real.txt
@@ -0,0 +1,140 @@
+bun test v1.3.10 (30e609e0)
+
+
+tests/routes/contexts.test.ts:
+(pass) context routes > GET /contexts returns empty list initially [26.73ms]
+(pass) context routes > PUT + GET /contexts/system.md round-trips content [14.51ms]
+(pass) context routes > GET /contexts lists created files [24.35ms]
+(pass) context routes > PUT /contexts/providers/anthropic.md creates nested file [17.57ms]
+
+tests/routes/executions.test.ts:
+(pass) execution routes > GET /executions/:id returns execution detail [14.16ms]
+(pass) execution routes > GET /executions/:id returns 404 for unknown id [10.62ms]
+(pass) execution routes > GET /executions/:id/logs returns logs [12.63ms]
+(pass) execution routes > GET /executions/:id/logs returns 404 for unknown execution [13.11ms]
+(pass) execution routes > POST /executions/:id/cancel > returns 404 for unknown execution [12.01ms]
+(pass) execution routes > POST /executions/:id/cancel > returns 409 for already completed execution [11.98ms]
+(pass) execution routes > POST /executions/:id/cancel > returns 409 when no abort controller is registered [14.10ms]
+(pass) execution routes > POST /executions/:id/cancel > returns cancelled: true when abort controller exists [13.60ms]
+
+tests/routes/notifications.test.ts:
+(pass) notification routes > GET /notifications returns empty list [11.55ms]
+(pass) notification routes > GET /notifications returns seeded notifications [11.45ms]
+(pass) notification routes > GET /notifications?unread=true filters unread only [11.91ms]
+(pass) notification routes > GET /notifications supports limit and offset [9.76ms]
+(pass) notification routes > GET /notifications/count returns unread count [11.85ms]
+(pass) notification routes > POST /notifications/:id/read marks notification as read [12.70ms]
+(pass) notification routes > POST /notifications/read-all marks all as read [12.24ms]
+(pass) notification preference routes > GET /notification-preferences requires scope param [11.62ms]
+(pass) notification preference routes > GET /notification-preferences?scope=system returns preferences object [12.55ms]
+(pass) notification preference routes > GET /notification-preferences rejects invalid scope [11.12ms]
+(pass) notification preference routes > PUT /notification-preferences updates a preference [11.92ms]
+(pass) notification preference routes > PUT /notification-preferences validates scope [11.14ms]
+(pass) notification preference routes > PUT /notification-preferences validates value [12.31ms]
+(pass) notification preference routes > PUT /notification-preferences requires scopeId [11.68ms]
+(pass) notification preference routes > PUT /notification-preferences requires eventType [13.92ms]
+
+tests/routes/tags.test.ts:
+(pass) tag routes > PATCH /tags/:id updates tag name [14.81ms]
+(pass) tag routes > PATCH /tags/:id updates tag color [11.18ms]
+(pass) tag routes > PATCH /tags/:id updates skillNames [11.88ms]
+(pass) tag routes > PATCH /tags/:id returns 404 for unknown id [10.73ms]
+(pass) tag routes > DELETE /tags/:id deletes tag [10.56ms]
+(pass) tag routes > DELETE /tags/:id returns 404 for nonexistent tag [9.79ms]
+
+tests/routes/tasks.test.ts:
+(pass) task routes > POST /tasks creates a task [12.30ms]
+(pass) task routes > GET /tasks/:id returns task with comments, timeline, executions [13.70ms]
+(pass) task routes > GET /tasks/:id returns 404 for unknown [9.92ms]
+(pass) task routes > PATCH /tasks/:id updates task [13.00ms]
+(pass) task routes > DELETE /tasks/:id deletes task [13.12ms]
+110 |
+111 |     const res = await app.request(json("POST", `/tasks/${created.id}/move`, { columnId: queueColumn.id }))
+112 |
+113 |     expect(res.status).toBe(200)
+114 |     const body = await res.json()
+115 |     expect(body.columnId).toBe(queueColumn.id)
+                                ^
+error: expect(received).toBe(expected)
+
+Expected: "d7f68205-8bd4-494c-a8a5-7939b4f6a443"
+Received: undefined
+
+      at <anonymous> (/home/henrique/Github/station/packages/api/tests/routes/tasks.test.ts:115:27)
+(fail) task routes > POST /tasks/:id/move moves task to another column [17.04ms]
+(pass) task routes > POST /tasks/:id/comments adds a comment [12.16ms]
+(pass) task routes > GET /tasks/:id/executions lists executions [12.16ms]
+
+tests/routes/providers.test.ts:
+(pass) provider routes > GET /providers/connections returns 200 [11.65ms]
+20 |   test("DELETE /providers/connections/:id returns 204", async () => {
+21 |     const res = await app.request(
+22 |       new Request("http://localhost/api/providers/connections/some-provider", { method: "DELETE" }),
+23 |     )
+24 |
+25 |     expect(res.status).toBe(204)
+                            ^
+error: expect(received).toBe(expected)
+
+Expected: 204
+Received: 404
+
+      at <anonymous> (/home/henrique/Github/station/packages/api/tests/routes/providers.test.ts:25:24)
+(fail) provider routes > DELETE /providers/connections/:id returns 204 [11.10ms]
+
+tests/routes/smoke.test.ts:
+(pass) API smoke test > app boots and returns 404 for unknown routes [14.23ms]
+(pass) API smoke test > CORS headers are present [12.20ms]
+
+tests/routes/boards.test.ts:
+(pass) Board routes > GET /boards/:id returns board with columns [12.20ms]
+(pass) Board routes > GET /boards/:id returns 404 for unknown [9.84ms]
+(pass) Board routes > PATCH /boards/:id updates board name [12.01ms]
+(pass) Board routes > DELETE /boards/:id deletes board [12.98ms]
+(pass) Board routes > POST /boards/:id/columns creates a column [11.82ms]
+(pass) Board routes > PATCH /boards/:id/columns/reorder reorders columns [11.34ms]
+(pass) Board routes > PATCH /boards/:id/columns/:colId updates column [12.27ms]
+(pass) Board routes > DELETE /boards/:id/columns/:colId deletes empty column [10.73ms]
+(pass) Board routes > DELETE /boards/:id/columns/:colId returns 409 when column has tasks [10.52ms]
+(pass) Board routes > GET /boards/:id/tasks returns tasks [11.80ms]
+
+tests/routes/analytics.test.ts:
+(pass) Analytics routes > GET /analytics/dashboard returns dashboard [12.21ms]
+(pass) Analytics routes > GET /analytics/models returns model usage [11.49ms]
+(pass) Analytics routes > GET /analytics/tools returns tool usage [11.63ms]
+(pass) Analytics routes > GET /analytics/daily returns daily stats [11.13ms]
+(pass) Analytics routes > GET /analytics/dashboard accepts valid date filters [13.40ms]
+(pass) Analytics routes > GET /analytics/dashboard rejects invalid date format [10.68ms]
+
+tests/routes/skills.test.ts:
+(pass) skill routes > GET /skills returns empty list initially [14.99ms]
+(pass) skill routes > POST /skills creates a global skill [14.20ms]
+(pass) skill routes > GET /skills lists created global skill [24.93ms]
+(pass) skill routes > GET /skills/projects/:projectId returns skills for project [15.09ms]
+(pass) skill routes > GET /skills/projects/:projectId returns 404 for unknown project [15.76ms]
+(pass) skill routes > POST /skills/projects/:projectId creates a project skill [17.30ms]
+(pass) skill routes > POST /skills/projects/:projectId returns 404 for unknown project [14.56ms]
+(pass) skill routes > GET /skills/projects/:projectId/:name returns skill detail [16.49ms]
+(pass) skill routes > GET /skills/projects/:projectId/:name returns 404 for unknown skill [11.55ms]
+(pass) skill routes > PUT /skills/projects/:projectId/:name updates skill content [14.59ms]
+(pass) skill routes > DELETE /skills/projects/:projectId/:name deletes skill [18.61ms]
+
+tests/routes/projects.test.ts:
+(pass) project routes > POST /projects creates a project and returns 201 [10.65ms]
+(pass) project routes > POST /projects with createDefaultBoard creates board + columns [20.49ms]
+(pass) project routes > GET /projects lists all projects [10.10ms]
+(pass) project routes > GET /projects/:id returns project [9.90ms]
+(pass) project routes > GET /projects/:id returns 404 for unknown id [10.42ms]
+(pass) project routes > PATCH /projects/:id updates project [11.11ms]
+(pass) project routes > DELETE /projects/:id deletes project [11.18ms]
+(pass) project routes > GET /projects/:id/boards lists boards [10.59ms]
+(pass) project routes > POST /projects/:id/boards creates a board [11.56ms]
+
+2 tests failed:
+(fail) task routes > POST /tasks/:id/move moves task to another column [17.04ms]
+(fail) provider routes > DELETE /providers/connections/:id returns 204 [11.10ms]
+
+ 79 pass
+ 2 fail
+ 180 expect() calls
+Ran 81 tests across 11 files. [1362.00ms]