diff --git a/src/analytics/README.md b/src/analytics/README.md
index 584b52d401..b6c6517056 100644
--- a/src/analytics/README.md
+++ b/src/analytics/README.md
@@ -4,7 +4,7 @@
 
 ## Scope
 
-**Read-only dashboards** over the tracking database. Analytics presents the value that `cmds/` creates — it queries token savings, correlates with external spending data, and surfaces adoption opportunities. It never modifies the tracking DB.
+**Read-only dashboards** over the tracking database. Queries token savings, correlates with external spending data, and surfaces adoption metrics. Never modifies the tracking DB.
 
 Owns: `rtk gain` (savings dashboard), `rtk cc-economics` (cost reduction), `rtk session` (adoption analysis), and Claude Code usage data parsing.
 
@@ -15,7 +15,7 @@ Boundary rule: if a new module writes to the DB, it belongs in `core/` or `cmds/
 ## Purpose
 Token savings analytics, economic modeling, and adoption metrics.
 
-These modules read from the SQLite tracking database to produce dashboards, spending estimates, and session-level adoption reports that help users understand the value RTK provides.
+These modules read from the SQLite tracking database to produce dashboards, spending estimates, and session-level adoption reports.
 
 ## Adding New Functionality
 To add a new analytics view: (1) create a new `*_cmd.rs` file in this directory, (2) query `core/tracking` for the metrics you need using the existing `TrackingDb` API, (3) register the command in `main.rs` under the `Commands` enum, and (4) add `#[cfg(test)]` unit tests with sample tracking data. Analytics modules should be read-only against the tracking database and never modify it.
diff --git a/src/analytics/cc_economics.rs b/src/analytics/cc_economics.rs
index 693dc61e2d..0375931027 100644
--- a/src/analytics/cc_economics.rs
+++ b/src/analytics/cc_economics.rs
@@ -14,9 +14,6 @@ use crate::core::utils::{format_cpt, format_tokens, format_usd};
 
 // ── Constants ──
 
-#[allow(dead_code)]
-const BILLION: f64 = 1e9;
-
 // API pricing ratios (verified Feb 2026, consistent across Claude models <=200K context)
 // Source: https://docs.anthropic.com/en/docs/about-claude/models
 const WEIGHT_OUTPUT: f64 = 5.0; // Output = 5x input
diff --git a/src/analytics/ccusage.rs b/src/analytics/ccusage.rs
index 49bd5bc8da..15d73109be 100644
--- a/src/analytics/ccusage.rs
+++ b/src/analytics/ccusage.rs
@@ -111,12 +111,6 @@ fn build_command() -> Option<Command> {
     None
 }
 
-/// Check if ccusage CLI is available (binary or via npx)
-#[allow(dead_code)]
-pub fn is_available() -> bool {
-    build_command().is_some()
-}
-
 /// Fetch usage data from ccusage for the last 90 days
 ///
 /// Returns `Ok(None)` if ccusage is unavailable (graceful degradation)
@@ -328,11 +322,4 @@ mod tests {
         assert_eq!(periods[0].metrics.cache_creation_tokens, 0); // default
         assert_eq!(periods[0].metrics.cache_read_tokens, 0);
     }
-
-    #[test]
-    fn test_is_available() {
-        // Just smoke test - actual availability depends on system
-        let _available = is_available();
-        // No assertion - just ensure it doesn't panic
-    }
 }
diff --git a/src/cmds/README.md b/src/cmds/README.md
index a84e8e7442..f48119d55f 100644
--- a/src/cmds/README.md
+++ b/src/cmds/README.md
@@ -2,7 +2,7 @@
 
 ## Scope
 
-**Command execution and output filtering** — this is the core value RTK delivers. Every module here calls an external CLI tool (`Command::new("some_tool")`), transforms its stdout/stderr to reduce token consumption, and records savings via `core/tracking`.
+**Command execution and output filtering.** Every module here calls an external CLI tool (`Command::new("some_tool")`), transforms its stdout/stderr to reduce token consumption, and records savings via `core/tracking`.
 
 Owns: all command-specific filter logic, organized by ecosystem (git, rust, js, python, go, dotnet, cloud, system). Cross-ecosystem routing (e.g., `lint_cmd` detecting Python and delegating to `ruff_cmd`) is an intra-component concern.
 
@@ -35,47 +35,92 @@ Each subdirectory has its own README with file descriptions, parsing strategies,
 - **[`system/`](system/README.md)** — ls, tree, read, grep, find, wc, env, json, log, deps, summary, format, smart — format_cmd routing, filter levels, language detection
 - **[`ruby/`](ruby/README.md)** — rake/rails test, rspec, rubocop — JSON injection pattern, `ruby_exec()` bundle exec auto-detection
 
-## Common Pattern
+## Execution Flow: `runner::run_filtered()`
 
-Every command module follows this structure:
+The shared wrapper in [`core/runner.rs`](../core/runner.rs) encapsulates the six-phase execution skeleton. Modules build the `Command` (custom arg logic), then delegate to `run_filtered()` for everything else.
+
+```
+ cmd.output()          Filter applied to         tee_and_hint()
+      |                stdout or combined              |
+      v                       |                        v
+ +---------+  stdout  +-------+-------+  filtered  +-------+
+ | Execute |--------->| filter_fn()   |----------->| Print |
+ +---------+  stderr  +---------------+            +-------+
+      |                                                |
+      v                                                v
+ +----------+                                    +---------+
+ | raw =    |                                    | Track   |
+ | stdout + |                                    | savings |
+ | stderr   |                                    +---------+
+ +----------+                                          |
+                                                       v
+                                                 +-----------+
+                                                 | Ok(code)  |
+                                                 | returned  |
+                                                 +-----------+
+```
+
+**Six phases in order:**
+
+1. **Execute** — `cmd.output()` captures stdout + stderr
+2. **Filter** — `filter_fn` receives stdout-only or combined, returns compressed string
+3. **Print** — filtered output printed; if tee enabled, appends recovery hint on failure
+4. **Stderr passthrough** — when `filter_stdout_only`: stderr printed via `eprintln!()` unconditionally
+5. **Track** — `timer.track()` records raw vs filtered for token savings
+6. **Exit code** — returns `Ok(exit_code)` to caller; `main.rs` calls `process::exit(code)` once
+
+**`RunOptions` builder:**
+
+| Constructor | Behavior |
+|-------------|----------|
+| `RunOptions::default()` | Combined stdout+stderr to filter, no tee |
+| `RunOptions::with_tee("label")` | Combined filtering + tee recovery |
+| `RunOptions::stdout_only()` | Stdout-only to filter, stderr passthrough, no tee |
+| `RunOptions::stdout_only().tee("label")` | Stdout-only + tee recovery |
+
+**Example — filtered command (recommended):**
 
 ```rust
-pub fn run(args: MyArgs, verbose: u8) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-    let output = resolved_command("mycmd").args(&args).output().context("Failed to execute mycmd")?;
-    let raw = format!("{}\n{}", String::from_utf8_lossy(&output.stdout), String::from_utf8_lossy(&output.stderr));
-
-    let filtered = filter_output(&raw).unwrap_or_else(|e| {
-        eprintln!("rtk: filter warning: {}", e);
-        raw.clone()  // Fallback to raw on filter failure
-    });
-
-    let exit_code = output.status.code().unwrap_or(1);
-    if let Some(hint) = tee::tee_and_hint(&raw, "mycmd", exit_code) {
-        println!("{}\n{}", filtered, hint);
-    } else {
-        println!("{}", filtered);
-    }
-
-    timer.track("mycmd args", "rtk mycmd args", &raw, &filtered);
-    if !output.status.success() { std::process::exit(exit_code); }
-    Ok(())
+pub fn run(args: &[String], verbose: u8) -> Result<i32> {
+    let mut cmd = resolved_command("mycmd");
+    for arg in args { cmd.arg(arg); }
+    if verbose > 0 { eprintln!("Running: mycmd {}", args.join(" ")); }
+
+    runner::run_filtered(
+        cmd, "mycmd", &args.join(" "),
+        filter_mycmd_output,
+        runner::RunOptions::stdout_only().tee("mycmd"),
+    )
 }
 ```
 
-Six phases: **timer** → **execute** → **filter (with fallback)** → **tee on failure** → **track** → **exit code**. See [core/README.md](../core/README.md#consumer-contracts) for the contracts each phase must honor.
+Exit code handling is **fully automatic** when using `run_filtered()` — the wrapper extracts the exit code (including Unix signal handling via 128+signal), tracks savings, and returns `Ok(exit_code)`. Module authors just return the result.
 
-## Token Savings by Category
+**Example — passthrough command (no filtering):**
+
+```rust
+pub fn run_passthrough(args: &[OsString], verbose: u8) -> Result<i32> {
+    let status = resolved_command("mycmd").args(args)
+        .stdin(Stdio::inherit()).stdout(Stdio::inherit()).stderr(Stdio::inherit())
+        .status().context("Failed to run mycmd")?;
+    Ok(exit_code_from_status(&status, "mycmd"))
+}
+```
+
+**Example — manual execution (custom logic):**
+
+```rust
+pub fn run(args: &[String], verbose: u8) -> Result<i32> {
+    let output = resolved_command("mycmd").args(args)
+        .output().context("Failed to run mycmd")?;
+    let exit_code = exit_code_from_output(&output, "mycmd");
+    // ... custom filtering, tracking ...
+    Ok(exit_code)
+}
+```
+
+Modules with deviations (subcommand dispatch, parser trait systems, two-command fallback, synthetic output).
 
-| Category | Commands | Typical Savings | Strategy |
-|----------|----------|----------------|----------|
-| Test Runners | vitest, pytest, cargo test, go test, playwright | 90-99% | Show failures only, aggregate passes |
-| Build Tools | cargo build, npm, pnpm, dotnet | 70-90% | Strip progress bars, summarize errors |
-| VCS | git status/log/diff/show | 70-80% | Compact commit hashes, stat summaries |
-| Linters | eslint/biome, ruff, tsc, mypy, golangci-lint | 80-85% | Group by file/rule, strip context |
-| Package Managers | pip, cargo install, pnpm list | 75-80% | Remove decorative output, compact trees |
-| File Operations | ls, find, grep, cat/head/tail | 60-75% | Tree format, grouped results, truncation |
-| Infrastructure | docker, kubectl, aws, terraform | 75-85% | Essential info only |
 
 ## Cross-Command Dependencies
 
@@ -89,7 +134,25 @@ These behaviors must be uniform across all command modules. Full audit details i
 
 ### Exit Code Propagation
 
-Modules must capture the underlying command's exit code, propagate it via `std::process::exit()` only on failure, and return `Ok(())` on success. When the process is killed by signal (`.code()` returns `None`), default to exit code 1.
+All module `run()` functions return `Result<i32>` where the `i32` is the underlying command's exit code. `main.rs` calls `std::process::exit(code)` once at the single exit point — **modules never call `process::exit()` directly**.
+
+| Return value | Meaning | Who exits |
+|--------------|---------|-----------|
+| `Ok(0)` | Command succeeded | `main.rs` exits 0 |
+| `Ok(N)` | Command failed with code N | `main.rs` exits N |
+| `Err(e)` | RTK itself failed (not the command) | `main.rs` prints error, exits 1 |
+
+**How exit codes are extracted:**
+
+| Execution style | Helper | Signal handling |
+|----------------|--------|-----------------|
+| `cmd.output()` (filtered) | `exit_code_from_output(&output, "tool")` | 128+signal on Unix |
+| `cmd.status()` (passthrough) | `exit_code_from_status(&status, "tool")` | 128+signal on Unix |
+| `run_filtered()` (wrapper) | Automatic — no manual code needed | Built-in |
+
+**When using `run_filtered()`**: exit code handling is fully automatic. The wrapper extracts the exit code, handles signals, and returns `Ok(exit_code)`. Module authors just return the wrapper's result — no exit code logic needed.
+
+**When doing manual execution**: use `exit_code_from_output()` or `exit_code_from_status()` and return `Ok(exit_code)`. Never call `process::exit()`, never use `.code().unwrap_or(1)` (loses signal info).
 
 ### Filter Failure Passthrough
 
@@ -105,50 +168,36 @@ Modules must capture stderr and include it in the raw string passed to `timer.tr
 
 ### Tracking Completeness
 
-All modules must call `timer.track()` on every path — success, failure, and fallback. Never exit before tracking.
+All modules must call `timer.track()` on every path — success, failure, and fallback. Since modules return `Ok(exit_code)` instead of calling `process::exit()`, tracking always runs before the program exits.
 
 ### Verbose Flag
 
 All modules accept `verbose: u8`. Use it to print debug info (command being run, savings %, filter tier). Do not accept and ignore it.
 
-### Gaps (to be fixed)
-
-**Exit code** — 5 different patterns coexist, should be reviewed for uniform behavior:
-- `vitest_cmd.rs`, `tsc_cmd.rs`, `psql_cmd.rs` — exit unconditionally, even on success
-- `lint_cmd.rs` — swallows signal kills silently
-- `golangci_cmd.rs` — maps signal kill to exit 130 (correct but unique)
-
-**Filter passthrough** — silent passthrough, no warning:
-- `gh_cmd.rs`, `pip_cmd.rs`, `container.rs`, `dotnet_cmd.rs` — `run_passthrough()` skips filtering without warning
-- `pnpm_cmd.rs` — 3-tier degradation but no tee recovery on final tier
-
-**Tee recovery** — missing from some high-risk modules:
-- `pnpm_cmd.rs` — 3-tier parser, no tee
-- `gh_cmd.rs` — aggressive markdown filtering, no tee
-- `ruff_cmd.rs`, `golangci_cmd.rs` — JSON parsers, no tee
-- `psql_cmd.rs` — has tee but exits before calling it on error path
-
-**Stderr handling** — 3 patterns coexist. Some modules combine stderr into raw (correct), others print via `eprintln!()` and exclude from tracking (inflates savings %). See `docs/ISO_ANALYZE.md` section 4.
-
-**Tracking** — exit before track on error path:
-- `ls.rs`, `tree.rs` — lost metrics on failure
-- `container.rs` — inconsistent across subcommands
-
-**Verbose** — accept parameter but ignore it:
-- `container.rs` — all internal functions prefix `_verbose`
-- `diff_cmd.rs` — `_verbose` unused
 
 ## Adding a New Command Filter
 
-Adding a new filter or command requires changes in multiple places:
+Adding a new filter or command requires changes in multiple places. For TOML-vs-Rust decision criteria, see [CONTRIBUTING.md](../../CONTRIBUTING.md#toml-vs-rust-which-one).
+
+### Rust module (structured output, flag injection, state machines)
 
-1. **Create the filter** — TOML file in [`src/filters/`](../filters/README.md) or Rust module in `src/cmds/<ecosystem>/`
-2. **Add rewrite pattern** — Entry in `src/discover/rules.rs` (PATTERNS + RULES arrays at matching index) so hooks auto-rewrite the command
-3. **Register in main.rs** — (Rust modules only) Three changes:
-   - Add `pub mod mymod;` to the ecosystem's `mod.rs` (e.g., `src/cmds/system/mod.rs`)
+1. **Create module** in `src/cmds/<ecosystem>/mycmd_cmd.rs`:
+   - Write the `filter_mycmd()` function (pure: `&str -> String`, no side effects)
+   - Write `pub fn run(...) -> Result<i32>` using `runner::run_filtered()` — build the `Command`, choose `RunOptions`, delegate
+   - Use `RunOptions::stdout_only()` when the filter parses structured stdout (JSON, NDJSON) — stderr would corrupt parsing
+   - Use `RunOptions::default()` when filtering combined text output
+   - Add `.tee("label")` when the filter parses structured output (enables raw output recovery on failure)
+   - **Exit codes**: handled automatically by `run_filtered()` — just return its result
+2. **Register module**:
+   - Add `pub mod mycmd_cmd;` to the ecosystem's `mod.rs`
    - Add variant to `Commands` enum in `main.rs` with `#[arg(trailing_var_arg = true, allow_hyphen_values = true)]`
-   - Add routing match arm in `main.rs` to call `mymod::run()`
+   - Add routing match arm in `main.rs`: `Commands::Mycmd { args } => mycmd_cmd::run(&args, cli.verbose)?,`
+3. **Add rewrite pattern** — Entry in `src/discover/rules.rs` (PATTERNS + RULES arrays at matching index) so hooks auto-rewrite the command
 4. **Write tests** — Real fixture, snapshot test, token savings >= 60% (see [testing rules](../../.claude/rules/cli-testing.md))
-5. **Update docs** — README.md command list, CHANGELOG.md
+5. **Update docs** — Ecosystem README, CHANGELOG.md
+
+### TOML filter (simple line-based filtering)
 
-Follow the [Common Pattern](#common-pattern) above for the module template (timer, fallback, tee, tracking, exit code). For TOML-vs-Rust decision criteria, see [CONTRIBUTING.md](../../CONTRIBUTING.md#toml-vs-rust-which-one).
+1. **Create filter** in [`src/filters/`](../filters/README.md)
+2. **Add rewrite pattern** in `src/discover/rules.rs`
+3. **Write tests** and **update docs**
diff --git a/src/cmds/cloud/aws_cmd.rs b/src/cmds/cloud/aws_cmd.rs
index bb1757ec13..2b1e9929ff 100644
--- a/src/cmds/cloud/aws_cmd.rs
+++ b/src/cmds/cloud/aws_cmd.rs
@@ -4,7 +4,10 @@
 //! Specialized filters for high-frequency commands (STS, S3, EC2, ECS, RDS, CloudFormation).
 
 use crate::core::tracking;
-use crate::core::utils::{join_with_overflow, resolved_command, truncate_iso_date};
+use crate::core::utils::{
+    exit_code_from_output, exit_code_from_status, join_with_overflow, resolved_command,
+    truncate_iso_date,
+};
 use crate::json_cmd;
 use anyhow::{Context, Result};
 use serde_json::Value;
@@ -13,7 +16,7 @@ const MAX_ITEMS: usize = 20;
 const JSON_COMPRESS_DEPTH: usize = 4;
 
 /// Run an AWS CLI command with token-optimized output
-pub fn run(subcommand: &str, args: &[String], verbose: u8) -> Result<()> {
+pub fn run(subcommand: &str, args: &[String], verbose: u8) -> Result<i32> {
     // Build the full sub-path: e.g. "sts" + ["get-caller-identity"] -> "sts get-caller-identity"
     let full_sub = if args.is_empty() {
         subcommand.to_string()
@@ -58,7 +61,7 @@ fn is_structured_operation(args: &[String]) -> bool {
 }
 
 /// Generic strategy: force --output json for structured ops, compress via json_cmd schema
-fn run_generic(subcommand: &str, args: &[String], verbose: u8, full_sub: &str) -> Result<()> {
+fn run_generic(subcommand: &str, args: &[String], verbose: u8, full_sub: &str) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     let mut cmd = resolved_command("aws");
@@ -95,7 +98,7 @@ fn run_generic(subcommand: &str, args: &[String], verbose: u8, full_sub: &str) -
             &stderr,
         );
         eprintln!("{}", stderr.trim());
-        std::process::exit(output.status.code().unwrap_or(1));
+        return Ok(exit_code_from_output(&output, "aws"));
     }
 
     let filtered = match json_cmd::filter_json_string(&raw, JSON_COMPRESS_DEPTH) {
@@ -117,7 +120,7 @@ fn run_generic(subcommand: &str, args: &[String], verbose: u8, full_sub: &str) -
         &filtered,
     );
 
-    Ok(())
+    Ok(0)
 }
 
 fn run_aws_json(
@@ -163,7 +166,7 @@ fn run_aws_json(
     Ok((stdout, stderr, output.status))
 }
 
-fn run_sts_identity(extra_args: &[String], verbose: u8) -> Result<()> {
+fn run_sts_identity(extra_args: &[String], verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
     let (raw, stderr, status) = run_aws_json(&["sts", "get-caller-identity"], extra_args, verbose)?;
 
@@ -174,7 +177,7 @@ fn run_sts_identity(extra_args: &[String], verbose: u8) -> Result<()> {
             &stderr,
             &stderr,
         );
-        std::process::exit(status.code().unwrap_or(1));
+        return Ok(exit_code_from_status(&status, "aws"));
     }
 
     let filtered = match filter_sts_identity(&raw) {
@@ -189,10 +192,10 @@ fn run_sts_identity(extra_args: &[String], verbose: u8) -> Result<()> {
         &raw,
         &filtered,
     );
-    Ok(())
+    Ok(0)
 }
 
-fn run_s3_ls(extra_args: &[String], verbose: u8) -> Result<()> {
+fn run_s3_ls(extra_args: &[String], verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     // s3 ls doesn't support --output json, run as-is and filter text
@@ -213,17 +216,17 @@ fn run_s3_ls(extra_args: &[String], verbose: u8) -> Result<()> {
         let stderr = String::from_utf8_lossy(&output.stderr).to_string();
         timer.track("aws s3 ls", "rtk aws s3 ls", &stderr, &stderr);
         eprintln!("{}", stderr.trim());
-        std::process::exit(output.status.code().unwrap_or(1));
+        return Ok(exit_code_from_output(&output, "aws"));
     }
 
     let filtered = filter_s3_ls(&raw);
     println!("{}", filtered);
 
     timer.track("aws s3 ls", "rtk aws s3 ls", &raw, &filtered);
-    Ok(())
+    Ok(0)
 }
 
-fn run_ec2_describe(extra_args: &[String], verbose: u8) -> Result<()> {
+fn run_ec2_describe(extra_args: &[String], verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
     let (raw, stderr, status) = run_aws_json(&["ec2", "describe-instances"], extra_args, verbose)?;
 
@@ -234,7 +237,7 @@ fn run_ec2_describe(extra_args: &[String], verbose: u8) -> Result<()> {
             &stderr,
             &stderr,
         );
-        std::process::exit(status.code().unwrap_or(1));
+        return Ok(exit_code_from_status(&status, "aws"));
     }
 
     let filtered = match filter_ec2_instances(&raw) {
@@ -249,10 +252,10 @@ fn run_ec2_describe(extra_args: &[String], verbose: u8) -> Result<()> {
         &raw,
         &filtered,
     );
-    Ok(())
+    Ok(0)
 }
 
-fn run_ecs_list_services(extra_args: &[String], verbose: u8) -> Result<()> {
+fn run_ecs_list_services(extra_args: &[String], verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
     let (raw, stderr, status) = run_aws_json(&["ecs", "list-services"], extra_args, verbose)?;
 
@@ -263,7 +266,7 @@ fn run_ecs_list_services(extra_args: &[String], verbose: u8) -> Result<()> {
             &stderr,
             &stderr,
         );
-        std::process::exit(status.code().unwrap_or(1));
+        return Ok(exit_code_from_status(&status, "aws"));
     }
 
     let filtered = match filter_ecs_list_services(&raw) {
@@ -278,10 +281,10 @@ fn run_ecs_list_services(extra_args: &[String], verbose: u8) -> Result<()> {
         &raw,
         &filtered,
     );
-    Ok(())
+    Ok(0)
 }
 
-fn run_ecs_describe_services(extra_args: &[String], verbose: u8) -> Result<()> {
+fn run_ecs_describe_services(extra_args: &[String], verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
     let (raw, stderr, status) = run_aws_json(&["ecs", "describe-services"], extra_args, verbose)?;
 
@@ -292,7 +295,7 @@ fn run_ecs_describe_services(extra_args: &[String], verbose: u8) -> Result<()> {
             &stderr,
             &stderr,
         );
-        std::process::exit(status.code().unwrap_or(1));
+        return Ok(exit_code_from_status(&status, "aws"));
     }
 
     let filtered = match filter_ecs_describe_services(&raw) {
@@ -307,10 +310,10 @@ fn run_ecs_describe_services(extra_args: &[String], verbose: u8) -> Result<()> {
         &raw,
         &filtered,
     );
-    Ok(())
+    Ok(0)
 }
 
-fn run_rds_describe(extra_args: &[String], verbose: u8) -> Result<()> {
+fn run_rds_describe(extra_args: &[String], verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
     let (raw, stderr, status) =
         run_aws_json(&["rds", "describe-db-instances"], extra_args, verbose)?;
@@ -322,7 +325,7 @@ fn run_rds_describe(extra_args: &[String], verbose: u8) -> Result<()> {
             &stderr,
             &stderr,
         );
-        std::process::exit(status.code().unwrap_or(1));
+        return Ok(exit_code_from_status(&status, "aws"));
     }
 
     let filtered = match filter_rds_instances(&raw) {
@@ -337,10 +340,10 @@ fn run_rds_describe(extra_args: &[String], verbose: u8) -> Result<()> {
         &raw,
         &filtered,
     );
-    Ok(())
+    Ok(0)
 }
 
-fn run_cfn_list_stacks(extra_args: &[String], verbose: u8) -> Result<()> {
+fn run_cfn_list_stacks(extra_args: &[String], verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
     let (raw, stderr, status) =
         run_aws_json(&["cloudformation", "list-stacks"], extra_args, verbose)?;
@@ -352,7 +355,7 @@ fn run_cfn_list_stacks(extra_args: &[String], verbose: u8) -> Result<()> {
             &stderr,
             &stderr,
         );
-        std::process::exit(status.code().unwrap_or(1));
+        return Ok(exit_code_from_status(&status, "aws"));
     }
 
     let filtered = match filter_cfn_list_stacks(&raw) {
@@ -367,10 +370,10 @@ fn run_cfn_list_stacks(extra_args: &[String], verbose: u8) -> Result<()> {
         &raw,
         &filtered,
     );
-    Ok(())
+    Ok(0)
 }
 
-fn run_cfn_describe_stacks(extra_args: &[String], verbose: u8) -> Result<()> {
+fn run_cfn_describe_stacks(extra_args: &[String], verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
     let (raw, stderr, status) =
         run_aws_json(&["cloudformation", "describe-stacks"], extra_args, verbose)?;
@@ -382,7 +385,7 @@ fn run_cfn_describe_stacks(extra_args: &[String], verbose: u8) -> Result<()> {
             &stderr,
             &stderr,
         );
-        std::process::exit(status.code().unwrap_or(1));
+        return Ok(exit_code_from_status(&status, "aws"));
     }
 
     let filtered = match filter_cfn_describe_stacks(&raw) {
@@ -397,7 +400,7 @@ fn run_cfn_describe_stacks(extra_args: &[String], verbose: u8) -> Result<()> {
         &raw,
         &filtered,
     );
-    Ok(())
+    Ok(0)
 }
 
 // --- Filter functions (all use serde_json::Value for resilience) ---
diff --git a/src/cmds/cloud/container.rs b/src/cmds/cloud/container.rs
index b4e0057ab8..0d6cede85d 100644
--- a/src/cmds/cloud/container.rs
+++ b/src/cmds/cloud/container.rs
@@ -1,7 +1,7 @@
 //! Filters Docker and kubectl output into compact summaries.
 
 use crate::core::tracking;
-use crate::core::utils::resolved_command;
+use crate::core::utils::{exit_code_from_output, exit_code_from_status, resolved_command};
 use anyhow::{Context, Result};
 use std::ffi::OsString;
 
@@ -15,7 +15,7 @@ pub enum ContainerCmd {
     KubectlLogs,
 }
 
-pub fn run(cmd: ContainerCmd, args: &[String], verbose: u8) -> Result<()> {
+pub fn run(cmd: ContainerCmd, args: &[String], verbose: u8) -> Result<i32> {
     match cmd {
         ContainerCmd::DockerPs => docker_ps(verbose),
         ContainerCmd::DockerImages => docker_images(verbose),
@@ -26,7 +26,7 @@ pub fn run(cmd: ContainerCmd, args: &[String], verbose: u8) -> Result<()> {
     }
 }
 
-fn docker_ps(_verbose: u8) -> Result<()> {
+fn docker_ps(_verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     let raw = resolved_command("docker")
@@ -48,7 +48,7 @@ fn docker_ps(_verbose: u8) -> Result<()> {
         let stderr = String::from_utf8_lossy(&output.stderr);
         eprint!("{}", stderr);
         timer.track("docker ps", "rtk docker ps", &raw, &raw);
-        std::process::exit(output.status.code().unwrap_or(1));
+        return Ok(exit_code_from_output(&output, "docker"));
     }
 
     let stdout = String::from_utf8_lossy(&output.stdout);
@@ -58,7 +58,7 @@ fn docker_ps(_verbose: u8) -> Result<()> {
         rtk.push_str("[docker] 0 containers");
         println!("{}", rtk);
         timer.track("docker ps", "rtk docker ps", &raw, &rtk);
-        return Ok(());
+        return Ok(0);
     }
 
     let count = stdout.lines().count();
@@ -92,10 +92,10 @@ fn docker_ps(_verbose: u8) -> Result<()> {
 
     print!("{}", rtk);
     timer.track("docker ps", "rtk docker ps", &raw, &rtk);
-    Ok(())
+    Ok(0)
 }
 
-fn docker_images(_verbose: u8) -> Result<()> {
+fn docker_images(_verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     let raw = resolved_command("docker")
@@ -113,7 +113,7 @@ fn docker_images(_verbose: u8) -> Result<()> {
         let stderr = String::from_utf8_lossy(&output.stderr);
         eprint!("{}", stderr);
         timer.track("docker images", "rtk docker images", &raw, &raw);
-        std::process::exit(output.status.code().unwrap_or(1));
+        return Ok(exit_code_from_output(&output, "docker"));
     }
 
     let stdout = String::from_utf8_lossy(&output.stdout);
@@ -124,7 +124,7 @@ fn docker_images(_verbose: u8) -> Result<()> {
         rtk.push_str("[docker] 0 images");
         println!("{}", rtk);
         timer.track("docker images", "rtk docker images", &raw, &rtk);
-        return Ok(());
+        return Ok(0);
     }
 
     let mut total_size_mb: f64 = 0.0;
@@ -173,16 +173,16 @@ fn docker_images(_verbose: u8) -> Result<()> {
 
     print!("{}", rtk);
     timer.track("docker images", "rtk docker images", &raw, &rtk);
-    Ok(())
+    Ok(0)
 }
 
-fn docker_logs(args: &[String], _verbose: u8) -> Result<()> {
+fn docker_logs(args: &[String], _verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     let container = args.first().map(|s| s.as_str()).unwrap_or("");
     if container.is_empty() {
         println!("Usage: rtk docker logs <container>");
-        return Ok(());
+        return Ok(0);
     }
 
     let output = resolved_command("docker")
@@ -204,7 +204,7 @@ fn docker_logs(args: &[String], _verbose: u8) -> Result<()> {
             &raw,
             &raw,
         );
-        std::process::exit(output.status.code().unwrap_or(1));
+        return Ok(exit_code_from_output(&output, "docker"));
     }
 
     let analyzed = crate::log_cmd::run_stdin_str(&raw);
@@ -216,10 +216,10 @@ fn docker_logs(args: &[String], _verbose: u8) -> Result<()> {
         &raw,
         &rtk,
     );
-    Ok(())
+    Ok(0)
 }
 
-fn kubectl_pods(args: &[String], _verbose: u8) -> Result<()> {
+fn kubectl_pods(args: &[String], _verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     let mut cmd = resolved_command("kubectl");
@@ -238,7 +238,7 @@ fn kubectl_pods(args: &[String], _verbose: u8) -> Result<()> {
             eprint!("{}", stderr);
         }
         timer.track("kubectl get pods", "rtk kubectl pods", &raw, &raw);
-        std::process::exit(output.status.code().unwrap_or(1));
+        return Ok(exit_code_from_output(&output, "kubectl"));
     }
 
     let json: serde_json::Value = match serde_json::from_str(&raw) {
@@ -247,7 +247,7 @@ fn kubectl_pods(args: &[String], _verbose: u8) -> Result<()> {
             rtk.push_str("No pods found");
             println!("{}", rtk);
             timer.track("kubectl get pods", "rtk kubectl pods", &raw, &rtk);
-            return Ok(());
+            return Ok(0);
         }
     };
 
@@ -255,7 +255,7 @@ fn kubectl_pods(args: &[String], _verbose: u8) -> Result<()> {
         rtk.push_str("No pods found");
         println!("{}", rtk);
         timer.track("kubectl get pods", "rtk kubectl pods", &raw, &rtk);
-        return Ok(());
+        return Ok(0);
     };
     let (mut running, mut pending, mut failed, mut restarts_total) = (0, 0, 0, 0i64);
     let mut issues: Vec<String> = Vec::new();
@@ -323,10 +323,10 @@ fn kubectl_pods(args: &[String], _verbose: u8) -> Result<()> {
 
     print!("{}", rtk);
     timer.track("kubectl get pods", "rtk kubectl pods", &raw, &rtk);
-    Ok(())
+    Ok(0)
 }
 
-fn kubectl_services(args: &[String], _verbose: u8) -> Result<()> {
+fn kubectl_services(args: &[String], _verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     let mut cmd = resolved_command("kubectl");
@@ -345,7 +345,7 @@ fn kubectl_services(args: &[String], _verbose: u8) -> Result<()> {
             eprint!("{}", stderr);
         }
         timer.track("kubectl get svc", "rtk kubectl svc", &raw, &raw);
-        std::process::exit(output.status.code().unwrap_or(1));
+        return Ok(exit_code_from_output(&output, "kubectl"));
     }
 
     let json: serde_json::Value = match serde_json::from_str(&raw) {
@@ -354,7 +354,7 @@ fn kubectl_services(args: &[String], _verbose: u8) -> Result<()> {
             rtk.push_str("No services found");
             println!("{}", rtk);
             timer.track("kubectl get svc", "rtk kubectl svc", &raw, &rtk);
-            return Ok(());
+            return Ok(0);
         }
     };
 
@@ -362,7 +362,7 @@ fn kubectl_services(args: &[String], _verbose: u8) -> Result<()> {
         rtk.push_str("No services found");
         println!("{}", rtk);
         timer.track("kubectl get svc", "rtk kubectl svc", &raw, &rtk);
-        return Ok(());
+        return Ok(0);
     };
     rtk.push_str(&format!("{} services:\n", services.len()));
 
@@ -403,16 +403,16 @@ fn kubectl_services(args: &[String], _verbose: u8) -> Result<()> {
 
     print!("{}", rtk);
     timer.track("kubectl get svc", "rtk kubectl svc", &raw, &rtk);
-    Ok(())
+    Ok(0)
 }
 
-fn kubectl_logs(args: &[String], _verbose: u8) -> Result<()> {
+fn kubectl_logs(args: &[String], _verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     let pod = args.first().map(|s| s.as_str()).unwrap_or("");
     if pod.is_empty() {
         println!("Usage: rtk kubectl logs <pod>");
-        return Ok(());
+        return Ok(0);
     }
 
     let mut cmd = resolved_command("kubectl");
@@ -435,7 +435,7 @@ fn kubectl_logs(args: &[String], _verbose: u8) -> Result<()> {
             &raw,
             &raw,
         );
-        std::process::exit(output.status.code().unwrap_or(1));
+        return Ok(exit_code_from_output(&output, "kubectl"));
     }
 
     let analyzed = crate::log_cmd::run_stdin_str(&raw);
@@ -447,7 +447,7 @@ fn kubectl_logs(args: &[String], _verbose: u8) -> Result<()> {
         &raw,
         &rtk,
     );
-    Ok(())
+    Ok(0)
 }
 
 /// Format `docker compose ps --format` output into compact form.
@@ -588,7 +588,7 @@ fn compact_ports(ports: &str) -> String {
 }
 
 /// Runs an unsupported docker subcommand by passing it through directly
-pub fn run_docker_passthrough(args: &[OsString], verbose: u8) -> Result<()> {
+pub fn run_docker_passthrough(args: &[OsString], verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     if verbose > 0 {
@@ -605,14 +605,11 @@ pub fn run_docker_passthrough(args: &[OsString], verbose: u8) -> Result<()> {
         &format!("rtk docker {} (passthrough)", args_str),
     );
 
-    if !status.success() {
-        std::process::exit(status.code().unwrap_or(1));
-    }
-    Ok(())
+    Ok(exit_code_from_status(&status, "docker"))
 }
 
 /// Run `docker compose ps` with compact output
-pub fn run_compose_ps(verbose: u8) -> Result<()> {
+pub fn run_compose_ps(verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     // Raw output for token tracking
@@ -624,7 +621,7 @@ pub fn run_compose_ps(verbose: u8) -> Result<()> {
     if !raw_output.status.success() {
         let stderr = String::from_utf8_lossy(&raw_output.stderr);
         eprintln!("{}", stderr);
-        std::process::exit(raw_output.status.code().unwrap_or(1));
+        return Ok(exit_code_from_output(&raw_output, "docker"));
     }
     let raw = String::from_utf8_lossy(&raw_output.stdout).to_string();
 
@@ -642,7 +639,7 @@ pub fn run_compose_ps(verbose: u8) -> Result<()> {
     if !output.status.success() {
         let stderr = String::from_utf8_lossy(&output.stderr);
         eprintln!("{}", stderr);
-        std::process::exit(output.status.code().unwrap_or(1));
+        return Ok(exit_code_from_output(&output, "docker"));
     }
     let structured = String::from_utf8_lossy(&output.stdout).to_string();
 
@@ -653,11 +650,11 @@ pub fn run_compose_ps(verbose: u8) -> Result<()> {
     let rtk = format_compose_ps(&structured);
     println!("{}", rtk);
     timer.track("docker compose ps", "rtk docker compose ps", &raw, &rtk);
-    Ok(())
+    Ok(0)
 }
 
 /// Run `docker compose logs` with deduplication
-pub fn run_compose_logs(service: Option<&str>, verbose: u8) -> Result<()> {
+pub fn run_compose_logs(service: Option<&str>, verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     let mut cmd = resolved_command("docker");
@@ -671,7 +668,7 @@ pub fn run_compose_logs(service: Option<&str>, verbose: u8) -> Result<()> {
     if !output.status.success() {
         let stderr = String::from_utf8_lossy(&output.stderr);
         eprintln!("{}", stderr);
-        std::process::exit(output.status.code().unwrap_or(1));
+        return Ok(exit_code_from_output(&output, "docker"));
     }
 
     let stdout = String::from_utf8_lossy(&output.stdout);
@@ -691,11 +688,11 @@ pub fn run_compose_logs(service: Option<&str>, verbose: u8) -> Result<()> {
         &raw,
         &rtk,
     );
-    Ok(())
+    Ok(0)
 }
 
 /// Run `docker compose build` with summary output
-pub fn run_compose_build(service: Option<&str>, verbose: u8) -> Result<()> {
+pub fn run_compose_build(service: Option<&str>, verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     let mut cmd = resolved_command("docker");
@@ -709,7 +706,7 @@ pub fn run_compose_build(service: Option<&str>, verbose: u8) -> Result<()> {
     if !output.status.success() {
         let stderr = String::from_utf8_lossy(&output.stderr);
         eprintln!("{}", stderr);
-        std::process::exit(output.status.code().unwrap_or(1));
+        return Ok(exit_code_from_output(&output, "docker"));
     }
 
     let stdout = String::from_utf8_lossy(&output.stdout);
@@ -729,11 +726,11 @@ pub fn run_compose_build(service: Option<&str>, verbose: u8) -> Result<()> {
         &raw,
         &rtk,
     );
-    Ok(())
+    Ok(0)
 }
 
 /// Runs an unsupported docker compose subcommand by passing it through directly
-pub fn run_compose_passthrough(args: &[OsString], verbose: u8) -> Result<()> {
+pub fn run_compose_passthrough(args: &[OsString], verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     if verbose > 0 {
@@ -751,14 +748,11 @@ pub fn run_compose_passthrough(args: &[OsString], verbose: u8) -> Result<()> {
         &format!("rtk docker compose {} (passthrough)", args_str),
     );
 
-    if !status.success() {
-        std::process::exit(status.code().unwrap_or(1));
-    }
-    Ok(())
+    Ok(exit_code_from_status(&status, "docker"))
 }
 
 /// Runs an unsupported kubectl subcommand by passing it through directly
-pub fn run_kubectl_passthrough(args: &[OsString], verbose: u8) -> Result<()> {
+pub fn run_kubectl_passthrough(args: &[OsString], verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     if verbose > 0 {
@@ -775,10 +769,7 @@ pub fn run_kubectl_passthrough(args: &[OsString], verbose: u8) -> Result<()> {
         &format!("rtk kubectl {} (passthrough)", args_str),
     );
 
-    if !status.success() {
-        std::process::exit(status.code().unwrap_or(1));
-    }
-    Ok(())
+    Ok(exit_code_from_status(&status, "kubectl"))
 }
 
 #[cfg(test)]
diff --git a/src/cmds/cloud/curl_cmd.rs b/src/cmds/cloud/curl_cmd.rs
index 7141ad72df..d6930ef67d 100644
--- a/src/cmds/cloud/curl_cmd.rs
+++ b/src/cmds/cloud/curl_cmd.rs
@@ -1,11 +1,13 @@
 //! Runs curl and auto-compresses JSON responses.
 
 use crate::core::tracking;
-use crate::core::utils::{resolved_command, truncate};
+use crate::core::utils::{exit_code_from_output, resolved_command, truncate};
 use crate::json_cmd;
 use anyhow::{Context, Result};
 
-pub fn run(args: &[String], verbose: u8) -> Result<()> {
+/// Not using run_filtered: on failure, curl can return HTML error pages (404, 500)
+/// that the JSON schema filter would mangle. The early exit skips filtering entirely.
+pub fn run(args: &[String], verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
     let mut cmd = resolved_command("curl");
     cmd.arg("-s"); // Silent mode (no progress bar)
@@ -22,6 +24,7 @@ pub fn run(args: &[String], verbose: u8) -> Result<()> {
     let stdout = String::from_utf8_lossy(&output.stdout);
     let stderr = String::from_utf8_lossy(&output.stderr);
 
+    // Early exit: don't feed HTTP error bodies (HTML 404 etc.) through JSON schema filter
     if !output.status.success() {
         let msg = if stderr.trim().is_empty() {
             stdout.trim().to_string()
@@ -29,7 +32,7 @@ pub fn run(args: &[String], verbose: u8) -> Result<()> {
             stderr.trim().to_string()
         };
         eprintln!("FAILED: curl {}", msg);
-        std::process::exit(output.status.code().unwrap_or(1));
+        return Ok(exit_code_from_output(&output, "curl"));
     }
 
     let raw = stdout.to_string();
@@ -45,7 +48,7 @@ pub fn run(args: &[String], verbose: u8) -> Result<()> {
         &filtered,
     );
 
-    Ok(())
+    Ok(0)
 }
 
 fn filter_curl_output(output: &str) -> String {
diff --git a/src/cmds/cloud/psql_cmd.rs b/src/cmds/cloud/psql_cmd.rs
index 9ec243bed4..18295eefaf 100644
--- a/src/cmds/cloud/psql_cmd.rs
+++ b/src/cmds/cloud/psql_cmd.rs
@@ -4,7 +4,7 @@
 //! and produces compact tab-separated or key=value output.
 
 use crate::core::tracking;
-use crate::core::utils::resolved_command;
+use crate::core::utils::{exit_code_from_output, resolved_command};
 use anyhow::{Context, Result};
 use lazy_static::lazy_static;
 use regex::Regex;
@@ -19,7 +19,9 @@ lazy_static! {
     static ref RECORD_HEADER: Regex = Regex::new(r"^-\[ RECORD (\d+) \]-").unwrap();
 }
 
-pub fn run(args: &[String], verbose: u8) -> Result<()> {
+/// Not using run_filtered: on failure, psql error messages containing `|` chars
+/// would be misinterpreted as table data by the table/expanded format parser.
+pub fn run(args: &[String], verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     let mut cmd = resolved_command("psql");
@@ -37,14 +39,15 @@ pub fn run(args: &[String], verbose: u8) -> Result<()> {
     let stdout = String::from_utf8_lossy(&output.stdout);
     let stderr = String::from_utf8_lossy(&output.stderr);
 
-    let exit_code = output.status.code().unwrap_or(1);
+    let exit_code = exit_code_from_output(&output, "psql");
 
     if !stderr.is_empty() {
         eprint!("{}", stderr);
     }
 
+    // Early exit: don't pass psql error messages through table/expanded format parser
     if exit_code != 0 {
-        std::process::exit(exit_code);
+        return Ok(exit_code);
     }
 
     let filtered = filter_psql_output(&stdout);
@@ -62,7 +65,7 @@ pub fn run(args: &[String], verbose: u8) -> Result<()> {
         &filtered,
     );
 
-    Ok(())
+    Ok(0)
 }
 
 fn filter_psql_output(output: &str) -> String {
diff --git a/src/cmds/cloud/wget_cmd.rs b/src/cmds/cloud/wget_cmd.rs
index 32996ac34b..fd1e26b643 100644
--- a/src/cmds/cloud/wget_cmd.rs
+++ b/src/cmds/cloud/wget_cmd.rs
@@ -1,9 +1,9 @@
 use crate::core::tracking;
-use crate::core::utils::resolved_command;
+use crate::core::utils::{exit_code_from_output, resolved_command};
 use anyhow::{Context, Result};
 
 /// Compact wget - strips progress bars, shows only result
-pub fn run(url: &str, args: &[String], verbose: u8) -> Result<()> {
+pub fn run(url: &str, args: &[String], verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     if verbose > 0 {
@@ -45,14 +45,14 @@ pub fn run(url: &str, args: &[String], verbose: u8) -> Result<()> {
         let msg = format!("{} FAILED: {}", compact_url(url), error);
         println!("{}", msg);
         timer.track(&format!("wget {}", url), "rtk wget", &raw_output, &msg);
-        std::process::exit(output.status.code().unwrap_or(1));
+        return Ok(exit_code_from_output(&output, "wget"));
     }
 
-    Ok(())
+    Ok(0)
 }
 
 /// Run wget and output to stdout (for piping)
-pub fn run_stdout(url: &str, args: &[String], verbose: u8) -> Result<()> {
+pub fn run_stdout(url: &str, args: &[String], verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     if verbose > 0 {
@@ -108,10 +108,10 @@ pub fn run_stdout(url: &str, args: &[String], verbose: u8) -> Result<()> {
         let msg = format!("{} FAILED: {}", compact_url(url), error);
         println!("{}", msg);
         timer.track(&format!("wget -O - {}", url), "rtk wget -o", &stderr, &msg);
-        std::process::exit(output.status.code().unwrap_or(1));
+        return Ok(exit_code_from_output(&output, "wget"));
     }
 
-    Ok(())
+    Ok(0)
 }
 
 fn extract_filename_from_output(stderr: &str, url: &str, args: &[String]) -> String {
diff --git a/src/cmds/dotnet/dotnet_cmd.rs b/src/cmds/dotnet/dotnet_cmd.rs
index 5f05088308..f1e5fe0d55 100644
--- a/src/cmds/dotnet/dotnet_cmd.rs
+++ b/src/cmds/dotnet/dotnet_cmd.rs
@@ -2,7 +2,7 @@
 
 use crate::binlog;
 use crate::core::tracking;
-use crate::core::utils::{resolved_command, truncate};
+use crate::core::utils::{exit_code_from_output, resolved_command, truncate};
 use crate::dotnet_format_report;
 use crate::dotnet_trx;
 use anyhow::{Context, Result};
@@ -18,19 +18,19 @@ const DOTNET_CLI_UI_LANGUAGE: &str = "DOTNET_CLI_UI_LANGUAGE";
 const DOTNET_CLI_UI_LANGUAGE_VALUE: &str = "en-US";
 static TEMP_PATH_COUNTER: AtomicU64 = AtomicU64::new(0);
 
-pub fn run_build(args: &[String], verbose: u8) -> Result<()> {
+pub fn run_build(args: &[String], verbose: u8) -> Result<i32> {
     run_dotnet_with_binlog("build", args, verbose)
 }
 
-pub fn run_test(args: &[String], verbose: u8) -> Result<()> {
+pub fn run_test(args: &[String], verbose: u8) -> Result<i32> {
     run_dotnet_with_binlog("test", args, verbose)
 }
 
-pub fn run_restore(args: &[String], verbose: u8) -> Result<()> {
+pub fn run_restore(args: &[String], verbose: u8) -> Result<i32> {
     run_dotnet_with_binlog("restore", args, verbose)
 }
 
-pub fn run_format(args: &[String], verbose: u8) -> Result<()> {
+pub fn run_format(args: &[String], verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
     let (report_path, cleanup_report_path) = resolve_format_report_path(args);
     let mut cmd = resolved_command("dotnet");
@@ -69,14 +69,10 @@ pub fn run_format(args: &[String], verbose: u8) -> Result<()> {
         }
     }
 
-    if !output.status.success() {
-        std::process::exit(output.status.code().unwrap_or(1));
-    }
-
-    Ok(())
+    Ok(exit_code_from_output(&output, "dotnet"))
 }
 
-pub fn run_passthrough(args: &[OsString], verbose: u8) -> Result<()> {
+pub fn run_passthrough(args: &[OsString], verbose: u8) -> Result<i32> {
     if args.is_empty() {
         anyhow::bail!("dotnet: no subcommand specified");
     }
@@ -113,14 +109,10 @@ pub fn run_passthrough(args: &[OsString], verbose: u8) -> Result<()> {
         &raw,
     );
 
-    if !output.status.success() {
-        std::process::exit(output.status.code().unwrap_or(1));
-    }
-
-    Ok(())
+    Ok(exit_code_from_output(&output, "dotnet"))
 }
 
-fn run_dotnet_with_binlog(subcommand: &str, args: &[String], verbose: u8) -> Result<()> {
+fn run_dotnet_with_binlog(subcommand: &str, args: &[String], verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
     let binlog_path = build_binlog_path(subcommand);
     let should_expect_binlog = subcommand != "test" || has_binlog_arg(args);
@@ -261,11 +253,7 @@ fn run_dotnet_with_binlog(subcommand: &str, args: &[String], verbose: u8) -> Res
         eprintln!("Binlog cleaned up: {}", binlog_path.display());
     }
 
-    if !output.status.success() {
-        std::process::exit(output.status.code().unwrap_or(1));
-    }
-
-    Ok(())
+    Ok(exit_code_from_output(&output, "dotnet"))
 }
 
 fn build_binlog_path(subcommand: &str) -> PathBuf {
diff --git a/src/cmds/git/gh_cmd.rs b/src/cmds/git/gh_cmd.rs
index e008a2f19e..3c202950f4 100644
--- a/src/cmds/git/gh_cmd.rs
+++ b/src/cmds/git/gh_cmd.rs
@@ -4,7 +4,9 @@
 //! Focuses on extracting essential information from JSON outputs.
 
 use crate::core::tracking;
-use crate::core::utils::{ok_confirmation, resolved_command, truncate};
+use crate::core::utils::{
+    exit_code_from_output, exit_code_from_status, ok_confirmation, resolved_command, truncate,
+};
 use crate::git;
 use anyhow::{Context, Result};
 use lazy_static::lazy_static;
@@ -161,7 +163,7 @@ fn extract_identifier_and_extra_args(args: &[String]) -> Option<(String, Vec<Str
 }
 
 /// Run a gh command with token-optimized output
-pub fn run(subcommand: &str, args: &[String], verbose: u8, ultra_compact: bool) -> Result<()> {
+pub fn run(subcommand: &str, args: &[String], verbose: u8, ultra_compact: bool) -> Result<i32> {
     // When user explicitly passes --json, they want raw gh JSON output, not RTK filtering
     if has_json_flag(args) {
         return run_passthrough("gh", subcommand, args);
@@ -180,7 +182,7 @@ pub fn run(subcommand: &str, args: &[String], verbose: u8, ultra_compact: bool)
     }
 }
 
-fn run_pr(args: &[String], verbose: u8, ultra_compact: bool) -> Result<()> {
+fn run_pr(args: &[String], verbose: u8, ultra_compact: bool) -> Result<i32> {
     if args.is_empty() {
         return run_passthrough("gh", "pr", args);
     }
@@ -199,7 +201,7 @@ fn run_pr(args: &[String], verbose: u8, ultra_compact: bool) -> Result<()> {
     }
 }
 
-fn list_prs(args: &[String], _verbose: u8, ultra_compact: bool) -> Result<()> {
+fn list_prs(args: &[String], _verbose: u8, ultra_compact: bool) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     let mut cmd = resolved_command("gh");
@@ -222,7 +224,7 @@ fn list_prs(args: &[String], _verbose: u8, ultra_compact: bool) -> Result<()> {
         let stderr = String::from_utf8_lossy(&output.stderr).to_string();
         timer.track("gh pr list", "rtk gh pr list", &stderr, &stderr);
         eprintln!("{}", stderr.trim());
-        std::process::exit(output.status.code().unwrap_or(1));
+        return Ok(exit_code_from_output(&output, "gh"));
     }
 
     let json: Value =
@@ -280,7 +282,7 @@ fn list_prs(args: &[String], _verbose: u8, ultra_compact: bool) -> Result<()> {
     }
 
     timer.track("gh pr list", "rtk gh pr list", &raw, &filtered);
-    Ok(())
+    Ok(0)
 }
 
 fn should_passthrough_pr_view(extra_args: &[String]) -> bool {
@@ -295,7 +297,7 @@ fn should_passthrough_issue_view(extra_args: &[String]) -> bool {
         .any(|a| a == "--json" || a == "--jq" || a == "--web" || a == "--comments")
 }
 
-fn view_pr(args: &[String], _verbose: u8, ultra_compact: bool) -> Result<()> {
+fn view_pr(args: &[String], _verbose: u8, ultra_compact: bool) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     let (pr_number, extra_args) = match extract_identifier_and_extra_args(args) {
@@ -333,7 +335,7 @@ fn view_pr(args: &[String], _verbose: u8, ultra_compact: bool) -> Result<()> {
             &stderr,
         );
         eprintln!("{}", stderr.trim());
-        std::process::exit(output.status.code().unwrap_or(1));
+        return Ok(exit_code_from_output(&output, "gh"));
     }
 
     let json: Value =
@@ -469,10 +471,10 @@ fn view_pr(args: &[String], _verbose: u8, ultra_compact: bool) -> Result<()> {
         &raw,
         &filtered,
     );
-    Ok(())
+    Ok(0)
 }
 
-fn pr_checks(args: &[String], _verbose: u8, _ultra_compact: bool) -> Result<()> {
+fn pr_checks(args: &[String], _verbose: u8, _ultra_compact: bool) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     let (pr_number, extra_args) = match extract_identifier_and_extra_args(args) {
@@ -498,7 +500,7 @@ fn pr_checks(args: &[String], _verbose: u8, _ultra_compact: bool) -> Result<()>
             &stderr,
         );
         eprintln!("{}", stderr.trim());
-        std::process::exit(output.status.code().unwrap_or(1));
+        return Ok(exit_code_from_output(&output, "gh"));
     }
 
     let stdout = String::from_utf8_lossy(&output.stdout);
@@ -557,10 +559,10 @@ fn pr_checks(args: &[String], _verbose: u8, _ultra_compact: bool) -> Result<()>
         &raw,
         &filtered,
     );
-    Ok(())
+    Ok(0)
 }
 
-fn pr_status(_verbose: u8, _ultra_compact: bool) -> Result<()> {
+fn pr_status(_verbose: u8, _ultra_compact: bool) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     let mut cmd = resolved_command("gh");
@@ -578,7 +580,7 @@ fn pr_status(_verbose: u8, _ultra_compact: bool) -> Result<()> {
         let stderr = String::from_utf8_lossy(&output.stderr).to_string();
         timer.track("gh pr status", "rtk gh pr status", &stderr, &stderr);
         eprintln!("{}", stderr.trim());
-        std::process::exit(output.status.code().unwrap_or(1));
+        return Ok(exit_code_from_output(&output, "gh"));
     }
 
     let json: Value =
@@ -601,10 +603,10 @@ fn pr_status(_verbose: u8, _ultra_compact: bool) -> Result<()> {
     }
 
     timer.track("gh pr status", "rtk gh pr status", &raw, &filtered);
-    Ok(())
+    Ok(0)
 }
 
-fn run_issue(args: &[String], verbose: u8, ultra_compact: bool) -> Result<()> {
+fn run_issue(args: &[String], verbose: u8, ultra_compact: bool) -> Result<i32> {
     if args.is_empty() {
         return run_passthrough("gh", "issue", args);
     }
@@ -616,7 +618,7 @@ fn run_issue(args: &[String], verbose: u8, ultra_compact: bool) -> Result<()> {
     }
 }
 
-fn list_issues(args: &[String], _verbose: u8, ultra_compact: bool) -> Result<()> {
+fn list_issues(args: &[String], _verbose: u8, ultra_compact: bool) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     let mut cmd = resolved_command("gh");
@@ -633,7 +635,7 @@ fn list_issues(args: &[String], _verbose: u8, ultra_compact: bool) -> Result<()>
         let stderr = String::from_utf8_lossy(&output.stderr).to_string();
         timer.track("gh issue list", "rtk gh issue list", &stderr, &stderr);
         eprintln!("{}", stderr.trim());
-        std::process::exit(output.status.code().unwrap_or(1));
+        return Ok(exit_code_from_output(&output, "gh"));
     }
 
     let json: Value =
@@ -675,10 +677,10 @@ fn list_issues(args: &[String], _verbose: u8, ultra_compact: bool) -> Result<()>
     }
 
     timer.track("gh issue list", "rtk gh issue list", &raw, &filtered);
-    Ok(())
+    Ok(0)
 }
 
-fn view_issue(args: &[String], _verbose: u8) -> Result<()> {
+fn view_issue(args: &[String], _verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     let (issue_number, extra_args) = match extract_identifier_and_extra_args(args) {
@@ -717,7 +719,7 @@ fn view_issue(args: &[String], _verbose: u8) -> Result<()> {
             &stderr,
         );
         eprintln!("{}", stderr.trim());
-        std::process::exit(output.status.code().unwrap_or(1));
+        return Ok(exit_code_from_output(&output, "gh"));
     }
 
     let json: Value =
@@ -775,10 +777,10 @@ fn view_issue(args: &[String], _verbose: u8) -> Result<()> {
         &raw,
         &filtered,
     );
-    Ok(())
+    Ok(0)
 }
 
-fn run_workflow(args: &[String], verbose: u8, ultra_compact: bool) -> Result<()> {
+fn run_workflow(args: &[String], verbose: u8, ultra_compact: bool) -> Result<i32> {
     if args.is_empty() {
         return run_passthrough("gh", "run", args);
     }
@@ -790,7 +792,7 @@ fn run_workflow(args: &[String], verbose: u8, ultra_compact: bool) -> Result<()>
     }
 }
 
-fn list_runs(args: &[String], _verbose: u8, ultra_compact: bool) -> Result<()> {
+fn list_runs(args: &[String], _verbose: u8, ultra_compact: bool) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     let mut cmd = resolved_command("gh");
@@ -813,7 +815,7 @@ fn list_runs(args: &[String], _verbose: u8, ultra_compact: bool) -> Result<()> {
         let stderr = String::from_utf8_lossy(&output.stderr).to_string();
         timer.track("gh run list", "rtk gh run list", &stderr, &stderr);
         eprintln!("{}", stderr.trim());
-        std::process::exit(output.status.code().unwrap_or(1));
+        return Ok(exit_code_from_output(&output, "gh"));
     }
 
     let json: Value =
@@ -870,7 +872,7 @@ fn list_runs(args: &[String], _verbose: u8, ultra_compact: bool) -> Result<()> {
     }
 
     timer.track("gh run list", "rtk gh run list", &raw, &filtered);
-    Ok(())
+    Ok(0)
 }
 
 /// Check if run view args should bypass filtering and pass through directly.
@@ -882,7 +884,7 @@ fn should_passthrough_run_view(extra_args: &[String]) -> bool {
         .any(|a| a == "--log-failed" || a == "--log" || a == "--json")
 }
 
-fn view_run(args: &[String], _verbose: u8) -> Result<()> {
+fn view_run(args: &[String], _verbose: u8) -> Result<i32> {
     let (run_id, extra_args) = match extract_identifier_and_extra_args(args) {
         Some(result) => result,
         None => return Err(anyhow::anyhow!("Run ID required")),
@@ -913,7 +915,7 @@ fn view_run(args: &[String], _verbose: u8) -> Result<()> {
             &stderr,
         );
         eprintln!("{}", stderr.trim());
-        std::process::exit(output.status.code().unwrap_or(1));
+        return Ok(exit_code_from_output(&output, "gh"));
     }
 
     // Parse output and show only failures
@@ -954,10 +956,10 @@ fn view_run(args: &[String], _verbose: u8) -> Result<()> {
         &raw,
         &filtered,
     );
-    Ok(())
+    Ok(0)
 }
 
-fn run_repo(args: &[String], _verbose: u8, _ultra_compact: bool) -> Result<()> {
+fn run_repo(args: &[String], _verbose: u8, _ultra_compact: bool) -> Result<i32> {
     // Parse subcommand (default to "view")
     let (subcommand, rest_args) = if args.is_empty() {
         ("view", args)
@@ -990,7 +992,7 @@ fn run_repo(args: &[String], _verbose: u8, _ultra_compact: bool) -> Result<()> {
         let stderr = String::from_utf8_lossy(&output.stderr).to_string();
         timer.track("gh repo view", "rtk gh repo view", &stderr, &stderr);
         eprintln!("{}", stderr.trim());
-        std::process::exit(output.status.code().unwrap_or(1));
+        return Ok(exit_code_from_output(&output, "gh"));
     }
 
     let json: Value =
@@ -1031,10 +1033,10 @@ fn run_repo(args: &[String], _verbose: u8, _ultra_compact: bool) -> Result<()> {
     print!("{}", line);
 
     timer.track("gh repo view", "rtk gh repo view", &raw, &filtered);
-    Ok(())
+    Ok(0)
 }
 
-fn pr_create(args: &[String], _verbose: u8) -> Result<()> {
+fn pr_create(args: &[String], _verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     let mut cmd = resolved_command("gh");
@@ -1050,7 +1052,7 @@ fn pr_create(args: &[String], _verbose: u8) -> Result<()> {
     if !output.status.success() {
         timer.track("gh pr create", "rtk gh pr create", &stderr, &stderr);
         eprintln!("{}", stderr.trim());
-        std::process::exit(output.status.code().unwrap_or(1));
+        return Ok(exit_code_from_output(&output, "gh"));
     }
 
     // gh pr create outputs the URL on success
@@ -1069,10 +1071,10 @@ fn pr_create(args: &[String], _verbose: u8) -> Result<()> {
     println!("{}", filtered);
 
     timer.track("gh pr create", "rtk gh pr create", &stdout, &filtered);
-    Ok(())
+    Ok(0)
 }
 
-fn pr_merge(args: &[String], _verbose: u8) -> Result<()> {
+fn pr_merge(args: &[String], _verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     let mut cmd = resolved_command("gh");
@@ -1088,7 +1090,7 @@ fn pr_merge(args: &[String], _verbose: u8) -> Result<()> {
     if !output.status.success() {
         timer.track("gh pr merge", "rtk gh pr merge", &stderr, &stderr);
         eprintln!("{}", stderr.trim());
-        std::process::exit(output.status.code().unwrap_or(1));
+        return Ok(exit_code_from_output(&output, "gh"));
     }
 
     // Extract PR number from args (first non-flag arg)
@@ -1115,7 +1117,7 @@ fn pr_merge(args: &[String], _verbose: u8) -> Result<()> {
     };
 
     timer.track("gh pr merge", "rtk gh pr merge", &raw, &filtered);
-    Ok(())
+    Ok(0)
 }
 
 /// Flags that change `gh pr diff` output from unified diff to a different format.
@@ -1130,7 +1132,7 @@ fn has_non_diff_format_flag(args: &[String]) -> bool {
     })
 }
 
-fn pr_diff(args: &[String], _verbose: u8) -> Result<()> {
+fn pr_diff(args: &[String], _verbose: u8) -> Result<i32> {
     // --no-compact: pass full diff through (gh CLI doesn't know this flag, strip it)
     let no_compact = args.iter().any(|a| a == "--no-compact");
     let gh_args: Vec<String> = args
@@ -1160,7 +1162,7 @@ fn pr_diff(args: &[String], _verbose: u8) -> Result<()> {
         let stderr = String::from_utf8_lossy(&output.stderr).to_string();
         timer.track("gh pr diff", "rtk gh pr diff", &stderr, &stderr);
         eprintln!("{}", stderr.trim());
-        std::process::exit(output.status.code().unwrap_or(1));
+        return Ok(exit_code_from_output(&output, "gh"));
     }
 
     let filtered = if raw.trim().is_empty() {
@@ -1174,11 +1176,11 @@ fn pr_diff(args: &[String], _verbose: u8) -> Result<()> {
     };
 
     timer.track("gh pr diff", "rtk gh pr diff", &raw, &filtered);
-    Ok(())
+    Ok(0)
 }
 
 /// Generic PR action handler for comment/edit
-fn pr_action(action: &str, args: &[String], _verbose: u8) -> Result<()> {
+fn pr_action(action: &str, args: &[String], _verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
     let subcmd = &args[0];
 
@@ -1202,7 +1204,7 @@ fn pr_action(action: &str, args: &[String], _verbose: u8) -> Result<()> {
             &stderr,
         );
         eprintln!("{}", stderr.trim());
-        std::process::exit(output.status.code().unwrap_or(1));
+        return Ok(exit_code_from_output(&output, "gh"));
     }
 
     // Extract PR number from args (skip args[0] which is the subcommand)
@@ -1228,10 +1230,10 @@ fn pr_action(action: &str, args: &[String], _verbose: u8) -> Result<()> {
         &raw,
         &filtered,
     );
-    Ok(())
+    Ok(0)
 }
 
-fn run_api(args: &[String], _verbose: u8) -> Result<()> {
+fn run_api(args: &[String], _verbose: u8) -> Result<i32> {
     // gh api is an explicit/advanced command — the user knows what they asked for.
     // Converting JSON to a schema destroys all values and forces Claude to re-fetch.
     // Passthrough preserves the full response and tracks metrics at 0% savings.
@@ -1239,7 +1241,7 @@ fn run_api(args: &[String], _verbose: u8) -> Result<()> {
 }
 
 /// Pass through a command with base args + extra args, tracking as passthrough.
-fn run_passthrough_with_extra(cmd: &str, base_args: &[&str], extra_args: &[String]) -> Result<()> {
+fn run_passthrough_with_extra(cmd: &str, base_args: &[&str], extra_args: &[String]) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     let mut command = resolved_command(cmd);
@@ -1263,14 +1265,10 @@ fn run_passthrough_with_extra(cmd: &str, base_args: &[&str], extra_args: &[Strin
     );
     timer.track_passthrough(&full_cmd, &format!("rtk {} (passthrough)", full_cmd));
 
-    if !status.success() {
-        std::process::exit(status.code().unwrap_or(1));
-    }
-
-    Ok(())
+    Ok(exit_code_from_status(&status, "gh"))
 }
 
-fn run_passthrough(cmd: &str, subcommand: &str, args: &[String]) -> Result<()> {
+fn run_passthrough(cmd: &str, subcommand: &str, args: &[String]) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     let mut command = resolved_command(cmd);
@@ -1289,11 +1287,7 @@ fn run_passthrough(cmd: &str, subcommand: &str, args: &[String]) -> Result<()> {
         &format!("rtk {} {} {} (passthrough)", cmd, subcommand, args_str),
     );
 
-    if !status.success() {
-        std::process::exit(status.code().unwrap_or(1));
-    }
-
-    Ok(())
+    Ok(exit_code_from_status(&status, "gh"))
 }
 
 #[cfg(test)]
diff --git a/src/cmds/git/git.rs b/src/cmds/git/git.rs
index 1ed848d631..8d3d0eb4bf 100644
--- a/src/cmds/git/git.rs
+++ b/src/cmds/git/git.rs
@@ -2,7 +2,7 @@
 
 use crate::core::config;
 use crate::core::tracking;
-use crate::core::utils::resolved_command;
+use crate::core::utils::{exit_code_from_output, exit_code_from_status, resolved_command};
 use anyhow::{Context, Result};
 use std::ffi::OsString;
 use std::process::Command;
@@ -39,7 +39,7 @@ pub fn run(
     max_lines: Option<usize>,
     verbose: u8,
     global_args: &[String],
-) -> Result<()> {
+) -> Result<i32> {
     match cmd {
         GitCommand::Diff => run_diff(args, max_lines, verbose, global_args),
         GitCommand::Log => run_log(args, max_lines, verbose, global_args),
@@ -63,7 +63,7 @@ fn run_diff(
     max_lines: Option<usize>,
     verbose: u8,
     global_args: &[String],
-) -> Result<()> {
+) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     // Check if user wants stat output
@@ -90,7 +90,7 @@ fn run_diff(
         if !output.status.success() {
             let stderr = String::from_utf8_lossy(&output.stderr);
             eprintln!("{}", stderr);
-            std::process::exit(output.status.code().unwrap_or(1));
+            return Ok(exit_code_from_output(&output, "git"));
         }
 
         let stdout = String::from_utf8_lossy(&output.stdout);
@@ -103,7 +103,7 @@ fn run_diff(
             &stdout,
         );
 
-        return Ok(());
+        return Ok(0);
     }
 
     // Default RTK behavior: stat first, then compacted diff
@@ -129,7 +129,7 @@ fn run_diff(
             &raw,
             &raw,
         );
-        std::process::exit(output.status.code().unwrap_or(1));
+        return Ok(exit_code_from_output(&output, "git"));
     }
 
     if verbose > 0 {
@@ -165,7 +165,7 @@ fn run_diff(
         &final_output,
     );
 
-    Ok(())
+    Ok(0)
 }
 
 fn run_show(
@@ -173,7 +173,7 @@ fn run_show(
     max_lines: Option<usize>,
     verbose: u8,
     global_args: &[String],
-) -> Result<()> {
+) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     // If user wants --stat or --format only, pass through
@@ -199,7 +199,7 @@ fn run_show(
         if !output.status.success() {
             let stderr = String::from_utf8_lossy(&output.stderr);
             eprintln!("{}", stderr);
-            std::process::exit(output.status.code().unwrap_or(1));
+            return Ok(exit_code_from_output(&output, "git"));
         }
         let stdout = String::from_utf8_lossy(&output.stdout);
         if wants_blob_show {
@@ -215,7 +215,7 @@ fn run_show(
             &stdout,
         );
 
-        return Ok(());
+        return Ok(0);
     }
 
     // Get raw output for tracking
@@ -239,7 +239,7 @@ fn run_show(
     if !summary_output.status.success() {
         let stderr = String::from_utf8_lossy(&summary_output.stderr);
         eprintln!("{}", stderr);
-        std::process::exit(summary_output.status.code().unwrap_or(1));
+        return Ok(exit_code_from_output(&summary_output, "git"));
     }
     let summary = String::from_utf8_lossy(&summary_output.stdout);
     println!("{}", summary.trim());
@@ -284,7 +284,7 @@ fn run_show(
         &final_output,
     );
 
-    Ok(())
+    Ok(0)
 }
 
 fn is_blob_show_arg(arg: &str) -> bool {
@@ -386,7 +386,7 @@ fn run_log(
     _max_lines: Option<usize>,
     verbose: u8,
     global_args: &[String],
-) -> Result<()> {
+) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     let mut cmd = git_cmd(global_args);
@@ -444,8 +444,7 @@ fn run_log(
     if !output.status.success() {
         let stderr = String::from_utf8_lossy(&output.stderr);
         eprintln!("{}", stderr);
-        // Propagate git's exit code
-        std::process::exit(output.status.code().unwrap_or(1));
+        return Ok(exit_code_from_output(&output, "git"));
     }
 
     let stdout = String::from_utf8_lossy(&output.stdout);
@@ -465,7 +464,7 @@ fn run_log(
         &filtered,
     );
 
-    Ok(())
+    Ok(0)
 }
 
 /// Filter git log output: truncate long messages, cap lines
@@ -740,7 +739,7 @@ fn filter_status_with_args(output: &str) -> String {
     }
 }
 
-fn run_status(args: &[String], verbose: u8, global_args: &[String]) -> Result<()> {
+fn run_status(args: &[String], verbose: u8, global_args: &[String]) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     // If user provided flags, apply minimal filtering
@@ -765,7 +764,7 @@ fn run_status(args: &[String], verbose: u8, global_args: &[String]) -> Result<()
                 &raw,
                 &raw,
             );
-            std::process::exit(output.status.code().unwrap_or(1));
+            return Ok(exit_code_from_output(&output, "git"));
         }
 
         if verbose > 0 || !stderr.is_empty() {
@@ -783,7 +782,7 @@ fn run_status(args: &[String], verbose: u8, global_args: &[String]) -> Result<()
             &filtered,
         );
 
-        return Ok(());
+        return Ok(0);
     }
 
     // Default RTK compact mode (no args provided)
@@ -806,7 +805,7 @@ fn run_status(args: &[String], verbose: u8, global_args: &[String]) -> Result<()
         let message = "Not a git repository".to_string();
         eprintln!("{}", message);
         timer.track("git status", "rtk git status", &raw_output, &message);
-        std::process::exit(output.status.code().unwrap_or(128));
+        return Ok(exit_code_from_output(&output, "git"));
     }
 
     let formatted = format_status_output(&stdout);
@@ -816,10 +815,10 @@ fn run_status(args: &[String], verbose: u8, global_args: &[String]) -> Result<()
     // Track for statistics
     timer.track("git status", "rtk git status", &raw_output, &formatted);
 
-    Ok(())
+    Ok(0)
 }
 
-fn run_add(args: &[String], verbose: u8, global_args: &[String]) -> Result<()> {
+fn run_add(args: &[String], verbose: u8, global_args: &[String]) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     let mut cmd = git_cmd(global_args);
@@ -884,11 +883,10 @@ fn run_add(args: &[String], verbose: u8, global_args: &[String]) -> Result<()> {
         if !stdout.trim().is_empty() {
             eprintln!("{}", stdout);
         }
-        // Propagate git's exit code
-        std::process::exit(output.status.code().unwrap_or(1));
+        return Ok(exit_code_from_output(&output, "git"));
     }
 
-    Ok(())
+    Ok(0)
 }
 
 fn build_commit_command(args: &[String], global_args: &[String]) -> Command {
@@ -900,7 +898,7 @@ fn build_commit_command(args: &[String], global_args: &[String]) -> Command {
     cmd
 }
 
-fn run_commit(args: &[String], verbose: u8, global_args: &[String]) -> Result<()> {
+fn run_commit(args: &[String], verbose: u8, global_args: &[String]) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     let original_cmd = format!("git commit {}", args.join(" "));
@@ -954,14 +952,14 @@ fn run_commit(args: &[String], verbose: u8, global_args: &[String]) -> Result<()
                 eprint!("{}", stdout);
             }
             timer.track(&original_cmd, "rtk git commit", &raw_output, &raw_output);
-            std::process::exit(output.status.code().unwrap_or(1));
+            return Ok(exit_code_from_output(&output, "git"));
         }
     }
 
-    Ok(())
+    Ok(0)
 }
 
-fn run_push(args: &[String], verbose: u8, global_args: &[String]) -> Result<()> {
+fn run_push(args: &[String], verbose: u8, global_args: &[String]) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     if verbose > 0 {
@@ -1017,13 +1015,13 @@ fn run_push(args: &[String], verbose: u8, global_args: &[String]) -> Result<()>
         if !stdout.trim().is_empty() {
             eprintln!("{}", stdout);
         }
-        std::process::exit(output.status.code().unwrap_or(1));
+        return Ok(exit_code_from_output(&output, "git"));
     }
 
-    Ok(())
+    Ok(0)
 }
 
-fn run_pull(args: &[String], verbose: u8, global_args: &[String]) -> Result<()> {
+fn run_pull(args: &[String], verbose: u8, global_args: &[String]) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     if verbose > 0 {
@@ -1103,13 +1101,13 @@ fn run_pull(args: &[String], verbose: u8, global_args: &[String]) -> Result<()>
         if !stdout.trim().is_empty() {
             eprintln!("{}", stdout);
         }
-        std::process::exit(output.status.code().unwrap_or(1));
+        return Ok(exit_code_from_output(&output, "git"));
     }
 
-    Ok(())
+    Ok(0)
 }
 
-fn run_branch(args: &[String], verbose: u8, global_args: &[String]) -> Result<()> {
+fn run_branch(args: &[String], verbose: u8, global_args: &[String]) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     if verbose > 0 {
@@ -1183,9 +1181,9 @@ fn run_branch(args: &[String], verbose: u8, global_args: &[String]) -> Result<()
             if !stderr.trim().is_empty() {
                 eprintln!("{}", stderr);
             }
-            std::process::exit(output.status.code().unwrap_or(1));
+            return Ok(exit_code_from_output(&output, "git"));
         }
-        return Ok(());
+        return Ok(0);
     }
 
     // Write operation: action flags, or positional args without list flags (= branch creation)
@@ -1223,9 +1221,9 @@ fn run_branch(args: &[String], verbose: u8, global_args: &[String]) -> Result<()
             if !stdout.trim().is_empty() {
                 eprintln!("{}", stdout);
             }
-            std::process::exit(output.status.code().unwrap_or(1));
+            return Ok(exit_code_from_output(&output, "git"));
         }
-        return Ok(());
+        return Ok(0);
     }
 
     // List mode: show compact branch list
@@ -1254,7 +1252,7 @@ fn run_branch(args: &[String], verbose: u8, global_args: &[String]) -> Result<()
             &raw,
             &raw,
         );
-        std::process::exit(output.status.code().unwrap_or(1));
+        return Ok(exit_code_from_output(&output, "git"));
     }
 
     let filtered = filter_branch_output(&stdout);
@@ -1267,7 +1265,7 @@ fn run_branch(args: &[String], verbose: u8, global_args: &[String]) -> Result<()
         &filtered,
     );
 
-    Ok(())
+    Ok(0)
 }
 
 fn filter_branch_output(output: &str) -> String {
@@ -1324,7 +1322,7 @@ fn filter_branch_output(output: &str) -> String {
     result.join("\n")
 }
 
-fn run_fetch(args: &[String], verbose: u8, global_args: &[String]) -> Result<()> {
+fn run_fetch(args: &[String], verbose: u8, global_args: &[String]) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     if verbose > 0 {
@@ -1347,7 +1345,7 @@ fn run_fetch(args: &[String], verbose: u8, global_args: &[String]) -> Result<()>
         if !stderr.trim().is_empty() {
             eprintln!("{}", stderr);
         }
-        std::process::exit(output.status.code().unwrap_or(1));
+        return Ok(exit_code_from_output(&output, "git"));
     }
 
     // Count new refs from stderr (git fetch outputs to stderr)
@@ -1365,7 +1363,7 @@ fn run_fetch(args: &[String], verbose: u8, global_args: &[String]) -> Result<()>
     println!("{}", msg);
     timer.track("git fetch", "rtk git fetch", &raw, &msg);
 
-    Ok(())
+    Ok(0)
 }
 
 fn run_stash(
@@ -1373,7 +1371,7 @@ fn run_stash(
     args: &[String],
     verbose: u8,
     global_args: &[String],
-) -> Result<()> {
+) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     if verbose > 0 {
@@ -1393,7 +1391,7 @@ fn run_stash(
                 let msg = "No stashes";
                 println!("{}", msg);
                 timer.track("git stash list", "rtk git stash list", &raw, msg);
-                return Ok(());
+                return Ok(0);
             }
 
             let filtered = filter_stash_list(&stdout);
@@ -1454,7 +1452,7 @@ fn run_stash(
             );
 
             if !output.status.success() {
-                std::process::exit(output.status.code().unwrap_or(1));
+                return Ok(exit_code_from_output(&output, "git"));
             }
         }
         Some(sub) => {
@@ -1489,7 +1487,7 @@ fn run_stash(
             );
 
             if !output.status.success() {
-                std::process::exit(output.status.code().unwrap_or(1));
+                return Ok(exit_code_from_output(&output, "git"));
             }
         }
         None => {
@@ -1525,12 +1523,12 @@ fn run_stash(
             timer.track("git stash", "rtk git stash", &combined, &msg);
 
             if !output.status.success() {
-                std::process::exit(output.status.code().unwrap_or(1));
+                return Ok(exit_code_from_output(&output, "git"));
             }
         }
     }
 
-    Ok(())
+    Ok(0)
 }
 
 fn filter_stash_list(output: &str) -> String {
@@ -1554,7 +1552,7 @@ fn filter_stash_list(output: &str) -> String {
     result.join("\n")
 }
 
-fn run_worktree(args: &[String], verbose: u8, global_args: &[String]) -> Result<()> {
+fn run_worktree(args: &[String], verbose: u8, global_args: &[String]) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     if verbose > 0 {
@@ -1597,9 +1595,9 @@ fn run_worktree(args: &[String], verbose: u8, global_args: &[String]) -> Result<
             if !stderr.trim().is_empty() {
                 eprintln!("{}", stderr);
             }
-            std::process::exit(output.status.code().unwrap_or(1));
+            return Ok(exit_code_from_output(&output, "git"));
         }
-        return Ok(());
+        return Ok(0);
     }
 
     // Default: list mode
@@ -1615,7 +1613,7 @@ fn run_worktree(args: &[String], verbose: u8, global_args: &[String]) -> Result<
     println!("{}", filtered);
     timer.track("git worktree list", "rtk git worktree", &raw, &filtered);
 
-    Ok(())
+    Ok(0)
 }
 
 fn filter_worktree_list(output: &str) -> String {
@@ -1646,7 +1644,7 @@ fn filter_worktree_list(output: &str) -> String {
 }
 
 /// Runs an unsupported git subcommand by passing it through directly
-pub fn run_passthrough(args: &[OsString], global_args: &[String], verbose: u8) -> Result<()> {
+pub fn run_passthrough(args: &[OsString], global_args: &[String], verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     if verbose > 0 {
@@ -1664,9 +1662,9 @@ pub fn run_passthrough(args: &[OsString], global_args: &[String], verbose: u8) -
     );
 
     if !status.success() {
-        std::process::exit(status.code().unwrap_or(1));
+        return Ok(exit_code_from_status(&status, "git"));
     }
-    Ok(())
+    Ok(0)
 }
 
 #[cfg(test)]
diff --git a/src/cmds/git/gt_cmd.rs b/src/cmds/git/gt_cmd.rs
index 580778ff14..19a03ead56 100644
--- a/src/cmds/git/gt_cmd.rs
+++ b/src/cmds/git/gt_cmd.rs
@@ -1,7 +1,10 @@
 //! Filters Graphite (gt) CLI output for stacking workflows.
 
 use crate::core::tracking;
-use crate::core::utils::{ok_confirmation, resolved_command, strip_ansi, truncate};
+use crate::core::utils::{
+    exit_code_from_output, exit_code_from_status, ok_confirmation, resolved_command, strip_ansi,
+    truncate,
+};
 use anyhow::{Context, Result};
 use lazy_static::lazy_static;
 use regex::Regex;
@@ -25,7 +28,7 @@ fn run_gt_filtered(
     verbose: u8,
     tee_label: &str,
     filter_fn: fn(&str) -> String,
-) -> Result<()> {
+) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     let mut cmd = resolved_command("gt");
@@ -52,7 +55,7 @@ fn run_gt_filtered(
     let stderr = String::from_utf8_lossy(&cmd_output.stderr);
     let raw = format!("{}\n{}", stdout, stderr);
 
-    let exit_code = cmd_output.status.code().unwrap_or(1);
+    let exit_code = exit_code_from_output(&cmd_output, "gt");
 
     let clean = strip_ansi(stdout.trim());
     let output = if verbose > 0 {
@@ -79,18 +82,14 @@ fn run_gt_filtered(
     let rtk_label = format!("rtk {}", label);
     timer.track(&label, &rtk_label, &raw, &output);
 
-    if !cmd_output.status.success() {
-        std::process::exit(exit_code);
-    }
-
-    Ok(())
+    Ok(exit_code)
 }
 
 fn filter_identity(input: &str) -> String {
     input.to_string()
 }
 
-pub fn run_log(args: &[String], verbose: u8) -> Result<()> {
+pub fn run_log(args: &[String], verbose: u8) -> Result<i32> {
     match args.first().map(|s| s.as_str()) {
         Some("short") => run_gt_filtered(
             &["log", "short"],
@@ -110,27 +109,27 @@ pub fn run_log(args: &[String], verbose: u8) -> Result<()> {
     }
 }
 
-pub fn run_submit(args: &[String], verbose: u8) -> Result<()> {
+pub fn run_submit(args: &[String], verbose: u8) -> Result<i32> {
     run_gt_filtered(&["submit"], args, verbose, "gt_submit", filter_gt_submit)
 }
 
-pub fn run_sync(args: &[String], verbose: u8) -> Result<()> {
+pub fn run_sync(args: &[String], verbose: u8) -> Result<i32> {
     run_gt_filtered(&["sync"], args, verbose, "gt_sync", filter_gt_sync)
 }
 
-pub fn run_restack(args: &[String], verbose: u8) -> Result<()> {
+pub fn run_restack(args: &[String], verbose: u8) -> Result<i32> {
     run_gt_filtered(&["restack"], args, verbose, "gt_restack", filter_gt_restack)
 }
 
-pub fn run_create(args: &[String], verbose: u8) -> Result<()> {
+pub fn run_create(args: &[String], verbose: u8) -> Result<i32> {
     run_gt_filtered(&["create"], args, verbose, "gt_create", filter_gt_create)
 }
 
-pub fn run_branch(args: &[String], verbose: u8) -> Result<()> {
+pub fn run_branch(args: &[String], verbose: u8) -> Result<i32> {
     run_gt_filtered(&["branch"], args, verbose, "gt_branch", filter_identity)
 }
 
-pub fn run_other(args: &[OsString], verbose: u8) -> Result<()> {
+pub fn run_other(args: &[OsString], verbose: u8) -> Result<i32> {
     if args.is_empty() {
         anyhow::bail!("gt: no subcommand specified");
     }
@@ -169,7 +168,7 @@ pub fn run_other(args: &[OsString], verbose: u8) -> Result<()> {
     }
 }
 
-fn passthrough_gt(subcommand: &str, args: &[String], verbose: u8) -> Result<()> {
+fn passthrough_gt(subcommand: &str, args: &[String], verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     let mut cmd = resolved_command("gt");
@@ -196,11 +195,7 @@ fn passthrough_gt(subcommand: &str, args: &[String], verbose: u8) -> Result<()>
         &format!("rtk gt {} (passthrough)", args_str),
     );
 
-    if !status.success() {
-        std::process::exit(status.code().unwrap_or(1));
-    }
-
-    Ok(())
+    Ok(exit_code_from_status(&status, "gt"))
 }
 
 const MAX_LOG_ENTRIES: usize = 15;
diff --git a/src/cmds/go/go_cmd.rs b/src/cmds/go/go_cmd.rs
index 47771e7aed..5d64f6a184 100644
--- a/src/cmds/go/go_cmd.rs
+++ b/src/cmds/go/go_cmd.rs
@@ -1,7 +1,7 @@
 //! Filters Go command output — test results, build errors, vet warnings.
 
 use crate::core::tracking;
-use crate::core::utils::{resolved_command, truncate};
+use crate::core::utils::{exit_code_from_output, resolved_command, truncate};
 use crate::golangci_cmd;
 use anyhow::{Context, Result};
 use serde::Deserialize;
@@ -39,13 +39,10 @@ struct PackageResult {
     failed_tests: Vec<(String, Vec<String>)>, // (test_name, output_lines)
 }
 
-pub fn run_test(args: &[String], verbose: u8) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
+pub fn run_test(args: &[String], verbose: u8) -> Result<i32> {
     let mut cmd = resolved_command("go");
     cmd.arg("test");
 
-    // Force JSON output if not already specified
     if !args.iter().any(|a| a == "-json") {
         cmd.arg("-json");
     }
@@ -58,49 +55,16 @@ pub fn run_test(args: &[String], verbose: u8) -> Result<()> {
         eprintln!("Running: go test -json {}", args.join(" "));
     }
 
-    let output = cmd
-        .output()
-        .context("Failed to run go test. Is Go installed?")?;
-
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    let raw = format!("{}\n{}", stdout, stderr);
-
-    let exit_code = output
-        .status
-        .code()
-        .unwrap_or(if output.status.success() { 0 } else { 1 });
-    let filtered = filter_go_test_json(&stdout);
-
-    if let Some(hint) = crate::core::tee::tee_and_hint(&raw, "go_test", exit_code) {
-        println!("{}\n{}", filtered, hint);
-    } else {
-        println!("{}", filtered);
-    }
-
-    // Include stderr if present (build errors, etc.)
-    if !stderr.trim().is_empty() {
-        eprintln!("{}", stderr.trim());
-    }
-
-    timer.track(
-        &format!("go test {}", args.join(" ")),
-        &format!("rtk go test {}", args.join(" ")),
-        &raw,
-        &filtered,
-    );
-
-    // Preserve exit code for CI/CD
-    if !output.status.success() {
-        std::process::exit(exit_code);
-    }
-
-    Ok(())
+    crate::core::runner::run_filtered(
+        cmd,
+        "go test",
+        &args.join(" "),
+        filter_go_test_json,
+        crate::core::runner::RunOptions::stdout_only().tee("go_test"),
+    )
 }
 
-pub fn run_build(args: &[String], verbose: u8) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
+pub fn run_build(args: &[String], verbose: u8) -> Result<i32> {
     let mut cmd = resolved_command("go");
     cmd.arg("build");
 
@@ -112,48 +76,16 @@ pub fn run_build(args: &[String], verbose: u8) -> Result<()> {
         eprintln!("Running: go build {}", args.join(" "));
     }
 
-    let output = cmd
-        .output()
-        .context("Failed to run go build. Is Go installed?")?;
-
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    let raw = format!("{}\n{}", stdout, stderr);
-
-    let exit_code = output
-        .status
-        .code()
-        .unwrap_or(if output.status.success() { 0 } else { 1 });
-    let filtered = filter_go_build(&raw);
-
-    if let Some(hint) = crate::core::tee::tee_and_hint(&raw, "go_build", exit_code) {
-        if !filtered.is_empty() {
-            println!("{}\n{}", filtered, hint);
-        } else {
-            println!("{}", hint);
-        }
-    } else if !filtered.is_empty() {
-        println!("{}", filtered);
-    }
-
-    timer.track(
-        &format!("go build {}", args.join(" ")),
-        &format!("rtk go build {}", args.join(" ")),
-        &raw,
-        &filtered,
-    );
-
-    // Preserve exit code for CI/CD
-    if !output.status.success() {
-        std::process::exit(exit_code);
-    }
-
-    Ok(())
+    crate::core::runner::run_filtered(
+        cmd,
+        "go build",
+        &args.join(" "),
+        filter_go_build,
+        crate::core::runner::RunOptions::with_tee("go_build"),
+    )
 }
 
-pub fn run_vet(args: &[String], verbose: u8) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
+pub fn run_vet(args: &[String], verbose: u8) -> Result<i32> {
     let mut cmd = resolved_command("go");
     cmd.arg("vet");
 
@@ -165,46 +97,16 @@ pub fn run_vet(args: &[String], verbose: u8) -> Result<()> {
         eprintln!("Running: go vet {}", args.join(" "));
     }
 
-    let output = cmd
-        .output()
-        .context("Failed to run go vet. Is Go installed?")?;
-
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    let raw = format!("{}\n{}", stdout, stderr);
-
-    let exit_code = output
-        .status
-        .code()
-        .unwrap_or(if output.status.success() { 0 } else { 1 });
-    let filtered = filter_go_vet(&raw);
-
-    if let Some(hint) = crate::core::tee::tee_and_hint(&raw, "go_vet", exit_code) {
-        if !filtered.is_empty() {
-            println!("{}\n{}", filtered, hint);
-        } else {
-            println!("{}", hint);
-        }
-    } else if !filtered.is_empty() {
-        println!("{}", filtered);
-    }
-
-    timer.track(
-        &format!("go vet {}", args.join(" ")),
-        &format!("rtk go vet {}", args.join(" ")),
-        &raw,
-        &filtered,
-    );
-
-    // Preserve exit code for CI/CD
-    if !output.status.success() {
-        std::process::exit(exit_code);
-    }
-
-    Ok(())
+    crate::core::runner::run_filtered(
+        cmd,
+        "go vet",
+        &args.join(" "),
+        filter_go_vet,
+        crate::core::runner::RunOptions::with_tee("go_vet"),
+    )
 }
 
-pub fn run_other(args: &[OsString], verbose: u8) -> Result<()> {
+pub fn run_other(args: &[OsString], verbose: u8) -> Result<i32> {
     if args.is_empty() {
         anyhow::bail!("go: no subcommand specified");
     }
@@ -248,12 +150,7 @@ pub fn run_other(args: &[OsString], verbose: u8) -> Result<()> {
         &raw, // No filtering for unsupported commands
     );
 
-    // Preserve exit code
-    if !output.status.success() {
-        std::process::exit(output.status.code().unwrap_or(1));
-    }
-
-    Ok(())
+    Ok(exit_code_from_output(&output, "go"))
 }
 
 /// Detect golangci-lint major version when invoked via `go tool`.
@@ -319,7 +216,7 @@ fn match_go_tool(args: &[OsString]) -> Option<(GoTool, &[OsString])> {
 
 /// Run `go tool golangci-lint` and filter its output via the golangci JSON filter.
 /// Reusing parts of golangci_cmd.
-fn run_go_tool_golangci_lint(args: &[OsString], verbose: u8) -> Result<()> {
+fn run_go_tool_golangci_lint(args: &[OsString], verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     let version = detect_go_tool_golangci_version();
@@ -380,20 +277,10 @@ fn run_go_tool_golangci_lint(args: &[OsString], verbose: u8) -> Result<()> {
         &filtered,
     );
 
-    // golangci-lint: exit 0 = clean, exit 1 = lint issues, exit 2+ = config/build error
-    match output.status.code() {
-        Some(0) | Some(1) => Ok(()),
-        Some(code) => {
-            if !stderr.trim().is_empty() {
-                eprintln!("{}", stderr.trim());
-            }
-            std::process::exit(code);
-        }
-        None => {
-            eprintln!("go tool golangci-lint: killed by signal");
-            std::process::exit(130);
-        }
-    }
+    let exit_code = exit_code_from_output(&output, "go tool golangci-lint");
+    // golangci-lint: exit 0 = clean, exit 1 = lint issues found (not an error),
+    // exit 2+ = config/build error, None = killed by signal (OOM, SIGKILL)
+    Ok(if exit_code == 1 { 0 } else { exit_code })
 }
 
 /// Parse go test -json output (NDJSON format)
diff --git a/src/cmds/go/golangci_cmd.rs b/src/cmds/go/golangci_cmd.rs
index 14cfa382c3..94a50e6c3e 100644
--- a/src/cmds/go/golangci_cmd.rs
+++ b/src/cmds/go/golangci_cmd.rs
@@ -1,9 +1,8 @@
 //! Filters golangci-lint output, grouping issues by rule.
 
 use crate::core::config;
-use crate::core::tracking;
 use crate::core::utils::{resolved_command, truncate};
-use anyhow::{Context, Result};
+use anyhow::Result;
 use serde::Deserialize;
 use std::collections::HashMap;
 
@@ -80,9 +79,7 @@ pub(crate) fn detect_major_version() -> u32 {
     }
 }
 
-pub fn run(args: &[String], verbose: u8) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
+pub fn run(args: &[String], verbose: u8) -> Result<i32> {
     let version = detect_major_version();
 
     let mut cmd = resolved_command("golangci-lint");
@@ -117,49 +114,25 @@ pub fn run(args: &[String], verbose: u8) -> Result<()> {
         }
     }
 
-    let output = cmd.output().context(
-        "Failed to run golangci-lint. Is it installed? Try: go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest",
+    let exit_code = crate::core::runner::run_filtered(
+        cmd,
+        "golangci-lint",
+        &args.join(" "),
+        |stdout| {
+            // v2 outputs JSON on first line + trailing text; v1 outputs just JSON
+            let json_output = if version >= 2 {
+                stdout.lines().next().unwrap_or("")
+            } else {
+                stdout
+            };
+            filter_golangci_json(json_output, version)
+        },
+        crate::core::runner::RunOptions::stdout_only(),
     )?;
 
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    let raw = format!("{}\n{}", stdout, stderr);
-
-    // v2 outputs JSON on first line + trailing text; v1 outputs just JSON
-    let json_output = if version >= 2 {
-        stdout.lines().next().unwrap_or("")
-    } else {
-        &*stdout
-    };
-
-    let filtered = filter_golangci_json(json_output, version);
-
-    println!("{}", filtered);
-
-    // Always forward stderr (config errors, missing linters, etc.)
-    if !stderr.trim().is_empty() {
-        eprintln!("{}", stderr.trim());
-    }
-
-    timer.track(
-        &format!("golangci-lint {}", args.join(" ")),
-        &format!("rtk golangci-lint {}", args.join(" ")),
-        &raw,
-        &filtered,
-    );
-
-    // golangci-lint: exit 0 = clean, exit 1 = lint issues, exit 2+ = config/build error
-    // None = killed by signal (OOM, SIGKILL) — always fatal
-    match output.status.code() {
-        Some(0) | Some(1) => Ok(()),
-        Some(code) => {
-            std::process::exit(code);
-        }
-        None => {
-            eprintln!("golangci-lint: killed by signal");
-            std::process::exit(130);
-        }
-    }
+    // golangci-lint: exit 0 = clean, exit 1 = lint issues found (not an error),
+    // exit 2+ = config/build error, None = killed by signal (OOM, SIGKILL)
+    Ok(if exit_code == 1 { 0 } else { exit_code })
 }
 
 /// Filter golangci-lint JSON output - group by linter and file
diff --git a/src/cmds/js/lint_cmd.rs b/src/cmds/js/lint_cmd.rs
index e7a88e890e..f407927d8c 100644
--- a/src/cmds/js/lint_cmd.rs
+++ b/src/cmds/js/lint_cmd.rs
@@ -85,7 +85,7 @@ fn detect_linter(args: &[String]) -> (&str, bool) {
     }
 }
 
-pub fn run(args: &[String], verbose: u8) -> Result<()> {
+pub fn run(args: &[String], verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     let skip = strip_pm_prefix(args);
@@ -181,7 +181,7 @@ pub fn run(args: &[String], verbose: u8) -> Result<()> {
                 stderr.lines().take(5).collect::<Vec<_>>().join("\n")
             );
         }
-        return Ok(());
+        return Ok(crate::core::utils::exit_code_from_output(&output, "eslint"));
     }
 
     let stdout = String::from_utf8_lossy(&output.stdout);
@@ -222,10 +222,10 @@ pub fn run(args: &[String], verbose: u8) -> Result<()> {
     );
 
     if !output.status.success() {
-        std::process::exit(output.status.code().unwrap_or(1));
+        return Ok(crate::core::utils::exit_code_from_output(&output, "eslint"));
     }
 
-    Ok(())
+    Ok(0)
 }
 
 /// Filter ESLint JSON output - group by rule and file
diff --git a/src/cmds/js/next_cmd.rs b/src/cmds/js/next_cmd.rs
index 5a7ad353df..1e17d60c5d 100644
--- a/src/cmds/js/next_cmd.rs
+++ b/src/cmds/js/next_cmd.rs
@@ -1,13 +1,11 @@
 //! Filters Next.js build output down to route metrics and bundle sizes.
 
-use crate::core::tracking;
+use crate::core::runner;
 use crate::core::utils::{resolved_command, strip_ansi, tool_exists, truncate};
-use anyhow::{Context, Result};
+use anyhow::Result;
 use regex::Regex;
 
-pub fn run(args: &[String], verbose: u8) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
+pub fn run(args: &[String], verbose: u8) -> Result<i32> {
     // Try next directly first, fallback to npx if not found
     let next_exists = tool_exists("next");
 
@@ -30,25 +28,13 @@ pub fn run(args: &[String], verbose: u8) -> Result<()> {
         eprintln!("Running: {} build", tool);
     }
 
-    let output = cmd
-        .output()
-        .context("Failed to run next build (try: npm install -g next)")?;
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    let raw = format!("{}\n{}", stdout, stderr);
-
-    let filtered = filter_next_build(&raw);
-
-    println!("{}", filtered);
-
-    timer.track("next build", "rtk next build", &raw, &filtered);
-
-    // Preserve exit code for CI/CD
-    if !output.status.success() {
-        std::process::exit(output.status.code().unwrap_or(1));
-    }
-
-    Ok(())
+    runner::run_filtered(
+        cmd,
+        "next build",
+        &args.join(" "),
+        |raw| filter_next_build(raw),
+        runner::RunOptions::default(),
+    )
 }
 
 /// Filter Next.js build output - extract routes, bundles, warnings
diff --git a/src/cmds/js/npm_cmd.rs b/src/cmds/js/npm_cmd.rs
index 7c86fe7761..6f310a32c5 100644
--- a/src/cmds/js/npm_cmd.rs
+++ b/src/cmds/js/npm_cmd.rs
@@ -1,8 +1,8 @@
 //! Filters npm output and auto-injects the "run" subcommand when appropriate.
 
-use crate::core::tracking;
+use crate::core::runner;
 use crate::core::utils::resolved_command;
-use anyhow::{Context, Result};
+use anyhow::Result;
 
 /// Known npm subcommands that should NOT get "run" injected.
 /// Shared between production code and tests to avoid drift.
@@ -73,9 +73,7 @@ const NPM_SUBCOMMANDS: &[&str] = &[
     "restart",
 ];
 
-pub fn run(args: &[String], verbose: u8, skip_env: bool) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
+pub fn run(args: &[String], verbose: u8, skip_env: bool) -> Result<i32> {
     let mut cmd = resolved_command("npm");
 
     // Determine if this is "npm run <script>" or another npm subcommand (install, list, etc.)
@@ -111,26 +109,13 @@ pub fn run(args: &[String], verbose: u8, skip_env: bool) -> Result<()> {
         eprintln!("Running: npm {}", args.join(" "));
     }
 
-    let output = cmd.output().context("Failed to run npm")?;
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    let raw = format!("{}\n{}", stdout, stderr);
-
-    let filtered = filter_npm_output(&raw);
-    println!("{}", filtered);
-
-    timer.track(
-        &format!("npm {}", args.join(" ")),
-        &format!("rtk npm {}", args.join(" ")),
-        &raw,
-        &filtered,
-    );
-
-    if !output.status.success() {
-        std::process::exit(output.status.code().unwrap_or(1));
-    }
-
-    Ok(())
+    runner::run_filtered(
+        cmd,
+        "npm",
+        &args.join(" "),
+        |raw| filter_npm_output(raw),
+        runner::RunOptions::default(),
+    )
 }
 
 /// Filter npm run output - strip boilerplate, progress bars, npm WARN
diff --git a/src/cmds/js/playwright_cmd.rs b/src/cmds/js/playwright_cmd.rs
index a2a8054261..e5077fa0fd 100644
--- a/src/cmds/js/playwright_cmd.rs
+++ b/src/cmds/js/playwright_cmd.rs
@@ -240,7 +240,7 @@ fn extract_failures_regex(output: &str) -> Vec<TestFailure> {
     failures
 }
 
-pub fn run(args: &[String], verbose: u8) -> Result<()> {
+pub fn run(args: &[String], verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     // Skip `which playwright` — it can find pyenv shims or other non-Node
@@ -316,7 +316,7 @@ pub fn run(args: &[String], verbose: u8) -> Result<()> {
         }
     };
 
-    let exit_code = output.status.code().unwrap_or(1);
+    let exit_code = crate::core::utils::exit_code_from_output(&output, "playwright");
     if let Some(hint) = crate::core::tee::tee_and_hint(&raw, "playwright", exit_code) {
         println!("{}\n{}", filtered, hint);
     } else {
@@ -332,10 +332,10 @@ pub fn run(args: &[String], verbose: u8) -> Result<()> {
 
     // Preserve exit code for CI/CD
     if !output.status.success() {
-        std::process::exit(exit_code);
+        return Ok(exit_code);
     }
 
-    Ok(())
+    Ok(0)
 }
 
 #[cfg(test)]
diff --git a/src/cmds/js/pnpm_cmd.rs b/src/cmds/js/pnpm_cmd.rs
index 9746b38f13..adf861cff9 100644
--- a/src/cmds/js/pnpm_cmd.rs
+++ b/src/cmds/js/pnpm_cmd.rs
@@ -285,7 +285,7 @@ pub enum PnpmCommand {
     Install { packages: Vec<String> },
 }
 
-pub fn run(cmd: PnpmCommand, args: &[String], verbose: u8) -> Result<()> {
+pub fn run(cmd: PnpmCommand, args: &[String], verbose: u8) -> Result<i32> {
     match cmd {
         PnpmCommand::List { depth } => run_list(depth, args, verbose),
         PnpmCommand::Outdated => run_outdated(args, verbose),
@@ -293,7 +293,7 @@ pub fn run(cmd: PnpmCommand, args: &[String], verbose: u8) -> Result<()> {
     }
 }
 
-fn run_list(depth: usize, args: &[String], verbose: u8) -> Result<()> {
+fn run_list(depth: usize, args: &[String], verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     let mut cmd = resolved_command("pnpm");
@@ -310,7 +310,7 @@ fn run_list(depth: usize, args: &[String], verbose: u8) -> Result<()> {
     if !output.status.success() {
         let stderr = String::from_utf8_lossy(&output.stderr);
         eprint!("{}", stderr);
-        std::process::exit(output.status.code().unwrap_or(1));
+        return Ok(crate::core::utils::exit_code_from_output(&output, "pnpm"));
     }
 
     let stdout = String::from_utf8_lossy(&output.stdout);
@@ -347,10 +347,10 @@ fn run_list(depth: usize, args: &[String], verbose: u8) -> Result<()> {
         &filtered,
     );
 
-    Ok(())
+    Ok(0)
 }
 
-fn run_outdated(args: &[String], verbose: u8) -> Result<()> {
+fn run_outdated(args: &[String], verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     let mut cmd = resolved_command("pnpm");
@@ -398,10 +398,10 @@ fn run_outdated(args: &[String], verbose: u8) -> Result<()> {
 
     timer.track("pnpm outdated", "rtk pnpm outdated", &combined, &filtered);
 
-    Ok(())
+    Ok(0)
 }
 
-fn run_install(packages: &[String], args: &[String], verbose: u8) -> Result<()> {
+fn run_install(packages: &[String], args: &[String], verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     // Validate package names to prevent command injection
@@ -435,7 +435,7 @@ fn run_install(packages: &[String], args: &[String], verbose: u8) -> Result<()>
 
     if !output.status.success() {
         eprint!("{}", stderr);
-        std::process::exit(output.status.code().unwrap_or(1));
+        return Ok(crate::core::utils::exit_code_from_output(&output, "pnpm"));
     }
 
     let combined = format!("{}{}", stdout, stderr);
@@ -450,7 +450,7 @@ fn run_install(packages: &[String], args: &[String], verbose: u8) -> Result<()>
         &filtered,
     );
 
-    Ok(())
+    Ok(0)
 }
 
 /// Filter pnpm install output - remove progress bars, keep summary
@@ -493,7 +493,7 @@ fn filter_pnpm_install(output: &str) -> String {
 }
 
 /// Runs an unsupported pnpm subcommand by passing it through directly
-pub fn run_passthrough(args: &[OsString], verbose: u8) -> Result<()> {
+pub fn run_passthrough(args: &[OsString], verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     if verbose > 0 {
@@ -511,9 +511,9 @@ pub fn run_passthrough(args: &[OsString], verbose: u8) -> Result<()> {
     );
 
     if !status.success() {
-        std::process::exit(status.code().unwrap_or(1));
+        return Ok(crate::core::utils::exit_code_from_status(&status, "pnpm"));
     }
-    Ok(())
+    Ok(0)
 }
 
 #[cfg(test)]
diff --git a/src/cmds/js/prettier_cmd.rs b/src/cmds/js/prettier_cmd.rs
index af6c27a97c..5dffa346b4 100644
--- a/src/cmds/js/prettier_cmd.rs
+++ b/src/cmds/js/prettier_cmd.rs
@@ -1,15 +1,11 @@
 //! Filters Prettier output to show only files that need formatting.
 
-use crate::core::tracking;
 use crate::core::utils::package_manager_exec;
-use anyhow::{Context, Result};
-
-pub fn run(args: &[String], verbose: u8) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
+use anyhow::Result;
 
+pub fn run(args: &[String], verbose: u8) -> Result<i32> {
     let mut cmd = package_manager_exec("prettier");
 
-    // Add user arguments
     for arg in args {
         cmd.arg(arg);
     }
@@ -18,50 +14,13 @@ pub fn run(args: &[String], verbose: u8) -> Result<()> {
         eprintln!("Running: prettier {}", args.join(" "));
     }
 
-    let output = cmd
-        .output()
-        .context("Failed to run prettier (try: npm install -g prettier)")?;
-
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    let raw = format!("{}\n{}", stdout, stderr);
-
-    // #221: If prettier is not installed or produced no meaningful output,
-    // show stderr as-is instead of a misleading "All files formatted" message.
-    let has_output = stdout.lines().any(|l| !l.trim().is_empty());
-    if !has_output && !output.status.success() {
-        let msg = stderr.trim();
-        if msg.is_empty() {
-            eprintln!("Error: prettier not found or produced no output");
-        } else {
-            eprintln!("{}", msg);
-        }
-        timer.track(
-            &format!("prettier {}", args.join(" ")),
-            &format!("rtk prettier {}", args.join(" ")),
-            &raw,
-            &raw,
-        );
-        std::process::exit(output.status.code().unwrap_or(1));
-    }
-
-    let filtered = filter_prettier_output(&raw);
-
-    println!("{}", filtered);
-
-    timer.track(
-        &format!("prettier {}", args.join(" ")),
-        &format!("rtk prettier {}", args.join(" ")),
-        &raw,
-        &filtered,
-    );
-
-    // Preserve exit code for CI/CD
-    if !output.status.success() {
-        std::process::exit(output.status.code().unwrap_or(1));
-    }
-
-    Ok(())
+    crate::core::runner::run_filtered(
+        cmd,
+        "prettier",
+        &args.join(" "),
+        filter_prettier_output,
+        crate::core::runner::RunOptions::stdout_only(),
+    )
 }
 
 /// Filter Prettier output - show only files that need formatting
diff --git a/src/cmds/js/prisma_cmd.rs b/src/cmds/js/prisma_cmd.rs
index a1299ede05..b96ca392d9 100644
--- a/src/cmds/js/prisma_cmd.rs
+++ b/src/cmds/js/prisma_cmd.rs
@@ -19,7 +19,7 @@ pub enum MigrateSubcommand {
     Deploy,
 }
 
-pub fn run(cmd: PrismaCommand, args: &[String], verbose: u8) -> Result<()> {
+pub fn run(cmd: PrismaCommand, args: &[String], verbose: u8) -> Result<i32> {
     match cmd {
         PrismaCommand::Generate => run_generate(args, verbose),
         PrismaCommand::Migrate { subcommand } => run_migrate(subcommand, args, verbose),
@@ -38,7 +38,7 @@ fn create_prisma_command() -> Command {
     }
 }
 
-fn run_generate(args: &[String], verbose: u8) -> Result<()> {
+fn run_generate(args: &[String], verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     let mut cmd = create_prisma_command();
@@ -56,7 +56,7 @@ fn run_generate(args: &[String], verbose: u8) -> Result<()> {
         .output()
         .context("Failed to run prisma generate (try: npm install -g prisma)")?;
 
-    let exit_code = output.status.code().unwrap_or(1);
+    let exit_code = crate::core::utils::exit_code_from_output(&output, "prisma");
     let stdout = String::from_utf8_lossy(&output.stdout);
     let stderr = String::from_utf8_lossy(&output.stderr);
     let raw = format!("{}\n{}", stdout, stderr);
@@ -69,17 +69,17 @@ fn run_generate(args: &[String], verbose: u8) -> Result<()> {
             eprint!("{}", stderr);
         }
         timer.track("prisma generate", "rtk prisma generate", &raw, &raw);
-        std::process::exit(exit_code);
+        return Ok(exit_code);
     }
 
     let filtered = filter_prisma_generate(&raw);
     println!("{}", filtered);
     timer.track("prisma generate", "rtk prisma generate", &raw, &filtered);
 
-    Ok(())
+    Ok(0)
 }
 
-fn run_migrate(subcommand: MigrateSubcommand, args: &[String], verbose: u8) -> Result<()> {
+fn run_migrate(subcommand: MigrateSubcommand, args: &[String], verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     let mut cmd = create_prisma_command();
@@ -113,7 +113,7 @@ fn run_migrate(subcommand: MigrateSubcommand, args: &[String], verbose: u8) -> R
 
     let output = cmd.output().context("Failed to run prisma migrate")?;
 
-    let exit_code = output.status.code().unwrap_or(1);
+    let exit_code = crate::core::utils::exit_code_from_output(&output, "prisma");
     let stdout = String::from_utf8_lossy(&output.stdout);
     let stderr = String::from_utf8_lossy(&output.stderr);
     let raw = format!("{}\n{}", stdout, stderr);
@@ -126,7 +126,7 @@ fn run_migrate(subcommand: MigrateSubcommand, args: &[String], verbose: u8) -> R
             eprint!("{}", stderr);
         }
         timer.track(cmd_name, &format!("rtk {}", cmd_name), &raw, &raw);
-        std::process::exit(exit_code);
+        return Ok(exit_code);
     }
 
     let filtered = match subcommand {
@@ -138,10 +138,10 @@ fn run_migrate(subcommand: MigrateSubcommand, args: &[String], verbose: u8) -> R
     println!("{}", filtered);
     timer.track(cmd_name, &format!("rtk {}", cmd_name), &raw, &filtered);
 
-    Ok(())
+    Ok(0)
 }
 
-fn run_db_push(args: &[String], verbose: u8) -> Result<()> {
+fn run_db_push(args: &[String], verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     let mut cmd = create_prisma_command();
@@ -157,7 +157,7 @@ fn run_db_push(args: &[String], verbose: u8) -> Result<()> {
 
     let output = cmd.output().context("Failed to run prisma db push")?;
 
-    let exit_code = output.status.code().unwrap_or(1);
+    let exit_code = crate::core::utils::exit_code_from_output(&output, "prisma");
     let stdout = String::from_utf8_lossy(&output.stdout);
     let stderr = String::from_utf8_lossy(&output.stderr);
     let raw = format!("{}\n{}", stdout, stderr);
@@ -170,14 +170,14 @@ fn run_db_push(args: &[String], verbose: u8) -> Result<()> {
             eprint!("{}", stderr);
         }
         timer.track("prisma db push", "rtk prisma db push", &raw, &raw);
-        std::process::exit(exit_code);
+        return Ok(exit_code);
     }
 
     let filtered = filter_db_push(&raw);
     println!("{}", filtered);
     timer.track("prisma db push", "rtk prisma db push", &raw, &filtered);
 
-    Ok(())
+    Ok(0)
 }
 
 /// Filter prisma generate output - strip ASCII art, extract counts
diff --git a/src/cmds/js/tsc_cmd.rs b/src/cmds/js/tsc_cmd.rs
index bddd047b9c..ed64fd09ed 100644
--- a/src/cmds/js/tsc_cmd.rs
+++ b/src/cmds/js/tsc_cmd.rs
@@ -1,14 +1,12 @@
 //! Filters TypeScript compiler errors, grouping them by file and error code.
 
-use crate::core::tracking;
+use crate::core::runner;
 use crate::core::utils::{resolved_command, tool_exists, truncate};
-use anyhow::{Context, Result};
+use anyhow::Result;
 use regex::Regex;
 use std::collections::HashMap;
 
-pub fn run(args: &[String], verbose: u8) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
+pub fn run(args: &[String], verbose: u8) -> Result<i32> {
     // Try tsc directly first, fallback to npx if not found
     let tsc_exists = tool_exists("tsc");
 
@@ -29,31 +27,13 @@ pub fn run(args: &[String], verbose: u8) -> Result<()> {
         eprintln!("Running: {} {}", tool, args.join(" "));
     }
 
-    let output = cmd
-        .output()
-        .context("Failed to run tsc (try: npm install -g typescript)")?;
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    let raw = format!("{}\n{}", stdout, stderr);
-
-    let filtered = filter_tsc_output(&raw);
-
-    let exit_code = output.status.code().unwrap_or(1);
-    if let Some(hint) = crate::core::tee::tee_and_hint(&raw, "tsc", exit_code) {
-        println!("{}\n{}", filtered, hint);
-    } else {
-        println!("{}", filtered);
-    }
-
-    timer.track(
-        &format!("tsc {}", args.join(" ")),
-        &format!("rtk tsc {}", args.join(" ")),
-        &raw,
-        &filtered,
-    );
-
-    // Preserve tsc exit code for CI/CD compatibility
-    std::process::exit(exit_code);
+    runner::run_filtered(
+        cmd,
+        "tsc",
+        &args.join(" "),
+        |raw| filter_tsc_output(raw),
+        runner::RunOptions::with_tee("tsc"),
+    )
 }
 
 /// Filter TypeScript compiler output - group errors by file, show every error
diff --git a/src/cmds/js/vitest_cmd.rs b/src/cmds/js/vitest_cmd.rs
index bc68e2dd5a..4f5e9ae471 100644
--- a/src/cmds/js/vitest_cmd.rs
+++ b/src/cmds/js/vitest_cmd.rs
@@ -215,13 +215,13 @@ pub enum VitestCommand {
     Run,
 }
 
-pub fn run(cmd: VitestCommand, args: &[String], verbose: u8) -> Result<()> {
+pub fn run(cmd: VitestCommand, args: &[String], verbose: u8) -> Result<i32> {
     match cmd {
         VitestCommand::Run => run_vitest(args, verbose),
     }
 }
 
-fn run_vitest(args: &[String], verbose: u8) -> Result<()> {
+fn run_vitest(args: &[String], verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     let mut cmd = package_manager_exec("vitest");
@@ -262,7 +262,7 @@ fn run_vitest(args: &[String], verbose: u8) -> Result<()> {
         }
     };
 
-    let exit_code = output.status.code().unwrap_or(1);
+    let exit_code = crate::core::utils::exit_code_from_output(&output, "vitest");
     if let Some(hint) = crate::core::tee::tee_and_hint(&combined, "vitest_run", exit_code) {
         println!("{}\n{}", filtered, hint);
     } else {
@@ -271,8 +271,10 @@ fn run_vitest(args: &[String], verbose: u8) -> Result<()> {
 
     timer.track("vitest run", "rtk vitest run", &combined, &filtered);
 
-    // Propagate original exit code
-    std::process::exit(exit_code)
+    if !output.status.success() {
+        return Ok(exit_code);
+    }
+    Ok(0)
 }
 
 #[cfg(test)]
diff --git a/src/cmds/python/mypy_cmd.rs b/src/cmds/python/mypy_cmd.rs
index 5114452c81..b0b6a43f3f 100644
--- a/src/cmds/python/mypy_cmd.rs
+++ b/src/cmds/python/mypy_cmd.rs
@@ -1,14 +1,12 @@
 //! Filters mypy type-checking output, grouping errors by file.
 
-use crate::core::tracking;
+use crate::core::runner;
 use crate::core::utils::{resolved_command, strip_ansi, tool_exists, truncate};
-use anyhow::{Context, Result};
+use anyhow::Result;
 use regex::Regex;
 use std::collections::HashMap;
 
-pub fn run(args: &[String], verbose: u8) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
+pub fn run(args: &[String], verbose: u8) -> Result<i32> {
     let mut cmd = if tool_exists("mypy") {
         resolved_command("mypy")
     } else {
@@ -25,30 +23,13 @@ pub fn run(args: &[String], verbose: u8) -> Result<()> {
         eprintln!("Running: mypy {}", args.join(" "));
     }
 
-    let output = cmd
-        .output()
-        .context("Failed to run mypy. Is it installed? Try: pip install mypy")?;
-
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    let raw = format!("{}\n{}", stdout, stderr);
-    let clean = strip_ansi(&raw);
-
-    let filtered = filter_mypy_output(&clean);
-
-    println!("{}", filtered);
-
-    timer.track(
-        &format!("mypy {}", args.join(" ")),
-        &format!("rtk mypy {}", args.join(" ")),
-        &raw,
-        &filtered,
-    );
-
-    if !output.status.success() {
-        std::process::exit(output.status.code().unwrap_or(1));
-    }
-    Ok(())
+    runner::run_filtered(
+        cmd,
+        "mypy",
+        &args.join(" "),
+        |raw| filter_mypy_output(&strip_ansi(raw)),
+        runner::RunOptions::default(),
+    )
 }
 
 struct MypyError {
diff --git a/src/cmds/python/pip_cmd.rs b/src/cmds/python/pip_cmd.rs
index 83e3c5b0bb..00090d4257 100644
--- a/src/cmds/python/pip_cmd.rs
+++ b/src/cmds/python/pip_cmd.rs
@@ -1,7 +1,7 @@
 //! Filters pip and uv package manager output.
 
 use crate::core::tracking;
-use crate::core::utils::{resolved_command, tool_exists};
+use crate::core::utils::{exit_code_from_output, resolved_command, tool_exists};
 use anyhow::{Context, Result};
 use serde::Deserialize;
 
@@ -13,7 +13,7 @@ struct Package {
     latest_version: Option<String>,
 }
 
-pub fn run(args: &[String], verbose: u8) -> Result<()> {
+pub fn run(args: &[String], verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     // Auto-detect uv vs pip
@@ -27,7 +27,7 @@ pub fn run(args: &[String], verbose: u8) -> Result<()> {
     // Detect subcommand
     let subcommand = args.first().map(|s| s.as_str()).unwrap_or("");
 
-    let (cmd_str, filtered) = match subcommand {
+    let (cmd_str, filtered, exit_code) = match subcommand {
         "list" => run_list(base_cmd, &args[1..], verbose)?,
         "outdated" => run_outdated(base_cmd, &args[1..], verbose)?,
         "install" | "uninstall" | "show" => {
@@ -47,10 +47,10 @@ pub fn run(args: &[String], verbose: u8) -> Result<()> {
         &filtered,
     );
 
-    Ok(())
+    Ok(exit_code)
 }
 
-fn run_list(base_cmd: &str, args: &[String], verbose: u8) -> Result<(String, String)> {
+fn run_list(base_cmd: &str, args: &[String], verbose: u8) -> Result<(String, String, i32)> {
     let mut cmd = resolved_command(base_cmd);
 
     if base_cmd == "uv" {
@@ -78,14 +78,11 @@ fn run_list(base_cmd: &str, args: &[String], verbose: u8) -> Result<(String, Str
     let filtered = filter_pip_list(&stdout);
     println!("{}", filtered);
 
-    if !output.status.success() {
-        std::process::exit(output.status.code().unwrap_or(1));
-    }
-
-    Ok((raw, filtered))
+    let exit_code = exit_code_from_output(&output, "pip");
+    Ok((raw, filtered, exit_code))
 }
 
-fn run_outdated(base_cmd: &str, args: &[String], verbose: u8) -> Result<(String, String)> {
+fn run_outdated(base_cmd: &str, args: &[String], verbose: u8) -> Result<(String, String, i32)> {
     let mut cmd = resolved_command(base_cmd);
 
     if base_cmd == "uv" {
@@ -113,14 +110,11 @@ fn run_outdated(base_cmd: &str, args: &[String], verbose: u8) -> Result<(String,
     let filtered = filter_pip_outdated(&stdout);
     println!("{}", filtered);
 
-    if !output.status.success() {
-        std::process::exit(output.status.code().unwrap_or(1));
-    }
-
-    Ok((raw, filtered))
+    let exit_code = exit_code_from_output(&output, "pip");
+    Ok((raw, filtered, exit_code))
 }
 
-fn run_passthrough(base_cmd: &str, args: &[String], verbose: u8) -> Result<(String, String)> {
+fn run_passthrough(base_cmd: &str, args: &[String], verbose: u8) -> Result<(String, String, i32)> {
     let mut cmd = resolved_command(base_cmd);
 
     if base_cmd == "uv" {
@@ -146,11 +140,8 @@ fn run_passthrough(base_cmd: &str, args: &[String], verbose: u8) -> Result<(Stri
     print!("{}", stdout);
     eprint!("{}", stderr);
 
-    if !output.status.success() {
-        std::process::exit(output.status.code().unwrap_or(1));
-    }
-
-    Ok((raw.clone(), raw))
+    let exit_code = exit_code_from_output(&output, "pip");
+    Ok((raw.clone(), raw, exit_code))
 }
 
 /// Filter pip list JSON output
diff --git a/src/cmds/python/pytest_cmd.rs b/src/cmds/python/pytest_cmd.rs
index 412acf9c7a..3e8cde4ed9 100644
--- a/src/cmds/python/pytest_cmd.rs
+++ b/src/cmds/python/pytest_cmd.rs
@@ -1,8 +1,8 @@
 //! Filters pytest output to show only failures and the summary line.
 
-use crate::core::tracking;
+use crate::core::runner;
 use crate::core::utils::{resolved_command, tool_exists, truncate};
-use anyhow::{Context, Result};
+use anyhow::Result;
 
 #[derive(Debug, PartialEq)]
 enum ParseState {
@@ -12,20 +12,15 @@ enum ParseState {
     Summary,
 }
 
-pub fn run(args: &[String], verbose: u8) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
-    // Try to detect pytest command (could be "pytest", "python -m pytest", etc.)
+pub fn run(args: &[String], verbose: u8) -> Result<i32> {
     let mut cmd = if tool_exists("pytest") {
         resolved_command("pytest")
     } else {
-        // Fallback to python -m pytest
         let mut c = resolved_command("python");
         c.arg("-m").arg("pytest");
         c
     };
 
-    // Force short traceback and quiet mode for compact output
     let has_tb_flag = args.iter().any(|a| a.starts_with("--tb"));
     let has_quiet_flag = args.iter().any(|a| a == "-q" || a == "--quiet");
 
@@ -44,44 +39,13 @@ pub fn run(args: &[String], verbose: u8) -> Result<()> {
         eprintln!("Running: pytest --tb=short -q {}", args.join(" "));
     }
 
-    let output = cmd
-        .output()
-        .context("Failed to run pytest. Is it installed? Try: pip install pytest")?;
-
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    let raw = format!("{}\n{}", stdout, stderr);
-
-    let filtered = filter_pytest_output(&stdout);
-
-    let exit_code = output
-        .status
-        .code()
-        .unwrap_or(if output.status.success() { 0 } else { 1 });
-    if let Some(hint) = crate::core::tee::tee_and_hint(&raw, "pytest", exit_code) {
-        println!("{}\n{}", filtered, hint);
-    } else {
-        println!("{}", filtered);
-    }
-
-    // Include stderr if present (import errors, etc.)
-    if !stderr.trim().is_empty() {
-        eprintln!("{}", stderr.trim());
-    }
-
-    timer.track(
-        &format!("pytest {}", args.join(" ")),
-        &format!("rtk pytest {}", args.join(" ")),
-        &raw,
-        &filtered,
-    );
-
-    // Preserve exit code for CI/CD
-    if !output.status.success() {
-        std::process::exit(exit_code);
-    }
-
-    Ok(())
+    runner::run_filtered(
+        cmd,
+        "pytest",
+        &args.join(" "),
+        filter_pytest_output,
+        runner::RunOptions::stdout_only().tee("pytest"),
+    )
 }
 
 /// Parse pytest output using state machine
diff --git a/src/cmds/python/ruff_cmd.rs b/src/cmds/python/ruff_cmd.rs
index b0073a8d02..b50409629f 100644
--- a/src/cmds/python/ruff_cmd.rs
+++ b/src/cmds/python/ruff_cmd.rs
@@ -1,9 +1,9 @@
 //! Filters Ruff linter and formatter output.
 
 use crate::core::config;
-use crate::core::tracking;
+use crate::core::runner;
 use crate::core::utils::{resolved_command, truncate};
-use anyhow::{Context, Result};
+use anyhow::Result;
 use serde::Deserialize;
 use std::collections::HashMap;
 
@@ -34,10 +34,7 @@ struct RuffDiagnostic {
     fix: Option<RuffFix>,
 }
 
-pub fn run(args: &[String], verbose: u8) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
-    // Detect subcommand: check, format, or version
+pub fn run(args: &[String], verbose: u8) -> Result<i32> {
     let is_check = args.is_empty()
         || args[0] == "check"
         || (!args[0].starts_with('-') && args[0] != "format" && args[0] != "version");
@@ -47,14 +44,12 @@ pub fn run(args: &[String], verbose: u8) -> Result<()> {
     let mut cmd = resolved_command("ruff");
 
     if is_check {
-        // Force JSON output for check command
         if !args.contains(&"--output-format".to_string()) {
             cmd.arg("check").arg("--output-format=json");
         } else {
             cmd.arg("check");
         }
 
-        // Add user arguments (skip "check" if it was the first arg)
         let start_idx = if !args.is_empty() && args[0] == "check" {
             1
         } else {
@@ -64,7 +59,6 @@ pub fn run(args: &[String], verbose: u8) -> Result<()> {
             cmd.arg(arg);
         }
 
-        // Default to current directory if no path specified
         if args
             .iter()
             .skip(start_idx)
@@ -73,7 +67,6 @@ pub fn run(args: &[String], verbose: u8) -> Result<()> {
             cmd.arg(".");
         }
     } else {
-        // Format or other commands - pass through
         for arg in args {
             cmd.arg(arg);
         }
@@ -83,38 +76,21 @@ pub fn run(args: &[String], verbose: u8) -> Result<()> {
         eprintln!("Running: ruff {}", args.join(" "));
     }
 
-    let output = cmd
-        .output()
-        .context("Failed to run ruff. Is it installed? Try: pip install ruff")?;
-
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    let raw = format!("{}\n{}", stdout, stderr);
-
-    let filtered = if is_check && !stdout.trim().is_empty() {
-        filter_ruff_check_json(&stdout)
-    } else if is_format {
-        filter_ruff_format(&raw)
-    } else {
-        // Fallback for other commands (version, etc.)
-        raw.trim().to_string()
-    };
-
-    println!("{}", filtered);
-
-    timer.track(
-        &format!("ruff {}", args.join(" ")),
-        &format!("rtk ruff {}", args.join(" ")),
-        &raw,
-        &filtered,
-    );
-
-    // Preserve exit code for CI/CD
-    if !output.status.success() {
-        std::process::exit(output.status.code().unwrap_or(1));
-    }
-
-    Ok(())
+    runner::run_filtered(
+        cmd,
+        "ruff",
+        &args.join(" "),
+        move |stdout| {
+            if is_check && !stdout.trim().is_empty() {
+                filter_ruff_check_json(stdout)
+            } else if is_format {
+                filter_ruff_format(stdout)
+            } else {
+                stdout.trim().to_string()
+            }
+        },
+        runner::RunOptions::stdout_only(),
+    )
 }
 
 /// Filter ruff check JSON output - group by rule and file
diff --git a/src/cmds/ruby/rake_cmd.rs b/src/cmds/ruby/rake_cmd.rs
index e116c8f90a..0b2c4c0147 100644
--- a/src/cmds/ruby/rake_cmd.rs
+++ b/src/cmds/ruby/rake_cmd.rs
@@ -4,9 +4,9 @@
 //! `rails test`, filtering down to failures/errors and the summary line.
 //! Uses `ruby_exec("rake")` to auto-detect `bundle exec`.
 
-use crate::core::tracking;
-use crate::core::utils::{exit_code_from_output, ruby_exec, strip_ansi};
-use anyhow::{Context, Result};
+use crate::core::runner;
+use crate::core::utils::{ruby_exec, strip_ansi};
+use anyhow::Result;
 
 /// Decide whether to use `rake test` or `rails test` based on args.
 ///
@@ -46,9 +46,7 @@ fn looks_like_test_path(arg: &str) -> bool {
         || path.contains("_spec.rb")
 }
 
-pub fn run(args: &[String], verbose: u8) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
+pub fn run(args: &[String], verbose: u8) -> Result<i32> {
     let (tool, effective_args) = select_runner(args);
     let mut cmd = ruby_exec(tool);
     for arg in &effective_args {
@@ -63,39 +61,13 @@ pub fn run(args: &[String], verbose: u8) -> Result<()> {
         );
     }
 
-    let output = cmd
-        .output()
-        .context("Failed to run rake. Is it installed? Try: gem install rake")?;
-
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    let raw = format!("{}\n{}", stdout, stderr);
-
-    let filtered = filter_minitest_output(&raw);
-
-    let exit_code = exit_code_from_output(&output, "rake");
-    if let Some(hint) = crate::core::tee::tee_and_hint(&raw, "rake", exit_code) {
-        println!("{}\n{}", filtered, hint);
-    } else {
-        println!("{}", filtered);
-    }
-
-    if !stderr.trim().is_empty() && verbose > 0 {
-        eprintln!("{}", stderr.trim());
-    }
-
-    timer.track(
-        &format!("rake {}", args.join(" ")),
-        &format!("rtk rake {}", args.join(" ")),
-        &raw,
-        &filtered,
-    );
-
-    if !output.status.success() {
-        std::process::exit(exit_code);
-    }
-
-    Ok(())
+    runner::run_filtered(
+        cmd,
+        "rake",
+        &args.join(" "),
+        filter_minitest_output,
+        runner::RunOptions::with_tee("rake"),
+    )
 }
 
 #[derive(Debug, PartialEq)]
diff --git a/src/cmds/ruby/rspec_cmd.rs b/src/cmds/ruby/rspec_cmd.rs
index 7b3d94db4a..cd909b3010 100644
--- a/src/cmds/ruby/rspec_cmd.rs
+++ b/src/cmds/ruby/rspec_cmd.rs
@@ -5,9 +5,9 @@
 //! (e.g., user specified `--format documentation`) or when injected JSON output
 //! fails to parse.
 
-use crate::core::tracking;
-use crate::core::utils::{exit_code_from_output, fallback_tail, ruby_exec, truncate};
-use anyhow::{Context, Result};
+use crate::core::runner;
+use crate::core::utils::{fallback_tail, ruby_exec, truncate};
+use anyhow::Result;
 use lazy_static::lazy_static;
 use regex::Regex;
 use serde::Deserialize;
@@ -62,13 +62,9 @@ struct RspecSummary {
 
 // ── Public entry point ───────────────────────────────────────────────────────
 
-pub fn run(args: &[String], verbose: u8) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
+pub fn run(args: &[String], verbose: u8) -> Result<i32> {
     let mut cmd = ruby_exec("rspec");
 
-    // Inject --format json unless the user already specified a format.
-    // Handles: --format, -f, --format=..., -fj, -fjson, -fdocumentation (from PR #534)
     let has_format = args.iter().any(|a| {
         a == "--format"
             || a == "-f"
@@ -87,48 +83,20 @@ pub fn run(args: &[String], verbose: u8) -> Result<()> {
         eprintln!("Running: rspec{} {}", injected, args.join(" "));
     }
 
-    let output = cmd.output().context(
-        "Failed to run rspec. Is it installed? Try: gem install rspec or add it to your Gemfile",
-    )?;
-
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    let raw = format!("{}\n{}", stdout, stderr);
-
-    let exit_code = exit_code_from_output(&output, "rspec");
-
-    let filtered = if stdout.trim().is_empty() && !output.status.success() {
-        "RSpec: FAILED (no stdout, see stderr below)".to_string()
-    } else if has_format {
-        // User specified format — use text fallback on stripped output
-        let stripped = strip_noise(&stdout);
-        filter_rspec_text(&stripped)
-    } else {
-        filter_rspec_output(&stdout)
-    };
-
-    if let Some(hint) = crate::core::tee::tee_and_hint(&raw, "rspec", exit_code) {
-        println!("{}\n{}", filtered, hint);
-    } else {
-        println!("{}", filtered);
-    }
-
-    if !stderr.trim().is_empty() && (!output.status.success() || verbose > 0) {
-        eprintln!("{}", stderr.trim());
-    }
-
-    timer.track(
-        &format!("rspec {}", args.join(" ")),
-        &format!("rtk rspec {}", args.join(" ")),
-        &raw,
-        &filtered,
-    );
-
-    if !output.status.success() {
-        std::process::exit(exit_code);
-    }
-
-    Ok(())
+    runner::run_filtered(
+        cmd,
+        "rspec",
+        &args.join(" "),
+        move |stdout| {
+            if has_format {
+                let stripped = strip_noise(stdout);
+                filter_rspec_text(&stripped)
+            } else {
+                filter_rspec_output(stdout)
+            }
+        },
+        runner::RunOptions::stdout_only().tee("rspec"),
+    )
 }
 
 // ── Noise stripping ─────────────────────────────────────────────────────────
diff --git a/src/cmds/ruby/rubocop_cmd.rs b/src/cmds/ruby/rubocop_cmd.rs
index 14342d8f65..5ad541ca76 100644
--- a/src/cmds/ruby/rubocop_cmd.rs
+++ b/src/cmds/ruby/rubocop_cmd.rs
@@ -5,9 +5,9 @@
 //! when the user specifies a custom format, or when injected JSON output fails
 //! to parse.
 
-use crate::core::tracking;
-use crate::core::utils::{exit_code_from_output, ruby_exec};
-use anyhow::{Context, Result};
+use crate::core::runner;
+use crate::core::utils::ruby_exec;
+use anyhow::Result;
 use serde::Deserialize;
 
 // ── JSON structures matching RuboCop's --format json output ─────────────────
@@ -50,17 +50,13 @@ struct RubocopSummary {
 
 // ── Public entry point ───────────────────────────────────────────────────────
 
-pub fn run(args: &[String], verbose: u8) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
+pub fn run(args: &[String], verbose: u8) -> Result<i32> {
     let mut cmd = ruby_exec("rubocop");
 
-    // Detect autocorrect mode
     let is_autocorrect = args
         .iter()
         .any(|a| a == "-a" || a == "-A" || a == "--auto-correct" || a == "--auto-correct-all");
 
-    // Inject --format json unless the user already specified a format
     let has_format = args
         .iter()
         .any(|a| a.starts_with("--format") || a.starts_with("-f"));
@@ -75,46 +71,19 @@ pub fn run(args: &[String], verbose: u8) -> Result<()> {
         eprintln!("Running: rubocop {}", args.join(" "));
     }
 
-    let output = cmd.output().context(
-        "Failed to run rubocop. Is it installed? Try: gem install rubocop or add it to your Gemfile",
-    )?;
-
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    let raw = format!("{}\n{}", stdout, stderr);
-
-    let exit_code = exit_code_from_output(&output, "rubocop");
-
-    let filtered = if stdout.trim().is_empty() && !output.status.success() {
-        "RuboCop: FAILED (no stdout, see stderr below)".to_string()
-    } else if has_format || is_autocorrect {
-        filter_rubocop_text(&stdout)
-    } else {
-        filter_rubocop_json(&stdout)
-    };
-
-    if let Some(hint) = crate::core::tee::tee_and_hint(&raw, "rubocop", exit_code) {
-        println!("{}\n{}", filtered, hint);
-    } else {
-        println!("{}", filtered);
-    }
-
-    if !stderr.trim().is_empty() && (!output.status.success() || verbose > 0) {
-        eprintln!("{}", stderr.trim());
-    }
-
-    timer.track(
-        &format!("rubocop {}", args.join(" ")),
-        &format!("rtk rubocop {}", args.join(" ")),
-        &raw,
-        &filtered,
-    );
-
-    if !output.status.success() {
-        std::process::exit(exit_code);
-    }
-
-    Ok(())
+    runner::run_filtered(
+        cmd,
+        "rubocop",
+        &args.join(" "),
+        move |stdout| {
+            if has_format || is_autocorrect {
+                filter_rubocop_text(stdout)
+            } else {
+                filter_rubocop_json(stdout)
+            }
+        },
+        runner::RunOptions::stdout_only().tee("rubocop"),
+    )
 }
 
 // ── JSON filtering ───────────────────────────────────────────────────────────
diff --git a/src/cmds/rust/cargo_cmd.rs b/src/cmds/rust/cargo_cmd.rs
index 438cdf6779..917e986f4b 100644
--- a/src/cmds/rust/cargo_cmd.rs
+++ b/src/cmds/rust/cargo_cmd.rs
@@ -1,5 +1,6 @@
 //! Filters cargo output — build errors, test results, clippy warnings.
 
+use crate::core::runner;
 use crate::core::tracking;
 use crate::core::utils::{resolved_command, truncate};
 use anyhow::{Context, Result};
@@ -17,7 +18,7 @@ pub enum CargoCommand {
     Nextest,
 }
 
-pub fn run(cmd: CargoCommand, args: &[String], verbose: u8) -> Result<()> {
+pub fn run(cmd: CargoCommand, args: &[String], verbose: u8) -> Result<i32> {
     match cmd {
         CargoCommand::Build => run_build(args, verbose),
         CargoCommand::Test => run_test(args, verbose),
@@ -67,13 +68,17 @@ fn restore_double_dash_with_raw(args: &[String], raw_args: &[String]) -> Vec<Str
     result
 }
 
-/// Generic cargo command runner with filtering
-fn run_cargo_filtered<F>(subcommand: &str, args: &[String], verbose: u8, filter_fn: F) -> Result<()>
+/// Generic cargo command runner with filtering.
+/// Builds the Command with restored `--` separator, then delegates to shared runner.
+fn run_cargo_filtered<F>(
+    subcommand: &str,
+    args: &[String],
+    verbose: u8,
+    filter_fn: F,
+) -> Result<i32>
 where
     F: Fn(&str) -> String,
 {
-    let timer = tracking::TimedExecution::start();
-
     let mut cmd = resolved_command("cargo");
     cmd.arg(subcommand);
 
@@ -86,62 +91,36 @@ where
         eprintln!("Running: cargo {} {}", subcommand, restored_args.join(" "));
     }
 
-    let output = cmd
-        .output()
-        .with_context(|| format!("Failed to run cargo {}", subcommand))?;
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    let raw = format!("{}\n{}", stdout, stderr);
-
-    let exit_code = output
-        .status
-        .code()
-        .unwrap_or(if output.status.success() { 0 } else { 1 });
-    let filtered = filter_fn(&raw);
-
-    if let Some(hint) =
-        crate::core::tee::tee_and_hint(&raw, &format!("cargo_{}", subcommand), exit_code)
-    {
-        println!("{}\n{}", filtered, hint);
-    } else {
-        println!("{}", filtered);
-    }
-
-    timer.track(
-        &format!("cargo {} {}", subcommand, restored_args.join(" ")),
-        &format!("rtk cargo {} {}", subcommand, restored_args.join(" ")),
-        &raw,
-        &filtered,
-    );
-
-    if !output.status.success() {
-        std::process::exit(exit_code);
-    }
-
-    Ok(())
+    runner::run_filtered(
+        cmd,
+        &format!("cargo {}", subcommand),
+        &restored_args.join(" "),
+        filter_fn,
+        runner::RunOptions::with_tee(&format!("cargo_{}", subcommand)),
+    )
 }
 
-fn run_build(args: &[String], verbose: u8) -> Result<()> {
+fn run_build(args: &[String], verbose: u8) -> Result<i32> {
     run_cargo_filtered("build", args, verbose, filter_cargo_build)
 }
 
-fn run_test(args: &[String], verbose: u8) -> Result<()> {
+fn run_test(args: &[String], verbose: u8) -> Result<i32> {
     run_cargo_filtered("test", args, verbose, filter_cargo_test)
 }
 
-fn run_clippy(args: &[String], verbose: u8) -> Result<()> {
+fn run_clippy(args: &[String], verbose: u8) -> Result<i32> {
     run_cargo_filtered("clippy", args, verbose, filter_cargo_clippy)
 }
 
-fn run_check(args: &[String], verbose: u8) -> Result<()> {
+fn run_check(args: &[String], verbose: u8) -> Result<i32> {
     run_cargo_filtered("check", args, verbose, filter_cargo_build)
 }
 
-fn run_install(args: &[String], verbose: u8) -> Result<()> {
+fn run_install(args: &[String], verbose: u8) -> Result<i32> {
     run_cargo_filtered("install", args, verbose, filter_cargo_install)
 }
 
-fn run_nextest(args: &[String], verbose: u8) -> Result<()> {
+fn run_nextest(args: &[String], verbose: u8) -> Result<i32> {
     run_cargo_filtered("nextest", args, verbose, filter_cargo_nextest)
 }
 
@@ -994,7 +973,7 @@ fn filter_cargo_clippy(output: &str) -> String {
 }
 
 /// Runs an unsupported cargo subcommand by passing it through directly
-pub fn run_passthrough(args: &[OsString], verbose: u8) -> Result<()> {
+pub fn run_passthrough(args: &[OsString], verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     if verbose > 0 {
@@ -1011,10 +990,7 @@ pub fn run_passthrough(args: &[OsString], verbose: u8) -> Result<()> {
         &format!("rtk cargo {} (passthrough)", args_str),
     );
 
-    if !status.success() {
-        std::process::exit(status.code().unwrap_or(1));
-    }
-    Ok(())
+    Ok(crate::core::utils::exit_code_from_status(&status, "cargo"))
 }
 
 #[cfg(test)]
diff --git a/src/cmds/rust/runner.rs b/src/cmds/rust/runner.rs
index 8c3f352706..101dd31c4d 100644
--- a/src/cmds/rust/runner.rs
+++ b/src/cmds/rust/runner.rs
@@ -6,7 +6,7 @@ use regex::Regex;
 use std::process::{Command, Stdio};
 
 /// Run a command and filter output to show only errors/warnings
-pub fn run_err(command: &str, verbose: u8) -> Result<()> {
+pub fn run_err(command: &str, verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     if verbose > 0 {
@@ -51,21 +51,18 @@ pub fn run_err(command: &str, verbose: u8) -> Result<()> {
         rtk.push_str(&filtered);
     }
 
-    let exit_code = output
-        .status
-        .code()
-        .unwrap_or(if output.status.success() { 0 } else { 1 });
+    let exit_code = crate::core::utils::exit_code_from_output(&output, "err");
     if let Some(hint) = crate::core::tee::tee_and_hint(&raw, "err", exit_code) {
         println!("{}\n{}", rtk, hint);
     } else {
         println!("{}", rtk);
     }
     timer.track(command, "rtk run-err", &raw, &rtk);
-    Ok(())
+    Ok(exit_code)
 }
 
 /// Run tests and show only failures
-pub fn run_test(command: &str, verbose: u8) -> Result<()> {
+pub fn run_test(command: &str, verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     if verbose > 0 {
@@ -91,10 +88,7 @@ pub fn run_test(command: &str, verbose: u8) -> Result<()> {
     let stderr = String::from_utf8_lossy(&output.stderr);
     let raw = format!("{}\n{}", stdout, stderr);
 
-    let exit_code = output
-        .status
-        .code()
-        .unwrap_or(if output.status.success() { 0 } else { 1 });
+    let exit_code = crate::core::utils::exit_code_from_output(&output, "test");
     let summary = extract_test_summary(&raw, command);
     if let Some(hint) = crate::core::tee::tee_and_hint(&raw, "test", exit_code) {
         println!("{}\n{}", summary, hint);
@@ -102,7 +96,7 @@ pub fn run_test(command: &str, verbose: u8) -> Result<()> {
         println!("{}", summary);
     }
     timer.track(command, "rtk run-test", &raw, &summary);
-    Ok(())
+    Ok(exit_code)
 }
 
 fn filter_errors(output: &str) -> String {
diff --git a/src/cmds/system/format_cmd.rs b/src/cmds/system/format_cmd.rs
index 4c4a31f4b6..6398b353e9 100644
--- a/src/cmds/system/format_cmd.rs
+++ b/src/cmds/system/format_cmd.rs
@@ -1,7 +1,7 @@
 //! Runs code formatters (Prettier, Ruff) and shows only files that changed.
 
 use crate::core::tracking;
-use crate::core::utils::{package_manager_exec, resolved_command};
+use crate::core::utils::{exit_code_from_output, package_manager_exec, resolved_command};
 use crate::prettier_cmd;
 use crate::ruff_cmd;
 use anyhow::{Context, Result};
@@ -52,7 +52,7 @@ fn detect_formatter_in_dir(args: &[String], dir: &Path) -> String {
     "ruff".to_string()
 }
 
-pub fn run(args: &[String], verbose: u8) -> Result<()> {
+pub fn run(args: &[String], verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     // Detect formatter
@@ -137,12 +137,7 @@ pub fn run(args: &[String], verbose: u8) -> Result<()> {
         &filtered,
     );
 
-    // Preserve exit code for CI/CD
-    if !output.status.success() {
-        std::process::exit(output.status.code().unwrap_or(1));
-    }
-
-    Ok(())
+    Ok(exit_code_from_output(&output, "format"))
 }
 
 /// Filter black output - show files that need formatting
diff --git a/src/cmds/system/grep_cmd.rs b/src/cmds/system/grep_cmd.rs
index 4550e87747..e9738fc1d6 100644
--- a/src/cmds/system/grep_cmd.rs
+++ b/src/cmds/system/grep_cmd.rs
@@ -2,7 +2,7 @@
 
 use crate::core::config;
 use crate::core::tracking;
-use crate::core::utils::resolved_command;
+use crate::core::utils::{exit_code_from_output, resolved_command};
 use anyhow::{Context, Result};
 use regex::Regex;
 use std::collections::HashMap;
@@ -17,7 +17,7 @@ pub fn run(
     file_type: Option<&str>,
     extra_args: &[String],
     verbose: u8,
-) -> Result<()> {
+) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     if verbose > 0 {
@@ -52,7 +52,7 @@ pub fn run(
         .context("grep/rg failed")?;
 
     let stdout = String::from_utf8_lossy(&output.stdout);
-    let exit_code = output.status.code().unwrap_or(1);
+    let exit_code = exit_code_from_output(&output, "grep");
 
     let raw_output = stdout.to_string();
 
@@ -72,10 +72,7 @@ pub fn run(
             &raw_output,
             &msg,
         );
-        if exit_code != 0 {
-            std::process::exit(exit_code);
-        }
-        return Ok(());
+        return Ok(exit_code);
     }
 
     let mut by_file: HashMap<String, Vec<(usize, String)>> = HashMap::new();
@@ -148,11 +145,7 @@ pub fn run(
         &rtk_output,
     );
 
-    if exit_code != 0 {
-        std::process::exit(exit_code);
-    }
-
-    Ok(())
+    Ok(exit_code)
 }
 
 fn clean_line(line: &str, max_len: usize, context_re: Option<&Regex>, pattern: &str) -> String {
diff --git a/src/cmds/system/ls.rs b/src/cmds/system/ls.rs
index 5a7badb20a..123e89684e 100644
--- a/src/cmds/system/ls.rs
+++ b/src/cmds/system/ls.rs
@@ -1,7 +1,7 @@
 //! Filters directory listings into a compact tree format.
 
 use crate::core::tracking;
-use crate::core::utils::resolved_command;
+use crate::core::utils::{exit_code_from_output, resolved_command};
 use anyhow::{Context, Result};
 use std::io::IsTerminal;
 
@@ -33,7 +33,7 @@ const NOISE_DIRS: &[&str] = &[
     ".eggs",
 ];
 
-pub fn run(args: &[String], verbose: u8) -> Result<()> {
+pub fn run(args: &[String], verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     // Separate flags from paths
@@ -88,7 +88,7 @@ pub fn run(args: &[String], verbose: u8) -> Result<()> {
     if !output.status.success() {
         let stderr = String::from_utf8_lossy(&output.stderr);
         eprint!("{}", stderr);
-        std::process::exit(output.status.code().unwrap_or(1));
+        return Ok(exit_code_from_output(&output, "ls"));
     }
 
     let raw = String::from_utf8_lossy(&output.stdout).to_string();
@@ -128,7 +128,7 @@ pub fn run(args: &[String], verbose: u8) -> Result<()> {
         &filtered,
     );
 
-    Ok(())
+    Ok(0)
 }
 
 /// Format bytes into human-readable size
diff --git a/src/cmds/system/tree.rs b/src/cmds/system/tree.rs
index 57706a6a22..5a38177146 100644
--- a/src/cmds/system/tree.rs
+++ b/src/cmds/system/tree.rs
@@ -7,7 +7,7 @@
 //! unless -a flag is present (respecting user intent).
 
 use crate::core::tracking;
-use crate::core::utils::{resolved_command, tool_exists};
+use crate::core::utils::{exit_code_from_output, resolved_command, tool_exists};
 use anyhow::{Context, Result};
 
 /// Noise directories commonly excluded from LLM context
@@ -40,7 +40,7 @@ const NOISE_DIRS: &[&str] = &[
     ".eggs",
 ];
 
-pub fn run(args: &[String], verbose: u8) -> Result<()> {
+pub fn run(args: &[String], verbose: u8) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
     // Check if tree is installed
@@ -76,7 +76,7 @@ pub fn run(args: &[String], verbose: u8) -> Result<()> {
     if !output.status.success() {
         let stderr = String::from_utf8_lossy(&output.stderr);
         eprint!("{}", stderr);
-        std::process::exit(output.status.code().unwrap_or(1));
+        return Ok(exit_code_from_output(&output, "tree"));
     }
 
     let raw = String::from_utf8_lossy(&output.stdout).to_string();
@@ -98,7 +98,7 @@ pub fn run(args: &[String], verbose: u8) -> Result<()> {
     print!("{}", filtered);
     timer.track("tree", "rtk tree", &raw, &filtered);
 
-    Ok(())
+    Ok(0)
 }
 
 fn filter_tree_output(raw: &str) -> String {
diff --git a/src/cmds/system/wc_cmd.rs b/src/cmds/system/wc_cmd.rs
index 14e4f69f1d..8d95161f98 100644
--- a/src/cmds/system/wc_cmd.rs
+++ b/src/cmds/system/wc_cmd.rs
@@ -6,13 +6,10 @@
 /// - `wc -w file.py`  → `96`
 /// - `wc -c file.py`  → `978`
 /// - `wc -l *.py`     → table with common path prefix stripped
-use crate::core::tracking;
 use crate::core::utils::resolved_command;
-use anyhow::{Context, Result};
-
-pub fn run(args: &[String], verbose: u8) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
+use anyhow::Result;
 
+pub fn run(args: &[String], verbose: u8) -> Result<i32> {
     let mut cmd = resolved_command("wc");
     for arg in args {
         cmd.arg(arg);
@@ -22,35 +19,14 @@ pub fn run(args: &[String], verbose: u8) -> Result<()> {
         eprintln!("Running: wc {}", args.join(" "));
     }
 
-    let output = cmd.output().context("Failed to run wc")?;
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let stderr = String::from_utf8_lossy(&output.stderr);
-
-    if !output.status.success() {
-        let msg = if stderr.trim().is_empty() {
-            stdout.trim().to_string()
-        } else {
-            stderr.trim().to_string()
-        };
-        eprintln!("FAILED: wc {}", msg);
-        std::process::exit(output.status.code().unwrap_or(1));
-    }
-
-    let raw = stdout.to_string();
-
-    // Detect which columns the user requested
     let mode = detect_mode(args);
-    let filtered = filter_wc_output(&raw, &mode);
-    println!("{}", filtered);
-
-    timer.track(
-        &format!("wc {}", args.join(" ")),
-        &format!("rtk wc {}", args.join(" ")),
-        &raw,
-        &filtered,
-    );
-
-    Ok(())
+    crate::core::runner::run_filtered(
+        cmd,
+        "wc",
+        &args.join(" "),
+        |stdout| filter_wc_output(stdout, &mode),
+        crate::core::runner::RunOptions::stdout_only(),
+    )
 }
 
 /// Which columns the user requested
diff --git a/src/core/README.md b/src/core/README.md
index 29befe0c39..59e70bbe4f 100644
--- a/src/core/README.md
+++ b/src/core/README.md
@@ -11,7 +11,7 @@ Owns: configuration loading, token tracking persistence, TOML filter engine, tee
 Does **not** own: command-specific filtering logic (that's `cmds/`), hook lifecycle management (that's `src/hooks/`), or analytics dashboards (that's `analytics/`).
 
 ## Purpose
-Core infrastructure shared by all RTK command modules. These are the foundational building blocks that every filter, tracker, and command handler depends on. This module group has no inward dependencies — it is a leaf in the dependency graph, ensuring clean layering across the codebase.
+Core infrastructure shared by all RTK command modules. Every filter, tracker, and command handler depends on these modules. No inward dependencies — leaf in the dependency graph (no circular imports possible).
 
 ## TOML Filter Pipeline
 
@@ -119,11 +119,5 @@ Consumers must call `timer.track()` on **all** code paths — success, failure,
 
 Consumers that parse structured output (JSON, NDJSON, state machines) should call `tee::tee_and_hint()` to save raw output for LLM recovery on failure. Tee must be called before `std::process::exit()`.
 
-### Gaps (to be fixed)
-
-- `ls.rs`, `tree.rs` — exit before `track()` on error path (lost metrics)
-- `container.rs` — inconsistent tracking across subcommands
-- Many command modules still missing tee integration — see `src/cmds/README.md` for the full list
-
 ## Adding New Functionality
 Place new infrastructure code here if it meets **all** of these criteria: (1) it has no dependencies on command modules or hooks, (2) it is used by two or more other modules, and (3) it provides a general-purpose utility rather than command-specific logic. Follow the existing pattern of lazy-initialized resources (`lazy_static!` for regex, on-demand config loading) to preserve the <10ms startup target. Add `#[cfg(test)] mod tests` with unit tests in the same file.
diff --git a/src/core/filter.rs b/src/core/filter.rs
index 1fc5a23fbb..de74368c7f 100644
--- a/src/core/filter.rs
+++ b/src/core/filter.rs
@@ -36,8 +36,6 @@ impl std::fmt::Display for FilterLevel {
 
 pub trait FilterStrategy {
     fn filter(&self, content: &str, lang: &Language) -> String;
-    #[allow(dead_code)]
-    fn name(&self) -> &'static str;
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -153,10 +151,6 @@ impl FilterStrategy for NoFilter {
     fn filter(&self, content: &str, _lang: &Language) -> String {
         content.to_string()
     }
-
-    fn name(&self) -> &'static str {
-        "none"
-    }
 }
 
 pub struct MinimalFilter;
@@ -234,10 +228,6 @@ impl FilterStrategy for MinimalFilter {
         let result = MULTIPLE_BLANK_LINES.replace_all(&result, "\n\n");
         result.trim().to_string()
     }
-
-    fn name(&self) -> &'static str {
-        "minimal"
-    }
 }
 
 pub struct AggressiveFilter;
@@ -320,10 +310,6 @@ impl FilterStrategy for AggressiveFilter {
 
         result.trim().to_string()
     }
-
-    fn name(&self) -> &'static str {
-        "aggressive"
-    }
 }
 
 pub fn get_filter(level: FilterLevel) -> Box<dyn FilterStrategy> {
diff --git a/src/core/mod.rs b/src/core/mod.rs
index 0a490aad32..b3a5eeb33f 100644
--- a/src/core/mod.rs
+++ b/src/core/mod.rs
@@ -3,6 +3,7 @@
 pub mod config;
 pub mod display_helpers;
 pub mod filter;
+pub mod runner;
 pub mod tee;
 pub mod telemetry;
 pub mod toml_filter;
diff --git a/src/core/runner.rs b/src/core/runner.rs
new file mode 100644
index 0000000000..86cd201535
--- /dev/null
+++ b/src/core/runner.rs
@@ -0,0 +1,91 @@
+//! Shared command execution skeleton for filter modules.
+
+use anyhow::{Context, Result};
+use std::process::Command;
+
+use crate::core::tracking;
+use crate::core::utils::exit_code_from_output;
+
+pub fn print_with_hint(filtered: &str, raw: &str, tee_label: &str, exit_code: i32) {
+    if let Some(hint) = crate::core::tee::tee_and_hint(raw, tee_label, exit_code) {
+        println!("{}\n{}", filtered, hint);
+    } else {
+        println!("{}", filtered);
+    }
+}
+
+#[derive(Default)]
+pub struct RunOptions<'a> {
+    pub tee_label: Option<&'a str>,
+    pub filter_stdout_only: bool,
+}
+
+impl<'a> RunOptions<'a> {
+    pub fn with_tee(label: &'a str) -> Self {
+        Self {
+            tee_label: Some(label),
+            ..Default::default()
+        }
+    }
+
+    pub fn stdout_only() -> Self {
+        Self {
+            filter_stdout_only: true,
+            ..Default::default()
+        }
+    }
+
+    pub fn tee(mut self, label: &'a str) -> Self {
+        self.tee_label = Some(label);
+        self
+    }
+}
+
+pub fn run_filtered<F>(
+    mut cmd: Command,
+    tool_name: &str,
+    args_display: &str,
+    filter_fn: F,
+    opts: RunOptions<'_>,
+) -> Result<i32>
+where
+    F: Fn(&str) -> String,
+{
+    let timer = tracking::TimedExecution::start();
+
+    let output = cmd
+        .output()
+        .with_context(|| format!("Failed to run {}", tool_name))?;
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    let raw = format!("{}\n{}", stdout, stderr);
+
+    let text_to_filter = if opts.filter_stdout_only {
+        &stdout
+    } else {
+        raw.as_str()
+    };
+    let filtered = filter_fn(text_to_filter);
+
+    let exit_code = exit_code_from_output(&output, tool_name);
+
+    if let Some(label) = opts.tee_label {
+        print_with_hint(&filtered, &raw, label, exit_code);
+    } else {
+        println!("{}", filtered);
+    }
+
+    if opts.filter_stdout_only && !stderr.trim().is_empty() {
+        eprintln!("{}", stderr.trim());
+    }
+
+    timer.track(
+        &format!("{} {}", tool_name, args_display),
+        &format!("rtk {} {}", tool_name, args_display),
+        &raw,
+        &filtered,
+    );
+
+    Ok(exit_code)
+}
diff --git a/src/core/tracking.rs b/src/core/tracking.rs
index 1cba65fd14..233f0e7c8a 100644
--- a/src/core/tracking.rs
+++ b/src/core/tracking.rs
@@ -1161,42 +1161,6 @@ pub fn args_display(args: &[OsString]) -> String {
         .join(" ")
 }
 
-/// Track a command execution (legacy function, use [`TimedExecution`] for new code).
-///
-/// # Deprecation Notice
-///
-/// This function is deprecated. Use [`TimedExecution`] instead for automatic
-/// timing and cleaner API.
-///
-/// # Arguments
-///
-/// - `original_cmd`: Standard command (e.g., "ls -la")
-/// - `rtk_cmd`: RTK command used (e.g., "rtk ls")
-/// - `input`: Standard command output (for token estimation)
-/// - `output`: RTK command output (for token estimation)
-///
-/// # Migration
-///
-/// ```no_run
-/// # use rtk::tracking::{track, TimedExecution};
-/// // Old (deprecated)
-/// track("ls -la", "rtk ls", "input", "output");
-///
-/// // New (preferred)
-/// let timer = TimedExecution::start();
-/// timer.track("ls -la", "rtk ls", "input", "output");
-/// ```
-#[deprecated(note = "Use TimedExecution instead")]
-#[allow(dead_code)]
-pub fn track(original_cmd: &str, rtk_cmd: &str, input: &str, output: &str) {
-    let input_tokens = estimate_tokens(input);
-    let output_tokens = estimate_tokens(output);
-
-    if let Ok(tracker) = Tracker::new() {
-        let _ = tracker.record(original_cmd, rtk_cmd, input_tokens, output_tokens, 0);
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/src/core/utils.rs b/src/core/utils.rs
index c1882fa81b..504a3fcf3b 100644
--- a/src/core/utils.rs
+++ b/src/core/utils.rs
@@ -60,27 +60,6 @@ pub fn strip_ansi(text: &str) -> String {
 ///
 /// # Returns
 /// `(stdout: String, stderr: String, exit_code: i32)`
-///
-/// # Examples
-/// ```no_run
-/// use rtk::utils::execute_command;
-/// let (stdout, stderr, code) = execute_command("echo", &["test"]).unwrap();
-/// assert_eq!(code, 0);
-/// ```
-#[allow(dead_code)]
-pub fn execute_command(cmd: &str, args: &[&str]) -> Result<(String, String, i32)> {
-    let output = resolved_command(cmd)
-        .args(args)
-        .output()
-        .context(format!("Failed to execute {}", cmd))?;
-
-    let stdout = String::from_utf8_lossy(&output.stdout).to_string();
-    let stderr = String::from_utf8_lossy(&output.stderr).to_string();
-    let exit_code = output.status.code().unwrap_or(-1);
-
-    Ok((stdout, stderr, exit_code))
-}
-
 /// Formats a token count with K/M suffixes for readability.
 ///
 /// # Arguments
@@ -228,6 +207,27 @@ pub fn exit_code_from_output(output: &std::process::Output, label: &str) -> i32
     }
 }
 
+/// Extract exit code from an ExitStatus (for `.status()` calls, not `.output()`).
+/// Returns the actual exit code, or `128 + signal` per Unix convention when
+/// terminated by a signal. Falls back to 1 on non-Unix platforms.
+pub fn exit_code_from_status(status: &std::process::ExitStatus, label: &str) -> i32 {
+    match status.code() {
+        Some(code) => code,
+        None => {
+            #[cfg(unix)]
+            {
+                use std::os::unix::process::ExitStatusExt;
+                if let Some(sig) = status.signal() {
+                    eprintln!("[rtk] {}: process terminated by signal {}", label, sig);
+                    return 128 + sig;
+                }
+            }
+            eprintln!("[rtk] {}: process terminated by signal", label);
+            1
+        }
+    }
+}
+
 /// Return the last `n` lines of output with a label, for use as a fallback
 /// when filter parsing fails. Logs a diagnostic to stderr.
 pub fn fallback_tail(output: &str, label: &str, n: usize) -> String {
@@ -421,21 +421,6 @@ mod tests {
         assert_eq!(strip_ansi(input), "Green normal Red");
     }
 
-    #[test]
-    fn test_execute_command_success() {
-        let result = execute_command("echo", &["test"]);
-        assert!(result.is_ok());
-        let (stdout, _, code) = result.unwrap();
-        assert_eq!(code, 0);
-        assert!(stdout.contains("test"));
-    }
-
-    #[test]
-    fn test_execute_command_failure() {
-        let result = execute_command("nonexistent_command_xyz_12345", &[]);
-        assert!(result.is_err());
-    }
-
     #[test]
     fn test_format_tokens_millions() {
         assert_eq!(format_tokens(1_234_567), "1.2M");
diff --git a/src/hooks/README.md b/src/hooks/README.md
index 65e05f03dc..216f49559c 100644
--- a/src/hooks/README.md
+++ b/src/hooks/README.md
@@ -65,9 +65,5 @@ All file operations use atomic writes (tempfile + rename) to prevent corruption
 
 Hook processors in `hook_cmd.rs` must return `Ok(())` on every path — success, no-match, parse error, and unexpected input. Returning `Err` propagates to `main()` and exits non-zero, which blocks the agent's command from executing. This violates the non-blocking guarantee documented in `hooks/README.md`.
 
-### Gaps (to be fixed)
-
-- `hook_cmd.rs::run_gemini()` — uses `.context()?` on JSON parse, which returns `Err` on malformed input
-
 ## Adding New Functionality
 To add support for a new AI coding agent: (1) add the hook installation logic to `init.rs` following the existing agent patterns, (2) if the agent requires a custom hook protocol (like Gemini's `BeforeTool`), add a processor function in `hook_cmd.rs`, (3) add the agent's hook file path to `hook_check.rs` for validation, and (4) update `integrity.rs` with the expected hash for the new hook file. Test by running `rtk init` in a fresh environment and verifying the hook rewrites commands correctly in the target agent.
diff --git a/src/hooks/trust.rs b/src/hooks/trust.rs
index 5bf6965ed6..7302504d2b 100644
--- a/src/hooks/trust.rs
+++ b/src/hooks/trust.rs
@@ -139,14 +139,6 @@ pub fn check_trust(filter_path: &Path) -> Result<TrustStatus> {
     }
 }
 
-/// Store current SHA-256 hash as trusted (computes hash from file).
-#[allow(dead_code)]
-pub fn trust_filter(filter_path: &Path) -> Result<()> {
-    let hash = integrity::compute_hash(filter_path)
-        .with_context(|| format!("Failed to hash: {}", filter_path.display()))?;
-    trust_filter_with_hash(filter_path, &hash)
-}
-
 /// Store a pre-computed SHA-256 hash as trusted (avoids TOCTOU re-read).
 pub fn trust_filter_with_hash(filter_path: &Path, hash: &str) -> Result<()> {
     let key = canonical_key(filter_path)?;
diff --git a/src/main.rs b/src/main.rs
index e43f92676d..15480c4fad 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1050,7 +1050,7 @@ const RTK_META_COMMANDS: &[&str] = &[
     "rewrite",
 ];
 
-fn run_fallback(parse_error: clap::Error) -> Result<()> {
+fn run_fallback(parse_error: clap::Error) -> Result<i32> {
     let args: Vec<String> = std::env::args().skip(1).collect();
 
     // No args → show Clap's error (user ran just "rtk" with bad syntax)
@@ -1099,15 +1099,12 @@ fn run_fallback(parse_error: clap::Error) -> Result<()> {
 
         match result {
             Ok(output) => {
+                let exit_code = core::utils::exit_code_from_output(&output, &raw_command);
                 let stdout_raw = String::from_utf8_lossy(&output.stdout);
 
                 // Tee raw output BEFORE filtering on failure — lets LLM re-read if needed
                 let tee_hint = if !output.status.success() {
-                    core::tee::tee_and_hint(
-                        &stdout_raw,
-                        &raw_command,
-                        output.status.code().unwrap_or(1),
-                    )
+                    core::tee::tee_and_hint(&stdout_raw, &raw_command, exit_code)
                 } else {
                     None
                 };
@@ -1126,15 +1123,13 @@ fn run_fallback(parse_error: clap::Error) -> Result<()> {
                 );
                 core::tracking::record_parse_failure_silent(&raw_command, &error_message, true);
 
-                if !output.status.success() {
-                    std::process::exit(output.status.code().unwrap_or(1));
-                }
+                Ok(exit_code)
             }
             Err(e) => {
                 // Command not found — same behaviour as no-TOML path
                 core::tracking::record_parse_failure_silent(&raw_command, &error_message, false);
                 eprintln!("[rtk: {}]", e);
-                std::process::exit(127);
+                Ok(127)
             }
         }
     } else {
@@ -1152,20 +1147,16 @@ fn run_fallback(parse_error: clap::Error) -> Result<()> {
 
                 core::tracking::record_parse_failure_silent(&raw_command, &error_message, true);
 
-                if !s.success() {
-                    std::process::exit(s.code().unwrap_or(1));
-                }
+                Ok(core::utils::exit_code_from_status(&s, &raw_command))
             }
             Err(e) => {
                 core::tracking::record_parse_failure_silent(&raw_command, &error_message, false);
                 // Command not found or other OS error — single message, no duplicate Clap error
                 eprintln!("[rtk: {}]", e);
-                std::process::exit(127);
+                Ok(127)
             }
         }
     }
-
-    Ok(())
 }
 
 #[derive(Subcommand)]
@@ -1232,7 +1223,18 @@ fn shell_split(input: &str) -> Vec<String> {
     tokens
 }
 
-fn main() -> Result<()> {
+fn main() {
+    let code = match run_cli() {
+        Ok(code) => code,
+        Err(e) => {
+            eprintln!("rtk: {:#}", e);
+            1
+        }
+    };
+    std::process::exit(code);
+}
+
+fn run_cli() -> Result<i32> {
     // Fire-and-forget telemetry ping (1/day, non-blocking)
     core::telemetry::maybe_ping();
 
@@ -1259,14 +1261,10 @@ fn main() -> Result<()> {
         hooks::integrity::runtime_check()?;
     }
 
-    match cli.command {
-        Commands::Ls { args } => {
-            ls::run(&args, cli.verbose)?;
-        }
+    let code = match cli.command {
+        Commands::Ls { args } => ls::run(&args, cli.verbose)?,
 
-        Commands::Tree { args } => {
-            tree::run(&args, cli.verbose)?;
-        }
+        Commands::Tree { args } => tree::run(&args, cli.verbose)?,
 
         Commands::Read {
             file,
@@ -1287,6 +1285,7 @@ fn main() -> Result<()> {
                     cli.verbose,
                 )?;
             }
+            0
         }
 
         Commands::Smart {
@@ -1295,6 +1294,7 @@ fn main() -> Result<()> {
             force_download,
         } => {
             local_llm::run(&file, &model, force_download, cli.verbose)?;
+            0
         }
 
         Commands::Git {
@@ -1340,156 +1340,124 @@ fn main() -> Result<()> {
             }
 
             match command {
-                GitCommands::Diff { args } => {
-                    git::run(
-                        git::GitCommand::Diff,
-                        &args,
-                        None,
-                        cli.verbose,
-                        &global_args,
-                    )?;
-                }
+                GitCommands::Diff { args } => git::run(
+                    git::GitCommand::Diff,
+                    &args,
+                    None,
+                    cli.verbose,
+                    &global_args,
+                )?,
                 GitCommands::Log { args } => {
-                    git::run(git::GitCommand::Log, &args, None, cli.verbose, &global_args)?;
-                }
-                GitCommands::Status { args } => {
-                    git::run(
-                        git::GitCommand::Status,
-                        &args,
-                        None,
-                        cli.verbose,
-                        &global_args,
-                    )?;
-                }
-                GitCommands::Show { args } => {
-                    git::run(
-                        git::GitCommand::Show,
-                        &args,
-                        None,
-                        cli.verbose,
-                        &global_args,
-                    )?;
+                    git::run(git::GitCommand::Log, &args, None, cli.verbose, &global_args)?
                 }
+                GitCommands::Status { args } => git::run(
+                    git::GitCommand::Status,
+                    &args,
+                    None,
+                    cli.verbose,
+                    &global_args,
+                )?,
+                GitCommands::Show { args } => git::run(
+                    git::GitCommand::Show,
+                    &args,
+                    None,
+                    cli.verbose,
+                    &global_args,
+                )?,
                 GitCommands::Add { args } => {
-                    git::run(git::GitCommand::Add, &args, None, cli.verbose, &global_args)?;
-                }
-                GitCommands::Commit { args } => {
-                    git::run(
-                        git::GitCommand::Commit,
-                        &args,
-                        None,
-                        cli.verbose,
-                        &global_args,
-                    )?;
-                }
-                GitCommands::Push { args } => {
-                    git::run(
-                        git::GitCommand::Push,
-                        &args,
-                        None,
-                        cli.verbose,
-                        &global_args,
-                    )?;
-                }
-                GitCommands::Pull { args } => {
-                    git::run(
-                        git::GitCommand::Pull,
-                        &args,
-                        None,
-                        cli.verbose,
-                        &global_args,
-                    )?;
-                }
-                GitCommands::Branch { args } => {
-                    git::run(
-                        git::GitCommand::Branch,
-                        &args,
-                        None,
-                        cli.verbose,
-                        &global_args,
-                    )?;
-                }
-                GitCommands::Fetch { args } => {
-                    git::run(
-                        git::GitCommand::Fetch,
-                        &args,
-                        None,
-                        cli.verbose,
-                        &global_args,
-                    )?;
-                }
-                GitCommands::Stash { subcommand, args } => {
-                    git::run(
-                        git::GitCommand::Stash { subcommand },
-                        &args,
-                        None,
-                        cli.verbose,
-                        &global_args,
-                    )?;
-                }
-                GitCommands::Worktree { args } => {
-                    git::run(
-                        git::GitCommand::Worktree,
-                        &args,
-                        None,
-                        cli.verbose,
-                        &global_args,
-                    )?;
-                }
-                GitCommands::Other(args) => {
-                    git::run_passthrough(&args, &global_args, cli.verbose)?;
+                    git::run(git::GitCommand::Add, &args, None, cli.verbose, &global_args)?
                 }
+                GitCommands::Commit { args } => git::run(
+                    git::GitCommand::Commit,
+                    &args,
+                    None,
+                    cli.verbose,
+                    &global_args,
+                )?,
+                GitCommands::Push { args } => git::run(
+                    git::GitCommand::Push,
+                    &args,
+                    None,
+                    cli.verbose,
+                    &global_args,
+                )?,
+                GitCommands::Pull { args } => git::run(
+                    git::GitCommand::Pull,
+                    &args,
+                    None,
+                    cli.verbose,
+                    &global_args,
+                )?,
+                GitCommands::Branch { args } => git::run(
+                    git::GitCommand::Branch,
+                    &args,
+                    None,
+                    cli.verbose,
+                    &global_args,
+                )?,
+                GitCommands::Fetch { args } => git::run(
+                    git::GitCommand::Fetch,
+                    &args,
+                    None,
+                    cli.verbose,
+                    &global_args,
+                )?,
+                GitCommands::Stash { subcommand, args } => git::run(
+                    git::GitCommand::Stash { subcommand },
+                    &args,
+                    None,
+                    cli.verbose,
+                    &global_args,
+                )?,
+                GitCommands::Worktree { args } => git::run(
+                    git::GitCommand::Worktree,
+                    &args,
+                    None,
+                    cli.verbose,
+                    &global_args,
+                )?,
+                GitCommands::Other(args) => git::run_passthrough(&args, &global_args, cli.verbose)?,
             }
         }
 
         Commands::Gh { subcommand, args } => {
-            gh_cmd::run(&subcommand, &args, cli.verbose, cli.ultra_compact)?;
+            gh_cmd::run(&subcommand, &args, cli.verbose, cli.ultra_compact)?
         }
 
-        Commands::Aws { subcommand, args } => {
-            aws_cmd::run(&subcommand, &args, cli.verbose)?;
-        }
+        Commands::Aws { subcommand, args } => aws_cmd::run(&subcommand, &args, cli.verbose)?,
 
-        Commands::Psql { args } => {
-            psql_cmd::run(&args, cli.verbose)?;
-        }
+        Commands::Psql { args } => psql_cmd::run(&args, cli.verbose)?,
 
         Commands::Pnpm { command } => match command {
             PnpmCommands::List { depth, args } => {
-                pnpm_cmd::run(pnpm_cmd::PnpmCommand::List { depth }, &args, cli.verbose)?;
+                pnpm_cmd::run(pnpm_cmd::PnpmCommand::List { depth }, &args, cli.verbose)?
             }
             PnpmCommands::Outdated { args } => {
-                pnpm_cmd::run(pnpm_cmd::PnpmCommand::Outdated, &args, cli.verbose)?;
-            }
-            PnpmCommands::Install { packages, args } => {
-                pnpm_cmd::run(
-                    pnpm_cmd::PnpmCommand::Install { packages },
-                    &args,
-                    cli.verbose,
-                )?;
+                pnpm_cmd::run(pnpm_cmd::PnpmCommand::Outdated, &args, cli.verbose)?
             }
+            PnpmCommands::Install { packages, args } => pnpm_cmd::run(
+                pnpm_cmd::PnpmCommand::Install { packages },
+                &args,
+                cli.verbose,
+            )?,
             PnpmCommands::Build { args } => {
                 let mut build_args: Vec<String> = vec!["build".into()];
                 build_args.extend(args);
                 let os_args: Vec<OsString> = build_args.into_iter().map(OsString::from).collect();
-                pnpm_cmd::run_passthrough(&os_args, cli.verbose)?;
-            }
-            PnpmCommands::Typecheck { args } => {
-                tsc_cmd::run(&args, cli.verbose)?;
-            }
-            PnpmCommands::Other(args) => {
-                pnpm_cmd::run_passthrough(&args, cli.verbose)?;
+                pnpm_cmd::run_passthrough(&os_args, cli.verbose)?
             }
+            PnpmCommands::Typecheck { args } => tsc_cmd::run(&args, cli.verbose)?,
+            PnpmCommands::Other(args) => pnpm_cmd::run_passthrough(&args, cli.verbose)?,
         },
 
         Commands::Err { command } => {
             let cmd = command.join(" ");
-            runner::run_err(&cmd, cli.verbose)?;
+            runner::run_err(&cmd, cli.verbose)?
         }
 
         Commands::Test { command } => {
             let cmd = command.join(" ");
-            runner::run_test(&cmd, cli.verbose)?;
+            runner::run_test(&cmd, cli.verbose)?
         }
 
         Commands::Json {
@@ -1502,18 +1470,22 @@ fn main() -> Result<()> {
             } else {
                 json_cmd::run(&file, depth, schema, cli.verbose)?;
             }
+            0
         }
 
         Commands::Deps { path } => {
             deps::run(&path, cli.verbose)?;
+            0
         }
 
         Commands::Env { filter, show_all } => {
             env_cmd::run(filter.as_deref(), show_all, cli.verbose)?;
+            0
         }
 
         Commands::Find { args } => {
             find_cmd::run_from_args(&args, cli.verbose)?;
+            0
         }
 
         Commands::Diff { file1, file2 } => {
@@ -1522,6 +1494,7 @@ fn main() -> Result<()> {
             } else {
                 diff_cmd::run_stdin(cli.verbose)?;
             }
+            0
         }
 
         Commands::Log { file } => {
@@ -1530,53 +1503,40 @@ fn main() -> Result<()> {
             } else {
                 log_cmd::run_stdin(cli.verbose)?;
             }
+            0
         }
 
         Commands::Dotnet { command } => match command {
-            DotnetCommands::Build { args } => {
-                dotnet_cmd::run_build(&args, cli.verbose)?;
-            }
-            DotnetCommands::Test { args } => {
-                dotnet_cmd::run_test(&args, cli.verbose)?;
-            }
-            DotnetCommands::Restore { args } => {
-                dotnet_cmd::run_restore(&args, cli.verbose)?;
-            }
-            DotnetCommands::Format { args } => {
-                dotnet_cmd::run_format(&args, cli.verbose)?;
-            }
-            DotnetCommands::Other(args) => {
-                dotnet_cmd::run_passthrough(&args, cli.verbose)?;
-            }
+            DotnetCommands::Build { args } => dotnet_cmd::run_build(&args, cli.verbose)?,
+            DotnetCommands::Test { args } => dotnet_cmd::run_test(&args, cli.verbose)?,
+            DotnetCommands::Restore { args } => dotnet_cmd::run_restore(&args, cli.verbose)?,
+            DotnetCommands::Format { args } => dotnet_cmd::run_format(&args, cli.verbose)?,
+            DotnetCommands::Other(args) => dotnet_cmd::run_passthrough(&args, cli.verbose)?,
         },
 
         Commands::Docker { command } => match command {
             DockerCommands::Ps => {
-                container::run(container::ContainerCmd::DockerPs, &[], cli.verbose)?;
+                container::run(container::ContainerCmd::DockerPs, &[], cli.verbose)?
             }
             DockerCommands::Images => {
-                container::run(container::ContainerCmd::DockerImages, &[], cli.verbose)?;
+                container::run(container::ContainerCmd::DockerImages, &[], cli.verbose)?
             }
             DockerCommands::Logs { container: c } => {
-                container::run(container::ContainerCmd::DockerLogs, &[c], cli.verbose)?;
+                container::run(container::ContainerCmd::DockerLogs, &[c], cli.verbose)?
             }
             DockerCommands::Compose { command: compose } => match compose {
-                ComposeCommands::Ps => {
-                    container::run_compose_ps(cli.verbose)?;
-                }
+                ComposeCommands::Ps => container::run_compose_ps(cli.verbose)?,
                 ComposeCommands::Logs { service } => {
-                    container::run_compose_logs(service.as_deref(), cli.verbose)?;
+                    container::run_compose_logs(service.as_deref(), cli.verbose)?
                 }
                 ComposeCommands::Build { service } => {
-                    container::run_compose_build(service.as_deref(), cli.verbose)?;
+                    container::run_compose_build(service.as_deref(), cli.verbose)?
                 }
                 ComposeCommands::Other(args) => {
-                    container::run_compose_passthrough(&args, cli.verbose)?;
+                    container::run_compose_passthrough(&args, cli.verbose)?
                 }
             },
-            DockerCommands::Other(args) => {
-                container::run_docker_passthrough(&args, cli.verbose)?;
-            }
+            DockerCommands::Other(args) => container::run_docker_passthrough(&args, cli.verbose)?,
         },
 
         Commands::Kubectl { command } => match command {
@@ -1588,7 +1548,7 @@ fn main() -> Result<()> {
                     args.push("-n".to_string());
                     args.push(n);
                 }
-                container::run(container::ContainerCmd::KubectlPods, &args, cli.verbose)?;
+                container::run(container::ContainerCmd::KubectlPods, &args, cli.verbose)?
             }
             KubectlCommands::Services { namespace, all } => {
                 let mut args: Vec<String> = Vec::new();
@@ -1598,7 +1558,7 @@ fn main() -> Result<()> {
                     args.push("-n".to_string());
                     args.push(n);
                 }
-                container::run(container::ContainerCmd::KubectlServices, &args, cli.verbose)?;
+                container::run(container::ContainerCmd::KubectlServices, &args, cli.verbose)?
             }
             KubectlCommands::Logs { pod, container: c } => {
                 let mut args = vec![pod];
@@ -1606,16 +1566,15 @@ fn main() -> Result<()> {
                     args.push("-c".to_string());
                     args.push(cont);
                 }
-                container::run(container::ContainerCmd::KubectlLogs, &args, cli.verbose)?;
-            }
-            KubectlCommands::Other(args) => {
-                container::run_kubectl_passthrough(&args, cli.verbose)?;
+                container::run(container::ContainerCmd::KubectlLogs, &args, cli.verbose)?
             }
+            KubectlCommands::Other(args) => container::run_kubectl_passthrough(&args, cli.verbose)?,
         },
 
         Commands::Summary { command } => {
             let cmd = command.join(" ");
             summary::run(&cmd, cli.verbose)?;
+            0
         }
 
         Commands::Grep {
@@ -1627,18 +1586,16 @@ fn main() -> Result<()> {
             file_type,
             line_numbers: _, // no-op: line numbers always enabled in grep_cmd::run
             extra_args,
-        } => {
-            grep_cmd::run(
-                &pattern,
-                &path,
-                max_len,
-                max,
-                context_only,
-                file_type.as_deref(),
-                &extra_args,
-                cli.verbose,
-            )?;
-        }
+        } => grep_cmd::run(
+            &pattern,
+            &path,
+            max_len,
+            max,
+            context_only,
+            file_type.as_deref(),
+            &extra_args,
+            cli.verbose,
+        )?,
 
         Commands::Init {
             global,
@@ -1698,11 +1655,12 @@ fn main() -> Result<()> {
                     cli.verbose,
                 )?;
             }
+            0
         }
 
         Commands::Wget { url, output, args } => {
             if output.as_deref() == Some("-") {
-                wget_cmd::run_stdout(&url, &args, cli.verbose)?;
+                wget_cmd::run_stdout(&url, &args, cli.verbose)?
             } else {
                 // Pass -O <file> through to wget via args
                 let mut all_args = Vec::new();
@@ -1711,13 +1669,11 @@ fn main() -> Result<()> {
                     all_args.push(out_file.clone());
                 }
                 all_args.extend(args);
-                wget_cmd::run(&url, &all_args, cli.verbose)?;
+                wget_cmd::run(&url, &all_args, cli.verbose)?
             }
         }
 
-        Commands::Wc { args } => {
-            wc_cmd::run(&args, cli.verbose)?;
-        }
+        Commands::Wc { args } => wc_cmd::run(&args, cli.verbose)?,
 
         Commands::Gain {
             project, // added
@@ -1746,6 +1702,7 @@ fn main() -> Result<()> {
                 failures,
                 cli.verbose,
             )?;
+            0
         }
 
         Commands::CcEconomics {
@@ -1756,6 +1713,7 @@ fn main() -> Result<()> {
             format,
         } => {
             analytics::cc_economics::run(daily, weekly, monthly, all, &format, cli.verbose)?;
+            0
         }
 
         Commands::Config { create } => {
@@ -1765,107 +1723,84 @@ fn main() -> Result<()> {
             } else {
                 core::config::show_config()?;
             }
+            0
         }
 
         Commands::Vitest { command } => match command {
             VitestCommands::Run { args } => {
-                vitest_cmd::run(vitest_cmd::VitestCommand::Run, &args, cli.verbose)?;
+                vitest_cmd::run(vitest_cmd::VitestCommand::Run, &args, cli.verbose)?
             }
         },
 
         Commands::Prisma { command } => match command {
             PrismaCommands::Generate { args } => {
-                prisma_cmd::run(prisma_cmd::PrismaCommand::Generate, &args, cli.verbose)?;
+                prisma_cmd::run(prisma_cmd::PrismaCommand::Generate, &args, cli.verbose)?
             }
             PrismaCommands::Migrate { command } => match command {
-                PrismaMigrateCommands::Dev { name, args } => {
-                    prisma_cmd::run(
-                        prisma_cmd::PrismaCommand::Migrate {
-                            subcommand: prisma_cmd::MigrateSubcommand::Dev { name },
-                        },
-                        &args,
-                        cli.verbose,
-                    )?;
-                }
-                PrismaMigrateCommands::Status { args } => {
-                    prisma_cmd::run(
-                        prisma_cmd::PrismaCommand::Migrate {
-                            subcommand: prisma_cmd::MigrateSubcommand::Status,
-                        },
-                        &args,
-                        cli.verbose,
-                    )?;
-                }
-                PrismaMigrateCommands::Deploy { args } => {
-                    prisma_cmd::run(
-                        prisma_cmd::PrismaCommand::Migrate {
-                            subcommand: prisma_cmd::MigrateSubcommand::Deploy,
-                        },
-                        &args,
-                        cli.verbose,
-                    )?;
-                }
+                PrismaMigrateCommands::Dev { name, args } => prisma_cmd::run(
+                    prisma_cmd::PrismaCommand::Migrate {
+                        subcommand: prisma_cmd::MigrateSubcommand::Dev { name },
+                    },
+                    &args,
+                    cli.verbose,
+                )?,
+                PrismaMigrateCommands::Status { args } => prisma_cmd::run(
+                    prisma_cmd::PrismaCommand::Migrate {
+                        subcommand: prisma_cmd::MigrateSubcommand::Status,
+                    },
+                    &args,
+                    cli.verbose,
+                )?,
+                PrismaMigrateCommands::Deploy { args } => prisma_cmd::run(
+                    prisma_cmd::PrismaCommand::Migrate {
+                        subcommand: prisma_cmd::MigrateSubcommand::Deploy,
+                    },
+                    &args,
+                    cli.verbose,
+                )?,
             },
             PrismaCommands::DbPush { args } => {
-                prisma_cmd::run(prisma_cmd::PrismaCommand::DbPush, &args, cli.verbose)?;
+                prisma_cmd::run(prisma_cmd::PrismaCommand::DbPush, &args, cli.verbose)?
             }
         },
 
-        Commands::Tsc { args } => {
-            tsc_cmd::run(&args, cli.verbose)?;
-        }
+        Commands::Tsc { args } => tsc_cmd::run(&args, cli.verbose)?,
 
-        Commands::Next { args } => {
-            next_cmd::run(&args, cli.verbose)?;
-        }
+        Commands::Next { args } => next_cmd::run(&args, cli.verbose)?,
 
-        Commands::Lint { args } => {
-            lint_cmd::run(&args, cli.verbose)?;
-        }
+        Commands::Lint { args } => lint_cmd::run(&args, cli.verbose)?,
 
-        Commands::Prettier { args } => {
-            prettier_cmd::run(&args, cli.verbose)?;
-        }
+        Commands::Prettier { args } => prettier_cmd::run(&args, cli.verbose)?,
 
-        Commands::Format { args } => {
-            format_cmd::run(&args, cli.verbose)?;
-        }
+        Commands::Format { args } => format_cmd::run(&args, cli.verbose)?,
 
-        Commands::Playwright { args } => {
-            playwright_cmd::run(&args, cli.verbose)?;
-        }
+        Commands::Playwright { args } => playwright_cmd::run(&args, cli.verbose)?,
 
         Commands::Cargo { command } => match command {
             CargoCommands::Build { args } => {
-                cargo_cmd::run(cargo_cmd::CargoCommand::Build, &args, cli.verbose)?;
+                cargo_cmd::run(cargo_cmd::CargoCommand::Build, &args, cli.verbose)?
             }
             CargoCommands::Test { args } => {
-                cargo_cmd::run(cargo_cmd::CargoCommand::Test, &args, cli.verbose)?;
+                cargo_cmd::run(cargo_cmd::CargoCommand::Test, &args, cli.verbose)?
             }
             CargoCommands::Clippy { args } => {
-                cargo_cmd::run(cargo_cmd::CargoCommand::Clippy, &args, cli.verbose)?;
+                cargo_cmd::run(cargo_cmd::CargoCommand::Clippy, &args, cli.verbose)?
             }
             CargoCommands::Check { args } => {
-                cargo_cmd::run(cargo_cmd::CargoCommand::Check, &args, cli.verbose)?;
+                cargo_cmd::run(cargo_cmd::CargoCommand::Check, &args, cli.verbose)?
             }
             CargoCommands::Install { args } => {
-                cargo_cmd::run(cargo_cmd::CargoCommand::Install, &args, cli.verbose)?;
+                cargo_cmd::run(cargo_cmd::CargoCommand::Install, &args, cli.verbose)?
             }
             CargoCommands::Nextest { args } => {
-                cargo_cmd::run(cargo_cmd::CargoCommand::Nextest, &args, cli.verbose)?;
-            }
-            CargoCommands::Other(args) => {
-                cargo_cmd::run_passthrough(&args, cli.verbose)?;
+                cargo_cmd::run(cargo_cmd::CargoCommand::Nextest, &args, cli.verbose)?
             }
+            CargoCommands::Other(args) => cargo_cmd::run_passthrough(&args, cli.verbose)?,
         },
 
-        Commands::Npm { args } => {
-            npm_cmd::run(&args, cli.verbose, cli.skip_env)?;
-        }
+        Commands::Npm { args } => npm_cmd::run(&args, cli.verbose, cli.skip_env)?,
 
-        Commands::Curl { args } => {
-            curl_cmd::run(&args, cli.verbose)?;
-        }
+        Commands::Curl { args } => curl_cmd::run(&args, cli.verbose)?,
 
         Commands::Discover {
             project,
@@ -1875,10 +1810,12 @@ fn main() -> Result<()> {
             format,
         } => {
             discover::run(project.as_deref(), all, since, limit, &format, cli.verbose)?;
+            0
         }
 
         Commands::Session {} => {
             analytics::session_cmd::run(cli.verbose)?;
+            0
         }
 
         Commands::Learn {
@@ -1899,6 +1836,7 @@ fn main() -> Result<()> {
                 min_confidence,
                 min_occurrences,
             )?;
+            0
         }
 
         Commands::Npx { args } => {
@@ -1908,31 +1846,23 @@ fn main() -> Result<()> {
 
             // Intelligent routing: delegate to specialized filters
             match args[0].as_str() {
-                "tsc" | "typescript" => {
-                    tsc_cmd::run(&args[1..], cli.verbose)?;
-                }
-                "eslint" => {
-                    lint_cmd::run(&args[1..], cli.verbose)?;
-                }
+                "tsc" | "typescript" => tsc_cmd::run(&args[1..], cli.verbose)?,
+                "eslint" => lint_cmd::run(&args[1..], cli.verbose)?,
                 "prisma" => {
                     // Route to prisma_cmd based on subcommand
                     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,
-                                    cli.verbose,
-                                )?;
-                            }
-                            "db" if args.len() > 2 && args[2] == "push" => {
-                                prisma_cmd::run(
-                                    prisma_cmd::PrismaCommand::DbPush,
-                                    &args[3..],
-                                    cli.verbose,
-                                )?;
-                            }
+                            "generate" => prisma_cmd::run(
+                                prisma_cmd::PrismaCommand::Generate,
+                                &prisma_args,
+                                cli.verbose,
+                            )?,
+                            "db" if args.len() > 2 && args[2] == "push" => prisma_cmd::run(
+                                prisma_cmd::PrismaCommand::DbPush,
+                                &args[3..],
+                                cli.verbose,
+                            )?,
                             _ => {
                                 // Passthrough other prisma subcommands
                                 let timer = core::tracking::TimedExecution::start();
@@ -1946,9 +1876,7 @@ fn main() -> Result<()> {
                                     &format!("npx {}", args_str),
                                     &format!("rtk npx {} (passthrough)", args_str),
                                 );
-                                if !status.success() {
-                                    std::process::exit(status.code().unwrap_or(1));
-                                }
+                                core::utils::exit_code_from_status(&status, "npx prisma")
                             }
                         }
                     } else {
@@ -1958,114 +1886,69 @@ fn main() -> Result<()> {
                             .status()
                             .context("Failed to run npx prisma")?;
                         timer.track_passthrough("npx prisma", "rtk npx prisma (passthrough)");
-                        if !status.success() {
-                            std::process::exit(status.code().unwrap_or(1));
-                        }
+                        core::utils::exit_code_from_status(&status, "npx prisma")
                     }
                 }
-                "next" => {
-                    next_cmd::run(&args[1..], cli.verbose)?;
-                }
-                "prettier" => {
-                    prettier_cmd::run(&args[1..], cli.verbose)?;
-                }
-                "playwright" => {
-                    playwright_cmd::run(&args[1..], cli.verbose)?;
-                }
+                "next" => next_cmd::run(&args[1..], cli.verbose)?,
+                "prettier" => prettier_cmd::run(&args[1..], cli.verbose)?,
+                "playwright" => playwright_cmd::run(&args[1..], cli.verbose)?,
                 _ => {
                     // Generic passthrough with npm boilerplate filter
-                    npm_cmd::run(&args, cli.verbose, cli.skip_env)?;
+                    npm_cmd::run(&args, cli.verbose, cli.skip_env)?
                 }
             }
         }
 
-        Commands::Ruff { args } => {
-            ruff_cmd::run(&args, cli.verbose)?;
-        }
+        Commands::Ruff { args } => ruff_cmd::run(&args, cli.verbose)?,
 
-        Commands::Pytest { args } => {
-            pytest_cmd::run(&args, cli.verbose)?;
-        }
+        Commands::Pytest { args } => pytest_cmd::run(&args, cli.verbose)?,
 
-        Commands::Mypy { args } => {
-            mypy_cmd::run(&args, cli.verbose)?;
-        }
+        Commands::Mypy { args } => mypy_cmd::run(&args, cli.verbose)?,
 
-        Commands::Rake { args } => {
-            rake_cmd::run(&args, cli.verbose)?;
-        }
+        Commands::Rake { args } => rake_cmd::run(&args, cli.verbose)?,
 
-        Commands::Rubocop { args } => {
-            rubocop_cmd::run(&args, cli.verbose)?;
-        }
+        Commands::Rubocop { args } => rubocop_cmd::run(&args, cli.verbose)?,
 
-        Commands::Rspec { args } => {
-            rspec_cmd::run(&args, cli.verbose)?;
-        }
+        Commands::Rspec { args } => rspec_cmd::run(&args, cli.verbose)?,
 
-        Commands::Pip { args } => {
-            pip_cmd::run(&args, cli.verbose)?;
-        }
+        Commands::Pip { args } => pip_cmd::run(&args, cli.verbose)?,
 
         Commands::Go { command } => match command {
-            GoCommands::Test { args } => {
-                go_cmd::run_test(&args, cli.verbose)?;
-            }
-            GoCommands::Build { args } => {
-                go_cmd::run_build(&args, cli.verbose)?;
-            }
-            GoCommands::Vet { args } => {
-                go_cmd::run_vet(&args, cli.verbose)?;
-            }
-            GoCommands::Other(args) => {
-                go_cmd::run_other(&args, cli.verbose)?;
-            }
+            GoCommands::Test { args } => go_cmd::run_test(&args, cli.verbose)?,
+            GoCommands::Build { args } => go_cmd::run_build(&args, cli.verbose)?,
+            GoCommands::Vet { args } => go_cmd::run_vet(&args, cli.verbose)?,
+            GoCommands::Other(args) => go_cmd::run_other(&args, cli.verbose)?,
         },
 
         Commands::Gt { command } => match command {
-            GtCommands::Log { args } => {
-                gt_cmd::run_log(&args, cli.verbose)?;
-            }
-            GtCommands::Submit { args } => {
-                gt_cmd::run_submit(&args, cli.verbose)?;
-            }
-            GtCommands::Sync { args } => {
-                gt_cmd::run_sync(&args, cli.verbose)?;
-            }
-            GtCommands::Restack { args } => {
-                gt_cmd::run_restack(&args, cli.verbose)?;
-            }
-            GtCommands::Create { args } => {
-                gt_cmd::run_create(&args, cli.verbose)?;
-            }
-            GtCommands::Branch { args } => {
-                gt_cmd::run_branch(&args, cli.verbose)?;
-            }
-            GtCommands::Other(args) => {
-                gt_cmd::run_other(&args, cli.verbose)?;
-            }
+            GtCommands::Log { args } => gt_cmd::run_log(&args, cli.verbose)?,
+            GtCommands::Submit { args } => gt_cmd::run_submit(&args, cli.verbose)?,
+            GtCommands::Sync { args } => gt_cmd::run_sync(&args, cli.verbose)?,
+            GtCommands::Restack { args } => gt_cmd::run_restack(&args, cli.verbose)?,
+            GtCommands::Create { args } => gt_cmd::run_create(&args, cli.verbose)?,
+            GtCommands::Branch { args } => gt_cmd::run_branch(&args, cli.verbose)?,
+            GtCommands::Other(args) => gt_cmd::run_other(&args, cli.verbose)?,
         },
 
-        Commands::GolangciLint { args } => {
-            golangci_cmd::run(&args, cli.verbose)?;
-        }
+        Commands::GolangciLint { args } => golangci_cmd::run(&args, cli.verbose)?,
 
         Commands::HookAudit { since } => {
             hooks::hook_audit_cmd::run(since, cli.verbose)?;
+            0
         }
 
-        Commands::Hook { command } => match command {
-            HookCommands::Gemini => {
-                hooks::hook_cmd::run_gemini()?;
-            }
-            HookCommands::Copilot => {
-                hooks::hook_cmd::run_copilot()?;
+        Commands::Hook { command } => {
+            match command {
+                HookCommands::Gemini => hooks::hook_cmd::run_gemini()?,
+                HookCommands::Copilot => hooks::hook_cmd::run_copilot()?,
             }
-        },
+            0
+        }
 
         Commands::Rewrite { args } => {
             let cmd = args.join(" ");
             hooks::rewrite_cmd::run(&cmd)?;
+            0
         }
 
         Commands::Proxy { args } => {
@@ -2183,18 +2066,17 @@ fn main() -> Result<()> {
                 &full_output,
             );
 
-            // Exit with same code as child process
-            if !status.success() {
-                std::process::exit(status.code().unwrap_or(1));
-            }
+            core::utils::exit_code_from_status(&status, &cmd_name)
         }
 
         Commands::Trust { list } => {
             hooks::trust::run_trust(list)?;
+            0
         }
 
         Commands::Untrust => {
             hooks::trust::run_untrust()?;
+            0
         }
 
         Commands::Verify {
@@ -2209,10 +2091,11 @@ fn main() -> Result<()> {
                 hooks::integrity::run_verify(cli.verbose)?;
                 hooks::verify_cmd::run(None, require_all)?;
             }
+            0
         }
-    }
+    };
 
-    Ok(())
+    Ok(code)
 }
 
 /// Returns true for commands that are invoked via the hook pipeline
diff --git a/src/parser/README.md b/src/parser/README.md
index ddac959db7..af5664c082 100644
--- a/src/parser/README.md
+++ b/src/parser/README.md
@@ -10,8 +10,6 @@ The parser infrastructure provides a unified, three-tier parsing system for tool
 - **Tier 2 (Degraded)**: Partial parsing with warnings (fallback regex)
 - **Tier 3 (Passthrough)**: Raw output truncation with error markers
 
-This ensures RTK **never returns false data silently** while maintaining maximum token efficiency.
-
 ## Architecture
 
 ```
diff --git a/src/parser/error.rs b/src/parser/error.rs
deleted file mode 100644
index e3e48f073e..0000000000
--- a/src/parser/error.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-/// Parser error types for structured output parsing
-use thiserror::Error;
-
-#[derive(Error, Debug)]
-#[allow(dead_code)]
-pub enum ParseError {
-    #[error("JSON parse failed at line {line}, column {col}: {msg}")]
-    JsonError {
-        line: usize,
-        col: usize,
-        msg: String,
-    },
-
-    #[error("Pattern mismatch: expected {expected}")]
-    PatternMismatch { expected: &'static str },
-
-    #[error("Partial parse: got {found}, missing fields: {missing:?}")]
-    PartialParse {
-        found: String,
-        missing: Vec<&'static str>,
-    },
-
-    #[error("Invalid format: {0}")]
-    InvalidFormat(String),
-
-    #[error("Missing required field: {0}")]
-    MissingField(&'static str),
-
-    #[error("Version mismatch: got {got}, expected {expected}")]
-    VersionMismatch { got: String, expected: String },
-
-    #[error("Empty output")]
-    EmptyOutput,
-
-    #[error(transparent)]
-    Other(#[from] anyhow::Error),
-}
-
-impl From<serde_json::Error> for ParseError {
-    fn from(err: serde_json::Error) -> Self {
-        ParseError::JsonError {
-            line: err.line(),
-            col: err.column(),
-            msg: err.to_string(),
-        }
-    }
-}
diff --git a/src/parser/formatter.rs b/src/parser/formatter.rs
index b41280e26d..6fc9022ef1 100644
--- a/src/parser/formatter.rs
+++ b/src/parser/formatter.rs
@@ -110,84 +110,6 @@ impl TokenFormatter for TestResult {
     }
 }
 
-impl TokenFormatter for LintResult {
-    fn format_compact(&self) -> String {
-        let mut lines = vec![format!(
-            "Errors: {} | Warnings: {} | Files: {}",
-            self.errors, self.warnings, self.files_with_issues
-        )];
-
-        if !self.issues.is_empty() {
-            // Group by rule_id
-            let mut by_rule: std::collections::HashMap<String, Vec<&LintIssue>> =
-                std::collections::HashMap::new();
-            for issue in &self.issues {
-                by_rule
-                    .entry(issue.rule_id.clone())
-                    .or_default()
-                    .push(issue);
-            }
-
-            let mut rules: Vec<_> = by_rule.iter().collect();
-            rules.sort_by_key(|(_, issues)| std::cmp::Reverse(issues.len()));
-
-            lines.push(String::new());
-            for (rule, issues) in rules.iter().take(5) {
-                lines.push(format!("{}: {} occurrences", rule, issues.len()));
-                for issue in issues.iter().take(2) {
-                    lines.push(format!("  {}:{}", issue.file_path, issue.line));
-                }
-            }
-
-            if by_rule.len() > 5 {
-                lines.push(format!("\n... +{} more rule violations", by_rule.len() - 5));
-            }
-        }
-
-        lines.join("\n")
-    }
-
-    fn format_verbose(&self) -> String {
-        let mut lines = vec![format!(
-            "Total issues: {} ({} errors, {} warnings) in {} files",
-            self.total_issues, self.errors, self.warnings, self.files_with_issues
-        )];
-
-        if !self.issues.is_empty() {
-            lines.push("\nIssues:".to_string());
-            for issue in self.issues.iter().take(20) {
-                let severity_symbol = match issue.severity {
-                    LintSeverity::Error => "[x]",
-                    LintSeverity::Warning => "[!]",
-                    LintSeverity::Info => "[info]",
-                };
-                lines.push(format!(
-                    "{} {}:{}:{} [{}] {}",
-                    severity_symbol,
-                    issue.file_path,
-                    issue.line,
-                    issue.column,
-                    issue.rule_id,
-                    issue.message
-                ));
-            }
-
-            if self.issues.len() > 20 {
-                lines.push(format!("\n... +{} more issues", self.issues.len() - 20));
-            }
-        }
-
-        lines.join("\n")
-    }
-
-    fn format_ultra(&self) -> String {
-        format!(
-            "[x]{} [!]{} {}F",
-            self.errors, self.warnings, self.files_with_issues
-        )
-    }
-}
-
 impl TokenFormatter for DependencyState {
     fn format_compact(&self) -> String {
         if self.outdated_count == 0 {
@@ -251,86 +173,6 @@ impl TokenFormatter for DependencyState {
     }
 }
 
-impl TokenFormatter for BuildOutput {
-    fn format_compact(&self) -> String {
-        let status = if self.success { "[ok]" } else { "[x]" };
-        let mut lines = vec![format!(
-            "{} Build: {} errors, {} warnings",
-            status, self.errors, self.warnings
-        )];
-
-        if !self.bundles.is_empty() {
-            let total_size: u64 = self.bundles.iter().map(|b| b.size_bytes).sum();
-            lines.push(format!(
-                "Bundles: {} ({:.1} KB)",
-                self.bundles.len(),
-                total_size as f64 / 1024.0
-            ));
-        }
-
-        if !self.routes.is_empty() {
-            lines.push(format!("Routes: {}", self.routes.len()));
-        }
-
-        if let Some(duration) = self.duration_ms {
-            lines.push(format!("Time: {}ms", duration));
-        }
-
-        lines.join("\n")
-    }
-
-    fn format_verbose(&self) -> String {
-        let status = if self.success { "Success" } else { "Failed" };
-        let mut lines = vec![format!(
-            "Build {}: {} errors, {} warnings",
-            status, self.errors, self.warnings
-        )];
-
-        if !self.bundles.is_empty() {
-            lines.push("\nBundles:".to_string());
-            for bundle in &self.bundles {
-                let gzip_info = bundle
-                    .gzip_size_bytes
-                    .map(|gz| format!(" (gzip: {:.1} KB)", gz as f64 / 1024.0))
-                    .unwrap_or_default();
-                lines.push(format!(
-                    "  {}: {:.1} KB{}",
-                    bundle.name,
-                    bundle.size_bytes as f64 / 1024.0,
-                    gzip_info
-                ));
-            }
-        }
-
-        if !self.routes.is_empty() {
-            lines.push("\nRoutes:".to_string());
-            for route in self.routes.iter().take(10) {
-                lines.push(format!("  {}: {:.1} KB", route.path, route.size_kb));
-            }
-            if self.routes.len() > 10 {
-                lines.push(format!("  ... +{} more routes", self.routes.len() - 10));
-            }
-        }
-
-        if let Some(duration) = self.duration_ms {
-            lines.push(format!("\nDuration: {}ms", duration));
-        }
-
-        lines.join("\n")
-    }
-
-    fn format_ultra(&self) -> String {
-        let status = if self.success { "[ok]" } else { "[x]" };
-        format!(
-            "{} [x]{} [!]{} ({}ms)",
-            status,
-            self.errors,
-            self.warnings,
-            self.duration_ms.unwrap_or(0)
-        )
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/src/parser/mod.rs b/src/parser/mod.rs
index 88ff5ddb97..864afb811a 100644
--- a/src/parser/mod.rs
+++ b/src/parser/mod.rs
@@ -7,7 +7,6 @@
 //!
 //! The three-tier system ensures RTK never returns false data silently.
 
-pub mod error;
 pub mod formatter;
 pub mod types;
 
diff --git a/src/parser/types.rs b/src/parser/types.rs
index 4fa6b804fc..0f095fcbfe 100644
--- a/src/parser/types.rs
+++ b/src/parser/types.rs
@@ -21,37 +21,6 @@ pub struct TestFailure {
     pub stack_trace: Option<String>,
 }
 
-/// Linting result (eslint, biome, tsc, etc.)
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[allow(dead_code)]
-pub struct LintResult {
-    pub total_files: usize,
-    pub files_with_issues: usize,
-    pub total_issues: usize,
-    pub errors: usize,
-    pub warnings: usize,
-    pub issues: Vec<LintIssue>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[allow(dead_code)]
-pub struct LintIssue {
-    pub file_path: String,
-    pub line: usize,
-    pub column: usize,
-    pub severity: LintSeverity,
-    pub rule_id: String,
-    pub message: String,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-#[allow(dead_code)]
-pub enum LintSeverity {
-    Error,
-    Warning,
-    Info,
-}
-
 /// Dependency state (pnpm, npm, cargo, etc.)
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct DependencyState {
@@ -68,61 +37,3 @@ pub struct Dependency {
     pub wanted_version: Option<String>,
     pub dev_dependency: bool,
 }
-
-/// Build output (next, webpack, vite, cargo, etc.)
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[allow(dead_code)]
-pub struct BuildOutput {
-    pub success: bool,
-    pub duration_ms: Option<u64>,
-    pub warnings: usize,
-    pub errors: usize,
-    pub bundles: Vec<BundleInfo>,
-    pub routes: Vec<RouteInfo>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[allow(dead_code)]
-pub struct BundleInfo {
-    pub name: String,
-    pub size_bytes: u64,
-    pub gzip_size_bytes: Option<u64>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[allow(dead_code)]
-pub struct RouteInfo {
-    pub path: String,
-    pub size_kb: f64,
-    pub first_load_js_kb: Option<f64>,
-}
-
-/// Git operation result
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[allow(dead_code)]
-pub struct GitResult {
-    pub operation: String,
-    pub files_changed: usize,
-    pub insertions: usize,
-    pub deletions: usize,
-    pub commits: Vec<GitCommit>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[allow(dead_code)]
-pub struct GitCommit {
-    pub hash: String,
-    pub author: String,
-    pub message: String,
-    pub timestamp: Option<String>,
-}
-
-/// Generic command output (for tools without specific types)
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[allow(dead_code)]
-pub struct GenericOutput {
-    pub exit_code: i32,
-    pub stdout: String,
-    pub stderr: String,
-    pub summary: Option<String>,
-}